font_with_face.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2016 SuperTuxKart-Team
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef HEADER_FONT_WITH_FACE_HPP
#define HEADER_FONT_WITH_FACE_HPP
 
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
 
#include <algorithm>
#include <cassert>
#include <map>
#include <set>
#include <string>
 
#ifndef SERVER_ONLY
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_OUTLINE_H
#endif
 
#include <GlyphLayout.h>
#include <dimension2d.h>
#include <irrString.h>
#include <rect.h>
 
using namespace irr;
 
const int BEARING = 64;
 
class FaceTTF;
class FontSettings;
struct FontArea;
 
namespace irr
{
    namespace video
    {
        class ITexture;
        class SColor;
    }
    namespace gui
    {
        class IGUISpriteBank;
    }
}
 
class FontWithFace : public NoCopy
{
public:
    class FontCharCollector
    {
    public:
        virtual void collectChar(video::ITexture* texture,
                                 const core::rect<float>& destRect,
                                 const core::rect<s32>& sourceRect,
                                 const video::SColor* const colors) = 0;
    };
 
protected:
    int m_font_max_height;
 
    int m_glyph_max_height;
 
    // ------------------------------------------------------------------------
    void insertCharacters(const wchar_t* in_ptr, bool first_load = false)
    {
        if (!supportLazyLoadChar() && !first_load) return;
 
        for (const wchar_t* p = in_ptr; *p; ++p)
        {
            if (*p == L'\r' ||  *p == L'\n' || *p < (wchar_t)32)
                continue;
            if (!loadedChar(*p))
            {
                loadGlyphInfo(*p);
                if (supportChar(*p))
                    addLazyLoadChar(*p);
                else if (m_fallback_font != NULL)
                {
                    if (!m_fallback_font->loadedChar(*p))
                    {
                        m_fallback_font->loadGlyphInfo(*p);
                        if (m_fallback_font->supportChar(*p))
                            m_fallback_font->addLazyLoadChar(*p);
                    }
                }
            }
        }
    }
    // ------------------------------------------------------------------------
    void updateCharactersList();
    // ------------------------------------------------------------------------
    void setFallbackFont(FontWithFace* face)        { m_fallback_font = face; }
    // ------------------------------------------------------------------------
    void setFallbackFontScale(float scale)   { m_fallback_font_scale = scale; }
 
private:
    struct GlyphInfo
    {
        GlyphInfo(unsigned int font_num = 0, unsigned int glyph_idx = 0) :
            font_number(font_num), glyph_index(glyph_idx) {}
        unsigned int font_number;
        unsigned int glyph_index;
    };
 
    FaceTTF*                     m_face_ttf;
 
    FontWithFace*                m_fallback_font;
 
    float                        m_fallback_font_scale;
 
    std::set<wchar_t>            m_new_char_holder;
 
    gui::IGUISpriteBank*         m_spritebank;
 
    unsigned int                 m_current_height;
 
    unsigned int                 m_used_width;
 
    unsigned int                 m_used_height;
 
    unsigned int                 m_face_dpi;
 
    float                        m_inverse_shaping;
    std::map<wchar_t, GlyphInfo> m_character_glyph_info_map;
 
    // ------------------------------------------------------------------------
    float getCharWidth(const FontArea& area, bool fallback, float scale) const;
    // ------------------------------------------------------------------------
    bool loadedChar(wchar_t c) const
    {
        std::map<wchar_t, GlyphInfo>::const_iterator n =
            m_character_glyph_info_map.find(c);
        if (n != m_character_glyph_info_map.end())
            return true;
        return false;
    }
    // ------------------------------------------------------------------------
    const GlyphInfo& getGlyphInfo(wchar_t c) const
    {
        std::map<wchar_t, GlyphInfo>::const_iterator n =
            m_character_glyph_info_map.find(c);
        // Make sure we always find GlyphInfo
        assert(n != m_character_glyph_info_map.end());
        return n->second;
    }
    // ------------------------------------------------------------------------
    bool supportChar(wchar_t c)
    {
        std::map<wchar_t, GlyphInfo>::const_iterator n =
            m_character_glyph_info_map.find(c);
        if (n != m_character_glyph_info_map.end())
        {
            return n->second.glyph_index > 0;
        }
        return false;
    }
    // ------------------------------------------------------------------------
    void loadGlyphInfo(wchar_t c);
    // ------------------------------------------------------------------------
    void createNewGlyphPage();
    // ------------------------------------------------------------------------
    void addLazyLoadChar(wchar_t c)            { m_new_char_holder.insert(c); }
    // ------------------------------------------------------------------------
    virtual bool supportLazyLoadChar() const                   { return true; }
    // ------------------------------------------------------------------------
    virtual unsigned int getGlyphPageSize() const = 0;
    // ------------------------------------------------------------------------
    virtual float getScalingFactorOne() const = 0;
    // ------------------------------------------------------------------------
    virtual unsigned int getScalingFactorTwo() const = 0;
    // ------------------------------------------------------------------------
    virtual bool isBold() const                               { return false; }
    // ------------------------------------------------------------------------
    const FontArea* getUnknownFontArea() const;
    // ------------------------------------------------------------------------
    std::vector<gui::GlyphLayout> text2GlyphsWithoutShaping(
                                                       const core::stringw& t);
    // ------------------------------------------------------------------------
#ifndef SERVER_ONLY
    virtual int shapeOutline(FT_Outline* outline) const           { return 0; }
#endif
 
public:
    LEAK_CHECK()
    // ------------------------------------------------------------------------
    FontWithFace(const std::string& name);
    // ------------------------------------------------------------------------
    virtual ~FontWithFace();
    // ------------------------------------------------------------------------
    virtual void init();
    // ------------------------------------------------------------------------
    virtual void reset();
    // ------------------------------------------------------------------------
    virtual core::dimension2d<u32> getDimension(const core::stringw& text,
                                           FontSettings* font_settings = NULL);
    // ------------------------------------------------------------------------
    int getCharacterFromPos(const wchar_t* text, int pixel_x,
                            FontSettings* font_settings = NULL) const;
    // ------------------------------------------------------------------------
    void render(const std::vector<gui::GlyphLayout>& gl,
                const core::rect<s32>& position, const video::SColor& color,
                bool hcenter, bool vcenter, const core::rect<s32>* clip,
                FontSettings* font_settings,
                FontCharCollector* char_collector = NULL);
    // ------------------------------------------------------------------------
    virtual void drawText(const core::stringw& text,
                          const core::rect<s32>& position,
                          const video::SColor& color, bool hcenter,
                          bool vcenter, const core::rect<s32>* clip,
                          FontSettings* font_settings,
                          FontCharCollector* char_collector = NULL);
    // ------------------------------------------------------------------------
    void drawTextQuick(const core::stringw& text,
                       const core::rect<s32>& position,
                       const video::SColor& color, bool hcenter, bool vcenter,
                       const core::rect<s32>* clip,
                       FontSettings* font_settings,
                       FontCharCollector* char_collector = NULL);
    // ------------------------------------------------------------------------
    void dumpGlyphPage(const std::string& name);
    // ------------------------------------------------------------------------
    void dumpGlyphPage();
    // ------------------------------------------------------------------------
    gui::IGUISpriteBank* getSpriteBank() const         { return m_spritebank; }
    // ------------------------------------------------------------------------
    const FontArea& getAreaFromCharacter(const wchar_t c,
                                         bool* fallback_font) const;
    // ------------------------------------------------------------------------
    unsigned int getDPI() const                          { return m_face_dpi; }
    // ------------------------------------------------------------------------
    FaceTTF* getFaceTTF() const                          { return m_face_ttf; }
    // ------------------------------------------------------------------------
    void insertGlyph(unsigned font_number, unsigned glyph_index);
    // ------------------------------------------------------------------------
    int getFontMaxHeight() const                  { return m_font_max_height; }
    // ------------------------------------------------------------------------
    int getGlyphMaxHeight() const                { return m_glyph_max_height; }
    // ------------------------------------------------------------------------
    virtual bool disableTextShaping() const                   { return false; }
    // ------------------------------------------------------------------------
    float getInverseShaping() const               { return m_inverse_shaping; }
    // ------------------------------------------------------------------------
    virtual bool useColorGlyphPage() const                    { return false; }
    // ------------------------------------------------------------------------
    void setDPI();
};   // FontWithFace
 
#endif
/* EOF */