BitmapFont.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <Gorgon/Utils/Assert.h>
#include <map>
 
#include "Font.h"
#include "Drawables.h"
#include "Bitmap.h"
#include "../Containers/Collection.h"
 
namespace Gorgon { namespace Resource { class Font; } }
 
 
namespace Gorgon { namespace Graphics {
 
 
    class BitmapFont : public GlyphRenderer, public BasicFont {
        friend class Resource::Font;
    public:
        class GlyphDescriptor {
        public:
            GlyphDescriptor() { }
            
            GlyphDescriptor(const RectangularDrawable &image, Geometry::Pointf offset, float advance) : 
            image(&image), offset(offset), advance(advance) { }
            
            GlyphDescriptor(int index, Geometry::Pointf offset, float advance) : 
            index(index), offset(offset), advance(advance) { }
            
            union {
                const RectangularDrawable *image = nullptr;
                int index; //for use in resource loading
            };
            
            Geometry::Pointf offset;//update offset to be x and y as well as a seperate advance field
            float advance;
        };
        
        enum ImportNamingTemplate {
            Automatic,
            Alpha,
            Decimal,
            Hexadecimal
        };
        
        enum DeleteConstants {
            None,
            Owned,
            All
        };
        
        
        struct ImportOptions {
            ImportOptions(
                bool pack = true,
                float baseline = -1,
                bool trim = true,
                YesNoAuto converttoalpha = YesNoAuto::Yes,
                bool prepare = true,
                bool estimatebaseline = false,
                bool automatickerning = true,
                int spacing = -1
            ) :
                pack(pack),
                baseline(baseline),
                trim(trim),
                converttoalpha(converttoalpha),
                prepare(prepare),
                estimatebaseline(estimatebaseline),
                automatickerning(automatickerning),
                spacing(spacing)
            { 
            }
            
            bool pack = true;
            
            float baseline = -1;
            
            bool trim = true;
            
            YesNoAuto converttoalpha = YesNoAuto::Yes; 
            
            bool prepare = true;
            
            bool estimatebaseline = false;
            
            bool automatickerning = true;
            
            int automatickerningreduction = 1;
            
            int spacing = -1;
        };
        
        explicit BitmapFont(float baseline = 0) : BasicFont(dynamic_cast<GlyphRenderer &>(*this)), baseline(baseline) { }
        
        BitmapFont(const BitmapFont &) = delete;
        
        BitmapFont Duplicate() {
            Utils::NotImplemented();
        }
        
        BitmapFont(BitmapFont &&other);
      
        BitmapFont &operator =(const BitmapFont &) = delete;
        
        BitmapFont &operator =(BitmapFont &&other);
        
        ~BitmapFont() {
            destroylist.Destroy();
        }
        
        void AddGlyph(Glyph glyph, const RectangularDrawable &bitmap, int baseline = 0) {
            AddGlyph(glyph, bitmap, {0, this->baseline - baseline}, float(bitmap.GetWidth() + spacing));
        }
                
        void AddGlyph(Glyph glyph, const RectangularDrawable &bitmap, Geometry::Pointf offset, float advance);
        
        void AssumeGlyph(Glyph glyph, const RectangularDrawable &bitmap, int baseline = 0) {
            AddGlyph(glyph, bitmap, baseline);
            destroylist.Push(bitmap);
        }
        
        void AssumeGlyph(Glyph glyph, const RectangularDrawable &bitmap, Geometry::Pointf offset, float advance) {
            AddGlyph(glyph, bitmap, offset, advance);
            destroylist.Push(bitmap);
        }
 
        virtual bool IsASCII() const override {
            return isascii;
        }
        
        void SetKerning(Glyph left, Glyph right, Geometry::Pointf kern) {
            kerning[{left, right}] = kern;
        }
        
        void SetKerning(Glyph left, Glyph right, float x) {
            kerning[{left, right}] = {x, 0.f};
        }
 
        void Pack(bool tight = false, DeleteConstants del = Owned);
        
        Graphics::Bitmap CreateAtlas(std::vector<Geometry::Bounds> &bounds, bool tight = false) const;
        
        using BasicFont::GetSize;
        
        virtual Geometry::Size GetSize(Glyph chr) const override;
        
        virtual void Render(Glyph chr, TextureTarget &target, Geometry::Pointf location, RGBAf color) const override;
 
        virtual bool IsFixedWidth() const override { return isfixedw; }
 
        virtual bool Exists(Glyph g) const override { return glyphmap.count(g) != 0; }
        
        virtual Geometry::Pointf KerningDistance(Glyph chr1, Glyph chr2) const override { 
            auto f = kerning.find({chr1, chr2});
            
            if(f != kerning.end())
                return f->second;
            else
                return {0.f, 0.f}; 
        }
        
        virtual float GetCursorAdvance(Glyph g) const override;         
        
        virtual int GetEMSize() const override { return Exists(0x2004) ? GetSize(0x2004).Width : GetHeight(); }
 
        virtual int GetMaxWidth() const override { return maxwidth; }
        
        virtual int GetHeight() const override { return height; }
        
        virtual float GetBaseLine() const override { return baseline; }
 
        virtual float GetLineGap() const override { return linegap; }
 
        virtual int GetDigitWidth() const override { return digw; }
 
        virtual float GetLineThickness() const override { return (float)linethickness; }
 
        virtual int GetUnderlineOffset() const override { return underlinepos; }
 
        void SetHeight(int value) { height = value; }
 
        void SetMaxWidth(int value) { maxwidth = value; }
 
        void DetermineDimensions();
        
        void SetGlyphSpacing(int value) { spacing = value; }
        
        int GetGlyphSpacing() const { return spacing; }
 
        void SetLineThickness(int value) { linethickness = value; }
 
        void SetUnderlineOffset(int value) { underlinepos = value; }
        
        void SetBaseline(float value) { baseline = value; }
        
        void SetLineGap(float value) { linegap = value; }
        
        int ImportFolder(const std::string &path, ImportNamingTemplate naming = Automatic, Glyph start = 0, 
                         std::string prefix = "", ImportOptions options = ImportOptions{});
        
        
        int ImportAtlas(Bitmap &&bmp, Geometry::Size grid = {0, 0}, Glyph start = 0x20, bool expand = false, ImportOptions options = ImportOptions{});
        
        int ImportAtlas(const Bitmap &bmp, Geometry::Size grid = {0, 0}, Glyph start = 0x20, bool expand = false, ImportOptions options = ImportOptions{}) { 
            return ImportAtlas(bmp.Duplicate(), grid, start, expand, options); 
        }
        
        int ImportAtlas(const std::string &filename, Geometry::Size grid = {0, 0}, Glyph start = 0x20, bool expand = false, ImportOptions options = ImportOptions{}) {
            Bitmap bmp;
            
            if(!bmp.Import(filename))
                return 0;
            
            return ImportAtlas(std::move(bmp), grid, start, expand, options);
        }
        
        void AutoKern(Byte opaquelevel = 64, int reduce = 1, int capitaloffset = -1);
 
        const RectangularDrawable *GetImage(Glyph g) {
            if(glyphmap.count(g))
                return glyphmap.at(g).image;
            else
                return nullptr;
        }
        
        using GlyphRenderer::Prepare;
        
        void Remove(Glyph g);
        
        bool Release(RectangularDrawable &img) {
            auto it = destroylist.Find(img);
            
            if(it.IsValid()) {
                destroylist.Remove(*it);
                
                return true;
            }
            else 
                return false;
        }
        
        bool IsOwned(const RectangularDrawable &img) const {
            auto it = destroylist.Find(img);
            
            return it.IsValid();
        }
        
        void Adopt(const RectangularDrawable &img) {
            destroylist.Add(img);
        }
           
        virtual std::pair<int, int> GetLetterHeight(bool asciionly = false) const override;
 
        
        virtual const GlyphRenderer &GetGlyphRenderer() const override {
            return *this;
        }
        
        std::map<Glyph, GlyphDescriptor>::iterator begin() {
            return glyphmap.begin();
        }
        
        std::map<Glyph, GlyphDescriptor>::iterator end() {
            return glyphmap.end();
        }
        
        std::map<Glyph, GlyphDescriptor>::const_iterator begin() const {
            return glyphmap.begin();
        }
        
        std::map<Glyph, GlyphDescriptor>::const_iterator end() const {
            return glyphmap.end();
        }
        
    protected:
        
        std::map<Glyph, GlyphDescriptor> glyphmap;
        Containers::Collection<const RectangularDrawable> destroylist;
        
        struct gtog {
            Glyph left, right;
            bool operator <(const gtog &other) const { if(left == other.left) return right < other.right; else return left < other.left; }
        };
        
        std::map<gtog, Geometry::Pointf> kerning;
        
        int isfixedw = true;
        
        int maxwidth = 0;
        
        int height = 0;
        
        float baseline = 0;
 
        int digw = 0;
 
        bool isascii = true;
        
        int spacing = 0;
 
        int linethickness = 1;
 
        int underlinepos = 0;
        
        float linegap = 0;
    };
    
} }