font_asset.h

#pragma once
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <vector>
 
#include <glm/glm.hpp>
 
#include "resource/resource.h"
#include "resource/resource_handle.h"
 
namespace Vkm::Engine {

struct FontGlyph {
    glm::vec2 uvMin   = {0.0f, 0.0f};
    glm::vec2 uvMax   = {0.0f, 0.0f};
    glm::vec2 size    = {0.0f, 0.0f};  
    glm::vec2 offset  = {0.0f, 0.0f};
    float     advance = 0.0f;          
};

struct KerningPair {
    uint32_t pair   = 0;
    float    adjust = 0.0f;  
};

struct FontAsset : public Resource {
    static constexpr uint32_t ASCII_FIRST  = 0x20;  
    static constexpr uint32_t ASCII_LAST   = 0x7E;  
    static constexpr uint32_t LATIN1_FIRST = 0xA0;  
    static constexpr uint32_t LATIN1_LAST  = 0xFF;  

    static constexpr uint32_t MARKS[] = {
        0x2013,
        0x2014,
        0x2018,
        0x2019,
        0x201C,
        0x201D,
        0x2022,
        0x2026,
        0x20AC
    };
 
    static constexpr uint32_t ASCII_COUNT  = ASCII_LAST - ASCII_FIRST + 1;
    static constexpr uint32_t LATIN1_COUNT = LATIN1_LAST - LATIN1_FIRST + 1;
    static constexpr uint32_t MARK_COUNT   = sizeof(MARKS) / sizeof(MARKS[0]);
    static constexpr uint32_t GLYPH_COUNT  = ASCII_COUNT + LATIN1_COUNT + MARK_COUNT;

    static constexpr uint32_t MIP_LEVELS = 4;
 
    std::vector<uint8_t> atlasPixels;   
    uint32_t atlasSize   = 0;           
 
    float pixelHeight = 0.0f;
    float ascent      = 0.0f;           
    float descent     = 0.0f;

    float lineHeight  = 0.0f;
 
    std::array<FontGlyph, GLYPH_COUNT> glyphs{};

    std::vector<KerningPair> kerning;

    static constexpr int glyphIndex(char32_t codepoint) {
        if (codepoint >= ASCII_FIRST && codepoint <= ASCII_LAST) {
            return static_cast<int>(codepoint - ASCII_FIRST);
        }
        if (codepoint >= LATIN1_FIRST && codepoint <= LATIN1_LAST) {
            return static_cast<int>(ASCII_COUNT + codepoint - LATIN1_FIRST);
        }
        for (uint32_t i = 0; i < MARK_COUNT; ++i) {
            if (MARKS[i] == codepoint) return static_cast<int>(ASCII_COUNT + LATIN1_COUNT + i);
        }
        return -1;
    }

    static constexpr char32_t codepointAt(uint32_t index) {
        if (index < ASCII_COUNT) return ASCII_FIRST + index;
        if (index < ASCII_COUNT + LATIN1_COUNT) return LATIN1_FIRST + index - ASCII_COUNT;
        return MARKS[index - ASCII_COUNT - LATIN1_COUNT];
    }

    const FontGlyph* glyph(char32_t codepoint) const {
        const int index = glyphIndex(codepoint);
        return index < 0 ? nullptr : &glyphs[static_cast<size_t>(index)];
    }

    float kern(int left, int right) const {
        const uint32_t pair = static_cast<uint32_t>(left) * GLYPH_COUNT + static_cast<uint32_t>(right);
        const auto found = std::lower_bound(
            kerning.begin(),
            kerning.end(),
            pair,
            [](const KerningPair& entry, uint32_t key) { return entry.pair < key; }
        );
        return (found != kerning.end() && found->pair == pair) ? found->adjust : 0.0f;
    }
};
 
using FontHandle = Handle<FontAsset>;
 
} // namespace Vkm::Engine