Renderer.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Core/ComputePass.h"
#include "Engine/Material/MaterialTypes.h"
#include "Engine/Renderer/RenderData.h"
#include "Engine/Renderer/TimelineSynchronizer.h"
#include "VulkanStagedBuffer.h"
 
#include <array>
#include <BS_tracy_thread_pool.hpp>
#include <chrono>
#include <Engine/Core/Settings.h>
#include <Engine/Renderer/PipelineMaterialPayload.h>
#include <Engine/Renderer/VulkanBuffer.h>
#include <filesystem>
#include <memory>
#include <unordered_map>
#include <vector>
#include <vulkan/vulkan_core.h>
 
#ifdef ENABLE_TRACY
#    include <tracy/TracyVulkan.hpp>
#endif
 
namespace Vulkan {
    class BarrierBundle;
}
 
namespace EngineCore
{
    class RenderingDataManager;
    struct MaterialShader;
    class AssetManager;
}  // namespace EngineCore
 
namespace EngineCore
{
    class Headset;
    class ApplicationContext;
    class GraphicsPipeline;
    class Engine;
    class DataBuffer;
    class RenderProcess;
}  // namespace EngineCore
 
namespace EngineCore
{
    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 )
            {
            }
 
            uint32_t drawCommandOffset = 0u;
        };
 
 
    public:
        explicit Renderer(
            ApplicationContext *                  context      = nullptr,
            Headset *                             headset      = nullptr,
            const Engine *                        engine       = nullptr
        );

        ~Renderer();

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

        void updateViewMatrix();
 
        void recordRenderPass( size_t swapChainImageIndex );
 
        void createPrimitiveCullingResources();     // 1
        void createBinningAllocatorResources();  // 1.5 (Stage 1)
        void createMeshletUnpackingResources();  // 3 (Stage 2)
        void createMeshletCullingResources();    // 5
        void createPrepareDrawResources();       // 6
        void createHiZGenerationResources();     // Hi-Z generation compute pass
        void createVertexShaderPathResources(); // Vertex shader path for single-meshlet geometry

        void createMeshletUnpackingDispatcherResources();  // 2
        void createMeshletCullingDispatcherResources();  // 4

        void updateCpuRenderResources( float time );

        void restartRenderCommandBuffers() const;
 
        void recordXrSwapchainImageWritableBarrier( uint32_t swapChainImageIndex ) const;
 
        void recordXrSwapchainImageFinishedWritingBarrier( uint32_t swapChainImageIndex ) const;

        void recordHiZGeneration();

        void recordPass2Culling( size_t swapChainImageIndex );

        void recordPass2RenderPass( size_t swapChainImageIndex );

        const std::unique_ptr<RenderingDataManager> & getRenderingDataManager() const;
    private:
 
        std::unique_ptr<RenderingDataManager> renderingDataManager;
 
        std::optional<VulkanBuffer> objectCullingDataBuffer;
        std::optional<VulkanBuffer> objectMeshletDataBuffer;
        std::optional<VulkanBuffer> objectIDsBuffer;
        std::optional<VulkanBuffer> meshUnpackingDataBuffer;
 
        std::optional<VulkanBuffer> counterBuffer;
        std::optional<VulkanBuffer> dispatchBuffer;
 
        std::optional<VulkanBuffer> placeholderBuffer;
        std::optional<VulkanBuffer> placeholderUniformBuffer;
 
        void createDispatchBuffer();
        void createPlaceholderBuffer();
        void createPlaceholderUniformBuffer();
        void createCounterBuffer();
        void createObjectIDsBuffer();
        void createObjectCullingDataBuffer();
        void createObjectMeshletDataBuffer();
        void createMeshUnpackingDataBuffer();
 
    public:
        [[nodiscard]] const VulkanBuffer & getObjectCullingDataBuffer() const;
        [[nodiscard]] const VulkanBuffer & getObjectMeshletDataBuffer() const;
        [[nodiscard]] const VulkanBuffer & getObjectIDsBuffer() const;
        [[nodiscard]] const VulkanBuffer & getCounterBuffer() const;
        [[nodiscard]] const VulkanBuffer & getDispatchBuffer() const;
        [[nodiscard]] const VulkanBuffer & getMeshUnpackingDataBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getPlaceholderBuffer() const;
        [[nodiscard]] const VulkanBuffer & getPlaceholderUniformBuffer() const;

        bool ensureOutputBufferSizes(uint32_t primitiveCount);
 
        VkDependencyInfo getObjectCullingToMeshletUnpackingDispatchBarriers(Vulkan::BarrierBundle & bundle ) const;
        VkDependencyInfo getMeshletUnpackingDispatchToMeshletUnpackingBarriers(Vulkan::BarrierBundle &bundle) const;
        VkDependencyInfo getMeshletUnpackingToMeshletCullingDispatchBarriers( Vulkan::BarrierBundle & bundle );
        VkDependencyInfo getMeshletCullingDispatchToMeshletCullingBarriers();
        VkDependencyInfo getMeshletCullingToPrepareDrawBarriers();
 
        void resetMeshletUnpackingDispatchBuffers();
        void resetMeshletCullingDispatchBuffers();
 
        void renderToXr( size_t swapChainImageIndex, float time );
 
        void recordTransfer( float time );
        void submitInitialTransfers();
        void uploadFrameData( float time );
        void submitTransfer();
        void submitGraphics(
            uint32_t    swapChainImageIndex,
            VkSemaphore mirrorAcquireSemaphore = VK_NULL_HANDLE
        );
        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;

        [[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();

        [[nodiscard]] int64_t getFrameElapsedMs() const;

        [[nodiscard]] bool isInStallRecovery() const;

        VkSemaphore getTimelineSemaphore() const;

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

        [[nodiscard]] Headset* getHeadset() const { return headset; }

        void setFreezeCulling(bool freeze);

        [[nodiscard]] bool isFreezeCulling() const { return freezeCulling_; }
 
#ifdef ENABLE_TRACY
        void setupTracy( const std::vector<TracyVkCtx> & tracyVulkanContext );

        void resetTracyContexts();
#endif

        [[nodiscard]] const TimelineSynchronizer& getTimelineSynchronizer() const;

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

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

        static PipelineConfig getPipelineConfig( PipelineNames pipelineName );
 
    private:
#ifdef ENABLE_TRACY
        std::vector<TracyVkCtx> tracyVkContext;
 
        TracyVkCtx getCurrentTracyVkContext() const;
        void destroyTracyContexts();
#else
        void getCurrentTracyVkContext() const {}
#endif
 
        std::unique_ptr<TimelineSynchronizer> timelineSynchronizer_;
 
        void initializeFrameIndices();
        void initializeXrSwapchainFormats();
 
        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<VulkanStagedBufferSyncObjects> syncCopyObjects{};
 
        BS_tracy::tracy_thread_pool<BS_tracy::tp::none> updateThreadPool;
 
        // 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;
 
        const Engine * 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;

        std::optional<ComputePass>           objectCullingComputePass;
        std::optional<ComputePass>           binningAllocatorComputePass;  
        std::optional<DispatcherComputePass> meshletUnpackingDispatchComputePass;
        std::optional<ComputePass>           meshletUnpackingComputePass;
        std::optional<DispatcherComputePass> meshletCullingDispatchComputePass;
        std::optional<ComputePass>           meshletCullingComputePass;
        std::optional<ComputePass>           drawPreparationComputePass;
 
        std::optional<ComputePass> primitiveCulling;
        std::optional<ComputePass> primitiveBinning;
        std::optional<ComputePass> meshletUnpacking;
        std::optional<ComputePass> drawPreparation;
 
        // Hi-Z Occlusion Culling (legacy multi-pass - kept for fallback)
        std::optional<ComputePass> hiZGenerationComputePass;

        static constexpr uint32_t MAX_HIZ_MIP_LEVELS = 16;
        std::array<std::array<VkDescriptorSet, MAX_HIZ_MIP_LEVELS>, MAX_FRAMES_IN_FLIGHT> hiZMipDescriptorSets{};
        VkDescriptorPool hiZDescriptorPool = VK_NULL_HANDLE;
 
        // Hi-Z SPD (Single Pass Downsampler) - generates all mips in one dispatch
        std::optional<ComputePass> hiZSPDComputePass;
        std::optional<VulkanBuffer> hiZSPDAtomicBuffer;  // Global atomic counter for SPD workgroup sync
        std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> hiZSPDDescriptorSets{};
        bool useSPDHiZ_ = false;  // Use SPD by default, can fall back to multi-pass
 
        void createHiZSPDResources();
        void createHiZSPDDescriptorSets();
        void updateHiZSPDDescriptorSets(uint32_t frameIndex);
        void recordHiZGenerationSPD();
 
        // Vertex Shader Path for single-meshlet geometry
        // Uses traditional vertex shader + instancing (faster than mesh shader for small meshes)
        VkPipeline vsGraphicsPipeline_ = VK_NULL_HANDLE;  // Vertex shader pipeline for single-meshlet geometry
        VkPipelineLayout vsPipelineLayout_ = VK_NULL_HANDLE;  // Pipeline layout for VS path
        bool useVertexShaderPath_ = true;  // Enable VS path for single-meshlet geometry
 
        void createVertexShaderPipelineResources();
        void recordVertexShaderDraws(size_t swapChainImageIndex) const;
        void recordVertexShaderDrawsDepthOnly(size_t swapChainImageIndex) const;
 
        // VS Instanced Drawing Pipeline (reduces ~5k draw calls to ~1)
        // Stage 1: VSBinningAllocator - Count instances per geometry type
        // Stage 2: VSInstanceUnpacking - Write instance IDs to per-geometry bins
        // Stage 3: VSPrepareDraw - Generate one draw command per geometry type
        std::optional<ComputePass> vsBinningAllocatorComputePass_;
        std::optional<ComputePass> vsInstanceUnpackingComputePass_;
        std::optional<ComputePass> vsPrepareDrawComputePass_;
        bool useVSInstancedDrawing_ = true;  // Enable VS instanced drawing optimization
 
        void createVSInstancedDrawingResources();
        void recordVSInstancedDrawingPipeline();

        bool freezeCulling_ = false;
 
        void createHiZMipDescriptorSets();
        void updateHiZMipDescriptorSets(uint32_t frameIndex);
 
 
 
    public:
        ComputePass &           getObjectCullingComputePass();
        ComputePass &           getBinningAllocatorComputePass();
        DispatcherComputePass & getMeshletUnpackingDispatchComputePass();
        ComputePass &           getMeshletUnpackingComputePass();
        DispatcherComputePass & getMeshletCullingDispatchComputePass();
        ComputePass &           getMeshletCullingComputePass();
        ComputePass &           getDrawPreparationComputePass();
 
        // VS Instanced Drawing Pipeline compute pass getters
        ComputePass &           getVSBinningAllocatorComputePass();
        ComputePass &           getVSInstanceUnpackingComputePass();
        ComputePass &           getVSPrepareDrawComputePass();
 
    private:
        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;
 
        // Depth-only pipelines for Z-prepass (Pass 1)
        // These have colorAttachmentCount = 0, enabling "Double-Speed Z" on NVIDIA/AMD
        std::vector<GraphicsPipeline *> depthOnlyGraphicsPipelines;
        VkPipeline vsDepthOnlyPipeline_ = VK_NULL_HANDLE;  // Depth-only VS pipeline
 
        uint32_t currentFrame = 0u;
 
        ApplicationContext * context = nullptr;
        Headset *            headset = nullptr;
 
        uint64_t frameCounter = 0u;
 
        std::vector<VkSemaphore> renderFinishedSemaphores;
    };
}  // namespace EngineCore