/home/rixxx/src/glttf/src/font.h

#ifndef _FONT_H_
#define _FONT_H_

#include <limits>
#include <string>
#include <stdexcept>
#include <map>
#include <cmath>

namespace glttf {


class Font
{
public:
    static const unsigned long DEFAULT_FACE_INDEX = 0;
    
    typedef unsigned char FontStyle;
    static const FontStyle PLAIN = 0x0;
    static const FontStyle BOLD = 0x1;
    static const FontStyle ITALIC = 0x2;
    
    typedef unsigned char Flags;
    static const Flags FLIP_Y_AXIS = 0x1;
    static const Flags SCALE_TO_1EM = 0x2;
    static const Flags TOP_LEFT_ORIGIN = 0x4;
    
    static const float BOLD_WEIGHT;
    static const float ITALIC_SHEAR;
    

    Font(const std::string &filename, unsigned int size, FontStyle style, unsigned long faceIndex = DEFAULT_FACE_INDEX);
    

    virtual ~Font();
    

    void setPixelSize(unsigned int width, unsigned int height = 0);
    

    void setCharSize(float width, float height, unsigned int hres = 0, unsigned int vres = 0);
    

    void setTransformation(float weight, float shear);
    

    void setStyle(FontStyle style);
    

    Glyph &getGlyph(unsigned long ch, bool cache);
    

    void drawCharacter(unsigned long ch, bool cache = true);
    

    template<typename Iterator>
    void drawString(Iterator begin, Iterator end, bool cache = true);


    template<typename Iterator>
    void getBoundingBox(Iterator begin, Iterator end, float &minX, float &minY, float &maxX, float &maxY, bool cache = true);
    

    void drawString(std::string const &str, bool cache = true);
    

    void getBoundingBox(std::string const &str, float &minX, float &minY, float &maxX, float &maxY, bool cache = true);

#ifdef HAVE_WSTRING

    void drawString(std::wstring const &str, bool cache = true);
    

    void getBoundingBox(std::wstring const &str, float &minX, float &minY, float &maxX, float &maxY, bool cache = true);
#endif
    

    void buildCache(unsigned long from = 0, unsigned long to = 127);
    

    virtual void setupState();
    

    virtual void cleanupState();


    void setScaleTo1EM(bool enable);
    

    bool getScaleTo1EM() const;
    

    void setFlipYAxis(bool enable);
    

    bool getFlipYAxis() const;
    

    void setTopLeftOrigin(bool enable);
    

    bool getTopLeftOrigin() const;
    

    Flags getFlags() const;
    

    void setFlags(Flags f);


    float getTextHeight() const;
    

    float getUnitsPerEM() const;
    

    float getAscender() const;
    

    float getDescender() const;
    

    float getMaxAdvanceX() const;
    

    float getMaxAdvanceY() const;
    

    float getWeight() const;
    

    float getShear() const;


    unsigned int getTabSize() const;
    

    void setTabSize(unsigned int size);
    

    void setTabWidth(float width);
    

    float getTabWidth() const;
    

    float getTabWidth(bool cache = true);
    
protected:
    unsigned int getCharIndex(unsigned long charcode) const;
    FT_GlyphSlot getFTGlyph(unsigned int index) const;
    

    void deleteCache();
    

    virtual Glyph *makeGlyph(FT_GlyphSlot glyph) = 0;
    
private:
    Font(const Font& font);
    Font &operator=(const Font &font);
    
    unsigned int stateSet;
    Flags flags;
    unsigned int tabSize;
    float tabWidth;
    
    typedef std::map<unsigned long, Glyph*> GlyphMap;
    GlyphMap glyphs;
    
    void loadCharacter(unsigned long ch);
    
    void initLibrary();
    void deinitLibrary();
    FT_Face face;
    
    bool kerning;
    
    FontStyle style;
    float weight, shear;
    
    float textHeight;
    float unitsPerEM;
    float ascender, descender;
    float maxAdvanceX, maxAdvanceY;
    
    static FT_Library library;
    static int instances;
    
    void calculateTabWidth(bool cache);
};

template<typename Iterator>
void Font::drawString(Iterator begin, Iterator end, bool cache)
{
    setupState();
    
    glPushMatrix();
    
    if(flags & FLIP_Y_AXIS) glScalef(1.0f, -1.0f, 1.0f);
    if(flags & SCALE_TO_1EM)
    {
        float scale = 1.0 / unitsPerEM;
        glScalef(scale, scale, scale);
    }
    if(flags & TOP_LEFT_ORIGIN) glTranslatef(0.0f, -ascender, 0.0f);
    
    glPushMatrix();
    
    float x0 = 0.0f;
    unsigned int prev = 0;
    for(Iterator i(begin); i != end; ++i)
    {
        unsigned long ch = (*i < 0)?(0):(*i);

        if(kerning)
        {
            unsigned int index = getCharIndex(ch);
            
            if(prev && index)
            {
                FT_Vector delta;
                if(FT_Get_Kerning(face, prev, index, FT_KERNING_DEFAULT, &delta))
                {
                    glPopMatrix();
                    glPopMatrix();
                    cleanupState();
                    throw std::runtime_error("Can't get glyph kerning");
                }
                
                glTranslatef(weight * delta.x / 64.0f, 0.0f, 0.0f);
            }
            
            prev = index;
        }
        
        // TODO: tab, etc
        if(ch == '\n')
        {
            x0 = 0.0f;
            glPopMatrix();
            glTranslatef(0.0f, -textHeight, 0.0f);
            glPushMatrix();
            continue;
        } else if(ch == '\r')
        {
            continue;
        } else if(ch == '\t')
        {
            ch = ' ';
            prev = getCharIndex(ch);
            
            if(tabWidth < 0.0)
            {
                try
                {
                    calculateTabWidth(cache);
                } catch(...)
                {
                    glPopMatrix();
                    glPopMatrix();
                    cleanupState();
                    throw;
                }
            }
            
            float tx = std::floor((x0 + tabWidth) / tabWidth) * tabWidth;
            glTranslatef(tx - x0, 0.0f ,0.0f);
            x0 = tx;
            
            continue;
        }
        
        try
        {
            const Glyph &glyph = getGlyph(ch, cache);
            glyph.draw();
            glTranslatef(weight * glyph.getAdvanceX(), 0.0f, 0.0f);
            x0 += glyph.getAdvanceX() * weight;
        } catch(...)
        {
            glPopMatrix();
            glPopMatrix();
            cleanupState();
            throw;
        }
    }
    
    glPopMatrix();
    glPopMatrix();
    cleanupState();
}

template<typename Iterator>
void Font::getBoundingBox(Iterator begin, Iterator end, float &minX, float &minY, float &maxX, float &maxY, bool cache)
{   
    float x0 = 0.0;
    float y0 = 0.0;
    
    const float MAX = std::numeric_limits<float>::max();
    const float MIN = std::numeric_limits<float>::min();
    minX = MAX;
    maxX = MIN;
    minY = MAX;
    maxY = MIN;
    
    unsigned int prev = 0;
    for(Iterator i(begin); i != end; ++i)
    {
        unsigned long ch = (*i < 0)?(0):(*i);
    
        unsigned int index = getCharIndex(ch);
        if(kerning && index)
        {
            if(prev)
            {
                FT_Vector delta;
                if(FT_Get_Kerning(face, prev, index, FT_KERNING_DEFAULT, &delta))
                {
                    throw std::runtime_error("Can't get glyph kerning");
                }
                x0 += weight * delta.x / 64.0f;
            }
        }
        prev = index;

        // TODO: tab, etc.
        if(ch == '\n')
        {
            x0 = 0.0f;
            y0 -= textHeight;
            continue;
        } else if(ch == '\r')
        {
            continue;
        } else if(ch == '\t')
        {
            ch = ' ';
            prev = index = getCharIndex(ch);

            if(tabWidth < 0.0f) calculateTabWidth(cache);

            x0 = std::floor((x0 + tabWidth) / tabWidth) * tabWidth;
    
            continue;
        }

        float x1, y1, x2, y2;

        const Glyph &glyph = getGlyph(ch, cache);

        x1 = x0 + glyph.getMinX();
        y1 = y0 + glyph.getMinY();
        x2 = x0 + glyph.getMaxX();
        y2 = y0 + glyph.getMaxY();
            
        x0 += glyph.getAdvanceX() * weight;

        if(x1 < minX) minX = x1;
        if(y1 < minY) minY = y1;
        if(x2 > maxX) maxX = x2;
        if(y2 > maxY) maxY = y2;
    }
    
    if(flags & FLIP_Y_AXIS)
    {
        minY = -minY;
        maxY = -maxY;
    }
    
    float scale = 1.0;
    if(flags & SCALE_TO_1EM)
    {
        scale = 1.0 / unitsPerEM;
        maxX *= scale;
        minX *= scale;
        maxY *= scale;
        minY *= scale;
    }
    
    if(flags & FLIP_Y_AXIS) scale = -scale;
    
    if(flags & TOP_LEFT_ORIGIN)
    {
        minY -= ascender * scale;
        maxY -= ascender * scale;
    }
}



template <class T>
class BasicFont : public Font
{
public:
    typedef T GlyphType;
    
    typedef typename T::Parameter Parameter;
    

    BasicFont(const std::string &filename, unsigned int size = 32, Font::FontStyle style = Font::PLAIN, unsigned long faceIndex = Font::DEFAULT_FACE_INDEX)
        : Font(filename, size, style, faceIndex), stateSet(0), parameter(GlyphType::DEFAULT_PARAMETER)
    {
    }
    
    ~BasicFont() {}
    

    void setupState()
    {
        if(stateSet)
        {
            ++stateSet;
            return;
        }
        ++stateSet;
    
        Font::setupState();
        GlyphType::setupState();
    }
    

    void cleanupState()
    {
        if(!stateSet) return;
        --stateSet;
        if(stateSet) return;

        GlyphType::cleanupState();
        Font::cleanupState();
    }
    

    void setParameter(const Parameter &param)
    {
        if(stateSet) throw std::logic_error("Can't set font parameters when in rendering state");
        deleteCache();
        parameter = param;
    }
    

    const Parameter &getParameter() const
    {
        return parameter;
    }
protected:

    Glyph *makeGlyph(FT_GlyphSlot glyph)
    {
        return dynamic_cast<Glyph*>(new GlyphType(glyph, parameter));
    }
private:
    BasicFont(const BasicFont<GlyphType> &font);
    BasicFont& operator=(const BasicFont<GlyphType> &font);
    int stateSet;
    
    Parameter parameter;
};

}

#endif

---