FreeType.h

Go to the documentation of this file.

#pragma once
 
#include "Font.h"
#include "Drawables.h"
#include "BitmapFont.h"
#include "../Geometry/Point.h"
#include "../Containers/Collection.h"
 
namespace Gorgon { namespace Resource { class Font; } }
 
 
namespace Gorgon { namespace Graphics {
    
    struct ftlib;
    
    class FreeType : public GlyphRenderer, public BasicFont { 
        friend class ::Gorgon::Resource::Font;
        
        class GlyphDescriptor {
            using Drawable = RectangularDrawable;
            struct Images {
                Images(Drawable *regular = nullptr, Drawable *withoffset = nullptr) :
                    regular(regular), withoffset(withoffset) {}
                Drawable *regular;
                Drawable *withoffset;
            };
        public:
            GlyphDescriptor() { }
            
            GlyphDescriptor(Images images, float advance, Geometry::Point offset, unsigned int ftind) :
                images(images), advance(advance), offset(offset), ftindex(ftind) { }
            
            Images images;
            float advance = 0;
            Geometry::Point offset = {0, 0};
            unsigned int ftindex = 0;
        };
        
    public:
        FreeType();
        
        FreeType(const std::string &filename) : FreeType() {
            LoadFile(filename);
        }
        
        FreeType(const std::string &filename, int size, bool loadascii = true) : FreeType() {
            LoadFile(filename, size, loadascii);
        }
        
        FreeType(const FreeType &) = delete;
        
        FreeType &operator =(const FreeType &) = delete;
        
        virtual ~FreeType();
        
        bool LoadFile(const std::string &filename);
        
        bool LoadFile(const std::string &filename, int size, bool loadascii = true);
        
        bool Load(const std::vector<Byte> &data);
        
        bool Load(const Byte *data, long datasize);
        
        bool Assume(std::vector<Byte> &data);
        
        bool Assume(const Byte *data, long datasize);
        
        bool LoadMetrics(int size);
        
        bool LoadGlyphs(GlyphRange range, bool prepare = true);
        
        bool LoadGlyphs(Glyph start, Glyph end, bool prepare = true) { return LoadGlyphs(GlyphRange{start, end}, prepare); }
        
        bool LoadGlyphs(const std::vector<GlyphRange> &ranges, bool prepare = true);
        
        bool IsScalable() const;
        
        std::vector<int> GetPresetSizes() const;
        
        bool IsFileLoaded() const;
        
        bool IsReady() const override;
        
        bool IsSymbolOnly() const {
            return issymbol;
        }
        
        bool HasKerning() const {
            return haskerning;
        }
        
        void DisableAntiAliasing() {
            aa = false;
        }
        
        void EnableAntiAliasing() {
            aa = true;
        }
        
        std::string GetFamilyName() const;
        
        std::string GetStyleName() const;
        
        void Clear();
        
        BitmapFont CopyToBitmap(bool prepare = true) const;
        
        
        BitmapFont MoveOutBitmap(bool unpack = false, bool prepare = true);
        
        void Pack(bool keeppacked = true, bool tight = true, float extrasize = 0.2) {
            this->keeppacked = keeppacked;
            this->tightpack  = tight;
            
            pack(extrasize);
        }
        
        void StopPacking() {
            keeppacked = false;
        }
        
        virtual void Render(Glyph chr, TextureTarget &target, Geometry::Pointf location, RGBAf color) const override;
        
        Drawable *GetCharacter(Glyph chr);
 
        using BasicFont::GetSize;
        
        virtual Geometry::Size GetSize(Glyph chr) const override;
        
        virtual float GetCursorAdvance(Glyph g) const override;
 
        virtual bool Exists(Glyph g) const override;
 
        bool Available(Glyph g) const;
 
        virtual bool IsASCII() const override { return isascii; }
 
        virtual bool IsFixedWidth() const override { return isfixedw; }
        
        virtual Geometry::Pointf KerningDistance(Glyph chr1, Glyph chr2) const override;
        
        virtual int GetEMSize() const override { return Exists(0x2004) ? GetSize(0x2004).Width : GetHeight(); }
        
        virtual int GetMaxWidth() const override { return maxadvance; }
 
        virtual int GetHeight() const override { return height; }
 
        virtual int GetDigitWidth() const override { return GetSize("0").Width; }
        
        virtual float GetBaseLine() const override { return baseline; }
        
        virtual float GetLineGap() const override { return linegap; }
 
        virtual float GetLineThickness() const override { return linethickness; }
 
        virtual int GetUnderlineOffset() const override { return underlinepos; }
        
        virtual bool NeedsPrepare() const override { return true; }
        
        virtual void Prepare(const std::string &text) const override;
        
        void Discard();
 
 
        virtual std::pair<int, int> GetLetterHeight(bool asciionly = false) const override;
 
    private:
        void pack(float extrasize = 0.2) const;
        
        bool loadglyphs(GlyphRange range, bool prepare) const;
        
        bool finalizeload();
 
        bool savedata(std::ostream &stream);
        
        void setatlassize(unsigned size) const;
        
        // automatic loading requires these functions to be mutable
        mutable ftlib *lib;
        
        mutable std::map<Glyph, GlyphDescriptor> glyphmap ;
        
        //this exists to speed up loading glyphs that are already read.
        mutable std::map<unsigned int, Glyph>    ft_to_map;
        
        mutable Containers::Collection<RectangularDrawable> destroylist;
        
        //these are here for saving the font
        std::string filename;
        
        const std::vector<Byte> *vecdata = nullptr;
        const Byte *data = nullptr;
        long datasize = 0;
        
        //stores the glyph atlas. could be empty if packing is not used
        mutable Texture atlas;
        //stores atlas pixel data
        mutable Containers::Image atlasdata;
        
        //stores which pixels are used within the atlas
        mutable std::vector<bool> used;
        
        //stores first free pixel location
        mutable int rowsused = 0;
        
        bool keeppacked = true;
        bool tightpack  = true;
 
 
        int isfixedw = false;
        
        int maxwidth = 0;
        
        int maxadvance = 0;
        
        int height = 0;
        
        float baseline = 0;
        
        bool aa = true;
 
        mutable int digw = 0;
 
        bool isascii = false;
        
        bool issymbol = false;
 
        float linethickness = 1;
 
        int underlinepos = 0;
        
        bool haskerning = false;
        
        float linegap = 0;
 
        float size = 0;
    };
    
} }