Renderer.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include "Camera.hpp"
#include "IRenderer.hpp"
#include "ModelLoader.hpp"
#include "RendererTypes.hpp"
 
#include <SDL3/SDL.h>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <string>
#include <vector>
 
class ParticleSystem; 
 
 
class Renderer : public IRenderer
{
public:
    [[nodiscard]] bool supports(RendererFeature /*feature*/) const override { return true; }
 
    bool init(SDL_Window* window) override;
 
    void drawFrame(glm::vec3 eye, float yaw, float pitch, float roll) override;
 
    void requestScreenshot(const std::string& path) override;
 
    bool setVSync(bool enabled) override;
 
    void quit() override;
 
    // Particle system integration
    void setParticleSystem(ParticleSystem* ps) override { particleSystem = ps; }
 
    [[nodiscard]] SDL_GPUDevice* getDevice() const override { return device; }
 
    [[nodiscard]] const Camera& getCamera() const override { return camera; }
 
    [[nodiscard]] SDL_GPUShaderFormat getShaderFormat() const override { return shaderFormat; }
 
    [[nodiscard]] static constexpr SDL_GPUTextureFormat getHdrFormat()
    {
        return SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT;
    }
 
    // Entity rendering
    void setEntityRenderList(std::vector<EntityRenderCmd> cmds) override { entityRenderCmds = std::move(cmds); }
 
    void setPointLights(std::vector<PointLight> lights) override { pointLights = std::move(lights); }
 
    void setModelEmissive(int modelIndex, glm::vec4 emissiveFactor) override
    {
        if (modelIndex >= 0 && static_cast<size_t>(modelIndex) < models.size())
            for (auto& m : models[static_cast<size_t>(modelIndex)].meshes)
                m.material.emissiveFactor = emissiveFactor;
    }
 
    void setWeaponViewmodel(const WeaponViewmodel& vm) override { weaponVM = vm; }
 
    int loadSceneModel(const char* filename, glm::vec3 pos, float scale, bool flipUVs = false) override;
 
    int uploadSceneModel(const LoadedModel& model) override;
 
    void
    updateModelMeshVertices(int modelIndex, int meshIndex, const ModelVertex* vertices, Uint32 vertexCount) override;
 
    [[nodiscard]] int modelCount() const override { return static_cast<int>(models.size()); }
 
    // HDR skybox
    bool loadHDRSkybox(const std::string& path);
    void scanHDRFiles();
    std::vector<std::string> availableHDRFiles;
    std::string currentHDRName = "(procedural)";
    bool useHDRSkybox = false;
 
private:
    // Core GPU state
    SDL_Window* window = nullptr;
    SDL_GPUDevice* device = nullptr;
    SDL_GPUTextureFormat swapchainFormat = SDL_GPU_TEXTUREFORMAT_INVALID;
    SDL_GPUShaderFormat shaderFormat = SDL_GPU_SHADERFORMAT_INVALID;
 
    Camera camera;
 
    // Pipelines
    SDL_GPUGraphicsPipeline* scenePipeline = nullptr;          
    SDL_GPUGraphicsPipeline* pbrPipeline = nullptr;            
    SDL_GPUGraphicsPipeline* pbrTransparentPipeline = nullptr; 
    SDL_GPUGraphicsPipeline* skyboxPipeline = nullptr;         
    SDL_GPUGraphicsPipeline* tonemapPipeline = nullptr;        
    SDL_GPUGraphicsPipeline* shadowPipeline = nullptr;         
    SDL_GPUGraphicsPipeline* sceneShadowPipeline = nullptr;    
 
    // Render targets
    SDL_GPUTexture* depthTexture = nullptr;       
    SDL_GPUTexture* weaponDepthTexture = nullptr; 
    Uint32 depthWidth = 0;
    Uint32 depthHeight = 0;
 
    SDL_GPUTexture* hdrTarget = nullptr; 
    Uint32 hdrWidth = 0;
    Uint32 hdrHeight = 0;
 
    static constexpr int k_shadowCascades = 4;
    static constexpr int k_shadowMapSize = 2048;
    SDL_GPUTexture* shadowMap = nullptr; 
 
    // IBL textures (Phase 6)
    SDL_GPUTexture* brdfLUT = nullptr;       
    SDL_GPUTexture* irradianceMap = nullptr; 
    SDL_GPUTexture* prefilterMap = nullptr;  
    SDL_GPUTexture* irradianceWorkMap = nullptr; 
    SDL_GPUTexture* prefilterWorkMap = nullptr;  
    SDL_GPUSampler* iblSampler = nullptr;        
    SDL_GPUTexture* envCubemap = nullptr;        
 
    // IBL compute pipelines (Phase 6) -- run once at startup, plus per HDR swap.
    SDL_GPUComputePipeline* brdfLutPipeline = nullptr;    
    SDL_GPUComputePipeline* irradiancePipeline = nullptr; 
    SDL_GPUComputePipeline* prefilterPipeline = nullptr;  
 
    // Samplers
    SDL_GPUSampler* pbrSampler = nullptr;          
    SDL_GPUSampler* shadowSampler = nullptr;       
    SDL_GPUSampler* tonemapSampler = nullptr;      
    SDL_GPUSampler* nearestDepthSampler = nullptr; 
 
    // Model rendering
 
    struct GpuMesh
    {
        SDL_GPUBuffer* vertexBuffer = nullptr;
        SDL_GPUBuffer* indexBuffer = nullptr;
        Uint32 indexCount = 0;
        int albedoTexIndex = -1;
        int normalTexIndex = -1;
        int metallicRoughnessTexIndex = -1;
        int emissiveTexIndex = -1;
        MaterialData material;
        bool isTransparent = false; 
    };
 
    struct ModelInstance
    {
        std::vector<GpuMesh> meshes;
        std::vector<SDL_GPUTexture*> textures;
        glm::mat4 transform{1.0f};
        bool drawInScenePass = true; 
    };
 
    std::vector<ModelInstance> models;
 
    // Fallback 1x1 textures for missing PBR maps.
    SDL_GPUTexture* fallbackWhite = nullptr;      
    SDL_GPUTexture* fallbackFlatNormal = nullptr; 
    SDL_GPUTexture* fallbackMR = nullptr;         
    SDL_GPUTexture* fallbackBlack = nullptr;      
 
    // Particle system
    ParticleSystem* particleSystem = nullptr; 
 
    // Entity rendering
    std::vector<EntityRenderCmd> entityRenderCmds; 
    std::vector<PointLight> pointLights;           
    WeaponViewmodel weaponVM;                      
 
    // Deferred vertex re-uploads (skinned animation)
    // Queued by updateModelMeshVertices(), flushed at the start of drawFrame()
    // inside the main command buffer -- zero extra submits, zero pipeline stalls.
 
    struct PendingVertexUpload
    {
        SDL_GPUBuffer* dstBuffer = nullptr;
        std::vector<uint8_t> data;
    };
    std::vector<PendingVertexUpload> pendingVertexUploads;
 
    SDL_GPUTransferBuffer* skinTransferBuf = nullptr; 
    Uint32 skinTransferBufSize = 0;                   
 
    // Screen capture
    SDL_GPUTexture* captureRT = nullptr;
    Uint32 captureRTW = 0, captureRTH = 0;
    SDL_GPUTextureFormat captureRTFmt = SDL_GPU_TEXTUREFORMAT_INVALID;
    std::string pendingCapPath;
 
    // Post-processing (Phases 7-12)
    Uint32 postProcW = 0, postProcH = 0; 
 
    // Bloom (Phase 8)
    static constexpr int k_bloomMips = 6;
    SDL_GPUTexture* bloomMips[k_bloomMips] = {}; 
    SDL_GPUComputePipeline* bloomDownsamplePipeline = nullptr;
    SDL_GPUComputePipeline* bloomUpsamplePipeline = nullptr;
 
    // SSAO (Phase 7)
    SDL_GPUTexture* ssaoTexture = nullptr;     
    SDL_GPUTexture* ssaoBlurTexture = nullptr; 
    SDL_GPUComputePipeline* ssaoPipeline = nullptr;
    SDL_GPUComputePipeline* ssaoBlurPipeline = nullptr;
    SDL_GPUTexture* ssaoNoiseTexture = nullptr; 
 
    // SMAA + Temporal Resolve (replaces old TAA)
    SDL_GPUGraphicsPipeline* smaaEdgePipeline = nullptr;  
    SDL_GPUGraphicsPipeline* smaaBlendPipeline = nullptr; 
    SDL_GPUGraphicsPipeline* smaaNeighborhoodPipeline =
        nullptr; 
    SDL_GPUComputePipeline* smaaResolvePipeline = nullptr; 
    SDL_GPUTexture* smaaEdgeTex = nullptr;                 
    SDL_GPUTexture* smaaBlendTex = nullptr;                
    SDL_GPUTexture* smaaOutputTex = nullptr;               
    SDL_GPUTexture* smaaAreaTex = nullptr;                 
    SDL_GPUTexture* smaaSearchTex = nullptr;               
 
    // CAS (Contrast Adaptive Sharpening)
    SDL_GPUComputePipeline* casPipeline = nullptr; 
    SDL_GPUTexture* casOutputTex = nullptr;        
 
    // Temporal history + motion vectors (reused from old TAA)
    SDL_GPUTexture* taaHistory[2] = {};            
    int taaCurrentIdx = 0;
    glm::mat4 previousVP{1.0f};                    
    SDL_GPUTexture* motionVectorTexture = nullptr; 
    SDL_GPUComputePipeline* motionVectorPipeline = nullptr;
 
    // Jitter
    int frameIndex = 0; 
 
    // SSR (Phase 9) — ping-pong for temporal accumulation.
    SDL_GPUTexture* ssrTexture[2] = {}; 
    int ssrCurrentIdx = 0;
    SDL_GPUComputePipeline* ssrPipeline = nullptr;
 
public:
    int ssrMode = 2;       
    RenderToggles toggles; 
 
    // Anti-aliasing (live-tunable via ImGui)
    AAMode aaMode = AAMode::SMAA_T2x; 
    bool casEnabled = true;           
    float casStrength = 1.0f;         
 
    // Sun / lighting (live-tunable via ImGui)
    float sunAzimuth = 210.0f;  
    float sunElevation = 60.0f; 
    float sunIntensity = 3.0f;  
    float fillIntensity = 0.8f; 
    float ambientR = 0.08f, ambientG = 0.09f, ambientB = 0.12f; 
    float iblDiffuseIntensity = 1.0f;                           
    float iblSpecularIntensity = 0.5f;
    float bloomStr = 0.3f;    
    float ssaoStr = 0.8f;     
    float ssaoRadius = 0.8f;  
    float ssaoFalloff = 2.0f; 
    float ssaoPower = 1.5f;   
    float ssrStr = 0.4f;      
    float volStr = 0.15f;     
    float sharpenStr = 0.6f;  
    float shadowBiasVal = 0.0005f;
    float shadowNormalBiasVal = 1.5f;
    float shadowDistance = 3000.0f; 
    float cascadeLambda = 0.92f;    
 
    [[nodiscard]] glm::vec3 getSunDirection() const;
 
private:
    // Volumetrics (Phase 10)
    SDL_GPUTexture* volumetricTexture = nullptr; 
    SDL_GPUComputePipeline* volumetricPipeline = nullptr;
 
    // OIT (Phase 12)
    SDL_GPUTexture* oitAccumTexture = nullptr;  
    SDL_GPUTexture* oitRevealTexture = nullptr; 
    SDL_GPUGraphicsPipeline* oitPipeline = nullptr;
    SDL_GPUGraphicsPipeline* oitResolvePipeline = nullptr;
 
    // Private helpers
    bool initScenePipeline();
    bool initPBRPipeline();
    bool initSkyboxPipeline();
    bool initTonemapPipeline();
    bool initShadowPipeline();
    bool initSceneShadowPipeline();
 
    bool initIBL();
 
    bool regenerateIBLFromCubemap(SDL_GPUTexture* envCube);
 
    bool initBloom();
    bool initSSAO();
    bool initSMAA(); 
    bool initCAS();  
    bool initSSR();
    bool initVolumetrics();
 
    SDL_GPUComputePipeline* createComputePipeline(const char* shaderName,
                                                  Uint32 numSamplers,
                                                  Uint32 numReadonlyStorageTextures,
                                                  Uint32 numReadonlyStorageBuffers,
                                                  Uint32 numReadwriteStorageTextures,
                                                  Uint32 numReadwriteStorageBuffers,
                                                  Uint32 numUniformBuffers,
                                                  Uint32 threadCountX,
                                                  Uint32 threadCountY,
                                                  Uint32 threadCountZ);
    bool ensureDepthTexture(Uint32 w, Uint32 h);
 
    bool ensureHDRTarget(Uint32 w, Uint32 h);
 
    bool ensureCaptureRT(Uint32 w, Uint32 h, SDL_GPUTextureFormat fmt);
 
    bool uploadModel(const LoadedModel& model, ModelInstance& outInstance);
 
    SDL_GPUTexture* uploadTexture(const uint8_t* pixels, int width, int height, bool sRGB = true);
 
    void downloadAndSaveCapture(Uint32 w, Uint32 h);
 
    SDL_GPUShader* loadShaderFromFile(const char* name,
                                      SDL_GPUShaderStage stage,
                                      Uint32 samplerCount,
                                      Uint32 uniformBufferCount,
                                      Uint32 storageBufferCount = 0,
                                      Uint32 storageTextureCount = 0);
};