Font.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <map>
#include <limits.h>
 
#include "../Types.h"
#include "../Geometry/Point.h"
#include "../Geometry/Size.h"
#include "TextureTargets.h"
#include "Color.h"
 
namespace Gorgon { namespace Graphics {
    using Glyph = Gorgon::Char;
    
    class GlyphRange {
    public:        
        /*implicit*/ GlyphRange(Glyph value = 0xFFFF) : Start(value), End(value) { }
        
        GlyphRange(Glyph start, Glyph end) : Start(start), End(end) { }
        
        int Count() const { 
            if(Start == -1) return 0; 
            
            return End - Start + 1; 
        }
        
        void Normalize() {
            if(Start > End)
                std::swap(Start, End);
        }
        
        Glyph Start;
        
        Glyph End;
    };
    
    namespace internal {
        Glyph decode(std::string::const_iterator &it, std::string::const_iterator end);
        bool isnewline(Glyph g);
        bool isspaced(Glyph g);
        bool isspace(Glyph g);
        bool isadjustablespace(Glyph g);
        bool isbreaking(Glyph g);
 
        inline int ceildiv(int v, float f) { return (int)std::ceil(v/f); }
        inline int rounddiv(int v, float f) { return (int)std::round(v/f); }
 
    }
 
    class GlyphRenderer {
    public:
        virtual ~GlyphRenderer() { }
 
        
        virtual void Render(Glyph chr, TextureTarget &target, Geometry::Pointf location, RGBAf color) const = 0;
 
        virtual Geometry::Size GetSize(Glyph chr) const = 0;
        
        virtual float GetCursorAdvance(Glyph g) const = 0;
 
        virtual bool Exists(Glyph g) const = 0;
 
        virtual bool IsASCII() const = 0;
 
        virtual bool IsFixedWidth() const = 0;
        
        virtual Geometry::Pointf KerningDistance(Glyph left, Glyph right) const = 0;
        
        virtual int GetEMSize() const = 0;
        
        virtual int GetMaxWidth() const = 0;
 
        virtual int GetHeight() const = 0;
 
        virtual std::pair<int, int> GetLetterHeight(bool asciionly = false) const = 0;
 
        virtual int GetDigitWidth() const = 0;
        
        virtual float GetBaseLine() const = 0;
        
        virtual float GetLineGap() const = 0;
 
        virtual float GetLineThickness() const = 0;
 
        virtual int GetUnderlineOffset() const = 0;
        
        virtual bool NeedsPrepare() const { return false; }
        
        virtual void Prepare(const std::string &) const { }
    };
 
    class TextRenderer {
    public:
        virtual ~TextRenderer() { }
        
        void Print(TextureTarget &target, const std::string &text, Geometry::Pointf location) const {
            print(target, text, location);
        }
        
        void Print(TextureTarget &target, const std::string &text, Geometry::Point location) const {
            print(target, text, location);
        }
        
        void Print(TextureTarget &target, const std::string &text, int x, int y) const {
            print(target, text, {x, y});
        }
        
        void Print(TextureTarget &target, const std::string &text, Geometry::Point location, int w, TextAlignment align_override) const {
            print(target, text, {location, w, 0}, align_override);
        }
        
        void Print(TextureTarget &target, const std::string &text, Geometry::Point location, int w) const {
            print(target, text, {location, w, 0});
        }
                
        void Print(TextureTarget &target, const std::string &text, int x, int y, int w, TextAlignment align_override) const {
            print(target, text, {x, y, w, 0}, align_override);
        }
        
        void Print(TextureTarget &target, const std::string &text, int x, int y, int w) const {
            print(target, text, {x, y, w, 0});
        }
 
        void PrintNoWrap(TextureTarget &target, const std::string &text, Geometry::Point location, int w, TextAlignment align_override) const {
            printnowrap(target, text, {location, w, 0}, align_override);
        }
        
        void PrintNoWrap(TextureTarget &target, const std::string &text, Geometry::Point location, int w) const {
            printnowrap(target, text, {location, w, 0});
        }
                
        void PrintNoWrap(TextureTarget &target, const std::string &text, int x, int y, int w, TextAlignment align_override) const {
            printnowrap(target, text, {x, y, w, 0}, align_override);
        }
        
        void PrintNoWrap(TextureTarget &target, const std::string &text, int x, int y, int w) const {
            printnowrap(target, text, {x, y, w, 0});
        }
 
        void Print(TextureTarget &target, const std::string &text) {
            print(target, text, {0, 0, target.GetTargetSize()});
        }
        
        virtual bool IsReady() const = 0;
 
        virtual const GlyphRenderer &GetGlyphRenderer() const = 0;
        
        virtual int GetEMSize() const = 0;
        
        virtual float GetBaseLine() const = 0;
        
        virtual int GetHeight() const = 0;
        
        virtual Geometry::Size GetSize(const std::string &text) const = 0;
        
        virtual Geometry::Size GetSize(const std::string &text, int width) const = 0;
 
        virtual int GetCharacterIndex(const std::string &text, Geometry::Point location) const = 0;
        
        virtual int GetCharacterIndex(const std::string &text, int w, Geometry::Point location, bool wrap = true) const = 0;
        
        virtual Geometry::Rectangle GetPosition(const std::string &text, int index) const = 0;
        
        virtual Geometry::Rectangle GetPosition(const std::string &text, int w, int index, bool wrap = true) const = 0;
 
    protected:
        virtual void print(TextureTarget &target, const std::string &text, Geometry::Point location) const = 0;
        
        virtual void print(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align_override) const = 0;
 
        virtual void print(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location) const = 0;
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location) const = 0;
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align_override) const = 0;
    };
    
    class BasicFont : public TextRenderer {
    public:
        BasicFont(const GlyphRenderer &renderer, RGBAf color = 1.f, TextAlignment defaultalign = TextAlignment::Left) : 
            defaultalign(defaultalign), color(color), renderer(&renderer) {
        }
 
        using TextRenderer::Print;
 
 
        void Print(TextureTarget &target, const std::string &text, RGBAf color) const {
            print(target, text, {0, 0, target.GetTargetSize()}, color);
        }
 
        void Print(TextureTarget &target, const std::string &text, Geometry::Point location, RGBAf color) const {
            print(target, text, location, color);
        }
 
        void Print(TextureTarget &target, const std::string &text, int x, int y, RGBAf color) const {
            print(target, text, {x, y}, color);
        }
        
        void Print(TextureTarget &target, const std::string &text, Geometry::Point location, int w, TextAlignment align_override, RGBAf color) const {
            print(target, text, {location, w, 0}, align_override, color);
        }
 
        void Print(TextureTarget &target, const std::string &text, Geometry::Point location, int w, RGBAf color) const {
            print(target, text, {location, w, 0}, color);
        }
        
        void Print(TextureTarget &target, const std::string &text, int x, int y, int w, TextAlignment align_override, RGBAf color) const {
            print(target, text, {x, y, w, 0}, align_override, color);
        }
 
        void Print(TextureTarget &target, const std::string &text, int x, int y, int w, RGBAf color) const {
            print(target, text, {x, y, w, 0}, color);
        }
 
        void PrintNoWrap(TextureTarget &target, const std::string &text, Geometry::Point location, int w, TextAlignment align_override, RGBAf color) const {
            printnowrap(target, text, {location, w, 0}, align_override, color);
        }
 
        void PrintNoWrap(TextureTarget &target, const std::string &text, Geometry::Point location, int w, RGBAf color) const {
            printnowrap(target, text, {location, w, 0}, color);
        }
        
        void PrintNoWrap(TextureTarget &target, const std::string &text, int x, int y, int w, TextAlignment align_override, RGBAf color) const {
            printnowrap(target, text, {x, y, w, 0}, align_override, color);
        }
 
        void PrintNoWrap(TextureTarget &target, const std::string &text, int x, int y, int w, RGBAf color) const {
            printnowrap(target, text, {x, y, w, 0}, color);
        }
 
        void SetDefaultAlignment(TextAlignment value) {
            defaultalign = value;
        }
 
        TextAlignment GetDefaultAlignment() const {
            return defaultalign;
        }
 
        void SetColor(RGBAf value) {
            color = value;
        }
 
        RGBAf GetColor() const {
            return color;
        }
        
        virtual bool IsReady() const override {
            return renderer != nullptr;
        }
        
        virtual const GlyphRenderer &GetGlyphRenderer() const override {
            return *renderer;
        }
        
        virtual int GetEMSize() const override {
            return renderer->GetEMSize();
        }
        
        virtual float GetBaseLine() const override {
            return renderer->GetBaseLine();
        }
        
        virtual int GetHeight() const override {
            return renderer->GetHeight();
        }
        
        virtual Geometry::Size GetSize(const std::string &text) const override;
        
        virtual Geometry::Size GetSize(const std::string &text, int width) const override;
        
        virtual int GetCharacterIndex(const std::string &text, Geometry::Point location) const override;
        
        virtual int GetCharacterIndex(const std::string &text, int w, Geometry::Point location, bool wrap = true) const override;
        
        virtual Geometry::Rectangle GetPosition(const std::string& text, int index) const override;
        
        virtual Geometry::Rectangle GetPosition(const std::string& text, int w, int index, bool wrap = true) const override;
        
    protected:
        virtual void print(TextureTarget &target, const std::string &text, Geometry::Point location) const override {
            print(target, text, location, color);
        }
 
        virtual void print(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align) const override {
            print(target, text, location, align, color);
        }
 
        virtual void print(TextureTarget &target, const std::string &text, Geometry::Point location, RGBAf color) const;
 
        virtual void print(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align, RGBAf color) const;
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align, RGBAf color) const;
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align) const override {
            printnowrap(target, text, location, align, color);
        }
 
        virtual void print(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location) const override {
            print(target, text, location, defaultalign);
        }
 
        virtual void print(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, RGBAf color) const {
            print(target, text, location, defaultalign, color);
        }
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location) const override {
            printnowrap(target, text, location, defaultalign);
        }
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, RGBAf color) const {
            printnowrap(target, text, location, defaultalign, color);
        }
 
        TextAlignment defaultalign;
 
        RGBAf color;
 
    private:
        const GlyphRenderer *renderer;
    };
 
    class TextShadow {
    public:
 
        enum ShadowType {
            None,
            Flat
        };
 
        TextShadow() = default;
 
        TextShadow(ShadowType type) : type(type) { }
 
        TextShadow(ShadowType type, RGBAf color, Geometry::Pointf offset) :
            type(type), color(color), offset(offset) {}
 
        TextShadow(RGBAf color, Geometry::Pointf offset = {1.f, 1.f}) :
            type(Flat), color(color), offset(offset) {}
 
        ShadowType type = None;
        RGBAf color = 0x80000000;
        Geometry::Pointf offset = {1.f, 1.f};
    };
 
    class StyledRenderer : public TextRenderer {
    public:
        StyledRenderer(GlyphRenderer &renderer, RGBAf color = 1.f, TextShadow shadow = {}) : 
            renderer(&renderer), color(color), shadow(shadow) { 
            tabwidth = renderer.GetMaxWidth() * 8;
        }
 
        StyledRenderer() = default;
 
        GlyphRenderer &GetGlyphRenderer() {
            return *renderer;
        }
        
        void SetGlyphRenderer(GlyphRenderer &renderer) {
            this->renderer = &renderer;
        }
        
        void SetColor(RGBAf value) {
            color = value;
        }
        
        RGBAf GetColor() const {
            return color;
        }
 
        void SetShadow(TextShadow value) {
            shadow = value;
        }
 
        void DisableShadow() {
            shadow = TextShadow::None;
        }
 
        void UseFlatShadow(RGBAf color, Geometry::Pointf offset = {1.f, 1.f}) {
            shadow = {TextShadow::Flat, color, offset};
        }
        
        TextShadow GetShadow() const {
            return shadow;
        }
 
        void SetUnderline(bool value) {
            underline = value;
        }
 
        void Underline() {
            underline = true;
        }
 
        void Underline(RGBAf color) {
            underline = true;
            underlinecolor = color;
        }
 
        bool GetUnderline() const {
            return underline;
        }
 
        void SetUnderlineColor(RGBAf value) {
            underlinecolor = value;
        }
 
        RGBAf GetUnderlineColor() const {
            if(underlinecolor.R == -1)
                return color;
            else
                return underlinecolor;
        }
 
        void ResetUnderlineColor() {
            underlinecolor = -1.f;
        }
 
        void SetStrike(bool value) {
            strike = value;
        }
 
        void Strike() {
            strike = true;
        }
 
        void Strike(RGBAf color) {
            strike = true;
            strikecolor = color;
        }
 
        bool GetStrike() const {
            return strike;
        }
 
        void SetStrikeColor(RGBAf value) {
            strikecolor = value;
        }
        
        RGBAf GetStrikeColor() const {
            if(strikecolor.R == -1)
                return color;
            else
                return strikecolor;
        }
 
        void ResetStrikeColor() {
            strikecolor = -1.f;
        }
 
        void SetStrikePosition(int value) {
            strikepos = value;
        }
        
        int GetStrikePosition() const {
            if(strikepos == INT_MIN)
                return (int)std::round( (renderer->GetHeight() - renderer->GetLineThickness()) * .6f );
            else
                return strikepos;
        }
 
        void SetDefaultAlign(TextAlignment value) {
            defaultalign = value;
        }
 
        void AlignLeft() {
            defaultalign = TextAlignment::Left;
            justify = false;
        }
 
        void AlignRight() {
            defaultalign  = TextAlignment::Right;
            justify = false;
        }
 
        void AlignCenter() {
            defaultalign = TextAlignment::Center;
            justify = false;
        }
        
        TextAlignment GetDefaultAlign() const {
            return defaultalign;
        }
 
        void SetJustify(bool value) {
            justify = value;
        }
 
        void JustifyLeft() {
            defaultalign = TextAlignment::Left;
            justify = true;
        }
 
        void JustifyRight() {
            defaultalign  = TextAlignment::Right;
            justify = true;
        }
 
        void JustifyCenter() {
            defaultalign = TextAlignment::Center;
            justify = true;
        }
        
        bool GetJustify() const {
            return justify;
        }
 
        void SetLineSpacingPixels(int value) {
            vspace = (float)value / renderer->GetHeight();
        }
        
        int GetLineSpacingPixels() const {
            return (int)std::round(vspace * renderer->GetHeight());
        }
 
        void SetLineSpacing(float value) {
            vspace = value;
        }
        
        float GetLineSpacing() const {
            return vspace;
        }
 
        void SetLetterSpacing(int value) {
            hspace = value;
        }
        
        int GetLetterSpacing() const {
            return hspace;
        }
 
        void SetTabWidth(int value) {
            tabwidth = value;
        }
 
        void SetTabWidthInLetters(float value) {
            tabwidth = (int)std::round(value * renderer->GetCursorAdvance('A'));
        }
        
        int GetTabWidth() const {
            return tabwidth;
        }
 
        void SetParagraphSpacing(int value) {
            pspace = value;
        }
        
        int GetParagraphSpacing() const {
            return pspace;
        }
        
        virtual bool IsReady() const override {
            return renderer != nullptr;
        }
        
        virtual int GetEMSize() const override {
            return renderer->GetEMSize();
        }
        
        virtual float GetBaseLine() const override {
            return renderer->GetBaseLine();
        }
        
        virtual int GetHeight() const override {
            return renderer->GetHeight();
        }
        
        virtual const GlyphRenderer &GetGlyphRenderer() const override {
            return *renderer;
        }
 
        virtual Geometry::Size GetSize(const std::string &text) const override;
 
        virtual Geometry::Size GetSize(const std::string &text, int width) const override;
 
        virtual int GetCharacterIndex(const std::string &text, Geometry::Point location) const override;
 
        virtual Geometry::Rectangle GetPosition(const std::string& text, int index) const override;
 
        virtual int GetCharacterIndex(const std::string &text, int w, Geometry::Point location, bool wrap = true) const override;
 
        virtual Geometry::Rectangle GetPosition(const std::string &text, int w, int index, bool wrap = true) const override;
 
    protected:
        virtual void print(TextureTarget &target, const std::string &text, Geometry::Point location) const override;
 
        virtual void print(TextureTarget &target, const std::string &text, Geometry::Rectangle location) const override {
            print(target, text, location, defaultalign);
        }
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location, TextAlignment align) const override;
 
        virtual void print(TextureTarget &target, const std::string &text, 
                        Geometry::Rectangle location, TextAlignment align_override) const override;
 
 
 
        virtual void printnowrap(TextureTarget &target, const std::string &text,
                        Geometry::Rectangle location) const override {
            printnowrap(target, text, location, defaultalign);
        }
 
    private:
        //internal, float to facilitate shadow offset
        void print(TextureTarget &target, const std::string &text, Geometry::Pointf location, RGBAf color, RGBAf strikecolor, RGBAf underlinecolor) const;
 
        void print(TextureTarget &target, const std::string &text, Geometry::Rectanglef location, TextAlignment align, RGBAf color, RGBAf strikecolor, RGBAf underlinecolor) const;
 
        GlyphRenderer *renderer = nullptr;
 
        RGBAf color = 1.f;
 
        TextShadow shadow = {};
        bool underline = false;
        RGBAf underlinecolor = -1.f;
        bool strike = false;
        RGBAf strikecolor = -1.f;
        int strikepos = INT_MIN;
        TextAlignment defaultalign = TextAlignment::Left;
        bool  justify = false;
        float vspace = 1.0f;
        int   hspace = 0;
        int   pspace = 0;
        int   tabwidth = 0;
    };
    
} }