RenderProcess.h

Go to the documentation of this file.

#pragma once
 
#include "RenderData.h"
#include "VulkanStagedBuffer.h"
 
#include <array>
#include <Engine/Texture/Texture.h>
#include <Engine/Component/CameraComponent.h>
#include <glm/mat4x4.hpp>
#include <memory>
#include <optional>
#include <vector>
 
namespace EngineCore
{
    class Headset;
    class ApplicationContext;
    struct GpuMeshDescription;
    struct PerObjectData;
    class GraphicsPipeline;
    class Renderer;
    class DataBuffer;
    class SceneManager;
    class RenderingDataManager;

    class RenderProcess final
    {
    public:
        void updateRendererDescriptorSets();
        void updateComputeObjectCullingDescriptorSets(VkImageView previousFrameHiZView = VK_NULL_HANDLE) const;
        void updateComputeBinningAllocatorDescriptorSets() const;
        void updateComputeMeshletCullingDescriptorSets() const;
        void updateComputePrepareDrawDescriptorSets() const;
        void updateComputeMeshletCullingDispatcherDescriptorSets() const;
        void updateComputeMeshletUnpackingDescriptorSets() const;
        void updateComputeMeshletUnpackingDispatcherDescriptorSets() const;
 
        // VS instanced drawing pipeline descriptor set updates
        void updateComputeVSBinningAllocatorDescriptorSets() const;
        void updateComputeVSInstanceUnpackingDescriptorSets() const;
        void updateComputeVSPrepareDrawDescriptorSets() const;

        void refreshAllDescriptorSets();

        bool ensureBufferSizes(uint32_t primitiveCount);

        void syncWithRenderingDataManager(RenderingDataManager* rdm);
 
        void updateMeshRenderingData();
 
        VulkanStagedBufferSyncObjects uploadMeshRenderingStagingData();
 
        void updateSSBO( const Renderer * renderer );
        void updateMeshletDataBuffer();
 
        VulkanStagedBufferSyncObjects uploadSSBOStagingBuffer();
 
        void updateFrustumUBOData( const Headset * headset );
 
        VulkanStagedBufferSyncObjects uploadFrustumUBO();

        void updateHiZViewProjectionData(const Headset* headset);

        VulkanStagedBufferSyncObjects uploadHiZViewProjectionUBO();
 
        RenderProcess(
            ApplicationContext *  context,
            VkDeviceSize          uniformBufferOffsetAlignment,
            VkCommandPool         graphicsCommandPool,
            VkCommandPool         transferCommandPool,
            VkDescriptorPool      descriptorPool,
            VkDescriptorSetLayout graphicsDescriptorSetLayout,
            uint32_t              eyeIndex,
            Renderer *            renderer,
            const Engine *        engine
        );
        void cleanup();

        struct ViewMatrixUniformData
        {
            std::array<glm::mat4, 2u> viewProjectionMatrices;  // 0 = left eye, 1 = right eye
        } staticVertexUniformData;

        void updateEyeViewProjectionMatrices( const Headset * headset );

        void updateFragmentTime( float time );
 
        [[nodiscard]] VkCommandBuffer & getTransferCommandBuffer();
        [[nodiscard]] VkCommandBuffer & getGraphicsCommandBuffer();
        [[nodiscard]] VkSemaphore       getTransferFinishedSemaphore() const;
        [[nodiscard]] VkSemaphore       getRenderFinishedSemaphore() const;
        [[nodiscard]] VkDescriptorSet   getGraphicsDescriptorSet() const;
        [[nodiscard]] VkSemaphore       getMirrorViewImageSemaphore() const;
 
        VulkanStagedBufferSyncObjects uploadUniformBufferData();
        uint32_t                      getEyeIndex() const;
 
        void uploadNewTextures( const std::vector<Texture *> & textures, uint32_t firstIndex ) const;
        // upload fragmented sections
        void addTexturesToUpload( const std::vector<Texture *> & textures, uint32_t firstIndex );
        void processTextureUpload();
 
        void addStagingBufferForCleanup( VulkanBuffer && stagingBuffer );
        void cleanupStagingBuffer();
 
    private:
        Renderer * renderer = nullptr;
        ApplicationContext * context = nullptr;
 
        uint32_t eyeIndex = 0u;  // 0 = left eye, 1 = right eye
 
        std::vector<VulkanBuffer> stagingBuffersForCleanup;

        struct StaticFragmentUniformData
        {
            float time;
        };
 
        StaticFragmentUniformData staticFragmentUniformData;
#ifdef IS_IN_DEBUG
        PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = nullptr;
        PFN_vkCmdEndDebugUtilsLabelEXT   vkCmdEndDebugUtilsLabelEXT   = nullptr;
#endif
 
        const std::unique_ptr<SceneManager> & sceneManager;
 
        struct TextureWriteContainer
        {
            std::vector<VkDescriptorImageInfo> imageInfos{};
            VkWriteDescriptorSet               write = {};
        };
 
        std::vector<TextureWriteContainer *> textureWritesToUpload;
 
        VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
 
 
        VkDescriptorSet graphicsDescriptorSet = VK_NULL_HANDLE;
 
        std::vector<PrimitiveMeshletData> objectMeshletData{};
 
 
        std::optional<VulkanStagedBuffer> viewProjectionBuffer;
        std::optional<VulkanStagedBuffer> meshletToObjectMapBuffer;
        std::optional<VulkanStagedBuffer> perObjectDataBuffer;
        std::optional<VulkanStagedBuffer> objectMeshletDataBuffer;
        std::optional<VulkanStagedBuffer> frustumDataBuffer;
        std::optional<VulkanStagedBuffer> meshRenderingInfoBuffer;
 
        std::optional<VulkanBuffer> binnedVisibleMeshletIndexBuffer;
        std::optional<VulkanBuffer> meshletCounterBuffer;
        std::optional<VulkanBuffer> visibleObjectRangesBuffer;
        std::optional<VulkanBuffer> pass1CounterBuffer;
        std::optional<VulkanBuffer> countDispatcherCounter;
        std::optional<VulkanBuffer> countDispatcherDispatchBuffer;
        std::optional<VulkanBuffer> indirectDrawBuffer;

        std::optional<VulkanBuffer> allocationsBuffer;       
        std::optional<VulkanBuffer> pipelineCountersBuffer;  
        std::optional<VulkanBuffer> pipelineBinOffsetsBuffer;
 
        std::optional<VulkanBuffer> dispatcherDispatchBuffer;

        std::optional<VulkanBuffer> cullingFailedBuffer;        
        std::optional<VulkanBuffer> cullingFailedCounterBuffer; 

        std::optional<VulkanBuffer> vsVisibleInstancesBuffer_;   
        std::optional<VulkanBuffer> vsVisibleCountBuffer_;       

        std::optional<VulkanBuffer> vsInstanceAllocationsBuffer_;  
        std::optional<VulkanBuffer> vsGeometryCountersBuffer_;     

        std::optional<VulkanBuffer> vsInstanceIdsBuffer_;          

        std::optional<VulkanBuffer> vsDrawCommandsBuffer_;         
        std::optional<VulkanBuffer> vsDrawCountBuffer_;            
 
        // Legacy VS path buffers (kept for backwards compatibility during transition)
        std::optional<VulkanBuffer> vsIndirectDrawBuffer_;       
        std::optional<VulkanBuffer> vsIndirectDrawCountBuffer_;  

        std::optional<VulkanBuffer> lodClusterSurvivorsBuffer_;      
        std::optional<VulkanBuffer> lodClusterSurvivorCountBuffer_;  
        std::optional<VulkanStagedBuffer> lodConfigBuffer_;          
        LodConfigUBO lodConfigData_{};                               
 
        std::unordered_map<GraphicsPipeline *, uint32_t> pipelineIndices;

        std::vector<PerObjectData> perObjectData;

        FrustumPlanes frustumData{};

        HiZViewProjectionData hiZViewProjectionData_{};
        std::optional<VulkanStagedBuffer> hiZViewProjectionBuffer_;
        bool hiZFirstFrame_ = true;
 
        std::vector<GpuMeshDescription> unifiedMeshes;
 
        void createDispatcherDispatchBuffer();
        void createCountDispatcherBuffers();
        void createObjectMeshletDataBuffer();
        void createVisibleObjectRangesBuffer();
        void createPass1CounterBuffer();
        void createViewProjectionBuffer();
        void createMeshletToObjectMapBuffer();
        void createBinnedVisibleMeshletIndexBuffer();
        void createMeshletCounterBuffer();
        void createPerObjectSSBOBuffer();
        void createMeshRenderingInfoBuffers();
        void createFrustumUBOBuffer();
        void createIndirectDrawBuffer();
        void createBinningAllocatorBuffers();
        void createCullingFailedBuffers();
        void createHiZViewProjectionBuffer();
        void createVSIndirectDrawBuffers();  // Legacy
        void createVSInstancedDrawingBuffers();  // New instanced drawing pipeline
        void createLodBuffers();  // LOD cluster-based selection buffers
 
        BS_tracy::tracy_thread_pool<BS_tracy::tp::none> bufferUpdateThreadPool;
 
    public:
        [[nodiscard]] VulkanStagedBuffer &       getViewProjectionBuffer();
        [[nodiscard]] const VulkanStagedBuffer & getViewProjectionBuffer() const;
 
        [[nodiscard]] VulkanStagedBuffer &       getMeshletToObjectMapBuffer();
        [[nodiscard]] const VulkanStagedBuffer & getMeshletToObjectMapBuffer() const;
 
        [[nodiscard]] VulkanBuffer &       getBinnedVisibleMeshletIndexBuffer();
        [[nodiscard]] const VulkanBuffer & getBinnedVisibleMeshletIndexBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getMeshletCounterBuffer() const;
 
        [[nodiscard]] const VulkanStagedBuffer & getPerObjectSSBOBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getPerObjectSSBO_StagingBuffer() const;
 
        [[nodiscard]] const VulkanStagedBuffer & getMeshRenderingBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getMeshRenderingStagingBuffer() const;
 
        [[nodiscard]] const VulkanStagedBuffer & getFrustumUBOBuffer() const;
 
        [[nodiscard]] const VulkanStagedBuffer & getHiZViewProjectionBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getIndirectDrawBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getVisibleObjectRangesBuffer() const;
 
        [[nodiscard]] const VulkanBuffer & getPass1CounterBuffer() const;
 
        [[nodiscard]] const VulkanStagedBuffer & getObjectMeshletDataBuffer() const;

        [[nodiscard]] const VulkanBuffer & getAllocationsBuffer() const;
        [[nodiscard]] const VulkanBuffer & getPipelineCountersBuffer() const;
        [[nodiscard]] const VulkanBuffer & getPipelineBinOffsetsBuffer() const;

        [[nodiscard]] const VulkanBuffer & getCullingFailedBuffer() const;
        [[nodiscard]] const VulkanBuffer & getCullingFailedCounterBuffer() const;

        [[nodiscard]] const VulkanBuffer & getVSVisibleInstancesBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSVisibleCountBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSInstanceAllocationsBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSGeometryCountersBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSInstanceIdsBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSDrawCommandsBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSDrawCountBuffer() const;

        [[nodiscard]] const VulkanBuffer & getVSIndirectDrawBuffer() const;
        [[nodiscard]] const VulkanBuffer & getVSIndirectDrawCountBuffer() const;

        [[nodiscard]] const VulkanBuffer & getLodClusterSurvivorsBuffer() const;
        [[nodiscard]] const VulkanBuffer & getLodClusterSurvivorCountBuffer() const;
        [[nodiscard]] const VulkanStagedBuffer & getLodConfigBuffer() const;

        void updateLodConfig(const glm::vec3& cameraPosition, const glm::mat4& projMatrix,
                            float nearPlane, float screenWidth, float screenHeight,
                            float errorThresholdPixels = 1.0f, bool ditherEnabled = true);

        VulkanStagedBufferSyncObjects uploadLodConfigBuffer();
 
        [[nodiscard]] VkFence & getTransferCompleteFence();
        [[nodiscard]] VkFence & getGraphicsCompleteFence();
 
        void setTransferFenceSubmitted( bool isSubmitted );
        void setGraphicsFenceSubmitted( bool isSubmitted );
 
        bool getTransferFenceSubmitted() const;
        bool getGraphicsFenceSubmitted() const;
 
    private:
        VkCommandBuffer transferCommandBuffer = VK_NULL_HANDLE;
        VkCommandBuffer graphicsCommandBuffer = VK_NULL_HANDLE;
 
        VkFence transferCompleteFence = VK_NULL_HANDLE;
        VkFence graphicsCompleteFence = VK_NULL_HANDLE;
 
        // Initialized to true because fences are created in SIGNALED state,
        // so the first frame needs to wait and reset them properly
        bool transferFenceSubmitted = true;
        bool graphicsFenceSubmitted = true;

        uint64_t lastSeenDataVersion_ = 0;
 
        VkSemaphore renderFinishedSemaphore       = VK_NULL_HANDLE;
        VkSemaphore transferFinishedSemaphore     = VK_NULL_HANDLE;
        VkSemaphore mirrorViewImageReadySemaphore = VK_NULL_HANDLE;
 
        // ============================================================================
        // Hi-Z Occlusion Culling resources (per-frame to avoid cross-frame hazards)
        // ============================================================================
        struct HiZPyramid {
            VkImage image = VK_NULL_HANDLE;
            VkDeviceMemory deviceMemory = VK_NULL_HANDLE;
            VkImageView fullView = VK_NULL_HANDLE;           
            std::vector<VkImageView> mipViews;               
            uint32_t mipLevels = 0;
            VkExtent2D extent{};
 
            void cleanup(VkDevice device);
        };
        HiZPyramid hiZPyramid_;
 
        void createHiZPyramid(VkDevice device, VkExtent2D resolution, uint32_t arrayLayers);
 
    public:
        // Hi-Z accessors
        [[nodiscard]] VkImage getHiZPyramidImage() const { return hiZPyramid_.image; }
        [[nodiscard]] VkImageView getHiZPyramidFullView() const { return hiZPyramid_.fullView; }
        [[nodiscard]] VkImageView getHiZPyramidMipView(uint32_t mipLevel) const { return hiZPyramid_.mipViews.at(mipLevel); }
        [[nodiscard]] uint32_t getHiZMipLevels() const { return hiZPyramid_.mipLevels; }
        [[nodiscard]] VkExtent2D getHiZExtent() const { return hiZPyramid_.extent; }
    };
 
}  // namespace EngineCore