fastfont.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/font.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/uncompressedvideopayload.h>
#include <promeki/buffer.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class FastFont : public Font {
        public:
                using UPtr = UniquePtr<FastFont>;
 
                struct DrawStyle {
                                Color foreground; 
                                Color background; 
                                bool  bold = false;
                                bool  italic = false;
                                bool  underline = false;
                };
 
                FastFont(const PaintEngine &pe);
 
                ~FastFont() override;
 
                bool drawText(const String &text, int x, int y) override;
                int  measureText(const String &text) override;
                int  lineHeight() override;
                int  ascender() override;
                int  descender() override;
 
                bool drawText(const String &text, int x, int y, const DrawStyle &style);
 
                int measureText(const String &text, const DrawStyle &style);
 
        protected:
                void onStateChanged() override;
                void onColorChanged() override;
 
        private:
                struct GlyphKey {
                                uint32_t codepoint = 0;
                                uint32_t fgRGBA = 0;
                                uint32_t bgRGBA = 0;
                                uint8_t  styleFlags = 0; 
                                bool     operator<(const GlyphKey &o) const {
                                        if (codepoint != o.codepoint) return codepoint < o.codepoint;
                                        if (fgRGBA != o.fgRGBA) return fgRGBA < o.fgRGBA;
                                        if (bgRGBA != o.bgRGBA) return bgRGBA < o.bgRGBA;
                                        return styleFlags < o.styleFlags;
                                }
                                bool operator==(const GlyphKey &o) const {
                                        return codepoint == o.codepoint && fgRGBA == o.fgRGBA
                                                && bgRGBA == o.bgRGBA && styleFlags == o.styleFlags;
                                }
                };
 
                struct CachedGlyph {
                                UncompressedVideoPayload::Ptr payload; 
                                int advanceX = 0;                      
                                int faceIndex = 0;
                };
 
                struct LoadedFace {
                                void  *face = nullptr;
                                Buffer data;
                                String path;
                };
 
                bool               ensureFontLoaded();
                bool               loadFace(const String &path, LoadedFace &out);
                const CachedGlyph *getGlyph(uint32_t codepoint, const GlyphKey &key, const Color &fg, const Color &bg);
                void               invalidateGlyphs();
                void               invalidateFont();
                void               invalidateAll();
 
                GlyphKey makeKey(uint32_t codepoint, const DrawStyle &style, Color &outFg, Color &outBg) const;
 
                static uint32_t colorKey(const Color &c);
 
                int resolveFaceIndex(uint32_t codepoint) const;
 
                void                      *_ftLibrary = nullptr;
                List<LoadedFace>           _ftFaces; 
                int                        _ascender = 0;
                int                        _descender = 0;
                int                        _lineHeight = 0;
                int _underlineThickness = 1;
                int _underlinePosition = 0;
                int                        _alignX = 1;
                int                        _alignY = 1;
                Map<GlyphKey, CachedGlyph> _glyphCache;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV