HudRenderer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "HudTypes.hpp"
 
#include <SDL3/SDL.h>
 
#include <array>
#include <span>
 
class SdfAtlas;
class HudSvgAtlas;

class HudRenderer
{
public:
    bool init(SDL_GPUDevice* device,
              SDL_GPUShaderFormat shaderFormat,
              const SdfAtlas& sdfAtlas,
              const HudSvgAtlas* svgAtlas,
              uint32_t screenW,
              uint32_t screenH);

    void quit();

    void resize(uint32_t newW, uint32_t newH);

    void render(std::span<const HudVertex> vertices, std::span<const std::array<float, 6>> clipRects);

    [[nodiscard]] SDL_GPUTexture* getOutputTexture() const { return offscreenTarget_; }

    [[nodiscard]] uint32_t width() const { return width_; }

    [[nodiscard]] uint32_t height() const { return height_; }
 
private:
    SDL_GPUDevice* device_ = nullptr;
    SDL_GPUShaderFormat shaderFormat_ = SDL_GPU_SHADERFORMAT_INVALID;
 
    // Offscreen targets — render into the multisample target, auto-resolve
    // into the 1× sampleable target at end-of-pass. The 4× MSAA gives the
    // entire HUD pass free geometry-edge AA on every diagonal icon stroke,
    // chevron, ring, and rotated rect, which were previously hard-aliased.
    SDL_GPUTexture* msaaTarget_ = nullptr;      
    SDL_GPUTexture* offscreenTarget_ = nullptr; 
    uint32_t width_ = 0;
    uint32_t height_ = 0;
    static constexpr SDL_GPUSampleCount k_sampleCount = SDL_GPU_SAMPLECOUNT_4;
 
    // Pipeline
    SDL_GPUGraphicsPipeline* pipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* erasePipeline_ = nullptr;
 
    // Samplers (bound to fragment set 1)
    SDL_GPUTexture* sdfAtlasTex_ = nullptr;   
    SDL_GPUSampler* sdfAtlasSamp_ = nullptr;  
    const HudSvgAtlas* svgAtlas_ = nullptr;   
    SDL_GPUTexture* iconAtlasTex_ = nullptr;  
    SDL_GPUSampler* iconAtlasSamp_ = nullptr; 
 
    // Dynamic vertex buffer (recreated if capacity exceeded)
    SDL_GPUBuffer* vertexBuffer_ = nullptr;
    SDL_GPUTransferBuffer* transferBuffer_ = nullptr;
    uint32_t vertexCapacity_ = 0; 
 
    // Uniform buffer data
    struct ScreenUniforms
    {
        float screenW;
        float screenH;
    };
 
    bool createOffscreenTarget(uint32_t w, uint32_t h);
    bool createPipeline();
    bool ensureVertexBuffer(uint32_t requiredVertices);

    SDL_GPUShader*
    loadShader(const char* name, SDL_GPUShaderStage stage, uint32_t samplerCount, uint32_t uniformBufferCount);
};