Render: Bitmap fonts #1258

engine/includes/components/textrender.h

@@ -44,6 +44,9 @@ class ENGINE_EXPORT TextRender : public Renderable {
     Vector4 color() const;
     void setColor(const Vector4 &color);
 
+    bool translated() const;
+    void setTranslated(bool enable);
+
     bool wordWrap() const;
     void setWordWrap(bool wrap);
 
@@ -54,7 +57,7 @@ class ENGINE_EXPORT TextRender : public Renderable {
     void setAlign(int alignment);
 
     bool kerning() const;
-    void setKerning(const bool kerning);
+    void setKerning(const bool enable);
 
     int layer() const;
     void setLayer(int layer);
@@ -93,16 +96,16 @@ class ENGINE_EXPORT TextRender : public Renderable {
 
     int m_priority;
 
-    float m_fontWeight;
-
-    bool m_kerning;
+    int m_flags;
 
-    bool m_wrap;
+    float m_fontWeight;
 
     bool m_dirtyMesh;
 
     bool m_dirtyMaterial;
 
+    bool m_translated;
+
 };
 
 #endif // TEXTRENDER_H

engine/includes/resources/font.h

@@ -15,73 +15,75 @@ enum Alignment {
 
 class Mesh;
 class Texture;
+class AtlasNode;
 
 class ENGINE_EXPORT Font : public Resource {
     A_OBJECT(Font, Resource, Resources)
 
     A_NOPROPERTIES()
-    A_METHODS(
-        A_METHOD(int, Font::atlasIndex),
-        A_METHOD(int, Font::requestKerning),
-        A_METHOD(void, Font::requestCharacters),
-        A_METHOD(int, Font::length),
-        A_METHOD(float, Font::spaceWidth),
-        A_METHOD(float, Font::lineHeight)
-    )
+    A_NOMETHODS()
 
-public:
-    Font();
-    ~Font();
+    struct GlyphData {
+        Vector3Vector vertices;
 
-    Texture *page(int index = 0);
+        Vector2Vector uvs;
 
-    int atlasIndex(int glyph) const;
+        IndexVector indices;
 
-    int requestKerning(int glyph, int previous) const;
+        ByteArray data;
 
-    void requestCharacters(const TString &characters);
+        AtlasNode *node = nullptr;
 
-    int length(const TString &characters) const;
+        int width = 0;
 
-    float spaceWidth() const;
+        int height = 0;
 
-    float lineHeight() const;
+        bool copied = false;
 
-    float textWidth(const TString &text, int size, bool kerning);
+    };
 
-    void composeMesh(Mesh *mesh, const TString &text, int size, int alignment, bool kerning, bool wrap, const Vector2 &boundaries);
+    enum Flags {
+        Kerning = (1<<0),
+        Wrap = (1<<1),
+        Sdf = (1<<2)
+    };
 
-    void loadUserData(const VariantMap &data) override;
+public:
+    Font();
+    ~Font();
+
+    Texture *page();
+
+    float textWidth(const TString &text, int size, int flags);
+
+    void composeMesh(Mesh *mesh, const TString &text, int size, int alignment, int flags, const Vector2 &boundaries);
 
 private:
     void clear();
 
-    Mesh *shape(int key) const;
+    void clearAtlas();
 
-    int addElement(Texture *texture);
+    void requestCharacters(const std::u32string &characters, uint32_t size);
 
-    void packSheets(int padding);
+    int requestKerning(int glyph, int previous) const;
 
-    void addPage(Texture *texture);
+    GlyphData *glyph(int key);
+
+    void packSheets(int padding);
 
-protected:
     VariantMap saveUserData() const override;
+    void loadUserData(const VariantMap &data) override;
 
 private:
-    std::unordered_map<uint32_t, uint32_t> m_glyphMap;
-    std::unordered_map<uint32_t, Mesh *> m_shapes;
-
-    std::vector<Texture *> m_pages;
-    std::vector<Texture *> m_sources;
+    std::unordered_map<uint32_t, GlyphData> m_shapes;
 
     ByteArray m_data;
 
     int32_t *m_face;
 
-    int32_t m_scale;
+    Texture *m_page;
 
-    float m_spaceWidth;
-    float m_lineHeight;
+    AtlasNode *m_root;
 
     bool m_useKerning;
 

engine/src/components/textrender.cpp

@@ -29,10 +29,10 @@ TextRender::TextRender() :
         m_alignment(Left),
         m_priority(0),
         m_fontWeight(0.5f),
-        m_kerning(true),
-        m_wrap(false),
+        m_flags(Font::Kerning | Font::Sdf),
         m_dirtyMesh(true),
-        m_dirtyMaterial(true) {
+        m_dirtyMaterial(true),
+        m_translated(false) {
 
     m_mesh->makeDynamic();
 
@@ -56,8 +56,8 @@ TextRender::~TextRender() {
 Mesh *TextRender::meshToDraw(int instance) {
     A_UNUSED(instance);
     if(m_dirtyMesh && m_font && !m_text.isEmpty()) {
-        m_font->composeMesh(m_mesh, m_text, m_size, m_alignment, m_kerning, m_wrap, m_boundaries);
-
+        m_font->composeMesh(m_mesh, m_translated ?  Engine::translate(m_text) : m_text, m_size, m_alignment, m_flags, m_boundaries);
+        m_mesh->setColors(Vector4Vector(m_mesh->vertices().size(), Vector4(1.0f)));
         m_dirtyMesh = false;
     }
 
@@ -139,17 +139,38 @@ void TextRender::setColor(const Vector4 &color) {
     m_color = color;
     m_dirtyMaterial = true;
 }
+/*!
+    Returns true if text in text render must be translated; othewise returns false.
+*/
+bool TextRender::translated() const {
+    return m_translated;
+}
+/*!
+    Sets \a enable or disable translation from dictionary for current text render.
+*/
+void TextRender::setTranslated(bool enable) {
+    if(m_translated != enable) {
+        m_translated = enable;
+        m_dirtyMesh = true;
+    }
+}
 /*!
     Returns true if word wrap enabled; otherwise returns false.
 */
 bool TextRender::wordWrap() const {
-    return m_wrap;
+    return m_flags & Font::Wrap;
 }
 /*!
     Sets the word \a wrap policy. Set true to enable word wrap and false to disable.
 */
 void TextRender::setWordWrap(bool wrap) {
-    m_wrap = wrap;
+    if(wordWrap() != wrap) {
+        if(wrap) {
+            m_flags |= Font::Wrap;
+        } else {
+            m_flags &= ~Font::Wrap;
+        }
+    }
     m_dirtyMesh = true;
 }
 /*!
@@ -182,15 +203,19 @@ void TextRender::setAlign(int alignment) {
     Returns true if glyph kerning enabled; otherwise returns false.
 */
 bool TextRender::kerning() const {
-    return m_kerning;
+    return m_flags & Font::Kerning;
 }
 /*!
-    Set true to enable glyph \a kerning and false to disable.
+    Set true to \a enable glyph kerning and false to disable.
     \note Glyph kerning functionality depends on fonts which you are using. In case of font doesn't support kerning, you will not see the difference.
 */
-void TextRender::setKerning(const bool kerning) {
-    if(m_kerning != kerning) {
-        m_kerning = kerning;
+void TextRender::setKerning(const bool enable) {
+    if(kerning() != enable) {
+        if(enable) {
+            m_flags |= Font::Kerning;
+        } else {
+            m_flags &= ~Font::Kerning;
+        }
         m_dirtyMesh = true;
     }
 }

engine/src/editor/converters/fontconverter.cpp

@@ -46,8 +46,6 @@ AssetConverter::ReturnCode FontConverter::convertFile(AssetConverterSettings *se
         map[gData] = src.readAll();
         src.close();
 
-        font->loadUserData(map);
-
         return settings->saveBinary(Engine::toVariant(font), settings->absoluteDestination());
     }
     return InternalError;