ui-canvas.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
 
#include "flint/graphics/gpu/gpu-texture.h"
#include "flint/graphics/types/color.h"
#include "flint/math/types.h"
#include "flint/ui/ui-types.h"
 
#include <SDL3/SDL_gpu.h>
#include <SDL3_ttf/SDL_textengine.h>
#include <SDL3_ttf/SDL_ttf.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Flint {
  struct GpuTextItem;
 
  class GPURenderer;
  class RenderQueue;
 
  struct FontKey {
      std::string name; 
      uint16_t weight;  
      uint16_t fontSize = 0; 
      bool operator==(const FontKey &other) const {
        return name == other.name && weight == other.weight && fontSize == other.fontSize;
      }
  };
 
  struct FontKeyHash {
      std::size_t operator()(const FontKey &key) const {
        return std::hash<std::string>()(key.name) ^ (std::hash<uint16_t>()(key.weight) << 8) ^
               (std::hash<uint16_t>()(key.fontSize) << 16);
      }
  };
 
  struct TextCacheKey {
      std::string text;     
      std::string fontName; 
      uint16_t    fontSize; 
      uint16_t    weight;   
      Color       color;    
      bool operator==(const TextCacheKey &other) const {
        return text == other.text && fontName == other.fontName && fontSize == other.fontSize &&
               weight == other.weight && color == other.color;
      }
  };
 
  struct TextCacheKeyHash {
      std::size_t operator()(const TextCacheKey &key) const {
        std::size_t seed = 0;
 
        auto combine = [&seed](std::size_t value) {
          value += 0x9e3779b97f4a7c15ULL + (seed << 6) + (seed >> 2);
          seed ^= value;
        };
 
        combine(std::hash<std::string>{}(key.text));
        combine(std::hash<std::string>{}(key.fontName));
        combine(std::hash<uint16_t>{}(key.fontSize));
        combine(std::hash<uint16_t>{}(key.weight));
 
        const uint32_t color = static_cast<uint32_t>(key.color.r) << 24 |
                               static_cast<uint32_t>(key.color.g) << 16 |
                               static_cast<uint32_t>(key.color.b) << 8 |
                               static_cast<uint32_t>(key.color.a);
 
        combine(std::hash<uint32_t>{}(color));
 
        return seed;
      }
  };
 
  class UICanvas {
    public:
      explicit UICanvas(GPURenderer &renderer);
      ~UICanvas();
 
      UICanvas(const UICanvas &) = delete;
      UICanvas &operator=(const UICanvas &) = delete;
 
      void emit(RenderQueue &queue);
      void uploadGeometry(SDL_GPUCommandBuffer *cmd);
 
      void flushDrawCalls(SDL_GPURenderPass *renderPass, SDL_GPUCommandBuffer *commandBuffer);
 
      void setScreenSize(Vec2f size);
 
      void drawRect(Rect<float> rect, Color color);
 
      void drawText(std::string text, float x, float y, float fontSize, Color color,
                    std::string fontName = "", uint16_t weight = 400);
 
      void drawTexture(const GPUTexture &texture, Rect<float> rect,
                       Color tint = {255, 255, 255, 255});
 
      Vec2f getScreenSize() const {
        return m_screenSize;
      }
 
      Vec2f measureText(const std::string &text, float fontSize, const std::string &fontName = "",
                        uint16_t weight = 400);
 
      float getGlyphCenterOffset(const std::string &text, float fontSize,
                                 const std::string &fontName = "", uint16_t weight = 400);
 
      bool loadFont(std::vector<char> &&data, const std::string &fontName, uint16_t weight = 400);
 
      void setDefaultFont(const std::string &name) {
        m_defaultFont = name;
      }
 
      void discardDrawCalls();
 
    private:
      struct RectVertex {
          float x, y, u, v;
      };
 
      struct RectDrawCall {
          std::size_t     vertexOffset;
          Color           color;
          SDL_GPUTexture *texture = nullptr;
      };
 
      struct TextDrawCall {
          std::string text;
          float       x, y;
          std::string fontName;
          float       fontSize;
          uint16_t    weight = 400;
          Color       color;
      };
 
      GPURenderer
           &m_renderer; 
      Vec2f m_screenSize = {1.0f, 1.0f};
 
      static constexpr std::size_t MAX_RECT_VERTICES =
          6 * 1024; 
      std::vector<RectVertex>
          m_rectVertices; 
      std::vector<RectDrawCall> m_rectDrawCalls; 
      SDL_GPUBuffer         *m_rectVBO = nullptr;
      SDL_GPUTransferBuffer *m_rectTransfer = nullptr;
      void                   initRectBuffers();
      void                   appendRectVertices(const Rect<float> &rect);
 
      std::vector<TextDrawCall> m_textDrawCalls;
 
      SDL_GPUSampler *m_sampler = nullptr;
      SDL_GPUTexture *m_whiteTexture =
          nullptr; 
      void initSharedGpuObjects();
 
      std::unordered_map<FontKey, TTF_Font *, FontKeyHash>        m_fontCache;
      std::unordered_map<FontKey, std::vector<char>, FontKeyHash> m_fontDataByWeight;
      std::unordered_map<TextCacheKey, std::unique_ptr<GpuTextItem>, TextCacheKeyHash> m_textCache;
 
      TTF_Font   *getFont(const std::string &name, uint16_t fontSize, uint16_t weight = 400);
      std::string m_defaultFont = "default";
 
      TTF_TextEngine *m_textEngine = nullptr;
  };
 
}