SpriteBatch.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include <DirectXMath.h>
 
#include "HMI/Graphics/Quad.h"
#include "HMI/Graphics/RenderLayer.h"
 
class QRhi;
class QRhiBuffer;
class QRhiCommandBuffer;
class QRhiGraphicsPipeline;
class QRhiRenderPassDescriptor;
class QRhiRenderTarget;
class QRhiResourceUpdateBatch;
class QRhiSampler;
class QRhiShaderResourceBindings;
class QRhiTexture;

 
namespace hmi {

class SpriteBatch {
public:
    explicit SpriteBatch(QRhi* rhi);
 
    ~SpriteBatch();
 
    SpriteBatch(const SpriteBatch&) = delete;
    SpriteBatch& operator=(const SpriteBatch&) = delete;

    [[nodiscard]] QRhi* rhi() const noexcept {
        return _rhi;
    }

    void beginFrame();

    void begin(const DirectX::XMFLOAT4X4& projection, TextureHandle texture);

    void draw(const SpriteQuad& quad);

    void draw(const LineQuad& line);

    void end();

    void submit(QRhiCommandBuffer* commandBuffer, QRhiRenderTarget* target,
                QRhiResourceUpdateBatch* updates, const float clear[4]);
 
private:
    struct Vertex {
        float x;
        float y;
        float u;
        float v;
        float r;
        float g;
        float b;
        float a;
    };

    struct Batch {
        QRhiTexture* texture = nullptr;
        int uniformOffset = 0;
        std::size_t firstQuad = 0;
        std::size_t quadCount = 0;
    };

    static constexpr std::size_t MAXIMUM_QUADS = 65536 / 4;

    bool ensurePipeline(QRhiRenderTarget* target);
    bool ensureVertexCapacity(std::size_t quadCount);
    bool ensureUniformCapacity(std::size_t batchCount);
    QRhiShaderResourceBindings* bindingsFor(QRhiTexture* texture);
    void closeBatch();
 
    QRhi* _rhi;  // non possédé
    std::unique_ptr<QRhiBuffer> _vertexBuffer;
    std::unique_ptr<QRhiBuffer> _indexBuffer;
    std::unique_ptr<QRhiBuffer> _uniformBuffer;
    std::unique_ptr<QRhiSampler> _sampler;
    std::unique_ptr<QRhiGraphicsPipeline> _pipeline;
    QRhiRenderPassDescriptor* _pipelinePass = nullptr;
    std::unordered_map<QRhiTexture*, std::unique_ptr<QRhiShaderResourceBindings>> _bindings;
    std::unique_ptr<QRhiShaderResourceBindings> _layoutBindings;
    QRhiResourceUpdateBatch* _pendingIndexUpload = nullptr;
    std::size_t _uniformSlots = 0;
    int _uniformStride = 0;
 
    std::vector<Vertex> _vertices;
    std::vector<Batch> _batches;
    Batch _current{};
    bool _recording = false;
    std::vector<DirectX::XMFLOAT4X4> _projections;
};
 
}  // namespace hmi