src/fontcache.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 fontcache.h Functions to read fonts from files and cache them. */
   9
  10 #ifndef FONTCACHE_H
  11 #define FONTCACHE_H
  12
  13 #include "string_type.h"
  14 #include "spritecache.h"
  15
  16 /** Glyphs are characters from a font. */
  17 typedef uint32 GlyphID;
  18 static const GlyphID SPRITE_GLYPH = 1U << 30;
  19
  20 /** Font cache for basic fonts. */
  21 class FontCache {
  22 private:
  23         static FontCache *caches[FS_END]; ///< All the font caches.
  24 protected:
  25         FontCache *parent;                ///< The parent of this font cache.
  26         const FontSize fs;                ///< The size of the font.
  27         int height;                       ///< The height of the font.
  28         int ascender;                     ///< The ascender value of the font.
  29         int descender;                    ///< The descender value of the font.
  30         int units_per_em;                 ///< The units per EM value of the font.
  31 public:
  32         FontCache(FontSize fs);
  33         virtual ~FontCache();
  34
  35         /**
  36          * Get the FontSize of the font.
  37          * @return The FontSize.
  38          */
  39         inline FontSize GetSize() const { return this->fs; }
  40
  41         /**
  42          * Get the height of the font.
  43          * @return The height of the font.
  44          */
  45         virtual int GetHeight() const { return this->height; }
  46
  47         /**
  48          * Get the ascender value of the font.
  49          * @return The ascender value of the font.
  50          */
  51         inline int GetAscender() const { return this->ascender; }
  52
  53         /**
  54          * Get the descender value of the font.
  55          * @return The descender value of the font.
  56          */
  57         inline int GetDescender() const{ return this->descender; }
  58
  59         /**
  60          * Get the units per EM value of the font.
  61          * @return The units per EM value of the font.
  62          */
  63         inline int GetUnitsPerEM() const { return this->units_per_em; }
  64
  65         /**
  66          * Get the nominal font size of the font.
  67          * @return The nominal font size.
  68          */
  69         virtual int GetFontSize() const { return this->height; }
  70
  71         /**
  72          * Get the SpriteID mapped to the given key
  73          * @param key The key to get the sprite for.
  74          * @return The sprite.
  75          */
  76         virtual SpriteID GetUnicodeGlyph(WChar key) = 0;
  77
  78         /**
  79          * Map a SpriteID to the key
  80          * @param key The key to map to.
  81          * @param sprite The sprite that is being mapped.
  82          */
  83         virtual void SetUnicodeGlyph(WChar key, SpriteID sprite) = 0;
  84
  85         /** Initialize the glyph map */
  86         virtual void InitializeUnicodeGlyphMap() = 0;
  87
  88         /** Clear the font cache. */
  89         virtual void ClearFontCache() = 0;
  90
  91         /**
  92          * Get the glyph (sprite) of the given key.
  93          * @param key The key to look up.
  94          * @return The sprite.
  95          */
  96         virtual const Sprite *GetGlyph(GlyphID key) = 0;
  97
  98         /**
  99          * Get the width of the glyph with the given key.
 100          * @param key The key to look up.
 101          * @return The width.
 102          */
 103         virtual uint GetGlyphWidth(GlyphID key) = 0;
 104
 105         /**
 106          * Do we need to draw a glyph shadow?
 107          * @return True if it has to be done, otherwise false.
 108          */
 109         virtual bool GetDrawGlyphShadow() = 0;
 110
 111         /**
 112          * Map a character into a glyph.
 113          * @param key The character.
 114          * @return The glyph ID used to draw the character.
 115          */
 116         virtual GlyphID MapCharToGlyph(WChar key) = 0;
 117
 118         /**
 119          * Read a font table from the font.
 120          * @param tag The of the table to load.
 121          * @param length The length of the read data.
 122          * @return The loaded table data.
 123          */
 124         virtual const void *GetFontTable(uint32 tag, size_t &length) = 0;
 125
 126         /**
 127          * Get the native OS font handle, if there is one.
 128          * @return Opaque OS font handle.
 129          */
 130         virtual void *GetOSHandle()
 131         {
 132                 return nullptr;
 133         }
 134
 135         /**
 136          * Get the name of this font.
 137          * @return The name of the font.
 138          */
 139         virtual const char *GetFontName() = 0;
 140
 141         /**
 142          * Get the font cache of a given font size.
 143          * @param fs The font size to look up.
 144          * @return The font cache.
 145          */
 146         static inline FontCache *Get(FontSize fs)
 147         {
 148                 assert(fs < FS_END);
 149                 return FontCache::caches[fs];
 150         }
 151
 152         /**
 153          * Check whether the font cache has a parent.
 154          */
 155         inline bool HasParent()
 156         {
 157                 return this->parent != nullptr;
 158         }
 159
 160         /**
 161          * Is this a built-in sprite font?
 162          */
 163         virtual bool IsBuiltInFont() = 0;
 164 };
 165
 166 /** Get the SpriteID mapped to the given font size and key */
 167 static inline SpriteID GetUnicodeGlyph(FontSize size, WChar key)
 168 {
 169         return FontCache::Get(size)->GetUnicodeGlyph(key);
 170 }
 171
 172 /** Map a SpriteID to the font size and key */
 173 static inline void SetUnicodeGlyph(FontSize size, WChar key, SpriteID sprite)
 174 {
 175         FontCache::Get(size)->SetUnicodeGlyph(key, sprite);
 176 }
 177
 178 /** Initialize the glyph map */
 179 static inline void InitializeUnicodeGlyphMap()
 180 {
 181         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 182                 FontCache::Get(fs)->InitializeUnicodeGlyphMap();
 183         }
 184 }
 185
 186 static inline void ClearFontCache()
 187 {
 188         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 189                 FontCache::Get(fs)->ClearFontCache();
 190         }
 191 }
 192
 193 /** Get the Sprite for a glyph */
 194 static inline const Sprite *GetGlyph(FontSize size, WChar key)
 195 {
 196         FontCache *fc = FontCache::Get(size);
 197         return fc->GetGlyph(fc->MapCharToGlyph(key));
 198 }
 199
 200 /** Get the width of a glyph */
 201 static inline uint GetGlyphWidth(FontSize size, WChar key)
 202 {
 203         FontCache *fc = FontCache::Get(size);
 204         return fc->GetGlyphWidth(fc->MapCharToGlyph(key));
 205 }
 206
 207 static inline bool GetDrawGlyphShadow(FontSize size)
 208 {
 209         return FontCache::Get(size)->GetDrawGlyphShadow();
 210 }
 211
 212 #if defined(WITH_FREETYPE) || defined(_WIN32)
 213
 214 /** Settings for a single freetype font. */
 215 struct FreeTypeSubSetting {
 216         char font[MAX_PATH]; ///< The name of the font, or path to the font.
 217         uint size;           ///< The (requested) size of the font.
 218         bool aa;             ///< Whether to do anti aliasing or not.
 219
 220         const void *os_handle = nullptr; ///< Optional native OS font info.
 221 };
 222
 223 /** Settings for the freetype fonts. */
 224 struct FreeTypeSettings {
 225         FreeTypeSubSetting small;  ///< The smallest font; mostly used for zoomed out view.
 226         FreeTypeSubSetting medium; ///< The normal font size.
 227         FreeTypeSubSetting large;  ///< The largest font; mostly used for newspapers.
 228         FreeTypeSubSetting mono;   ///< The mono space font used for license/readme viewers.
 229 };
 230
 231 extern FreeTypeSettings _freetype;
 232
 233 #endif /* defined(WITH_FREETYPE) || defined(_WIN32) */
 234
 235 void InitFreeType(bool monospace);
 236 void UninitFreeType();
 237
 238 #endif /* FONTCACHE_H */