OpenTTD
fontcache.cpp
Go to the documentation of this file.
1 /* $Id$ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "stdafx.h"
13 #include "fontcache.h"
14 #include "fontdetection.h"
15 #include "blitter/factory.hpp"
16 #include "core/math_func.hpp"
17 #include "core/smallmap_type.hpp"
18 #include "strings_func.h"
19 #include "zoom_type.h"
20 #include "gfx_layout.h"
21 #include "zoom_func.h"
22 
23 #include "table/sprites.h"
24 #include "table/control_codes.h"
25 #include "table/unicode.h"
26 
27 #include "safeguards.h"
28 
29 static const int ASCII_LETTERSTART = 32;
30 static const int MAX_FONT_SIZE = 72;
31 
33 static const int _default_font_height[FS_END] = {10, 6, 18, 10};
34 static const int _default_font_ascender[FS_END] = { 8, 5, 15, 8};
35 
40 FontCache::FontCache(FontSize fs) : parent(FontCache::Get(fs)), fs(fs), height(_default_font_height[fs]),
41  ascender(_default_font_ascender[fs]), descender(_default_font_ascender[fs] - _default_font_height[fs]),
42  units_per_em(1)
43 {
44  assert(this->parent == NULL || this->fs == this->parent->fs);
45  FontCache::caches[this->fs] = this;
46  Layouter::ResetFontCache(this->fs);
47 }
48 
51 {
52  assert(this->fs == this->parent->fs);
53  FontCache::caches[this->fs] = this->parent;
55 }
56 
57 
64 {
65  return FontCache::Get(size)->GetHeight();
66 }
67 
68 
70 class SpriteFontCache : public FontCache {
71 private:
73 
74  void ClearGlyphToSpriteMap();
75 public:
77  ~SpriteFontCache();
78  virtual SpriteID GetUnicodeGlyph(WChar key);
79  virtual void SetUnicodeGlyph(WChar key, SpriteID sprite);
80  virtual void InitializeUnicodeGlyphMap();
81  virtual void ClearFontCache();
82  virtual const Sprite *GetGlyph(GlyphID key);
83  virtual uint GetGlyphWidth(GlyphID key);
84  virtual int GetHeight() const;
85  virtual bool GetDrawGlyphShadow();
86  virtual GlyphID MapCharToGlyph(WChar key) { assert(IsPrintable(key)); return SPRITE_GLYPH | key; }
87  virtual const void *GetFontTable(uint32 tag, size_t &length) { length = 0; return NULL; }
88  virtual const char *GetFontName() { return "sprite"; }
89  virtual bool IsBuiltInFont() { return true; }
90 };
91 
96 SpriteFontCache::SpriteFontCache(FontSize fs) : FontCache(fs), glyph_to_spriteid_map(NULL)
97 {
99 }
100 
105 {
106  this->ClearGlyphToSpriteMap();
107 }
108 
110 {
111  if (this->glyph_to_spriteid_map[GB(key, 8, 8)] == NULL) return 0;
112  return this->glyph_to_spriteid_map[GB(key, 8, 8)][GB(key, 0, 8)];
113 }
114 
116 {
117  if (this->glyph_to_spriteid_map == NULL) this->glyph_to_spriteid_map = CallocT<SpriteID*>(256);
118  if (this->glyph_to_spriteid_map[GB(key, 8, 8)] == NULL) this->glyph_to_spriteid_map[GB(key, 8, 8)] = CallocT<SpriteID>(256);
119  this->glyph_to_spriteid_map[GB(key, 8, 8)][GB(key, 0, 8)] = sprite;
120 }
121 
123 {
124  /* Clear out existing glyph map if it exists */
125  this->ClearGlyphToSpriteMap();
126 
127  SpriteID base;
128  switch (this->fs) {
129  default: NOT_REACHED();
130  case FS_MONO: // Use normal as default for mono spaced font
131  case FS_NORMAL: base = SPR_ASCII_SPACE; break;
132  case FS_SMALL: base = SPR_ASCII_SPACE_SMALL; break;
133  case FS_LARGE: base = SPR_ASCII_SPACE_BIG; break;
134  }
135 
136  for (uint i = ASCII_LETTERSTART; i < 256; i++) {
137  SpriteID sprite = base + i - ASCII_LETTERSTART;
138  if (!SpriteExists(sprite)) continue;
139  this->SetUnicodeGlyph(i, sprite);
140  this->SetUnicodeGlyph(i + SCC_SPRITE_START, sprite);
141  }
142 
143  for (uint i = 0; i < lengthof(_default_unicode_map); i++) {
144  byte key = _default_unicode_map[i].key;
145  if (key == CLRA) {
146  /* Clear the glyph. This happens if the glyph at this code point
147  * is non-standard and should be accessed by an SCC_xxx enum
148  * entry only. */
149  this->SetUnicodeGlyph(_default_unicode_map[i].code, 0);
150  } else {
151  SpriteID sprite = base + key - ASCII_LETTERSTART;
152  this->SetUnicodeGlyph(_default_unicode_map[i].code, sprite);
153  }
154  }
155 }
156 
161 {
162  if (this->glyph_to_spriteid_map == NULL) return;
163 
164  for (uint i = 0; i < 256; i++) {
165  free(this->glyph_to_spriteid_map[i]);
166  }
168  this->glyph_to_spriteid_map = NULL;
169 }
170 
172 {
174 }
175 
177 {
178  SpriteID sprite = this->GetUnicodeGlyph(key);
179  if (sprite == 0) sprite = this->GetUnicodeGlyph('?');
180  return GetSprite(sprite, ST_FONT);
181 }
182 
184 {
185  SpriteID sprite = this->GetUnicodeGlyph(key);
186  if (sprite == 0) sprite = this->GetUnicodeGlyph('?');
187  return SpriteExists(sprite) ? GetSprite(sprite, ST_FONT)->width + ScaleGUITrad(this->fs != FS_NORMAL ? 1 : 0) : 0;
188 }
189 
191 {
192  return ScaleGUITrad(this->height);
193 }
194 
196 {
197  return false;
198 }
199 
201 
202 #ifdef WITH_FREETYPE
203 #include <ft2build.h>
204 #include FT_FREETYPE_H
205 #include FT_GLYPH_H
206 #include FT_TRUETYPE_TABLES_H
207 
209 class FreeTypeFontCache : public FontCache {
210 private:
211  FT_Face face;
212  int req_size;
213  int used_size;
214 
216  FontTable font_tables;
217 
219  struct GlyphEntry {
221  byte width;
222  bool duplicate;
223  };
224 
239 
240  GlyphEntry *GetGlyphPtr(GlyphID key);
241  void SetGlyphPtr(GlyphID key, const GlyphEntry *glyph, bool duplicate = false);
242  void SetFontSize(FontSize fs, FT_Face face, int pixels);
243 
244 public:
245  FreeTypeFontCache(FontSize fs, FT_Face face, int pixels);
247  virtual int GetFontSize() const { return this->used_size; }
248  virtual SpriteID GetUnicodeGlyph(WChar key) { return this->parent->GetUnicodeGlyph(key); }
249  virtual void SetUnicodeGlyph(WChar key, SpriteID sprite) { this->parent->SetUnicodeGlyph(key, sprite); }
251  virtual void ClearFontCache();
252  virtual const Sprite *GetGlyph(GlyphID key);
253  virtual uint GetGlyphWidth(GlyphID key);
254  virtual bool GetDrawGlyphShadow();
255  virtual GlyphID MapCharToGlyph(WChar key);
256  virtual const void *GetFontTable(uint32 tag, size_t &length);
257  virtual const char *GetFontName() { return face->family_name; }
258  virtual bool IsBuiltInFont() { return false; }
259 };
260 
261 FT_Library _library = NULL;
262 
263 FreeTypeSettings _freetype;
264 
265 static const byte FACE_COLOUR = 1;
266 static const byte SHADOW_COLOUR = 2;
267 
274 FreeTypeFontCache::FreeTypeFontCache(FontSize fs, FT_Face face, int pixels) : FontCache(fs), face(face), req_size(pixels), glyph_to_sprite(NULL)
275 {
276  assert(face != NULL);
277 
278  this->SetFontSize(fs, face, pixels);
279 }
280 
281 void FreeTypeFontCache::SetFontSize(FontSize fs, FT_Face face, int pixels)
282 {
283  if (pixels == 0) {
284  /* Try to determine a good height based on the minimal height recommended by the font. */
285  int scaled_height = ScaleGUITrad(_default_font_height[this->fs]);
286  pixels = scaled_height;
287 
288  TT_Header *head = (TT_Header *)FT_Get_Sfnt_Table(this->face, ft_sfnt_head);
289  if (head != NULL) {
290  /* Font height is minimum height plus the difference between the default
291  * height for this font size and the small size. */
292  int diff = scaled_height - ScaleGUITrad(_default_font_height[FS_SMALL]);
293  pixels = Clamp(min(head->Lowest_Rec_PPEM, 20) + diff, scaled_height, MAX_FONT_SIZE);
294  }
295  }
296  this->used_size = pixels;
297 
298  FT_Error err = FT_Set_Pixel_Sizes(this->face, 0, pixels);
299  if (err != FT_Err_Ok) {
300 
301  /* Find nearest size to that requested */
302  FT_Bitmap_Size *bs = this->face->available_sizes;
303  int i = this->face->num_fixed_sizes;
304  if (i > 0) { // In pathetic cases one might get no fixed sizes at all.
305  int n = bs->height;
306  FT_Int chosen = 0;
307  for (; --i; bs++) {
308  if (abs(pixels - bs->height) >= abs(pixels - n)) continue;
309  n = bs->height;
310  chosen = this->face->num_fixed_sizes - i;
311  }
312 
313  /* Don't use FT_Set_Pixel_Sizes here - it might give us another
314  * error, even though the size is available (FS#5885). */
315  err = FT_Select_Size(this->face, chosen);
316  }
317  }
318 
319  if (err == FT_Err_Ok) {
320  this->units_per_em = this->face->units_per_EM;
321  this->ascender = this->face->size->metrics.ascender >> 6;
322  this->descender = this->face->size->metrics.descender >> 6;
323  this->height = this->ascender - this->descender;
324  } else {
325  /* Both FT_Set_Pixel_Sizes and FT_Select_Size failed. */
326  DEBUG(freetype, 0, "Font size selection failed. Using FontCache defaults.");
327  }
328 }
329 
338 {
340  switch (fs) {
341  default: NOT_REACHED();
342  case FS_SMALL: settings = &_freetype.small; break;
343  case FS_NORMAL: settings = &_freetype.medium; break;
344  case FS_LARGE: settings = &_freetype.large; break;
345  case FS_MONO: settings = &_freetype.mono; break;
346  }
347 
348  if (StrEmpty(settings->font)) return;
349 
350  if (_library == NULL) {
351  if (FT_Init_FreeType(&_library) != FT_Err_Ok) {
352  ShowInfoF("Unable to initialize FreeType, using sprite fonts instead");
353  return;
354  }
355 
356  DEBUG(freetype, 2, "Initialized");
357  }
358 
359  FT_Face face = NULL;
360  FT_Error error = FT_New_Face(_library, settings->font, 0, &face);
361 
362  if (error != FT_Err_Ok) error = GetFontByFaceName(settings->font, &face);
363 
364  if (error == FT_Err_Ok) {
365  DEBUG(freetype, 2, "Requested '%s', using '%s %s'", settings->font, face->family_name, face->style_name);
366 
367  /* Attempt to select the unicode character map */
368  error = FT_Select_Charmap(face, ft_encoding_unicode);
369  if (error == FT_Err_Ok) goto found_face; // Success
370 
371  if (error == FT_Err_Invalid_CharMap_Handle) {
372  /* Try to pick a different character map instead. We default to
373  * the first map, but platform_id 0 encoding_id 0 should also
374  * be unicode (strange system...) */
375  FT_CharMap found = face->charmaps[0];
376  int i;
377 
378  for (i = 0; i < face->num_charmaps; i++) {
379  FT_CharMap charmap = face->charmaps[i];
380  if (charmap->platform_id == 0 && charmap->encoding_id == 0) {
381  found = charmap;
382  }
383  }
384 
385  if (found != NULL) {
386  error = FT_Set_Charmap(face, found);
387  if (error == FT_Err_Ok) goto found_face;
388  }
389  }
390  }
391 
392  FT_Done_Face(face);
393 
394  static const char *SIZE_TO_NAME[] = { "medium", "small", "large", "mono" };
395  ShowInfoF("Unable to use '%s' for %s font, FreeType reported error 0x%X, using sprite font instead", settings->font, SIZE_TO_NAME[fs], error);
396  return;
397 
398 found_face:
399  new FreeTypeFontCache(fs, face, settings->size);
400 }
401 
402 
407 {
408  FT_Done_Face(this->face);
409  this->face = NULL;
410  this->ClearFontCache();
411 
412  for (FontTable::iterator iter = this->font_tables.Begin(); iter != this->font_tables.End(); iter++) {
413  free(iter->second.second);
414  }
415 }
416 
421 {
422  if (this->glyph_to_sprite == NULL) return;
423 
424  for (int i = 0; i < 256; i++) {
425  if (this->glyph_to_sprite[i] == NULL) continue;
426 
427  for (int j = 0; j < 256; j++) {
428  if (this->glyph_to_sprite[i][j].duplicate) continue;
429  free(this->glyph_to_sprite[i][j].sprite);
430  }
431 
432  free(this->glyph_to_sprite[i]);
433  }
434 
435  free(this->glyph_to_sprite);
436  this->glyph_to_sprite = NULL;
437 
439 
440  /* GUI scaling might have changed, determine font size anew if it was automatically selected. */
441  if (this->face != NULL && this->req_size == 0) this->SetFontSize(this->fs, this->face, this->req_size);
442 }
443 
444 FreeTypeFontCache::GlyphEntry *FreeTypeFontCache::GetGlyphPtr(GlyphID key)
445 {
446  if (this->glyph_to_sprite == NULL) return NULL;
447  if (this->glyph_to_sprite[GB(key, 8, 8)] == NULL) return NULL;
448  return &this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)];
449 }
450 
451 
452 void FreeTypeFontCache::SetGlyphPtr(GlyphID key, const GlyphEntry *glyph, bool duplicate)
453 {
454  if (this->glyph_to_sprite == NULL) {
455  DEBUG(freetype, 3, "Allocating root glyph cache for size %u", this->fs);
456  this->glyph_to_sprite = CallocT<GlyphEntry*>(256);
457  }
458 
459  if (this->glyph_to_sprite[GB(key, 8, 8)] == NULL) {
460  DEBUG(freetype, 3, "Allocating glyph cache for range 0x%02X00, size %u", GB(key, 8, 8), this->fs);
461  this->glyph_to_sprite[GB(key, 8, 8)] = CallocT<GlyphEntry>(256);
462  }
463 
464  DEBUG(freetype, 4, "Set glyph for unicode character 0x%04X, size %u", key, this->fs);
465  this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)].sprite = glyph->sprite;
466  this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)].width = glyph->width;
467  this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)].duplicate = duplicate;
468 }
469 
470 static void *AllocateFont(size_t size)
471 {
472  return MallocT<byte>(size);
473 }
474 
475 
476 /* Check if a glyph should be rendered with antialiasing */
477 static bool GetFontAAState(FontSize size)
478 {
479  /* AA is only supported for 32 bpp */
480  if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() != 32) return false;
481 
482  switch (size) {
483  default: NOT_REACHED();
484  case FS_NORMAL: return _freetype.medium.aa;
485  case FS_SMALL: return _freetype.small.aa;
486  case FS_LARGE: return _freetype.large.aa;
487  case FS_MONO: return _freetype.mono.aa;
488  }
489 }
490 
491 
493 {
494  if ((key & SPRITE_GLYPH) != 0) return this->parent->GetGlyph(key);
495 
496  /* Check for the glyph in our cache */
497  GlyphEntry *glyph = this->GetGlyphPtr(key);
498  if (glyph != NULL && glyph->sprite != NULL) return glyph->sprite;
499 
500  FT_GlyphSlot slot = this->face->glyph;
501 
502  bool aa = GetFontAAState(this->fs);
503 
504  GlyphEntry new_glyph;
505  if (key == 0) {
506  GlyphID question_glyph = this->MapCharToGlyph('?');
507  if (question_glyph == 0) {
508  /* The font misses the '?' character. Use built-in sprite.
509  * Note: We cannot use the baseset as this also has to work in the bootstrap GUI. */
510 #define CPSET { 0, 0, 0, 0, 1 }
511 #define CP___ { 0, 0, 0, 0, 0 }
512  static SpriteLoader::CommonPixel builtin_questionmark_data[10 * 8] = {
513  CP___, CP___, CPSET, CPSET, CPSET, CPSET, CP___, CP___,
514  CP___, CPSET, CPSET, CP___, CP___, CPSET, CPSET, CP___,
515  CP___, CP___, CP___, CP___, CP___, CPSET, CPSET, CP___,
516  CP___, CP___, CP___, CP___, CPSET, CPSET, CP___, CP___,
517  CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
518  CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
519  CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
520  CP___, CP___, CP___, CP___, CP___, CP___, CP___, CP___,
521  CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
522  CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
523  };
524 #undef CPSET
525 #undef CP___
526  static const SpriteLoader::Sprite builtin_questionmark = {
527  10, // height
528  8, // width
529  0, // x_offs
530  0, // y_offs
531  ST_FONT,
532  builtin_questionmark_data
533  };
534 
535  Sprite *spr = BlitterFactory::GetCurrentBlitter()->Encode(&builtin_questionmark, AllocateFont);
536  assert(spr != NULL);
537  new_glyph.sprite = spr;
538  new_glyph.width = spr->width + (this->fs != FS_NORMAL);
539  this->SetGlyphPtr(key, &new_glyph, false);
540  return new_glyph.sprite;
541  } else {
542  /* Use '?' for missing characters. */
543  this->GetGlyph(question_glyph);
544  glyph = this->GetGlyphPtr(question_glyph);
545  this->SetGlyphPtr(key, glyph, true);
546  return glyph->sprite;
547  }
548  }
549  FT_Load_Glyph(this->face, key, aa ? FT_LOAD_TARGET_NORMAL : FT_LOAD_TARGET_MONO);
550  FT_Render_Glyph(this->face->glyph, aa ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO);
551 
552  /* Despite requesting a normal glyph, FreeType may have returned a bitmap */
553  aa = (slot->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY);
554 
555  /* Add 1 pixel for the shadow on the medium font. Our sprite must be at least 1x1 pixel */
556  uint width = max(1U, (uint)slot->bitmap.width + (this->fs == FS_NORMAL));
557  uint height = max(1U, (uint)slot->bitmap.rows + (this->fs == FS_NORMAL));
558 
559  /* Limit glyph size to prevent overflows later on. */
560  if (width > 256 || height > 256) usererror("Font glyph is too large");
561 
562  /* FreeType has rendered the glyph, now we allocate a sprite and copy the image into it */
563  SpriteLoader::Sprite sprite;
564  sprite.AllocateData(ZOOM_LVL_NORMAL, width * height);
565  sprite.type = ST_FONT;
566  sprite.width = width;
567  sprite.height = height;
568  sprite.x_offs = slot->bitmap_left;
569  sprite.y_offs = this->ascender - slot->bitmap_top;
570 
571  /* Draw shadow for medium size */
572  if (this->fs == FS_NORMAL && !aa) {
573  for (uint y = 0; y < (uint)slot->bitmap.rows; y++) {
574  for (uint x = 0; x < (uint)slot->bitmap.width; x++) {
575  if (aa ? (slot->bitmap.buffer[x + y * slot->bitmap.pitch] > 0) : HasBit(slot->bitmap.buffer[(x / 8) + y * slot->bitmap.pitch], 7 - (x % 8))) {
576  sprite.data[1 + x + (1 + y) * sprite.width].m = SHADOW_COLOUR;
577  sprite.data[1 + x + (1 + y) * sprite.width].a = aa ? slot->bitmap.buffer[x + y * slot->bitmap.pitch] : 0xFF;
578  }
579  }
580  }
581  }
582 
583  for (uint y = 0; y < (uint)slot->bitmap.rows; y++) {
584  for (uint x = 0; x < (uint)slot->bitmap.width; x++) {
585  if (aa ? (slot->bitmap.buffer[x + y * slot->bitmap.pitch] > 0) : HasBit(slot->bitmap.buffer[(x / 8) + y * slot->bitmap.pitch], 7 - (x % 8))) {
586  sprite.data[x + y * sprite.width].m = FACE_COLOUR;
587  sprite.data[x + y * sprite.width].a = aa ? slot->bitmap.buffer[x + y * slot->bitmap.pitch] : 0xFF;
588  }
589  }
590  }
591 
592  new_glyph.sprite = BlitterFactory::GetCurrentBlitter()->Encode(&sprite, AllocateFont);
593  new_glyph.width = slot->advance.x >> 6;
594 
595  this->SetGlyphPtr(key, &new_glyph);
596 
597  return new_glyph.sprite;
598 }
599 
600 
602 {
603  return this->fs == FS_NORMAL && GetFontAAState(FS_NORMAL);
604 }
605 
606 
608 {
609  if ((key & SPRITE_GLYPH) != 0) return this->parent->GetGlyphWidth(key);
610 
611  GlyphEntry *glyph = this->GetGlyphPtr(key);
612  if (glyph == NULL || glyph->sprite == NULL) {
613  this->GetGlyph(key);
614  glyph = this->GetGlyphPtr(key);
615  }
616 
617  return glyph->width;
618 }
619 
621 {
622  assert(IsPrintable(key));
623 
624  if (key >= SCC_SPRITE_START && key <= SCC_SPRITE_END) {
625  return this->parent->MapCharToGlyph(key);
626  }
627 
628  return FT_Get_Char_Index(this->face, key);
629 }
630 
631 const void *FreeTypeFontCache::GetFontTable(uint32 tag, size_t &length)
632 {
633  const FontTable::iterator iter = this->font_tables.Find(tag);
634  if (iter != this->font_tables.End()) {
635  length = iter->second.first;
636  return iter->second.second;
637  }
638 
639  FT_ULong len = 0;
640  FT_Byte *result = NULL;
641 
642  FT_Load_Sfnt_Table(this->face, tag, 0, NULL, &len);
643 
644  if (len > 0) {
645  result = MallocT<FT_Byte>(len);
646  FT_Load_Sfnt_Table(this->face, tag, 0, result, &len);
647  }
648  length = len;
649 
650  this->font_tables.Insert(tag, SmallPair<size_t, const void *>(length, result));
651  return result;
652 }
653 
654 #endif /* WITH_FREETYPE */
655 
660 void InitFreeType(bool monospace)
661 {
662  for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
663  if (monospace != (fs == FS_MONO)) continue;
664 
665  FontCache *fc = FontCache::Get(fs);
666  if (fc->HasParent()) delete fc;
667 
668 #ifdef WITH_FREETYPE
670 #endif
671  }
672 }
673 
678 {
679  for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
680  FontCache *fc = FontCache::Get(fs);
681  if (fc->HasParent()) delete fc;
682  }
683 
684 #ifdef WITH_FREETYPE
685  FT_Done_FreeType(_library);
686  _library = NULL;
687 #endif /* WITH_FREETYPE */
688 }
Functions related to OTTD&#39;s strings.
Character mapping for using Unicode characters in OTTD.
virtual void InitializeUnicodeGlyphMap()
Initialize the glyph map.
Definition: fontcache.cpp:122
virtual uint GetGlyphWidth(GlyphID key)
Get the width of the glyph with the given key.
Definition: fontcache.cpp:607
uint8 a
Alpha-channel.
int height
The height of the font.
Definition: fontcache.h:29
Control codes that are embedded in the translation strings.
virtual SpriteID GetUnicodeGlyph(WChar key)
Get the SpriteID mapped to the given key.
Definition: fontcache.cpp:109
SpriteFontCache(FontSize fs)
Create a new sprite font cache.
Definition: fontcache.cpp:96
const Pair * Find(const T &key) const
Finds given key in this map.
virtual bool GetDrawGlyphShadow()
Do we need to draw a glyph shadow?
Definition: fontcache.cpp:601
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition: fontcache.cpp:63
int descender
The descender value of the font.
Definition: fontcache.h:31
Settings for a single freetype font.
Definition: fontcache.h:208
~FreeTypeFontCache()
Free everything that was allocated for this font cache.
Definition: fontcache.cpp:406
Index of the monospaced font in the font tables.
Definition: gfx_type.h:207
Data structure describing a sprite.
Definition: spritecache.h:18
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:82
fluid_settings_t * settings
FluidSynth settings handle.
Definition: fluidsynth.cpp:22
Sprite * sprite
The loaded sprite.
Definition: fontcache.cpp:220
FontTable font_tables
Cached font tables.
Definition: fontcache.cpp:216
Implementation of simple mapping class.
SmallMap< uint32, SmallPair< size_t, const void * > > FontTable
Table with font table cache.
Definition: fontcache.cpp:215
Functions related to detecting/finding the right font.
const T * Begin() const
Get the pointer to the first item (const)
bool Insert(const T &key, const U &data)
Adds new item to this map.
void AllocateData(ZoomLevel zoom, size_t size)
Allocate the sprite data of this sprite.
virtual void ClearFontCache()
Clear the font cache.
Definition: fontcache.cpp:171
virtual bool IsBuiltInFont()
Is this a built-in sprite font?
Definition: fontcache.cpp:89
FreeTypeSubSetting large
The largest font; mostly used for newspapers.
Definition: fontcache.h:218
int units_per_em
The units per EM value of the font.
Definition: fontcache.h:32
virtual void SetUnicodeGlyph(WChar key, SpriteID sprite)=0
Map a SpriteID to the key.
virtual const char * GetFontName()
Get the name of this font.
Definition: fontcache.cpp:257
virtual Sprite * Encode(const SpriteLoader::Sprite *sprite, AllocatorProc *allocator)=0
Convert a sprite from the loader to our own format.
virtual GlyphID MapCharToGlyph(WChar key)
Map a character into a glyph.
Definition: fontcache.cpp:86
byte width
The width of the glyph.
Definition: fontcache.cpp:221
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:26
Functions related to laying out the texts.
static FontCache * Get(FontSize fs)
Get the font cache of a given font size.
Definition: fontcache.h:139
const T * End() const
Get the pointer behind the last valid item (const)
virtual int GetFontSize() const
Get the nominal font size of the font.
Definition: fontcache.cpp:247
int used_size
Used font size.
Definition: fontcache.cpp:213
Settings for the freetype fonts.
Definition: fontcache.h:215
bool HasParent()
Check whether the font cache has a parent.
Definition: fontcache.h:148
Definition of a common pixel in OpenTTD&#39;s realm.
SpriteType type
The sprite type.
Font cache for fonts that are based on a freetype font.
Definition: fontcache.cpp:70
Types related to zooming in and out.
Simple mapping class targeted for small sets of data.
void InitFreeType(bool monospace)
(Re)initialize the freetype related things, i.e.
Definition: fontcache.cpp:660
void CDECL ShowInfoF(const char *str,...)
Shows some information on the console/a popup box depending on the OS.
Definition: openttd.cpp:133
Functions to read fonts from files and cache them.
virtual void ClearFontCache()
Reset cached glyphs.
Definition: fontcache.cpp:420
bool aa
Whether to do anti aliasing or not.
Definition: fontcache.h:211
Simple pair of data.
First font.
Definition: gfx_type.h:210
virtual ~FontCache()
Clean everything up.
Definition: fontcache.cpp:50
FreeTypeSubSetting mono
The mono space font used for license/readme viewers.
Definition: fontcache.h:219
FontCache(FontSize fs)
Create a new font cache.
Definition: fontcache.cpp:40
FT_Face face
The font face associated with this font.
Definition: fontcache.cpp:211
virtual void InitializeUnicodeGlyphMap()
Initialize the glyph map.
Definition: fontcache.cpp:250
virtual uint GetGlyphWidth(GlyphID key)=0
Get the width of the glyph with the given key.
GlyphEntry ** glyph_to_sprite
The glyph cache.
Definition: fontcache.cpp:238
Definition of base types and functions in a cross-platform compatible way.
virtual bool IsBuiltInFont()
Is this a built-in sprite font?
Definition: fontcache.cpp:258
Font cache for fonts that are based on a freetype font.
Definition: fontcache.cpp:209
void CDECL usererror(const char *s,...)
Error handling for fatal user errors.
Definition: openttd.cpp:91
A number of safeguards to prevent using unsafe methods.
FT_Error GetFontByFaceName(const char *font_name, FT_Face *face)
Get the font loaded into a Freetype face by using a font-name.
virtual const void * GetFontTable(uint32 tag, size_t &length)
Read a font table from the font.
Definition: fontcache.cpp:87
int16 x_offs
The x-offset of where the sprite will be drawn.
virtual int GetHeight() const
Get the height of the font.
Definition: fontcache.h:47
virtual const Sprite * GetGlyph(GlyphID key)
Get the glyph (sprite) of the given key.
Definition: fontcache.cpp:176
FreeTypeFontCache(FontSize fs, FT_Face face, int pixels)
Create a new FreeTypeFontCache.
Definition: fontcache.cpp:274
~SpriteFontCache()
Free everything we allocated.
Definition: fontcache.cpp:104
SpriteLoader::CommonPixel * data
The sprite itself.
virtual bool GetDrawGlyphShadow()
Do we need to draw a glyph shadow?
Definition: fontcache.cpp:195
Structure for passing information from the sprite loader to the blitter.
FreeTypeSubSetting medium
The normal font size.
Definition: fontcache.h:217
static const int MAX_FONT_SIZE
Maximum font size.
Definition: fontcache.cpp:30
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:42
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition: factory.hpp:147
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:42
virtual GlyphID MapCharToGlyph(WChar key)=0
Map a character into a glyph.
static void ResetFontCache(FontSize size)
Reset cached font information.
Definition: gfx_layout.cpp:845
Font cache for basic fonts.
Definition: fontcache.h:23
Integer math functions.
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:139
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:36
FontCache * parent
The parent of this font cache.
Definition: fontcache.h:27
uint size
The (requested) size of the font.
Definition: fontcache.h:210
uint8 m
Remap-channel.
uint16 width
Width of the sprite.
char font[MAX_PATH]
The name of the font, or path to the font.
Definition: fontcache.h:209
uint16 width
Width of the sprite.
Definition: spritecache.h:20
void ClearGlyphToSpriteMap()
Clear the glyph to sprite mapping.
Definition: fontcache.cpp:160
SpriteID ** glyph_to_spriteid_map
Mapping of glyphs to sprite IDs.
Definition: fontcache.cpp:72
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:19
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:59
static FontCache * caches[FS_END]
All the font caches.
Definition: fontcache.h:25
virtual uint GetGlyphWidth(GlyphID key)
Get the width of the glyph with the given key.
Definition: fontcache.cpp:183
virtual void SetUnicodeGlyph(WChar key, SpriteID sprite)
Map a SpriteID to the key.
Definition: fontcache.cpp:115
virtual const char * GetFontName()
Get the name of this font.
Definition: fontcache.cpp:88
static const byte CLRA
Identifier to clear all glyphs at this codepoint.
Definition: unicode.h:17
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:111
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:83
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
FreeTypeSubSetting small
The smallest font; mostly used for zoomed out view.
Definition: fontcache.h:216
virtual const Sprite * GetGlyph(GlyphID key)=0
Get the glyph (sprite) of the given key.
Functions related to zooming.
FontSize
Available font sizes.
Definition: gfx_type.h:203
uint16 height
Height of the sprite.
static void LoadFreeTypeFont(FontSize fs)
Loads the freetype font.
Definition: fontcache.cpp:337
Index of the normal font in the font tables.
Definition: gfx_type.h:204
virtual const Sprite * GetGlyph(GlyphID key)
Get the glyph (sprite) of the given key.
Definition: fontcache.cpp:492
virtual SpriteID GetUnicodeGlyph(WChar key)
Get the SpriteID mapped to the given key.
Definition: fontcache.cpp:248
virtual bool GetDrawGlyphShadow()=0
Do we need to draw a glyph shadow?
virtual int GetHeight() const
Get the height of the font.
Definition: fontcache.cpp:190
static const int _default_font_height[FS_END]
Default heights for the different sizes of fonts.
Definition: fontcache.cpp:33
void UninitFreeType()
Free everything allocated w.r.t.
Definition: fontcache.cpp:677
int16 y_offs
The y-offset of where the sprite will be drawn.
Index of the small font in the font tables.
Definition: gfx_type.h:205
virtual void InitializeUnicodeGlyphMap()=0
Initialize the glyph map.
int ascender
The ascender value of the font.
Definition: fontcache.h:30
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:114
Index of the large font in the font tables.
Definition: gfx_type.h:206
Container for information about a glyph.
Definition: fontcache.cpp:219
const FontSize fs
The size of the font.
Definition: fontcache.h:28
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
int req_size
Requested font size.
Definition: fontcache.cpp:212
The normal zoom level.
Definition: zoom_type.h:24
virtual void SetUnicodeGlyph(WChar key, SpriteID sprite)
Map a SpriteID to the key.
Definition: fontcache.cpp:249
virtual const void * GetFontTable(uint32 tag, size_t &length)
Read a font table from the font.
Definition: fontcache.cpp:631
virtual GlyphID MapCharToGlyph(WChar key)
Map a character into a glyph.
Definition: fontcache.cpp:620
uint32 GlyphID
Glyphs are characters from a font.
Definition: fontcache.h:19
virtual void ClearFontCache()=0
Clear the font cache.
uint32 WChar
Type for wide characters, i.e.
Definition: string_type.h:35
bool duplicate
Whether this glyph entry is a duplicate, i.e. may this be freed?
Definition: fontcache.cpp:222
This file contains all sprite-related enums and defines.
Factory to &#39;query&#39; all available blitters.
A sprite used for fonts.
Definition: gfx_type.h:300
virtual SpriteID GetUnicodeGlyph(WChar key)=0
Get the SpriteID mapped to the given key.
static const int ASCII_LETTERSTART
First printable ASCII letter.
Definition: fontcache.cpp:29