fontcache.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */
 
#ifndef FONTCACHE_H
#define FONTCACHE_H
 
#include "gfx_type.h"
#include "provider_manager.h"
#include "spritecache_type.h"
 
typedef uint32_t GlyphID;
using FontIndex = uint8_t;
 
static const FontIndex INVALID_FONT_INDEX = std::numeric_limits<FontIndex>::max();
 
enum class FontLoadReason : uint8_t {
  Default,
  Configured,
  LanguageFallback,
  MissingFallback,
  End,
};
 
class FontCache {
protected:
  using FontCaches = std::vector<std::unique_ptr<FontCache>>;
  static FontCaches caches;
 
  struct FontMetrics {
    int height = 0;
    int baseline = 0;
  };
 
  static std::array<FontMetrics, FS_END> metrics;
  static std::array<FontIndex, FS_END> default_font_index;
 
  const FontSize fs; 
  FontIndex font_index; 
  FontLoadReason load_reason; 
  int height = 0; 
  int ascender = 0; 
  int descender = 0; 
 
  FontCache(FontSize fs) : fs(fs) {}
  static void Register(std::unique_ptr<FontCache> &&fc, FontLoadReason load_reason);
  static void LoadDefaultFonts(FontSize fs);
  static void LoadFallbackFonts(FontSize fs, FontLoadReason load_reason);
 
public:
  virtual ~FontCache() = default;
 
  static void InitializeFontCaches();
  static void UninitializeFontCaches();
  static void LoadFontCaches(FontSizes fontsizes);
  static void ClearFontCaches(FontSizes fontsizes);
 
  static const int DEFAULT_FONT_HEIGHT[FS_END];
  static const int DEFAULT_FONT_ASCENDER[FS_END];
 
  static int GetDefaultFontHeight(FontSize fs);
 
  static inline int GetFontBaseline(FontSize fs)
  {
    return FontCache::metrics[fs].baseline;
  }
 
  static void AddFallback(FontSizes fontsizes, FontLoadReason load_reason, std::string_view name, std::span<const std::byte> os_data = {});
 
  template <typename T>
  static void AddFallbackWithHandle(FontSizes fontsizes, FontLoadReason load_reason, std::string_view name, T &handle)
  {
    auto os_data = std::as_bytes(std::span(&handle, 1));
    FontCache::AddFallback(fontsizes, load_reason, name, os_data);
  }
 
  inline FontSize GetSize() const { return this->fs; }
 
  inline FontIndex GetIndex() const { return this->font_index; }
 
  inline FontLoadReason GetFontLoadReason() const { return this->load_reason; }
 
  inline int GetHeight() const { return this->height; }
 
  inline int GetAscender() const { return this->ascender; }
 
  inline int GetDescender() const{ return this->descender; }
 
  virtual int GetFontSize() const { return this->height; }
 
  virtual void ClearFontCache() = 0;
 
  virtual const Sprite *GetGlyph(GlyphID key) = 0;
 
  virtual uint GetGlyphWidth(GlyphID key) = 0;
 
  virtual bool GetDrawGlyphShadow() = 0;
 
  virtual GlyphID MapCharToGlyph(char32_t key) = 0;
 
  virtual const void *GetOSHandle()
  {
    return nullptr;
  }
 
  virtual std::string GetFontName() = 0;
 
  virtual int GetGlyphYOffset();
 
  static inline std::span<const std::unique_ptr<FontCache>> Get()
  {
    return FontCache::caches;
  }
 
  static inline FontCache *Get(FontIndex font_index)
  {
    assert(font_index < FontCache::caches.size());
    return FontCache::caches[font_index].get();
  }
 
  static inline int GetCharacterHeight(FontSize fs)
  {
    return FontCache::metrics[fs].height;
  }
 
  static void UpdateCharacterHeight(FontSize fs);
 
  static inline FontIndex GetDefaultFontIndex(FontSize fs)
  {
    return FontCache::default_font_index[fs];
  }
 
  static inline class FontCache *GetDefaultFontCache(FontSize fs)
  {
    FontIndex index = FontCache::GetDefaultFontIndex(fs);
    if (index != INVALID_FONT_INDEX) return FontCache::Get(index);
    NOT_REACHED();
  }
 
  static inline FontIndex GetFontIndexForCharacter(FontSize fs, char32_t c)
  {
    for (auto it = std::rbegin(FontCache::caches); it != std::rend(FontCache::caches); ++it) {
      FontCache *fc = it->get();
      if (fc == nullptr) continue;
      if (fc->GetSize() != fs) continue;
      if (fc->MapCharToGlyph(c) == 0) continue;
      return std::distance(std::begin(FontCache::caches), std::next(it).base());
    }
    return INVALID_FONT_INDEX;
  }
 
  virtual bool IsBuiltInFont() = 0;
};
 
inline const Sprite *GetGlyph(FontSize size, char32_t key)
{
  FontIndex font_index = FontCache::GetFontIndexForCharacter(size, key);
  FontCache *fc = font_index != INVALID_FONT_INDEX ? FontCache::Get(font_index) : FontCache::GetDefaultFontCache(size);
  if (fc == nullptr) return nullptr;
  return fc->GetGlyph(fc->MapCharToGlyph(key));
}
 
inline uint GetGlyphWidth(FontSize size, char32_t key)
{
  FontIndex font_index = FontCache::GetFontIndexForCharacter(size, key);
  FontCache *fc = font_index != INVALID_FONT_INDEX ? FontCache::Get(font_index) : FontCache::GetDefaultFontCache(size);
  if (fc == nullptr) return 0;
  return fc->GetGlyphWidth(fc->MapCharToGlyph(key));
}
 
struct FontCacheSubSetting {
  std::string font; 
  uint size;        
 
  struct FontCacheFallback {
    FontLoadReason load_reason = FontLoadReason::LanguageFallback;
    std::string name;
    std::vector<std::byte> os_handle;
  };
 
  std::vector<FontCacheFallback> fallback_fonts;
};
 
struct FontCacheSettings {
  FontCacheSubSetting small;  
  FontCacheSubSetting medium; 
  FontCacheSubSetting large;  
  FontCacheSubSetting mono;   
  bool prefer_sprite;         
  bool global_aa;             
  bool prefer_default; 
};
 
extern FontCacheSettings _fcsettings;
 
inline FontCacheSubSetting *GetFontCacheSubSetting(FontSize fs)
{
  switch (fs) {
    default: NOT_REACHED();
    case FS_SMALL:  return &_fcsettings.small;
    case FS_NORMAL: return &_fcsettings.medium;
    case FS_LARGE:  return &_fcsettings.large;
    case FS_MONO:   return &_fcsettings.mono;
  }
}
 
uint GetFontCacheFontSize(FontSize fs);
std::string GetFontCacheFontName(FontSize fs);
 
bool GetFontAAState();
void SetFont(FontSize fontsize, const std::string &font, uint size);
 
enum class FontType : uint8_t {
  Sprite, 
  TrueType, 
};
 
class FontCacheFactory : public BaseProvider<FontCacheFactory> {
public:
  FontCacheFactory(std::string_view name, std::string_view description) : BaseProvider<FontCacheFactory>(name, description)
  {
    ProviderManager<FontCacheFactory>::Register(*this);
  }
 
  virtual ~FontCacheFactory()
  {
    ProviderManager<FontCacheFactory>::Unregister(*this);
  }
 
  virtual std::unique_ptr<FontCache> LoadFont(FontSize fs, FontType fonttype, bool search, const std::string &font_name, std::span<const std::byte> os_handle) const = 0;
  virtual bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, class MissingGlyphSearcher *callback) const = 0;
};
 
class FontProviderManager : ProviderManager<FontCacheFactory> {
public:
  static std::unique_ptr<FontCache> LoadFont(FontSize fs, FontType fonttype, bool search, const std::string &font_name, std::span<const std::byte> os_handle);
  static bool FindFallbackFont(const std::string &language_isocode, FontSizes fontsizes, class MissingGlyphSearcher *callback);
};
 
/* Implemented in spritefontcache.cpp */
void InitializeUnicodeGlyphMap();
void SetUnicodeGlyph(FontSize size, char32_t key, SpriteID sprite);
 
#endif /* FONTCACHE_H */