spk_font_painter.hpp

#pragma once
 
#include "structure/graphics/painter/spk_mesh_painter.hpp"
#include "structure/graphics/spk_color.hpp"
#include "structure/graphics/spk_font.hpp"
 
#include "structure/geometry/spk_mesh.hpp"
#include "structure/opengl/spk_vertex_buffer_object.hpp"
 
#include "type/spk_text_aligmnent.hpp"
 
#include <algorithm>
#include <cstddef>
#include <limits>
#include <string>
#include <utility>
#include <vector>
 
namespace spk
{
    struct FontVertex
    {
        spk::Vector2Int pos;
        spk::Vector2 uv;
    };

    struct FontMesh : public spk::IMesh<FontVertex>
    {
    public:
        class Builder
        {
        private:
            Font *_font = nullptr;
            Font::Size _fontSize{};
            size_t _tabSize = 4;
 
            spk::Vector2Int _cursor{0, 0};
            wchar_t _previousGlyph = 0;
            int _lineHeight = 0;
 
            struct Bounds
            {
                spk::Vector2Int min{std::numeric_limits<int>::max(), std::numeric_limits<int>::max()};
                spk::Vector2Int max{std::numeric_limits<int>::min(), std::numeric_limits<int>::min()};
                bool has = false;
 
                void include(const spk::Vector2Int &p_point)
                {
                    if (!has)
                    {
                        min = max = p_point;
                        has = true;
                        return;
                    }
 
                    min.x = std::min(min.x, p_point.x);
                    min.y = std::min(min.y, p_point.y);
                    max.x = std::max(max.x, p_point.x);
                    max.y = std::max(max.y, p_point.y);
                }
 
                spk::Vector2Int size() const
                {
                    return max - min;
                }
            };
 
            Bounds _bounds;
 
            using Placement = std::pair<const Font::Bitmap::Glyph *, spk::Vector2Int>;
            std::vector<Placement> _placements;
            std::vector<size_t> _lineBreaks{0};
 
            void _validateSingleLine(const std::wstring &p_text) const;
 
            int _ensureLineHeight();
 
            void _newline();
 
            spk::Vector2Int _computeOffset(const Bounds &p_bounds, const spk::Vector2Int &p_anchor, spk::HorizontalAlignment p_horizontalAlignment, spk::VerticalAlignment p_verticalAlignment) const;
 
            struct LayoutResult
            {
                std::vector<Placement> placements;
                Bounds bounds;
            };
 
            LayoutResult _layout(const std::wstring &p_text, Font::Bitmap &p_bitmap, int p_lineHeight, bool p_buildPlacements) const;
 
            int _glyphAdvance(Font::Bitmap &p_bitmap, const Font::Bitmap::Glyph &p_glyph, wchar_t p_previousGlyph, wchar_t p_currentGlyph) const;
 
        public:
            Builder() = default;

            Builder(Font *p_font, const Font::Size &p_fontSize, size_t p_tabSize = 4);

            Builder &setTabSize(size_t p_tabSize);

            Builder &clear();

            Builder &addText(const std::wstring &p_text);

            Builder &addNewline();

            spk::Vector2UInt computeTextSize(const std::wstring &p_text) const;

            FontMesh construct(const spk::Vector2Int &p_anchor, spk::HorizontalAlignment p_horizontalAlignment = spk::HorizontalAlignment::Centered, spk::VerticalAlignment p_verticalAlignment = spk::VerticalAlignment::Centered);
        };
 
    private:
        Font *_font = nullptr;
        Font::Size _fontSize = {16, 0};
 
    public:
        FontMesh() = default;

        FontMesh(Font *p_font, const Font::Size &p_fontSize);

        const Font *font() const;

        Font::Bitmap &bitmap();

        const Font::Bitmap &bitmap() const;

        const Font::Size &fontSize() const;
 
    protected:
        void _configureBufferSet() const override
        {
            auto &layout = bufferSet()->vbo().layout();
            using Attribute = spk::OpenGL::VertexBufferObject::Layout::Attribute;
            layout.addAttribute({0, Attribute::Type::Vector2Int});
            layout.addAttribute({1, Attribute::Type::Vector2});
        }
    };

    class FontPainter : public spk::MeshPainter<FontMesh>
    {
    private:
        static spk::Lumina::Pipeline &_fontPipeline();
        OpenGL::UBO &_modelData;
        float &_layerRef;
        OpenGL::UBO &_styleUBO;
        spk::Color &_glyphColorRef;
        spk::Color &_outlineColorRef;
 
    public:
        FontPainter();

        void setLayer(const float &p_layer);
        const float &layer() const;

        void setMesh(const FontMesh *p_mesh) override;

        void setGlyphColor(const spk::Color &p_color);
        void setOutlineColor(const spk::Color &p_color);
        void setColors(const spk::Color &p_glyphColor, const spk::Color &p_outlineColor);

        const spk::Color &glyphColor() const;
        const spk::Color &outlineColor() const;
    };
}