CUFont.h

//
//  CUFont.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a robust font asset with atlas support.  Unlike other
//  systems we decided to merge fonts and font atlases because it helps with
//  asset management.
//
//  This module makes heavy use of the cross-platform UTF8 utilities by
//  Nemanja Trifunovic ( https://github.com/nemtrif/utfcpp ).
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 7/6/16

#ifndef __CU_FONT_H__
#define __CU_FONT_H__

#include <string>
#include <unordered_map>
#include <vector>
#include <cugl/math/CUSize.h>
#include <cugl/math/CURect.h>
#include <cugl/renderer/CUTexture.h>
#include <cugl/renderer/CUVertex.h>
#include <SDL/SDL_ttf.h>

namespace cugl {
    
class Font {
#pragma mark Inner Classes
public:
    class Metrics {
    public:
        int minx;
        int maxx;
        int miny;
        int maxy;
        int advance;
    };

    enum class Style : int {
        NORMAL      = TTF_STYLE_NORMAL,
        BOLD        = TTF_STYLE_BOLD,
        ITALIC      = TTF_STYLE_ITALIC,
        UNDERLINE   = TTF_STYLE_UNDERLINE,
        STRIKE      = TTF_STYLE_STRIKETHROUGH
    };
    
    enum class Hinting : int {
        NORMAL  = TTF_HINTING_NORMAL,
        LIGHT   = TTF_HINTING_LIGHT,
        MONO    = TTF_HINTING_MONO,
        NONE    = TTF_HINTING_NONE
    };
    
    enum class Resolution : int {
        SOLID   = 0,
        SHADED  = 1,
        BLENDED  = 2,
    };

#pragma mark -
#pragma mark Values
protected:
    std::string _name;
    std::string _stylename;
    int _size;
    
    TTF_Font* _data;

    // Cached settings
    unsigned int _fontHeight;
    unsigned int _fontDescent;
    unsigned int _fontAscent;
    unsigned int _fontLineSkip;
    bool _fixedWidth;
    bool _useKerning;
    
    // Render settings
    Style _style;
    Hinting _hints;
    Resolution _render;
    
    // Altas support
    bool _hasAtlas;
    std::vector<Uint32> _glyphset;
    std::unordered_map<Uint32, Rect> _glyphmap;
    std::unordered_map<Uint32, Metrics> _glyphsize;
    std::unordered_map<Uint32, std::unordered_map<Uint32, Uint32> > _kernmap;
    std::shared_ptr<Texture> _texture;
    SDL_Surface* _surface;

    
public:
#pragma mark -
#pragma mark Constructors

    Font();
    
    ~Font() { dispose(); }
    
    virtual void dispose();
    
    bool init(const std::string& file, int size);

    bool init(const char* file, int size) {
        return init(std::string(file),size);
    }
    
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<Font> alloc(const std::string& file, int size) {
        std::shared_ptr<Font> result = std::make_shared<Font>();
        return (result->init(file,size) ? result : nullptr);
    }

    static std::shared_ptr<Font> alloc(const char* file, int size) {
        std::shared_ptr<Font> result = std::make_shared<Font>();
        return (result->init(file,size) ? result : nullptr);
    }

#pragma mark -
#pragma mark Attributes

    const std::string& getName() const { return _name; }

    const std::string& getStyleName() const { return _stylename; }
    
    int getHeight() const { return _fontHeight; }
    
    int getDescent() const { return _fontDescent; }
    
    int getAscent() const { return _fontAscent; }
    
    int getLineSkip() const { return _fontLineSkip; }
    
    bool isFixedWidth() const { return _fixedWidth; }
    
    bool usesKerning() const { return _useKerning; }
    
    void setKerning(bool kerning);
    
    bool hasGlyph(char a) const { return hasGlyph((Uint32)a); }
    
    bool hasGlyph(Uint32 a) const;
    
    bool hasString(const std::string& text) const;
    
    bool hasString(const char* text) const {
        return hasString(std::string(text));
    }

#pragma mark -
#pragma mark Settings

    Style getStyle() const { return _style; }
    
    void setStyle(Style style);
    
    Hinting getHinting() const { return _hints; }
    
    void setHinting(Hinting hinting);
    
    Resolution getResolution() const { return _render; }
    
    void setResolution(Resolution resolution) { clearAtlas(); _render = resolution; }


    
#pragma mark -
#pragma mark Measurements

    const Metrics getMetrics(char thechar) const {
        return getMetrics((Uint32)thechar);
    }
    
    const Metrics getMetrics(Uint32 thechar) const;
    
    unsigned int getKerning(char a, char b) const {
        return getKerning((Uint32)a, (Uint32)b);
    }
    
    unsigned int getKerning(Uint32 a, Uint32 b) const;
    
    Size getSize(const std::string& text, bool utf8=true) const;
    
    Size getSize(const char* text, bool utf8=true) const {
        return getSize(std::string(text), utf8);
    }
    
    Rect getInternalBounds(const std::string& text, bool utf8=true) const;
    
    Rect getInternalBounds(const char* text, bool utf8=true) const {
        return getInternalBounds(std::string(text), utf8);
    }

#pragma mark -
#pragma mark Atlas Support

    void clearAtlas();

    bool buildAtlas() {
        bool result = buildAtlasAsync();
        return result && (getAtlas() != nullptr);
    }

    bool buildAtlas(const std::string& charset) {
        bool result = buildAtlasAsync(charset);
        return result && (getAtlas() != nullptr);
    }

    bool buildAtlas(const char* charset) {
        bool result = buildAtlasAsync(charset);
        return result && (getAtlas() != nullptr);
    }

    bool buildAtlasAsync();
    
    bool buildAtlasAsync(const std::string& charset);

    bool buildAtlasAsync(const char* charset) {
        return buildAtlasAsync(std::string(charset));
    }

    const std::shared_ptr<Texture>& getAtlas();

    bool hasAtlas() const { return _hasAtlas; }
    
#pragma mark -
#pragma mark Rendering

    std::shared_ptr<Texture> getQuads(const std::string& text, const Vec2& origin,
                                      std::vector<Vertex2>& vertices, bool utf8=true);
    
    std::shared_ptr<Texture> getQuads(const char* text, const Vec2& origin,
                                      std::vector<Vertex2>& vertices, bool utf8=true)  {
        return getQuads(std::string(text),origin,vertices,utf8);
    }
    
    std::shared_ptr<Texture> getQuads(const std::string& text, const Vec2& origin, const Rect& rect,
                                      std::vector<Vertex2>& vertices,  bool utf8=true);
    
    std::shared_ptr<Texture> getQuads(const char* text, const Vec2& origin, const Rect& rect,
                                      std::vector<Vertex2>& vertices, bool utf8=true) {
        return getQuads(std::string(text),origin,rect,vertices,utf8);
    }
    
    std::shared_ptr<Texture> getQuad(Uint32 thechar, Vec2& offset, std::vector<Vertex2>& vertices);

    std::shared_ptr<Texture> getQuad(Uint32 thechar, Vec2& offset, const Rect& rect,
                                     std::vector<Vertex2>& vertices);
    
    
#pragma mark -
#pragma mark Rendering Internals
protected:
    void getAtlasQuads(const std::string& text, const Vec2& origin, const Rect& rect,
                       std::vector<Vertex2>& vertices, bool utf8);
    
    std::shared_ptr<Texture> getRenderedQuads(const std::string& text, const Vec2& origin, const Rect& rect,
                                              std::vector<Vertex2>& vertices, bool utf8);
    
    bool getAtlasQuad(Uint32 thechar, Vec2& offset, const Rect& rect, std::vector<Vertex2>& vertices);
    
    std::shared_ptr<Texture> getRenderedQuad(Uint32 thechar, Vec2& offset, const Rect& rect,
                                             std::vector<Vertex2>& vertices);
    
    Size getSizeASCII(const std::string& text) const;

    Size getSizeUTF8(const std::string& text) const;

    Rect getInternalBoundsASCII(const std::string& text) const;

    Rect getInternalBoundsUTF8(const std::string& text) const;

#pragma mark -
#pragma mark Atlas Preparation

    int prepareAtlas();
    
    int prepareAtlas(std::string charset);
    
    void prepareAtlasKerning();

    Metrics computeMetrics(Uint32 thechar) const;

    int computeKerning(Uint32 a, Uint32 b) const;

    void computeAtlasSize(int* width, int* height);
    
    std::vector< std::vector<Uint32> > planAtlas(int width, int height);
    
    void layoutAtlas(const std::vector< std::vector<Uint32> >& rectangle);
    
    bool generateSurface(int width, int height);
    
    SDL_Surface* allocSurface(int width, int height);
};
    
#pragma mark -
#pragma mark Style Bit-Wise Operators
    
inline int operator*(Font::Style value) {
    return static_cast<int>(value);
}

inline Font::Style operator|(Font::Style lhs, Font::Style rhs) {
    return static_cast<Font::Style>((*lhs) | (*rhs));
}
    
inline Font::Style operator&(Font::Style lhs, Font::Style rhs) {
    return static_cast<Font::Style>((*lhs) & (*rhs));
}

inline Font::Style operator^(Font::Style lhs, Font::Style rhs) {
    return static_cast<Font::Style>((*lhs) ^ (*rhs));
}

inline Font::Style operator~(Font::Style lhs) {
    return static_cast<Font::Style>(~(*lhs));
}


}

#endif /* __CU_FONT_H__ */