SkinnedRenderer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Camera.hpp"       // FrustumPlanes
#include "RendererTypes.hpp" // BoneInfluence, SkinnedInstance, RigMeshSource
 
#include <SDL3/SDL.h>
#include <SDL3/SDL_gpu.h>
 
#include <glm/glm.hpp>
#include <vector>

class SkinnedRenderer
{
public:
    SkinnedRenderer() = default;
    ~SkinnedRenderer() = default;
 
    SkinnedRenderer(const SkinnedRenderer&) = delete;
    SkinnedRenderer& operator=(const SkinnedRenderer&) = delete;
    SkinnedRenderer(SkinnedRenderer&&) = delete;
    SkinnedRenderer& operator=(SkinnedRenderer&&) = delete;

    void init(SDL_GPUDevice* device,
              SDL_GPUTextureFormat& colorTarget,
              const SDL_GPUShaderFormat& shaderFormat);

    void setFrustumCullEnabled(bool enabled) { frustumCullEnabled_ = enabled; }

    bool setRig(const std::vector<RigMeshSource>& meshes, int numJoints);

    void setFrame(const std::vector<glm::mat4>& palette,
                  const std::vector<SkinnedInstance>& instances,
                  const FrustumPlanes& frustum);

    void uploadFrame(SDL_GPUCommandBuffer* cmd, SDL_GPUCopyPass* copyPass);

    void draw(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd);

    void drawDepth(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd);

    void drawChams(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd);

    void drawKillcamHighlight(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd);

    void shutdown();
 
    // ─── Readback (optional, for debug UI) ───────────────────────────────────

    [[nodiscard]] int numJoints() const { return numJoints_; }

    [[nodiscard]] bool rigInstalled() const { return rigInstalled_; }

    [[nodiscard]] size_t pendingInstanceCount() const { return frameInstances_.size(); }
 
private:
    struct SkinnedMesh
    {
        SDL_GPUBuffer* vb = nullptr;
        SDL_GPUBuffer* boneVb = nullptr;
        SDL_GPUBuffer* ib = nullptr;
        Uint32 indexCount = 0;
        Uint32 vertexCount = 0;
    };
 
    struct SsboInfo
    {
        SDL_GPUBuffer* ssbo_{};
        Uint32 capacityBytes_ = 0;
    };

    bool ensureSsbos(Uint32 paletteBytes, Uint32 instanceBytes);

    static bool sphereInFrustum(const glm::vec3& center, float radius, const FrustumPlanes& planes);
 
    bool createSkinningPipeline(SDL_GPUTextureFormat& colorTarget, const SDL_GPUShaderFormat& shaderFormat);
 
    bool createSkinnedDepthPipeline(const SDL_GPUShaderFormat& shaderFormat);

    bool createChamsPipeline();

    bool createKillcamHighlightPipeline();
 
    // ─── Borrowed ────────────────────────────────────────────────────────────
    SDL_GPUDevice* device_ = nullptr;
 
    // ─── Owned: pipeline (graphics team to create) ───────────────────────────
    SDL_GPUGraphicsPipeline* pipeline_ = nullptr;

    SDL_GPUGraphicsPipeline* depthPipeline_ = nullptr;

    SDL_GPUGraphicsPipeline* chamsPipeline_ = nullptr;

    SDL_GPUGraphicsPipeline* killcamHighlightPipeline_ = nullptr;

    SDL_GPUTextureFormat colorFormat_{};
    SDL_GPUShaderFormat shaderFormat_{};

    std::vector<Uint32> chamsIndices_;

    std::vector<Uint32> killcamHighlightIndices_;
 
    // ─── Owned: rig (set once via setRig) ────────────────────────────────────
    bool rigInstalled_ = false;
    int numJoints_ = 0;
    std::vector<SkinnedMesh> skinnedMeshes_;
    // Disabled by default: Game submits the skinned frame before drawFrame()
    // updates the renderer camera, so culling here can use a stale frustum and
    // make remote players flicker/fade at the edge of the previous frame's view.
    bool frustumCullEnabled_ = false; 
 
    // Bind-pose bounding sphere (rig-local space), computed in `setRig` and used
    // by `setFrame` to frustum-cull instances.  The radius carries an animation
    // margin so limbs swung out past the bind pose are not clipped early.
    glm::vec3 rigBoundingCenter_{0.0f};
    float rigBoundingRadius_ = 0.0f;
 
    // ─── Owned: per-frame GPU resources (grow on demand) ─────────────────────
    // SDL_GPUBuffer* palettesSsbo_ = nullptr;  ///< STORAGE_READ, mat4[numInstances * numJoints].
    // SDL_GPUBuffer* instancesSsbo_ = nullptr; ///< STORAGE_READ, SkinnedInstance[numInstances].
    // Uint32 palettesCapacityBytes_ = 0;
    // Uint32 instancesCapacityBytes_ = 0;
    SsboInfo palettesSsboInfo_;
    SsboInfo instancesSsboInfo_;
 
    SDL_GPUTransferBuffer* paletteXfer_ = nullptr;
    SDL_GPUTransferBuffer* instanceXfer_ = nullptr;
    Uint32 paletteXferCapacityBytes_ = 0;
    Uint32 instanceXferCapacityBytes_ = 0;
 
    // ─── CPU staging (filled by setFrame, drained by uploadFrame) ────────────
    //
    // `frameInstances_` holds EVERY submitted character, partitioned so the
    // on-screen ones come first:
    //   [0, visibleInstanceCount_)        → inside the camera frustum
    //   [visibleInstanceCount_, size())   → off-screen, but still shadow casters
    // The colour pass (`draw`) renders only the front slice; the shadow/depth
    // pass (`drawDepth`) renders the whole buffer so off-screen players keep
    // casting shadows.  `framePalette_` is compacted in the same order.
    std::vector<glm::mat4> framePalette_;
    std::vector<SkinnedInstance> frameInstances_;
    Uint32 visibleInstanceCount_ = 0;
    bool frameDirty_ = false;
};