DistanceFieldFont.hpp

Go to the documentation of this file.

#pragma once

#include <ewol/resource/font/FontBase.hpp>
#include <ewol/resource/Texture.hpp>
#include <ewol/resource/TexturedFont.hpp>

namespace ewol {
    namespace resource {
        class DistanceFieldFont : public ewol::resource::Texture {
            private:
                std::string m_fileName;
                float m_sizeRatio;
                // specific element to have the the know if the specify element is known...
                //  == > otherwise I can just generate italic ...
                //  == > Bold is a little more complicated (maybe with the bordersize)
                ememory::SharedPtr<ewol::resource::FontBase> m_font;
            public:
                std::vector<GlyphProperty> m_listElement;
            private:
                // for the texture generation :
                ivec2 m_lastGlyphPos;
                int32_t m_lastRawHeigh;
            protected:
                DistanceFieldFont();
                void init(const std::string& _fontName);
            public:
                DECLARE_RESOURCE_NAMED_FACTORY(DistanceFieldFont);
                virtual ~DistanceFieldFont();
            public:
                float getDisplayRatio(float _size);
                float getHeight(float _size) {
                    return ((float)m_font->getHeight(_size));
                };
                float getSize(float _fontHeight) {
                    return m_font->getSizeWithHeight(_fontHeight);
                }
                int32_t getIndex(char32_t _charcode);
                ewol::GlyphProperty* getGlyphPointer(const char32_t& _charcode);
            public:
                static ememory::SharedPtr<ewol::resource::DistanceFieldFont> keep(const std::string& _filename);
            private:
                bool addGlyph(const char32_t& _val);
                
                void generateDistanceField(const egami::ImageMono& _input, egami::Image& _output);
            private:
                float m_borderSize; 
                vec2 m_textureBorderSize; 
            public:
                float getPixelBorderSize() {
                    return m_borderSize;
                }
                const vec2& getTextureBorderSize() {
                    return m_textureBorderSize;
                }
            public:
                void exportOnFile();
                bool importFromFile();
        };
    };
};