Font.hpp

#ifndef RAYLIB_CPP_INCLUDE_FONT_HPP_
#define RAYLIB_CPP_INCLUDE_FONT_HPP_
 
#include <cassert>
#include <string>
#include <string_view>
#include <span>
 
#include "./RaylibException.hpp"
#include "./TextureUnmanaged.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./raylib.hpp"
 
namespace raylib {
class Font : public ::Font {
public:
    Font(
        int baseSize,
        int glyphCount,
        int glyphPadding,
        ::Texture2D texture,
        ::Rectangle* recs = nullptr,
        ::GlyphInfo* glyphs = nullptr)
        : ::Font{baseSize, glyphCount, glyphPadding, texture, recs, glyphs} {
        // Nothing.
    }
 
    Font(int baseSize,
            int glyphPadding,
            ::Texture2D texture,
            std::span<::Rectangle> recs = {},
            std::span<::GlyphInfo> glyphs = {}) : ::Font{baseSize, static_cast<int>((assert(glyphs.size() == recs.size()), glyphs.size())), glyphPadding, texture, recs.data(), glyphs.data()} {
        // Nothing.
    }
 
    Font() : ::Font(::GetFontDefault()) { }
 
    Font(const ::Font& font) : ::Font(font) { }
 
    Font(const std::string_view fileName) {
        Load(fileName);
    }
 
    Font(const std::string_view fileName, int fontSize, int* fontChars = 0, int charCount = 0)  {
        Load(fileName, fontSize, fontChars, charCount);
    }
 
    Font(const std::string_view fileName, int fontSize, std::span<int> fontChars)  {
        Load(fileName, fontSize, fontChars.data(), static_cast<int>(fontChars.size()));
    }
 
    Font(const ::Image& image, ::Color key, int firstChar) { Load(image, key, firstChar); }
 
    Font(const std::string_view fileType, const unsigned char* fileData, int dataSize, int fontSize,
            int *fontChars, int charsCount)  {
        Load(fileType, fileData, dataSize, fontSize, fontChars, charsCount);
    }
 
    Font(const std::string_view fileType, const unsigned char* fileData, int dataSize, int fontSize,
            std::span<int> fontChars)  {
        Load(fileType, fileData, dataSize, fontSize, fontChars.data(), static_cast<int>(fontChars.size()));
    }
 
    Font(const Font&) = delete;
 
    Font(Font&& other) noexcept {
        set(other);
 
        other.baseSize = 0;
        other.glyphCount = 0;
        other.glyphPadding = 0;
        other.texture = {};
        other.recs = nullptr;
        other.glyphs = nullptr;
    }
 
    ~Font() { Unload(); }
 
    void Unload() {
        // Protect against calling UnloadFont() twice.
        if (baseSize != 0) {
            UnloadFont(*this);
            baseSize = 0;
        }
    }
 
    GETTER(int, BaseSize, baseSize)
    GETTER(int, GlyphCount, glyphCount)
    GETTER(int, GlyphPadding, glyphPadding)
    GETTER(::Rectangle*, Recs, recs)
    GETTER(::GlyphInfo*, Glyphs, glyphs)
 
    TextureUnmanaged GetTexture() { return texture; }
 
    void SetTexture(const ::Texture& newTexture) { texture = newTexture; }
 
    Font& operator=(const ::Font& font) {
        Unload();
        set(font);
        return *this;
    }
 
    Font& operator=(const Font&) = delete;
 
    Font& operator=(Font&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.baseSize = 0;
        other.glyphCount = 0;
        other.glyphPadding = 0;
        other.texture = {};
        other.recs = nullptr;
        other.glyphs = nullptr;
 
        return *this;
    }
 
    void Load(const std::string_view fileName) {
        set(::LoadFont(fileName.data()));
        if (!IsValid()) {
            throw RaylibException("Failed to load Font with from file: " + std::string(fileName));
        }
    }
 
    void Load(const std::string_view fileName, int fontSize, int* fontChars, int charCount)  {
        set(::LoadFontEx(fileName.data(), fontSize, fontChars, charCount));
        if (!IsValid()) {
            throw RaylibException("Failed to load Font with from file with font size: " + std::string(fileName));
        }
    }
 
    void Load(const std::string_view fileName, int fontSize, std::span<int> fontChars)  {
        set(::LoadFontEx(fileName.data(), fontSize, fontChars.data(), static_cast<int>(fontChars.size())));
        if (!IsValid()) {
            throw new RaylibException("Failed to load Font with from file with font size: " + std::string(fileName));
        }
    }
 
    void Load(const ::Image& image, ::Color key, int firstChar) {
        set(::LoadFontFromImage(image, key, firstChar));
        if (!IsValid()) {
            throw RaylibException("Failed to load Font with from image");
        }
    }
 
    void Load(const std::string_view fileType, const unsigned char* fileData, int dataSize, int fontSize,
            int *fontChars, int charsCount)  {
        set(::LoadFontFromMemory(fileType.data(), fileData, dataSize, fontSize, fontChars,
            charsCount));
        if (!IsValid()) {
            throw RaylibException("Failed to load Font " + std::string(fileType) + " with from file data");
        }
    }
 
    void Load(const std::string_view fileType, const unsigned char* fileData, int dataSize, int fontSize,
            std::span<int> fontChars)  {
        set(::LoadFontFromMemory(fileType.data(), fileData, dataSize, fontSize, fontChars.data(),
            static_cast<int>(fontChars.size())));
        if (!IsValid()) {
            throw new RaylibException("Failed to load Font " + std::string(fileType) + " with from file data");
        }
    }
 
    void Load(const std::string_view fileType, std::span<unsigned char> fileData, int fontSize,
            int *fontChars, int charsCount)  {
        set(::LoadFontFromMemory(fileType.data(), fileData.data(), static_cast<int>(fileData.size()), fontSize, fontChars,
            charsCount));
        if (!IsValid()) {
            throw RaylibException("Failed to load Font " + std::string(fileType) + " with from file data");
        }
    }
 
    void Load(const std::string_view fileType, std::span<unsigned char> fileData, int fontSize,
            std::span<int> fontChars)  {
        set(::LoadFontFromMemory(fileType.data(), fileData.data(), static_cast<int>(fileData.size()), fontSize, fontChars.data(),
            static_cast<int>(fontChars.size())));
        if (!IsValid()) {
            throw new RaylibException("Failed to load Font " + std::string(fileType) + " with from file data");
        }
    }
 
    [[nodiscard]] bool IsValid() const { return ::IsFontValid(*this); }
 
    void DrawText(const char* text, ::Vector2 position, float fontSize, float spacing, ::Color tint = WHITE) const {
        ::DrawTextEx(*this, text, position, fontSize, spacing, tint);
    }
 
    void DrawText(const std::string_view text, ::Vector2 position, float fontSize,
            float spacing, ::Color tint = WHITE) const {
        ::DrawTextEx(*this, text.data(), position,  fontSize,  spacing,  tint);
    }
 
    void DrawText(const char* text, int posX, int posY, float fontSize, float spacing, ::Color tint = WHITE) const {
        ::DrawTextEx(*this, text, {static_cast<float>(posX), static_cast<float>(posY)}, fontSize, spacing, tint);
    }
 
    void DrawText(const std::string_view text, int posX, int posY, float fontSize,
            float spacing, ::Color tint = WHITE) const {
        ::DrawTextEx(*this, text.data(),
            { static_cast<float>(posX), static_cast<float>(posY) },
            fontSize, spacing, tint);
    }
 
    void DrawText(
            const char* text,
            ::Vector2 position,
            ::Vector2 origin,
            Degree rotation,
            float fontSize,
            float spacing,
            ::Color tint = WHITE) const {
        ::DrawTextPro(*this, text,
            position, origin,
            rotation, fontSize,
            spacing, tint);
    }
 
    void DrawText(
            const std::string_view text,
            ::Vector2 position,
            ::Vector2 origin,
            Degree rotation,
            float fontSize,
            float spacing,
            ::Color tint = WHITE) const {
        ::DrawTextPro(*this, text.data(),
            position, origin,
            rotation, fontSize,
            spacing, tint);
    }
 
    void DrawText(int codepoint, ::Vector2 position, float fontSize, ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTextCodepoint(*this, codepoint, position, fontSize, tint);
    }
 
    void DrawText(
        const int* codepoints,
        int count,
        ::Vector2 position,
        float fontSize,
        float spacing,
        ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTextCodepoints(*this, codepoints, count, position, fontSize, spacing, tint);
    }
 
    inline void DrawText(std::span<const int> codepoints, ::Vector2 position,
            float fontSize, float spacing,
            ::Color tint = { 255, 255, 255, 255 }) const {
        ::DrawTextCodepoints(*this,
            codepoints.data(), static_cast<int>(codepoints.size()),
            position, fontSize,
            spacing, tint);
    }
 
    [[nodiscard]] Vector2 MeasureText(const char* text, float fontSize, float spacing) const {
        return ::MeasureTextEx(*this, text, fontSize, spacing);
    }
 
    Vector2 MeasureText(const std::string_view text, float fontSize, float spacing) const {
        return ::MeasureTextEx(*this, text.data(), fontSize, spacing);
    }
 
    [[nodiscard]] int GetGlyphIndex(int character) const { return ::GetGlyphIndex(*this, character); }
 
    [[nodiscard]] ::Image ImageText(const char* text, float fontSize, float spacing, ::Color tint) const {
        return ::ImageTextEx(*this, text, fontSize, spacing, tint);
    }
 
    ::Image ImageText(const std::string_view text, float fontSize,
            float spacing, ::Color tint) const {
        return ::ImageTextEx(*this, text.data(), fontSize, spacing, tint);
    }
protected:
    void set(const ::Font& font) {
        baseSize = font.baseSize;
        glyphCount = font.glyphCount;
        glyphPadding = font.glyphPadding;
        texture = font.texture;
        recs = font.recs;
        glyphs = font.glyphs;
    }
};
} // namespace raylib
 
using RFont = raylib::Font;
 
#endif // RAYLIB_CPP_INCLUDE_FONT_HPP_