SDL3pp_ttf.h

#ifndef SDL3PP_TTF_H_
#define SDL3PP_TTF_H_
 
#include "SDL3pp_gpu.h"
#include "SDL3pp_render.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_version.h"
#include "SDL3pp_video.h"
 
#if !defined(SDL3PP_DISABLE_TTF) && !defined(SDL3PP_ENABLE_TTF) &&             \
  __has_include(<SDL3_ttf/SDL_ttf.h>)
#define SDL3PP_ENABLE_TTF
#endif
 
#if defined(SDL3PP_ENABLE_TTF) || defined(SDL3PP_DOC)
 
#include <SDL3_ttf/SDL_ttf.h>
 
namespace SDL {
 
// Forward decl
struct Font;
 
using FontRaw = TTF_Font*;
 
// Forward decl
struct FontRef;
 
struct FontParam
{
  FontRaw value; 
 
  constexpr FontParam(FontRaw value)
    : value(value)
  {
  }
 
  constexpr FontParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const FontParam& other) const = default;
 
  constexpr operator FontRaw() const { return value; }
};
 
// Forward decl
struct TextEngine;
 
using TextEngineRaw = TTF_TextEngine*;
 
struct TextEngineParam
{
  TextEngineRaw value; 
 
  constexpr TextEngineParam(TextEngineRaw value)
    : value(value)
  {
  }
 
  constexpr TextEngineParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const TextEngineParam& other) const = default;
 
  constexpr operator TextEngineRaw() const { return value; }
};
 
// Forward decl
struct Text;
 
using TextRaw = TTF_Text*;
 
// Forward decl
struct TextRef;
 
struct TextParam
{
  TextRaw value; 
 
  constexpr TextParam(TextRaw value)
    : value(value)
  {
  }
 
  constexpr TextParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const TextParam& other) const = default;
 
  constexpr operator TextRaw() const { return value; }
};
 
#ifdef SDL3PP_DOC
 
#define SDL_TTF_MAJOR_VERSION
 
#define SDL_TTF_MINOR_VERSION
 
#define SDL_TTF_MICRO_VERSION
 
 
#define SDL_TTF_VERSION                                                        \
  SDL_VERSIONNUM(                                                              \
    SDL_TTF_MAJOR_VERSION, SDL_TTF_MINOR_VERSION, SDL_TTF_MICRO_VERSION)
 
#define SDL_TTF_VERSION_ATLEAST(X, Y, Z)                                       \
  ((SDL_TTF_MAJOR_VERSION >= X) &&                                             \
   (SDL_TTF_MAJOR_VERSION > X || SDL_TTF_MINOR_VERSION >= Y) &&                \
   (SDL_TTF_MAJOR_VERSION > X || SDL_TTF_MINOR_VERSION > Y ||                  \
    SDL_TTF_MICRO_VERSION >= Z))
 
#endif // SDL3PP_DOC
 
namespace TTF {
 
inline int Version() { return TTF_Version(); }
 
inline void Init() { CheckError(TTF_Init()); }
 
inline void Quit() { TTF_Quit(); }
 
inline int WasInit() { return TTF_WasInit(); }
 
} // namespace TTF
 
inline void GetFreeTypeVersion(int* major, int* minor, int* patch)
{
  TTF_GetFreeTypeVersion(major, minor, patch);
}
 
inline void GetHarfBuzzVersion(int* major, int* minor, int* patch)
{
  TTF_GetHarfBuzzVersion(major, minor, patch);
}
 
using TextData = TTF_TextData;
 
using FontStyleFlags = Uint32;
 
constexpr FontStyleFlags STYLE_NORMAL = TTF_STYLE_NORMAL; 
 
constexpr FontStyleFlags STYLE_BOLD = TTF_STYLE_BOLD; 
 
constexpr FontStyleFlags STYLE_ITALIC = TTF_STYLE_ITALIC; 
 
constexpr FontStyleFlags STYLE_UNDERLINE =
  TTF_STYLE_UNDERLINE; 
 
constexpr FontStyleFlags STYLE_STRIKETHROUGH =
  TTF_STYLE_STRIKETHROUGH; 
 
using HintingFlags = TTF_HintingFlags;
 
constexpr HintingFlags HINTING_INVALID = TTF_HINTING_INVALID; 
 
constexpr HintingFlags HINTING_NORMAL =
  TTF_HINTING_NORMAL; 
 
constexpr HintingFlags HINTING_LIGHT = TTF_HINTING_LIGHT;
 
constexpr HintingFlags HINTING_MONO = TTF_HINTING_MONO;
 
constexpr HintingFlags HINTING_NONE = TTF_HINTING_NONE;
 
constexpr HintingFlags HINTING_LIGHT_SUBPIXEL = TTF_HINTING_LIGHT_SUBPIXEL;
 
using HorizontalAlignment = TTF_HorizontalAlignment;
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_INVALID =
  TTF_HORIZONTAL_ALIGN_INVALID; 
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_LEFT =
  TTF_HORIZONTAL_ALIGN_LEFT; 
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_CENTER =
  TTF_HORIZONTAL_ALIGN_CENTER; 
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_RIGHT =
  TTF_HORIZONTAL_ALIGN_RIGHT; 
 
using Direction = TTF_Direction;
 
constexpr Direction DIRECTION_INVALID = TTF_DIRECTION_INVALID; 
 
constexpr Direction DIRECTION_LTR = TTF_DIRECTION_LTR; 
 
constexpr Direction DIRECTION_RTL = TTF_DIRECTION_RTL; 
 
constexpr Direction DIRECTION_TTB = TTF_DIRECTION_TTB; 
 
constexpr Direction DIRECTION_BTT = TTF_DIRECTION_BTT; 
 
using ImageType = TTF_ImageType;
 
constexpr ImageType IMAGE_INVALID = TTF_IMAGE_INVALID; 
 
constexpr ImageType IMAGE_ALPHA =
  TTF_IMAGE_ALPHA; 
 
constexpr ImageType IMAGE_COLOR =
  TTF_IMAGE_COLOR; 
 
constexpr ImageType IMAGE_SDF = TTF_IMAGE_SDF;
 
class Font
{
  FontRaw m_resource = nullptr;
 
public:
  constexpr Font() = default;
 
  constexpr explicit Font(const FontRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr Font(const Font& other) = delete;
 
  constexpr Font(Font&& other)
    : Font(other.release())
  {
  }
 
  constexpr Font(const FontRef& other) = delete;
 
  constexpr Font(FontRef&& other) = delete;
 
  Font(StringParam file, float ptsize)
    : m_resource(CheckError(TTF_OpenFont(file, ptsize)))
  {
  }
 
  Font(IOStreamParam src, float ptsize, bool closeio = false)
    : m_resource(CheckError(TTF_OpenFontIO(src, closeio, ptsize)))
  {
  }
 
  Font(PropertiesParam props)
    : m_resource(CheckError(TTF_OpenFontWithProperties(props)))
  {
  }
 
  ~Font() { TTF_CloseFont(m_resource); }
 
  Font& operator=(Font other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr FontRaw get() const { return m_resource; }
 
  constexpr FontRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Font& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator FontParam() const { return {m_resource}; }
 
  void Close();
 
  Font Copy() const;
 
  PropertiesRef GetProperties();
 
  Uint32 GetGeneration() const;
 
  void AddFallback(FontParam fallback);
 
  void RemoveFallback(FontParam fallback);
 
  void ClearFallbacks();
 
  void SetSize(float ptsize);
 
  void SetSizeDPI(float ptsize, int hdpi, int vdpi);
 
  float GetSize() const;
 
  void GetDPI(int* hdpi, int* vdpi) const;
 
  void SetStyle(FontStyleFlags style);
 
  FontStyleFlags GetStyle() const;
 
  void SetOutline(int outline);
 
  int GetOutline() const;
 
  void SetHinting(HintingFlags hinting);
 
  int GetNumFaces() const;
 
  HintingFlags GetHinting() const;
 
  void SetSDF(bool enabled);
 
  bool GetSDF() const;
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
  int GetWeight() const;
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
  void SetWrapAlignment(HorizontalAlignment align);
 
  HorizontalAlignment GetWrapAlignment() const;
 
  int GetHeight() const;
 
  int GetAscent() const;
 
  int GetDescent() const;
 
  void SetLineSkip(int lineskip);
 
  int GetLineSkip() const;
 
  void SetKerning(bool enabled);
 
  bool GetKerning() const;
 
  bool IsFixedWidth() const;
 
  bool IsScalable() const;
 
  const char* GetFamilyName() const;
 
  const char* GetStyleName() const;
 
  void SetDirection(Direction direction);
 
  Direction GetDirection() const;
 
  void SetScript(Uint32 script);
 
  Uint32 GetScript() const;
 
  static Uint32 GetGlyphScript(Uint32 ch);
 
  void SetLanguage(StringParam language_bcp47);
 
  bool HasGlyph(Uint32 ch) const;
 
  Surface GetGlyphImage(Uint32 ch, ImageType* image_type) const;
 
  Surface GetGlyphImageForIndex(Uint32 glyph_index,
                                ImageType* image_type) const;
 
  void GetGlyphMetrics(Uint32 ch,
                       int* minx,
                       int* maxx,
                       int* miny,
                       int* maxy,
                       int* advance) const;
 
  int GetGlyphKerning(Uint32 previous_ch, Uint32 ch) const;
 
  Point GetStringSize(std::string_view text) const
  {
    Point p;
    GetStringSize(text, &p.x, &p.y);
    return p;
  }
 
  void GetStringSize(std::string_view text, int* w, int* h) const;
 
  Point GetStringSizeWrapped(std::string_view text, int wrap_width) const
  {
    Point p;
    GetStringSizeWrapped(text, wrap_width, &p.x, &p.y);
    return p;
  }
 
  void GetStringSizeWrapped(std::string_view text,
                            int wrap_width,
                            int* w,
                            int* h) const;
 
  void MeasureString(std::string_view text,
                     int max_width,
                     int* measured_width,
                     size_t* measured_length) const;
 
  Surface RenderText_Solid(std::string_view text, Color fg) const;
 
  Surface RenderText_Solid_Wrapped(std::string_view text,
                                   Color fg,
                                   int wrapLength) const;
 
  Surface RenderGlyph_Solid(Uint32 ch, ColorRaw fg) const;
 
  Surface RenderText_Shaded(std::string_view text, Color fg, Color bg) const;
 
  Surface RenderText_Shaded_Wrapped(std::string_view text,
                                    Color fg,
                                    Color bg,
                                    int wrap_width) const;
 
  Surface RenderGlyph_Shaded(Uint32 ch, ColorRaw fg, ColorRaw bg) const;
 
  Surface RenderText_Blended(std::string_view text, Color fg) const;
 
  Surface RenderText_Blended_Wrapped(std::string_view text,
                                     Color fg,
                                     int wrap_width) const;
 
  Surface RenderGlyph_Blended(Uint32 ch, ColorRaw fg) const;
 
  Surface RenderText_LCD(std::string_view text, Color fg, Color bg) const;
 
  Surface RenderText_LCD_Wrapped(std::string_view text,
                                 Color fg,
                                 Color bg,
                                 int wrap_width) const;
 
  Surface RenderGlyph_LCD(Uint32 ch, ColorRaw fg, ColorRaw bg) const;
};
 
struct FontRef : Font
{
  FontRef(FontParam resource)
    : Font(resource.value)
  {
  }
 
  FontRef(const FontRef& other)
    : Font(other.get())
  {
  }
 
  ~FontRef() { release(); }
};
 
using SubStringFlags = Uint32;
 
constexpr SubStringFlags SUBSTRING_DIRECTION_MASK =
  TTF_SUBSTRING_DIRECTION_MASK; 
 
constexpr SubStringFlags SUBSTRING_TEXT_START =
  TTF_SUBSTRING_TEXT_START; 
 
constexpr SubStringFlags SUBSTRING_LINE_START = TTF_SUBSTRING_LINE_START;
 
constexpr SubStringFlags SUBSTRING_LINE_END = TTF_SUBSTRING_LINE_END;
 
constexpr SubStringFlags SUBSTRING_TEXT_END =
  TTF_SUBSTRING_TEXT_END; 
 
using GPUTextEngineWinding = TTF_GPUTextEngineWinding;
 
constexpr GPUTextEngineWinding GPU_TEXTENGINE_WINDING_INVALID =
  TTF_GPU_TEXTENGINE_WINDING_INVALID; 
 
constexpr GPUTextEngineWinding GPU_TEXTENGINE_WINDING_CLOCKWISE =
  TTF_GPU_TEXTENGINE_WINDING_CLOCKWISE; 
 
constexpr GPUTextEngineWinding GPU_TEXTENGINE_WINDING_COUNTER_CLOCKWISE =
  TTF_GPU_TEXTENGINE_WINDING_COUNTER_CLOCKWISE; 
 
class TextEngine
{
  TextEngineRaw m_resource = nullptr;
 
public:
  constexpr TextEngine() = default;
 
  constexpr explicit TextEngine(const TextEngineRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr TextEngine(const TextEngine& other) = delete;
 
  constexpr TextEngine(TextEngine&& other)
    : TextEngine(other.release())
  {
  }
 
  virtual ~TextEngine() = default;
 
  TextEngine& operator=(TextEngine&& other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  TextEngine& operator=(const TextEngine& other) = delete;
 
  constexpr TextEngineRaw get() const { return m_resource; }
 
  constexpr TextEngineRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const TextEngine& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator TextEngineParam() const { return {m_resource}; }
 
  virtual void Destroy() = 0;
 
  Text CreateText(FontParam font, std::string_view text);
};
 
struct SurfaceTextEngine : TextEngine
{
  SurfaceTextEngine()
    : TextEngine(TTF_CreateSurfaceTextEngine())
  {
  }
 
  ~SurfaceTextEngine() { Destroy(); }
 
  void Destroy() final;
};
 
struct RendererTextEngine : TextEngine
{
  RendererTextEngine(RendererParam renderer)
    : TextEngine(TTF_CreateRendererTextEngine(renderer))
  {
  }
 
  RendererTextEngine(PropertiesParam props)
    : TextEngine(TTF_CreateRendererTextEngineWithProperties(props))
  {
  }
 
  ~RendererTextEngine() { Destroy(); }
 
  void Destroy() final;
};
 
struct GPUTextEngine : TextEngine
{
  GPUTextEngine(GPUDeviceParam device)
    : TextEngine(TTF_CreateGPUTextEngine(device))
  {
  }
 
  GPUTextEngine(PropertiesParam props)
    : TextEngine(TTF_CreateGPUTextEngineWithProperties(props))
  {
  }
 
  ~GPUTextEngine() { Destroy(); }
 
  void SetGPUWinding(GPUTextEngineWinding winding);
 
  GPUTextEngineWinding GetGPUWinding() const;
 
  void Destroy() final;
};
 
using GPUAtlasDrawSequence = TTF_GPUAtlasDrawSequence;
 
using SubString = TTF_SubString;
 
// Forward decl
struct SubStringIterator;
 
inline Font OpenFont(StringParam file, float ptsize)
{
  return Font(std::move(file), ptsize);
}
 
inline Font OpenFont(IOStreamParam src, float ptsize, bool closeio = false)
{
  return Font(src, ptsize, closeio);
}
 
inline Font OpenFontWithProperties(PropertiesParam props)
{
  return Font(props);
}
 
namespace prop::Font {
 
constexpr auto CREATE_FILENAME_STRING = TTF_PROP_FONT_CREATE_FILENAME_STRING;
 
constexpr auto CREATE_IOSTREAM_POINTER = TTF_PROP_FONT_CREATE_IOSTREAM_POINTER;
 
constexpr auto CREATE_IOSTREAM_OFFSET_NUMBER =
  TTF_PROP_FONT_CREATE_IOSTREAM_OFFSET_NUMBER;
 
constexpr auto CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN =
  TTF_PROP_FONT_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN;
 
constexpr auto CREATE_SIZE_FLOAT = TTF_PROP_FONT_CREATE_SIZE_FLOAT;
 
constexpr auto CREATE_FACE_NUMBER = TTF_PROP_FONT_CREATE_FACE_NUMBER;
 
constexpr auto CREATE_HORIZONTAL_DPI_NUMBER =
  TTF_PROP_FONT_CREATE_HORIZONTAL_DPI_NUMBER;
 
constexpr auto CREATE_VERTICAL_DPI_NUMBER =
  TTF_PROP_FONT_CREATE_VERTICAL_DPI_NUMBER;
 
constexpr auto CREATE_EXISTING_FONT_POINTER =
  TTF_PROP_FONT_CREATE_EXISTING_FONT_POINTER;
 
constexpr auto OUTLINE_LINE_CAP_NUMBER = TTF_PROP_FONT_OUTLINE_LINE_CAP_NUMBER;
 
constexpr auto OUTLINE_LINE_JOIN_NUMBER =
  TTF_PROP_FONT_OUTLINE_LINE_JOIN_NUMBER;
 
constexpr auto OUTLINE_MITER_LIMIT_NUMBER =
  TTF_PROP_FONT_OUTLINE_MITER_LIMIT_NUMBER;
 
} // namespace prop::Font
 
inline Font CopyFont(FontParam existing_font)
{
  return Font(CheckError(TTF_CopyFont(existing_font)));
}
 
inline Font Font::Copy() const { return SDL::CopyFont(m_resource); }
 
inline PropertiesRef GetFontProperties(FontParam font)
{
  return {CheckError(TTF_GetFontProperties(font))};
}
 
inline PropertiesRef Font::GetProperties()
{
  return SDL::GetFontProperties(m_resource);
}
 
inline Uint32 GetFontGeneration(FontParam font)
{
  return TTF_GetFontGeneration(font);
}
 
inline Uint32 Font::GetGeneration() const
{
  return SDL::GetFontGeneration(m_resource);
}
 
inline void AddFallbackFont(FontParam font, FontParam fallback)
{
  CheckError(TTF_AddFallbackFont(font, fallback));
}
 
inline void Font::AddFallback(FontParam fallback)
{
  SDL::AddFallbackFont(m_resource, fallback);
}
 
inline void RemoveFallbackFont(FontParam font, FontParam fallback)
{
  TTF_RemoveFallbackFont(font, fallback);
}
 
inline void Font::RemoveFallback(FontParam fallback)
{
  SDL::RemoveFallbackFont(m_resource, fallback);
}
 
inline void ClearFallbackFonts(FontParam font) { TTF_ClearFallbackFonts(font); }
 
inline void Font::ClearFallbacks() { SDL::ClearFallbackFonts(m_resource); }
 
inline void SetFontSize(FontParam font, float ptsize)
{
  CheckError(TTF_SetFontSize(font, ptsize));
}
 
inline void Font::SetSize(float ptsize)
{
  SDL::SetFontSize(m_resource, ptsize);
}
 
inline void SetFontSizeDPI(FontParam font, float ptsize, int hdpi, int vdpi)
{
  CheckError(TTF_SetFontSizeDPI(font, ptsize, hdpi, vdpi));
}
 
inline void Font::SetSizeDPI(float ptsize, int hdpi, int vdpi)
{
  SDL::SetFontSizeDPI(m_resource, ptsize, hdpi, vdpi);
}
 
inline float GetFontSize(FontParam font) { return TTF_GetFontSize(font); }
 
inline float Font::GetSize() const { return SDL::GetFontSize(m_resource); }
 
inline void GetFontDPI(FontParam font, int* hdpi, int* vdpi)
{
  CheckError(TTF_GetFontDPI(font, hdpi, vdpi));
}
 
inline void Font::GetDPI(int* hdpi, int* vdpi) const
{
  SDL::GetFontDPI(m_resource, hdpi, vdpi);
}
 
inline void SetFontStyle(FontParam font, FontStyleFlags style)
{
  TTF_SetFontStyle(font, style);
}
 
inline void Font::SetStyle(FontStyleFlags style)
{
  SDL::SetFontStyle(m_resource, style);
}
 
inline FontStyleFlags GetFontStyle(FontParam font)
{
  return TTF_GetFontStyle(font);
}
 
inline FontStyleFlags Font::GetStyle() const
{
  return SDL::GetFontStyle(m_resource);
}
 
inline void SetFontOutline(FontParam font, int outline)
{
  CheckError(TTF_SetFontOutline(font, outline));
}
 
inline void Font::SetOutline(int outline)
{
  SDL::SetFontOutline(m_resource, outline);
}
 
inline int GetFontOutline(FontParam font) { return TTF_GetFontOutline(font); }
 
inline int Font::GetOutline() const { return SDL::GetFontOutline(m_resource); }
 
inline void SetFontHinting(FontParam font, HintingFlags hinting)
{
  TTF_SetFontHinting(font, hinting);
}
 
inline void Font::SetHinting(HintingFlags hinting)
{
  SDL::SetFontHinting(m_resource, hinting);
}
 
inline int GetNumFontFaces(FontParam font) { return TTF_GetNumFontFaces(font); }
 
inline int Font::GetNumFaces() const
{
  return SDL::GetNumFontFaces(m_resource);
}
 
inline HintingFlags GetFontHinting(FontParam font)
{
  return TTF_GetFontHinting(font);
}
 
inline HintingFlags Font::GetHinting() const
{
  return SDL::GetFontHinting(m_resource);
}
 
inline void SetFontSDF(FontParam font, bool enabled)
{
  CheckError(TTF_SetFontSDF(font, enabled));
}
 
inline void Font::SetSDF(bool enabled) { SDL::SetFontSDF(m_resource, enabled); }
 
inline bool GetFontSDF(FontParam font) { return TTF_GetFontSDF(font); }
 
inline bool Font::GetSDF() const { return SDL::GetFontSDF(m_resource); }
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
inline int GetFontWeight(FontParam font) { return TTF_GetFontWeight(font); }
 
inline int Font::GetWeight() const { return SDL::GetFontWeight(m_resource); }
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
#define SDL_FONT_WEIGHT_THIN TTF_FONT_WEIGHT_THIN
 
#define SDL_FONT_WEIGHT_EXTRA_LIGHT TTF_FONT_WEIGHT_EXTRA_LIGHT
 
#define SDL_FONT_WEIGHT_LIGHT TTF_FONT_WEIGHT_LIGHT
 
#define SDL_FONT_WEIGHT_NORMAL TTF_FONT_WEIGHT_NORMAL
 
#define SDL_FONT_WEIGHT_MEDIUM TTF_FONT_WEIGHT_MEDIUM
 
#define SDL_FONT_WEIGHT_SEMI_BOLD TTF_FONT_WEIGHT_SEMI_BOLD
 
#define SDL_FONT_WEIGHT_BOLD TTF_FONT_WEIGHT_BOLD
 
#define SDL_FONT_WEIGHT_EXTRA_BOLD TTF_FONT_WEIGHT_EXTRA_BOLD
 
#define SDL_FONT_WEIGHT_BLACK TTF_FONT_WEIGHT_BLACK
 
#define SDL_FONT_WEIGHT_EXTRA_BLACK TTF_FONT_WEIGHT_EXTRA_BLACK
 
inline void SetFontWrapAlignment(FontParam font, HorizontalAlignment align)
{
  TTF_SetFontWrapAlignment(font, align);
}
 
inline void Font::SetWrapAlignment(HorizontalAlignment align)
{
  SDL::SetFontWrapAlignment(m_resource, align);
}
 
inline HorizontalAlignment GetFontWrapAlignment(FontParam font)
{
  return TTF_GetFontWrapAlignment(font);
}
 
inline HorizontalAlignment Font::GetWrapAlignment() const
{
  return SDL::GetFontWrapAlignment(m_resource);
}
 
inline int GetFontHeight(FontParam font) { return TTF_GetFontHeight(font); }
 
inline int Font::GetHeight() const { return SDL::GetFontHeight(m_resource); }
 
inline int GetFontAscent(FontParam font) { return TTF_GetFontAscent(font); }
 
inline int Font::GetAscent() const { return SDL::GetFontAscent(m_resource); }
 
inline int GetFontDescent(FontParam font) { return TTF_GetFontDescent(font); }
 
inline int Font::GetDescent() const { return SDL::GetFontDescent(m_resource); }
 
inline void SetFontLineSkip(FontParam font, int lineskip)
{
  TTF_SetFontLineSkip(font, lineskip);
}
 
inline void Font::SetLineSkip(int lineskip)
{
  SDL::SetFontLineSkip(m_resource, lineskip);
}
 
inline int GetFontLineSkip(FontParam font) { return TTF_GetFontLineSkip(font); }
 
inline int Font::GetLineSkip() const
{
  return SDL::GetFontLineSkip(m_resource);
}
 
inline void SetFontKerning(FontParam font, bool enabled)
{
  TTF_SetFontKerning(font, enabled);
}
 
inline void Font::SetKerning(bool enabled)
{
  SDL::SetFontKerning(m_resource, enabled);
}
 
inline bool GetFontKerning(FontParam font) { return TTF_GetFontKerning(font); }
 
inline bool Font::GetKerning() const { return SDL::GetFontKerning(m_resource); }
 
inline bool FontIsFixedWidth(FontParam font)
{
  return TTF_FontIsFixedWidth(font);
}
 
inline bool Font::IsFixedWidth() const
{
  return SDL::FontIsFixedWidth(m_resource);
}
 
inline bool FontIsScalable(FontParam font) { return TTF_FontIsScalable(font); }
 
inline bool Font::IsScalable() const { return SDL::FontIsScalable(m_resource); }
 
inline const char* GetFontFamilyName(FontParam font)
{
  return TTF_GetFontFamilyName(font);
}
 
inline const char* Font::GetFamilyName() const
{
  return SDL::GetFontFamilyName(m_resource);
}
 
inline const char* GetFontStyleName(FontParam font)
{
  return TTF_GetFontStyleName(font);
}
 
inline const char* Font::GetStyleName() const
{
  return SDL::GetFontStyleName(m_resource);
}
 
inline void SetFontDirection(FontParam font, Direction direction)
{
  CheckError(TTF_SetFontDirection(font, direction));
}
 
inline void Font::SetDirection(Direction direction)
{
  SDL::SetFontDirection(m_resource, direction);
}
 
inline Direction GetFontDirection(FontParam font)
{
  return TTF_GetFontDirection(font);
}
 
inline Direction Font::GetDirection() const
{
  return SDL::GetFontDirection(m_resource);
}
 
inline Uint32 StringToTag(StringParam string)
{
  return TTF_StringToTag(string);
}
 
inline void TagToString(Uint32 tag, char* string, size_t size)
{
  TTF_TagToString(tag, string, size);
}
 
inline void SetFontScript(FontParam font, Uint32 script)
{
  CheckError(TTF_SetFontScript(font, script));
}
 
inline void Font::SetScript(Uint32 script)
{
  SDL::SetFontScript(m_resource, script);
}
 
inline Uint32 GetFontScript(FontParam font) { return TTF_GetFontScript(font); }
 
inline Uint32 Font::GetScript() const { return SDL::GetFontScript(m_resource); }
 
inline Uint32 GetGlyphScript(Uint32 ch) { return TTF_GetGlyphScript(ch); }
 
inline Uint32 Font::GetGlyphScript(Uint32 ch)
{
  return SDL::GetGlyphScript(ch);
}
 
inline void SetFontLanguage(FontParam font, StringParam language_bcp47)
{
  CheckError(TTF_SetFontLanguage(font, language_bcp47));
}
 
inline void Font::SetLanguage(StringParam language_bcp47)
{
  SDL::SetFontLanguage(m_resource, std::move(language_bcp47));
}
 
inline bool FontHasGlyph(FontParam font, Uint32 ch)
{
  return TTF_FontHasGlyph(font, ch);
}
 
inline bool Font::HasGlyph(Uint32 ch) const
{
  return SDL::FontHasGlyph(m_resource, ch);
}
 
inline Surface GetGlyphImage(FontParam font, Uint32 ch, ImageType* image_type)
{
  return Surface{TTF_GetGlyphImage(font, ch, image_type)};
}
 
inline Surface Font::GetGlyphImage(Uint32 ch, ImageType* image_type) const
{
  return SDL::GetGlyphImage(m_resource, ch, image_type);
}
 
inline Surface GetGlyphImageForIndex(FontParam font,
                                     Uint32 glyph_index,
                                     ImageType* image_type)
{
  return Surface(TTF_GetGlyphImageForIndex(font, glyph_index, image_type));
}
 
inline Surface Font::GetGlyphImageForIndex(Uint32 glyph_index,
                                           ImageType* image_type) const
{
  return SDL::GetGlyphImageForIndex(m_resource, glyph_index, image_type);
}
 
inline void GetGlyphMetrics(FontParam font,
                            Uint32 ch,
                            int* minx,
                            int* maxx,
                            int* miny,
                            int* maxy,
                            int* advance)
{
  CheckError(TTF_GetGlyphMetrics(font, ch, minx, maxx, miny, maxy, advance));
}
 
inline void Font::GetGlyphMetrics(Uint32 ch,
                                  int* minx,
                                  int* maxx,
                                  int* miny,
                                  int* maxy,
                                  int* advance) const
{
  SDL::GetGlyphMetrics(m_resource, ch, minx, maxx, miny, maxy, advance);
}
 
inline int GetGlyphKerning(FontParam font, Uint32 previous_ch, Uint32 ch)
{
  if (int r; TTF_GetGlyphKerning(font, previous_ch, ch, &r)) return r;
  throw Error();
}
 
inline int Font::GetGlyphKerning(Uint32 previous_ch, Uint32 ch) const
{
  return SDL::GetGlyphKerning(m_resource, previous_ch, ch);
}
 
inline void GetStringSize(FontParam font, std::string_view text, int* w, int* h)
{
  CheckError(TTF_GetStringSize(font, text.data(), text.size(), w, h));
}
 
inline void Font::GetStringSize(std::string_view text, int* w, int* h) const
{
  SDL::GetStringSize(m_resource, text, w, h);
}
 
inline void GetStringSizeWrapped(FontParam font,
                                 std::string_view text,
                                 int wrap_width,
                                 int* w,
                                 int* h)
{
  CheckError(
    TTF_GetStringSizeWrapped(font, text.data(), text.size(), wrap_width, w, h));
}
 
inline void Font::GetStringSizeWrapped(std::string_view text,
                                       int wrap_width,
                                       int* w,
                                       int* h) const
{
  SDL::GetStringSizeWrapped(m_resource, text, wrap_width, w, h);
}
 
inline void MeasureString(FontParam font,
                          std::string_view text,
                          int max_width,
                          int* measured_width,
                          size_t* measured_length)
{
  CheckError(TTF_MeasureString(font,
                               text.data(),
                               text.size(),
                               max_width,
                               measured_width,
                               measured_length));
}
 
inline void Font::MeasureString(std::string_view text,
                                int max_width,
                                int* measured_width,
                                size_t* measured_length) const
{
  SDL::MeasureString(
    m_resource, text, max_width, measured_width, measured_length);
}
 
inline Surface RenderText_Solid(FontParam font, std::string_view text, Color fg)
{
  return Surface{TTF_RenderText_Solid(font, text.data(), text.size(), fg)};
}
 
inline Surface Font::RenderText_Solid(std::string_view text, Color fg) const
{
  return SDL::RenderText_Solid(m_resource, text, fg);
}
 
inline Surface RenderText_Solid_Wrapped(FontParam font,
                                        std::string_view text,
                                        Color fg,
                                        int wrapLength)
{
  return Surface(TTF_RenderText_Solid_Wrapped(
    font, text.data(), text.size(), fg, wrapLength));
}
 
inline Surface Font::RenderText_Solid_Wrapped(std::string_view text,
                                              Color fg,
                                              int wrapLength) const
{
  return SDL::RenderText_Solid_Wrapped(m_resource, text, fg, wrapLength);
}
 
inline Surface RenderGlyph_Solid(FontParam font, Uint32 ch, ColorRaw fg)
{
  return Surface(TTF_RenderGlyph_Solid(font, ch, fg));
}
 
inline Surface Font::RenderGlyph_Solid(Uint32 ch, ColorRaw fg) const
{
  return SDL::RenderGlyph_Solid(m_resource, ch, fg);
}
 
inline Surface RenderText_Shaded(FontParam font,
                                 std::string_view text,
                                 Color fg,
                                 Color bg)
{
  return Surface(TTF_RenderText_Shaded(font, text.data(), text.size(), fg, bg));
}
 
inline Surface Font::RenderText_Shaded(std::string_view text,
                                       Color fg,
                                       Color bg) const
{
  return SDL::RenderText_Shaded(m_resource, text, fg, bg);
}
 
inline Surface RenderText_Shaded_Wrapped(FontParam font,
                                         std::string_view text,
                                         Color fg,
                                         Color bg,
                                         int wrap_width)
{
  return Surface(TTF_RenderText_Shaded_Wrapped(
    font, text.data(), text.size(), fg, bg, wrap_width));
}
 
inline Surface Font::RenderText_Shaded_Wrapped(std::string_view text,
                                               Color fg,
                                               Color bg,
                                               int wrap_width) const
{
  return SDL::RenderText_Shaded_Wrapped(m_resource, text, fg, bg, wrap_width);
}
 
inline Surface RenderGlyph_Shaded(FontParam font,
                                  Uint32 ch,
                                  ColorRaw fg,
                                  ColorRaw bg)
{
  return Surface(TTF_RenderGlyph_Shaded(font, ch, fg, bg));
}
 
inline Surface Font::RenderGlyph_Shaded(Uint32 ch,
                                        ColorRaw fg,
                                        ColorRaw bg) const
{
  return SDL::RenderGlyph_Shaded(m_resource, ch, fg, bg);
}
 
inline Surface RenderText_Blended(FontParam font,
                                  std::string_view text,
                                  Color fg)
{
  return Surface(TTF_RenderText_Blended(font, text.data(), text.size(), fg));
}
 
inline Surface Font::RenderText_Blended(std::string_view text, Color fg) const
{
  return SDL::RenderText_Blended(m_resource, text, fg);
}
 
inline Surface RenderText_Blended_Wrapped(FontParam font,
                                          std::string_view text,
                                          Color fg,
                                          int wrap_width)
{
  return Surface(TTF_RenderText_Blended_Wrapped(
    font, text.data(), text.size(), fg, wrap_width));
}
 
inline Surface Font::RenderText_Blended_Wrapped(std::string_view text,
                                                Color fg,
                                                int wrap_width) const
{
  return SDL::RenderText_Blended_Wrapped(m_resource, text, fg, wrap_width);
}
 
inline Surface RenderGlyph_Blended(FontParam font, Uint32 ch, ColorRaw fg)
{
  return Surface(TTF_RenderGlyph_Blended(font, ch, fg));
}
 
inline Surface Font::RenderGlyph_Blended(Uint32 ch, ColorRaw fg) const
{
  return SDL::RenderGlyph_Blended(m_resource, ch, fg);
}
 
inline Surface RenderText_LCD(FontParam font,
                              std::string_view text,
                              Color fg,
                              Color bg)
{
  return Surface(TTF_RenderText_LCD(font, text.data(), text.size(), fg, bg));
}
 
inline Surface Font::RenderText_LCD(std::string_view text,
                                    Color fg,
                                    Color bg) const
{
  return SDL::RenderText_LCD(m_resource, text, fg, bg);
}
 
inline Surface RenderText_LCD_Wrapped(FontParam font,
                                      std::string_view text,
                                      Color fg,
                                      Color bg,
                                      int wrap_width)
{
  return Surface(TTF_RenderText_LCD_Wrapped(
    font, text.data(), text.size(), fg, bg, wrap_width));
}
 
inline Surface Font::RenderText_LCD_Wrapped(std::string_view text,
                                            Color fg,
                                            Color bg,
                                            int wrap_width) const
{
  return SDL::RenderText_LCD_Wrapped(m_resource, text, fg, bg, wrap_width);
}
 
inline Surface RenderGlyph_LCD(FontParam font,
                               Uint32 ch,
                               ColorRaw fg,
                               ColorRaw bg)
{
  return Surface(TTF_RenderGlyph_LCD(font, ch, fg, bg));
}
 
inline Surface Font::RenderGlyph_LCD(Uint32 ch, ColorRaw fg, ColorRaw bg) const
{
  return SDL::RenderGlyph_LCD(m_resource, ch, fg, bg);
}
 
class Text
{
  TextRaw m_resource = nullptr;
 
public:
  constexpr Text() = default;
 
  constexpr explicit Text(const TextRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr Text(const Text& other) = delete;
 
  constexpr Text(Text&& other)
    : Text(other.release())
  {
  }
 
  constexpr Text(const TextRef& other) = delete;
 
  constexpr Text(TextRef&& other) = delete;
 
  Text(TextEngineParam engine, FontParam font, std::string_view text)
    : m_resource(TTF_CreateText(engine, font, text.data(), text.size()))
  {
  }
 
  ~Text() { TTF_DestroyText(m_resource); }
 
  Text& operator=(Text other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr TextRaw get() const { return m_resource; }
 
  constexpr TextRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Text& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator TextParam() const { return {m_resource}; }
 
  void Destroy();
 
  void DrawSurface(Point p, SurfaceParam surface) const;
 
  void DrawRenderer(FPoint p) const;
 
  GPUAtlasDrawSequence* GetGPUDrawData() const;
 
  PropertiesRef GetProperties() const;
 
  void SetEngine(TextEngineParam engine);
 
  TextEngineParam GetEngine() const;
 
  bool SetFont(FontParam font);
 
  FontRef GetFont() const;
 
  void SetDirection(Direction direction);
 
  Direction GetDirection() const;
 
  void SetScript(Uint32 script);
 
  Uint32 GetScript() const;
 
  void SetColor(Color c);
 
  void SetColorFloat(FColor c);
 
  void GetColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const;
 
  Color GetColor() const;
 
  void GetColorFloat(float* r, float* g, float* b, float* a) const;
 
  FColor GetColorFloat() const;
 
  bool SetPosition(Point p);
 
  bool GetPosition(int* x, int* y) const;
 
  Point GetPosition() const;
 
  void SetWrapWidth(int wrap_width);
 
  int GetWrapWidth() const;
 
  void SetWrapWhitespaceVisible(bool visible);
 
  bool IsWrapWhitespaceVisible() const;
 
  void SetString(std::string_view string);
 
  void InsertString(int offset, std::string_view string);
 
  void AppendString(std::string_view string);
 
  void DeleteString(int offset, int length);
 
  void GetSize(int* w, int* h) const;
 
  Point GetSize() const;
 
  void GetSubString(int offset, SubString* substring) const;
 
  SubStringIterator begin() const;
 
  SubStringIterator end() const;
 
  SubStringIterator GetSubStringForLine(int line) const;
 
  void GetSubStringForLine(int line, SubString* substring) const;
 
  OwnArray<SubString*> GetSubStrings() const
  {
    return GetSubStringsForRange(0);
  }
 
  OwnArray<SubString*> GetSubStringsForRange(int offset, int length = -1) const;
 
  SubStringIterator GetSubStringForPoint(Point p) const;
 
  void GetSubStringForPoint(Point p, SubString* substring) const;
 
  void GetPreviousSubString(const SubString& substring,
                            SubString* previous) const;
 
  void GetNextSubString(const SubString& substring, SubString* next) const;
 
  void Update();
 
  const char* GetText() const { return m_resource->text; }
 
  int GetNumLines() const { return m_resource->num_lines; }
};
 
struct TextRef : Text
{
  TextRef(TextParam resource = nullptr)
    : Text(resource.value)
  {
  }
 
  TextRef(const TextRef& other)
    : Text(other.get())
  {
  }
 
  ~TextRef() { release(); }
};
 
class SubStringIterator
{
  TextRef m_text;
 
  SubString m_subString;
 
  constexpr SubStringIterator(TextRef text)
    : m_text(text)
    , m_subString(0)
  {
  }
 
public:
  constexpr SubStringIterator()
    : SubStringIterator(TextRef{})
  {
  }
 
  constexpr operator bool() const { return bool(m_text); }
 
  constexpr const SubString& operator*() const { return m_subString; }
 
  constexpr const SubString* operator->() const { return &m_subString; }
 
  constexpr bool operator==(const SubStringIterator& other) const
  {
    return m_subString.offset == other.m_subString.offset;
  }
 
  constexpr SubStringIterator& operator++()
  {
    m_text.GetNextSubString(m_subString, &m_subString);
    return *this;
  }
 
  constexpr SubStringIterator operator++(int)
  {
    auto curr = *this;
    m_text.GetNextSubString(m_subString, &m_subString);
    return curr;
  }
 
  constexpr SubStringIterator& operator--()
  {
    m_text.GetPreviousSubString(m_subString, &m_subString);
    return *this;
  }
 
  constexpr SubStringIterator operator--(int)
  {
    auto curr = *this;
    m_text.GetPreviousSubString(m_subString, &m_subString);
    return curr;
  }
 
  friend class Text;
};
 
inline SurfaceTextEngine CreateSurfaceTextEngine()
{
  return SurfaceTextEngine();
}
 
inline void DrawSurfaceText(TextParam text, Point p, SurfaceParam surface)
{
  CheckError(TTF_DrawSurfaceText(text, p.x, p.y, surface));
}
 
inline void Text::DrawSurface(Point p, SurfaceParam surface) const
{
  SDL::DrawSurfaceText(m_resource, p, surface);
}
 
inline void DestroySurfaceTextEngine(TextEngineRaw engine)
{
  TTF_DestroySurfaceTextEngine(engine);
}
 
inline void SurfaceTextEngine::Destroy()
{
  DestroySurfaceTextEngine(release());
}
 
inline RendererTextEngine CreateRendererTextEngine(RendererParam renderer)
{
  return RendererTextEngine(renderer);
}
 
inline RendererTextEngine CreateRendererTextEngineWithProperties(
  PropertiesParam props)
{
  return RendererTextEngine(props);
}
 
namespace prop::RendererTextEngine {
 
constexpr auto RENDERER_POINTER =
  TTF_PROP_RENDERER_TEXT_ENGINE_RENDERER_POINTER;
 
constexpr auto ATLAS_TEXTURE_SIZE_NUMBER =
  TTF_PROP_RENDERER_TEXT_ENGINE_ATLAS_TEXTURE_SIZE_NUMBER;
 
} // namespace prop::RendererTextEngine
 
inline void DrawRendererText(TextParam text, FPoint p)
{
  CheckError(TTF_DrawRendererText(text, p.x, p.y));
}
 
inline void Text::DrawRenderer(FPoint p) const
{
  SDL::DrawRendererText(m_resource, p);
}
 
inline void DestroyRendererTextEngine(TextEngineRaw engine)
{
  TTF_DestroyRendererTextEngine(engine);
}
 
inline void RendererTextEngine::Destroy()
{
  DestroyRendererTextEngine(release());
}
 
inline GPUTextEngine CreateGPUTextEngine(GPUDeviceParam device)
{
  return GPUTextEngine(device);
}
 
inline GPUTextEngine CreateGPUTextEngineWithProperties(PropertiesParam props)
{
  return GPUTextEngine(props);
}
 
namespace prop::GpuTextEngine {
 
constexpr auto DEVICE_POINTER = TTF_PROP_GPU_TEXT_ENGINE_DEVICE_POINTER;
 
constexpr auto ATLAS_TEXTURE_SIZE_NUMBER =
  TTF_PROP_GPU_TEXT_ENGINE_ATLAS_TEXTURE_SIZE_NUMBER;
 
} // namespace prop::GpuTextEngine
 
inline GPUAtlasDrawSequence* GetGPUTextDrawData(TextParam text)
{
  return TTF_GetGPUTextDrawData(text);
}
 
inline GPUAtlasDrawSequence* Text::GetGPUDrawData() const
{
  return SDL::GetGPUTextDrawData(m_resource);
}
 
inline void DestroyGPUTextEngine(TextEngineRaw engine)
{
  TTF_DestroyGPUTextEngine(engine);
}
 
inline void GPUTextEngine::Destroy() { DestroyGPUTextEngine(release()); }
 
inline void SetGPUTextEngineWinding(TextEngineParam engine,
                                    GPUTextEngineWinding winding)
{
  TTF_SetGPUTextEngineWinding(engine, winding);
}
 
inline void GPUTextEngine::SetGPUWinding(GPUTextEngineWinding winding)
{
  SDL::SetGPUTextEngineWinding(get(), winding);
}
 
inline GPUTextEngineWinding GetGPUTextEngineWinding(TextEngineParam engine)
{
  return TTF_GetGPUTextEngineWinding(engine);
}
 
inline GPUTextEngineWinding GPUTextEngine::GetGPUWinding() const
{
  return SDL::GetGPUTextEngineWinding(get());
}
 
inline Text CreateText(TextEngineParam engine,
                       FontParam font,
                       std::string_view text)
{
  return Text(engine, font, text);
}
 
inline Text TextEngine::CreateText(FontParam font, std::string_view text)
{
  return Text(m_resource, font, text);
}
 
inline PropertiesRef GetTextProperties(TextParam text)
{
  return {CheckError(TTF_GetTextProperties(text))};
}
 
inline PropertiesRef Text::GetProperties() const
{
  return SDL::GetTextProperties(m_resource);
}
 
inline void SetTextEngine(TextParam text, TextEngineParam engine)
{
  CheckError(TTF_SetTextEngine(text, engine));
}
 
inline void Text::SetEngine(TextEngineParam engine)
{
  SDL::SetTextEngine(m_resource, engine);
}
 
inline TextEngineParam GetTextEngine(TextParam text)
{
  return CheckError(TTF_GetTextEngine(text));
}
 
inline TextEngineParam Text::GetEngine() const
{
  return SDL::GetTextEngine(m_resource);
}
 
inline bool SetTextFont(TextParam text, FontParam font)
{
  return TTF_SetTextFont(text, font);
}
 
inline bool Text::SetFont(FontParam font)
{
  return SDL::SetTextFont(m_resource, font);
}
 
inline FontRef GetTextFont(TextParam text)
{
  return {CheckError(TTF_GetTextFont(text))};
}
 
inline FontRef Text::GetFont() const { return SDL::GetTextFont(m_resource); }
 
inline void SetTextDirection(TextParam text, Direction direction)
{
  CheckError(TTF_SetTextDirection(text, direction));
}
 
inline void Text::SetDirection(Direction direction)
{
  SDL::SetTextDirection(m_resource, direction);
}
 
inline Direction GetTextDirection(TextParam text)
{
  return TTF_GetTextDirection(text);
}
 
inline Direction Text::GetDirection() const
{
  return SDL::GetTextDirection(m_resource);
}
 
inline void SetTextScript(TextParam text, Uint32 script)
{
  CheckError(TTF_SetTextScript(text, script));
}
 
inline void Text::SetScript(Uint32 script)
{
  SDL::SetTextScript(m_resource, script);
}
 
inline Uint32 GetTextScript(TextParam text) { return TTF_GetTextScript(text); }
 
inline Uint32 Text::GetScript() const { return SDL::GetTextScript(m_resource); }
 
inline void SetTextColor(TextParam text, Color c)
{
  CheckError(TTF_SetTextColor(text, c.r, c.g, c.b, c.a));
}
 
inline void Text::SetColor(Color c) { SDL::SetTextColor(m_resource, c); }
 
inline void SetTextColorFloat(TextParam text, FColor c)
{
  CheckError(TTF_SetTextColorFloat(text, c.r, c.g, c.b, c.a));
}
 
inline void Text::SetColorFloat(FColor c)
{
  SDL::SetTextColorFloat(m_resource, c);
}
 
inline void GetTextColor(TextParam text, Uint8* r, Uint8* g, Uint8* b, Uint8* a)
{
  CheckError(TTF_GetTextColor(text, r, g, b, a));
}
 
inline Color GetTextColor(TextParam text)
{
  Color c;
  GetTextColor(text, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void Text::GetColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const
{
  SDL::GetTextColor(m_resource, r, g, b, a);
}
 
inline Color Text::GetColor() const { return SDL::GetTextColor(m_resource); }
 
inline void GetTextColorFloat(TextParam text,
                              float* r,
                              float* g,
                              float* b,
                              float* a)
{
  CheckError(TTF_GetTextColorFloat(text, r, g, b, a));
}
 
inline FColor GetTextColorFloat(TextParam text)
{
  FColor c;
  GetTextColorFloat(text, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void Text::GetColorFloat(float* r, float* g, float* b, float* a) const
{
  SDL::GetTextColorFloat(m_resource, r, g, b, a);
}
 
inline FColor Text::GetColorFloat() const
{
  return SDL::GetTextColorFloat(m_resource);
}
 
inline bool SetTextPosition(TextParam text, Point p)
{
  return TTF_SetTextPosition(text, p.x, p.y);
}
 
inline bool Text::SetPosition(Point p)
{
  return SDL::SetTextPosition(m_resource, p);
}
 
inline bool GetTextPosition(TextParam text, int* x, int* y)
{
  return TTF_GetTextPosition(text, x, y);
}
 
inline Point GetTextPosition(TextParam text)
{
  Point p;
  CheckError(GetTextPosition(text, &p.x, &p.y));
  return p;
}
 
inline bool Text::GetPosition(int* x, int* y) const
{
  return SDL::GetTextPosition(m_resource, x, y);
}
 
inline Point Text::GetPosition() const
{
  return SDL::GetTextPosition(m_resource);
}
 
inline void SetTextWrapWidth(TextParam text, int wrap_width)
{
  CheckError(TTF_SetTextWrapWidth(text, wrap_width));
}
 
inline void Text::SetWrapWidth(int wrap_width)
{
  SDL::SetTextWrapWidth(m_resource, wrap_width);
}
 
inline int GetTextWrapWidth(TextParam text)
{
  int w;
  CheckError(TTF_GetTextWrapWidth(text, &w));
  return w;
}
 
inline int Text::GetWrapWidth() const
{
  return SDL::GetTextWrapWidth(m_resource);
}
 
inline void SetTextWrapWhitespaceVisible(TextParam text, bool visible)
{
  CheckError(TTF_SetTextWrapWhitespaceVisible(text, visible));
}
 
inline void Text::SetWrapWhitespaceVisible(bool visible)
{
  SDL::SetTextWrapWhitespaceVisible(m_resource, visible);
}
 
inline bool TextWrapWhitespaceVisible(TextParam text)
{
  return TTF_TextWrapWhitespaceVisible(text);
}
 
inline bool Text::IsWrapWhitespaceVisible() const
{
  return SDL::TextWrapWhitespaceVisible(m_resource);
}
 
inline void SetTextString(TextParam text, std::string_view string)
{
  CheckError(TTF_SetTextString(text, string.data(), string.size()));
}
 
inline void Text::SetString(std::string_view string)
{
  SDL::SetTextString(m_resource, string);
}
 
inline void InsertTextString(TextParam text,
                             int offset,
                             std::string_view string)
{
  CheckError(TTF_InsertTextString(text, offset, string.data(), string.size()));
}
 
inline void Text::InsertString(int offset, std::string_view string)
{
  SDL::InsertTextString(m_resource, offset, string);
}
 
inline void AppendTextString(TextParam text, std::string_view string)
{
  CheckError(TTF_AppendTextString(text, string.data(), string.size()));
}
 
inline void Text::AppendString(std::string_view string)
{
  SDL::AppendTextString(m_resource, string);
}
 
inline void DeleteTextString(TextParam text, int offset, int length)
{
  CheckError(TTF_DeleteTextString(text, offset, length));
}
 
inline void Text::DeleteString(int offset, int length)
{
  SDL::DeleteTextString(m_resource, offset, length);
}
 
inline void GetTextSize(TextParam text, int* w, int* h)
{
  CheckError(TTF_GetTextSize(text, w, h));
}
 
inline Point GetTextSize(TextParam text)
{
  Point p;
  GetTextSize(text, &p.x, &p.y);
  return p;
}
 
inline void Text::GetSize(int* w, int* h) const
{
  SDL::GetTextSize(m_resource, w, h);
}
 
inline Point Text::GetSize() const { return SDL::GetTextSize(m_resource); }
 
inline void GetTextSubString(TextParam text, int offset, SubString* substring)
{
  CheckError(TTF_GetTextSubString(text, offset, substring));
}
 
inline void Text::GetSubString(int offset, SubString* substring) const
{
  SDL::GetTextSubString(m_resource, offset, substring);
}
 
inline void GetTextSubStringForLine(TextParam text,
                                    int line,
                                    SubString* substring)
{
  CheckError(TTF_GetTextSubStringForLine(text, line, substring));
}
 
inline void Text::GetSubStringForLine(int line, SubString* substring) const
{
  SDL::GetTextSubStringForLine(m_resource, line, substring);
}
 
inline OwnArray<SubString*> GetTextSubStringsForRange(TextParam text,
                                                      int offset,
                                                      int length)
{
  int count = 0;
  auto data = TTF_GetTextSubStringsForRange(text, offset, length, &count);
  return OwnArray<SubString*>{data, size_t(count)};
}
 
inline OwnArray<SubString*> Text::GetSubStringsForRange(int offset,
                                                        int length) const
{
  return SDL::GetTextSubStringsForRange(m_resource, offset, length);
}
 
inline void GetTextSubStringForPoint(TextParam text,
                                     Point p,
                                     SubString* substring)
{
  CheckError(TTF_GetTextSubStringForPoint(text, p.x, p.y, substring));
}
 
inline void Text::GetSubStringForPoint(Point p, SubString* substring) const
{
  SDL::GetTextSubStringForPoint(m_resource, p, substring);
}
 
inline void GetPreviousTextSubString(TextParam text,
                                     const SubString& substring,
                                     SubString* previous)
{
  CheckError(TTF_GetPreviousTextSubString(text, &substring, previous));
}
 
inline void Text::GetPreviousSubString(const SubString& substring,
                                       SubString* previous) const
{
  SDL::GetPreviousTextSubString(m_resource, substring, previous);
}
 
inline void GetNextTextSubString(TextParam text,
                                 const SubString& substring,
                                 SubString* next)
{
  CheckError(TTF_GetNextTextSubString(text, &substring, next));
}
 
inline void Text::GetNextSubString(const SubString& substring,
                                   SubString* next) const
{
  SDL::GetNextTextSubString(m_resource, substring, next);
}
 
inline void UpdateText(TextParam text) { CheckError(TTF_UpdateText(text)); }
 
inline void Text::Update() { SDL::UpdateText(m_resource); }
 
inline void DestroyText(TextRaw text) { TTF_DestroyText(text); }
 
inline void Text::Destroy() { DestroyText(release()); }
 
inline void CloseFont(FontRaw font) { TTF_CloseFont(font); }
 
inline void Font::Close() { CloseFont(release()); }
 
 
} // namespace SDL
 
#endif // defined(SDL3PP_ENABLE_TTF) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_TTF_H_ */