src/client/fontengine.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2014 sapier <sapier at gmx dot net>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "fontengine.h"
  21 #include <cmath>
  22 #include "client/renderingengine.h"
  23 #include "config.h"
  24 #include "porting.h"
  25 #include "filesys.h"
  26 #include "gettext.h"
  27
  28 #if USE_FREETYPE
  29 #include "irrlicht_changes/CGUITTFont.h"
  30 #endif
  31
  32 /** maximum size distance for getting a "similar" font size */
  33 #define MAX_FONT_SIZE_OFFSET 10
  34
  35 /** reference to access font engine, has to be initialized by main */
  36 FontEngine* g_fontengine = NULL;
  37
  38 /** callback to be used on change of font size setting */
  39 static void font_setting_changed(const std::string &name, void *userdata)
  40 {
  41         g_fontengine->readSettings();
  42 }
  43
  44 /******************************************************************************/
  45 FontEngine::FontEngine(Settings* main_settings, gui::IGUIEnvironment* env) :
  46         m_settings(main_settings),
  47         m_env(env)
  48 {
  49
  50         for (u32 &i : m_default_size) {
  51                 i = (FontMode) FONT_SIZE_UNSPECIFIED;
  52         }
  53
  54         assert(m_settings != NULL); // pre-condition
  55         assert(m_env != NULL); // pre-condition
  56         assert(m_env->getSkin() != NULL); // pre-condition
  57
  58         readSettings();
  59
  60         if (m_currentMode == FM_Standard) {
  61                 m_settings->registerChangedCallback("font_size", font_setting_changed, NULL);
  62                 m_settings->registerChangedCallback("font_bold", font_setting_changed, NULL);
  63                 m_settings->registerChangedCallback("font_italic", font_setting_changed, NULL);
  64                 m_settings->registerChangedCallback("font_path", font_setting_changed, NULL);
  65                 m_settings->registerChangedCallback("font_path_bold", font_setting_changed, NULL);
  66                 m_settings->registerChangedCallback("font_path_italic", font_setting_changed, NULL);
  67                 m_settings->registerChangedCallback("font_path_bolditalic", font_setting_changed, NULL);
  68                 m_settings->registerChangedCallback("font_shadow", font_setting_changed, NULL);
  69                 m_settings->registerChangedCallback("font_shadow_alpha", font_setting_changed, NULL);
  70         }
  71         else if (m_currentMode == FM_Fallback) {
  72                 m_settings->registerChangedCallback("fallback_font_size", font_setting_changed, NULL);
  73                 m_settings->registerChangedCallback("fallback_font_path", font_setting_changed, NULL);
  74                 m_settings->registerChangedCallback("fallback_font_shadow", font_setting_changed, NULL);
  75                 m_settings->registerChangedCallback("fallback_font_shadow_alpha", font_setting_changed, NULL);
  76         }
  77
  78         m_settings->registerChangedCallback("mono_font_path", font_setting_changed, NULL);
  79         m_settings->registerChangedCallback("mono_font_size", font_setting_changed, NULL);
  80         m_settings->registerChangedCallback("screen_dpi", font_setting_changed, NULL);
  81         m_settings->registerChangedCallback("gui_scaling", font_setting_changed, NULL);
  82 }
  83
  84 /******************************************************************************/
  85 FontEngine::~FontEngine()
  86 {
  87         cleanCache();
  88 }
  89
  90 /******************************************************************************/
  91 void FontEngine::cleanCache()
  92 {
  93         for (auto &font_cache_it : m_font_cache) {
  94
  95                 for (auto &font_it : font_cache_it) {
  96                         font_it.second->drop();
  97                         font_it.second = NULL;
  98                 }
  99                 font_cache_it.clear();
 100         }
 101 }
 102
 103 /******************************************************************************/
 104 irr::gui::IGUIFont *FontEngine::getFont(FontSpec spec)
 105 {
 106         if (spec.mode == FM_Unspecified) {
 107                 spec.mode = m_currentMode;
 108         } else if (m_currentMode == FM_Simple) {
 109                 // Freetype disabled -> Force simple mode
 110                 spec.mode = (spec.mode == FM_Mono ||
 111                                 spec.mode == FM_SimpleMono) ?
 112                                 FM_SimpleMono : FM_Simple;
 113                 // Support for those could be added, but who cares?
 114                 spec.bold = false;
 115                 spec.italic = false;
 116         }
 117
 118         // Fallback to default size
 119         if (spec.size == FONT_SIZE_UNSPECIFIED)
 120                 spec.size = m_default_size[spec.mode];
 121
 122         const auto &cache = m_font_cache[spec.getHash()];
 123         auto it = cache.find(spec.size);
 124         if (it != cache.end())
 125                 return it->second;
 126
 127         // Font does not yet exist
 128         gui::IGUIFont *font = nullptr;
 129         if (spec.mode == FM_Simple || spec.mode == FM_SimpleMono)
 130                 font = initSimpleFont(spec);
 131         else
 132                 font = initFont(spec);
 133
 134         m_font_cache[spec.getHash()][spec.size] = font;
 135
 136         return font;
 137 }
 138
 139 /******************************************************************************/
 140 unsigned int FontEngine::getTextHeight(const FontSpec &spec)
 141 {
 142         irr::gui::IGUIFont *font = getFont(spec);
 143
 144         // use current skin font as fallback
 145         if (font == NULL) {
 146                 font = m_env->getSkin()->getFont();
 147         }
 148         FATAL_ERROR_IF(font == NULL, "Could not get skin font");
 149
 150         return font->getDimension(L"Some unimportant example String").Height;
 151 }
 152
 153 /******************************************************************************/
 154 unsigned int FontEngine::getTextWidth(const std::wstring &text, const FontSpec &spec)
 155 {
 156         irr::gui::IGUIFont *font = getFont(spec);
 157
 158         // use current skin font as fallback
 159         if (font == NULL) {
 160                 font = m_env->getSkin()->getFont();
 161         }
 162         FATAL_ERROR_IF(font == NULL, "Could not get font");
 163
 164         return font->getDimension(text.c_str()).Width;
 165 }
 166
 167
 168 /** get line height for a specific font (including empty room between lines) */
 169 unsigned int FontEngine::getLineHeight(const FontSpec &spec)
 170 {
 171         irr::gui::IGUIFont *font = getFont(spec);
 172
 173         // use current skin font as fallback
 174         if (font == NULL) {
 175                 font = m_env->getSkin()->getFont();
 176         }
 177         FATAL_ERROR_IF(font == NULL, "Could not get font");
 178
 179         return font->getDimension(L"Some unimportant example String").Height
 180                         + font->getKerningHeight();
 181 }
 182
 183 /******************************************************************************/
 184 unsigned int FontEngine::getDefaultFontSize()
 185 {
 186         return m_default_size[m_currentMode];
 187 }
 188
 189 /******************************************************************************/
 190 void FontEngine::readSettings()
 191 {
 192         if (USE_FREETYPE && g_settings->getBool("freetype")) {
 193                 m_default_size[FM_Standard] = m_settings->getU16("font_size");
 194                 m_default_size[FM_Fallback] = m_settings->getU16("fallback_font_size");
 195                 m_default_size[FM_Mono]     = m_settings->getU16("mono_font_size");
 196
 197                 m_currentMode = is_yes(gettext("needs_fallback_font")) ?
 198                                 FM_Fallback : FM_Standard;
 199
 200                 m_default_bold = m_settings->getBool("font_bold");
 201                 m_default_italic = m_settings->getBool("font_italic");
 202
 203         } else {
 204                 m_currentMode = FM_Simple;
 205         }
 206
 207         m_default_size[FM_Simple]       = m_settings->getU16("font_size");
 208         m_default_size[FM_SimpleMono]   = m_settings->getU16("mono_font_size");
 209
 210         cleanCache();
 211         updateFontCache();
 212         updateSkin();
 213 }
 214
 215 /******************************************************************************/
 216 void FontEngine::updateSkin()
 217 {
 218         gui::IGUIFont *font = getFont();
 219
 220         if (font)
 221                 m_env->getSkin()->setFont(font);
 222         else
 223                 errorstream << "FontEngine: Default font file: " <<
 224                                 "\n\t\"" << m_settings->get("font_path") << "\"" <<
 225                                 "\n\trequired for current screen configuration was not found" <<
 226                                 " or was invalid file format." <<
 227                                 "\n\tUsing irrlicht default font." << std::endl;
 228
 229         // If we did fail to create a font our own make irrlicht find a default one
 230         font = m_env->getSkin()->getFont();
 231         FATAL_ERROR_IF(font == NULL, "Could not create/get font");
 232
 233         u32 text_height = font->getDimension(L"Hello, world!").Height;
 234         infostream << "text_height=" << text_height << std::endl;
 235 }
 236
 237 /******************************************************************************/
 238 void FontEngine::updateFontCache()
 239 {
 240         /* the only font to be initialized is default one,
 241          * all others are re-initialized on demand */
 242         getFont(FONT_SIZE_UNSPECIFIED, FM_Unspecified);
 243 }
 244
 245 /******************************************************************************/
 246 gui::IGUIFont *FontEngine::initFont(const FontSpec &spec)
 247 {
 248         assert(spec.mode != FM_Unspecified);
 249         assert(spec.size != FONT_SIZE_UNSPECIFIED);
 250
 251         std::string setting_prefix = "";
 252
 253         switch (spec.mode) {
 254                 case FM_Fallback:
 255                         setting_prefix = "fallback_";
 256                         break;
 257                 case FM_Mono:
 258                 case FM_SimpleMono:
 259                         setting_prefix = "mono_";
 260                         break;
 261                 default:
 262                         break;
 263         }
 264
 265         std::string setting_suffix = "";
 266         if (spec.bold)
 267                 setting_suffix.append("_bold");
 268         if (spec.italic)
 269                 setting_suffix.append("_italic");
 270
 271         u32 size = std::floor(RenderingEngine::getDisplayDensity() *
 272                         m_settings->getFloat("gui_scaling") * spec.size);
 273
 274         if (size == 0) {
 275                 errorstream << "FontEngine: attempt to use font size 0" << std::endl;
 276                 errorstream << "  display density: " << RenderingEngine::getDisplayDensity() << std::endl;
 277                 abort();
 278         }
 279
 280         u16 font_shadow       = 0;
 281         u16 font_shadow_alpha = 0;
 282         g_settings->getU16NoEx(setting_prefix + "font_shadow", font_shadow);
 283         g_settings->getU16NoEx(setting_prefix + "font_shadow_alpha",
 284                         font_shadow_alpha);
 285
 286         std::string wanted_font_path;
 287         wanted_font_path = g_settings->get(setting_prefix + "font_path" + setting_suffix);
 288
 289         std::string fallback_settings[] = {
 290                 wanted_font_path,
 291                 m_settings->get("fallback_font_path"),
 292                 m_settings->getDefault(setting_prefix + "font_path")
 293         };
 294
 295 #if USE_FREETYPE
 296         for (const std::string &font_path : fallback_settings) {
 297                 irr::gui::IGUIFont *font = gui::CGUITTFont::createTTFont(m_env,
 298                                 font_path.c_str(), size, true, true, font_shadow,
 299                                 font_shadow_alpha);
 300
 301                 if (font)
 302                         return font;
 303
 304                 errorstream << "FontEngine: Cannot load '" << font_path <<
 305                                 "'. Trying to fall back to another path." << std::endl;
 306         }
 307
 308
 309         // give up
 310         errorstream << "minetest can not continue without a valid font. "
 311                         "Please correct the 'font_path' setting or install the font "
 312                         "file in the proper location" << std::endl;
 313 #else
 314         errorstream << "FontEngine: Tried to load freetype fonts but Minetest was"
 315                         " not compiled with that library." << std::endl;
 316 #endif
 317         abort();
 318 }
 319
 320 /** initialize a font without freetype */
 321 gui::IGUIFont *FontEngine::initSimpleFont(const FontSpec &spec)
 322 {
 323         assert(spec.mode == FM_Simple || spec.mode == FM_SimpleMono);
 324         assert(spec.size != FONT_SIZE_UNSPECIFIED);
 325
 326         const std::string &font_path = m_settings->get(
 327                         (spec.mode == FM_SimpleMono) ? "mono_font_path" : "font_path");
 328
 329         size_t pos_dot = font_path.find_last_of('.');
 330         std::string basename = font_path;
 331         std::string ending = lowercase(font_path.substr(pos_dot));
 332
 333         if (ending == ".ttf") {
 334                 errorstream << "FontEngine: Found font \"" << font_path
 335                                 << "\" but freetype is not available." << std::endl;
 336                 return nullptr;
 337         }
 338
 339         if (ending == ".xml" || ending == ".png")
 340                 basename = font_path.substr(0, pos_dot);
 341
 342         u32 size = std::floor(
 343                         RenderingEngine::getDisplayDensity() *
 344                         m_settings->getFloat("gui_scaling") *
 345                         spec.size);
 346
 347         irr::gui::IGUIFont *font = nullptr;
 348         std::string font_extensions[] = { ".png", ".xml" };
 349
 350         // Find nearest matching font scale
 351         // Does a "zig-zag motion" (positibe/negative), from 0 to MAX_FONT_SIZE_OFFSET
 352         for (s32 zoffset = 0; zoffset < MAX_FONT_SIZE_OFFSET * 2; zoffset++) {
 353                 std::stringstream path;
 354
 355                 // LSB to sign
 356                 s32 sign = (zoffset & 1) ? -1 : 1;
 357                 s32 offset = zoffset >> 1;
 358
 359                 for (const std::string &ext : font_extensions) {
 360                         path.str(""); // Clear
 361                         path << basename << "_" << (size + offset * sign) << ext;
 362
 363                         if (!fs::PathExists(path.str()))
 364                                 continue;
 365
 366                         font = m_env->getFont(path.str().c_str());
 367
 368                         if (font) {
 369                                 verbosestream << "FontEngine: found font: " << path.str() << std::endl;
 370                                 break;
 371                         }
 372                 }
 373
 374                 if (font)
 375                         break;
 376         }
 377
 378         // try name direct
 379         if (font == NULL) {
 380                 if (fs::PathExists(font_path)) {
 381                         font = m_env->getFont(font_path.c_str());
 382                         if (font)
 383                                 verbosestream << "FontEngine: found font: " << font_path << std::endl;
 384                 }
 385         }
 386
 387         return font;
 388 }