CGUITTFont.h

Go to the documentation of this file.

/*
   CGUITTFont FreeType class for Irrlicht
   Copyright (c) 2009-2010 John Norman
   Copyright (c) 2016 Nathanaël Courant
 
   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.
 
   The original version of this class can be located at:
   http://irrlicht.suckerfreegames.com/
 
   John Norman
   john@suckerfreegames.com
*/
 
#pragma once
 
#include <irrlicht.h>
#include <ft2build.h>
#include <vector>
#include "irrUString.h"
#include "util/enriched_string.h"
#include FT_FREETYPE_H
 
namespace irr
{
namespace gui
{
    struct SGUITTFace;
    class CGUITTFont;
 
    class CGUITTAssistDelete
    {
        public:
            template <class T, typename TAlloc>
            static void Delete(core::array<T, TAlloc>& a)
            {
                TAlloc allocator;
                allocator.deallocate(a.pointer());
            }
    };
 
    struct SGUITTGlyph
    {
        SGUITTGlyph() : isLoaded(false), glyph_page(0), surface(0), parent(0) {}
 
        ~SGUITTGlyph() { unload(); }
 
        void preload(u32 char_index, FT_Face face, video::IVideoDriver* driver, u32 font_size, const FT_Int32 loadFlags);
 
        void unload();
 
        video::IImage* createGlyphImage(const FT_Bitmap& bits, video::IVideoDriver* driver) const;
 
        bool isLoaded;
 
        u32 glyph_page;
 
        core::recti source_rect;
 
        core::vector2di offset;
 
        FT_Vector advance;
 
        mutable video::IImage* surface;
 
        CGUITTFont* parent;
    };
 
    class CGUITTGlyphPage
    {
        public:
            CGUITTGlyphPage(video::IVideoDriver* Driver, const io::path& texture_name) :texture(0), available_slots(0), used_slots(0), dirty(false), driver(Driver), name(texture_name) {}
            ~CGUITTGlyphPage()
            {
                if (texture)
                {
                    if (driver)
                        driver->removeTexture(texture);
                    else texture->drop();
                }
            }
 
            bool createPageTexture(const u8& pixel_mode, const core::dimension2du& texture_size)
            {
                if( texture )
                    return false;
 
                bool flgmip = driver->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
                driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
#if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR > 8
                bool flgcpy = driver->getTextureCreationFlag(video::ETCF_ALLOW_MEMORY_COPY);
                driver->setTextureCreationFlag(video::ETCF_ALLOW_MEMORY_COPY, true);
#endif
 
                // Set the texture color format.
                switch (pixel_mode)
                {
                    case FT_PIXEL_MODE_MONO:
                        texture = driver->addTexture(texture_size, name, video::ECF_A1R5G5B5);
                        break;
                    case FT_PIXEL_MODE_GRAY:
                    default:
                        texture = driver->addTexture(texture_size, name, video::ECF_A8R8G8B8);
                        break;
                }
 
                // Restore our texture creation flags.
                driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, flgmip);
#if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR > 8
                driver->setTextureCreationFlag(video::ETCF_ALLOW_MEMORY_COPY, flgcpy);
#endif
                return texture ? true : false;
            }
 
            void pushGlyphToBePaged(const SGUITTGlyph* glyph)
            {
                glyph_to_be_paged.push_back(glyph);
            }
 
            void updateTexture()
            {
                if (!dirty) return;
 
                void* ptr = texture->lock();
                video::ECOLOR_FORMAT format = texture->getColorFormat();
                core::dimension2du size = texture->getOriginalSize();
                video::IImage* pageholder = driver->createImageFromData(format, size, ptr, true, false);
 
                for (u32 i = 0; i < glyph_to_be_paged.size(); ++i)
                {
                    const SGUITTGlyph* glyph = glyph_to_be_paged[i];
                    if (glyph && glyph->isLoaded)
                    {
                        if (glyph->surface)
                        {
                            glyph->surface->copyTo(pageholder, glyph->source_rect.UpperLeftCorner);
                            glyph->surface->drop();
                            glyph->surface = 0;
                        }
                        else
                        {
                            ; // TODO: add error message?
                            //currently, if we failed to create the image, just ignore this operation.
                        }
                    }
                }
 
                pageholder->drop();
                texture->unlock();
                glyph_to_be_paged.clear();
                dirty = false;
            }
 
            video::ITexture* texture;
            u32 available_slots;
            u32 used_slots;
            bool dirty;
 
            core::array<core::vector2di> render_positions;
            core::array<core::recti> render_source_rects;
 
        private:
            core::array<const SGUITTGlyph*> glyph_to_be_paged;
            video::IVideoDriver* driver;
            io::path name;
    };
 
    class CGUITTFont : public IGUIFont
    {
        public:
            static CGUITTFont* createTTFont(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true, const u32 shadow = 0, const u32 shadow_alpha = 255);
            static CGUITTFont* createTTFont(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
            static CGUITTFont* create(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
            static CGUITTFont* create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
 
            virtual ~CGUITTFont();
 
            virtual void setBatchLoadSize(u32 batch_size) { batch_load_size = batch_size; }
 
            virtual void setMaxPageTextureSize(const core::dimension2du& texture_size) { max_page_texture_size = texture_size; }
 
            virtual u32 getFontSize() const { return size; }
 
            virtual bool isTransparent() const { return use_transparency; }
 
            virtual bool useAutoHinting() const { return use_auto_hinting; }
 
            virtual bool useHinting()    const { return use_hinting; }
 
            virtual bool useMonochrome()  const { return use_monochrome; }
 
            virtual void setTransparency(const bool flag);
 
            virtual void setMonochrome(const bool flag);
 
            virtual void setFontHinting(const bool enable, const bool enable_auto_hinting = true);
 
            virtual void draw(const core::stringw& text, const core::rect<s32>& position,
                video::SColor color, bool hcenter=false, bool vcenter=false,
                const core::rect<s32>* clip=0);
 
            virtual void draw(const EnrichedString& text, const core::rect<s32>& position,
                video::SColor color, bool hcenter=false, bool vcenter=false,
                const core::rect<s32>* clip=0);
 
            virtual core::dimension2d<u32> getCharDimension(const wchar_t ch) const;
 
            virtual core::dimension2d<u32> getDimension(const wchar_t* text) const;
            virtual core::dimension2d<u32> getDimension(const core::ustring& text) const;
 
            virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const;
            virtual s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const;
 
            virtual void setKerningWidth(s32 kerning);
 
            virtual void setKerningHeight(s32 kerning);
 
            virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const;
            virtual s32 getKerningWidth(const uchar32_t thisLetter=0, const uchar32_t previousLetter=0) const;
 
            virtual s32 getKerningHeight() const;
 
            virtual void setInvisibleCharacters(const wchar_t *s);
            virtual void setInvisibleCharacters(const core::ustring& s);
 
            CGUITTGlyphPage* getLastGlyphPage() const;
 
            //should be better typed. fix later.
            CGUITTGlyphPage* createGlyphPage(const u8& pixel_mode);
 
            u32 getLastGlyphPageIndex() const { return Glyph_Pages.size() - 1; }
 
            virtual video::IImage* createTextureFromChar(const uchar32_t& ch);
 
            virtual video::ITexture* getPageTextureByIndex(const u32& page_index) const;
 
            virtual core::array<scene::ISceneNode*> addTextSceneNode
                (const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent = 0,
                 const video::SColor& color = video::SColor(255, 0, 0, 0), bool center = false );
 
            inline s32 getAscender() const { return font_metrics.ascender; }
 
        protected:
            bool use_monochrome;
            bool use_transparency;
            bool use_hinting;
            bool use_auto_hinting;
            u32 size;
            u32 batch_load_size;
            core::dimension2du max_page_texture_size;
 
        private:
            // Manages the FreeType library.
            static FT_Library c_library;
            static core::map<io::path, SGUITTFace*> c_faces;
            static bool c_libraryLoaded;
            static scene::IMesh* shared_plane_ptr_;
            static scene::SMesh  shared_plane_;
 
            CGUITTFont(IGUIEnvironment *env);
            bool load(const io::path& filename, const u32 size, const bool antialias, const bool transparency);
            void reset_images();
            void update_glyph_pages() const;
            void update_load_flags()
            {
                // Set up our loading flags.
                load_flags = FT_LOAD_DEFAULT | FT_LOAD_RENDER;
                if (!useHinting()) load_flags |= FT_LOAD_NO_HINTING;
                if (!useAutoHinting()) load_flags |= FT_LOAD_NO_AUTOHINT;
                if (useMonochrome()) load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO;
                else load_flags |= FT_LOAD_TARGET_NORMAL;
            }
            u32 getWidthFromCharacter(wchar_t c) const;
            u32 getWidthFromCharacter(uchar32_t c) const;
            u32 getHeightFromCharacter(wchar_t c) const;
            u32 getHeightFromCharacter(uchar32_t c) const;
            u32 getGlyphIndexByChar(wchar_t c) const;
            u32 getGlyphIndexByChar(uchar32_t c) const;
            core::vector2di getKerning(const wchar_t thisLetter, const wchar_t previousLetter) const;
            core::vector2di getKerning(const uchar32_t thisLetter, const uchar32_t previousLetter) const;
            core::dimension2d<u32> getDimensionUntilEndOfLine(const wchar_t* p) const;
 
            void createSharedPlane();
 
            irr::IrrlichtDevice* Device;
            gui::IGUIEnvironment* Environment;
            video::IVideoDriver* Driver;
            io::path filename;
            FT_Face tt_face;
            FT_Size_Metrics font_metrics;
            FT_Int32 load_flags;
 
            mutable core::array<CGUITTGlyphPage*> Glyph_Pages;
            mutable core::array<SGUITTGlyph> Glyphs;
 
            s32 GlobalKerningWidth;
            s32 GlobalKerningHeight;
            core::ustring Invisible;
            u32 shadow_offset;
            u32 shadow_alpha;
    };
 
} // end namespace gui
} // end namespace irr