src/font.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD 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, version 2.
   4  * OpenTTD 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.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file font.h Functions to read fonts from files and cache them. */
   9
  10 #ifndef FONT_H
  11 #define FONT_H
  12
  13 #ifdef WITH_FREETYPE
  14 #include <ft2build.h>
  15 #include FT_FREETYPE_H
  16 #include FT_GLYPH_H
  17 #include FT_TRUETYPE_TABLES_H
  18 #endif /* WITH_FREETYPE */
  19
  20 #include "core/smallmap_type.hpp"
  21 #include "string.h"
  22 #include "spritecache.h"
  23
  24 /** Glyphs are characters from a font. */
  25 typedef uint32 GlyphID;
  26 static const GlyphID SPRITE_GLYPH = 1U << 30;
  27
  28 /** Font cache for basic fonts. */
  29 class FontCache {
  30 private:
  31         static FontCache cache [FS_END]; ///< All the font caches.
  32
  33         SpriteID *spriteid_map[0x100]; ///< Mapping of glyphs to sprite IDs.
  34
  35         byte glyph_widths [256 - 32]; ///< Glyph widths of all ASCII characters.
  36
  37 #ifdef WITH_FREETYPE
  38
  39         /** Container for information about a FreeType glyph. */
  40         struct GlyphEntry {
  41                 Sprite *sprite; ///< The loaded sprite.
  42                 byte width;     ///< The width of the glyph.
  43         };
  44
  45         /**
  46          * The glyph cache. This is structured to reduce memory consumption.
  47          * 1) There is a 'segment' table for each font size.
  48          * 2) Each segment table is a discrete block of characters.
  49          * 3) Each block contains 256 (aligned) characters sequential characters.
  50          *
  51          * The cache is accessed in the following way:
  52          * For character 0x0041  ('A'): sprite_map[0x00][0x41]
  53          * For character 0x20AC (Euro): sprite_map[0x20][0xAC]
  54          *
  55          * Currently only 256 segments are allocated, "limiting" us to 65536 characters.
  56          * This can be simply changed in the function GetGlyphPtr.
  57          */
  58         GlyphEntry *sprite_map[0x100];
  59
  60         const GlyphEntry *missing_sprite; ///< Sprite for missing glyphs (question mark)
  61
  62         typedef SmallMap<uint32, SmallPair<size_t, const void*> > FontTable; ///< Table with font table cache
  63
  64         FontTable font_tables; ///< Cached font tables.
  65
  66         FT_Face face;  ///< The font face associated with this font.
  67
  68 #endif /* WITH_FREETYPE */
  69
  70         const FontSize fs;                ///< The size of the font.
  71         int height;                       ///< The height of the font.
  72         int ascender;                     ///< The ascender value of the font.
  73         int descender;                    ///< The descender value of the font.
  74         int units_per_em;                 ///< The units per EM value of the font.
  75
  76         byte widest_digit;          ///< Widest digit.
  77         byte widest_digit_nonnull;  ///< Widest leading (non-null) digit.
  78         byte digit_width;           ///< Width of the widest digit.
  79
  80         void ResetFontMetrics (void);
  81         void RebuildWidthCache (void);
  82
  83         void ClearGlyphToSpriteMap (void);
  84
  85         SpriteID GetGlyphSprite (GlyphID key) const;
  86
  87 #ifdef WITH_FREETYPE
  88
  89         const GlyphEntry *GetGlyphPtr (GlyphID key);
  90
  91 #endif /* WITH_FREETYPE */
  92
  93         FontCache(FontSize fs);
  94         ~FontCache();
  95
  96 public:
  97         /**
  98          * Get the height of the font.
  99          * @return The height of the font.
 100          */
 101         inline int GetHeight() const { return this->height; }
 102
 103         /**
 104          * Get the ascender value of the font.
 105          * @return The ascender value of the font.
 106          */
 107         inline int GetAscender() const { return this->ascender; }
 108
 109         /**
 110          * Get the descender value of the font.
 111          * @return The descender value of the font.
 112          */
 113         inline int GetDescender() const{ return this->descender; }
 114
 115         /**
 116          * Get the units per EM value of the font.
 117          * @return The units per EM value of the font.
 118          */
 119         inline int GetUnitsPerEM() const { return this->units_per_em; }
 120
 121         /**
 122          * Get the SpriteID mapped to the given key
 123          * @param key The key to get the sprite for.
 124          * @return The sprite.
 125          */
 126         SpriteID GetUnicodeGlyph (WChar key) const;
 127
 128         /**
 129          * Map a SpriteID to the key
 130          * @param key The key to map to.
 131          * @param sprite The sprite that is being mapped.
 132          */
 133         void SetUnicodeGlyph (WChar key, SpriteID sprite);
 134
 135         /** Initialize the glyph map */
 136         void InitializeUnicodeGlyphMap (void);
 137
 138 #ifdef WITH_FREETYPE
 139
 140         /* Load the freetype font. */
 141         void LoadFreeTypeFont (void);
 142
 143         /* Clear the glyph cache. */
 144         void ClearGlyphCache (void);
 145
 146         /* Unload the freetype font. */
 147         void UnloadFreeTypeFont (void);
 148
 149 #endif /* WITH_FREETYPE */
 150
 151         /** Clear the font cache. */
 152         void ClearFontCache (void);
 153
 154         /**
 155          * Get the glyph (sprite) of the given key.
 156          * @param key The key to look up.
 157          * @return The sprite.
 158          */
 159         const Sprite *GetGlyph (GlyphID key);
 160
 161         /**
 162          * Get the width of the glyph with the given key.
 163          * @param key The key to look up.
 164          * @return The width.
 165          */
 166         uint GetGlyphWidth (GlyphID key);
 167
 168         /**
 169          * Do we need to draw a glyph shadow?
 170          * @return True if it has to be done, otherwise false.
 171          */
 172         bool GetDrawGlyphShadow (void) const;
 173
 174         /**
 175          * Map a character into a glyph.
 176          * @param key The character.
 177          * @return The glyph ID used to draw the character.
 178          */
 179         GlyphID MapCharToGlyph (WChar key) const;
 180
 181         /**
 182          * Get the glyph (sprite) for a given character.
 183          * @param c The character to look up.
 184          * @return The sprite.
 185          */
 186         const Sprite *GetCharGlyph (WChar c)
 187         {
 188                 return this->GetGlyph (this->MapCharToGlyph (c));
 189         }
 190
 191         /**
 192          * Read a font table from the font.
 193          * @param tag The of the table to load.
 194          * @param length The length of the read data.
 195          * @return The loaded table data.
 196          */
 197         const void *GetFontTable (uint32 tag, size_t &length);
 198
 199         /**
 200          * Get the name of this font.
 201          * @return The name of the font.
 202          */
 203         const char *GetFontName (void) const;
 204
 205         /**
 206          * Return width of character glyph.
 207          * @param size  Font of the character
 208          * @param key   Character code glyph
 209          * @return Width of the character glyph
 210          */
 211         byte GetCharacterWidth (WChar key)
 212         {
 213                 /* Use cache if possible */
 214                 if (key >= 32 && key < 256) return this->glyph_widths [key - 32];
 215
 216                 return this->GetGlyphWidth (this->MapCharToGlyph (key));
 217         }
 218
 219         /**
 220          * Return the maximum width of single digit.
 221          * @param size  Font of the digit
 222          * @return Width of the digit.
 223          */
 224         byte GetDigitWidth (void) const
 225         {
 226                 return this->digit_width;
 227         }
 228
 229         /* Compute the broadest n-digit value in a given font size. */
 230         uint64 GetBroadestValue (uint n) const;
 231
 232         /**
 233          * Get the font cache of a given font size.
 234          * @param fs The font size to look up.
 235          * @return The font cache.
 236          */
 237         static inline FontCache *Get(FontSize fs)
 238         {
 239                 assert(fs < FS_END);
 240                 return &FontCache::cache[fs];
 241         }
 242 };
 243
 244 /** Initialize the glyph map */
 245 static inline void InitializeUnicodeGlyphMap()
 246 {
 247         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 248                 FontCache::Get(fs)->InitializeUnicodeGlyphMap();
 249         }
 250 }
 251
 252 static inline void ClearFontCache()
 253 {
 254         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 255                 FontCache::Get(fs)->ClearFontCache();
 256         }
 257 }
 258
 259 /**
 260  * Return the maximum width of single digit.
 261  * @param size  Font of the digit
 262  * @return Width of the digit.
 263  */
 264 static inline byte GetDigitWidth (FontSize size = FS_NORMAL)
 265 {
 266         return FontCache::Get(size)->GetDigitWidth();
 267 }
 268
 269 #ifdef WITH_FREETYPE
 270
 271 /** Settings for a single freetype font. */
 272 struct FreeTypeSubSetting {
 273         char font[MAX_PATH]; ///< The name of the font, or path to the font.
 274         uint size;           ///< The (requested) size of the font.
 275         bool aa;             ///< Whether to do anti aliasing or not.
 276 };
 277
 278 /** Settings for the freetype fonts. */
 279 struct FreeTypeSettings {
 280         FreeTypeSubSetting small;  ///< The smallest font; mostly used for zoomed out view.
 281         FreeTypeSubSetting medium; ///< The normal font size.
 282         FreeTypeSubSetting large;  ///< The largest font; mostly used for newspapers.
 283         FreeTypeSubSetting mono;   ///< The mono space font used for license/readme viewers.
 284 };
 285
 286 extern FreeTypeSettings _freetype;
 287
 288 void InitFreeType(bool monospace);
 289
 290 /**
 291  * We would like to have a fallback font as the current one
 292  * doesn't contain all characters we need.
 293  * This function must set all fonts of settings.
 294  * @param settings the settings to overwrite the fontname of.
 295  * @param language_isocode the language, e.g. en_GB.
 296  * @param winlangid the language ID windows style.
 297  * @param callback The function to call to check for missing glyphs.
 298  * @return true if a font has been set, false otherwise.
 299  */
 300 bool SetFallbackFont (FreeTypeSettings *settings, const char *language_isocode, int winlangid, class MissingGlyphSearcher *callback);
 301
 302 #else /* WITH_FREETYPE */
 303
 304 static inline void InitFreeType (bool monospace)
 305 {
 306 }
 307
 308 #endif /* WITH_FREETYPE */
 309
 310 #endif /* FONT_H */