Renderer.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Debug/DebugDraw.h"
#include "Engine/Material/MaterialTypes.h"
#include "Engine/Renderer/IBLResources.h"
#include "Engine/Renderer/SunShadowResources.h"
#include "Engine/World/SceneGraph.h"
#include "VulkanStagedBuffer.h"
 
#include <chrono>
#include <Engine/Renderer/PipelineMaterialPayload.h>
#include <Engine/Renderer/Buffer.h>
#include <filesystem>
#include <memory>
#include <unordered_map>
#include <vector>
#include <vulkan/vulkan_core.h>
 
#ifdef ENABLE_TRACY
#    include <tracy/TracyVulkan.hpp>
#endif
 
namespace Engine::Debug::Tracy
{
    class TracyVkContextManager;
}  // namespace Engine::Debug::Tracy
 
namespace Vulkan
{
    class BarrierBundle;
}  // namespace Vulkan
 
namespace Engine
{
    class EngineKern;
    class ParticleSystem;
}
 
namespace Engine::Core
{
    class RenderingDataManager;
}
 
namespace Engine::Assets
{
    class Material;
}
 
namespace Engine::Rendering
{
    class ComputePassManager;
    class RenderProcess;
    class BufferManager;
    class Headset;
    class TimelineSynchronizer;
    class WorldUiRenderer;

    struct PipelineConfig
    {
        std::filesystem::path meshShaderPath;
        std::filesystem::path fragmentShaderPath;
        PipelineMaterialPayload pipelineData = {};
    };

    class Renderer
    {
        struct TaskConstants
        {
            TaskConstants() = default;
 
            explicit TaskConstants( const uint32_t drawCommandOffset = 0 )
              : drawCommandOffset( drawCommandOffset )
            {
            }
 
            TaskConstants( const uint32_t drawCommandOffset, const uint32_t cascadeIndex )
              : drawCommandOffset( drawCommandOffset )
              , cascadeIndex( cascadeIndex )
            {
            }
 
            uint32_t drawCommandOffset = 0u;
            uint32_t cascadeIndex = 0u;
            uint32_t _padding[2]{};
        };
 
 
    public:
        explicit Renderer(
            Core::ApplicationContext * context = nullptr,
            Headset *                  headset = nullptr,
            const EngineKern *         engine  = nullptr
        );

        ~Renderer();

        void allocateDescriptors();
 
        void initializeGpuBuffers() const;
        void prepareTransferSubmission( uint32_t frameIndex ) const;

        void updateViewMatrix() const;
 
        // Compute pass resources are now created via ComputePassManager
        // void createPrimitiveCullingResources();     // 1
        // void createBinningAllocatorResources();  // 1.5 (Stage 1)
        // void createMeshletUnpackingResources();  // 3 (Stage 2)
        // void createMeshletCullingResources();    // 5
        // void createPrepareDrawResources();       // 6
        void createVertexShaderPathResources(); // Vertex shader path for single-meshlet geometry

        // void createMeshletUnpackingDispatcherResources();  // 2 - Now in ComputePassManager
        // void createMeshletCullingDispatcherResources();  // 4 - Now in ComputePassManager

        void updateCpuRenderResources( float time );

        void restartRenderCommandBuffers() const;
 
        void recordTonemapToSwapchain( uint32_t swapChainImageIndex ) const;

        void recordRenderPass( size_t swapChainImageIndex );

        const std::unique_ptr<Core::RenderingDataManager> & getRenderingDataManager() const;

        const std::unique_ptr<BufferManager> & getBufferManager() const;
 
        const std::unique_ptr<ComputePassManager> & getComputePassManager() const;

        bool ensureOutputBufferSizes( uint32_t primitive_count ) const;
 
    private:
 
        std::unique_ptr<Core::RenderingDataManager> renderingDataManager_;
        std::unique_ptr<BufferManager> bufferManager_;
        std::unique_ptr<ComputePassManager> computePassManager_;
 
    public:
        [[nodiscard]] const Vulkan::Buffer & getObjectCullingDataBuffer() const;
        [[nodiscard]] const Vulkan::Buffer & getObjectMeshletDataBuffer() const;
        [[nodiscard]] const Vulkan::Buffer & getObjectIDsBuffer() const;
        [[nodiscard]] const Vulkan::Buffer & getCounterBuffer() const;
        [[nodiscard]] const Vulkan::Buffer & getDispatchBuffer() const;
        [[nodiscard]] const Vulkan::Buffer & getMeshUnpackingDataBuffer() const;
 
        [[nodiscard]] const Vulkan::Buffer & getPlaceholderBuffer() const;
        [[nodiscard]] const Vulkan::Buffer & getPlaceholderUniformBuffer() const;
 
        VkDependencyInfo getObjectCullingToMeshletUnpackingDispatchBarriers(Vulkan::BarrierBundle & bundle ) const;
        VkDependencyInfo getMeshletUnpackingDispatchToMeshletUnpackingBarriers(Vulkan::BarrierBundle &bundle) const;
        VkDependencyInfo getMeshletUnpackingToMeshletCullingDispatchBarriers( Vulkan::BarrierBundle & bundle ) const;
        VkDependencyInfo getMeshletCullingDispatchToMeshletCullingBarriers() const;
        VkDependencyInfo getMeshletCullingToPrepareDrawBarriers() const;
 
        void resetMeshletUnpackingDispatchBuffers();
        void resetMeshletCullingDispatchBuffers() const;
 
        void renderToXr( size_t swapChainImageIndex, float time );
 
        void recordTransfer( float time );
        void submitInitialTransfers();
        void uploadFrameData( float time );
        void submitTransfer() const;

        void waitForPreviousFrame() const;
 
        void submitGraphics(
            uint32_t    swapChainImageIndex,
            VkSemaphore mirrorAcquireSemaphore = VK_NULL_HANDLE
        ) const;
        uint64_t getTimelineSemaphoreValue() const;

        [[nodiscard]] VkCommandBuffer getCurrentTransferCommandBuffer() const;
        [[nodiscard]] VkCommandBuffer getCurrentRenderingCommandBuffer() const;
        [[nodiscard]] VkSemaphore     getCurrentMirrorViewSemaphore() const;
        [[nodiscard]] VkSemaphore     getCurrentPresentableSemaphore( uint32_t swapchainImageIndex ) const;

        std::vector<VkCommandBuffer> getGraphicsCommandBuffers() const;
        std::vector<VkCommandBuffer> getTransferCommandBuffers() const;

        [[nodiscard]] const std::vector<RenderProcess*>& getRenderProcesses() const { return renderProcesses; }

        [[nodiscard]] VkCommandPool getGraphicsCommandPool() const;

        [[nodiscard]] VkCommandPool getTransferCommandPool() const;

        void cleanup();

        RenderProcess * getCurrentRenderProcess() const;

        void advanceFrameIndices();

        void syncTimelineAfterPause();

        [[nodiscard]] bool shouldSkipMirrorView();

        void markFrameStart();

        void resetFrameTimer();

        [[nodiscard]] int64_t getFrameElapsedMs() const;

        [[nodiscard]] bool isInStallRecovery() const;

        VkSemaphore getTimelineSemaphore() const;

        const std::vector<GraphicsPipeline *> & getGraphicsPipelines() const;

        [[nodiscard]] Headset* getHeadset() const { return headset_; }
 
        [[nodiscard]] const ImageBasedLightingResources & getIBLResources() const { return iblResources_; }
        [[nodiscard]] const SunShadowResources & getSunShadowResources() const { return sunShadowResources_; }
        [[nodiscard]] const SunShadowResources & getDynamicSunShadowResources() const { return dynamicSunShadowResources_; }

        void setFreezeCulling(bool freeze);

        [[nodiscard]] bool isFreezeCulling() const { return freezeCulling_; }
 
        void setVertexShaderOnlyMode(bool enabled) { vertexShaderOnlyMode_ = enabled; }
        [[nodiscard]] bool isVertexShaderOnlyMode() const { return vertexShaderOnlyMode_; }
 
        void setParallelLodSelection(bool enabled ) const;
 
        void setVSInstancedDrawing(bool enabled) { useVSInstancedDrawing_ = enabled; }
        void setSkipMeshShaderDraw(bool skip) { skipMeshShaderDraw_ = skip; }
        void setSkipVertexShaderDraw(bool skip) { skipVertexShaderDraw_ = skip; }
        void setSunShadowCasterDebugView(bool enabled) { sunShadowCasterDebugView_ = enabled; }
 
        void registerWindTrailEmitter(std::shared_ptr<Entities::SceneNode> node) { windTrailEmitterNode_ = node; }
        void unregisterWindTrailEmitter() { windTrailEmitterNode_.reset(); }
 
        void setTracyContextManager( Debug::Tracy::TracyVkContextManager * manager ) { tracyContextManager_ = manager; }

        [[nodiscard]] const TimelineSynchronizer& getTimelineSynchronizer() const;
 
        [[nodiscard]] WorldUiRenderer * getWorldUiRenderer() const { return worldUiRenderer_.get(); }
 
        void notifyMaterialLoaded( Assets::Material * material ) const;

        bool getPipelineIndex( GraphicsPipeline * pipeline, uint32_t & pipelineIndex ) const;

        bool getPipelineIndex( PipelineNames pipelineName, uint32_t & pipelineIndex ) const;

        static PipelineConfig getPipelineConfig( PipelineNames pipelineName );
 
    private:
        Debug::Tracy::TracyVkContextManager * tracyContextManager_ = nullptr;
 
#ifdef ENABLE_TRACY
        TracyVkCtx getCurrentTracyVkContext() const;
        TracyVkCtx getCurrentTracyTransferVkContext() const;
#else
        void getCurrentTracyVkContext() const {}
        void getCurrentTracyTransferVkContext() const {}
#endif
 
        std::unique_ptr<TimelineSynchronizer> timelineSynchronizer_;
        std::unique_ptr<WorldUiRenderer> worldUiRenderer_;
 
        void initializeFrameIndices();
        void initializeXrSwapchainFormats() const;
 
        uint64_t renderedFrameCounter_ = 0u;

        int skipMirrorFramesRemaining_ = 0;

        static constexpr int SKIP_FRAMES_AFTER_STALL = 4;

        std::chrono::steady_clock::time_point lastFrameStartTime_ = std::chrono::steady_clock::now();

        static constexpr std::chrono::milliseconds STALL_THRESHOLD_MS{1000};
 
        std::vector<Vulkan::StagedBufferSyncObjects> syncCopyObjects_{};
 
        // Maps each graphics pipeline pointer to its index within the graphicsPipelines vector
        std::unordered_map<GraphicsPipeline *, uint32_t> pipelineIndices_;
 
        // Maps PipelineNames enum to the created GraphicsPipeline object
        std::unordered_map<PipelineNames, GraphicsPipeline *> pipelinesByName_;
 
        // Maps PipelineNames enum to VS pipeline index (for when mesh shader pipelines are unavailable)
        std::unordered_map<PipelineNames, uint32_t> vsPipelineNameToIndex_;
 
        const EngineKern * engine_ = nullptr;

        int findExistingPipeline(
            const std::string &             meshShader,
            const std::string &             fragShader,
            const PipelineMaterialPayload & pipelineData
        ) const;

        VkCommandPool vkGraphicsCommandPool_ = VK_NULL_HANDLE;

        VkCommandPool vkTransferCommandPool_ = VK_NULL_HANDLE;

        VkDescriptorPool descriptorPool_ = VK_NULL_HANDLE;
 
 
        // Vertex Shader Path for single-meshlet geometry
        // Uses traditional vertex shader + instancing (faster than mesh shader for small meshes)
        std::vector<VkPipeline> vsGraphicsPipelines_;  // Per-material vertex shader pipelines (indexed by PipelineNames)
        VkPipelineLayout vsPipelineLayout_ = VK_NULL_HANDLE;  // Pipeline layout for VS path
        bool useVertexShaderPath_ = true;  // Enable VS path for single-meshlet geometry
        bool vertexShaderOnlyMode_ = false;  // Force ALL geometry through VS pipeline (bypass mesh shaders)
 
        void createVertexShaderPipelineResources();
        void recordVertexShaderDraws(size_t swapChainImageIndex) const;
 
        bool useVSInstancedDrawing_ = true;  // Enable VS instanced drawing optimization
 
        void createVSInstancedDrawingResources();
        void recordVSInstancedDrawingPipeline() const;
 
 
        void recordParallelLodSelectionPipeline() const;
        void resetVisibilityBuffers(VkCommandBuffer commandBuffer) const;
        void recordVisibilityComputeToGraphicsBarriers(VkCommandBuffer commandBuffer) const;
 
        // IBL (Image-Based Lighting) resources
        ImageBasedLightingResources iblResources_;
        VkDescriptorPool iblDescriptorPool_ = VK_NULL_HANDLE;
        VkDescriptorSet brdfLutDescriptorSet_ = VK_NULL_HANDLE;
 
        void createImageBasedLightingResources();
 
        // Cascaded sun shadow resources and pass state
        SunShadowResources sunShadowResources_;
        SunShadowResources dynamicSunShadowResources_;
        SunShadowCascadeBuffer staticSunShadowCascadeData_{};
        bool staticSunShadowCacheValid_ = false;
        VkPipeline sunShadowOpaquePipeline_ = VK_NULL_HANDLE;
        VkPipeline sunShadowMovableAlphaPipeline_ = VK_NULL_HANDLE;
        VkPipeline sunShadowStaticAlphaPipeline_ = VK_NULL_HANDLE;
        VkPipeline vsSunShadowOpaquePipeline_ = VK_NULL_HANDLE;
        VkPipeline vsSunShadowMovableAlphaPipeline_ = VK_NULL_HANDLE;
        VkPipeline vsSunShadowStaticAlphaPipeline_ = VK_NULL_HANDLE;
 
        void createSunShadowResources();
        void createSunShadowPipelines();
        void updateSunShadowCascades();
        void recordSunShadowPass();
        void recordSunShadowVisibilityPipeline(uint32_t cascadeIndex) const;
        void recordSunShadowPipelineDraws(VkCommandBuffer commandBuffer, PipelineNames pipelineName, VkPipeline shadowPipeline, uint32_t cascadeIndex);
        void recordSunShadowVertexShaderDraws(VkCommandBuffer commandBuffer, uint32_t cascadeIndex, bool staticCastersOnly, bool dynamicCastersOnly) const;
        [[nodiscard]] VkPipeline getSunShadowPipelineForCaster(PipelineNames pipelineName) const;
        [[nodiscard]] VkPipeline getVSSunShadowPipelineForCaster(PipelineNames pipelineName) const;
 
        // Debug line rendering pipeline
        VkPipeline debugLinePipeline_ = VK_NULL_HANDLE;
        VkPipeline debugLineOverlayPipeline_ = VK_NULL_HANDLE;
 
        void createDebugLinePipeline();
        void recordDebugLineDraws(VkCommandBuffer commandBuffer ) const;
 
        // Sky gradient pipeline
        VkPipeline skyGradientPipeline_ = VK_NULL_HANDLE;
        VkPipelineLayout skyGradientPipelineLayout_ = VK_NULL_HANDLE;
 
        void createSkyGradientPipeline();
        void recordSkyGradientDraw(VkCommandBuffer commandBuffer);
 
        // Final scene color grading / display conversion pass
        struct TonemapPushConstants
        {
            float exposure = 1.0f;
            uint32_t tonemapMode = 0u;
        };
 
        VkDescriptorSetLayout tonemapDescriptorSetLayout_ = VK_NULL_HANDLE;
        VkDescriptorSet tonemapDescriptorSet_ = VK_NULL_HANDLE;
        VkPipelineLayout tonemapPipelineLayout_ = VK_NULL_HANDLE;
        VkPipeline tonemapPipeline_ = VK_NULL_HANDLE;
 
        void createTonemapResources();
 
        // Wind trail particle system
        ParticleSystem* particleSystem_ = nullptr;
        std::weak_ptr<Entities::SceneNode> windTrailEmitterNode_;
        float lastRenderTime_ = 0.0f;

        bool freezeCulling_ = false;
 
        bool skipMeshShaderDraw_ = false;
        bool skipVertexShaderDraw_ = false;
        bool sunShadowCasterDebugView_ = false;
 
        VkDescriptorSetLayout graphicsDescriptorSetLayout              = VK_NULL_HANDLE;
 
#ifdef IS_IN_DEBUG
        PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = nullptr;
        PFN_vkCmdEndDebugUtilsLabelEXT   vkCmdEndDebugUtilsLabelEXT   = nullptr;
#endif

        struct MeshConstants
        {
            MeshConstants() = default;
 
            explicit MeshConstants( uint32_t baseVisibleMeshletIndex )
              : baseVisibleMeshletIndex( baseVisibleMeshletIndex )
            {
            }
 
            uint32_t baseVisibleMeshletIndex = 0u;
            uint32_t _padding1               = 0u;
            uint32_t _padding2               = 0u;
            uint32_t _padding3               = 0u;
        };
 
        std::vector<VkPushConstantRange> pushConstants;

        VkPipelineLayout computeObjectCullingPipelineLayout  = VK_NULL_HANDLE;
        VkPipelineLayout computeMeshletCullingPipelineLayout = VK_NULL_HANDLE;
        VkPipelineLayout prepareDrawsComputePipelineLayout   = VK_NULL_HANDLE;
        VkPipelineLayout graphicsPipelineLayout              = VK_NULL_HANDLE;

        std::vector<RenderProcess *> renderProcesses;

        //ComputePipeline * objectCullingComputePipeline  = nullptr;
        //ComputePipeline * meshletCullingComputePipeline = nullptr;
        //ComputePipeline * prepareDrawsComputePipeline   = nullptr;
 
        std::vector<GraphicsPipeline *> graphicsPipelines;
 
        uint32_t currentFrame = 0u;
 
        Core::ApplicationContext * context_ = nullptr;
        Headset *            headset_ = nullptr;
 
        uint64_t frameCounter = 0u;
 
        std::vector<VkSemaphore> renderFinishedSemaphores;
    };
}  // namespace EngineCore