RenderProcess.cpp

Go to the documentation of this file.

#include "Engine/Entity/Actor.h"
#include "Engine/Logging/TracyMacros.hpp"
 
#include <Engine/Core/VulkanHelper.h>
#include <Engine/Renderer/RenderProcess.h>
#include <Engine/Renderer/RenderData.h>
#include <Engine/Renderer/RenderingDataManager.h>
#include <Engine/Renderer/Headset.h>
#include <Engine/Renderer/Renderer.h>
#include <plog/Log.h>
#include <Engine/Core/Engine.h>
 
#include <Engine/Core/Settings.h>
#include <cmath>
#include <cstring>
 
#include "Engine/Renderer/DescriptorSetUpdater.h"
#include "Engine/World/SceneManager.h"
 
namespace EngineCore {
#if defined(HEADLESS)
    #define GRAPHICS_GUARD() return;
    #define COMPUTE_GUARD() return;
#elif defined(COMPUTE_DEBUG)
    #define GRAPHICS_GUARD() return;  // Skip graphics in debug mode
    #define COMPUTE_GUARD()           // No-op: compute runs in debug mode
#else
    #define GRAPHICS_GUARD()
    #define COMPUTE_GUARD()
#endif
 
    void RenderProcess::updateRendererDescriptorSets() {
        GRAPHICS_GUARD()
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        std::vector<VkDescriptorImageInfo> imageInfos = renderingDataManager->generateTextureDescriptorInfos();
        PLOGI << "Update renderer descriptor sets";
        DescriptorSetUpdater(graphicsDescriptorSet)
        .addStorageBuffer(ShaderStage::Graphics::VERTEX_BUFFER, VulkanHelper::fullBufferInfo( renderingDataManager->getVertexBuffer().getBuffer() ) )
        .addUniformBuffer(ShaderStage::Graphics::VIEW_PROJECTION_UBO, VulkanHelper::fullBufferInfo( getViewProjectionBuffer().getBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MESHLET_BUFFER, VulkanHelper::fullBufferInfo( renderingDataManager->getMeshletBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MESHLET_TRIANGLES_BUFFER, VulkanHelper::fullBufferInfo( renderingDataManager->getTriangleBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::BINNED_VISIBLE_MESHLET_INDEX_BUFFER, VulkanHelper::fullBufferInfo( getBinnedVisibleMeshletIndexBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::PER_OBJECT_SSBO, VulkanHelper::fullBufferInfo( renderingDataManager->getPerObjectDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MESH_BUFFER, VulkanHelper::fullBufferInfo( getMeshRenderingBuffer().getBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MESH_PRIMITIVE_BUFFER, VulkanHelper::fullBufferInfo( renderingDataManager->getPrimitiveRenderDataBuffer().getBuffer() ) )
        // NOTE: MESHLET_TO_OBJECT_MAP_BUFFER (binding 8) is not used in shaders - provide placeholder
        .addStorageBuffer(ShaderStage::Graphics::MESHLET_TO_OBJECT_MAP_BUFFER, VulkanHelper::fullBufferInfo( getMeshletToObjectMapBuffer().getBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_DIFFUSE_FLAT_COLOR, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::DIFFUSE_FLAT_COLOR ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_NORMALS, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::NORMALS_SHADER ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_DIFFUSE_SHADER, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::DIFFUSE_SHADER ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_MOVABLE_DIFFUSE, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::MOVABLE_DIFFUSE_SHADER ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_L0, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::L0_SHADER ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_L1, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::L1_SHADER ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_L2, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::L2_SHADER ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_DYNAMIC_TEXTURES, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::DYNAMIC_TEXTURES ).getBuffer() ) )
        .addStorageBuffer(ShaderStage::Graphics::MATERIAL_STATIC_LIGHTMAP, VulkanHelper::fullBufferInfo( renderingDataManager->getMaterialBufferForPipeline( PipelineNames::STATIC_LIGHTMAP ).getBuffer() ) )
        .addTextureArrayIf(!imageInfos.empty(), ShaderStage::Graphics::TEXTURE_ARRAY, &imageInfos)
        // VS instanced drawing: instance ID buffer for vertex shader lookup
        .addStorageBuffer(ShaderStage::Graphics::VS_INSTANCE_IDS, VulkanHelper::fullBufferInfo( getVSInstanceIdsBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeObjectCullingDescriptorSets(VkImageView previousFrameHiZView) const {
        COMPUTE_GUARD()
        PLOGI << "Update object culling descriptor sets";
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        const Headset* headset = renderer->getHeadset();
 
        // Use provided Hi-Z view (from previous frame) or fallback to own (for initial setup)
        VkImageView hiZView = (previousFrameHiZView != VK_NULL_HANDLE)
            ? previousFrameHiZView
            : getHiZPyramidFullView();
 
        // Hi-Z image info for occlusion culling (previous frame's Hi-Z for Pass 1)
        VkDescriptorImageInfo hiZImageInfo{
            .sampler = headset->getHiZSampler(),
            .imageView = hiZView,
            .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
        };
 
        // Current frame's Hi-Z for Pass 2 occlusion culling
        // This is this RenderProcess's own Hi-Z pyramid (generated after Pass 1 rendering)
        VkDescriptorImageInfo currentHiZImageInfo{
            .sampler = headset->getHiZSampler(),
            .imageView = getHiZPyramidFullView(),
            .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
        };
 
        renderer->getObjectCullingComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getPrimitiveCullingBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_MESHLET_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getPrimitiveMeshletBuffer().getBuffer() ) )
        .addUniformBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_FRUSTUM_PLANES, VulkanHelper::fullBufferInfo( getFrustumUBOBuffer().getBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_IDS, VulkanHelper::fullBufferInfo( renderer->getObjectIDsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_COUNTER, VulkanHelper::fullBufferInfo( renderer->getCounterBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_MESH_UNPACKING_DATA, VulkanHelper::fullBufferInfo( renderer->getMeshUnpackingDataBuffer().getBuffer() ) )
        // Hi-Z Occlusion Culling bindings (two pyramids for two-pass culling)
        .addCombinedImageSampler(ShaderStage::HiZCulling::HIZ_PYRAMID, &hiZImageInfo)               // Previous frame's Hi-Z (Pass 1)
        .addUniformBuffer(ShaderStage::HiZCulling::HIZ_VIEW_PROJECTION, VulkanHelper::fullBufferInfo( getHiZViewProjectionBuffer().getBuffer().getBuffer() ) )
        .addCombinedImageSampler(ShaderStage::HiZCulling::HIZ_PYRAMID_CURRENT, &currentHiZImageInfo) // Current frame's Hi-Z (Pass 2)
        // GPU Transform Optimization: bind local bounds and per-object transforms for GPU-side world space computation
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_LOCAL_BOUNDS, VulkanHelper::fullBufferInfo( renderingDataManager->getLocalBoundsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_PER_OBJECT_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getPerObjectDataBuffer().getBuffer() ) )
        // Two-pass occlusion culling: failed objects buffer for Pass 2 re-testing
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_FAILED, VulkanHelper::fullBufferInfo( getCullingFailedBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_FAILED_COUNTER, VulkanHelper::fullBufferInfo( getCullingFailedCounterBuffer().getBuffer() ) )
        // Vertex shader path for single-meshlet geometry optimization (now outputs primitive IDs)
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_VS_INDIRECT_DRAW, VulkanHelper::fullBufferInfo( getVSVisibleInstancesBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_VS_INDIRECT_COUNT, VulkanHelper::fullBufferInfo( getVSVisibleCountBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_SINGLE_MESHLET_GEO, VulkanHelper::fullBufferInfo( renderingDataManager->getSingleMeshletGeometryBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_INSTANCE_CULLING_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getInstanceCullingDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::PRIMITIVE_MESH_GEOMETRY_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getMeshGeometryDataBuffer().getBuffer() ) )
        // LOD cluster-based selection buffers
        .addStorageBuffer(ShaderStage::PrimitiveCulling::CLUSTER_LOD_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getClusterLodDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::CLUSTER_GROUP_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getClusterGroupDataBuffer().getBuffer() ) )
        .addUniformBuffer(ShaderStage::PrimitiveCulling::LOD_CONFIG, VulkanHelper::fullBufferInfo( getLodConfigBuffer().getBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::LOD_CLUSTER_SURVIVORS, VulkanHelper::fullBufferInfo( getLodClusterSurvivorsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveCulling::LOD_CLUSTER_SURVIVOR_COUNT, VulkanHelper::fullBufferInfo( getLodClusterSurvivorCountBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeBinningAllocatorDescriptorSets() const {
        COMPUTE_GUARD()
        PLOGI << "Update binning allocator descriptor sets";
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        renderer->getBinningAllocatorComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_CULLING_SURVIVORS, VulkanHelper::fullBufferInfo( renderer->getMeshUnpackingDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_PRIMITIVE_MESHLET_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getPrimitiveMeshletBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_ALLOCATIONS, VulkanHelper::fullBufferInfo( getAllocationsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_PIPELINE_COUNTERS, VulkanHelper::fullBufferInfo( getPipelineCountersBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_SURVIVOR_COUNT, VulkanHelper::fullBufferInfo( renderer->getCounterBuffer().getBuffer() ) )
        // LOD cluster survivor inputs for Stage 1 binning
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_LOD_CLUSTER_SURVIVORS, VulkanHelper::fullBufferInfo( getLodClusterSurvivorsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_LOD_CLUSTER_SURVIVOR_COUNT, VulkanHelper::fullBufferInfo( getLodClusterSurvivorCountBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_CLUSTER_LOD_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getClusterLodDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrimitiveBinning::BINNING_PRIMITIVE_MESHLET_DATA_LOD, VulkanHelper::fullBufferInfo( renderingDataManager->getPrimitiveMeshletBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeMeshletUnpackingDispatcherDescriptorSets() const {
        COMPUTE_GUARD()
        PLOGI << "Update meshlet unpacking dispatcher descriptor sets";
        renderer->getMeshletUnpackingDispatchComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::MeshletUnpackingDispatch::MESHLET_UNPACKING_DISPATCH_COUNTER, VulkanHelper::fullBufferInfo( renderer->getCounterBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::MeshletUnpackingDispatch::MESHLET_UNPACKING_DISPATCH_BUFFER, VulkanHelper::fullBufferInfo( renderer->getDispatchBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::MeshletUnpackingDispatch::MESHLET_UNPACKING_DISPATCH_LOD_COUNTER, VulkanHelper::fullBufferInfo( getLodClusterSurvivorCountBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeMeshletUnpackingDescriptorSets() const {
        COMPUTE_GUARD()
        PLOGI << "Update meshlet unpacking descriptor sets (V2 bindings)";
        renderer->getMeshletUnpackingComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_ALLOCATIONS, VulkanHelper::fullBufferInfo( getAllocationsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_BIN_OFFSETS, VulkanHelper::fullBufferInfo( getPipelineBinOffsetsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_OUTPUT, VulkanHelper::fullBufferInfo( getBinnedVisibleMeshletIndexBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_SURVIVOR_COUNT, VulkanHelper::fullBufferInfo( renderer->getCounterBuffer().getBuffer() ) )
        // LOD cluster survivor count for combined allocation processing
        .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_LOD_CLUSTER_SURVIVOR_COUNT, VulkanHelper::fullBufferInfo( getLodClusterSurvivorCountBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeMeshletCullingDispatcherDescriptorSets() const {
        COMPUTE_GUARD()
        renderer->getMeshletCullingDispatchComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::MeshletCullingDispatch::MESHLET_CULLING_DISPATCH_COUNTER, VulkanHelper::fullBufferInfo( getMeshletCounterBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::MeshletCullingDispatch::MESHLET_CULLING_DISPATCH_BUFFER, VulkanHelper::fullBufferInfo( renderer->getDispatchBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeMeshletCullingDescriptorSets() const {
        COMPUTE_GUARD()
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        renderer->getMeshletCullingComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_INDICES, VulkanHelper::fullBufferInfo( getBinnedVisibleMeshletIndexBuffer().getBuffer() ) )
        .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_BOUNDS, VulkanHelper::fullBufferInfo( renderingDataManager->getMeshletBoundsBuffer().getBuffer() ) )
        .addUniformBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_FRUSTUM_PLANES, VulkanHelper::fullBufferInfo( getFrustumUBOBuffer().getBuffer().getBuffer() ) )
        .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_COUNTS, VulkanHelper::fullBufferInfo( getMeshletCounterBuffer().getBuffer() ) )
        .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_BINNED_RENDERING, VulkanHelper::fullBufferInfo( getBinnedVisibleMeshletIndexBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputePrepareDrawDescriptorSets() const {
        COMPUTE_GUARD()
        renderer->getDrawPreparationComputePass().updateDescriptorSet(getEyeIndex())
        // Use pipelineCountersBuffer (written by BinningAllocator) instead of meshletCounterBuffer
        // BinningAllocator computes per-pipeline meshlet counts, which PrepareDraw reads to generate indirect draw commands
        .addStorageBuffer(ShaderStage::PrepareDraw::PREPARE_DRAW_MESHLET_COUNTER, VulkanHelper::fullBufferInfo( getPipelineCountersBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::PrepareDraw::PREPARE_DRAW_INDIRECT_DRAW, VulkanHelper::fullBufferInfo( getIndirectDrawBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeVSBinningAllocatorDescriptorSets() const {
        COMPUTE_GUARD()
        PLOGI << "Update VS binning allocator descriptor sets";
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        renderer->getVSBinningAllocatorComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::VSBinning::VS_BINNING_VISIBLE_INSTANCES, VulkanHelper::fullBufferInfo( getVSVisibleInstancesBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSBinning::VS_BINNING_VISIBLE_COUNT, VulkanHelper::fullBufferInfo( getVSVisibleCountBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSBinning::VS_BINNING_MESH_GEOMETRY_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getMeshGeometryDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSBinning::VS_BINNING_INSTANCE_CULLING_DATA, VulkanHelper::fullBufferInfo( renderingDataManager->getInstanceCullingDataBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSBinning::VS_BINNING_ALLOCATIONS, VulkanHelper::fullBufferInfo( getVSInstanceAllocationsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSBinning::VS_BINNING_GEOMETRY_COUNTERS, VulkanHelper::fullBufferInfo( getVSGeometryCountersBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeVSInstanceUnpackingDescriptorSets() const {
        COMPUTE_GUARD()
        PLOGI << "Update VS instance unpacking descriptor sets";
        renderer->getVSInstanceUnpackingComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::VSInstanceUnpacking::VS_UNPACKING_ALLOCATIONS, VulkanHelper::fullBufferInfo( getVSInstanceAllocationsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSInstanceUnpacking::VS_UNPACKING_VISIBLE_COUNT, VulkanHelper::fullBufferInfo( getVSVisibleCountBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSInstanceUnpacking::VS_UNPACKING_INSTANCE_IDS, VulkanHelper::fullBufferInfo( getVSInstanceIdsBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::updateComputeVSPrepareDrawDescriptorSets() const {
        COMPUTE_GUARD()
        PLOGI << "Update VS prepare draw descriptor sets for eye " << eyeIndex;
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        // Log buffer handles for debugging buffer mismatch
        PLOGI << "[VS_BUFFER_DEBUG] Eye " << eyeIndex << " VSPrepareDraw descriptor binding:"
              << " vsDrawCountBuffer=" << (void*)getVSDrawCountBuffer().getBuffer()
              << " vsDrawCommandsBuffer=" << (void*)getVSDrawCommandsBuffer().getBuffer();
        renderer->getVSPrepareDrawComputePass().updateDescriptorSet(getEyeIndex())
        .addStorageBuffer(ShaderStage::VSPrepareDraw::VS_PREPARE_SINGLE_MESHLET_GEO, VulkanHelper::fullBufferInfo( renderingDataManager->getSingleMeshletGeometryBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSPrepareDraw::VS_PREPARE_GEOMETRY_COUNTERS, VulkanHelper::fullBufferInfo( getVSGeometryCountersBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSPrepareDraw::VS_PREPARE_INDIRECT_DRAWS, VulkanHelper::fullBufferInfo( getVSDrawCommandsBuffer().getBuffer() ) )
        .addStorageBuffer(ShaderStage::VSPrepareDraw::VS_PREPARE_DRAW_COUNT, VulkanHelper::fullBufferInfo( getVSDrawCountBuffer().getBuffer() ) )
        .update(context->getVkDevice());
    }
 
    void RenderProcess::refreshAllDescriptorSets() {
        PLOGI << "Refreshing all descriptor sets for eye " << eyeIndex;
        updateRendererDescriptorSets();
        updateComputeObjectCullingDescriptorSets();
        updateComputeBinningAllocatorDescriptorSets();
        updateComputeMeshletUnpackingDispatcherDescriptorSets();
        updateComputeMeshletUnpackingDescriptorSets();
        updateComputeMeshletCullingDispatcherDescriptorSets();
        updateComputeMeshletCullingDescriptorSets();
        updateComputePrepareDrawDescriptorSets();
        // VS instanced drawing pipeline (optional - may not exist if disabled)
        try {
            updateComputeVSBinningAllocatorDescriptorSets();
            updateComputeVSInstanceUnpackingDescriptorSets();
            updateComputeVSPrepareDrawDescriptorSets();
        } catch (const std::runtime_error& e) {
            // VS instanced drawing is disabled, skip updates
        }
    }
 
    void RenderProcess::syncWithRenderingDataManager(RenderingDataManager* rdm) {
        if (rdm == nullptr) return;
 
        uint64_t currentVersion = rdm->getDataVersion();
        if (lastSeenDataVersion_ < currentVersion) {
            PLOGI << "RenderProcess " << eyeIndex << " syncing: version "
                  << lastSeenDataVersion_ << " -> " << currentVersion;
            refreshAllDescriptorSets();
            lastSeenDataVersion_ = currentVersion;
        }
    }
 
    void RenderProcess::updateMeshRenderingData() {
        // DEPRECATED: Mesh rendering data is now managed by RenderingDataManager.
        // UnifiedMeshlet data is populated via RenderingDataManager::updatePrimitiveData()
        // and stored in getMeshletBuffer(). This function is kept as a no-op for API compatibility.
    }
 
    VulkanStagedBufferSyncObjects RenderProcess::uploadMeshRenderingStagingData() {
        // DEPRECATED: Mesh rendering data is now managed by RenderingDataManager.
        // Data is uploaded via RenderingDataManager::updatePrimitiveData().
        // Return empty sync objects as no upload is performed here.
        return VulkanStagedBufferSyncObjects{};
    }
 
    void RenderProcess::updateSSBO(const Renderer* renderer) {
        // DEPRECATED: Per-object data is now managed by RenderingDataManager.
        // The slimmed-down PerObjectData (mat4 only) is populated via
        // RenderingDataManager::updatePrimitiveData() and bound directly to the mesh shader.
        // This function is kept as a no-op for API compatibility during transition.
        (void)renderer; // Suppress unused parameter warning
    }
 
    void RenderProcess::updateMeshletDataBuffer()
    {
        // DEPRECATED: Meshlet data is now managed by RenderingDataManager.
        // PrimitiveMeshletData (meshletStartIndex, meshletCount, pipelineID) is populated via
        // RenderingDataManager::updatePrimitiveData() and stored in getPrimitiveMeshletBuffer().
        // This function is kept as a no-op for API compatibility during transition.
    }
 
    VulkanStagedBufferSyncObjects RenderProcess::uploadSSBOStagingBuffer() {
        // DEPRECATED: Per-object data is now managed by RenderingDataManager.
        // Data is uploaded via RenderingDataManager::updatePrimitiveData().
        // Return empty sync objects as no upload is performed here.
        return VulkanStagedBufferSyncObjects{};
    }
 
    void RenderProcess::updateFrustumUBOData(const Headset* headset) {
        TRACY_ZONE_SCOPED_FUNCTION;
        for (uint32_t eyeIndex = 0; eyeIndex < headset->getEyeCount(); ++eyeIndex) {
            // Use the already-computed view-projection matrices from staticVertexUniformData
            // This ensures the frustum matches what's being rendered (respects active camera)
            // Note: updateEyeViewProjectionMatrices() must be called before this
            const glm::mat4 eyeViewProjection = staticVertexUniformData.viewProjectionMatrices.at(eyeIndex);
            const glm::mat4 mat = glm::transpose(eyeViewProjection); // Transpose for easier plane extraction
 
            frustumData.planes[eyeIndex][0] = mat[3] + mat[0]; // Left plane
            frustumData.planes[eyeIndex][1] = mat[3] - mat[0]; // Right plane
            frustumData.planes[eyeIndex][2] = mat[3] + mat[1]; // Bottom plane
            frustumData.planes[eyeIndex][3] = mat[3] - mat[1]; // Top plane
            frustumData.planes[eyeIndex][4] = mat[3] + mat[2]; // Near plane
            frustumData.planes[eyeIndex][5] = mat[3] - mat[2]; // Far plane
 
            for (int i = 0; i < 6; ++i) {
                const float length = glm::length(glm::vec3(frustumData.planes[eyeIndex][i]));
                frustumData.planes[eyeIndex][i] /= length;
            }
        }
 
        // For desktop mode (1 eye), duplicate eye 0's frustum to eye 1
        // The culling shader always tests both eyes, so we need valid data in both slots
        if (headset->getEyeCount() == 1) {
            for (int i = 0; i < 6; ++i) {
                frustumData.planes[1][i] = frustumData.planes[0][i];
            }
        }
    }
 
    VulkanStagedBufferSyncObjects RenderProcess::uploadFrustumUBO() {
        TRACY_ZONE_SCOPED_NAMED("Upload Frustum UBO");
 
        constexpr VkDeviceSize size = sizeof(FrustumPlanes);
        return frustumDataBuffer->upload(context, &frustumData, size);
    }
 
    RenderProcess::RenderProcess(
                                 ApplicationContext *context,
                                 VkDeviceSize uniformBufferOffsetAlignment,
                                 VkCommandPool graphicsCommandPool,
                                 VkCommandPool transferCommandPool,
                                 VkDescriptorPool descriptorPool,
                                 VkDescriptorSetLayout graphicsDescriptorSetLayout,
                                 uint32_t eyeIndex,
                                 Renderer *renderer,
                                 const Engine* engine
    ) : renderer(renderer),
        sceneManager(engine->getSceneManager()),
        eyeIndex(eyeIndex),
        context(context),
        bufferUpdateThreadPool(20, [](std::size_t) {}, "BufferUpdate")
    {
        // --- Initialize view-projection data (for binding 3: ViewProjection) ---
        // (Our shader expects 2 matrices; initialize both to identity.)
        staticVertexUniformData.viewProjectionMatrices[0] = glm::mat4(1.0f);
        staticVertexUniformData.viewProjectionMatrices[1] = glm::mat4(1.0f);
 
        // --- graphics Allocate command buffer, semaphores, and fence ---
        {
            VkCommandBufferAllocateInfo commandBufferAllocateInfo{
                .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
                .commandPool = graphicsCommandPool,
                .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
                .commandBufferCount = 1u
            };
            VulkanHelper::allocateCommandBuffers(context->getVkDevice(), &commandBufferAllocateInfo, &graphicsCommandBuffer, "Graphics");
        }
 
        // --- transfer Allocate command buffer,
        {
            VkCommandBufferAllocateInfo transferBufferAllocInfo{
                .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
                .commandPool = transferCommandPool,
                .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
                .commandBufferCount = 1u
            };
            VulkanHelper::allocateCommandBuffers(context->getVkDevice(), &transferBufferAllocInfo, &transferCommandBuffer, "Transfer");
        }

        {
            VkSemaphoreCreateInfo semaphoreCreateInfo{
                .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
            };
            VulkanHelper::createSemaphore(context->getVkDevice(), &semaphoreCreateInfo, nullptr, &renderFinishedSemaphore, "RenderFinished");
            VulkanHelper::createSemaphore(context->getVkDevice(), &semaphoreCreateInfo, nullptr, &transferFinishedSemaphore, "Transfer Finished");
            VulkanHelper::createSemaphore( context->getVkDevice(), &semaphoreCreateInfo, nullptr, &mirrorViewImageReadySemaphore, "Mirror View Image Ready" );
 
            VkFenceCreateInfo fenceCreateInfo{
                .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
                .flags = VK_FENCE_CREATE_SIGNALED_BIT
            };
            VulkanHelper::createFence(context->getVkDevice(), &fenceCreateInfo, nullptr, &transferCompleteFence, "Transfer Complete");
            VulkanHelper::createFence(context->getVkDevice(), &fenceCreateInfo, nullptr, &graphicsCompleteFence, "Graphics Complete");
 
            PLOGI << "Created fences for RenderProcess (eyeIndex=" << eyeIndex << ")";
        }

        {
            // resources for dispatch pipelines
            createCountDispatcherBuffers();
 
            createDispatcherDispatchBuffer();
            createBinnedVisibleMeshletIndexBuffer();
            createMeshletCounterBuffer();
            createMeshletToObjectMapBuffer();
            createViewProjectionBuffer();
            createPerObjectSSBOBuffer();
            createObjectMeshletDataBuffer();
            createMeshRenderingInfoBuffers();
            createFrustumUBOBuffer();
            createIndirectDrawBuffer();
            createVisibleObjectRangesBuffer();
        createPass1CounterBuffer();
            createBinningAllocatorBuffers();
            createCullingFailedBuffers();
            createHiZViewProjectionBuffer();
            createVSIndirectDrawBuffers();
            createVSInstancedDrawingBuffers();
            createLodBuffers();
 
            // Create Hi-Z pyramid for this frame (per-frame to avoid cross-frame hazards)
            const Headset* headset = renderer->getHeadset();
            createHiZPyramid(context->getVkDevice(), headset->getEyeResolution(0), 2u);  // 2 layers for stereo
        }
 
        // --- Allocate descriptor set for set 0 using variable descriptor count for the texture array ---
        const auto& renderingDataManager = renderer->getRenderingDataManager();
        // Always allocate MAX_TEXTURE_COUNT slots to handle dynamic texture loading.
        // Textures may be loaded after descriptor set creation, and variable descriptor count
        // allocation cannot be resized after creation.
        const uint32_t variableDescriptorCount = MAX_TEXTURE_COUNT;
        assert(variableDescriptorCount <= MAX_TEXTURE_COUNT);
        VkDescriptorSetVariableDescriptorCountAllocateInfo variableDescriptorCountAllocInfo{
            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
            .descriptorSetCount = 1u,
            .pDescriptorCounts = &variableDescriptorCount
        };
 
        // --- Allocate graphics descriptor set ---
        VkDescriptorSetAllocateInfo descriptorSetAllocateInfo{
            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
            .pNext = &variableDescriptorCountAllocInfo,
            .descriptorPool = descriptorPool,
            .descriptorSetCount = 1u,
            .pSetLayouts = &graphicsDescriptorSetLayout,
        };
        VulkanHelper::allocateDescriptorSets(context->getVkDevice(), &descriptorSetAllocateInfo, &graphicsDescriptorSet, "Graphics descriptor set");
 
        renderer->getObjectCullingComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
        renderer->getBinningAllocatorComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
        renderer->getMeshletUnpackingDispatchComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
        renderer->getMeshletUnpackingComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
        renderer->getMeshletCullingDispatchComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
        renderer->getMeshletCullingComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
        renderer->getDrawPreparationComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
 
        // VS Instanced Drawing Pipeline (optional - may not exist if disabled)
        try {
            renderer->getVSBinningAllocatorComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
            renderer->getVSInstanceUnpackingComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
            renderer->getVSPrepareDrawComputePass().createDescriptorSet(context->getVkDevice(), getEyeIndex(), descriptorPool);
            PLOGI << "[VS_INSTANCED] Created descriptor sets for VS instanced drawing passes (eye " << eyeIndex << ")";
        } catch (const std::runtime_error& e) {
            PLOGI << "[VS_INSTANCED] VS instanced drawing disabled, skipping descriptor sets";
        }
 
        updateRendererDescriptorSets();
 
        updateComputeObjectCullingDescriptorSets();                 // 1
        updateComputeBinningAllocatorDescriptorSets();              // 1.5 (Stage 1: Binning Allocator)
        updateComputeMeshletUnpackingDispatcherDescriptorSets();    // 2
        updateComputeMeshletUnpackingDescriptorSets();              // 3 (Stage 2: Meshlet Unpacking V2)
        updateComputeMeshletCullingDispatcherDescriptorSets();      // 4
        updateComputeMeshletCullingDescriptorSets();                // 5
        updateComputePrepareDrawDescriptorSets();                   // 6
        // VS Instanced Drawing Pipeline descriptor updates (handled in refreshAllDescriptorSets)
    }
 
    void RenderProcess::cleanup() {
        if (countDispatcherDispatchBuffer) countDispatcherDispatchBuffer->destroy();
        if (visibleObjectRangesBuffer) visibleObjectRangesBuffer->destroy();
        if (dispatcherDispatchBuffer) dispatcherDispatchBuffer->destroy();
        if (pass1CounterBuffer) pass1CounterBuffer->destroy();
        if (countDispatcherCounter) countDispatcherCounter->destroy();
        if (objectMeshletDataBuffer) objectMeshletDataBuffer->destroy();
        if (viewProjectionBuffer) viewProjectionBuffer->destroy();
        if (meshletToObjectMapBuffer) meshletToObjectMapBuffer->destroy();
        if (binnedVisibleMeshletIndexBuffer) binnedVisibleMeshletIndexBuffer->destroy();
        if (meshletCounterBuffer) meshletCounterBuffer->destroy();
        if (perObjectDataBuffer) perObjectDataBuffer->destroy();
        if (indirectDrawBuffer) indirectDrawBuffer->destroy();
        if (frustumDataBuffer) frustumDataBuffer->destroy();
        if (meshRenderingInfoBuffer) meshRenderingInfoBuffer->destroy();
        if (allocationsBuffer) allocationsBuffer->destroy();
        if (pipelineCountersBuffer) pipelineCountersBuffer->destroy();
        if (pipelineBinOffsetsBuffer) pipelineBinOffsetsBuffer->destroy();
        if (cullingFailedBuffer) cullingFailedBuffer->destroy();
        if (cullingFailedCounterBuffer) cullingFailedCounterBuffer->destroy();
        if (hiZViewProjectionBuffer_) hiZViewProjectionBuffer_->destroy();
        if (vsIndirectDrawBuffer_) vsIndirectDrawBuffer_->destroy();
        if (vsIndirectDrawCountBuffer_) vsIndirectDrawCountBuffer_->destroy();
 
        // VS instanced drawing buffers
        if (vsVisibleInstancesBuffer_) vsVisibleInstancesBuffer_->destroy();
        if (vsVisibleCountBuffer_) vsVisibleCountBuffer_->destroy();
        if (vsInstanceAllocationsBuffer_) vsInstanceAllocationsBuffer_->destroy();
        if (vsGeometryCountersBuffer_) vsGeometryCountersBuffer_->destroy();
        if (vsInstanceIdsBuffer_) vsInstanceIdsBuffer_->destroy();
        if (vsDrawCommandsBuffer_) vsDrawCommandsBuffer_->destroy();
        if (vsDrawCountBuffer_) vsDrawCountBuffer_->destroy();
 
        // Cleanup Hi-Z pyramid
        hiZPyramid_.cleanup(context->getVkDevice());
 
        cleanupStagingBuffer();
 
        for (const auto &textureWrite: textureWritesToUpload) {
            delete textureWrite;
        }
        textureWritesToUpload.clear();
 
        if (context->getVkDevice()) {
            // destroy semaphores
            if (transferFinishedSemaphore)
                vkDestroySemaphore(context->getVkDevice(), transferFinishedSemaphore, nullptr);
 
            if (renderFinishedSemaphore)
                vkDestroySemaphore(context->getVkDevice(), renderFinishedSemaphore, nullptr);
 
            if (mirrorViewImageReadySemaphore)
                vkDestroySemaphore(context->getVkDevice(), mirrorViewImageReadySemaphore, nullptr);
 
            if (transferCompleteFence)
                vkDestroyFence(context->getVkDevice(), transferCompleteFence, nullptr);
 
            if (graphicsCompleteFence)
                vkDestroyFence(context->getVkDevice(), graphicsCompleteFence, nullptr);
        }
    }
 
    void RenderProcess::updateEyeViewProjectionMatrices(const Headset* headset) {
        // Check if there's an active camera override
        CameraComponent* activeCamera = getActiveCamera();
 
        for (size_t eye = 0; eye < headset->getEyeCount(); eye++) {
            if (activeCamera != nullptr) {
                // Use camera's view matrix with headset's projection matrix
                // This allows viewing the scene from a debug camera while keeping VR projection
                const glm::mat4 cameraView = activeCamera->getViewMatrix();
                const glm::mat4 headsetProj = headset->getEyeProjectionMatrix(eye);
                staticVertexUniformData.viewProjectionMatrices.at(eye) = headsetProj * cameraView;
            } else {
                // Default: use headset's view-projection (normal VR rendering)
                staticVertexUniformData.viewProjectionMatrices.at(eye) = headset->getViewProjectionMatrix(eye);
            }
        }
    }
 
    void RenderProcess::updateFragmentTime(const float time) {
        TRACY_ZONE_SCOPED_FUNCTION;
        staticFragmentUniformData.time = time;
    }
 
    VkCommandBuffer& RenderProcess::getTransferCommandBuffer()
    {
        return transferCommandBuffer;
    }
 
    VkCommandBuffer& RenderProcess::getGraphicsCommandBuffer()
    {
        return graphicsCommandBuffer;
    }
 
    VkSemaphore RenderProcess::getTransferFinishedSemaphore() const {
        return transferFinishedSemaphore;
    }
 
    VkSemaphore RenderProcess::getRenderFinishedSemaphore() const {
        return renderFinishedSemaphore;
    }
 
    VkDescriptorSet RenderProcess::getGraphicsDescriptorSet() const {
        return graphicsDescriptorSet;
    }
 
    VkSemaphore RenderProcess::getMirrorViewImageSemaphore() const
    {
        return mirrorViewImageReadySemaphore;
    }
 
    VulkanStagedBufferSyncObjects RenderProcess::uploadUniformBufferData() {
        TRACY_ZONE_SCOPED_NAMED("Update uniform buffers");
        constexpr VkDeviceSize size = sizeof(ViewMatrixUniformData);
        return viewProjectionBuffer->upload(context, &staticVertexUniformData, size);
    }
 
    uint32_t RenderProcess::getEyeIndex() const {
        return eyeIndex;
    }
 
    void RenderProcess::uploadNewTextures(const std::vector<Texture *> &textures, uint32_t firstIndex) const {
        std::vector<VkDescriptorImageInfo> imageInfos(textures.size());
        for (uint32_t i = 0; i < imageInfos.size(); i++) {
            imageInfos.at(i).imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
            imageInfos.at(i).sampler = textures.at(i)->getVkImageSampler();
            imageInfos.at(i).imageView = textures.at(i)->getVkImageView();
        }
 
        VkWriteDescriptorSet write {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet = graphicsDescriptorSet,
            .dstBinding = ShaderStage::Graphics::TEXTURE_ARRAY,
            .dstArrayElement = firstIndex,
            .descriptorCount = static_cast<uint32_t>(imageInfos.size()),
            .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            .pImageInfo = imageInfos.data(),
            .pBufferInfo = nullptr,
            .pTexelBufferView = nullptr
        };
 
        // Call vkUpdateDescriptorSets with a single write
        vkUpdateDescriptorSets(context->getVkDevice(), 1, &write, 0, nullptr);
    }
 
    void RenderProcess::addTexturesToUpload(const std::vector<Texture *> &textures,
                                            uint32_t firstIndex) {
        TRACY_ZONE_SCOPED_NAMED("Add textures to upload queue");
        TextureWriteContainer *writeContainer = new TextureWriteContainer();
        writeContainer->imageInfos.resize(textures.size());
        for (uint32_t i = 0; i < writeContainer->imageInfos.size(); i++) {
            writeContainer->imageInfos.at(i).imageLayout =
                    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
            writeContainer->imageInfos.at(i).sampler = textures.at(i)->getVkImageSampler();
            writeContainer->imageInfos.at(i).imageView = textures.at(i)->getVkImageView();
        }
 
        writeContainer->write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
        writeContainer->write.dstSet = graphicsDescriptorSet;
        writeContainer->write.dstBinding = ShaderStage::Graphics::TEXTURE_ARRAY;
        // the array binding index in the descriptor set
        writeContainer->write.dstArrayElement =
                firstIndex; // start writing at index 4 (the 5th element)
        writeContainer->write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        writeContainer->write.descriptorCount = static_cast<uint32_t>(
            writeContainer->imageInfos.size()); // how many new descriptors to write
        writeContainer->write.pImageInfo = writeContainer->imageInfos.data();
        writeContainer->write.pBufferInfo = nullptr;
        writeContainer->write.pTexelBufferView = nullptr;
 
        textureWritesToUpload.push_back(std::move(writeContainer));
    }
 
    void RenderProcess::processTextureUpload() {
        if (textureWritesToUpload.empty()) return;
 
        TRACY_ZONE_SCOPED_NAMED("Process texture uploads");
        std::vector<VkWriteDescriptorSet> writes(textureWritesToUpload.size());
        for (uint32_t copyIndex = 0u; copyIndex < textureWritesToUpload.size(); copyIndex++) {
            writes.at(copyIndex) = textureWritesToUpload.at(copyIndex)->write;
        }
 
        PLOGI << "Called update descriptor sets for textures";
        vkUpdateDescriptorSets(context->getVkDevice(), static_cast<uint32_t>(writes.size()), writes.data(), 0, nullptr);
 
        for (const TextureWriteContainer *writeContainer: textureWritesToUpload) {
            delete writeContainer;
        }
        textureWritesToUpload.clear();
    }
 
    void RenderProcess::addStagingBufferForCleanup(VulkanBuffer &&stagingBuffer) {
        stagingBuffersForCleanup.push_back(std::move(stagingBuffer));
    }
 
    void RenderProcess::cleanupStagingBuffer() {
        TRACY_ZONE_SCOPED_NAMED("Cleanup staging buffers");
        for (VulkanBuffer &buffer: stagingBuffersForCleanup) {
            buffer.destroy();
        }
        stagingBuffersForCleanup.clear();
    }
 
    void RenderProcess::createObjectMeshletDataBuffer()
    {
        objectMeshletData.resize( MAX_MESHLETS_PER_BIN );
        constexpr VkDeviceSize bufferSize = sizeof(PrimitiveMeshletData) * MAX_MESHLETS_PER_BIN;
        objectMeshletDataBuffer.emplace();
        objectMeshletDataBuffer->create( context, bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT );
        objectMeshletDataBuffer->setDebugName( "Object meshlet data ", eyeIndex );
    }
 
    void RenderProcess::createBinnedVisibleMeshletIndexBuffer() {
        constexpr VkDeviceSize bufferSize = sizeof(VisibleMeshletInfo) * MAX_PIPELINES * MAX_MESHLETS_PER_BIN;
        binnedVisibleMeshletIndexBuffer.emplace(context);
        binnedVisibleMeshletIndexBuffer->create(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        binnedVisibleMeshletIndexBuffer->setDebugName( "binnedMeshletRenderingIndices" + std::to_string(eyeIndex) );
    }
 
    void RenderProcess::createMeshletCounterBuffer() {
        constexpr VkDeviceSize bufferSize = sizeof(uint32_t) * MAX_PIPELINES * MAX_MESHLETS_PER_BIN;
        meshletCounterBuffer.emplace(context);
        meshletCounterBuffer->create(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        meshletCounterBuffer->setDebugName( "meshlet counter buffer " + std::to_string(eyeIndex) );
    }
 
    void RenderProcess::createPerObjectSSBOBuffer() {
        // Initial capacity - will grow dynamically via ensureBufferSizes()
        constexpr uint32_t INITIAL_BUFFER_CAPACITY = 1000;
        perObjectData.resize(INITIAL_BUFFER_CAPACITY);
        constexpr VkDeviceSize bufferSize = INITIAL_BUFFER_CAPACITY * sizeof(PerObjectData);
        perObjectDataBuffer.emplace();
        perObjectDataBuffer->create(context, bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
        perObjectDataBuffer->setDebugName("per Object", eyeIndex);
    }
 
    void RenderProcess::createMeshRenderingInfoBuffers() {
        // Initial capacity - will grow dynamically via ensureBufferSizes()
        constexpr uint32_t INITIAL_BUFFER_CAPACITY = 1000;
        unifiedMeshes.resize(INITIAL_BUFFER_CAPACITY);
        constexpr VkDeviceSize bufferSize = sizeof(GpuMeshDescription) * INITIAL_BUFFER_CAPACITY;
        meshRenderingInfoBuffer.emplace();
        meshRenderingInfoBuffer->create(context, bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
        meshRenderingInfoBuffer->setDebugName("mesh Rendering Info", eyeIndex);
    }
 
    void RenderProcess::createFrustumUBOBuffer() {
        constexpr VkDeviceSize frustumUBOSize = sizeof(FrustumPlanes);
        frustumDataBuffer.emplace();
        frustumDataBuffer->create(context, frustumUBOSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
        frustumDataBuffer->setDebugName("frustumUBO" + std::to_string(eyeIndex));
    }
 
    void RenderProcess::createIndirectDrawBuffer() {
        constexpr VkDeviceSize bufferSize = MAX_PIPELINES * sizeof(VkDrawMeshTasksIndirectCommandEXT);
        indirectDrawBuffer.emplace(context);
        indirectDrawBuffer->create(bufferSize, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        indirectDrawBuffer->setDebugName( "indirect draw buffer " + std::to_string(eyeIndex) );
        std::vector<VkDrawMeshTasksIndirectCommandEXT> cmd(MAX_PIPELINES, {1,1,1});
        VulkanHelper::uploadDataToExistingBuffer( context->getVkDevice(), context->getVkPhysicalDevice(), renderer->getGraphicsCommandPool(), context->getGraphicsQueue(), bufferSize, &cmd, indirectDrawBuffer->getBuffer());
    }
 
    VulkanStagedBuffer& RenderProcess::getViewProjectionBuffer() {
        return viewProjectionBuffer.value();
    }
 
    const VulkanStagedBuffer& RenderProcess::getViewProjectionBuffer() const
    {
        return viewProjectionBuffer.value();
    }
 
    VulkanStagedBuffer& RenderProcess::getMeshletToObjectMapBuffer()
    {
        return meshletToObjectMapBuffer.value();
    }
 
    const VulkanStagedBuffer& RenderProcess::getMeshletToObjectMapBuffer() const
    {
        return meshletToObjectMapBuffer.value();
    }
 
    VulkanBuffer& RenderProcess::getBinnedVisibleMeshletIndexBuffer()
    {
        return binnedVisibleMeshletIndexBuffer.value();
    }
 
    const VulkanBuffer &RenderProcess::getBinnedVisibleMeshletIndexBuffer() const {
        return binnedVisibleMeshletIndexBuffer.value();
    }
 
    const VulkanBuffer &RenderProcess::getMeshletCounterBuffer() const {
        return meshletCounterBuffer.value();
    }
 
    const VulkanStagedBuffer &RenderProcess::getPerObjectSSBOBuffer() const {
        return perObjectDataBuffer.value();
    }
 
    const VulkanStagedBuffer &RenderProcess::getMeshRenderingBuffer() const {
        return meshRenderingInfoBuffer.value();
    }
 
    const VulkanStagedBuffer &RenderProcess::getFrustumUBOBuffer() const {
        return frustumDataBuffer.value();
    }
 
    void RenderProcess::createHiZViewProjectionBuffer() {
        constexpr VkDeviceSize bufferSize = sizeof(HiZViewProjectionData);
        hiZViewProjectionBuffer_.emplace();
        hiZViewProjectionBuffer_->create(context, bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
        hiZViewProjectionBuffer_->setDebugName("hiZViewProjectionUBO", eyeIndex);
    }
 
    void RenderProcess::updateHiZViewProjectionData(const Headset* headset) {
        TRACY_ZONE_SCOPED_FUNCTION;
 
        // Use this frame's view-projection matrices for Hi-Z occlusion culling.
        // Two-pass culling uses current VP with previous Hi-Z, catching false negatives in Pass 2.
        for (uint32_t eye = 0; eye < 2u; ++eye) {
            hiZViewProjectionData_.viewProjection[eye] = staticVertexUniformData.viewProjectionMatrices.at(eye);
        }
 
        // Update screen size and mip level info
        const VkExtent2D eyeResolution = headset->getEyeResolution(0);
        hiZViewProjectionData_.screenSize = glm::vec2(
            static_cast<float>(eyeResolution.width),
            static_cast<float>(eyeResolution.height)
        );
        // Use this frame's Hi-Z pyramid mip levels
        hiZViewProjectionData_.hiZMipLevels = getHiZMipLevels();
        hiZViewProjectionData_._padding = 0;
 
        // On first frame, disable Hi-Z culling by setting mipLevels to 0
        // The Hi-Z pyramid hasn't been generated yet
        if (hiZFirstFrame_) {
            hiZViewProjectionData_.hiZMipLevels = 0;
            hiZFirstFrame_ = false;
        }
    }
 
    VulkanStagedBufferSyncObjects RenderProcess::uploadHiZViewProjectionUBO() {
        TRACY_ZONE_SCOPED_NAMED("Upload Hi-Z ViewProjection UBO");
 
        if (!hiZViewProjectionBuffer_.has_value()) {
            return VulkanStagedBufferSyncObjects{};
        }
 
        constexpr VkDeviceSize size = sizeof(HiZViewProjectionData);
        return hiZViewProjectionBuffer_->upload(context, &hiZViewProjectionData_, size);
    }
 
    const VulkanStagedBuffer& RenderProcess::getHiZViewProjectionBuffer() const {
        return hiZViewProjectionBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getIndirectDrawBuffer() const
    {
        return indirectDrawBuffer.value();
    }
 
    const VulkanBuffer & RenderProcess::getVisibleObjectRangesBuffer() const {
        return visibleObjectRangesBuffer.value();
    }
 
    const VulkanBuffer & RenderProcess::getPass1CounterBuffer() const {
        return pass1CounterBuffer.value();
    }
 
    const VulkanStagedBuffer & RenderProcess::getObjectMeshletDataBuffer() const
    {
        return objectMeshletDataBuffer.value();
    }
 
    VkFence & RenderProcess::getTransferCompleteFence()
    {
        return transferCompleteFence;
    }
    VkFence& RenderProcess::getGraphicsCompleteFence()
    {
        return graphicsCompleteFence;
    }
    void RenderProcess::setTransferFenceSubmitted(const bool isSubmitted)
    {
        transferFenceSubmitted = isSubmitted;
    }
    void RenderProcess::setGraphicsFenceSubmitted(const bool isSubmitted)
    {
        graphicsFenceSubmitted = isSubmitted;
    }
    bool RenderProcess::getTransferFenceSubmitted() const
    {
        return transferFenceSubmitted;
    }
    bool RenderProcess::getGraphicsFenceSubmitted() const
    {
        return graphicsFenceSubmitted;
    }
 
    void RenderProcess::createDispatcherDispatchBuffer() {
        constexpr VkDeviceSize bufferSize = sizeof(Dispatch);
        dispatcherDispatchBuffer.emplace(context);
        dispatcherDispatchBuffer->create(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT );
        dispatcherDispatchBuffer->setDebugName("dispatcher Dispatch Buffer");
    }
 
    void RenderProcess::createCountDispatcherBuffers() {
        constexpr VkDeviceSize counterBufferSize = sizeof(uint32_t);
        constexpr VkDeviceSize dispatchBufferSize = sizeof(Dispatch);
        countDispatcherCounter.emplace(context);
        countDispatcherDispatchBuffer.emplace(context);
        countDispatcherCounter->create(counterBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        countDispatcherDispatchBuffer->create(dispatchBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        countDispatcherCounter->setDebugName("countDispatcherCounter");
        countDispatcherDispatchBuffer->setDebugName("countDispatcherDispatchBuffer");
    }
 
    void RenderProcess::createVisibleObjectRangesBuffer() {
        // Initial capacity - will grow dynamically via ensureBufferSizes()
        constexpr uint32_t INITIAL_BUFFER_CAPACITY = 1000;
        constexpr VkDeviceSize bufferSize = sizeof(VisibleMeshletRange) * INITIAL_BUFFER_CAPACITY;
        visibleObjectRangesBuffer.emplace(context);
        visibleObjectRangesBuffer->create(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        visibleObjectRangesBuffer->setDebugName("visibleObjectRanges" + std::to_string(eyeIndex));
    }
 
    void RenderProcess::createPass1CounterBuffer() {
        constexpr VkDeviceSize bufferSize = sizeof(uint32_t) * 2; // objectCount + totalMeshletCount
        pass1CounterBuffer.emplace(context);
        pass1CounterBuffer->create(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        pass1CounterBuffer->setDebugName("pass1Counters" + std::to_string(eyeIndex));
    }
 
    void RenderProcess::createViewProjectionBuffer() {
        constexpr VkDeviceSize viewProjBufferSize = sizeof(ViewMatrixUniformData);
        viewProjectionBuffer.emplace();
        viewProjectionBuffer->create(context, viewProjBufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
        viewProjectionBuffer->setDebugName("View projection buffer" + std::to_string(eyeIndex));
    }
 
    void RenderProcess::createMeshletToObjectMapBuffer() {
        constexpr VkDeviceSize bufferSize = sizeof(uint32_t) * MAX_MESHLETS_PER_BIN;
        meshletToObjectMapBuffer.emplace();
        meshletToObjectMapBuffer->create(context, bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
        meshletToObjectMapBuffer->setDebugName("meshletToObjectMap Buffer" + std::to_string(eyeIndex));
    }
 
    void RenderProcess::createBinningAllocatorBuffers() {
        // PrimitiveAllocation struct size: 32 bytes (8 * sizeof(uint32_t))
        // Includes: primitiveID, pipelineID, binWriteOffset, meshletStartIndex, meshletCount, ditherFactor, _padding[2]
        // Initial capacity - will grow dynamically via ensureBufferSizes()
        constexpr uint32_t INITIAL_BUFFER_CAPACITY = 1000;
        constexpr VkDeviceSize allocationStructSize = 32;  // 8 * sizeof(uint32_t) = 32 bytes
        constexpr VkDeviceSize allocationsBufferSize = allocationStructSize * INITIAL_BUFFER_CAPACITY;
 
        allocationsBuffer.emplace(context);
        allocationsBuffer->create(allocationsBufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        allocationsBuffer->setDebugName("allocationsBuffer" + std::to_string(eyeIndex));
 
        // Pipeline counters: one uint32_t per pipeline for atomic counting
        constexpr VkDeviceSize pipelineCountersSize = sizeof(uint32_t) * MAX_PIPELINES;
        pipelineCountersBuffer.emplace(context);
        pipelineCountersBuffer->create(pipelineCountersSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        pipelineCountersBuffer->setDebugName("pipelineCountersBuffer" + std::to_string(eyeIndex));
 
        // Pipeline bin offsets: prefix sum of pipeline counters (one uint32_t per pipeline)
        constexpr VkDeviceSize binOffsetsSize = sizeof(uint32_t) * MAX_PIPELINES;
        pipelineBinOffsetsBuffer.emplace(context);
        pipelineBinOffsetsBuffer->create(binOffsetsSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        pipelineBinOffsetsBuffer->setDebugName("pipelineBinOffsetsBuffer" + std::to_string(eyeIndex));
    }
 
    const VulkanBuffer& RenderProcess::getAllocationsBuffer() const {
        return allocationsBuffer.value();
    }
 
    const VulkanBuffer& RenderProcess::getPipelineCountersBuffer() const {
        return pipelineCountersBuffer.value();
    }
 
    const VulkanBuffer& RenderProcess::getPipelineBinOffsetsBuffer() const {
        return pipelineBinOffsetsBuffer.value();
    }
 
    void RenderProcess::createCullingFailedBuffers() {
        // Two-pass occlusion culling: buffer to store object IDs that failed Pass 1 Hi-Z test
        // Initial capacity - will grow dynamically via ensureBufferSizes()
        constexpr uint32_t INITIAL_BUFFER_CAPACITY = 1000;
        constexpr VkDeviceSize failedBufferSize = sizeof(uint32_t) * INITIAL_BUFFER_CAPACITY;
 
        cullingFailedBuffer.emplace(context);
        cullingFailedBuffer->create(failedBufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        cullingFailedBuffer->setDebugName("cullingFailedBuffer" + std::to_string(eyeIndex));
 
        // Counter for failed objects (single uint32_t, used atomically)
        constexpr VkDeviceSize counterSize = sizeof(uint32_t);
        cullingFailedCounterBuffer.emplace(context);
        cullingFailedCounterBuffer->create(counterSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        cullingFailedCounterBuffer->setDebugName("cullingFailedCounterBuffer" + std::to_string(eyeIndex));
    }
 
    const VulkanBuffer& RenderProcess::getCullingFailedBuffer() const {
        return cullingFailedBuffer.value();
    }
 
    const VulkanBuffer& RenderProcess::getCullingFailedCounterBuffer() const {
        return cullingFailedCounterBuffer.value();
    }
 
    void RenderProcess::createVSIndirectDrawBuffers() {
        // Vertex shader path: indirect draw buffer for single-meshlet geometry
        // VkDrawIndexedIndirectCommand is 20 bytes (5 x uint32_t)
        // Initial capacity for 10000 single-meshlet draws - will grow via ensureBufferSizes()
        constexpr uint32_t INITIAL_DRAW_CAPACITY = 10000;
        constexpr VkDeviceSize drawBufferSize = sizeof(VkDrawIndexedIndirectCommand) * INITIAL_DRAW_CAPACITY;
 
        vsIndirectDrawBuffer_.emplace(context);
        vsIndirectDrawBuffer_->create(drawBufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsIndirectDrawBuffer_->setDebugName("vsIndirectDrawBuffer" + std::to_string(eyeIndex));
 
        // Draw count buffer - single uint32_t for indirect draw count
        constexpr VkDeviceSize countBufferSize = sizeof(uint32_t);
        vsIndirectDrawCountBuffer_.emplace(context);
        vsIndirectDrawCountBuffer_->create(countBufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsIndirectDrawCountBuffer_->setDebugName("vsIndirectDrawCountBuffer" + std::to_string(eyeIndex));
 
        PLOGI << "[VS_PATH] Created VS indirect draw buffers for frame " << eyeIndex;
    }
 
    const VulkanBuffer& RenderProcess::getVSIndirectDrawBuffer() const {
        return vsIndirectDrawBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSIndirectDrawCountBuffer() const {
        return vsIndirectDrawCountBuffer_.value();
    }
 
    void RenderProcess::createVSInstancedDrawingBuffers() {
        // VS Instanced Drawing Pipeline Buffers
        // This pipeline reduces ~5k draw calls to ~1 by batching instances by geometry type
 
        constexpr uint32_t INITIAL_INSTANCE_CAPACITY = 10000;
        constexpr uint32_t MAX_GEOMETRY_TYPES = 256;
        constexpr uint32_t MAX_VS_INSTANCES_PER_GEO = 16384;
 
        // Stage 0: Culling outputs primitive IDs (replaces draw commands)
        // vsVisibleInstancesBuffer_: uint array of primitive IDs
        constexpr VkDeviceSize visibleInstancesSize = sizeof(uint32_t) * INITIAL_INSTANCE_CAPACITY;
        vsVisibleInstancesBuffer_.emplace(context);
        vsVisibleInstancesBuffer_->create(visibleInstancesSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsVisibleInstancesBuffer_->setDebugName("vsVisibleInstancesBuffer" + std::to_string(eyeIndex));
 
        // vsVisibleCountBuffer_: single uint32_t for visible count
        constexpr VkDeviceSize countSize = sizeof(uint32_t);
        vsVisibleCountBuffer_.emplace(context);
        vsVisibleCountBuffer_->create(countSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsVisibleCountBuffer_->setDebugName("vsVisibleCountBuffer" + std::to_string(eyeIndex));
 
        // Stage 1: VSBinningAllocator outputs
        // vsInstanceAllocationsBuffer_: (primitiveID, geoIndex, writeOffset) per survivor
        constexpr VkDeviceSize allocationStructSize = 3 * sizeof(uint32_t);  // VSInstanceAllocation
        constexpr VkDeviceSize allocationsBufferSize = allocationStructSize * INITIAL_INSTANCE_CAPACITY;
        vsInstanceAllocationsBuffer_.emplace(context);
        vsInstanceAllocationsBuffer_->create(allocationsBufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsInstanceAllocationsBuffer_->setDebugName("vsInstanceAllocationsBuffer" + std::to_string(eyeIndex));
 
        // vsGeometryCountersBuffer_: atomic instance count per geometry type
        constexpr VkDeviceSize geometryCountersSize = sizeof(uint32_t) * MAX_GEOMETRY_TYPES;
        vsGeometryCountersBuffer_.emplace(context);
        vsGeometryCountersBuffer_->create(geometryCountersSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsGeometryCountersBuffer_->setDebugName("vsGeometryCountersBuffer" + std::to_string(eyeIndex));
 
        // Stage 2: VSInstanceUnpacking outputs
        // vsInstanceIdsBuffer_: Instance ID lookup for vertex shader
        // Layout: [Geo0 slots][Geo1 slots]... with MAX_VS_INSTANCES_PER_GEO slots each
        constexpr VkDeviceSize instanceIdsSize = sizeof(uint32_t) * MAX_GEOMETRY_TYPES * MAX_VS_INSTANCES_PER_GEO;
        vsInstanceIdsBuffer_.emplace(context);
        vsInstanceIdsBuffer_->create(instanceIdsSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsInstanceIdsBuffer_->setDebugName("vsInstanceIdsBuffer" + std::to_string(eyeIndex));
 
        // Stage 3: VSPrepareDraw outputs
        // vsDrawCommandsBuffer_: VkDrawIndexedIndirectCommand array (one per geometry with instances)
        constexpr VkDeviceSize drawCommandsSize = sizeof(VkDrawIndexedIndirectCommand) * MAX_GEOMETRY_TYPES;
        vsDrawCommandsBuffer_.emplace(context);
        vsDrawCommandsBuffer_->create(drawCommandsSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsDrawCommandsBuffer_->setDebugName("vsDrawCommandsBuffer" + std::to_string(eyeIndex));
 
        // vsDrawCountBuffer_: number of draw commands generated
        vsDrawCountBuffer_.emplace(context);
        vsDrawCountBuffer_->create(countSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        vsDrawCountBuffer_->setDebugName("vsDrawCountBuffer" + std::to_string(eyeIndex));
 
        PLOGI << "[VS_PATH_INSTANCED] Created VS instanced drawing buffers for frame " << eyeIndex;
    }
 
    const VulkanBuffer& RenderProcess::getVSVisibleInstancesBuffer() const {
        return vsVisibleInstancesBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSVisibleCountBuffer() const {
        return vsVisibleCountBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSInstanceAllocationsBuffer() const {
        return vsInstanceAllocationsBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSGeometryCountersBuffer() const {
        return vsGeometryCountersBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSInstanceIdsBuffer() const {
        return vsInstanceIdsBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSDrawCommandsBuffer() const {
        return vsDrawCommandsBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getVSDrawCountBuffer() const {
        return vsDrawCountBuffer_.value();
    }
 
    void RenderProcess::createLodBuffers() {
        // LOD cluster-based selection buffers
        // These support Nanite-style per-cluster LOD selection
 
        constexpr uint32_t INITIAL_CLUSTER_SURVIVOR_CAPACITY = 100000;
 
        // lodClusterSurvivorsBuffer_: ClusterSurvivor output from culling shader
        // ClusterSurvivor = {primitiveID, clusterIndex, ditherFactor, padding} = 16 bytes
        constexpr VkDeviceSize survivorsSize = sizeof(ClusterSurvivor) * INITIAL_CLUSTER_SURVIVOR_CAPACITY;
        lodClusterSurvivorsBuffer_.emplace(context);
        lodClusterSurvivorsBuffer_->create(survivorsSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        lodClusterSurvivorsBuffer_->setDebugName("lodClusterSurvivorsBuffer" + std::to_string(eyeIndex));
 
        // lodClusterSurvivorCountBuffer_: atomic counter for LOD cluster survivors
        constexpr VkDeviceSize counterSize = sizeof(uint32_t);
        lodClusterSurvivorCountBuffer_.emplace(context);
        lodClusterSurvivorCountBuffer_->create(counterSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        lodClusterSurvivorCountBuffer_->setDebugName("lodClusterSurvivorCountBuffer" + std::to_string(eyeIndex));
 
        // lodConfigBuffer_: LodConfigUBO for camera/screen info (uniform buffer)
        lodConfigBuffer_.emplace();
        lodConfigBuffer_->create(context, sizeof(LodConfigUBO),
            VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            true /* persistentMapping */);
        lodConfigBuffer_->setDebugName("lodConfigBuffer" + std::to_string(eyeIndex));
 
        PLOGI << "[LOD] Created LOD cluster selection buffers for frame " << eyeIndex;
    }
 
    const VulkanBuffer& RenderProcess::getLodClusterSurvivorsBuffer() const {
        return lodClusterSurvivorsBuffer_.value();
    }
 
    const VulkanBuffer& RenderProcess::getLodClusterSurvivorCountBuffer() const {
        return lodClusterSurvivorCountBuffer_.value();
    }
 
    const VulkanStagedBuffer& RenderProcess::getLodConfigBuffer() const {
        return lodConfigBuffer_.value();
    }
 
    void RenderProcess::updateLodConfig(const glm::vec3& cameraPosition, const glm::mat4& projMatrix,
                                        float nearPlane, float screenWidth, float screenHeight,
                                        float errorThresholdPixels, bool ditherEnabled) {
        lodConfigData_.errorThresholdPixels = errorThresholdPixels;
        lodConfigData_.cameraProj11 = projMatrix[1][1];  // cot(fov/2)
        lodConfigData_.cameraNear = nearPlane;
        lodConfigData_.ditherEnabled = ditherEnabled ? 1u : 0u;
        lodConfigData_.cameraPosition = glm::vec4(cameraPosition, 1.0f);
        lodConfigData_.screenSize = glm::vec2(screenWidth, screenHeight);
        lodConfigData_._padding = glm::vec2(0.0f);
    }
 
    VulkanStagedBufferSyncObjects RenderProcess::uploadLodConfigBuffer() {
        return lodConfigBuffer_->upload(context, &lodConfigData_, sizeof(LodConfigUBO));
    }
 
    bool RenderProcess::ensureBufferSizes(const uint32_t primitiveCount)
    {
        bool anyRecreated = false;
        constexpr VkMemoryPropertyFlags deviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        constexpr VkBufferUsageFlags storageUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 
        // perObjectDataBuffer: stores PerObjectData per primitive
        const VkDeviceSize perObjectSize = primitiveCount * sizeof(PerObjectData);
        if (perObjectDataBuffer.has_value()) {
            anyRecreated |= perObjectDataBuffer->ensureSize(perObjectSize, storageUsage);
        }
 
        // meshRenderingInfoBuffer: stores GpuMeshDescription per primitive
        const VkDeviceSize meshRenderingSize = primitiveCount * sizeof(GpuMeshDescription);
        if (meshRenderingInfoBuffer.has_value()) {
            anyRecreated |= meshRenderingInfoBuffer->ensureSize(meshRenderingSize, storageUsage);
        }
 
        // visibleObjectRangesBuffer: stores VisibleMeshletRange per primitive
        const VkDeviceSize visibleRangesSize = primitiveCount * sizeof(VisibleMeshletRange);
        if (visibleObjectRangesBuffer.has_value()) {
            anyRecreated |= visibleObjectRangesBuffer->ensureSize(visibleRangesSize, storageUsage, deviceLocal);
        }
 
        // allocationsBuffer: stores PrimitiveAllocation (32 bytes) per allocation
        // With LOD, allocations = primitiveCount (regular) + clusterCount (LOD clusters)
        // PrimitiveAllocation: primitiveID, pipelineID, binWriteOffset, meshletStartIndex, meshletCount, ditherFactor, _padding[2]
        constexpr VkDeviceSize allocationStructSize = 32;  // 8 * uint32_t = 32 bytes
        const uint32_t clusterCount = renderer->getRenderingDataManager()->getClusterCount();
        const VkDeviceSize allocationsSize = (primitiveCount + clusterCount) * allocationStructSize;
        if (allocationsBuffer.has_value()) {
            anyRecreated |= allocationsBuffer->ensureSize(allocationsSize,
                VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, deviceLocal);
        }
 
        // cullingFailedBuffer: stores uint32_t object IDs that failed Pass 1 Hi-Z test
        const VkDeviceSize failedBufferSize = primitiveCount * sizeof(uint32_t);
        if (cullingFailedBuffer.has_value()) {
            anyRecreated |= cullingFailedBuffer->ensureSize(failedBufferSize,
                VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, deviceLocal);
        }
 
        // vsIndirectDrawBuffer: stores VkDrawIndexedIndirectCommand for VS path
        // Size based on primitiveCount since all primitives could potentially be single-meshlet
        const VkDeviceSize vsDrawBufferSize = primitiveCount * sizeof(VkDrawIndexedIndirectCommand);
        if (vsIndirectDrawBuffer_.has_value()) {
            anyRecreated |= vsIndirectDrawBuffer_->ensureSize(vsDrawBufferSize,
                VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, deviceLocal);
        }
 
        // Resize CPU-side vectors to match
        if (perObjectData.size() < primitiveCount) {
            perObjectData.resize(primitiveCount);
        }
        if (unifiedMeshes.size() < primitiveCount) {
            unifiedMeshes.resize(primitiveCount);
        }
 
        if (anyRecreated) {
            PLOGI << "RenderProcess " << eyeIndex << ": Buffers resized for " << primitiveCount << " primitives";
        }
 
        return anyRecreated;
    }
 
    // ============================================================================
    // Hi-Z Pyramid Implementation
    // ============================================================================
 
    void RenderProcess::HiZPyramid::cleanup(VkDevice device)
    {
        if (device == VK_NULL_HANDLE) return;
 
        for (VkImageView mipView : mipViews) {
            if (mipView != VK_NULL_HANDLE) {
                vkDestroyImageView(device, mipView, nullptr);
            }
        }
        mipViews.clear();
 
        if (fullView != VK_NULL_HANDLE) {
            vkDestroyImageView(device, fullView, nullptr);
            fullView = VK_NULL_HANDLE;
        }
 
        if (image != VK_NULL_HANDLE) {
            vkDestroyImage(device, image, nullptr);
            image = VK_NULL_HANDLE;
        }
 
        if (deviceMemory != VK_NULL_HANDLE) {
            vkFreeMemory(device, deviceMemory, nullptr);
            deviceMemory = VK_NULL_HANDLE;
        }
 
        mipLevels = 0;
        extent = {};
    }
 
    void RenderProcess::createHiZPyramid(VkDevice device, VkExtent2D resolution, uint32_t arrayLayers)
    {
        PLOGI << "Creating Hi-Z pyramid for frame " << eyeIndex << " with resolution "
              << resolution.width << "x" << resolution.height;
 
        // Calculate number of mip levels needed
        hiZPyramid_.extent = resolution;
        hiZPyramid_.mipLevels = static_cast<uint32_t>(
            std::floor(std::log2(std::max(resolution.width, resolution.height)))) + 1;
 
        PLOGI << "Hi-Z pyramid will have " << hiZPyramid_.mipLevels << " mip levels";
 
        // Create Hi-Z image with all mip levels
        VkImageCreateInfo imageCreateInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
        imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
        imageCreateInfo.extent.width = resolution.width;
        imageCreateInfo.extent.height = resolution.height;
        imageCreateInfo.extent.depth = 1u;
        imageCreateInfo.mipLevels = hiZPyramid_.mipLevels;
        imageCreateInfo.arrayLayers = arrayLayers;  // 2 for stereo
        imageCreateInfo.format = VK_FORMAT_R32_SFLOAT;  // Single float for depth
        imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
        imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
        imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
        imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
        PLOG_FN_VK(vkCreateImage(device, &imageCreateInfo, nullptr, &hiZPyramid_.image));
        VulkanHelper::setObjectName(device, hiZPyramid_.image,
            "Hi-Z Pyramid Image Frame " + std::to_string(eyeIndex));
 
        // Allocate memory
        VkMemoryRequirements memRequirements;
        vkGetImageMemoryRequirements(device, hiZPyramid_.image, &memRequirements);
 
        uint32_t memoryTypeIndex = 0u;
        VkMemoryRequirements2 memReqs2{VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
        memReqs2.memoryRequirements = memRequirements;
        if (!VulkanHelper::findSuitableMemoryType(context->getVkPhysicalDevice(), memReqs2,
                                                  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, memoryTypeIndex))
        {
            THROW_ERROR("Could not find suitable memory type for Hi-Z pyramid");
        }
 
        VkMemoryAllocateInfo allocInfo{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
        allocInfo.allocationSize = memRequirements.size;
        allocInfo.memoryTypeIndex = memoryTypeIndex;
 
        PLOG_FN_VK(vkAllocateMemory(device, &allocInfo, nullptr, &hiZPyramid_.deviceMemory));
        VulkanHelper::setObjectName(device, hiZPyramid_.deviceMemory,
            "Hi-Z Pyramid Memory Frame " + std::to_string(eyeIndex));
 
        PLOG_FN_VK(vkBindImageMemory(device, hiZPyramid_.image, hiZPyramid_.deviceMemory, 0));
 
        // Create full image view (all mip levels) for sampling
        VkImageViewCreateInfo viewInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
        viewInfo.image = hiZPyramid_.image;
        viewInfo.viewType = (arrayLayers == 1u ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
        viewInfo.format = VK_FORMAT_R32_SFLOAT;
        viewInfo.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
                               VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
        viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        viewInfo.subresourceRange.baseMipLevel = 0;
        viewInfo.subresourceRange.levelCount = hiZPyramid_.mipLevels;
        viewInfo.subresourceRange.baseArrayLayer = 0;
        viewInfo.subresourceRange.layerCount = arrayLayers;
 
        PLOG_FN_VK(vkCreateImageView(device, &viewInfo, nullptr, &hiZPyramid_.fullView));
        VulkanHelper::setObjectName(device, hiZPyramid_.fullView,
            "Hi-Z Pyramid Full View Frame " + std::to_string(eyeIndex));
 
        // Create per-mip image views for compute shader writes
        hiZPyramid_.mipViews.resize(hiZPyramid_.mipLevels);
        for (uint32_t mip = 0; mip < hiZPyramid_.mipLevels; mip++)
        {
            VkImageViewCreateInfo mipViewInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
            mipViewInfo.image = hiZPyramid_.image;
            mipViewInfo.viewType = (arrayLayers == 1u ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
            mipViewInfo.format = VK_FORMAT_R32_SFLOAT;
            mipViewInfo.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
                                      VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
            mipViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            mipViewInfo.subresourceRange.baseMipLevel = mip;
            mipViewInfo.subresourceRange.levelCount = 1;
            mipViewInfo.subresourceRange.baseArrayLayer = 0;
            mipViewInfo.subresourceRange.layerCount = arrayLayers;
 
            PLOG_FN_VK(vkCreateImageView(device, &mipViewInfo, nullptr, &hiZPyramid_.mipViews[mip]));
            VulkanHelper::setObjectName(device, hiZPyramid_.mipViews[mip],
                "Hi-Z Pyramid Mip " + std::to_string(mip) + " View Frame " + std::to_string(eyeIndex));
        }
 
        PLOGI << "Hi-Z pyramid created successfully for frame " << eyeIndex;
    }
 
} // namespace EngineCore