spk_font.hpp

// spk_font.hpp
#pragma once
 
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "structure/design_pattern/spk_contract_provider.hpp"
#include "structure/opengl/spk_texture_object.hpp"
#include "utils/spk_file_utils.hpp"
 
#include "stb_truetype.h"
 
namespace spk
{
    class Font
    {
    public:
        struct Size
        {
            size_t glyph;
            size_t outline;

            bool operator==(const Size &p_other) const noexcept
            {
                return glyph == p_other.glyph && outline == p_other.outline;
            }
        };
 
    private:
        struct SizeHasher
        {
            std::size_t operator()(const Size &p_s) const noexcept
            {
                std::size_t h1 = std::hash<std::size_t>{}(p_s.glyph);
                std::size_t h2 = std::hash<std::size_t>{}(p_s.outline);
                return h1 ^ (h2 + 0x9e3779b97f4a7c15ULL + (h1 << 6) + (h1 >> 2));
            }
        };
 
    public:
        class Bitmap : public spk::OpenGL::TextureObject
        {
        public:
            using Format = spk::OpenGL::TextureObject::Format;
            using Filtering = spk::OpenGL::TextureObject::Filtering;
            using Filter = spk::OpenGL::TextureObject::Filter;
            using Wrap = spk::OpenGL::TextureObject::Wrap;
            using Wrapper = spk::OpenGL::TextureObject::Wrapper;
            using Mipmap = spk::OpenGL::TextureObject::Mipmap;

            using EditionContract = spk::ContractProvider::Contract;
            using EditionJob = spk::ContractProvider::Job;

            struct Glyph
            {
                std::array<spk::Vector2Int, 4> positions;
                std::array<spk::Vector2, 4> uvs;
                spk::Vector2Int step;
                spk::Vector2Int baselineOffset;
                spk::Vector2UInt size;
                wchar_t codepoint = 0;

                static inline std::array<unsigned int, 6> indexesOrder = {0, 1, 2, 2, 1, 3};

                void applyRatioOnUV(const spk::Vector2 &p_scaleRatio)
                {
                    for (size_t i = 0; i < 4; i++)
                    {
                        uvs[i] *= p_scaleRatio;
                    }
                }
            };
 
        private:
            struct RasterizedGlyph
            {
                std::vector<uint8_t> pixels;
                spk::Vector2UInt size{0, 0};
                spk::Vector2Int offset{0, 0};
                int advance = 0;
 
                bool valid() const
                {
                    return pixels.empty() == false;
                }
            };
 
            class KerningCache
            {
            private:
                using KerningMap = std::unordered_map<wchar_t, int>;
                std::unordered_map<wchar_t, KerningMap> _cache;
 
            public:
                int get(const stbtt_fontinfo *p_fontInfo, const wchar_t p_previous, const wchar_t p_current, float p_scale);
            };
 
            class AtlasPacker
            {
            private:
                enum class Quadrant
                {
                    TopLeft,
                    TopRight,
                    DownLeft,
                    DownRight
                };
 
                Quadrant _currentQuadrant = Quadrant::TopLeft;
                spk::Vector2Int _quadrantAnchor = {0, 0};
                spk::Vector2UInt _quadrantSize = {0, 0};
                spk::Vector2Int _nextGlyphAnchor = {0, 0};
                spk::Vector2Int _nextLineAnchor = {0, 0};
 
                void _resizeTexture(Bitmap &p_bitmap, const spk::Vector2UInt &p_size);
 
            public:
                AtlasPacker() = default;
 
                void reset(const spk::Vector2UInt &p_initialSize);
                spk::Vector2UInt textureSize(const Bitmap &p_bitmap) const;
                spk::Vector2Int allocate(Bitmap &p_bitmap, const spk::Vector2UInt &p_glyphSize);
                void blit(Bitmap &p_bitmap, const uint8_t *p_pixelsToApply, const spk::Vector2Int &p_glyphPosition, const spk::Vector2UInt &p_glyphSize);
            };
 
            const stbtt_fontinfo *_fontInfo;
            Size _fontSize;
            std::unordered_map<wchar_t, Glyph> _glyphs;
            Glyph _unknownGlyph;
            AtlasPacker _atlas;
            mutable KerningCache _kerningCache;
            spk::ContractProvider _onEditionContractProvider;
 
            float _scale() const;
            void _rescaleGlyphs(const spk::Vector2 &p_scaleRatio);
            RasterizedGlyph _rasterizeGlyph(const wchar_t &p_glyphChar) const;
            Glyph _placeGlyph(const RasterizedGlyph &p_raster, const wchar_t &p_glyphChar);
            void _cacheGlyph(const wchar_t &p_glyphChar, Glyph p_glyph);
            void _loadGlyph(const wchar_t &p_glyphChar);
            void _onSynchronize() override;
 
        public:
            Bitmap(const stbtt_fontinfo *p_fontInfo, const Size &p_fontSize);

            EditionContract subscribeToEdition(const EditionJob &p_job);

            const Glyph &operator[](const wchar_t &p_glyphChar);

            int lineHeight() const;
            int kerning(const wchar_t p_previous, const wchar_t p_current) const;
            void preloadGlyphs(const std::wstring &p_glyphs);
        };
 
    private:
        std::vector<uint8_t> _fontData;
        stbtt_fontinfo _fontInfo;
        std::unordered_map<Size, Bitmap, SizeHasher> _loadedFonts;
 
    public:
        Font(const std::vector<uint8_t> &p_rawData);

        static Font fromFile(const std::filesystem::path &p_path);
        static Font fromRawData(const std::vector<uint8_t> &p_rawData);

        Bitmap &bitmap(const Size &p_fontSize);
    };
}