th_gfx_font.h

Go to the documentation of this file.

/*
Copyright (c) 2010 Peter "Corsix" Cawley
 
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#ifndef CORSIX_TH_TH_GFX_FONT_H_
#define CORSIX_TH_TH_GFX_FONT_H_
#include "config.h"
 
#include <SDL_render.h>
#include <ft2build.h>  // IWYU pragma: keep
// IWYU pragma: no_include "freetype/config/ftheader.h"
 
#include <climits>
 
#include "th_gfx_sdl.h"
#include FT_FREETYPE_H
#include FT_IMAGE_H
#include FT_TYPES_H
 
enum class text_alignment {
  left = 0,
  center = 1,
  right = 2,
};
 
enum class bitmap_font_character_set { cp437, mik };
 
struct text_layout {
  int row_count;
 
  int start_x;
 
  int end_x;
 
  int start_y;
 
  int end_y;
 
  int width;
};
 
struct font_shadow_options {
  bool enabled{false};
 
  int offset_x{1};
 
  int offset_y{1};
 
  argb_colour color{0xFF000000u};
};
 
class font {
 public:
  virtual ~font() = default;
 
 
  virtual text_layout get_text_dimensions(const char* sMessage,
                                          size_t iMessageLength,
                                          int iMaxWidth = INT_MAX) const = 0;
 
 
  virtual void draw_text(render_target* pCanvas, const char* sMessage,
                         size_t iMessageLength, int iX, int iY) const = 0;
 
 
  virtual text_layout draw_text_wrapped(
      render_target* pCanvas, const char* sMessage, size_t iMessageLength,
      int iX, int iY, int iWidth, int iMaxRows = INT_MAX, int iSkipRows = 0,
      text_alignment eAlign = text_alignment::left) const = 0;
};
 
class bitmap_font final : public font {
 public:
  bitmap_font();
 
 
  void set_sprite_sheet(sprite_sheet* pSpriteSheet,
                        bitmap_font_character_set character_set);
 
  void set_scale_factor(int factor);
 
  sprite_sheet* get_sprite_sheet() { return sheet; }
 
 
  void set_separation(int iCharSep, int iLineSep);
 
  text_layout get_text_dimensions(const char* sMessage, size_t iMessageLength,
                                  int iMaxWidth = INT_MAX) const override;
 
  void draw_text(render_target* pCanvas, const char* sMessage,
                 size_t iMessageLength, int iX, int iY) const override;
 
  text_layout draw_text_wrapped(
      render_target* pCanvas, const char* sMessage, size_t iMessageLength,
      int iX, int iY, int iWidth, int iMaxRows = INT_MAX, int iSkipRows = 0,
      text_alignment eAlign = text_alignment::left) const override;
 
 private:
  sprite_sheet* sheet{nullptr};
  int letter_spacing{};
  int line_spacing{};
  int scale_factor{1};
  bitmap_font_character_set character_set{bitmap_font_character_set::cp437};
};
 
 
class freetype_font final : public font {
 public:
  freetype_font();
  ~freetype_font() override;
 
 
  static const char* get_copyright_notice();
 
 
  FT_Error initialise();
 
  void clear_cache();
 
 
  FT_Error set_face(const uint8_t* pData, size_t iLength);
 
 
  FT_Error match_bitmap_font(sprite_sheet* font_spritesheet, argb_colour* color,
                             int* width, int* height);
 
 
  FT_Error set_ideal_character_size(int iWidth, int iHeight);
 
  void set_font_color(argb_colour color);
 
  void set_shadow_options(const font_shadow_options& options);
 
  text_layout get_text_dimensions(const char* sMessage, size_t iMessageLength,
                                  int iMaxWidth = INT_MAX) const override;
 
  void draw_text(render_target* pCanvas, const char* sMessage,
                 size_t iMessageLength, int iX, int iY) const override;
 
  text_layout draw_text_wrapped(
      render_target* pCanvas, const char* sMessage, size_t iMessageLength,
      int iX, int iY, int iWidth, int iMaxRows = INT_MAX, int iSkipRows = 0,
      text_alignment eAlign = text_alignment::left) const override;
 
 private:
  struct cached_text {
    char* message;
 
    uint8_t* data;
 
    SDL_Texture* texture;
 
    size_t message_length;
 
    size_t message_buffer_length;
 
    int width;
 
    int height;
 
    int widest_line_width;
 
    int last_x;
 
    int row_count;
 
    text_alignment alignment;
 
    bool is_valid;
  };
 
  void render_mono(cached_text* pCacheEntry, FT_Bitmap* pBitmap, FT_Pos x,
                   FT_Pos y) const;
 
  void render_gray(cached_text* pCacheEntry, FT_Bitmap* pBitmap, FT_Pos x,
                   FT_Pos y) const;
 
  static FT_Library freetype_library;
  static int freetype_init_count;
  static constexpr int cache_size_log2{7};
  FT_Face font_face{nullptr};
  argb_colour font_color{0};
  font_shadow_options shadow_opts{};
  bool is_done_freetype_init{false};
  mutable cached_text cache[1 << cache_size_log2]{};
 
  // The following five methods are implemented by the rendering engine.
 
 
  bool is_monochrome() const;
 
 
  void make_texture(const render_target* pEventualCanvas,
                    cached_text* pCacheEntry) const;
 
  static void copy_pixel_data(const cached_text* cacheEntry, argb_colour color,
                              int offsetX, int offsetY,
                              std::vector<argb_colour>::iterator outIter);
 
 
  void free_texture(cached_text* pCacheEntry) const;
 
 
  void draw_texture(render_target* pCanvas, cached_text* pCacheEntry, int iX,
                    int iY) const;
};
 
#endif  // CORSIX_TH_TH_GFX_FONT_H_