src/irrlicht_changes/CGUITTFont.h

   1 /*
   2    CGUITTFont FreeType class for Irrlicht
   3    Copyright (c) 2009-2010 John Norman
   4    Copyright (c) 2016 Nathanaël Courant
   5
   6    This software is provided 'as-is', without any express or implied
   7    warranty. In no event will the authors be held liable for any
   8    damages arising from the use of this software.
   9
  10    Permission is granted to anyone to use this software for any
  11    purpose, including commercial applications, and to alter it and
  12    redistribute it freely, subject to the following restrictions:
  13
  14    1. The origin of this software must not be misrepresented; you
  15       must not claim that you wrote the original software. If you use
  16       this software in a product, an acknowledgment in the product
  17       documentation would be appreciated but is not required.
  18
  19    2. Altered source versions must be plainly marked as such, and
  20       must not be misrepresented as being the original software.
  21
  22    3. This notice may not be removed or altered from any source
  23       distribution.
  24
  25    The original version of this class can be located at:
  26    http://irrlicht.suckerfreegames.com/
  27
  28    John Norman
  29    john@suckerfreegames.com
  30 */
  31
  32 #pragma once
  33
  34 #include <irrlicht.h>
  35 #include <ft2build.h>
  36 #include <vector>
  37 #include "irrUString.h"
  38 #include "util/enriched_string.h"
  39 #include FT_FREETYPE_H
  40
  41 namespace irr
  42 {
  43 namespace gui
  44 {
  45         struct SGUITTFace;
  46         class CGUITTFont;
  47
  48         //! Class to assist in deleting glyphs.
  49         class CGUITTAssistDelete
  50         {
  51                 public:
  52                         template <class T, typename TAlloc>
  53                         static void Delete(core::array<T, TAlloc>& a)
  54                         {
  55                                 TAlloc allocator;
  56                                 allocator.deallocate(a.pointer());
  57                         }
  58         };
  59
  60         //! Structure representing a single TrueType glyph.
  61         struct SGUITTGlyph
  62         {
  63                 //! Constructor.
  64                 SGUITTGlyph() : isLoaded(false), glyph_page(0), surface(0), parent(0) {}
  65
  66                 //! Destructor.
  67                 ~SGUITTGlyph() { unload(); }
  68
  69                 //! Preload the glyph.
  70                 //!     The preload process occurs when the program tries to cache the glyph from FT_Library.
  71                 //! However, it simply defines the SGUITTGlyph's properties and will only create the page
  72                 //! textures if necessary.  The actual creation of the textures should only occur right
  73                 //! before the batch draw call.
  74                 void preload(u32 char_index, FT_Face face, video::IVideoDriver* driver, u32 font_size, const FT_Int32 loadFlags);
  75
  76                 //! Unloads the glyph.
  77                 void unload();
  78
  79                 //! Creates the IImage object from the FT_Bitmap.
  80                 video::IImage* createGlyphImage(const FT_Bitmap& bits, video::IVideoDriver* driver) const;
  81
  82                 //! If true, the glyph has been loaded.
  83                 bool isLoaded;
  84
  85                 //! The page the glyph is on.
  86                 u32 glyph_page;
  87
  88                 //! The source rectangle for the glyph.
  89                 core::recti source_rect;
  90
  91                 //! The offset of glyph when drawn.
  92                 core::vector2di offset;
  93
  94                 //! Glyph advance information.
  95                 FT_Vector advance;
  96
  97                 //! This is just the temporary image holder.  After this glyph is paged,
  98                 //! it will be dropped.
  99                 mutable video::IImage* surface;
 100
 101                 //! The pointer pointing to the parent (CGUITTFont)
 102                 CGUITTFont* parent;
 103         };
 104
 105         //! Holds a sheet of glyphs.
 106         class CGUITTGlyphPage
 107         {
 108                 public:
 109                         CGUITTGlyphPage(video::IVideoDriver* Driver, const io::path& texture_name) :texture(0), available_slots(0), used_slots(0), dirty(false), driver(Driver), name(texture_name) {}
 110                         ~CGUITTGlyphPage()
 111                         {
 112                                 if (texture)
 113                                 {
 114                                         if (driver)
 115                                                 driver->removeTexture(texture);
 116                                         else texture->drop();
 117                                 }
 118                         }
 119
 120                         //! Create the actual page texture,
 121                         bool createPageTexture(const u8& pixel_mode, const core::dimension2du& texture_size)
 122                         {
 123                                 if( texture )
 124                                         return false;
 125
 126                                 bool flgmip = driver->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
 127                                 driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
 128 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR > 8
 129                                 bool flgcpy = driver->getTextureCreationFlag(video::ETCF_ALLOW_MEMORY_COPY);
 130                                 driver->setTextureCreationFlag(video::ETCF_ALLOW_MEMORY_COPY, true);
 131 #endif
 132
 133                                 // Set the texture color format.
 134                                 switch (pixel_mode)
 135                                 {
 136                                         case FT_PIXEL_MODE_MONO:
 137                                                 texture = driver->addTexture(texture_size, name, video::ECF_A1R5G5B5);
 138                                                 break;
 139                                         case FT_PIXEL_MODE_GRAY:
 140                                         default:
 141                                                 texture = driver->addTexture(texture_size, name, video::ECF_A8R8G8B8);
 142                                                 break;
 143                                 }
 144
 145                                 // Restore our texture creation flags.
 146                                 driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, flgmip);
 147 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR > 8
 148                                 driver->setTextureCreationFlag(video::ETCF_ALLOW_MEMORY_COPY, flgcpy);
 149 #endif
 150                                 return texture ? true : false;
 151                         }
 152
 153                         //! Add the glyph to a list of glyphs to be paged.
 154                         //! This collection will be cleared after updateTexture is called.
 155                         void pushGlyphToBePaged(const SGUITTGlyph* glyph)
 156                         {
 157                                 glyph_to_be_paged.push_back(glyph);
 158                         }
 159
 160                         //! Updates the texture atlas with new glyphs.
 161                         void updateTexture()
 162                         {
 163                                 if (!dirty) return;
 164
 165                                 void* ptr = texture->lock();
 166                                 video::ECOLOR_FORMAT format = texture->getColorFormat();
 167                                 core::dimension2du size = texture->getOriginalSize();
 168                                 video::IImage* pageholder = driver->createImageFromData(format, size, ptr, true, false);
 169
 170                                 for (u32 i = 0; i < glyph_to_be_paged.size(); ++i)
 171                                 {
 172                                         const SGUITTGlyph* glyph = glyph_to_be_paged[i];
 173                                         if (glyph && glyph->isLoaded)
 174                                         {
 175                                                 if (glyph->surface)
 176                                                 {
 177                                                         glyph->surface->copyTo(pageholder, glyph->source_rect.UpperLeftCorner);
 178                                                         glyph->surface->drop();
 179                                                         glyph->surface = 0;
 180                                                 }
 181                                                 else
 182                                                 {
 183                                                         ; // TODO: add error message?
 184                                                         //currently, if we failed to create the image, just ignore this operation.
 185                                                 }
 186                                         }
 187                                 }
 188
 189                                 pageholder->drop();
 190                                 texture->unlock();
 191                                 glyph_to_be_paged.clear();
 192                                 dirty = false;
 193                         }
 194
 195                         video::ITexture* texture;
 196                         u32 available_slots;
 197                         u32 used_slots;
 198                         bool dirty;
 199
 200                         core::array<core::vector2di> render_positions;
 201                         core::array<core::recti> render_source_rects;
 202
 203                 private:
 204                         core::array<const SGUITTGlyph*> glyph_to_be_paged;
 205                         video::IVideoDriver* driver;
 206                         io::path name;
 207         };
 208
 209         //! Class representing a TrueType font.
 210         class CGUITTFont : public IGUIFont
 211         {
 212                 public:
 213                         //! Creates a new TrueType font and returns a pointer to it.  The pointer must be drop()'ed when finished.
 214                         //! \param env The IGUIEnvironment the font loads out of.
 215                         //! \param filename The filename of the font.
 216                         //! \param size The size of the font glyphs in pixels.  Since this is the size of the individual glyphs, the true height of the font may change depending on the characters used.
 217                         //! \param antialias set the use_monochrome (opposite to antialias) flag
 218                         //! \param transparency set the use_transparency flag
 219                         //! \return Returns a pointer to a CGUITTFont.  Will return 0 if the font failed to load.
 220                         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);
 221                         static CGUITTFont* createTTFont(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
 222                         static CGUITTFont* create(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
 223                         static CGUITTFont* create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
 224
 225                         //! Destructor
 226                         virtual ~CGUITTFont();
 227
 228                         //! Sets the amount of glyphs to batch load.
 229                         virtual void setBatchLoadSize(u32 batch_size) { batch_load_size = batch_size; }
 230
 231                         //! Sets the maximum texture size for a page of glyphs.
 232                         virtual void setMaxPageTextureSize(const core::dimension2du& texture_size) { max_page_texture_size = texture_size; }
 233
 234                         //! Get the font size.
 235                         virtual u32 getFontSize() const { return size; }
 236
 237                         //! Check the font's transparency.
 238                         virtual bool isTransparent() const { return use_transparency; }
 239
 240                         //! Check if the font auto-hinting is enabled.
 241                         //! Auto-hinting is FreeType's built-in font hinting engine.
 242                         virtual bool useAutoHinting() const { return use_auto_hinting; }
 243
 244                         //! Check if the font hinting is enabled.
 245                         virtual bool useHinting()        const { return use_hinting; }
 246
 247                         //! Check if the font is being loaded as a monochrome font.
 248                         //! The font can either be a 256 color grayscale font, or a 2 color monochrome font.
 249                         virtual bool useMonochrome()  const { return use_monochrome; }
 250
 251                         //! Tells the font to allow transparency when rendering.
 252                         //! Default: true.
 253                         //! \param flag If true, the font draws using transparency.
 254                         virtual void setTransparency(const bool flag);
 255
 256                         //! Tells the font to use monochrome rendering.
 257                         //! Default: false.
 258                         //! \param flag If true, the font draws using a monochrome image.  If false, the font uses a grayscale image.
 259                         virtual void setMonochrome(const bool flag);
 260
 261                         //! Enables or disables font hinting.
 262                         //! Default: Hinting and auto-hinting true.
 263                         //! \param enable If false, font hinting is turned off. If true, font hinting is turned on.
 264                         //! \param enable_auto_hinting If true, FreeType uses its own auto-hinting algorithm.  If false, it tries to use the algorithm specified by the font.
 265                         virtual void setFontHinting(const bool enable, const bool enable_auto_hinting = true);
 266
 267                         //! Draws some text and clips it to the specified rectangle if wanted.
 268                         virtual void draw(const core::stringw& text, const core::rect<s32>& position,
 269                                 video::SColor color, bool hcenter=false, bool vcenter=false,
 270                                 const core::rect<s32>* clip=0);
 271
 272                         virtual void draw(const EnrichedString& text, const core::rect<s32>& position,
 273                                 video::SColor color, bool hcenter=false, bool vcenter=false,
 274                                 const core::rect<s32>* clip=0);
 275
 276                         //! Returns the dimension of a character produced by this font.
 277                         virtual core::dimension2d<u32> getCharDimension(const wchar_t ch) const;
 278
 279                         //! Returns the dimension of a text string.
 280                         virtual core::dimension2d<u32> getDimension(const wchar_t* text) const;
 281                         virtual core::dimension2d<u32> getDimension(const core::ustring& text) const;
 282
 283                         //! Calculates the index of the character in the text which is on a specific position.
 284                         virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const;
 285                         virtual s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const;
 286
 287                         //! Sets global kerning width for the font.
 288                         virtual void setKerningWidth(s32 kerning);
 289
 290                         //! Sets global kerning height for the font.
 291                         virtual void setKerningHeight(s32 kerning);
 292
 293                         //! Gets kerning values (distance between letters) for the font. If no parameters are provided,
 294                         virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const;
 295                         virtual s32 getKerningWidth(const uchar32_t thisLetter=0, const uchar32_t previousLetter=0) const;
 296
 297                         //! Returns the distance between letters
 298                         virtual s32 getKerningHeight() const;
 299
 300                         //! Define which characters should not be drawn by the font.
 301                         virtual void setInvisibleCharacters(const wchar_t *s);
 302                         virtual void setInvisibleCharacters(const core::ustring& s);
 303
 304                         //! Get the last glyph page if there's still available slots.
 305                         //! If not, it will return zero.
 306                         CGUITTGlyphPage* getLastGlyphPage() const;
 307
 308                         //! Create a new glyph page texture.
 309                         //! \param pixel_mode the pixel mode defined by FT_Pixel_Mode
 310                         //should be better typed. fix later.
 311                         CGUITTGlyphPage* createGlyphPage(const u8& pixel_mode);
 312
 313                         //! Get the last glyph page's index.
 314                         u32 getLastGlyphPageIndex() const { return Glyph_Pages.size() - 1; }
 315
 316                         //! Create corresponding character's software image copy from the font,
 317                         //! so you can use this data just like any ordinary video::IImage.
 318                         //! \param ch The character you need
 319                         virtual video::IImage* createTextureFromChar(const uchar32_t& ch);
 320
 321                         //! This function is for debugging mostly. If the page doesn't exist it returns zero.
 322                         //! \param page_index Simply return the texture handle of a given page index.
 323                         virtual video::ITexture* getPageTextureByIndex(const u32& page_index) const;
 324
 325                         //! Add a list of scene nodes generated by putting font textures on the 3D planes.
 326                         virtual core::array<scene::ISceneNode*> addTextSceneNode
 327                                 (const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent = 0,
 328                                  const video::SColor& color = video::SColor(255, 0, 0, 0), bool center = false );
 329
 330                         inline s32 getAscender() const { return font_metrics.ascender; }
 331
 332                 protected:
 333                         bool use_monochrome;
 334                         bool use_transparency;
 335                         bool use_hinting;
 336                         bool use_auto_hinting;
 337                         u32 size;
 338                         u32 batch_load_size;
 339                         core::dimension2du max_page_texture_size;
 340
 341                 private:
 342                         // Manages the FreeType library.
 343                         static FT_Library c_library;
 344                         static core::map<io::path, SGUITTFace*> c_faces;
 345                         static bool c_libraryLoaded;
 346                         static scene::IMesh* shared_plane_ptr_;
 347                         static scene::SMesh  shared_plane_;
 348
 349                         CGUITTFont(IGUIEnvironment *env);
 350                         bool load(const io::path& filename, const u32 size, const bool antialias, const bool transparency);
 351                         void reset_images();
 352                         void update_glyph_pages() const;
 353                         void update_load_flags()
 354                         {
 355                                 // Set up our loading flags.
 356                                 load_flags = FT_LOAD_DEFAULT | FT_LOAD_RENDER;
 357                                 if (!useHinting()) load_flags |= FT_LOAD_NO_HINTING;
 358                                 if (!useAutoHinting()) load_flags |= FT_LOAD_NO_AUTOHINT;
 359                                 if (useMonochrome()) load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO | FT_RENDER_MODE_MONO;
 360                                 else load_flags |= FT_LOAD_TARGET_NORMAL;
 361                         }
 362                         u32 getWidthFromCharacter(wchar_t c) const;
 363                         u32 getWidthFromCharacter(uchar32_t c) const;
 364                         u32 getHeightFromCharacter(wchar_t c) const;
 365                         u32 getHeightFromCharacter(uchar32_t c) const;
 366                         u32 getGlyphIndexByChar(wchar_t c) const;
 367                         u32 getGlyphIndexByChar(uchar32_t c) const;
 368                         core::vector2di getKerning(const wchar_t thisLetter, const wchar_t previousLetter) const;
 369                         core::vector2di getKerning(const uchar32_t thisLetter, const uchar32_t previousLetter) const;
 370                         core::dimension2d<u32> getDimensionUntilEndOfLine(const wchar_t* p) const;
 371
 372                         void createSharedPlane();
 373
 374                         irr::IrrlichtDevice* Device;
 375                         gui::IGUIEnvironment* Environment;
 376                         video::IVideoDriver* Driver;
 377                         io::path filename;
 378                         FT_Face tt_face;
 379                         FT_Size_Metrics font_metrics;
 380                         FT_Int32 load_flags;
 381
 382                         mutable core::array<CGUITTGlyphPage*> Glyph_Pages;
 383                         mutable core::array<SGUITTGlyph> Glyphs;
 384
 385                         s32 GlobalKerningWidth;
 386                         s32 GlobalKerningHeight;
 387                         core::ustring Invisible;
 388                         u32 shadow_offset;
 389                         u32 shadow_alpha;
 390         };
 391
 392 } // end namespace gui
 393 } // end namespace irr