OpenTTD Source: src/fontcache/freetypefontcache.cpp Source File

OpenTTD Source 15.0-beta1

freetypefontcache.cpp
Go to the documentation of this file.
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
10#include "../stdafx.h"
11#include "../debug.h"
12#include "../fontcache.h"
13#include "../fontdetection.h"
14#include "../blitter/factory.hpp"
15#include "../core/math_func.hpp"
16#include "../zoom_func.h"
17#include "../fileio_func.h"
18#include "../error_func.h"
19#include "truetypefontcache.h"
20
21#include "../table/control_codes.h"
22
23#include "../safeguards.h"
24
25#ifdef WITH_FREETYPE
26#include <ft2build.h>
27#include FT_FREETYPE_H
28#include FT_GLYPH_H
29#include FT_TRUETYPE_TABLES_H
30
32 class FreeTypeFontCache : public TrueTypeFontCache {
33private:
34 FT_Face face;
35
36 void SetFontSize(int pixels);
37 const Sprite *InternalGetGlyph(GlyphID key, bool aa) override;
38
39public:
40 FreeTypeFontCache(FontSize fs, FT_Face face, int pixels);
41 ~FreeTypeFontCache();
42 void ClearFontCache() override;
43 GlyphID MapCharToGlyph(char32_t key, bool allow_fallback = true) override;
44 std::string GetFontName() override { return fmt::format("{}, {}", face->family_name, face->style_name); }
45 bool IsBuiltInFont() override { return false; }
46 const void *GetOSHandle() override { return &face; }
47};
48
49FT_Library _library = nullptr;
50
51
58FreeTypeFontCache::FreeTypeFontCache(FontSize fs, FT_Face face, int pixels) : TrueTypeFontCache(fs, pixels), face(face)
59{
60 assert(face != nullptr);
61
62 this->SetFontSize(pixels);
63}
64
65void FreeTypeFontCache::SetFontSize(int pixels)
66{
67 if (pixels == 0) {
68 /* Try to determine a good height based on the minimal height recommended by the font. */
69 int scaled_height = ScaleGUITrad(FontCache::GetDefaultFontHeight(this->fs));
70 pixels = scaled_height;
71
72 TT_Header *head = (TT_Header *)FT_Get_Sfnt_Table(this->face, ft_sfnt_head);
73 if (head != nullptr) {
74 /* Font height is minimum height plus the difference between the default
75 * height for this font size and the small size. */
76 int diff = scaled_height - ScaleGUITrad(FontCache::GetDefaultFontHeight(FS_SMALL));
77 /* Clamp() is not used as scaled_height could be greater than MAX_FONT_SIZE, which is not permitted in Clamp(). */
78 pixels = std::min(std::max(std::min<int>(head->Lowest_Rec_PPEM, MAX_FONT_MIN_REC_SIZE) + diff, scaled_height), MAX_FONT_SIZE);
79 }
80 } else {
81 pixels = ScaleGUITrad(pixels);
82 }
83 this->used_size = pixels;
84
85 FT_Error err = FT_Set_Pixel_Sizes(this->face, 0, pixels);
86 if (err != FT_Err_Ok) {
87
88 /* Find nearest size to that requested */
89 FT_Bitmap_Size *bs = this->face->available_sizes;
90 int i = this->face->num_fixed_sizes;
91 if (i > 0) { // In pathetic cases one might get no fixed sizes at all.
92 int n = bs->height;
93 FT_Int chosen = 0;
94 for (; --i; bs++) {
95 if (abs(pixels - bs->height) >= abs(pixels - n)) continue;
96 n = bs->height;
97 chosen = this->face->num_fixed_sizes - i;
98 }
99
100 /* Don't use FT_Set_Pixel_Sizes here - it might give us another
101 * error, even though the size is available (FS#5885). */
102 err = FT_Select_Size(this->face, chosen);
103 }
104 }
105
106 if (err == FT_Err_Ok) {
107 this->ascender = this->face->size->metrics.ascender >> 6;
108 this->descender = this->face->size->metrics.descender >> 6;
109 this->height = this->ascender - this->descender;
110 } else {
111 /* Both FT_Set_Pixel_Sizes and FT_Select_Size failed. */
112 Debug(fontcache, 0, "Font size selection failed. Using FontCache defaults.");
113 }
114}
115
116static FT_Error LoadFont(FontSize fs, FT_Face face, const char *font_name, uint size)
117{
118 Debug(fontcache, 2, "Requested '{}', using '{} {}'", font_name, face->family_name, face->style_name);
119
120 /* Attempt to select the unicode character map */
121 FT_Error error = FT_Select_Charmap(face, ft_encoding_unicode);
122 if (error == FT_Err_Ok) goto found_face; // Success
123
124 if (error == FT_Err_Invalid_CharMap_Handle) {
125 /* Try to pick a different character map instead. We default to
126 * the first map, but platform_id 0 encoding_id 0 should also
127 * be unicode (strange system...) */
128 FT_CharMap found = face->charmaps[0];
129 int i;
130
131 for (i = 0; i < face->num_charmaps; i++) {
132 FT_CharMap charmap = face->charmaps[i];
133 if (charmap->platform_id == 0 && charmap->encoding_id == 0) {
134 found = charmap;
135 }
136 }
137
138 if (found != nullptr) {
139 error = FT_Set_Charmap(face, found);
140 if (error == FT_Err_Ok) goto found_face;
141 }
142 }
143
144 FT_Done_Face(face);
145 return error;
146
147found_face:
148 new FreeTypeFontCache(fs, face, size);
149 return FT_Err_Ok;
150}
151
159 void LoadFreeTypeFont(FontSize fs)
160{
161 FontCacheSubSetting *settings = GetFontCacheSubSetting(fs);
162
163 std::string font = GetFontCacheFontName(fs);
164 if (font.empty()) return;
165
166 if (_library == nullptr) {
167 if (FT_Init_FreeType(&_library) != FT_Err_Ok) {
168 ShowInfo("Unable to initialize FreeType, using sprite fonts instead");
169 return;
170 }
171
172 Debug(fontcache, 2, "Initialized");
173 }
174
175 const char *font_name = font.c_str();
176 FT_Face face = nullptr;
177
178 /* If font is an absolute path to a ttf, try loading that first. */
179 int32_t index = 0;
180 if (settings->os_handle != nullptr) index = *static_cast<const int32_t *>(settings->os_handle);
181 FT_Error error = FT_New_Face(_library, font_name, index, &face);
182
183 if (error != FT_Err_Ok) {
184 /* Check if font is a relative filename in one of our search-paths. */
185 std::string full_font = FioFindFullPath(BASE_DIR, font_name);
186 if (!full_font.empty()) {
187 error = FT_New_Face(_library, full_font.c_str(), 0, &face);
188 }
189 }
190
191 /* Try loading based on font face name (OS-wide fonts). */
192 if (error != FT_Err_Ok) error = GetFontByFaceName(font_name, &face);
193
194 if (error == FT_Err_Ok) {
195 error = LoadFont(fs, face, font_name, GetFontCacheFontSize(fs));
196 if (error != FT_Err_Ok) {
197 ShowInfo("Unable to use '{}' for {} font, FreeType reported error 0x{:X}, using sprite font instead", font_name, FontSizeToName(fs), error);
198 }
199 } else {
200 FT_Done_Face(face);
201 }
202}
203
207FreeTypeFontCache::~FreeTypeFontCache()
208{
209 FT_Done_Face(this->face);
210 this->face = nullptr;
211 this->ClearFontCache();
212}
213
217 void FreeTypeFontCache::ClearFontCache()
218{
219 /* Font scaling might have changed, determine font size anew if it was automatically selected. */
220 if (this->face != nullptr) this->SetFontSize(this->req_size);
221
222 this->TrueTypeFontCache::ClearFontCache();
223}
224
225
226const Sprite *FreeTypeFontCache::InternalGetGlyph(GlyphID key, bool aa)
227{
228 FT_GlyphSlot slot = this->face->glyph;
229
230 FT_Load_Glyph(this->face, key, aa ? FT_LOAD_TARGET_NORMAL : FT_LOAD_TARGET_MONO);
231 FT_Render_Glyph(this->face->glyph, aa ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO);
232
233 /* Despite requesting a normal glyph, FreeType may have returned a bitmap */
234 aa = (slot->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY);
235
236 /* Add 1 scaled pixel for the shadow on the medium font. Our sprite must be at least 1x1 pixel */
237 uint shadow = (this->fs == FS_NORMAL) ? ScaleGUITrad(1) : 0;
238 uint width = std::max(1U, (uint)slot->bitmap.width + shadow);
239 uint height = std::max(1U, (uint)slot->bitmap.rows + shadow);
240
241 /* Limit glyph size to prevent overflows later on. */
242 if (width > MAX_GLYPH_DIM || height > MAX_GLYPH_DIM) UserError("Font glyph is too large");
243
244 /* FreeType has rendered the glyph, now we allocate a sprite and copy the image into it */
245 SpriteLoader::SpriteCollection spritecollection;
246 SpriteLoader::Sprite &sprite = spritecollection[ZOOM_LVL_MIN];
247 sprite.AllocateData(ZOOM_LVL_MIN, static_cast<size_t>(width) * height);
248 sprite.type = SpriteType::Font;
249 sprite.colours = (aa ? SCC_PAL | SCC_ALPHA : SCC_PAL);
250 sprite.width = width;
251 sprite.height = height;
252 sprite.x_offs = slot->bitmap_left;
253 sprite.y_offs = this->ascender - slot->bitmap_top;
254
255 /* Draw shadow for medium size */
256 if (this->fs == FS_NORMAL && !aa) {
257 for (uint y = 0; y < (uint)slot->bitmap.rows; y++) {
258 for (uint x = 0; x < (uint)slot->bitmap.width; x++) {
259 if (HasBit(slot->bitmap.buffer[(x / 8) + y * slot->bitmap.pitch], 7 - (x % 8))) {
260 sprite.data[shadow + x + (shadow + y) * sprite.width].m = SHADOW_COLOUR;
261 sprite.data[shadow + x + (shadow + y) * sprite.width].a = 0xFF;
262 }
263 }
264 }
265 }
266
267 for (uint y = 0; y < (uint)slot->bitmap.rows; y++) {
268 for (uint x = 0; x < (uint)slot->bitmap.width; x++) {
269 if (aa ? (slot->bitmap.buffer[x + y * slot->bitmap.pitch] > 0) : HasBit(slot->bitmap.buffer[(x / 8) + y * slot->bitmap.pitch], 7 - (x % 8))) {
270 sprite.data[x + y * sprite.width].m = FACE_COLOUR;
271 sprite.data[x + y * sprite.width].a = aa ? slot->bitmap.buffer[x + y * slot->bitmap.pitch] : 0xFF;
272 }
273 }
274 }
275
276 UniquePtrSpriteAllocator allocator;
277 BlitterFactory::GetCurrentBlitter()->Encode(spritecollection, allocator);
278
279 GlyphEntry new_glyph;
280 new_glyph.data = std::move(allocator.data);
281 new_glyph.width = slot->advance.x >> 6;
282
283 return this->SetGlyphPtr(key, std::move(new_glyph)).GetSprite();
284}
285
286
287 GlyphID FreeTypeFontCache::MapCharToGlyph(char32_t key, bool allow_fallback)
288{
289 assert(IsPrintable(key));
290
291 FT_UInt glyph = FT_Get_Char_Index(this->face, key);
292
293 if (glyph == 0 && allow_fallback && key >= SCC_SPRITE_START && key <= SCC_SPRITE_END) {
294 return this->parent->MapCharToGlyph(key);
295 }
296
297 return glyph;
298}
299
303 void UninitFreeType()
304{
305 FT_Done_FreeType(_library);
306 _library = nullptr;
307}
308
309#if !defined(WITH_FONTCONFIG)
310
311FT_Error GetFontByFaceName(const char *font_name, FT_Face *face) { return FT_Err_Cannot_Open_Resource; }
312
313#endif /* !defined(WITH_FONTCONFIG) */
314
315#endif /* WITH_FREETYPE */
HasBit
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
BlitterFactory::GetCurrentBlitter
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition factory.hpp:138
FontCache::height
int height
The height of the font.
Definition fontcache.h:26
FontCache::parent
FontCache * parent
The parent of this font cache.
Definition fontcache.h:24
FontCache::MapCharToGlyph
virtual GlyphID MapCharToGlyph(char32_t key, bool fallback=true)=0
Map a character into a glyph.
FontCache::fs
const FontSize fs
The size of the font.
Definition fontcache.h:25
FontCache::descender
int descender
The descender value of the font.
Definition fontcache.h:28
FontCache::ascender
int ascender
The ascender value of the font.
Definition fontcache.h:27
FreeTypeFontCache
Font cache for fonts that are based on a freetype font.
Definition freetypefontcache.cpp:32
FreeTypeFontCache::GetOSHandle
const void * GetOSHandle() override
Get the native OS font handle, if there is one.
Definition freetypefontcache.cpp:46
FreeTypeFontCache::FreeTypeFontCache
FreeTypeFontCache(FontSize fs, FT_Face face, int pixels)
Create a new FreeTypeFontCache.
Definition freetypefontcache.cpp:58
FreeTypeFontCache::~FreeTypeFontCache
~FreeTypeFontCache()
Free everything that was allocated for this font cache.
Definition freetypefontcache.cpp:207
FreeTypeFontCache::ClearFontCache
void ClearFontCache() override
Reset cached glyphs.
Definition freetypefontcache.cpp:217
FreeTypeFontCache::MapCharToGlyph
GlyphID MapCharToGlyph(char32_t key, bool allow_fallback=true) override
Map a character into a glyph.
Definition freetypefontcache.cpp:287
FreeTypeFontCache::face
FT_Face face
The font face associated with this font.
Definition freetypefontcache.cpp:34
FreeTypeFontCache::GetFontName
std::string GetFontName() override
Get the name of this font.
Definition freetypefontcache.cpp:44
FreeTypeFontCache::IsBuiltInFont
bool IsBuiltInFont() override
Is this a built-in sprite font?
Definition freetypefontcache.cpp:45
SpriteEncoder::Encode
virtual Sprite * Encode(const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator)=0
Convert a sprite from the loader to our own format.
SpriteLoader::SpriteCollection
std::array< Sprite, ZOOM_LVL_END > SpriteCollection
Type defining a collection of sprites, one for each zoom level.
Definition spriteloader.hpp:70
TrueTypeFontCache
Font cache for fonts that are based on a TrueType font.
Definition truetypefontcache.h:22
TrueTypeFontCache::MAX_GLYPH_DIM
static constexpr int MAX_GLYPH_DIM
Maximum glyph dimensions.
Definition truetypefontcache.h:24
TrueTypeFontCache::used_size
int used_size
Used font size.
Definition truetypefontcache.h:28
TrueTypeFontCache::req_size
int req_size
Requested font size.
Definition truetypefontcache.h:27
TrueTypeFontCache::ClearFontCache
void ClearFontCache() override
Reset cached glyphs.
Definition truetypefontcache.cpp:40
TrueTypeFontCache::MAX_FONT_MIN_REC_SIZE
static constexpr uint MAX_FONT_MIN_REC_SIZE
Upper limit for the recommended font size in case a font file contains nonsensical values.
Definition truetypefontcache.h:25
UniquePtrSpriteAllocator
SpriteAllocator that allocates memory via a unique_ptr array.
Definition spritecache.h:41
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
FioFindFullPath
std::string FioFindFullPath(Subdirectory subdir, const std::string &filename)
Find a path to the filename in one of the search directories.
Definition fileio.cpp:144
BASE_DIR
@ BASE_DIR
Base directory for all subdirectories.
Definition fileio_type.h:116
settings
fluid_settings_t * settings
FluidSynth settings handle.
Definition fluidsynth.cpp:21
GetFontCacheFontSize
uint GetFontCacheFontSize(FontSize fs)
Get the scalable font size to use for a FontSize.
Definition fontcache.cpp:162
GetFontCacheFontName
std::string GetFontCacheFontName(FontSize fs)
Get font to use for a given font size.
Definition fontcache.cpp:206
GetFontCacheSubSetting
FontCacheSubSetting * GetFontCacheSubSetting(FontSize fs)
Get the settings of a given font size.
Definition fontcache.h:216
GlyphID
uint32_t GlyphID
Glyphs are characters from a font.
Definition fontcache.h:17
GetFontByFaceName
FT_Error GetFontByFaceName(const char *font_name, FT_Face *face)
Load a freetype font face with the given font name.
Definition font_unix.cpp:42
UninitFreeType
void UninitFreeType()
Free everything allocated w.r.t.
Definition freetypefontcache.cpp:303
LoadFreeTypeFont
void LoadFreeTypeFont(FontSize fs)
Loads the freetype font.
Definition freetypefontcache.cpp:159
SpriteType::Font
@ Font
A sprite used for fonts.
FontSize
FontSize
Available font sizes.
Definition gfx_type.h:208
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition gfx_type.h:210
FS_NORMAL
@ FS_NORMAL
Index of the normal font in the font tables.
Definition gfx_type.h:209
abs
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition math_func.hpp:23
SCC_ALPHA
@ SCC_ALPHA
Sprite has alpha.
Definition spriteloader.hpp:23
SCC_PAL
@ SCC_PAL
Sprite has palette data.
Definition spriteloader.hpp:24
FontCacheSubSetting
Settings for a single font.
Definition fontcache.h:192
SpriteLoader::CommonPixel::m
uint8_t m
Remap-channel.
Definition spriteloader.hpp:38
SpriteLoader::CommonPixel::a
uint8_t a
Alpha-channel.
Definition spriteloader.hpp:37
SpriteLoader::Sprite
Structure for passing information from the sprite loader to the blitter.
Definition spriteloader.hpp:47
SpriteLoader::Sprite::AllocateData
void AllocateData(ZoomLevel zoom, size_t size)
Allocate the sprite data of this sprite.
Definition spriteloader.hpp:61
SpriteLoader::Sprite::colours
SpriteColourComponent colours
The colour components of the sprite with useful information.
Definition spriteloader.hpp:53
SpriteLoader::Sprite::width
uint16_t width
Width of the sprite.
Definition spriteloader.hpp:49
SpriteLoader::Sprite::x_offs
int16_t x_offs
The x-offset of where the sprite will be drawn.
Definition spriteloader.hpp:50
SpriteLoader::Sprite::data
SpriteLoader::CommonPixel * data
The sprite itself.
Definition spriteloader.hpp:54
SpriteLoader::Sprite::height
uint16_t height
Height of the sprite.
Definition spriteloader.hpp:48
SpriteLoader::Sprite::type
SpriteType type
The sprite type.
Definition spriteloader.hpp:52
SpriteLoader::Sprite::y_offs
int16_t y_offs
The y-offset of where the sprite will be drawn.
Definition spriteloader.hpp:51
Sprite
Data structure describing a sprite.
Definition spritecache.h:17
Sprite::data
uint8_t data[]
Sprite data.
Definition spritecache.h:22
truetypefontcache.h
Common base definition for font file based font caches.
MAX_FONT_SIZE
static const int MAX_FONT_SIZE
Maximum font size.
Definition truetypefontcache.h:16
ScaleGUITrad
static RectPadding ScaleGUITrad(const RectPadding &r)
Scale a RectPadding to GUI zoom level.
Definition widget.cpp:35
ZOOM_LVL_MIN
@ ZOOM_LVL_MIN
Minimum zoom level.
Definition zoom_type.h:41