NewRenderer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Asset.hpp"
#include "Boilerplate.hpp"
#include "Camera.hpp"
#include "RendererTypes.hpp"
#include "SkinnedRenderer.hpp"
 
#include <SDL3/SDL.h>
#include <SDL3/SDL_gpu.h>
 
#include <glm/glm.hpp>
#include <queue>
#include <string>
#include <vector>
 
#define NUM_CUBE_FACES 6
class ParticleSystem; 

struct Vertex
{
    glm::vec3 position;
    glm::vec3 normal;
    glm::vec2 texUV;
    glm::vec4 tangent;
    glm::vec2 lightMapUV;
};
 
enum class PointLightType : std::uint8_t
{
    STATIC,
    MOVING,
    TEMPORARY,
    NON_SHADOW,
};
 
struct LightUBO
{
    uint32_t numPointLights = 0;
    uint32_t numMovingPointLights = 0;
    uint32_t numSpotLights = 0;
    float pointLightFarPlane = 4000.0f;
    float pointLightNearPlane = 5.0f;
    float cameraPosX = 0.0f;
    float cameraPosY = 0.0f;
    float cameraPosZ = 0.0f;
    PointLight pointLights[MAX_POINT_LIGHTS];
    PointLight movingPointLights[MAX_MOVING_POINT_LIGHTS];
};

class NewRenderer
{
public:
    // ─── Lifecycle ───────────────────────────────────────────────────────────

    bool init(SDL_Window* window);

    void drawFrame(glm::vec3 eye, float yaw, float pitch, float roll);

    void quit();
 
    // ─── Readback (must return real values — gameplay depends on them) ───────

    [[nodiscard]] SDL_GPUDevice* getDevice() const { return device_; }

    [[nodiscard]] SDL_GPUShaderFormat getShaderFormat() const { return shaderFormat_; }

    [[nodiscard]] SDL_GPUTextureFormat getSwapchainColorFormat() const { return colorTarget_; }

    [[nodiscard]] const NewCamera& getCamera() const { return camera_; }

    [[nodiscard]] int modelCount() const;

    [[nodiscard]] static constexpr SDL_GPUTextureFormat getHdrFormat()
    {
        return SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT;
    }

    [[nodiscard]] float getLastAcquireMs() const { return lastAcquireMs_; }

    [[nodiscard]] float getLastRecordMs() const { return lastRecordMs_; }

    [[nodiscard]] float getLastSubmitMs() const { return lastSubmitMs_; }
 
    // ─── Per-frame submit setters (data-capture stubs) ───────────────────────
    //
    // Called by Game.cpp every frame BEFORE drawFrame.  Each stores the
    // payload into a member field; drawFrame reads it.  Currently most of
    // these have no consumer — the data is captured but nothing renders.

    void setEntityRenderList(std::vector<EntityRenderCmd>&& entityList);

    void setPointLights(std::vector<PointLight> pointLights);
    void setStaticPointLights(std::vector<PointLight>&& pointLights);

    void setWeaponViewmodel(const WeaponViewmodel& vm);

    void setModelEmissive(int32_t modelIdUnsanitized, glm::vec4 emissiveColor);

    void setModelScenePass(int32_t modelIndex, bool drawInScene);
 
    // ─── Skinned characters (animated players) ───────────────────────────────
    //
    // The skinning pipeline (rig install, per-frame palette upload, instanced
    // draw, shaders) is its own subsystem — see `SkinnedRenderer.hpp`.
    // Game code talks to it through the accessor below:
    //
    //   renderer.skinned().setRig(meshes, numJoints);            // once
    //   renderer.skinned().setFrame(palette, instances);          // every frame
    //
    // `NewRenderer::drawFrame` automatically drives the matching
    // `uploadFrame()` (before render pass) and `draw()` (inside geometry pass)
    // — game code never calls those directly.

    [[nodiscard]] SkinnedRenderer& skinned() { return skinnedRenderer_; }
    [[nodiscard]] const SkinnedRenderer& skinned() const { return skinnedRenderer_; }
 
    // ─── Static models ───────────────────────────────────────────────────────

    int loadSceneModel(
        const char* filename, glm::vec3 pos, float scale, bool flipUVs, const std::string& excludeNodesContaining = "");

    void setHudTexture(SDL_GPUTexture* hudTexture);
 
    // ─── Subsystem registration ─────────────────────────────────────────────

    void setParticleSystem(ParticleSystem* ps);
 
    // ─── Settings / toggles ─────────────────────────────────────────────────

    bool setVSync(bool enabled);

    void requestScreenshot(const std::string& path);
    void updateModelMeshVertices(int modelIndex, int meshIndex, const Vertex* vertices, Uint32 vertexCount);

    bool loadHDRSkybox(const std::string& path);

    void scanHDRFiles();
 
    bool setRig(const std::vector<RigMeshSource>& meshes, int numJoints);
 
    void setSkinnedFrame(const std::vector<glm::mat4>& palette, const std::vector<SkinnedInstance>& instances);
 
    // ─── Public settings members (mutable directly from Game / debug UI) ─────
    //
    // The legacy renderer exposed these as direct member access.  Keep the
    // pattern so Game.cpp and the debug UI can read/write without a getter
    // ceremony.
 
    float renderScale = 1.0f;                    
    float mainHorizontalFovDegrees = 110.0f;     
    float scopeZoom = 1.0f;                      
    bool imguiEnabled = true;                    
    RenderToggles toggles{};                     
    float roughnessTextureStrength = 1.0f;       
    float metallicTextureStrength = 0.5f;        
    float ambientColorMultiplier = 1.0f;         
    float lightIntensityMultiplier = 8.0f;       
    float hdrExposure = 1.0f;                    
    float hdrWhitePoint = 4.0f;                  
    float ssaoRadius = 24.0f;                    
    float ssaoBias = 1.5f;                       
    float ssaoPixelRadiusScale = 0.35f;          
    float ssaoDepthThreshold = 0.01f;            
    float ssaoNormalDiffMin = 0.12f;             
    float ssaoNormalDiffMax = 0.55f;             
    float ssaoHemisphereMin = 0.05f;             
    float ssaoContactWeight = 1.0f;              
    float ssaoMediumRadius = 48.0f;              
    float ssaoMediumWeight = 0.25f;              
    float ssaoIntensity = 1.0f;                  
    float ssaoMinAo = 0.45f;                     
    float ssaoMaxAo = 1.0f;                      
    bool ssaoBlurEnabled = true;                 
    float ssaoBlurRadius = 1.0f;                 
    float ssaoBlurDepthThreshold = 0.3f;         
    float ssaoBlurNormalThreshold = 0.6f;        
    float ssaoBlurStrength = 1.0f;               
    float ssaoCompositeStrength = 1.0f;          
    float ssaoCompositePower = 2.0f;             
    int ssaoDebugView = 0;                       
    std::vector<std::string> availableHDRFiles;  
    std::string currentHDRName = "(procedural)"; 
    bool useHDRSkybox = false;                   
 
private:
    // ─── Existing internal helpers ───────────────────────────────────────────
 
    bool createGeometryPipeline();
    bool createGeometryLightMapPipeline();
    bool createEntityChamsPipeline();
    SDL_GPUGraphicsPipeline* createDepthPipeline(const SDL_GPURasterizerState& rasterizer_state) const;
    bool createDepthRes0Pipeline(bool reverseZ);
    bool createDepthRes1Pipeline(bool reverseZ);
    bool createDepthRes2Pipeline(bool reverseZ);
    bool createHudPipeline();
    bool createFxaaPipeline();
    bool createTonemapPipeline();
    bool createSsaoPipeline();
    bool createSsaoBlurPipeline();
    bool createSsaoCompositePipeline();
    bool ensureDepthTextureSize(Uint32 width, Uint32 height);
    bool ensureSceneTextureSize(Uint32 width, Uint32 height);
    void createMeshBuffers(MeshIdInt meshId) const;
    void setMainCamera(glm::vec3 eye, float yaw, float pitch, float roll, Uint32 width, Uint32 height, float fov);
 
    void drawGeometryDepthPass(SDL_GPUTexture* depthTexture,
                               Uint8 res,
                               Uint8 layer,
                               SDL_GPUCommandBuffer* cmd,
                               const glm::mat4& shadowViewProjection,
                               bool staticGeometry,
                               bool entityGeometry,
                               bool skinnedGeometry);
    void drawToShadowMap(SDL_GPUCommandBuffer* cmd,
                         SDL_GPUTexture* shadowMapTexture,
                         Uint8 res,
                         bool staticGeometry,
                         bool entityGeometry,
                         bool skinnedGeometry,
                         PointLightType lightType,
                         bool cullByCamera = true);
 
    void onFirstFrame(SDL_GPUCommandBuffer* cmd);
 
    void bindLightShadowInfo(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd, bool lightmap);
    void drawStaticLightmapGeometryPass(SDL_GPUTexture* sceneColor, SDL_GPUCommandBuffer* cmd);
    void drawGeometryPass(SDL_GPUTexture* sceneColor, SDL_GPUCommandBuffer* cmd);
    void drawGeometryOverlayPass(SDL_GPUTexture* sceneColor, SDL_GPUCommandBuffer* cmd);
    void drawSsaoPass(SDL_GPUTexture* depth, SDL_GPUTexture* normal, SDL_GPUTexture* ao, SDL_GPUCommandBuffer* cmd);
    void drawSsaoBlurPass(
        SDL_GPUTexture* ao, SDL_GPUTexture* depth, SDL_GPUTexture* normal, SDL_GPUTexture* output, SDL_GPUCommandBuffer* cmd);
    void drawSsaoCompositePass(
        SDL_GPUTexture* sceneColor, SDL_GPUTexture* rawAo, SDL_GPUTexture* blurredAo, SDL_GPUTexture* output, SDL_GPUCommandBuffer* cmd);
    void drawUIPass(SDL_GPUTexture* swapchain, SDL_GPUCommandBuffer* cmd);
    void drawHudPass(SDL_GPUTexture* target, SDL_GPUCommandBuffer* cmd);
    void drawFxaaPass(SDL_GPUTexture* sceneColor, SDL_GPUTexture* swapchain, SDL_GPUCommandBuffer* cmd);
    void drawTonemapPass(SDL_GPUTexture* hdrSceneColor, SDL_GPUTexture* ldrColor, SDL_GPUCommandBuffer* cmd);
    void drawParticles(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd) const;
    void drawWeaponPass(SDL_GPUTexture* sceneColor, SDL_GPUCommandBuffer* cmd);
    void drawWorldModelInstances(SDL_GPURenderPass* renderPass,
                                 SDL_GPUCommandBuffer* cmd,
                                 bool depth,
                                 const FrustumPlanes& frustumPlanes);
    void drawWeapon(SDL_GPURenderPass* geometryPass, SDL_GPUCommandBuffer* cmd, const FrustumPlanes& frustumPlanes);
    void drawSkinnedModels(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd);
    void drawEntityChams(SDL_GPURenderPass* renderPass, SDL_GPUCommandBuffer* cmd, const FrustumPlanes& frustumPlanes);
 
    void drawModel(ModelIdInt modelId,
                   const glm::mat4& modelTransform,
                   SDL_GPURenderPass* renderPass,
                   SDL_GPUCommandBuffer* cmd,
                   const FrustumPlanes& frustumPlanes,
                   glm::vec4 tint = glm::vec4{1.0f});
 
    void drawModelDepth(ModelIdInt modelId,
                        const glm::mat4& modelTransform,
                        SDL_GPURenderPass* renderPass,
                        SDL_GPUCommandBuffer* cmd,
                        const FrustumPlanes& frustumPlanes);
 
    void drawEntityModels(SDL_GPURenderPass* renderPass,
                          SDL_GPUCommandBuffer* cmd,
                          bool depth,
                          const FrustumPlanes& frustumPlanes);
 
    void drawMesh(SDL_GPURenderPass* renderPass, const Asset::Mesh& mesh) const;
    void drawHud(SDL_GPURenderPass* pass);
 
    static bool
    inFrustum(const Asset::AABB& modelElementAABB, const FrustumPlanes& frustumPlanes, const glm::mat4& modelMat);
    bool loadLightMap();
 
    // ─── Member state ────────────────────────────────────────────────────────
 
    SDL_Window* window_ = nullptr;
    SDL_GPUDevice* device_ = nullptr;
    SDL_GPUShaderFormat shaderFormat_ = SDL_GPU_SHADERFORMAT_INVALID;
 
    SDL_GPUGraphicsPipeline* geometryPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* geometryLightMapPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* entityChamsPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* hudPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* fxaaPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* tonemapPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* ssaoPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* ssaoBlurPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* ssaoCompositePipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* skinnedPipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* depthRes0Pipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* depthRes1Pipeline_ = nullptr;
    SDL_GPUGraphicsPipeline* depthRes2Pipeline_ = nullptr;
 
    SDL_GPUTextureFormat colorTarget_ = SDL_GPU_TEXTUREFORMAT_INVALID;
    SDL_GPUTexture* sceneColor_ = nullptr;
    SDL_GPUTexture* sceneNormal_ = nullptr;
    SDL_GPUTexture* ssaoColor_ = nullptr;
    SDL_GPUTexture* ssaoBlurred_ = nullptr;
    SDL_GPUTexture* sceneWithAo_ = nullptr;
    SDL_GPUTexture* tonemappedColor_ = nullptr;
    SDL_GPUTexture* lightMap_ = nullptr;
    SDL_GPUDepthStencilTargetInfo depthTarget_{};
    Uint32 sceneWidth_ = 0;
    Uint32 sceneHeight_ = 0;
    Uint32 ssaoWidth_ = 0;
    Uint32 ssaoHeight_ = 0;
    Uint32 depthWidth_ = 0;
    Uint32 depthHeight_ = 0;
 
    // Default fallback texture used when a mesh has no material/texture.
    SDL_GPUTexture* texture_ = nullptr;
    SDL_GPUSampler* sampler_ = nullptr;
    SDL_GPUSampler* nearestSampler_ = nullptr;
 
    SDL_GPUTexture* hudTexture_ = nullptr;
    SDL_GPUSampler* hudSampler_ = nullptr;
    SDL_GPUSampler* fxaaSampler_ = nullptr;
 
    // constexpr uint32_t shadowSize = 2048;
    //  constexpr uint32_t shadowSize = 512;
    static const uint32_t shadowSize = 1024;
    static const uint32_t macShadowSize = 512;
    static const uint32_t staticShadowSize = 2048;
    SDL_GPUTexture* dynamicShadowMaps_ = nullptr;
    SDL_GPUTexture* staticShadowMaps_ = nullptr;
    SDL_GPUSampler* staticDepthSampler_ = nullptr;
    SDL_GPUSampler* dynamicDepthSampler_ = nullptr;
 
    SDL_GPUTexture* movingLightShadowMaps_ = nullptr;
 
    glm::vec3 cubeFaceTargets_[NUM_CUBE_FACES];
    glm::vec3 cubeFaceUps_[NUM_CUBE_FACES];
 
    bool firstFrame_ = true;
 
    LightUBO sceneLightInfo_;
 
    NewCamera camera_;
 
    // Per-frame captured state ───────────────────────────────────────────────
    std::vector<EntityRenderCmd> entities_;
    // std::vector<Asset::AABB> entityAABBs_;
    WeaponViewmodel weapon_{};
    ParticleSystem* particleSystem_ = nullptr;
 
    // Settings captured state ─────────────────────────────────────────────────
    bool vsyncEnabled_ = true;
    std::string pendingScreenshotPath_;
    // Skinned-character subsystem (see SkinnedRenderer.hpp) ──────────────────
    SkinnedRenderer skinnedRenderer_;
 
    // Telemetry counters (filled by drawFrame) ────────────────────────────────
    float lastAcquireMs_ = 0.0f;
    float lastRecordMs_ = 0.0f;
    float lastSubmitMs_ = 0.0f;
};