Renderer.cpp

Go to the documentation of this file.

#include "Engine/Component/CameraComponent.h"
#include "Engine/Core/ComputePass.h"
#include "Engine/Core/Engine.h"
#include "Engine/Shader/Shader.h"
#include "Engine/Files/Path.h"
#include "Engine/Logging/FunctionNotImplemented.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Renderer/DescriptorSetUpdater.h"
#include "Engine/Renderer/LayoutBindingsBuilder.h"
#include "Engine/Renderer/PipelineStages.h"
#include "Engine/Renderer/QueueSubmitBuilder.h"
#include "Engine/Renderer/RenderData.h"
#include "Engine/Renderer/RenderingDataManager.h"
#include "Engine/Renderer/RenderProcess.h"
#include "Engine/Renderer/TimelineSynchronizer.h"
#include "Engine/Vulkan/BarrierBundle.h"
 
#ifdef COMPUTE_DEBUG
#include "Engine/Renderer/ComputeDebugUtils.h"
#endif
 
#include <array>
#include <cmath>
#include <glm/gtc/matrix_transform.hpp>
#include "Engine/Logging/LogCategories.h"
#include <BS_tracy_thread_pool.hpp>
#include <Engine/Core/ApplicationContext.h>
#include <Engine/Core/Settings.h>
#include <Engine/Core/VulkanHelper.h>
#include <Engine/Mesh/AssetManager.h>
#include <Engine/Mesh/Vertex.h>
#include <Engine/Renderer/Headset.h>
#include <Engine/Renderer/PipelineMaterialPayload.h>
#include <Engine/Renderer/Renderer.h>
#include <plog/Log.h>
#include <sstream>
#include <vector>
#include <vulkan/vulkan_core.h>
 
#ifdef ENABLE_TRACY
    #include "Engine/Logging/Colors.h"
#endif
 
namespace EngineCore
{
#if defined(HEADLESS)
    #define COMPUTE_SHADER_NAME(name) "Output/Placeholder.comp.spv"
    #define COMPUTE_GUARD() return;
    #define GRAPHICS_GUARD() return;
#elif defined(COMPUTE_DEBUG)
    #define COMPUTE_SHADER_NAME(name) name
    #define COMPUTE_GUARD()           // No-op: compute runs in debug mode
    #define GRAPHICS_GUARD() return;  // Skip graphics in debug mode
#else
    #define COMPUTE_SHADER_NAME(name) name
    #define COMPUTE_GUARD()
    #define GRAPHICS_GUARD()
#endif
 
    Renderer::Renderer(
        ApplicationContext *                  context,
        Headset *                             headset,
        const Engine *                        engine
    )
      : updateThreadPool( 2, [](std::size_t) {}, "Renderer" )
      , engine( engine )
      , context( context )
      , headset( headset )
    {
        TRACY_ZONE_SCOPED_NAMED( "Renderer Constructor" );
 
        renderingDataManager = std::make_unique<RenderingDataManager>(engine, context);
 
        {
            TRACY_ZONE_SCOPED_NAMED( "Initialize Frame Indices" );
            initializeFrameIndices();
        }
 
        {
            TRACY_ZONE_SCOPED_NAMED("Creating buffers");
            createDispatchBuffer();
            createPlaceholderBuffer();
            createPlaceholderUniformBuffer();
            createCounterBuffer();
            createObjectIDsBuffer();
            createObjectCullingDataBuffer();
            createObjectMeshletDataBuffer();
            createMeshUnpackingDataBuffer();
 
            // create main stages
            createPrimitiveCullingResources();
            createBinningAllocatorResources();  // Stage 1: Binning Allocator
            createMeshletUnpackingResources();  // Stage 2: Meshlet Unpacking V2
            createMeshletCullingResources();
            createPrepareDrawResources();
 
            // create dispatcher stages. This should only be placed after the actual creation of the others as it
            // requires the pipelines to be setup already. It fetches the thread count from the pipeline to set
            // the target size in the next shader
            createMeshletUnpackingDispatcherResources();
            createMeshletCullingDispatcherResources();
 
            // Hi-Z occlusion culling resources
            createHiZGenerationResources();  // Legacy multi-pass (fallback)
            createHiZSPDResources();         // SPD single-pass (default)
            // NOTE: createHiZMipDescriptorSets() and createHiZSPDDescriptorSets() are called after renderProcesses are created
            // NOTE: createVertexShaderPathResources() is called after graphicsPipelineLayout is created
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Graphics Command Pool" );
            VkCommandPoolCreateInfo commandPoolCreateInfo{
                .sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
                .pNext            = nullptr,
                .flags            = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
                .queueFamilyIndex = context->getVkGraphicsQueueFamilyIndex()
            };
            PLOG_THROW_FN_VK( vkCreateCommandPool(
                context->getVkDevice(), &commandPoolCreateInfo, nullptr, &vkGraphicsCommandPool
            ) )
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Transfer Command Pool" );
            VkCommandPoolCreateInfo commandPoolCreateInfo{
                .sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
                .pNext            = nullptr,
                .flags            = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
                .queueFamilyIndex = context->getVkTransferQueueFamilyIndex()
            };
            PLOG_THROW_FN_VK( vkCreateCommandPool(
                context->getVkDevice(), &commandPoolCreateInfo, nullptr, &vkTransferCommandPool
            ) )
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Descriptor Pool" );
            std::array<VkDescriptorPoolSize, 3u> descriptorPoolSizes{};
 
            descriptorPoolSizes.at( 0 ) = {
                .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                .descriptorCount =
                    static_cast<uint32_t>( MAX_FRAMES_IN_FLIGHT ) * 22  // for binding 3 and frustumUBOs + Hi-Z viewproj UBO
            };
 
            descriptorPoolSizes.at( 1 ) = { .type            = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                            .descriptorCount = (MAX_TEXTURE_COUNT + 2) * MAX_FRAMES_IN_FLIGHT };  // +2 for Hi-Z pyramid in primitive culling
 
            descriptorPoolSizes.at( 2 ) = {
                .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
                .descriptorCount =
                    static_cast<uint32_t>( MAX_FRAMES_IN_FLIGHT ) *
                    ( 83 )  // 8 for graphics + 8 for primitive culling (including Hi-Z) + 4 for binning allocator
                            // + 3 for meshlet unpacking V2 + 5 for meshlet culling + 2 for prepare draw
                            // + dispatchers + 8 materials + extra buffer
                            // + 13 for VS instanced drawing (6 binning + 3 unpacking + 4 prepare draw)
            };
 
            VkDescriptorPoolCreateInfo descriptorPoolCreateInfo{
                .sType   = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
                .pNext   = nullptr,
                .flags   = 0,
                .maxSets = static_cast<uint32_t>( MAX_FRAMES_IN_FLIGHT ) *
                           (7+1+3),  // One for graphics, seven for compute, +3 for VS instanced drawing pipeline
                .poolSizeCount = static_cast<uint32_t>( descriptorPoolSizes.size() ),
                .pPoolSizes    = descriptorPoolSizes.data()
            };
 
            VulkanHelper::createDescriptorPool(
                context->getVkDevice(), &descriptorPoolCreateInfo, nullptr, &descriptorPool, "Main"
            );
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Timeline Synchronizer" );
            timelineSynchronizer_ = std::make_unique<TimelineSynchronizer>(context, MAX_FRAMES_IN_FLIGHT);
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Render Finished Semaphores" );
            renderFinishedSemaphores.resize( headset->getSwapchainRenderTargets().size() );
            for ( auto & sem : renderFinishedSemaphores )
            {
                VkSemaphoreCreateInfo semInfo{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
                vkCreateSemaphore( context->getVkDevice(), &semInfo, nullptr, &sem );
            }
        }
    }
 
    Renderer::~Renderer()
    {
        // TODO: Check if this is actually necessary during destruction as i dont think it is necessary. If it
        // isn't remove it and note in comment that it needs to be cleaned up manually.
        cleanup();
    }
 
    void Renderer::allocateDescriptors()
    {
        TRACY_ZONE_SCOPED_NAMED( "Allocate Descriptors" );

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Descriptor Set Layout Bindings" );
            auto builder = LayoutBindingsBuilder();
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
    #define MESH_STAGE VK_SHADER_STAGE_MESH_BIT_EXT
    #define VERTEX_STAGE VK_SHADER_STAGE_VERTEX_BIT // though not used in mesh shader path
#else
    #define MESH_STAGE VK_SHADER_STAGE_VERTEX_BIT
    #define VERTEX_STAGE VK_SHADER_STAGE_VERTEX_BIT
#endif
 
            // VS path needs VERTEX_BIT for bindings 1 (VIEW_PROJECTION_UBO) and 5 (PER_OBJECT_SSBO)
            constexpr VkShaderStageFlags MESH_AND_VERTEX_STAGE = MESH_STAGE | VK_SHADER_STAGE_VERTEX_BIT;
 
            builder.addStorageBuffer( ShaderStage::Graphics::VERTEX_BUFFER, MESH_STAGE )
                .addUniformBuffer( ShaderStage::Graphics::VIEW_PROJECTION_UBO, MESH_AND_VERTEX_STAGE )
                .addStorageBuffer( ShaderStage::Graphics::MESHLET_BUFFER, MESH_STAGE )
                .addStorageBuffer( ShaderStage::Graphics::MESHLET_TRIANGLES_BUFFER, MESH_STAGE )
                .addStorageBuffer( ShaderStage::Graphics::BINNED_VISIBLE_MESHLET_INDEX_BUFFER, MESH_STAGE )
                .addStorageBuffer( ShaderStage::Graphics::PER_OBJECT_SSBO, MESH_AND_VERTEX_STAGE )
                .addStorageBuffer( ShaderStage::Graphics::MESH_BUFFER, MESH_STAGE )
                .addStorageBuffer( ShaderStage::Graphics::MESH_PRIMITIVE_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MESHLET_TO_OBJECT_MAP_BUFFER, MESH_STAGE )
                // MATERIAL DATA
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_DIFFUSE_FLAT_COLOR, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_DIFFUSE_SHADER, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_MOVABLE_DIFFUSE, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_NORMALS, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_L0, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_L1, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_L2, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_DYNAMIC_TEXTURES, VK_SHADER_STAGE_FRAGMENT_BIT )
                .addStorageBuffer( ShaderStage::Graphics::MATERIAL_STATIC_LIGHTMAP, VK_SHADER_STAGE_FRAGMENT_BIT )
                // VS instanced drawing: instance ID buffer for vertex shader lookup
                // NOTE: Must be added BEFORE texture array because texture array uses
                // VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT which must be last
                .addStorageBuffer( ShaderStage::Graphics::VS_INSTANCE_IDS, VK_SHADER_STAGE_VERTEX_BIT )
                .addTextureBuffer( ShaderStage::Graphics::TEXTURE_ARRAY, VK_SHADER_STAGE_FRAGMENT_BIT )
                .build();
 
#undef MESH_STAGE
#undef VERTEX_STAGE
 
            VkDescriptorSetLayoutBindingFlagsCreateInfo bindingFlagsInfo{
                .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
                .bindingCount  = static_cast<uint32_t>( builder.getFlags().size() ),
                .pBindingFlags = builder.getFlags().data()
            };
 
            // Now create the descriptor set layout.
            VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo{
                .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
                .pNext        = &bindingFlagsInfo,
                .flags        = 0,
                .bindingCount = static_cast<uint32_t>( builder.getBindings().size() ),
                .pBindings    = builder.getBindings().data()
            };
            VulkanHelper::createDescriptorSetLayout(
                context->getVkDevice(),
                &descriptorSetLayoutCreateInfo,
                nullptr,
                &graphicsDescriptorSetLayout,
                "Graphics"
            );
            assert(graphicsDescriptorSetLayout != nullptr);
        }

        {
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
            TRACY_ZONE_SCOPED_NAMED( "Create Push Constant Range" );
            VkPushConstantRange pushConstantRange{ .stageFlags = VK_SHADER_STAGE_MESH_BIT_EXT |
                                                                 VK_SHADER_STAGE_FRAGMENT_BIT,
                                                   .offset = 0,
                                                   .size   = sizeof( TaskConstants ) };
            pushConstants = { pushConstantRange };
#endif
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Pipeline Layout" );
            VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo{
                .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
                .setLayoutCount         = 1u,
                .pSetLayouts            = &graphicsDescriptorSetLayout,
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
                .pushConstantRangeCount = static_cast<uint32_t>( pushConstants.size() ),
                .pPushConstantRanges    = pushConstants.data()
#else
                .pushConstantRangeCount = 0,
                .pPushConstantRanges    = nullptr
#endif
            };
            VulkanHelper::createPipelineLayout(
                context->getVkDevice(),
                &pipelineLayoutCreateInfo,
                nullptr,
                &graphicsPipelineLayout,
                "Graphics"
            );
        }
 
        // Create vertex shader path pipeline (needs graphicsPipelineLayout)
        createVertexShaderPathResources();
        createVSInstancedDrawingResources();  // VS instanced drawing compute passes
 
        // Geometry and material buffers are now managed by RenderingDataManager
        // They will be populated automatically when scenes load via the event-driven system
        // For initial empty scene, RenderingDataManager creates placeholder buffers
 
        // Verify RenderingDataManager buffers were created successfully
        PLOGI << "RenderingDataManager buffer creation complete:";
        PLOGI << "  Vertex buffer: "
              << VulkanHelper::strIsValid( renderingDataManager->getVertexBuffer().getBuffer() );
        PLOGI << "  Meshlet buffer: "
              << VulkanHelper::strIsValid( renderingDataManager->getMeshletBuffer().getBuffer() );
        PLOGI << "  Triangle buffer: "
              << VulkanHelper::strIsValid( renderingDataManager->getTriangleBuffer().getBuffer() );
        PLOGI << "  Primitive render data buffer: "
              << VulkanHelper::strIsValid( renderingDataManager->getPrimitiveRenderDataBuffer().getBuffer() );

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Render Processes" );
            renderProcesses.resize( MAX_FRAMES_IN_FLIGHT );
 
            for ( uint32_t eyeIndex = 0u; eyeIndex < renderProcesses.size(); eyeIndex++ )
            {
                {
                    TRACY_ZONE_SCOPED_NAMED( "Create RenderProcess" );
                    PLOGI << "Creating RenderProcess " << eyeIndex;
                    renderProcesses.at( eyeIndex ) = new RenderProcess(
                        context,
                        context->getUniformBufferOffsetAlignment(),
                        vkGraphicsCommandPool,
                        vkTransferCommandPool,
                        descriptorPool,
                        graphicsDescriptorSetLayout,
                        eyeIndex,
                        this,
                        engine
                    );
                }
            }
        }
 
        // Hi-Z descriptor sets need renderProcesses to exist for the image views
        createHiZMipDescriptorSets();     // Legacy multi-pass
        createHiZSPDDescriptorSets();     // SPD single-pass

        {
            TRACY_ZONE_SCOPED_NAMED( "Create Graphics Pipelines" );
            VkVertexInputBindingDescription vertexInputBindingDescription{
                .binding = 0u, .stride = sizeof( Vertex ), .inputRate = VK_VERTEX_INPUT_RATE_VERTEX
            };
 
            VkVertexInputAttributeDescription vertexInputAttributePosition{
                .location = 0u,
                .binding  = 0u,
                .format   = VK_FORMAT_R32G32B32_SFLOAT,
                .offset   = offsetof( Vertex, position )
            };
 
            VkVertexInputAttributeDescription vertexInputAttributeNormal{
                .location = 1u,
                .binding  = 0u,
                .format   = VK_FORMAT_R32G32B32_SFLOAT,
                .offset   = offsetof( Vertex, normal ),
            };
 
            VkVertexInputAttributeDescription vertexInputAttributeTextureCoordinate{
                .location = 2u,
                .binding  = 0u,
                .format   = VK_FORMAT_R32G32_SFLOAT,
                .offset   = offsetof( Vertex, textureCoordinate )
            };
 
            // Create graphics pipelines from static PipelineNames configuration
            {
                TRACY_ZONE_SCOPED_NAMED( "Create Graphics Pipelines" );
 
                // List of all pipeline types to create
                const std::vector<PipelineNames> pipelinesToCreate = {
                    DIFFUSE_FLAT_COLOR,
                    DIFFUSE_SHADER,
                    MOVABLE_DIFFUSE_SHADER,
                    NORMALS_SHADER,
                    L0_SHADER,
                    L1_SHADER,
                    L2_SHADER,
                    DYNAMIC_TEXTURES,
                    STATIC_LIGHTMAP
                };
 
                graphicsPipelines.reserve( pipelinesToCreate.size() );
 
                // Create mesh shader specialization with actual screen resolution from headset
                VkExtent2D eyeResolution = headset->getEyeResolution(0);
                MeshShaderSpecializationData meshSpecData(
                    static_cast<float>(eyeResolution.width),
                    static_cast<float>(eyeResolution.height)
                );
                PLOGI << "Mesh shader screen resolution: " << eyeResolution.width << "x" << eyeResolution.height;
 
                for ( PipelineNames pipelineName : pipelinesToCreate )
                {
                    PipelineConfig config = getPipelineConfig( pipelineName );
                    TRACY_ZONE_SCOPED_NAMED_D( "Create Pipeline " << static_cast<int>(pipelineName) );
 
                    GraphicsPipeline * pipeline = nullptr;
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
                    pipeline = new GraphicsPipeline(
                        context->getVkDevice(),
                        context->getMultisampleCount(),
                        graphicsPipelineLayout,
                        VK_NULL_HANDLE,  // Use dynamic rendering (vkCmdBeginRendering)
                        config.meshShaderPath,
                        config.fragmentShaderPath,
                        {},
                        { vertexInputAttributePosition,
                          vertexInputAttributeNormal,
                          vertexInputAttributeTextureCoordinate },
                        config.pipelineData,
                        &meshSpecData  // Pass screen resolution for small triangle culling
                    );
#else
                    pipeline = new GraphicsPipeline(
                        context->getVkDevice(),
                        context->getMultisampleCount(),
                        graphicsPipelineLayout,
                        headset->getRenderPass(),
                        Path::engineShaders() / "Output/Placeholder.vert.spv",
                        Path::engineShaders() / "Output/Placeholder.frag.spv"
                    );
#endif
 
                    graphicsPipelines.push_back( pipeline );
                    pipelinesByName[pipelineName] = pipeline;
                }
 
                PLOGI << "Created " << graphicsPipelines.size() << " graphics pipelines";
            }
 
            // Create depth-only pipeline variants for Z-prepass (Pass 1)
            // These have colorAttachmentCount = 0, enabling "Double-Speed Z" on NVIDIA/AMD
            {
                TRACY_ZONE_SCOPED_NAMED( "Create Depth-Only Pipelines" );
 
                depthOnlyGraphicsPipelines.reserve( graphicsPipelines.size() );
 
                // Depth-only fragment shader path
                const auto depthOnlyFragPath = Path::engineShaders() / "Output/depth_only.frag.spv";
 
                VkExtent2D eyeResolution = headset->getEyeResolution(0);
                MeshShaderSpecializationData meshSpecData(
                    static_cast<float>(eyeResolution.width),
                    static_cast<float>(eyeResolution.height)
                );
 
                // Create depth-only variants for each pipeline type
                const std::vector<PipelineNames> pipelinesToCreate = {
                    DIFFUSE_FLAT_COLOR,
                    DIFFUSE_SHADER,
                    MOVABLE_DIFFUSE_SHADER,
                    NORMALS_SHADER,
                    L0_SHADER,
                    L1_SHADER,
                    L2_SHADER,
                    DYNAMIC_TEXTURES,
                    STATIC_LIGHTMAP
                };
 
                for ( PipelineNames pipelineName : pipelinesToCreate )
                {
                    PipelineConfig config = getPipelineConfig( pipelineName );
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
                    GraphicsPipeline * depthOnlyPipeline = new GraphicsPipeline(
                        context->getVkDevice(),
                        context->getMultisampleCount(),
                        graphicsPipelineLayout,
                        VK_NULL_HANDLE,  // Use dynamic rendering
                        config.meshShaderPath,
                        depthOnlyFragPath.string(),  // Use depth-only fragment shader
                        {},
                        {},
                        config.pipelineData,
                        &meshSpecData,
                        true  // depthOnly = true
                    );
                    depthOnlyGraphicsPipelines.push_back( depthOnlyPipeline );
#endif
                }
 
                PLOGI << "Created " << depthOnlyGraphicsPipelines.size() << " depth-only pipelines for Z-prepass";
            }
 
            // Build pipeline index map for fast lookup
            {
                TRACY_ZONE_SCOPED_NAMED( "Build Pipeline Index Map" );
                pipelineIndices.clear();
                for ( uint32_t i = 0; i < graphicsPipelines.size(); ++i )
                {
                    pipelineIndices[graphicsPipelines[i]] = i;
                }
            }
        }
 
        // setup tracy with calibrated timestamps
        {
#ifdef ENABLE_TRACY
            TRACY_ZONE_SCOPED_NAMED( "Setup Tracy Profiling" );
            // Get function pointers for calibrated timestamps
            for ( size_t i = 0; i < renderProcesses.size(); i++ )
            {
                {
                    TRACY_ZONE_SCOPED_NAMED( "Create Tracy Context" );
                    VkCommandBuffer commandBuffer = renderProcesses[i]->getGraphicsCommandBuffer();
 
                    TracyVkCtx tracyContext = TracyVkContext(
                        context->getVkPhysicalDevice(),
                        context->getVkDevice(),
                        context->getGraphicsQueue(),
                        commandBuffer
                    );
 
                    std::stringstream contextNameStream{};
                    contextNameStream << "Vulkan Context " << i;
                    std::string contextName = contextNameStream.str();
 
                    TracyVkContextName( tracyContext, contextName.c_str(), contextName.size() );
 
                    tracyVkContext.push_back( tracyContext );
                }
            }
#endif
        }
    }
 
    void Renderer::initializeGpuBuffers() const
    {
        TRACY_ZONE_SCOPED_NAMED( "Initialize GPU Buffers" );
        PLOGI << "Populating staging buffers with initial data for all frames";
 
        // Skip initialization if engine is not available (e.g., during testing)
        if (engine == nullptr) {
            PLOGD << "Engine is null, skipping GPU buffer initialization (test mode)";
            return;
        }
 
        for ( RenderProcess * renderProcess : renderProcesses )
        {
            {
                TRACY_ZONE_SCOPED_NAMED( "Update Render Process Data" );
                renderProcess->updateSSBO( this );
                renderProcess->updateMeshletDataBuffer();
                renderProcess->updateMeshRenderingData();
 
                renderProcess->uploadSSBOStagingBuffer();
                renderProcess->uploadMeshRenderingStagingData();
            }
        }
    }
 
    void Renderer::prepareTransferSubmission( const uint32_t frameIndex ) const
    {
        TRACY_ZONE_SCOPED_NAMED( "Prepare Transfer Submission" );
        std::vector<VkBufferMemoryBarrier2> barriers{};
 
        // Get the transfer command buffer for the SPECIFIED frame
        VkCommandBuffer transferCommandBuffer = renderProcesses[frameIndex]->getTransferCommandBuffer();
 
        // Reset and begin recording
        {
            TRACY_ZONE_SCOPED_NAMED( "Record transfer command buffer n+1" );
            PLOG_RETURN_FN_VK( vkResetCommandBuffer( transferCommandBuffer, 0u ) )
 
            VkCommandBufferBeginInfo commandBufferBeginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
            PLOG_RETURN_FN_VK( vkBeginCommandBuffer( transferCommandBuffer, &commandBufferBeginInfo ) )
        }
 
        // Record the copy commands
        {
            TRACY_VK_ZONE_C(
                getCurrentTracyVkContext(), transferCommandBuffer, "Transfer Buffer Copies", Colors::Green
            )
            for ( const auto & copyObject : syncCopyObjects )
            {
                VkBufferCopy copyRegion{};
                copyRegion.srcOffset = copyObject.copyObject.srcOffset;
                copyRegion.dstOffset = copyObject.copyObject.dstOffset;
                copyRegion.size = copyObject.copyObject.size;
                if (copyObject.copyObject.size == 0)
                {
                    PLOGW << "Trying to copy copy object of size 0. Skipping copy command";
                    continue;
                }
                vkCmdCopyBuffer(
                    transferCommandBuffer,
                    copyObject.copyObject.sourceBuffer,
                    copyObject.copyObject.destinationBuffer,
                    1,
                    &copyRegion
                );
            }
 
            // NEW: Memory barrier after copies to ensure writes are complete before release.
            VkMemoryBarrier2 copyBarrier{ .sType         = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                                          .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                                          .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                                          .dstStageMask  = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
                                          .dstAccessMask = VK_ACCESS_2_NONE };
 
            VkDependencyInfo copyDep{
                .sType              = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                .memoryBarrierCount = 1,
                .pMemoryBarriers    = &copyBarrier,
            };
            vkCmdPipelineBarrier2( transferCommandBuffer, &copyDep );
 
            // NEW: Record release barriers here (moved from render()).
            // For each syncCopyObject, create a release barrier. Assume syncCopyObjects already have the
            // needed data.
            std::vector<VkBufferMemoryBarrier2> releaseBarriers;
            for ( const auto & obj : syncCopyObjects )
            {
                VkBufferMemoryBarrier2 rel = {
                    .sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
                    .srcStageMask        = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                    .srcAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                    .dstStageMask        = VK_PIPELINE_STAGE_2_NONE,  // Not needed for release
                    .dstAccessMask       = VK_ACCESS_2_NONE,
                    .srcQueueFamilyIndex = context->getVkTransferQueueFamilyIndex(),
                    .dstQueueFamilyIndex = context->getVkGraphicsQueueFamilyIndex(),
                    .buffer              = obj.copyObject.destinationBuffer,
                    .offset              = 0,
                    .size                = VK_WHOLE_SIZE,
                };
                releaseBarriers.push_back( rel );
            }
            if ( !releaseBarriers.empty() )
            {
                VkDependencyInfo dep{
                    .sType                    = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .bufferMemoryBarrierCount = static_cast<uint32_t>( releaseBarriers.size() ),
                    .pBufferMemoryBarriers    = releaseBarriers.data(),
                };
                vkCmdPipelineBarrier2( transferCommandBuffer, &dep );
            }
 
            if ( !barriers.empty() )
            {
                VkDependencyInfo dependencyInfo{
                    .sType                    = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .bufferMemoryBarrierCount = static_cast<uint32_t>( barriers.size() ),
                    .pBufferMemoryBarriers    = barriers.data(),
                };
                vkCmdPipelineBarrier2( transferCommandBuffer, &dependencyInfo );
            }
 
            if ( !syncCopyObjects.empty() )
            {
                VkMemoryBarrier2 memoryBarrier{ .sType         = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                                                .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                                                .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                                                .dstStageMask  = VK_PIPELINE_STAGE_2_NONE,
                                                .dstAccessMask = 0 };
 
                VkDependencyInfo dependencyInfo{
                    .sType              = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .memoryBarrierCount = 1,
                    .pMemoryBarriers    = &memoryBarrier,
                };
                vkCmdPipelineBarrier2( transferCommandBuffer, &dependencyInfo );
            }
 
            vkEndCommandBuffer( transferCommandBuffer );
        }
    }
 
    void Renderer::updateViewMatrix()
    {
        TRACY_ZONE_SCOPED_NAMED( "Renderer::updateViewMatrix" );
        // Always update view-projection matrices for rendering (follows camera)
        getCurrentRenderProcess()->updateEyeViewProjectionMatrices( headset );
 
        // Only update culling data (frustum planes, Hi-Z VP) if not frozen
        // When frozen, culling uses the viewpoint from when freeze was enabled
        if ( !freezeCulling_ )
        {
            getCurrentRenderProcess()->updateFrustumUBOData( headset );
            getCurrentRenderProcess()->updateHiZViewProjectionData( headset );  // Per-frame Hi-Z data
        }
    }
 
    void Renderer::setFreezeCulling( bool freeze )
    {
        freezeCulling_ = freeze;
        PLOGI << "Culling freeze " << ( freeze ? "enabled" : "disabled" );
    }
 
    void Renderer::uploadFrameData( float time )
    {
        TRACY_ZONE_SCOPED_FUNCTION;
        updateCpuRenderResources( time );
    }
 
    void Renderer::recordTransfer( float time )
    {
        TRACY_ZONE_SCOPED_FUNCTION;
 
        RenderProcess *       currentRenderProcess  = getCurrentRenderProcess();
        const VkCommandBuffer transferCommandBuffer = currentRenderProcess->getTransferCommandBuffer();
 
        // Begin transfer command buffer recording
        {
            TRACY_ZONE_SCOPED_NAMED( "Begin transfer command buffer" );
            PLOG_RETURN_FN_VK( vkResetCommandBuffer( transferCommandBuffer, 0u ) )
 
            constexpr VkCommandBufferBeginInfo commandBufferBeginInfo{
                .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
            };
            PLOG_RETURN_FN_VK( vkBeginCommandBuffer( transferCommandBuffer, &commandBufferBeginInfo ) )
        }
 
        // Record buffer copy commands
        {
            TRACY_ZONE_SCOPED_NAMED( "Buffer transfer processing" );
            TRACY_VK_ZONE_C(
                getCurrentTracyVkContext(), transferCommandBuffer, "Buffer Copy Operations", Colors::Green
            );
 
            for ( const auto & copyObject : syncCopyObjects )
            {
                VkBufferCopy copyRegion{};
                copyRegion.srcOffset = copyObject.copyObject.srcOffset;
                copyRegion.dstOffset = copyObject.copyObject.dstOffset;
                copyRegion.size = copyObject.copyObject.size;
                if (copyRegion.size == 0)
                {
                    PLOGW << "Trying to upload a copy buffer with size 0. Skipping copy command";
                    continue;
                }
                vkCmdCopyBuffer(
                    transferCommandBuffer,
                    copyObject.copyObject.sourceBuffer,
                    copyObject.copyObject.destinationBuffer,
                    1,
                    &copyRegion
                );
            }
 
            // Memory barrier after copies to ensure writes are complete
            if ( !syncCopyObjects.empty() )
            {
                VkMemoryBarrier2 copyBarrier{ .sType         = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                                              .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                                              .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                                              .dstStageMask  = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
                                              .dstAccessMask = VK_ACCESS_2_NONE };
 
                VkDependencyInfo copyDep{
                    .sType              = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .memoryBarrierCount = 1,
                    .pMemoryBarriers    = &copyBarrier,
                };
                vkCmdPipelineBarrier2( transferCommandBuffer, &copyDep );
 
                // Queue family ownership transfer: Release barriers from Transfer to Graphics queue
                // The acquire barriers are recorded in renderToXr() on the graphics command buffer
                std::vector<VkBufferMemoryBarrier2> releaseBarriers;
                releaseBarriers.reserve( syncCopyObjects.size() );
                for ( const auto & obj : syncCopyObjects )
                {
                    VkBufferMemoryBarrier2 rel = {
                        .sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
                        .srcStageMask        = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                        .srcAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                        .dstStageMask        = VK_PIPELINE_STAGE_2_NONE,
                        .dstAccessMask       = VK_ACCESS_2_NONE,
                        .srcQueueFamilyIndex = context->getVkTransferQueueFamilyIndex(),
                        .dstQueueFamilyIndex = context->getVkGraphicsQueueFamilyIndex(),
                        .buffer              = obj.copyObject.destinationBuffer,
                        .offset              = 0,
                        .size                = VK_WHOLE_SIZE,
                    };
                    releaseBarriers.push_back( rel );
                }
 
                VkDependencyInfo releaseDep{
                    .sType                    = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .bufferMemoryBarrierCount = static_cast<uint32_t>( releaseBarriers.size() ),
                    .pBufferMemoryBarriers    = releaseBarriers.data(),
                };
                vkCmdPipelineBarrier2( transferCommandBuffer, &releaseDep );
            }
        }

        {
            TRACY_ZONE_SCOPED_NAMED( "Texture transfer processing" );
            TRACY_VK_ZONE_C(
                getCurrentTracyVkContext(), transferCommandBuffer, "Texture Upload Commands", Colors::Orange
            )  // Orange
 
            for ( Texture * texture : renderingDataManager->getTexturesToUpload() )
            {
                TRACY_ZONE_SCOPED_NAMED("Creating texture upload command");
                PLOGI << "Recording texture transfer command for texture: " << texture->getDescriptorIndex();
                texture->createDataUploadCommand( transferCommandBuffer, this );
            }
 
            if ( !renderingDataManager->getTexturesToUpload().empty() )
            {
                TRACY_ZONE_SCOPED_NAMED( "Adding textures to upload" );
                for ( RenderProcess * renderProcessPtr : renderProcesses )
                {
                    for ( Texture * texture : renderingDataManager->getTexturesToUpload() )
                    {
                        renderProcessPtr->addTexturesToUpload( { texture }, texture->getDescriptorIndex() );
                    }
                }
            }
 
            // Textures will be cleared after graphics queue processing completes
        }
 
        // End transfer command buffer recording
        PLOG_RETURN_FN_VK( vkEndCommandBuffer( transferCommandBuffer ) )
    }
 
    void Renderer::renderToXr( size_t swapChainImageIndex, float time )
    {
        PLOGV << "Swap chain image index: " << swapChainImageIndex << " currentFrame: " << currentFrame;
        TRACY_ZONE_SCOPED_FUNCTION;
 
        // updateCpuRenderResources(time); // Moved to recordTransfer
 
        RenderProcess *                     currentRenderProcess = renderProcesses.at( currentFrame );
        std::vector<VkBufferMemoryBarrier2> acquireBarriers{};
        std::vector<BufferCopyObject>       copyObjects{};
 
        for ( const auto & [releaseBarrier, acquireBarrier, copyObject] : syncCopyObjects )
        {
            acquireBarriers.push_back( acquireBarrier );
            copyObjects.push_back( copyObject );
        }
 
        restartRenderCommandBuffers();

        {
            TRACY_ZONE_SCOPED_NAMED( "Acquire transfer resources" );
            if ( !acquireBarriers.empty() )
            {
                VkDependencyInfo acquireDependency{
                    .sType                    = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .bufferMemoryBarrierCount = static_cast<uint32_t>( acquireBarriers.size() ),
                    .pBufferMemoryBarriers    = acquireBarriers.data(),
                };
 
                vkCmdPipelineBarrier2( currentRenderProcess->getGraphicsCommandBuffer(), &acquireDependency );
            }
        }
 
        // Process texture uploads on graphics queue (after transfer data is available)
        currentRenderProcess->processTextureUpload();
 
        // Transition textures from transfer layout to shader-readable layout
        if ( !renderingDataManager->getTexturesToUpload().empty() )
        {
            TRACY_ZONE_SCOPED_NAMED( "Texture layout transitions" );
            TRACY_VK_ZONE_C(
                getCurrentTracyVkContext(),
                currentRenderProcess->getGraphicsCommandBuffer(),
                "Texture Layout Transitions",
                Colors::Blue
            )  // Blue
 
            for ( Texture * texture : renderingDataManager->getTexturesToUpload() )
            {
                VkImageMemoryBarrier2 imageBarrier{ .sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                                                    .pNext         = nullptr,
                                                    .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                                                    .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                                                    .dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
                                                    .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT,
                                                    .oldLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                                    .newLayout     = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                                                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                                                    .image               = texture->getVkImage(),
                                                    .subresourceRange    = { .aspectMask =
                                                                                 VK_IMAGE_ASPECT_COLOR_BIT,
                                                                             .baseMipLevel   = 0,
                                                                             .levelCount     = 1,
                                                                             .baseArrayLayer = 0,
                                                                             .layerCount     = 1 } };
 
                VkDependencyInfo depInfo{
                    .sType                   = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                    .pNext                   = nullptr,
                    .imageMemoryBarrierCount = 1u,
                    .pImageMemoryBarriers    = &imageBarrier,
                };
                vkCmdPipelineBarrier2( currentRenderProcess->getGraphicsCommandBuffer(), &depInfo );
            }
 
            // Now we can clear the textures to upload since processing is complete
            renderingDataManager->clearTexturesToUpload();
        }
 
        TRACY_VK_ZONE_C(
            getCurrentTracyVkContext(),
            currentRenderProcess->getGraphicsCommandBuffer(),
            "Draw Frame",
            Colors::Red
        )
 
        // Reset pipeline counters and bin offsets buffers before compute passes
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Reset Pipeline Buffers", Colors::Red )
            // Zero pipeline counters (used as atomic counters in binning allocator)
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                currentRenderProcess->getPipelineCountersBuffer().getBuffer(),
                0,
                VK_WHOLE_SIZE,
                0
            );
            // Zero bin offsets (pipeline 0 starts at offset 0, others need prefix sum)
            // TODO: Add proper prefix sum computation for multi-pipeline support
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                currentRenderProcess->getPipelineBinOffsetsBuffer().getBuffer(),
                0,
                VK_WHOLE_SIZE,
                0
            );
            // Zero primitive culling survivor counter (accumulates via atomicAdd in PrimitiveCulling)
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                counterBuffer->getBuffer(),
                0,
                sizeof(uint32_t),
                0
            );
            // Zero culling failed counter (two-pass occlusion: stores objects that failed Pass 1 Hi-Z)
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                currentRenderProcess->getCullingFailedCounterBuffer().getBuffer(),
                0,
                sizeof(uint32_t),
                0
            );
            // Zero VS indirect draw count (vertex shader path for single-meshlet geometry - legacy)
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                currentRenderProcess->getVSIndirectDrawCountBuffer().getBuffer(),
                0,
                sizeof(uint32_t),
                0
            );
            // Zero VS visible count (VS instanced drawing pipeline - PrimitiveCulling writes this)
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                currentRenderProcess->getVSVisibleCountBuffer().getBuffer(),
                0,
                sizeof(uint32_t),
                0
            );
            // Zero LOD cluster survivor count (PrimitiveCulling writes this via atomicAdd for LOD path)
            // Without this reset, garbage values cause MeshletBinningAllocator/Unpacking to read invalid data
            vkCmdFillBuffer(
                getCurrentRenderingCommandBuffer(),
                currentRenderProcess->getLodClusterSurvivorCountBuffer().getBuffer(),
                0,
                sizeof(uint32_t),
                0
            );
            // Barrier to ensure fills complete before compute passes read/write
            VkMemoryBarrier2 fillBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT
            };
            VkDependencyInfo fillDep{
                .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                .memoryBarrierCount = 1,
                .pMemoryBarriers = &fillBarrier
            };
            vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &fillDep );
        }
 
        // Update culling descriptor set with PREVIOUS frame's Hi-Z pyramid
        // The Hi-Z was generated at the end of the previous frame, so culling reads from it
        {
            const uint32_t previousFrame = (currentFrame + MAX_FRAMES_IN_FLIGHT - 1) % MAX_FRAMES_IN_FLIGHT;
            RenderProcess* previousRenderProcess = renderProcesses[previousFrame];
            currentRenderProcess->updateComputeObjectCullingDescriptorSets(
                previousRenderProcess->getHiZPyramidFullView()
            );
        }
 
        // Update LOD configuration with camera and screen info for cluster-based LOD selection
        {
            const uint32_t eyeIndex = currentRenderProcess->getEyeIndex();
            const glm::mat4 viewMatrix = headset->getEyeViewMatrix(eyeIndex);
            const glm::mat4 projMatrix = headset->getEyeProjectionMatrix(eyeIndex);
            const VkExtent2D resolution = headset->getEyeResolution(eyeIndex);
 
            // Extract camera position from inverse view matrix (column 3 of inverse = world position)
            const glm::mat4 invView = glm::inverse(viewMatrix);
            const glm::vec3 cameraPosition = glm::vec3(invView[3]);
 
            // Use default near plane for VR (0.01m is common)
            constexpr float nearPlane = 0.01f;
 
            // Update LOD config UBO
            currentRenderProcess->updateLodConfig(
                cameraPosition,
                projMatrix,
                nearPlane,
                static_cast<float>(resolution.width),
                static_cast<float>(resolution.height),
                1.0f,   // errorThresholdPixels - 1 pixel error target
                true    // ditherEnabled
            );
 
            // Upload to GPU (staged buffer)
            currentRenderProcess->uploadLodConfigBuffer();
 
            // Log LOD config once at startup
            VS_LOG_ONCE(LogLOD, Warning, "[DIAG] LOD Config: cameraPos=({:.2f},{:.2f},{:.2f}) proj11={:.4f} nearPlane={} screenSize={}x{} errorThreshold=1.0",
                       cameraPosition.x, cameraPosition.y, cameraPosition.z,
                       projMatrix[1][1], nearPlane, resolution.width, resolution.height);
        }
 
        // Stage 0: Primitive Culling - PASS 1
        // Uses previous frame's Hi-Z, may have false negatives which Pass 2 will catch
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Primitive Culling Pass 1", Colors::Red )
            const uint32_t threadCount = getObjectCullingComputePass().getThreadCount();
            const uint32_t primitiveCount = renderingDataManager->getPrimitiveCount();
 
            // Push constants: {primitiveCount, cullingPass}
            struct CullingPushConstants {
                uint32_t primitiveCount;
                uint32_t cullingPass;  // 0 = Pass 1
            } pushData = { primitiveCount, 0 };
 
            getObjectCullingComputePass().getComputePipeline()->bind( getCurrentRenderingCommandBuffer() );
            getObjectCullingComputePass().bindDescriptorSets( getCurrentRenderingCommandBuffer(), currentRenderProcess->getEyeIndex() );
            PLOGI << "Starting Pass 1 culling with " << primitiveCount << " primitives";
            VkPushConstantsInfo pushConstantsInfo = getObjectCullingComputePass().createPushConstantsInfo( sizeof( CullingPushConstants ), &pushData );
            vkCmdPushConstants2( getCurrentRenderingCommandBuffer(), &pushConstantsInfo );
            if ( primitiveCount > 0 )
            {
                vkCmdDispatch( getCurrentRenderingCommandBuffer(), ( primitiveCount + threadCount - 1 ) / threadCount, 1, 1 );
            }
        }
        {
            PLOGI << "Barrier: Primitive Culling -> Binning Allocator";
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Primitive Culling -> Binning Allocator", Colors::Red )
            Vulkan::BarrierBundle bundle;
            VkDependencyInfo dependencyInfo = getObjectCullingToMeshletUnpackingDispatchBarriers(bundle);
            vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &dependencyInfo );
        }
 
        // Stage 1: Binning Allocator
        // BinningAllocator processes both regular primitive survivors AND LOD cluster survivors
        // Total work = survivor_count + lod_cluster_survivor_count (computed in shader)
        // Dispatch bound: primitiveCount (max regular survivors) + clusterCount (max LOD cluster survivors)
        const uint32_t primitiveCount = renderingDataManager->getPrimitiveCount();
        const uint32_t clusterCount = renderingDataManager->getClusterCount();
        const uint32_t maxBinningWorkItems = primitiveCount + clusterCount;
 
        // LOD diagnostic logging (every 60 frames to avoid spam)
        static uint32_t lodDiagFrameCounter = 0;
        if (++lodDiagFrameCounter >= 60) {
            lodDiagFrameCounter = 0;
            VS_LOG(LogLOD, Warning, "[DIAG] Renderer: primitiveCount={} clusterCount={} hasLodData={} clusterGroupCount={}",
                  primitiveCount, clusterCount, renderingDataManager->hasLodData(), renderingDataManager->getClusterGroupCount());
        }
 
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Binning Allocator", Colors::Red )
            const uint32_t threadCount = getBinningAllocatorComputePass().getThreadCount();
 
            getBinningAllocatorComputePass().getComputePipeline()->bind( getCurrentRenderingCommandBuffer() );
            getBinningAllocatorComputePass().bindDescriptorSets( getCurrentRenderingCommandBuffer(), currentRenderProcess->getEyeIndex() );
            PLOGI << "Starting binning allocator with max " << primitiveCount << " primitives + " << clusterCount << " LOD clusters";
            if ( maxBinningWorkItems > 0 )
            {
                vkCmdDispatch( getCurrentRenderingCommandBuffer(), ( maxBinningWorkItems + threadCount - 1 ) / threadCount, 1, 1 );
            }
        }
        {
            PLOGI << "Barrier: Binning Allocator -> Meshlet Unpacking Dispatcher";
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Binning Allocator -> Meshlet Unpacking Dispatcher", Colors::Red )
            // Barrier to ensure binning allocator writes are visible to dispatcher
            VkMemoryBarrier2 binningBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo binningDep{
                .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                .memoryBarrierCount = 1,
                .pMemoryBarriers = &binningBarrier
            };
            vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &binningDep );
        }
        {
            PLOGI << "Meshlet Unpacking Dispatcher";
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Meshlet Unpacking Dispatcher", Colors::Red)
            getMeshletUnpackingDispatchComputePass().getComputePipeline()->bind( getCurrentRenderingCommandBuffer() );
            getMeshletUnpackingDispatchComputePass().bindDescriptorSets(currentRenderProcess->getGraphicsCommandBuffer(), currentRenderProcess->getEyeIndex());
            vkCmdDispatch( getCurrentRenderingCommandBuffer(), 1, 1, 1 );
        }
        {
            PLOGI << "Barrier: Meshlet Unpacking Dispatcher -> Meshlet Unpacking";
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Meshlet Unpacking Dispatcher -> Meshlet Unpacking", Colors::Red)
            Vulkan::BarrierBundle bundle;
            VkDependencyInfo dependencyInfo = getMeshletUnpackingDispatchToMeshletUnpackingBarriers(bundle);
            vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &dependencyInfo );
        }
 
        // Stage 2: Meshlet Unpacking (V2)
        // MeshletUnpacking reads survivor_count directly from the counter buffer (GPU-driven)
        {
            PLOGI << "Meshlet Unpacking (V2)";
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Meshlet Unpacking", Colors::Red)
            getMeshletUnpackingComputePass().getComputePipeline()->bind( getCurrentRenderingCommandBuffer() );
            getMeshletUnpackingComputePass().bindDescriptorSets( getCurrentRenderingCommandBuffer(), getCurrentRenderProcess()->getEyeIndex());
            vkCmdDispatchIndirect( getCurrentRenderingCommandBuffer(), getDispatchBuffer().getBuffer(), 0 );
        }
        // NOTE: MeshletCulling stage removed - BinningAllocator already computes per-pipeline counts
        // in pipelineCountersBuffer, which PrepareDraw now reads directly
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Meshlet Unpacking -> Prepare Draw", Colors::Red)
            // Barrier: MeshletUnpacking writes to binnedVisibleMeshletIndexBuffer
            // PrepareDraw reads from pipelineCountersBuffer (written by BinningAllocator)
            // Both are compute shader operations
            VkMemoryBarrier2 memBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{
                .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                .memoryBarrierCount = 1,
                .pMemoryBarriers = &memBarrier
            };
            vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &depInfo );
        }
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer(), "Prepare Draw", Colors::Red)
            getDrawPreparationComputePass().getComputePipeline()->bind( getCurrentRenderingCommandBuffer() );
            getDrawPreparationComputePass().bindDescriptorSets( getCurrentRenderingCommandBuffer(), getCurrentRenderProcess()->getEyeIndex() );
            vkCmdDispatch( getCurrentRenderingCommandBuffer(), 1, 1, 1 );
        }
 
        // VS Instanced Drawing Pipeline: convert ~5k VS draws to ~1 draw per geometry type
        // This reads vs_visible_instances from PrimitiveCulling and outputs instanced draw commands
        recordVSInstancedDrawingPipeline();
 
#ifdef COMPUTE_DEBUG
        // Debug logging for compute pipeline results
        {
            const uint32_t objectCount = engine->getRenderableSceneObjectCount();
            PLOGI << "[COMPUTE_DEBUG] Compute pipeline completed for " << objectCount << " objects";
            PLOGI << "[COMPUTE_DEBUG] To read back buffer values, wait for GPU completion and use ComputeDebug::readbackBuffer()";
        }
#endif
 
        // Graphics barriers and render pass - skip in COMPUTE_DEBUG mode
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        // Add barriers after compute pass (before image barriers/render pass)
        {
            TRACY_VK_ZONE_C(
                getCurrentTracyVkContext(),
                currentRenderProcess->getGraphicsCommandBuffer(),
                "Compute-Graphics Barriers",
                Colors::Turquoise
            )
            // Barrier 1: Culling compute write to mesh shader read (visible meshlet buffer)
            VkBufferMemoryBarrier2 visibleBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            visibleBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            visibleBarrier.srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            visibleBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT;
            visibleBarrier.dstAccessMask       = VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
            visibleBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            visibleBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            visibleBarrier.buffer =
                getCurrentRenderProcess()->getBinnedVisibleMeshletIndexBuffer().getBuffer();
            visibleBarrier.offset = 0;
            visibleBarrier.size   = VK_WHOLE_SIZE;
 
            // Barrier 2: Prepare draw compute write to indirect draw read (indirect buffer)
            VkBufferMemoryBarrier2 indirectBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            indirectBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            indirectBarrier.srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            indirectBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
            indirectBarrier.dstAccessMask       = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
            indirectBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            indirectBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            indirectBarrier.buffer = getCurrentRenderProcess()->getIndirectDrawBuffer().getBuffer();
            indirectBarrier.offset = 0;
            indirectBarrier.size   = VK_WHOLE_SIZE;
 
            // Barrier 3: VS indirect draw buffer (single-meshlet geometry path)
            VkBufferMemoryBarrier2 vsIndirectBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            vsIndirectBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            vsIndirectBarrier.srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            vsIndirectBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
            vsIndirectBarrier.dstAccessMask       = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
            vsIndirectBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsIndirectBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsIndirectBarrier.buffer = getCurrentRenderProcess()->getVSIndirectDrawBuffer().getBuffer();
            vsIndirectBarrier.offset = 0;
            vsIndirectBarrier.size   = VK_WHOLE_SIZE;
 
            // Barrier 4: VS indirect draw count buffer (single-meshlet geometry path)
            VkBufferMemoryBarrier2 vsCountBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            vsCountBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            vsCountBarrier.srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            vsCountBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
            vsCountBarrier.dstAccessMask       = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
            vsCountBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsCountBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsCountBarrier.buffer = getCurrentRenderProcess()->getVSIndirectDrawCountBuffer().getBuffer();
            vsCountBarrier.offset = 0;
            vsCountBarrier.size   = VK_WHOLE_SIZE;
 
            // Barrier 5: VS instanced draw commands buffer (new instanced drawing path)
            VkBufferMemoryBarrier2 vsInstancedDrawBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            vsInstancedDrawBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            vsInstancedDrawBarrier.srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            vsInstancedDrawBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
            vsInstancedDrawBarrier.dstAccessMask       = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
            vsInstancedDrawBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsInstancedDrawBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsInstancedDrawBarrier.buffer = getCurrentRenderProcess()->getVSDrawCommandsBuffer().getBuffer();
            vsInstancedDrawBarrier.offset = 0;
            vsInstancedDrawBarrier.size   = VK_WHOLE_SIZE;
 
            // Barrier 6: VS instanced draw count buffer (new instanced drawing path)
            VkBufferMemoryBarrier2 vsInstancedCountBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            vsInstancedCountBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            vsInstancedCountBarrier.srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            vsInstancedCountBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
            vsInstancedCountBarrier.dstAccessMask       = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
            vsInstancedCountBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsInstancedCountBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            vsInstancedCountBarrier.buffer = getCurrentRenderProcess()->getVSDrawCountBuffer().getBuffer();
            vsInstancedCountBarrier.offset = 0;
            vsInstancedCountBarrier.size   = VK_WHOLE_SIZE;
 
            VkBufferMemoryBarrier2 barriers[] = { visibleBarrier, indirectBarrier, vsIndirectBarrier, vsCountBarrier, vsInstancedDrawBarrier, vsInstancedCountBarrier };
 
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.bufferMemoryBarrierCount = 6;
            depInfo.pBufferMemoryBarriers    = barriers;
            vkCmdPipelineBarrier2( currentRenderProcess->getGraphicsCommandBuffer(), &depInfo );
        }
 
        recordXrSwapchainImageWritableBarrier( swapChainImageIndex );
        recordRenderPass( swapChainImageIndex );
        // Generate Hi-Z pyramid for occlusion culling (uses depth from just-completed render pass)
        recordHiZGeneration();
 
        // =====================================================================
        // TWO-PASS OCCLUSION CULLING - PASS 2
        // =====================================================================
        // Pass 2 re-tests objects that failed Pass 1 Hi-Z against the NEW Hi-Z
        // (generated from Pass 1 rendering). This catches objects that were
        // incorrectly culled due to camera movement (temporal disocclusion).
        //
        // Note: Pass 2 survivors are APPENDED to culling_survivors (via atomicAdd
        // to cull_count). We then re-run the full pipeline (binning, unpacking,
        // prepare draw) for ALL survivors and render everything with LOAD_OP_CLEAR.
        // The resolve overwrites the swapchain with the complete final image.
        // =====================================================================
        recordPass2Culling( swapChainImageIndex );
 
        // Synchronize swapchain image for MirrorView blit and SteamVR compositor copy.
        // This makes the rendered data available for TRANSFER_READ operations while
        // keeping the image in COLOR_ATTACHMENT_OPTIMAL as required by OpenXR spec.
        recordXrSwapchainImageFinishedWritingBarrier( swapChainImageIndex );
#endif
 
        TRACY_VK_COLLECT( getCurrentTracyVkContext(), currentRenderProcess->getGraphicsCommandBuffer() )
    }
 
    /*void Renderer::resetCounterBuffer() const
    {
        const VkBufferMemoryBarrier2 bufferFillBarrier{
            .sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
            .pNext               = nullptr,
            .srcStageMask        = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
            .srcAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT,
            .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            .dstAccessMask       = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .buffer              = getCurrentRenderProcess()->getMeshletCounterBuffer().getBuffer(),
            .offset              = 0,
            .size                = VK_WHOLE_SIZE,
        };
 
        // Reset the draw counter buffer to 0 for the current frame
        vkCmdFillBuffer(
            getCurrentRenderingCommandBuffer(),
            getCurrentRenderProcess()->getMeshletCounterBuffer().getBuffer(),
            0,
            VK_WHOLE_SIZE,
            0
        );
 
        VkDependencyInfo dependencyInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
        dependencyInfo.bufferMemoryBarrierCount = 1;
        dependencyInfo.pBufferMemoryBarriers    = &bufferFillBarrier;
        vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &dependencyInfo );
    }
 
    void Renderer::recordComputeMeshletCulling()
    {
        TRACY_ZONE_SCOPED_NAMED( "Compute Meshlet Culling Pass" )
 
        const VkCommandBuffer commandBuffer = getCurrentRenderProcess()->getGraphicsCommandBuffer();
        TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Meshlet Culling Compute", Colors::Purple )  // Purple
 
        resetCounterBuffer();
 
        // Bind compute pipeline and descriptor sets
        objectCullingComputePipeline->bind( commandBuffer );
        const VkDescriptorSet computeDescriptorSet =
            getCurrentRenderProcess()->getComputeCullingDescriptorSet();
        vkCmdBindDescriptorSets(
            commandBuffer,
            VK_PIPELINE_BIND_POINT_COMPUTE,
            computeMeshletCullingPipelineLayout,
            0,
            1,
            &computeDescriptorSet,
            0,
            nullptr
        );
 
        // dispatch compute shader
        const uint32_t numObjects =
            static_cast<uint32_t>( engine->getSceneManager()->getGameObjectCount() );
        PLOGI << "Dispatching Meshlet culling compute shader with " << numObjects << " objects";
        if ( numObjects > 0 )
        {
            const uint32_t numWorkgroups = ( numObjects + 255 ) / 256;  // Divide by 256, round up
            vkCmdDispatch( commandBuffer, numWorkgroups, 1, 1 );
        }
 
        // Debug: Read back the draw counter value
        PLOGI << "Dispatched compute shader for culling. Draw counter buffer at "
              << getCurrentRenderProcess()->getMeshletCounterBuffer().getBuffer();
    }*/
 
    /*void Renderer::recordComputeDrawCommands() const
    {
        VkCommandBuffer cmdBuffer = getCurrentRenderingCommandBuffer();
 
        TRACY_VK_ZONE_C( tracyVkContext[currentFrame], cmdBuffer, "Compute Draw Commands", Colors::Cyan );
 
        // meshlet counter buffer
        VkBufferMemoryBarrier2 bufferBarrier{
            .sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
            .pNext               = nullptr,
            .srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            .srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
            .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            .dstAccessMask       = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .buffer              = getCurrentRenderProcess()->getMeshletCounterBuffer().getBuffer(),
            .offset              = 0,
            .size                = VK_WHOLE_SIZE,
        };
 
        VkDependencyInfo dependencyInfo{ .sType                    = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
                                         .bufferMemoryBarrierCount = 1u,
                                         .pBufferMemoryBarriers    = &bufferBarrier };
        vkCmdPipelineBarrier2( cmdBuffer, &dependencyInfo );
 
        prepareDrawsComputePipeline->bind( cmdBuffer );
        VkDescriptorSet prepareDrawComputeDescriptorSet =
            getCurrentRenderProcess()->getComputePrepareDrawDescriptorSet();
        vkCmdBindDescriptorSets(
            cmdBuffer,
            VK_PIPELINE_BIND_POINT_COMPUTE,
            prepareDrawsComputePipelineLayout,
            0,
            1,
            &prepareDrawComputeDescriptorSet,
            0,
            nullptr
        );
 
        // Dispatch one thread per pipeline
        // vkCmdDispatchIndirect()
        vkCmdDispatch( getCurrentRenderProcess()->getGraphicsCommandBuffer(), MAX_PIPELINES, 1, 1 );
    }*/
 
    void Renderer::submitInitialTransfers()
    {
        TRACY_ZONE_SCOPED_NAMED( "Submit Initial Transfers" );
        PLOGI << "Submitting initial transfers for all frames in flight";
 
        for ( uint32_t frameIndex = 0; frameIndex < MAX_FRAMES_IN_FLIGHT; frameIndex++ )
        {
            {
                TRACY_ZONE_SCOPED_NAMED( "Submit Initial Transfer Frame" );
                // First, record the command buffer using the data populated in initializeGpuBuffers()
                prepareTransferSubmission( frameIndex );
 
                RenderProcess * currentProcess    = renderProcesses[frameIndex];
                VkCommandBuffer transferCmdBuffer = getCurrentTransferCommandBuffer();
 
                // Use the new QueueSubmitBuilder for clean submission
                uint64_t signalValue = timelineSynchronizer_->getStageValue(
                    frameIndex, PipelineStage::TransferComplete);
 
                PLOGI << "Submitting initial transfer for frame " << frameIndex << " signaling value "
                      << signalValue;
 
                QueueSubmitBuilder builder(*timelineSynchronizer_, frameIndex);
                VkResult result = builder
                    .withCommandBuffer(transferCmdBuffer)
                    .signalStage(PipelineStage::TransferComplete)
                    .submit(context->getTransferQueue(), currentProcess->getTransferCompleteFence());
 
                if (result != VK_SUCCESS)
                {
                    PLOGE << "Failed to submit initial transfer for frame " << frameIndex;
                }
                currentProcess->setTransferFenceSubmitted( true );
            }
        }
 
        // Wait for all initial fences to ensure completion before main loop
        {
            TRACY_ZONE_SCOPED_NAMED( "Wait for Initial Transfer Completion" );
            for ( uint32_t frameIndex = 0; frameIndex < MAX_FRAMES_IN_FLIGHT; frameIndex++ )
            {
                {
                    TRACY_ZONE_SCOPED_NAMED( "Wait for Transfer Fence" );
                    RenderProcess * process = renderProcesses[frameIndex];
                    vkWaitForFences(
                        context->getVkDevice(), 1, &process->getTransferCompleteFence(), VK_TRUE, UINT64_MAX
                    );
                    vkResetFences( context->getVkDevice(), 1, &process->getTransferCompleteFence() );
                    process->setTransferFenceSubmitted( false );
                }
            }
        }
 
        renderedFrameCounter = MAX_FRAMES_IN_FLIGHT;
        PLOGI << "All initial transfers submitted.";
    }
 
    void Renderer::submitTransfer()
    {
        TRACY_ZONE_SCOPED_NAMED( "Submit Transfer" );
        RenderProcess * transferProcess = renderProcesses[currentFrame];
 
        if ( transferProcess->getTransferFenceSubmitted() )
        {
            {
                TRACY_ZONE_SCOPED_NAMED( "Wait for Transfer Fence" );
                vkWaitForFences(
                    context->getVkDevice(),
                    1,
                    &transferProcess->getTransferCompleteFence(),
                    VK_TRUE,
                    UINT64_MAX
                );
                vkResetFences( context->getVkDevice(), 1, &transferProcess->getTransferCompleteFence() );
                transferProcess->setTransferFenceSubmitted( false );
            }
 
            // Process deferred buffer deletions AFTER fence wait to ensure
            // previous GPU work using this frame slot is complete
            renderingDataManager->processPendingDeletions();
 
            // Cleanup staging buffers AFTER fence wait - these buffers were used
            // by the transfer command buffer that just completed
            transferProcess->cleanupStagingBuffer();
        }
 
        // Use QueueSubmitBuilder for clean, correct synchronization
        // Wait for resource reuse: wait for the frame that last used this slot to complete graphics
        QueueSubmitBuilder builder(*timelineSynchronizer_, renderedFrameCounter);
 
        builder.waitForResourceReuse(
            PipelineStage::GraphicsComplete,
            VK_PIPELINE_STAGE_2_TRANSFER_BIT
        );
 
        uint64_t signalValue = timelineSynchronizer_->getStageValue(
            renderedFrameCounter, PipelineStage::TransferComplete);
        PLOGI << "Transfer: frame " << renderedFrameCounter << " signal " << signalValue;
 
        VkResult result = builder
            .withCommandBuffer(transferProcess->getTransferCommandBuffer())
            .signalStage(PipelineStage::TransferComplete)
            .submit(context->getTransferQueue(), transferProcess->getTransferCompleteFence());
 
        if (result != VK_SUCCESS)
        {
            PLOGE << "Failed to submit transfer for frame " << renderedFrameCounter;
        }
 
        transferProcess->setTransferFenceSubmitted( true );
    }
 
    void Renderer::submitGraphics( uint32_t swapchainImageIndex, VkSemaphore mirrorAcquireSemaphore )
    {
        TRACY_ZONE_SCOPED_NAMED( "Submit Graphics" );
        RenderProcess * graphicsProcess = getCurrentRenderProcess();
 
        {
            TRACY_ZONE_SCOPED_NAMED( "End Graphics Command Buffer" );
            vkEndCommandBuffer( graphicsProcess->getGraphicsCommandBuffer() );
        }
 
        // Get the binary semaphore for presentation
        VkSemaphore binarySemaphore = renderFinishedSemaphores[swapchainImageIndex];
        if ( binarySemaphore == VK_NULL_HANDLE )
        {
            PLOGE << "Invalid render finished semaphore";
        }
 
        // Use QueueSubmitBuilder for clean, unified submission
        // This combines the timeline signal AND binary semaphore signal in a single submit
        QueueSubmitBuilder builder(*timelineSynchronizer_, renderedFrameCounter);
 
        // Wait for transfer completion from current frame
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        builder.waitForCurrent(
            PipelineStage::TransferComplete,
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT |
            VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_2_TRANSFER_BIT
        );
        // Wait for previous frame's Hi-Z generation to complete before culling reads it.
        // Hi-Z is generated at the end of the graphics pass, so we wait for GraphicsComplete.
        // Without this, the culling compute shader may read incomplete Hi-Z data causing flickering.
        if (renderedFrameCounter > 0) {
            builder.waitForPrevious(
                PipelineStage::GraphicsComplete,
                VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT
            );
        }
#else
        builder.waitForCurrent(
            PipelineStage::TransferComplete,
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT |
            VK_PIPELINE_STAGE_2_TRANSFER_BIT
        );
#endif
 
        // Wait for mirror acquire semaphore if provided
        if ( mirrorAcquireSemaphore != VK_NULL_HANDLE )
        {
            builder.waitForBinary(mirrorAcquireSemaphore, VK_PIPELINE_STAGE_2_TRANSFER_BIT);
        }
 
        uint64_t signalValue = timelineSynchronizer_->getStageValue(
            renderedFrameCounter, PipelineStage::GraphicsComplete);
        PLOGI << "Submitting graphics frame " << renderedFrameCounter << " signaling " << signalValue;
 
        // Single submit that signals timeline semaphore, and binary semaphore only if presenting
        builder.withCommandBuffer(graphicsProcess->getGraphicsCommandBuffer())
               .signalStage(PipelineStage::GraphicsComplete);
 
        // Only signal binary semaphore if we're going to present (mirror view was rendered)
        if ( mirrorAcquireSemaphore != VK_NULL_HANDLE )
        {
            builder.signalBinary(binarySemaphore);  // For vkQueuePresentKHR
        }
 
        VkResult result = builder.submit(context->getGraphicsQueue(), graphicsProcess->getGraphicsCompleteFence());
 
        if (result != VK_SUCCESS)
        {
            PLOGE << "Failed to submit graphics for frame " << renderedFrameCounter;
        }
 
        graphicsProcess->setGraphicsFenceSubmitted( true );
    }
 
    uint64_t Renderer::getTimelineSemaphoreValue() const
    {
        return timelineSynchronizer_->getCurrentValue();
    }
 
    VkCommandBuffer Renderer::getCurrentTransferCommandBuffer() const
    {
        return getCurrentRenderProcess()->getTransferCommandBuffer();
    }
 
    VkCommandBuffer Renderer::getCurrentRenderingCommandBuffer() const
    {
        return getCurrentRenderProcess()->getGraphicsCommandBuffer();
    }
 
    VkSemaphore Renderer::getCurrentMirrorViewSemaphore() const
    {
        return getCurrentRenderProcess()->getMirrorViewImageSemaphore();
    }
 
    VkSemaphore Renderer::getCurrentPresentableSemaphore( uint32_t swapchainImageIndex ) const
    {
        return renderFinishedSemaphores[swapchainImageIndex];
    }
 
    std::vector<VkCommandBuffer> Renderer::getGraphicsCommandBuffers() const
    {
        std::vector<VkCommandBuffer> commandBuffers;
        for ( RenderProcess * renderProcess : renderProcesses )
        {
            commandBuffers.push_back( renderProcess->getGraphicsCommandBuffer() );
        }
        return commandBuffers;
    }
 
    VkCommandPool Renderer::getGraphicsCommandPool() const
    {
        return vkGraphicsCommandPool;
    }
 
    VkCommandPool Renderer::getTransferCommandPool() const
    {
        return vkTransferCommandPool;
    }
 
    void Renderer::cleanup()
    {
        TRACY_ZONE_SCOPED_NAMED( "Renderer Cleanup" );
#ifdef ENABLE_TRACY
        destroyTracyContexts();
#endif
 
        for ( GraphicsPipeline * pipeline : graphicsPipelines )
        {
            delete pipeline;  // Delete the pipeline object to free the memory
        }
        graphicsPipelines.clear();
 
        // Cleanup depth-only pipelines
        for ( GraphicsPipeline * pipeline : depthOnlyGraphicsPipelines )
        {
            delete pipeline;
        }
        depthOnlyGraphicsPipelines.clear();
 
        // Cleanup depth-only vertex shader pipeline
        if (vsDepthOnlyPipeline_ != VK_NULL_HANDLE) {
            vkDestroyPipeline(context->getVkDevice(), vsDepthOnlyPipeline_, nullptr);
            vsDepthOnlyPipeline_ = VK_NULL_HANDLE;
        }
 
        // Cleanup vertex shader path pipeline
        if (vsGraphicsPipeline_ != VK_NULL_HANDLE) {
            vkDestroyPipeline(context->getVkDevice(), vsGraphicsPipeline_, nullptr);
            vsGraphicsPipeline_ = VK_NULL_HANDLE;
        }
 
        for ( RenderProcess * process : renderProcesses )
        {
            process->cleanup();
            delete process;
        }
        renderProcesses.clear();
 
        // Cleanup compute passes
        /*if (objectCullingComputePass.has_value()) {
            objectCullingComputePass->cleanup(context);
            objectCullingComputePass.reset();
        }
        if (meshletUnpackingDispatchComputePass.has_value()) {
            meshletUnpackingDispatchComputePass->cleanup(context);
            meshletUnpackingDispatchComputePass.reset();
        }
        if (meshletUnpackingComputePass.has_value()) {
            meshletUnpackingComputePass->cleanup(context);
            meshletUnpackingComputePass.reset();
        }
        if (meshletCullingDispatchComputePass.has_value()) {
            meshletCullingDispatchComputePass->cleanup(context);
            meshletCullingDispatchComputePass.reset();
        }
        if (meshletCullingComputePass.has_value()) {
            meshletCullingComputePass->cleanup(context);
            meshletCullingComputePass.reset();
        }
        if (drawPreparationComputePass.has_value()) {
            drawPreparationComputePass->cleanup(context);
            drawPreparationComputePass.reset();
        }*/
 
        if (placeholderBuffer.has_value())
            placeholderBuffer->destroy();
        if (placeholderUniformBuffer.has_value())
            placeholderUniformBuffer->destroy();
        if (counterBuffer.has_value())
            counterBuffer->destroy();
        if (dispatchBuffer.has_value())
            dispatchBuffer->destroy();
        if (objectIDsBuffer.has_value())
            objectIDsBuffer->destroy();
        if (objectCullingDataBuffer.has_value())
            objectCullingDataBuffer->destroy();
        if (objectMeshletDataBuffer.has_value())
            objectMeshletDataBuffer->destroy();
        if (meshUnpackingDataBuffer.has_value())
            meshUnpackingDataBuffer->destroy();
 
        vkDestroyCommandPool( context->getVkDevice(), vkGraphicsCommandPool, nullptr );
        vkGraphicsCommandPool = VK_NULL_HANDLE;  // Set to NULL after destroying
        vkDestroyCommandPool( context->getVkDevice(), vkTransferCommandPool, nullptr );
        vkTransferCommandPool = VK_NULL_HANDLE;
 
        vkDestroyDescriptorSetLayout( context->getVkDevice(), graphicsDescriptorSetLayout, nullptr );
        graphicsDescriptorSetLayout = VK_NULL_HANDLE;
 
        vkDestroyPipelineLayout( context->getVkDevice(), prepareDrawsComputePipelineLayout, nullptr );
        prepareDrawsComputePipelineLayout = VK_NULL_HANDLE;
        vkDestroyPipelineLayout( context->getVkDevice(), computeObjectCullingPipelineLayout, nullptr );
        computeObjectCullingPipelineLayout = VK_NULL_HANDLE;
        vkDestroyPipelineLayout( context->getVkDevice(), graphicsPipelineLayout, nullptr );
        graphicsPipelineLayout = VK_NULL_HANDLE;
 
        vkDestroyDescriptorPool( context->getVkDevice(), descriptorPool, nullptr );
        descriptorPool = VK_NULL_HANDLE;
 
        // Clean up Hi-Z descriptor pool
        if (hiZDescriptorPool != VK_NULL_HANDLE)
        {
            vkDestroyDescriptorPool( context->getVkDevice(), hiZDescriptorPool, nullptr );
            hiZDescriptorPool = VK_NULL_HANDLE;
        }
 
        // TimelineSynchronizer handles its own cleanup via RAII
        timelineSynchronizer_.reset();
 
        for ( auto sem : renderFinishedSemaphores )
            vkDestroySemaphore( context->getVkDevice(), sem, nullptr );
        renderFinishedSemaphores.clear();
    }
 
    RenderProcess * Renderer::getCurrentRenderProcess() const
    {
        return renderProcesses.at( currentFrame );
    }
 
    void Renderer::initializeFrameIndices()
    {
        currentFrame         = 0;
        renderedFrameCounter = 0;
        // Timeline values are now computed on-demand by TimelineSynchronizer
    }
 
    void Renderer::initializeXrSwapchainFormats()
    {
        VkCommandBuffer initialImageTransition =
            VulkanHelper::beginSingleTimeCommands( context->getVkDevice(), getGraphicsCommandPool() );
 
        std::vector<VkImageMemoryBarrier2> swapchainImageBarriers;
 
        for ( const auto & renderTarget : headset->getSwapchainRenderTargets() )
        {
            VkImageMemoryBarrier2 swapchainImageMemoryBarrier{
                .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                .srcStageMask        = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
                .srcAccessMask       = 0,
                .dstStageMask        = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
                .dstAccessMask       = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
                .oldLayout           = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout           = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .image               = renderTarget.image,
                .subresourceRange{ .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
                                   .baseMipLevel   = 0u,
                                   .levelCount     = 1u,
                                   .baseArrayLayer = 0u,
                                   .layerCount     = headset->getEyeCount() }
            };
            swapchainImageBarriers.push_back( swapchainImageMemoryBarrier );
        }
 
        VkDependencyInfo dependencyInfo{
            .sType                   = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
            .dependencyFlags         = 0,
            .imageMemoryBarrierCount = static_cast<uint32_t>( swapchainImageBarriers.size() ),
            .pImageMemoryBarriers    = swapchainImageBarriers.data(),
        };
 
        vkCmdPipelineBarrier2( initialImageTransition, &dependencyInfo );
        VulkanHelper::endSingleTimeCommands(
            context->getVkDevice(),
            context->getGraphicsQueue(),
            getGraphicsCommandPool(),
            initialImageTransition
        );
    }
 
    void Renderer::advanceFrameIndices()
    {
        currentFrame = ( currentFrame + 1 ) % MAX_FRAMES_IN_FLIGHT;
        renderedFrameCounter++;
        // Timeline values are now computed on-demand by TimelineSynchronizer
    }
 
    void Renderer::syncTimelineAfterPause()
    {
        // Get the current timeline semaphore value
        uint64_t currentValue = timelineSynchronizer_->getCurrentValue();
 
        // Calculate the minimum frame number that would produce valid signals.
        // Timeline signal formula: value = frameNumber * PIPELINE_STAGE_COUNT + stage + 1
        // We need nextSignal > currentValue, so:
        //   (nextFrame * PIPELINE_STAGE_COUNT + 0 + 1) > currentValue
        //   nextFrame > (currentValue - 1) / PIPELINE_STAGE_COUNT
        //   nextFrame = ceil((currentValue) / PIPELINE_STAGE_COUNT)
        // Use the actual PIPELINE_STAGE_COUNT from PipelineStages.h (currently 5)
        constexpr uint64_t stageCount = static_cast<uint64_t>(PIPELINE_STAGE_COUNT);
        uint64_t minFrameForValidSignal = (currentValue + stageCount - 1) / stageCount;
 
        if (renderedFrameCounter < minFrameForValidSignal)
        {
            PLOGI << "Timeline sync after pause: advancing frame counter from "
                  << renderedFrameCounter << " to " << minFrameForValidSignal
                  << " (timeline at " << currentValue << ")";
            renderedFrameCounter = minFrameForValidSignal;
            // Also advance currentFrame to match, wrapping around MAX_FRAMES_IN_FLIGHT
            currentFrame = renderedFrameCounter % MAX_FRAMES_IN_FLIGHT;
            // Skip mirror view for multiple frames to cycle through all swapchain images
            // This prevents WRITE_AFTER_PRESENT hazard on any swapchain image
            skipMirrorFramesRemaining_ = SKIP_FRAMES_AFTER_STALL;
        }
        else
        {
            PLOGI << "Timeline sync after pause: no adjustment needed (frame "
                  << renderedFrameCounter << ", timeline at " << currentValue << ")";
        }
    }
 
    bool Renderer::shouldSkipMirrorView()
    {
        // Check skip counter (set by timeline sync or stall detection in markFrameStart)
        if (skipMirrorFramesRemaining_ > 0)
        {
            PLOGI << "Skipping mirror view (stall recovery, " << skipMirrorFramesRemaining_ << " frames remaining)";
            skipMirrorFramesRemaining_--;
            return true;
        }
 
        return false;
    }
 
    void Renderer::markFrameStart()
    {
        auto now = std::chrono::steady_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFrameStartTime_);
        PLOGI << "[FRAME_TIME] Frame start - elapsed since last frame: " << elapsed.count() << "ms";
 
        // If there was a long stall, skip mirror view for multiple frames to cycle through
        // all swapchain images safely
        if (elapsed > STALL_THRESHOLD_MS)
        {
            PLOGI << "[FRAME_TIME] Stall detected (" << elapsed.count() << "ms > "
                  << STALL_THRESHOLD_MS.count() << "ms) - will skip mirror view for "
                  << SKIP_FRAMES_AFTER_STALL << " frames and sync GPU";
 
            // Always skip mirror frames after a stall to prevent WRITE_AFTER_PRESENT hazard
            skipMirrorFramesRemaining_ = SKIP_FRAMES_AFTER_STALL;
 
            // Wait for all GPU work to complete to ensure clean state after stall
            vkDeviceWaitIdle(context->getVkDevice());
            PLOGI << "[FRAME_TIME] GPU sync completed after stall";
 
            // Sync the timeline semaphore and frame counter after GPU idle.
            // This ensures the frame counter is advanced to produce valid timeline values.
            // Without this, the frame counter may be too low, causing submitTransfer to
            // wait for timeline values that will never be signaled (deadlock).
            syncTimelineAfterPause();
        }
 
        lastFrameStartTime_ = now;
    }
 
    int64_t Renderer::getFrameElapsedMs() const
    {
        auto now = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFrameStartTime_).count();
    }
 
    bool Renderer::isInStallRecovery() const
    {
        return skipMirrorFramesRemaining_ > 0;
    }
 
    VkSemaphore Renderer::getTimelineSemaphore() const
    {
        return timelineSynchronizer_->getSemaphore();
    }
 
    const TimelineSynchronizer& Renderer::getTimelineSynchronizer() const
    {
        return *timelineSynchronizer_;
    }
 
    const std::vector<GraphicsPipeline *> & Renderer::getGraphicsPipelines() const
    {
        return graphicsPipelines;
    }
 
#ifdef ENABLE_TRACY
 
    void Renderer::destroyTracyContexts()
    {
        TRACY_ZONE_SCOPED_NAMED( "Cleanup Tracy Contexts" );
 
        PLOGI << "Cleaning up " << tracyVkContext.size() << " Tracy Vulkan contexts";
 
        for ( TracyVkCtx ctx : tracyVkContext )
        {
            if ( ctx == nullptr )
            {
                continue;
            }
 
            PLOGI << "Destroying Tracy context: " << static_cast<void *>( ctx );
            TracyVkDestroy( ctx );
            PLOGI << "Tracy context destroyed";
        }
 
        tracyVkContext.clear();
        PLOGI << "Tracy contexts cleanup complete";
    }
 
    void Renderer::setupTracy( const std::vector<TracyVkCtx> & tracyVulkanContext )
    {
        if ( !tracyVkContext.empty() )
        {
            destroyTracyContexts();
        }
        tracyVkContext = tracyVulkanContext;
    }
 
    void Renderer::resetTracyContexts()
    {
        TRACY_ZONE_SCOPED_NAMED( "Reset Tracy Contexts" );
        PLOGI << "Resetting Tracy Vulkan contexts for state transition";
 
        // Destroy existing contexts
        destroyTracyContexts();
 
        // Recreate Tracy contexts using the same pattern as the constructor
        for ( size_t i = 0; i < renderProcesses.size(); i++ )
        {
            VkCommandBuffer commandBuffer = renderProcesses[i]->getGraphicsCommandBuffer();
 
            TracyVkCtx tracyContext = TracyVkContext(
                context->getVkPhysicalDevice(),
                context->getVkDevice(),
                context->getGraphicsQueue(),
                commandBuffer
            );
 
            std::stringstream contextNameStream{};
            contextNameStream << "Vulkan Context " << i;
            std::string contextName = contextNameStream.str();
 
            TracyVkContextName( tracyContext, contextName.c_str(), contextName.size() );
 
            tracyVkContext.push_back( tracyContext );
        }
 
        PLOGI << "Tracy contexts reset complete, created " << tracyVkContext.size() << " contexts";
    }
 
#endif
 
    int Renderer::findExistingPipeline(
        const std::string &             meshShader,
        const std::string &             fragShader,
        const PipelineMaterialPayload & pipelineData
    ) const
    {
        PLOGI << "Trying to find existing pipeline for mesh shader: " << meshShader
              << " frag shader: " << fragShader;
        for ( size_t i = 0; i < graphicsPipelines.size(); i++ )
        {
            if ( graphicsPipelines[i]->getMeshShaderName() == meshShader &&
                 graphicsPipelines[i]->getFragShaderName() == fragShader )
            {
                PLOGI << "Found existing pipeline at " << i << "!";
                return static_cast<int>( i );
            }
        }
        PLOGI << "No existing pipeline!";
        return -1;
    }
 
    ComputePass & Renderer::getObjectCullingComputePass()
    {
        if (!objectCullingComputePass.has_value() ) throw std::runtime_error( "No primtive culling compute pass found!" );
        return objectCullingComputePass.value();
    }
 
    ComputePass & Renderer::getBinningAllocatorComputePass()
    {
        if (!binningAllocatorComputePass.has_value()) throw std::runtime_error("No binning allocator compute pass found!");
        return binningAllocatorComputePass.value();
    }
 
    DispatcherComputePass & Renderer::getMeshletUnpackingDispatchComputePass()
    {
        if ( meshletUnpackingDispatchComputePass.has_value() )
            return meshletUnpackingDispatchComputePass.value();
        throw std::runtime_error( "No object for object unpacking compute pass found!" );
    }
 
    ComputePass & Renderer::getMeshletUnpackingComputePass()
    {
        if ( meshletUnpackingComputePass.has_value() )
            return meshletUnpackingComputePass.value();
        throw std::runtime_error( "No object for meshlet unpacking compute pass found!" );
    }
 
    DispatcherComputePass & Renderer::getMeshletCullingDispatchComputePass()
    {
        if ( meshletCullingDispatchComputePass.has_value() )
            return meshletCullingDispatchComputePass.value();
        throw std::runtime_error( "No object for meshlet culling compute pass found!" );
    }
 
    ComputePass & Renderer::getMeshletCullingComputePass()
    {
        if ( meshletCullingComputePass.has_value() )
            return meshletCullingComputePass.value();
        throw std::runtime_error( "No object for meshlet culling compute pass found!" );
    }
 
    ComputePass & Renderer::getDrawPreparationComputePass()
    {
        if ( drawPreparationComputePass.has_value() )
            return drawPreparationComputePass.value();
        throw std::runtime_error( "No object for draw preparation compute pass found!" );
    }
 
    ComputePass & Renderer::getVSBinningAllocatorComputePass()
    {
        if ( vsBinningAllocatorComputePass_.has_value() )
            return vsBinningAllocatorComputePass_.value();
        throw std::runtime_error( "No VS binning allocator compute pass found!" );
    }
 
    ComputePass & Renderer::getVSInstanceUnpackingComputePass()
    {
        if ( vsInstanceUnpackingComputePass_.has_value() )
            return vsInstanceUnpackingComputePass_.value();
        throw std::runtime_error( "No VS instance unpacking compute pass found!" );
    }
 
    ComputePass & Renderer::getVSPrepareDrawComputePass()
    {
        if ( vsPrepareDrawComputePass_.has_value() )
            return vsPrepareDrawComputePass_.value();
        throw std::runtime_error( "No VS prepare draw compute pass found!" );
    }
 
    void Renderer::createPrimitiveCullingResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Object Culling Resources" );
 
        std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
            DescriptorSetLayoutBuilder()
            #if !defined(HEADLESS)  // COMPUTE_DEBUG uses real compute shaders
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_DATA, VK_SHADER_STAGE_COMPUTE_BIT)
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_MESHLET_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                .addUniformBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_FRUSTUM_PLANES, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_IDS, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_COUNTER, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_MESH_UNPACKING_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                // Hi-Z Occlusion Culling bindings (two pyramids for two-pass culling)
                .addCombinedImageSampler( ShaderStage::HiZCulling::HIZ_PYRAMID, VK_SHADER_STAGE_COMPUTE_BIT )         // Previous frame's Hi-Z
                .addUniformBuffer( ShaderStage::HiZCulling::HIZ_VIEW_PROJECTION, VK_SHADER_STAGE_COMPUTE_BIT )
                .addCombinedImageSampler( ShaderStage::HiZCulling::HIZ_PYRAMID_CURRENT, VK_SHADER_STAGE_COMPUTE_BIT )  // Current frame's Hi-Z
                // GPU Transform Optimization: local bounds + per-object transforms for GPU-side world space computation
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_LOCAL_BOUNDS, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_PER_OBJECT_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                // Two-pass occlusion culling: failed objects buffer for Pass 2 re-testing
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_FAILED, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_CULLING_FAILED_COUNTER, VK_SHADER_STAGE_COMPUTE_BIT )
                // Vertex shader path for single-meshlet geometry optimization
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_VS_INDIRECT_DRAW, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_VS_INDIRECT_COUNT, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_SINGLE_MESHLET_GEO, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_INSTANCE_CULLING_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveCulling::PRIMITIVE_MESH_GEOMETRY_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
            #endif
                .build();
 
        VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo = {
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
            .pBindings    = computeLayoutBindings.data()
        };
 
        // Push constants: primitiveCount (uint32_t) + cullingPass (uint32_t)
        VkPushConstantRange pushConstantRange{
            .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
            .offset     = 0,
            .size       = 2 * sizeof( uint32_t )
        };
 
        VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .pNext                  = nullptr,
            .flags                  = 0,
            .setLayoutCount         = 1u,
            .pSetLayouts            = nullptr,
            .pushConstantRangeCount = 1u,
            .pPushConstantRanges    = &pushConstantRange,
        };
 
        auto* specialization = new ComputePipelineSpecializationData(32);
        const auto shaderPath = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/PrimitiveCulling.comp.spv");
        objectCullingComputePass.emplace( ComputePass( "Primitive Culling" ) );
        objectCullingComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutCreateInfo,
            &computeLayoutCreateInfo,
            shaderPath.string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createBinningAllocatorResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Binning Allocator Resources" );
 
        std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
            DescriptorSetLayoutBuilder()
            #if !defined(HEADLESS)  // COMPUTE_DEBUG uses real compute shaders
                .addStorageBuffer( ShaderStage::PrimitiveBinning::BINNING_CULLING_SURVIVORS, VK_SHADER_STAGE_COMPUTE_BIT)
                .addStorageBuffer( ShaderStage::PrimitiveBinning::BINNING_PRIMITIVE_MESHLET_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveBinning::BINNING_ALLOCATIONS, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveBinning::BINNING_PIPELINE_COUNTERS, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrimitiveBinning::BINNING_SURVIVOR_COUNT, VK_SHADER_STAGE_COMPUTE_BIT )
            #endif
                .build();
 
        VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo = {
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
            .pBindings    = computeLayoutBindings.data()
        };
 
        VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .pNext                  = nullptr,
            .flags                  = 0,
            .setLayoutCount         = 1u,
            .pSetLayouts            = nullptr,
            .pushConstantRangeCount = 0,
            .pPushConstantRanges    = nullptr,
        };
 
        auto* specialization = new ComputePipelineSpecializationData(32);
        const auto shaderPath = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/MeshletBinningAllocator.comp.spv");
        binningAllocatorComputePass.emplace( ComputePass( "Binning Allocator" ) );
        binningAllocatorComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutCreateInfo,
            &computeLayoutCreateInfo,
            shaderPath.string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createMeshletUnpackingDispatcherResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Meshlet Unpacking Dispatcher" );
 
        std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
            DescriptorSetLayoutBuilder()
            #if !defined(HEADLESS)  // COMPUTE_DEBUG uses real compute shaders
                .addStorageBuffer(ShaderStage::MeshletUnpackingDispatch::MESHLET_UNPACKING_DISPATCH_COUNTER, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer(ShaderStage::MeshletUnpackingDispatch::MESHLET_UNPACKING_DISPATCH_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer(ShaderStage::MeshletUnpackingDispatch::MESHLET_UNPACKING_DISPATCH_LOD_COUNTER, VK_SHADER_STAGE_COMPUTE_BIT )
            #endif
                .build();
 
        VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo{
            .sType          = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .setLayoutCount = 1u,
            .pSetLayouts    = nullptr,
        };
 
        VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo{
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
            .pBindings    = computeLayoutBindings.data(),
        };
 
        auto* specialization = new DispatcherComputePipelineSpecializationData(1, meshletUnpackingComputePass->getThreadCount());
        const auto shaderName = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/CountDispatcher.comp.spv");
        meshletUnpackingDispatchComputePass.emplace( DispatcherComputePass( "Meshlet Unpacking Dispatcher" ) );
        meshletUnpackingDispatchComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutCreateInfo,
            &computeLayoutCreateInfo,
            shaderName.string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createMeshletCullingDispatcherResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Meshlet Unpacking Dispatcher" );
 
        std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
            DescriptorSetLayoutBuilder()
#if !defined(HEADLESS)  // COMPUTE_DEBUG uses real compute shaders
                .addStorageBuffer(ShaderStage::MeshletCullingDispatch::MESHLET_CULLING_DISPATCH_COUNTER, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer(ShaderStage::MeshletCullingDispatch::MESHLET_CULLING_DISPATCH_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT )
#endif
                .build();
 
        VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo{
            .sType          = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .setLayoutCount = 1u,
            .pSetLayouts    = nullptr,
        };
 
        VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo{
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
            .pBindings    = computeLayoutBindings.data(),
        };
 
        auto* specialization = new DispatcherComputePipelineSpecializationData(1, meshletCullingComputePass->getThreadCount());
        const auto shaderName = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/CountDispatcher.comp.spv");
        meshletCullingDispatchComputePass.emplace( DispatcherComputePass( "Meshlet Culling Dispatcher" ) );
        meshletCullingDispatchComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutCreateInfo,
            &computeLayoutCreateInfo,
            shaderName.string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createMeshletUnpackingResources()
    {
        // Stage 2: Meshlet Unpacking V2 bindings
        std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
            DescriptorSetLayoutBuilder()
#if !defined(HEADLESS)  // COMPUTE_DEBUG uses real compute shaders
            .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_ALLOCATIONS, VK_SHADER_STAGE_COMPUTE_BIT)
            .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_BIN_OFFSETS, VK_SHADER_STAGE_COMPUTE_BIT)
            .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_OUTPUT, VK_SHADER_STAGE_COMPUTE_BIT)
            .addStorageBuffer(ShaderStage::MeshletUnpackingV2::UNPACKING_SURVIVOR_COUNT, VK_SHADER_STAGE_COMPUTE_BIT)
#endif
            .build();
 
 
        VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo = {
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
            .pBindings    = computeLayoutBindings.data()
        };
 
        VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .pNext                  = nullptr,
            .flags                  = 0,
            .setLayoutCount         = 1u,
            .pSetLayouts            = nullptr,
            .pushConstantRangeCount = 0,
            .pPushConstantRanges    = nullptr,
        };
 
        auto* specialization = new ComputePipelineSpecializationData(128);
        const auto shaderName = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/MeshletUnpacking.comp.spv");
 
        meshletUnpackingComputePass.emplace(ComputePass("Meshlet Unpacking"));
        meshletUnpackingComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutCreateInfo,
            &computeLayoutCreateInfo,
            shaderName.string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createMeshletCullingResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Meshlet Culling Resources" );
        VkDevice device = context->getVkDevice();
 
        // Create computeDescriptorSetLayout
        std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
            DescriptorSetLayoutBuilder()
#if !defined(HEADLESS)
                .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_INDICES, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_BOUNDS, VK_SHADER_STAGE_COMPUTE_BIT )
                .addUniformBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_FRUSTUM_PLANES, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_COUNTS, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::MeshletCulling::MESHLET_CULLING_BINNED_RENDERING, VK_SHADER_STAGE_COMPUTE_BIT )
#endif
                .build();
 
        VkDescriptorSetLayoutCreateInfo computeSetLayoutInfo{
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
            .pBindings    = computeLayoutBindings.data()
        };
 
        // Create computePipelineLayout
        VkPipelineLayoutCreateInfo computePipelineLayoutInfo{
            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .setLayoutCount         = 1,
            .pSetLayouts            = nullptr,
            .pushConstantRangeCount = 0,
            .pPushConstantRanges    = nullptr
        };
 
        auto* specialization = new ComputePipelineSpecializationData(32);
        meshletCullingComputePass                = ComputePass( "Meshlet Culling" );
        meshletCullingComputePass->create(
            device,
            &computePipelineLayoutInfo,
            &computeSetLayoutInfo,
            ( Path::engineShaders() / COMPUTE_SHADER_NAME("Output/MeshletCulling.comp.spv") ).string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createPrepareDrawResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Prepare Draw Resources" );
 
        std::vector<VkDescriptorSetLayoutBinding> prepareBindings =
            DescriptorSetLayoutBuilder()
            #if !defined(HEADLESS)  // COMPUTE_DEBUG uses real compute shaders
                .addStorageBuffer( ShaderStage::PrepareDraw::PREPARE_DRAW_MESHLET_COUNTER, VK_SHADER_STAGE_COMPUTE_BIT )
                .addStorageBuffer( ShaderStage::PrepareDraw::PREPARE_DRAW_INDIRECT_DRAW, VK_SHADER_STAGE_COMPUTE_BIT )
            #endif
                .build();
 
        VkDescriptorSetLayoutCreateInfo prepareLayoutInfo{
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( prepareBindings.size() ),
            .pBindings    = prepareBindings.data()
        };
 
        VkPipelineLayoutCreateInfo pipelineLayoutInfo{ .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
                                                       .setLayoutCount = 1,
                                                       .pSetLayouts = nullptr};
 
        auto* specialization = new ComputePipelineSpecializationData( MAX_PIPELINES );
        const auto shaderName = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/PrepareDraw.comp.spv");
        drawPreparationComputePass.emplace( ComputePass( "Draw Preparation" ) );
        drawPreparationComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutInfo,
            &prepareLayoutInfo,
            shaderName.string(),
            specialization
        );
        delete specialization;
    }
 
    void Renderer::createHiZGenerationResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Hi-Z Generation Resources" );
 
        // Hi-Z generation shader bindings:
        // binding 0: Source texture (previous mip or depth buffer) - combined image sampler
        // binding 1: Source MSAA depth buffer (for mip 0) - combined image sampler (MS)
        // binding 2: Destination mip (storage image)
        std::vector<VkDescriptorSetLayoutBinding> hiZBindings =
            DescriptorSetLayoutBuilder()
#if !defined(HEADLESS)
                .addCombinedImageSampler( 0, VK_SHADER_STAGE_COMPUTE_BIT )  // u_srcTexture
                .addCombinedImageSampler( 1, VK_SHADER_STAGE_COMPUTE_BIT )  // u_srcDepthMS (placeholder for now)
                .addStorageImage( 2, VK_SHADER_STAGE_COMPUTE_BIT )          // u_dstMip
#endif
                .build();
 
        VkDescriptorSetLayoutCreateInfo hiZLayoutInfo{
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>( hiZBindings.size() ),
            .pBindings    = hiZBindings.data()
        };
 
        // Push constants for mip level, source dimensions, and sample count
        VkPushConstantRange pushConstantRange{
            .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
            .offset     = 0,
            .size       = 4 * sizeof( uint32_t )  // mipLevel, srcWidth, srcHeight, sampleCount
        };
 
        VkPipelineLayoutCreateInfo pipelineLayoutInfo{
            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .setLayoutCount         = 1,
            .pSetLayouts            = nullptr,
            .pushConstantRangeCount = 1,
            .pPushConstantRanges    = &pushConstantRange
        };
 
        auto* specialization = new ComputePipelineSpecializationData( 64 );  // 8x8 workgroups
        const auto shaderName = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/HiZGeneration.comp.spv");
        hiZGenerationComputePass.emplace( ComputePass( "Hi-Z Generation" ) );
        hiZGenerationComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutInfo,
            &hiZLayoutInfo,
            shaderName.string(),
            specialization
        );
        delete specialization;
 
        PLOGI << "Hi-Z generation compute pass created";
    }
 
    void Renderer::createHiZMipDescriptorSets()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Hi-Z Mip Descriptor Sets" );
 
        if (!hiZGenerationComputePass.has_value())
        {
            PLOGW << "Hi-Z generation compute pass not available, skipping descriptor set creation";
            return;
        }
 
        // Calculate mip levels from eye resolution (same formula as Hi-Z pyramid creation)
        const VkExtent2D eyeResolution = headset->getEyeResolution(0);
        const uint32_t mipLevels = static_cast<uint32_t>(
            std::floor(std::log2(std::max(eyeResolution.width, eyeResolution.height)))) + 1;
        if (mipLevels == 0)
        {
            PLOGW << "Hi-Z pyramid has 0 mip levels, skipping descriptor set creation";
            return;
        }
 
        // Create a dedicated descriptor pool for Hi-Z mip descriptor sets
        std::array<VkDescriptorPoolSize, 2u> poolSizes{};
        poolSizes.at(0) = {
            .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            .descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT) * mipLevels * 2  // 2 samplers per mip
        };
        poolSizes.at(1) = {
            .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
            .descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT) * mipLevels
        };
 
        VkDescriptorPoolCreateInfo poolInfo{
            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
            .maxSets = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT) * mipLevels,
            .poolSizeCount = static_cast<uint32_t>(poolSizes.size()),
            .pPoolSizes = poolSizes.data()
        };
 
        VulkanHelper::createDescriptorPool(
            context->getVkDevice(), &poolInfo, nullptr, &hiZDescriptorPool, "Hi-Z Mip"
        );
 
        // Allocate descriptor sets for each frame and mip level
        VkDescriptorSetLayout layout = hiZGenerationComputePass->getDescriptorSetLayout();
        for (uint32_t frame = 0; frame < MAX_FRAMES_IN_FLIGHT; frame++)
        {
            for (uint32_t mip = 0; mip < mipLevels; mip++)
            {
                VkDescriptorSetAllocateInfo allocInfo{
                    .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
                    .descriptorPool = hiZDescriptorPool,
                    .descriptorSetCount = 1,
                    .pSetLayouts = &layout
                };
 
                VkResult result = vkAllocateDescriptorSets(
                    context->getVkDevice(), &allocInfo, &hiZMipDescriptorSets[frame][mip]
                );
                if (result != VK_SUCCESS)
                {
                    PLOGE << "Failed to allocate Hi-Z descriptor set for frame " << frame << " mip " << mip;
                }
            }
 
            // Update descriptor sets with image bindings
            updateHiZMipDescriptorSets(frame);
        }
 
        PLOGI << "Created Hi-Z mip descriptor sets: " << mipLevels << " mips x " << MAX_FRAMES_IN_FLIGHT << " frames";
    }
 
    void Renderer::updateHiZMipDescriptorSets(uint32_t frameIndex)
    {
        if (!hiZGenerationComputePass.has_value())
            return;
 
        // Use per-frame Hi-Z pyramid from the RenderProcess
        RenderProcess* renderProcess = renderProcesses[frameIndex];
        const uint32_t mipLevels = renderProcess->getHiZMipLevels();
 
        for (uint32_t mip = 0; mip < mipLevels; mip++)
        {
            // Storage for image infos (must persist until vkUpdateDescriptorSets)
            VkDescriptorImageInfo srcTextureInfo{};
            VkDescriptorImageInfo srcDepthMSInfo{};
            VkDescriptorImageInfo dstMipInfo{};
 
            // Binding 0: Source texture (previous mip level - NOT used for mip 0)
            if (mip == 0)
            {
                // For mip 0, binding 0 is unused (shader uses binding 1 for MSAA depth)
                // Use mip 0 of the Hi-Z pyramid itself as a placeholder
                srcTextureInfo = {
                    .sampler = headset->getHiZSampler(),
                    .imageView = renderProcess->getHiZPyramidMipView(0),
                    .imageLayout = VK_IMAGE_LAYOUT_GENERAL
                };
            }
            else
            {
                // For other mips, we read from the previous mip level
                srcTextureInfo = {
                    .sampler = headset->getHiZSampler(),
                    .imageView = renderProcess->getHiZPyramidMipView(mip - 1),
                    .imageLayout = VK_IMAGE_LAYOUT_GENERAL
                };
            }
 
            // Binding 1: MSAA depth buffer (used for mip 0 generation)
            srcDepthMSInfo = {
                .sampler = headset->getHiZSampler(),
                .imageView = headset->getDepthBufferView(),
                .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
            };
 
            // Binding 2: Destination mip as storage image (write to current frame's Hi-Z)
            dstMipInfo = {
                .sampler = VK_NULL_HANDLE,
                .imageView = renderProcess->getHiZPyramidMipView(mip),
                .imageLayout = VK_IMAGE_LAYOUT_GENERAL
            };
 
            DescriptorSetUpdater(hiZMipDescriptorSets[frameIndex][mip])
                .addCombinedImageSampler(ShaderStage::HiZGeneration::HIZ_SRC_TEXTURE, &srcTextureInfo)
                .addCombinedImageSampler(ShaderStage::HiZGeneration::HIZ_SRC_DEPTH_MS, &srcDepthMSInfo)
                .addStorageImage(ShaderStage::HiZGeneration::HIZ_DST_MIP, &dstMipInfo)
                .update(context->getVkDevice());
        }
    }
 
    //==============================================================================
    // Hi-Z SPD (Single Pass Downsampler) Implementation
    //==============================================================================
 
    void Renderer::createHiZSPDResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create Hi-Z SPD Resources" );
 
        // Create atomic counter buffer for SPD workgroup synchronization
        // SPD needs one counter per slice (we have 2 slices for stereo)
        hiZSPDAtomicBuffer.emplace(context);
        constexpr VkDeviceSize atomicBufferSize = sizeof(uint32_t) * 6;  // 6 counters max (SPD supports up to 6 slices)
        hiZSPDAtomicBuffer->create(
            atomicBufferSize,
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
        );
        hiZSPDAtomicBuffer->setDebugName("Hi-Z SPD Atomic Counter Buffer");
 
        // SPD shader bindings:
        // binding 0: Source MSAA depth buffer (combined image sampler)
        // binding 1: Destination mip levels array [12] (storage images)
        // binding 2: Mip level 5 - globally coherent (storage image)
        // binding 3: Global atomic counter buffer
        std::vector<VkDescriptorSetLayoutBinding> spdBindings = DescriptorSetLayoutBuilder()
#if !defined(HEADLESS)
            .addCombinedImageSampler(0, VK_SHADER_STAGE_COMPUTE_BIT)  // imgSrcDepthMS
            .addStorageImageArray(1, 12, VK_SHADER_STAGE_COMPUTE_BIT) // imgDst[12]
            .addStorageImage(2, VK_SHADER_STAGE_COMPUTE_BIT)          // imgDst5 (coherent)
            .addStorageBuffer(3, VK_SHADER_STAGE_COMPUTE_BIT)         // spdGlobalAtomic
#endif
            .build();
 
        VkDescriptorSetLayoutCreateInfo spdLayoutInfo{
            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            .bindingCount = static_cast<uint32_t>(spdBindings.size()),
            .pBindings    = spdBindings.data()
        };
 
        // Push constants: mips, numWorkGroups, workGroupOffset, sampleCount
        VkPushConstantRange pushConstantRange{
            .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
            .offset     = 0,
            .size       = sizeof(uint32_t) * 2 + sizeof(int32_t) * 2 + sizeof(uint32_t)  // mips, numWorkGroups, workGroupOffset.xy, sampleCount
        };
 
        VkPipelineLayoutCreateInfo pipelineLayoutInfo{
            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .setLayoutCount         = 1,
            .pSetLayouts            = nullptr,  // Will be set by ComputePass
            .pushConstantRangeCount = 1,
            .pPushConstantRanges    = &pushConstantRange
        };
 
        auto* specialization = new ComputePipelineSpecializationData(256);  // SPD uses 256 threads
        const auto shaderName = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/HiZGenerationSPD.comp.spv");
        hiZSPDComputePass.emplace(ComputePass("Hi-Z SPD Generation"));
        hiZSPDComputePass->create(
            context->getVkDevice(),
            &pipelineLayoutInfo,
            &spdLayoutInfo,
            shaderName.string(),
            specialization
        );
        delete specialization;
 
        PLOGI << "Hi-Z SPD compute pass created";
    }
 
    void Renderer::createHiZSPDDescriptorSets()
    {
        TRACY_ZONE_SCOPED_NAMED("Create Hi-Z SPD Descriptor Sets");
 
        if (!hiZSPDComputePass.has_value())
        {
            PLOGW << "Hi-Z SPD compute pass not available, skipping descriptor set creation";
            useSPDHiZ_ = false;
            return;
        }
 
        // Create descriptor pool for SPD
        // Per frame: 1 combined image sampler, 12 storage images, 1 storage image (coherent), 1 storage buffer
        std::array<VkDescriptorPoolSize, 3u> poolSizes{};
        poolSizes[0] = {
            .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            .descriptorCount = MAX_FRAMES_IN_FLIGHT
        };
        poolSizes[1] = {
            .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
            .descriptorCount = MAX_FRAMES_IN_FLIGHT * 13  // 12 + 1 coherent
        };
        poolSizes[2] = {
            .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = MAX_FRAMES_IN_FLIGHT
        };
 
        VkDescriptorPoolCreateInfo poolInfo{
            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
            .maxSets = MAX_FRAMES_IN_FLIGHT,
            .poolSizeCount = static_cast<uint32_t>(poolSizes.size()),
            .pPoolSizes = poolSizes.data()
        };
 
        VkDescriptorPool spdDescriptorPool = VK_NULL_HANDLE;
        VulkanHelper::createDescriptorPool(
            context->getVkDevice(), &poolInfo, nullptr, &spdDescriptorPool, "Hi-Z SPD"
        );
 
        // Allocate descriptor sets
        VkDescriptorSetLayout layout = hiZSPDComputePass->getDescriptorSetLayout();
        for (uint32_t frame = 0; frame < MAX_FRAMES_IN_FLIGHT; frame++)
        {
            VkDescriptorSetAllocateInfo allocInfo{
                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
                .descriptorPool = spdDescriptorPool,
                .descriptorSetCount = 1,
                .pSetLayouts = &layout
            };
 
            VkResult result = vkAllocateDescriptorSets(
                context->getVkDevice(), &allocInfo, &hiZSPDDescriptorSets[frame]
            );
            if (result != VK_SUCCESS)
            {
                PLOGE << "Failed to allocate Hi-Z SPD descriptor set for frame " << frame;
                useSPDHiZ_ = false;
                return;
            }
 
            updateHiZSPDDescriptorSets(frame);
        }
 
        PLOGI << "Created Hi-Z SPD descriptor sets for " << MAX_FRAMES_IN_FLIGHT << " frames";
    }
 
    void Renderer::updateHiZSPDDescriptorSets(uint32_t frameIndex)
    {
        if (!hiZSPDComputePass.has_value())
            return;
 
        RenderProcess* renderProcess = renderProcesses[frameIndex];
        const uint32_t mipLevels = renderProcess->getHiZMipLevels();
 
        // Binding 0: MSAA depth buffer
        VkDescriptorImageInfo depthMSInfo{
            .sampler = headset->getHiZSampler(),
            .imageView = headset->getDepthBufferView(),
            .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
        };
 
        // Binding 1: Destination mip levels array (12 images, use mip views or placeholders)
        std::array<VkDescriptorImageInfo, 12> dstMipInfos{};
        for (uint32_t mip = 0; mip < 12; mip++)
        {
            if (mip < mipLevels)
            {
                dstMipInfos[mip] = {
                    .sampler = VK_NULL_HANDLE,
                    .imageView = renderProcess->getHiZPyramidMipView(mip),
                    .imageLayout = VK_IMAGE_LAYOUT_GENERAL
                };
            }
            else
            {
                // Use mip 0 as placeholder for unused mip slots
                dstMipInfos[mip] = {
                    .sampler = VK_NULL_HANDLE,
                    .imageView = renderProcess->getHiZPyramidMipView(0),
                    .imageLayout = VK_IMAGE_LAYOUT_GENERAL
                };
            }
        }
 
        // Binding 2: Mip level 5 (globally coherent)
        VkDescriptorImageInfo dst5Info{
            .sampler = VK_NULL_HANDLE,
            .imageView = (mipLevels > 5) ? renderProcess->getHiZPyramidMipView(5) : renderProcess->getHiZPyramidMipView(0),
            .imageLayout = VK_IMAGE_LAYOUT_GENERAL
        };
 
        // Binding 3: Atomic counter buffer
        VkDescriptorBufferInfo atomicBufferInfo = VulkanHelper::fullBufferInfo(hiZSPDAtomicBuffer->getBuffer());
 
        // Update descriptor set
        std::array<VkWriteDescriptorSet, 4> writes{};
 
        writes[0] = {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet = hiZSPDDescriptorSets[frameIndex],
            .dstBinding = 0,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            .pImageInfo = &depthMSInfo
        };
 
        writes[1] = {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet = hiZSPDDescriptorSets[frameIndex],
            .dstBinding = 1,
            .dstArrayElement = 0,
            .descriptorCount = 12,
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
            .pImageInfo = dstMipInfos.data()
        };
 
        writes[2] = {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet = hiZSPDDescriptorSets[frameIndex],
            .dstBinding = 2,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
            .pImageInfo = &dst5Info
        };
 
        writes[3] = {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet = hiZSPDDescriptorSets[frameIndex],
            .dstBinding = 3,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .pBufferInfo = &atomicBufferInfo
        };
 
        vkUpdateDescriptorSets(context->getVkDevice(), static_cast<uint32_t>(writes.size()), writes.data(), 0, nullptr);
    }
 
    void Renderer::recordHiZGenerationSPD()
    {
        if (!hiZSPDComputePass.has_value() || !useSPDHiZ_)
            return;
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
 
        TRACY_VK_ZONE_C(getCurrentTracyVkContext(), commandBuffer, "Hi-Z Generation SPD", Colors::Orange)
 
        const uint32_t mipLevels = currentRenderProcess->getHiZMipLevels();
        const VkExtent2D hiZExtent = currentRenderProcess->getHiZExtent();
        VkImage hiZImage = currentRenderProcess->getHiZPyramidImage();
 
        // Execution barrier: ensure render pass depth writes complete before compute reads
        {
            VkMemoryBarrier2 depthBarrier{
                .sType               = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask        = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
                .srcAccessMask       = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
                .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask       = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{VK_STRUCTURE_TYPE_DEPENDENCY_INFO};
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &depthBarrier;
            vkCmdPipelineBarrier2(commandBuffer, &depInfo);
        }
 
        // Transition Hi-Z pyramid to GENERAL for compute writes
        {
            VkImageMemoryBarrier2 hiZBarrier{
                .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                .srcStageMask        = VK_PIPELINE_STAGE_2_NONE,
                .srcAccessMask       = VK_ACCESS_2_NONE,
                .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
                .oldLayout           = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout           = VK_IMAGE_LAYOUT_GENERAL,
                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .image               = hiZImage,
                .subresourceRange    = {VK_IMAGE_ASPECT_COLOR_BIT, 0, mipLevels, 0, 2}
            };
            VkDependencyInfo depInfo{VK_STRUCTURE_TYPE_DEPENDENCY_INFO};
            depInfo.imageMemoryBarrierCount = 1;
            depInfo.pImageMemoryBarriers = &hiZBarrier;
            vkCmdPipelineBarrier2(commandBuffer, &depInfo);
        }
 
        // Bind SPD pipeline and descriptor set
        hiZSPDComputePass->getComputePipeline()->bind(commandBuffer);
        vkCmdBindDescriptorSets(
            commandBuffer,
            VK_PIPELINE_BIND_POINT_COMPUTE,
            hiZSPDComputePass->getPipelineLayout(),
            0, 1,
            &hiZSPDDescriptorSets[currentFrame],
            0, nullptr
        );
 
        // Calculate dispatch parameters
        uint32_t dispatchX = (hiZExtent.width + 63) / 64;
        uint32_t dispatchY = (hiZExtent.height + 63) / 64;
        uint32_t numWorkGroups = dispatchX * dispatchY;
 
        // Push constants
        struct SPDPushConstants {
            uint32_t mips;
            uint32_t numWorkGroups;
            int32_t workGroupOffsetX;
            int32_t workGroupOffsetY;
            uint32_t sampleCount;
        } pushConstants;
 
        pushConstants.mips = mipLevels;
        pushConstants.numWorkGroups = numWorkGroups;
        pushConstants.workGroupOffsetX = 0;
        pushConstants.workGroupOffsetY = 0;
        pushConstants.sampleCount = context->getMultisampleCount();
 
        vkCmdPushConstants(
            commandBuffer,
            hiZSPDComputePass->getPipelineLayout(),
            VK_SHADER_STAGE_COMPUTE_BIT,
            0,
            sizeof(SPDPushConstants),
            &pushConstants
        );
 
        // Single dispatch for ALL mip levels!
        vkCmdDispatch(commandBuffer, dispatchX, dispatchY, 2);  // 2 slices for stereo
 
        // Transition Hi-Z pyramid to SHADER_READ_ONLY for culling
        {
            VkImageMemoryBarrier2 finalBarrier{
                .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                .srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
                .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask       = VK_ACCESS_2_SHADER_READ_BIT,
                .oldLayout           = VK_IMAGE_LAYOUT_GENERAL,
                .newLayout           = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .image               = hiZImage,
                .subresourceRange    = {VK_IMAGE_ASPECT_COLOR_BIT, 0, mipLevels, 0, 2}
            };
            VkDependencyInfo depInfo{VK_STRUCTURE_TYPE_DEPENDENCY_INFO};
            depInfo.imageMemoryBarrierCount = 1;
            depInfo.pImageMemoryBarriers = &finalBarrier;
            vkCmdPipelineBarrier2(commandBuffer, &depInfo);
        }
    }
 
    void Renderer::recordHiZGeneration()
    {
        // Skip Hi-Z generation when culling is frozen - keep using the frozen pyramid
        if (freezeCulling_)
        {
            return;
        }
 
        // Use SPD (Single Pass Downsampler) by default for much faster Hi-Z generation
        // Falls back to multi-pass if SPD is not available
        if (useSPDHiZ_ && hiZSPDComputePass.has_value())
        {
            recordHiZGenerationSPD();
            return;
        }
 
        // Legacy multi-pass Hi-Z generation:
        // This function records the Hi-Z pyramid generation after the render pass.
        // It needs to:
        // 1. Transition depth buffer from SHADER_READ_ONLY to be readable
        // 2. For each mip level:
        //    a. Dispatch compute shader to generate mip
        //    b. Barrier before next mip
        // 3. Transition Hi-Z pyramid to SHADER_READ_ONLY for culling
 
        if (!hiZGenerationComputePass.has_value())
        {
            PLOGW << "Hi-Z generation compute pass not created, skipping Hi-Z generation";
            return;
        }
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
        TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Hi-Z Generation (Legacy)", Colors::Orange )
 
        // Get Hi-Z pyramid info from current frame's RenderProcess (per-frame pyramid)
        const uint32_t mipLevels = currentRenderProcess->getHiZMipLevels();
        const VkExtent2D hiZExtent = currentRenderProcess->getHiZExtent();
        VkImage hiZImage = currentRenderProcess->getHiZPyramidImage();
 
        // NOTE: The depth buffer is already in SHADER_READ_ONLY_OPTIMAL layout.
        // recordRenderPass() transitions it after vkCmdEndRendering() completes.
        // Hi-Z generation reads the depth buffer via combined image sampler.
 
        // Transition Hi-Z pyramid to GENERAL for compute writes
        // Each frame has its own Hi-Z pyramid, so we can safely discard previous contents
        {
            VkImageMemoryBarrier2 hiZBarrier{
                .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                .srcStageMask        = VK_PIPELINE_STAGE_2_NONE,
                .srcAccessMask       = VK_ACCESS_2_NONE,
                .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
                .oldLayout           = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout           = VK_IMAGE_LAYOUT_GENERAL,
                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .image               = hiZImage,
                .subresourceRange    = { VK_IMAGE_ASPECT_COLOR_BIT, 0, mipLevels, 0, 2 }
            };
 
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.imageMemoryBarrierCount = 1;
            depInfo.pImageMemoryBarriers = &hiZBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Bind Hi-Z generation pipeline
        hiZGenerationComputePass->getComputePipeline()->bind( commandBuffer );
 
        // Generate each mip level
        // Track source dimensions (what we read from) and destination dimensions (what we write to)
        // Mip 0: src = MSAA depth (full res), dst = mip 0 (full res)
        // Mip N: src = mip N-1, dst = mip N (half of src)
        uint32_t srcWidth = hiZExtent.width;
        uint32_t srcHeight = hiZExtent.height;
 
        for (uint32_t mip = 0; mip < mipLevels; mip++)
        {
            // Calculate destination dimensions
            // Mip 0: same as source (1:1 copy from MSAA depth)
            // Mip N: half of source (2:1 reduction)
            uint32_t dstWidth = (mip == 0) ? srcWidth : std::max(1u, srcWidth >> 1);
            uint32_t dstHeight = (mip == 0) ? srcHeight : std::max(1u, srcHeight >> 1);
 
            // Push constants: mipLevel, srcWidth, srcHeight, sampleCount
            struct HiZPushConstants {
                uint32_t mipLevel;
                uint32_t srcWidth;
                uint32_t srcHeight;
                uint32_t sampleCount;
            } pushConstants;
 
            pushConstants.mipLevel = mip;
            pushConstants.srcWidth = srcWidth;
            pushConstants.srcHeight = srcHeight;
            pushConstants.sampleCount = (mip == 0) ? context->getMultisampleCount() : 1;
 
            vkCmdPushConstants(
                commandBuffer,
                hiZGenerationComputePass->getPipelineLayout(),
                VK_SHADER_STAGE_COMPUTE_BIT,
                0,
                sizeof(HiZPushConstants),
                &pushConstants
            );
 
            // Bind descriptor set for this mip level
            vkCmdBindDescriptorSets(
                commandBuffer,
                VK_PIPELINE_BIND_POINT_COMPUTE,
                hiZGenerationComputePass->getPipelineLayout(),
                0, 1,
                &hiZMipDescriptorSets[currentFrame][mip],
                0, nullptr
            );
 
            // Dispatch compute shader to cover destination mip
            uint32_t groupsX = (dstWidth + 7) / 8;
            uint32_t groupsY = (dstHeight + 7) / 8;
            uint32_t groupsZ = 2;  // 2 layers for stereo
 
            vkCmdDispatch( commandBuffer, groupsX, groupsY, groupsZ );
 
            // Barrier between mip levels (read-after-write)
            if (mip < mipLevels - 1)
            {
                VkImageMemoryBarrier2 mipBarrier{
                    .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                    .srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                    .srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
                    .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                    .dstAccessMask       = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
                    .oldLayout           = VK_IMAGE_LAYOUT_GENERAL,
                    .newLayout           = VK_IMAGE_LAYOUT_GENERAL,
                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                    .image               = hiZImage,
                    .subresourceRange    = { VK_IMAGE_ASPECT_COLOR_BIT, mip, 1, 0, 2 }
                };
 
                VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
                depInfo.imageMemoryBarrierCount = 1;
                depInfo.pImageMemoryBarriers = &mipBarrier;
                vkCmdPipelineBarrier2( commandBuffer, &depInfo );
            }
 
            // Source for next iteration is this iteration's destination
            srcWidth = dstWidth;
            srcHeight = dstHeight;
        }
 
        // Final barrier: transition Hi-Z pyramid to SHADER_READ_ONLY for culling in next frame
        {
            VkImageMemoryBarrier2 finalBarrier{
                .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                .srcStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
                .dstStageMask        = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask       = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
                .oldLayout           = VK_IMAGE_LAYOUT_GENERAL,
                .newLayout           = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .image               = hiZImage,
                .subresourceRange    = { VK_IMAGE_ASPECT_COLOR_BIT, 0, mipLevels, 0, 2 }
            };
 
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.imageMemoryBarrierCount = 1;
            depInfo.pImageMemoryBarriers = &finalBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
    }
 
    //==============================================================================
    // Vertex Shader Path for Single-Meshlet Geometry
    //==============================================================================
 
    void Renderer::createVertexShaderPathResources()
    {
        TRACY_ZONE_SCOPED_NAMED("Create Vertex Shader Path Resources");
 
        PLOGI << "[VS_PATH] Creating vertex shader path pipeline resources";
 
        // Vertex input binding description - matches Vertex struct (64 bytes)
        // vec4 position (16) + vec4 normal (16) + vec4 tangent (16) + vec2 texCoord (8) + vec2 lightmapUV (8)
        VkVertexInputBindingDescription vertexBindingDesc{
            .binding = 0,
            .stride = 64,  // sizeof(Vertex)
            .inputRate = VK_VERTEX_INPUT_RATE_VERTEX
        };
 
        // Vertex input attribute descriptions
        std::array<VkVertexInputAttributeDescription, 5> vertexAttrDescs = {{
            {.location = 0, .binding = 0, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = 0},   // position (vec4)
            {.location = 1, .binding = 0, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = 16},  // normal (vec4)
            {.location = 2, .binding = 0, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = 32},  // tangent (vec4)
            {.location = 3, .binding = 0, .format = VK_FORMAT_R32G32_SFLOAT, .offset = 48},        // texCoord (vec2)
            {.location = 4, .binding = 0, .format = VK_FORMAT_R32G32_SFLOAT, .offset = 56}         // lightmapUV (vec2)
        }};
 
        VkPipelineVertexInputStateCreateInfo vertexInputState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
            .vertexBindingDescriptionCount = 1,
            .pVertexBindingDescriptions = &vertexBindingDesc,
            .vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexAttrDescs.size()),
            .pVertexAttributeDescriptions = vertexAttrDescs.data()
        };
 
        VkPipelineInputAssemblyStateCreateInfo inputAssemblyState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
            .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
            .primitiveRestartEnable = VK_FALSE
        };
 
        // Load vertex and fragment shaders
        // Use Placeholder.vert which reads from vs_instance_ids[] for the VS instanced drawing pipeline
        const auto shaderDir = Path::engineShaders() / "Output";
        VertexShader shader(context->getVkDevice(), shaderDir / "Placeholder.vert.spv", shaderDir / "triangle_movable_normals.frag.spv");
 
        std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages = {{
            {
                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
                .stage = VK_SHADER_STAGE_VERTEX_BIT,
                .module = shader.getVertexShader(),
                .pName = "main"
            },
            {
                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
                .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
                .module = shader.getFragmentShader(),
                .pName = "main"
            }
        }};
 
        VkPipelineViewportStateCreateInfo viewportState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
            .viewportCount = 1,
            .scissorCount = 1
        };
 
        VkPipelineRasterizationStateCreateInfo rasterizationState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
            .polygonMode = VK_POLYGON_MODE_FILL,
            .cullMode = VK_CULL_MODE_NONE,              // Match mesh shader pipelines
            .frontFace = VK_FRONT_FACE_CLOCKWISE,       // Match mesh shader pipelines
            .lineWidth = 1.0f
        };
 
        VkPipelineMultisampleStateCreateInfo multisampleState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
            .rasterizationSamples = context->getMultisampleCount()
        };
 
        VkPipelineDepthStencilStateCreateInfo depthStencilState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
            .depthTestEnable = VK_TRUE,
            .depthWriteEnable = VK_TRUE,
            .depthCompareOp = VK_COMPARE_OP_GREATER  // Reverse-Z
        };
 
        VkPipelineColorBlendAttachmentState colorBlendAttachment{
            .blendEnable = VK_FALSE,
            .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
                              VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
        };
 
        VkPipelineColorBlendStateCreateInfo colorBlendState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
            .attachmentCount = 1,
            .pAttachments = &colorBlendAttachment
        };
 
        std::array<VkDynamicState, 2> dynamicStates = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
        VkPipelineDynamicStateCreateInfo dynamicState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
            .dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()),
            .pDynamicStates = dynamicStates.data()
        };
 
        // Use dynamic rendering (same as recordRenderPass which now uses vkCmdBeginRendering)
        constexpr VkFormat colorFormat = VK_FORMAT_R8G8B8A8_SRGB;
        constexpr VkFormat depthFormat = VK_FORMAT_D32_SFLOAT;
        VkPipelineRenderingCreateInfo pipelineRenderingInfo{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
            .viewMask = 0b11,  // Stereo: render to both layers
            .colorAttachmentCount = 1,
            .pColorAttachmentFormats = &colorFormat,
            .depthAttachmentFormat = depthFormat,
        };
 
        VkGraphicsPipelineCreateInfo pipelineCreateInfo{
            .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
            .pNext = &pipelineRenderingInfo,  // Dynamic rendering
            .stageCount = static_cast<uint32_t>(shaderStages.size()),
            .pStages = shaderStages.data(),
            .pVertexInputState = &vertexInputState,
            .pInputAssemblyState = &inputAssemblyState,
            .pViewportState = &viewportState,
            .pRasterizationState = &rasterizationState,
            .pMultisampleState = &multisampleState,
            .pDepthStencilState = &depthStencilState,
            .pColorBlendState = &colorBlendState,
            .pDynamicState = &dynamicState,
            .layout = graphicsPipelineLayout,  // Same layout as mesh shader pipeline
            .renderPass = VK_NULL_HANDLE  // Use dynamic rendering
        };
 
        VkResult result = vkCreateGraphicsPipelines(
            context->getVkDevice(),
            VK_NULL_HANDLE,
            1,
            &pipelineCreateInfo,
            nullptr,
            &vsGraphicsPipeline_
        );
 
        if (result != VK_SUCCESS) {
            PLOGE << "[VS_PATH] Failed to create vertex shader pipeline: " << result;
            useVertexShaderPath_ = false;
        } else {
            VulkanHelper::setObjectName(context->getVkDevice(), vsGraphicsPipeline_, "VS Single-Meshlet Pipeline");
            PLOGI << "[VS_PATH] Vertex shader pipeline created successfully";
        }
 
        shader.destroyShaders(context->getVkDevice());
 
        // Create depth-only VS pipeline for Z-prepass
        // Uses the same vertex shader but with depth-only fragment shader and no color attachments
        {
            const auto shaderDir = Path::engineShaders() / "Output";
            VertexShader depthOnlyShader(context->getVkDevice(), shaderDir / "Placeholder.vert.spv", shaderDir / "depth_only.frag.spv");
 
            std::array<VkPipelineShaderStageCreateInfo, 2> depthOnlyShaderStages = {{
                {
                    .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
                    .stage = VK_SHADER_STAGE_VERTEX_BIT,
                    .module = depthOnlyShader.getVertexShader(),
                    .pName = "main"
                },
                {
                    .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
                    .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
                    .module = depthOnlyShader.getFragmentShader(),
                    .pName = "main"
                }
            }};
 
            // Depth-only: no color attachments
            VkPipelineColorBlendStateCreateInfo depthOnlyColorBlendState{
                .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
                .attachmentCount = 0,
                .pAttachments = nullptr
            };
 
            VkPipelineRenderingCreateInfo depthOnlyRenderingInfo{
                .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
                .viewMask = 0b11,  // Stereo: render to both layers
                .colorAttachmentCount = 0,
                .pColorAttachmentFormats = nullptr,
                .depthAttachmentFormat = depthFormat,
            };
 
            VkGraphicsPipelineCreateInfo depthOnlyPipelineCreateInfo{
                .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
                .pNext = &depthOnlyRenderingInfo,
                .stageCount = static_cast<uint32_t>(depthOnlyShaderStages.size()),
                .pStages = depthOnlyShaderStages.data(),
                .pVertexInputState = &vertexInputState,
                .pInputAssemblyState = &inputAssemblyState,
                .pViewportState = &viewportState,
                .pRasterizationState = &rasterizationState,
                .pMultisampleState = &multisampleState,
                .pDepthStencilState = &depthStencilState,
                .pColorBlendState = &depthOnlyColorBlendState,
                .pDynamicState = &dynamicState,
                .layout = graphicsPipelineLayout,
                .renderPass = VK_NULL_HANDLE
            };
 
            VkResult depthOnlyResult = vkCreateGraphicsPipelines(
                context->getVkDevice(),
                VK_NULL_HANDLE,
                1,
                &depthOnlyPipelineCreateInfo,
                nullptr,
                &vsDepthOnlyPipeline_
            );
 
            if (depthOnlyResult != VK_SUCCESS) {
                PLOGE << "[VS_PATH] Failed to create depth-only VS pipeline: " << depthOnlyResult;
            } else {
                VulkanHelper::setObjectName(context->getVkDevice(), vsDepthOnlyPipeline_, "VS Depth-Only Pipeline");
                PLOGI << "[VS_PATH] Depth-only VS pipeline created successfully";
            }
 
            depthOnlyShader.destroyShaders(context->getVkDevice());
        }
    }
 
    void Renderer::createVSInstancedDrawingResources()
    {
        TRACY_ZONE_SCOPED_NAMED("Create VS Instanced Drawing Resources");
 
        // Skip if VS path is disabled
        if (!useVSInstancedDrawing_) {
            PLOGI << "[VS_INSTANCED] VS instanced drawing disabled, skipping compute pipeline creation";
            return;
        }
 
        PLOGI << "[VS_INSTANCED] Creating VS instanced drawing compute pipelines";
 
        // Stage 1: VSBinningAllocator - Count instances per geometry type
        {
            std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
                DescriptorSetLayoutBuilder()
                #if !defined(HEADLESS)
                    .addStorageBuffer( ShaderStage::VSBinning::VS_BINNING_VISIBLE_INSTANCES, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSBinning::VS_BINNING_VISIBLE_COUNT, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSBinning::VS_BINNING_MESH_GEOMETRY_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSBinning::VS_BINNING_INSTANCE_CULLING_DATA, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSBinning::VS_BINNING_ALLOCATIONS, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSBinning::VS_BINNING_GEOMETRY_COUNTERS, VK_SHADER_STAGE_COMPUTE_BIT )
                #endif
                    .build();
 
            VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo = {
                .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
                .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
                .pBindings    = computeLayoutBindings.data()
            };
 
            VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
                .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
                .pNext                  = nullptr,
                .flags                  = 0,
                .setLayoutCount         = 1u,
                .pSetLayouts            = nullptr,
                .pushConstantRangeCount = 0,
                .pPushConstantRanges    = nullptr,
            };
 
            auto* specialization = new ComputePipelineSpecializationData(32);
            // Note: MAX_GEOMETRY_TYPES (constant_id=2) uses default value of 256 in shader
            const auto shaderPath = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/VSBinningAllocator.comp.spv");
            vsBinningAllocatorComputePass_.emplace( ComputePass( "VS Binning Allocator" ) );
            vsBinningAllocatorComputePass_->create(
                context->getVkDevice(),
                &pipelineLayoutCreateInfo,
                &computeLayoutCreateInfo,
                shaderPath.string(),
                specialization
            );
            delete specialization;
            PLOGI << "[VS_INSTANCED] Created VS Binning Allocator compute pass";
        }
 
        // Stage 2: VSInstanceUnpacking - Write instance IDs to per-geometry bins
        {
            std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
                DescriptorSetLayoutBuilder()
                #if !defined(HEADLESS)
                    .addStorageBuffer( ShaderStage::VSInstanceUnpacking::VS_UNPACKING_ALLOCATIONS, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSInstanceUnpacking::VS_UNPACKING_VISIBLE_COUNT, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSInstanceUnpacking::VS_UNPACKING_INSTANCE_IDS, VK_SHADER_STAGE_COMPUTE_BIT )
                #endif
                    .build();
 
            VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo = {
                .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
                .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
                .pBindings    = computeLayoutBindings.data()
            };
 
            VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
                .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
                .pNext                  = nullptr,
                .flags                  = 0,
                .setLayoutCount         = 1u,
                .pSetLayouts            = nullptr,
                .pushConstantRangeCount = 0,
                .pPushConstantRanges    = nullptr,
            };
 
            auto* specialization = new ComputePipelineSpecializationData(32);
            // Note: MAX_VS_INSTANCES_PER_GEO (constant_id=2) uses default value of 16384 in shader
            const auto shaderPath = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/VSInstanceUnpacking.comp.spv");
            vsInstanceUnpackingComputePass_.emplace( ComputePass( "VS Instance Unpacking" ) );
            vsInstanceUnpackingComputePass_->create(
                context->getVkDevice(),
                &pipelineLayoutCreateInfo,
                &computeLayoutCreateInfo,
                shaderPath.string(),
                specialization
            );
            delete specialization;
            PLOGI << "[VS_INSTANCED] Created VS Instance Unpacking compute pass";
        }
 
        // Stage 3: VSPrepareDraw - Generate one draw command per geometry type
        {
            std::vector<VkDescriptorSetLayoutBinding> computeLayoutBindings =
                DescriptorSetLayoutBuilder()
                #if !defined(HEADLESS)
                    .addStorageBuffer( ShaderStage::VSPrepareDraw::VS_PREPARE_SINGLE_MESHLET_GEO, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSPrepareDraw::VS_PREPARE_GEOMETRY_COUNTERS, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSPrepareDraw::VS_PREPARE_INDIRECT_DRAWS, VK_SHADER_STAGE_COMPUTE_BIT )
                    .addStorageBuffer( ShaderStage::VSPrepareDraw::VS_PREPARE_DRAW_COUNT, VK_SHADER_STAGE_COMPUTE_BIT )
                #endif
                    .build();
 
            VkDescriptorSetLayoutCreateInfo computeLayoutCreateInfo = {
                .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
                .bindingCount = static_cast<uint32_t>( computeLayoutBindings.size() ),
                .pBindings    = computeLayoutBindings.data()
            };
 
            // Push constants: uniqueGeometryCount (uint32_t)
            VkPushConstantRange pushConstantRange{
                .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
                .offset     = 0,
                .size       = sizeof( uint32_t )
            };
 
            VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
                .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
                .pNext                  = nullptr,
                .flags                  = 0,
                .setLayoutCount         = 1u,
                .pSetLayouts            = nullptr,
                .pushConstantRangeCount = 1,
                .pPushConstantRanges    = &pushConstantRange,
            };
 
            auto* specialization = new ComputePipelineSpecializationData(32);
            // Note: MAX_VS_INSTANCES_PER_GEO (constant_id=2) uses default value of 16384 in shader
            const auto shaderPath = Path::engineShaders() / COMPUTE_SHADER_NAME("Output/VSPrepareDraw.comp.spv");
            vsPrepareDrawComputePass_.emplace( ComputePass( "VS Prepare Draw" ) );
            vsPrepareDrawComputePass_->create(
                context->getVkDevice(),
                &pipelineLayoutCreateInfo,
                &computeLayoutCreateInfo,
                shaderPath.string(),
                specialization
            );
            delete specialization;
            PLOGI << "[VS_INSTANCED] Created VS Prepare Draw compute pass";
        }
 
        PLOGI << "[VS_INSTANCED] All VS instanced drawing compute passes created successfully";
    }
 
    void Renderer::recordVSInstancedDrawingPipeline()
    {
        COMPUTE_GUARD()
 
        // Skip if VS instanced drawing is disabled
        if (!useVSInstancedDrawing_ || !vsBinningAllocatorComputePass_.has_value()) {
            return;
        }
 
        // Skip if no single-meshlet geometry exists
        if (!renderingDataManager->hasVertexShaderPath()) {
            return;
        }
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
 
        TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "VS Instanced Drawing Pipeline", Colors::Cyan );
 
        const uint32_t primitiveCount = renderingDataManager->getPrimitiveCount();
        // Use single-meshlet geometry count, NOT total unique geometry count
        // The VS path only handles single-meshlet geometries
        const uint32_t uniqueGeoCount = renderingDataManager->getSingleMeshletGeometryCount();
 
        if (primitiveCount == 0 || uniqueGeoCount == 0) {
            return;
        }
 
        // Reset VS instanced drawing buffers (NOT vs_visible_count - that's written by PrimitiveCulling)
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Reset VS Instanced Buffers", Colors::Cyan );
            // Note: vs_visible_count is populated by PrimitiveCulling.comp - do NOT reset it here!
            vkCmdFillBuffer( commandBuffer, currentRenderProcess->getVSGeometryCountersBuffer().getBuffer(), 0, VK_WHOLE_SIZE, 0 );
            vkCmdFillBuffer( commandBuffer, currentRenderProcess->getVSDrawCountBuffer().getBuffer(), 0, VK_WHOLE_SIZE, 0 );
 
            VkMemoryBarrier2 fillBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT
            };
            VkDependencyInfo fillDep{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            fillDep.memoryBarrierCount = 1;
            fillDep.pMemoryBarriers = &fillBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &fillDep );
        }
 
        // Stage 1: VSBinningAllocator
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "VS Binning Allocator", Colors::Cyan );
            const uint32_t threadCount = getVSBinningAllocatorComputePass().getThreadCount();
 
            getVSBinningAllocatorComputePass().getComputePipeline()->bind( commandBuffer );
            getVSBinningAllocatorComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
 
            // Dispatch based on max visible count (primitiveCount upper bound)
            vkCmdDispatch( commandBuffer, ( primitiveCount + threadCount - 1 ) / threadCount, 1, 1 );
        }
 
        // Barrier: VSBinningAllocator -> VSInstanceUnpacking
        {
            VkMemoryBarrier2 barrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &barrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Stage 2: VSInstanceUnpacking
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "VS Instance Unpacking", Colors::Cyan );
            const uint32_t threadCount = getVSInstanceUnpackingComputePass().getThreadCount();
 
            getVSInstanceUnpackingComputePass().getComputePipeline()->bind( commandBuffer );
            getVSInstanceUnpackingComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
 
            vkCmdDispatch( commandBuffer, ( primitiveCount + threadCount - 1 ) / threadCount, 1, 1 );
        }
 
        // Barrier: VSInstanceUnpacking -> VSPrepareDraw + Vertex Shader read
        {
            VkMemoryBarrier2 barrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &barrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Stage 3: VSPrepareDraw
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "VS Prepare Draw", Colors::Cyan );
            const uint32_t threadCount = getVSPrepareDrawComputePass().getThreadCount();
 
            getVSPrepareDrawComputePass().getComputePipeline()->bind( commandBuffer );
            getVSPrepareDrawComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
 
            // Push constant: uniqueGeometryCount
            VkPushConstantsInfo pushConstantsInfo = getVSPrepareDrawComputePass().createPushConstantsInfo( sizeof( uint32_t ), &uniqueGeoCount );
            vkCmdPushConstants2( commandBuffer, &pushConstantsInfo );
 
            vkCmdDispatch( commandBuffer, ( uniqueGeoCount + threadCount - 1 ) / threadCount, 1, 1 );
        }
 
        // Barrier: VSPrepareDraw -> Indirect Draw
        {
            VkMemoryBarrier2 barrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,
                .dstAccessMask = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &barrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        PLOGI << "[VS_INSTANCED] Dispatched VS instanced drawing pipeline for " << uniqueGeoCount << " geometry types";
    }
 
    void Renderer::recordVertexShaderDraws(size_t swapChainImageIndex) const
    {
        PLOGI << "[VS_DIAG] recordVertexShaderDraws: hasVSPath="
              << renderingDataManager->hasVertexShaderPath()
              << ", count=" << renderingDataManager->getSingleMeshletGeometryCount();
 
        // Skip if VS path is disabled or pipeline wasn't created
        if (!useVertexShaderPath_ || vsGraphicsPipeline_ == VK_NULL_HANDLE) {
            PLOGI << "[VS_DIAG] EARLY EXIT: useVertexShaderPath_=" << useVertexShaderPath_
                  << ", vsGraphicsPipeline_=" << (vsGraphicsPipeline_ != VK_NULL_HANDLE ? "valid" : "NULL");
            return;
        }
 
        // Skip if no single-meshlet geometry exists
        if (!renderingDataManager->hasVertexShaderPath()) {
            PLOGI << "[VS_DIAG] EARLY EXIT: no single-meshlet geometry";
            return;
        }
 
        // Note: Even with no textures loaded, we can still render using shaders that
        // don't require texture sampling (e.g., normals visualization shader)
 
        PLOGI << "[VS_DIAG] Passed all checks, proceeding with VS draw recording";
 
        TRACY_ZONE_SCOPED_NAMED("VS Path Draw Recording");
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
 
        TRACY_VK_ZONE_C(getCurrentTracyVkContext(), commandBuffer, "Vertex Shader Draws", Colors::Cyan);
 
        // Bind VS graphics pipeline
        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vsGraphicsPipeline_);
 
        // Bind vertex buffer - use the shared vertex buffer from RenderingDataManager
        VkBuffer vertexBuffers[] = { renderingDataManager->getVertexBuffer().getBuffer() };
        VkDeviceSize offsets[] = { 0 };
        PLOGI << "[VS_DIAG] Binding vertex buffer: handle=" << (void*)vertexBuffers[0]
              << ", size=" << renderingDataManager->getVertexBuffer().getBufferSize();
        vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
 
        // Bind index buffer - use the VS-specific index buffer (contiguous uint32_t indices)
        VkBuffer indexBuffer = renderingDataManager->getVSIndexBuffer().getBuffer();
        PLOGI << "[VS_DIAG] Binding index buffer: handle=" << (void*)indexBuffer
              << ", size=" << renderingDataManager->getVSIndexBuffer().getBufferSize();
        vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT32);
 
        // Bind descriptor sets - same as mesh shader path
        VkDescriptorSet descriptorSet = currentRenderProcess->getGraphicsDescriptorSet();
        vkCmdBindDescriptorSets(
            commandBuffer,
            VK_PIPELINE_BIND_POINT_GRAPHICS,
            graphicsPipelineLayout,
            0,
            1,
            &descriptorSet,
            0,
            nullptr
        );
 
        // Note: VS path does not use push constants - the shader uses gl_InstanceIndex directly
        // to look up per-object data from the SSBO.
 
        // Draw using indirect count - reads draw commands and count from GPU buffers
        // With VS instanced drawing pipeline:
        // - VSPrepareDraw generates one draw command per unique geometry type
        // - Each command has instanceCount = number of visible instances of that geometry
        // - maxDrawCount = unique geometry count (typically 1 for a scene of cubes)
        // Legacy path:
        // - PrimitiveCulling generates one draw command per visible primitive
        // - maxDrawCount = primitiveCount
 
        if (useVSInstancedDrawing_ && vsBinningAllocatorComputePass_.has_value()) {
            // Use new instanced drawing buffers
            // maxDrawCount = single-meshlet geometry count (VS path only handles these)
            const uint32_t maxDrawCount = renderingDataManager->getSingleMeshletGeometryCount();
            PLOGI << "[VS_DIAG] VS Instanced path: maxDrawCount=" << maxDrawCount;
            if (maxDrawCount > 0) {
                VkBuffer drawCmdBuffer = currentRenderProcess->getVSDrawCommandsBuffer().getBuffer();
                VkBuffer drawCountBuffer = currentRenderProcess->getVSDrawCountBuffer().getBuffer();
                PLOGI << "[VS_BUFFER_DEBUG] Eye " << currentRenderProcess->getEyeIndex() << " Draw call using:"
                      << " vsDrawCountBuffer=" << (void*)drawCountBuffer
                      << " vsDrawCommandsBuffer=" << (void*)drawCmdBuffer;
                PLOGI << "[VS_DIAG] CALLING vkCmdDrawIndexedIndirectCount (instanced path)"
                      << " drawCmdBuffer=" << (void*)drawCmdBuffer
                      << " drawCountBuffer=" << (void*)drawCountBuffer
                      << " stride=" << sizeof(VkDrawIndexedIndirectCommand);
                vkCmdDrawIndexedIndirectCount(
                    commandBuffer,
                    drawCmdBuffer,
                    0,  // offset
                    drawCountBuffer,
                    0,  // countBufferOffset
                    maxDrawCount,
                    sizeof(VkDrawIndexedIndirectCommand)
                );
            }
        } else {
            // Legacy path: one draw command per visible primitive
            const uint32_t maxDrawCount = renderingDataManager->getPrimitiveCount();
            PLOGI << "[VS_DIAG] VS Legacy path: maxDrawCount=" << maxDrawCount;
            if (maxDrawCount > 0) {
                PLOGI << "[VS_DIAG] CALLING vkCmdDrawIndexedIndirectCount (legacy path)";
                vkCmdDrawIndexedIndirectCount(
                    commandBuffer,
                    currentRenderProcess->getVSIndirectDrawBuffer().getBuffer(),
                    0,  // offset
                    currentRenderProcess->getVSIndirectDrawCountBuffer().getBuffer(),
                    0,  // countBufferOffset
                    maxDrawCount,
                    sizeof(VkDrawIndexedIndirectCommand)
                );
            }
        }
    }
 
    void Renderer::recordVertexShaderDrawsDepthOnly(size_t swapChainImageIndex) const
    {
        // Skip if VS path is disabled or depth-only pipeline wasn't created
        if (!useVertexShaderPath_ || vsDepthOnlyPipeline_ == VK_NULL_HANDLE) {
            return;
        }
 
        // Skip if no single-meshlet geometry exists
        if (!renderingDataManager->hasVertexShaderPath()) {
            return;
        }
 
        TRACY_ZONE_SCOPED_NAMED("VS Path Depth-Only Draw Recording");
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
 
        TRACY_VK_ZONE_C(getCurrentTracyVkContext(), commandBuffer, "Vertex Shader Draws (Depth-Only)", Colors::Cyan);
 
        // Bind VS DEPTH-ONLY graphics pipeline
        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vsDepthOnlyPipeline_);
 
        // Bind vertex buffer
        VkBuffer vertexBuffers[] = { renderingDataManager->getVertexBuffer().getBuffer() };
        VkDeviceSize offsets[] = { 0 };
        vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
 
        // Bind index buffer
        VkBuffer indexBuffer = renderingDataManager->getVSIndexBuffer().getBuffer();
        vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT32);
 
        // Bind descriptor sets
        VkDescriptorSet descriptorSet = currentRenderProcess->getGraphicsDescriptorSet();
        vkCmdBindDescriptorSets(
            commandBuffer,
            VK_PIPELINE_BIND_POINT_GRAPHICS,
            graphicsPipelineLayout,
            0,
            1,
            &descriptorSet,
            0,
            nullptr
        );
 
        // Draw using indirect count
        if (useVSInstancedDrawing_ && vsBinningAllocatorComputePass_.has_value()) {
            const uint32_t maxDrawCount = renderingDataManager->getSingleMeshletGeometryCount();
            if (maxDrawCount > 0) {
                VkBuffer drawCmdBuffer = currentRenderProcess->getVSDrawCommandsBuffer().getBuffer();
                VkBuffer drawCountBuffer = currentRenderProcess->getVSDrawCountBuffer().getBuffer();
                vkCmdDrawIndexedIndirectCount(
                    commandBuffer,
                    drawCmdBuffer,
                    0,
                    drawCountBuffer,
                    0,
                    maxDrawCount,
                    sizeof(VkDrawIndexedIndirectCommand)
                );
            }
        } else {
            const uint32_t maxDrawCount = renderingDataManager->getPrimitiveCount();
            if (maxDrawCount > 0) {
                vkCmdDrawIndexedIndirectCount(
                    commandBuffer,
                    currentRenderProcess->getVSIndirectDrawBuffer().getBuffer(),
                    0,
                    currentRenderProcess->getVSIndirectDrawCountBuffer().getBuffer(),
                    0,
                    maxDrawCount,
                    sizeof(VkDrawIndexedIndirectCommand)
                );
            }
        }
    }
 
    void Renderer::recordPass2Culling( const size_t swapChainImageIndex )
    {
        TRACY_ZONE_SCOPED_NAMED( "Two-Pass Occlusion - Pass 2" );
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
 
        // =====================================================================
        // PASS 2: Re-test failed objects against CURRENT frame's Hi-Z
        // =====================================================================
        // At this point:
        // - Pass 1 survivors have been rendered
        // - Hi-Z pyramid has been generated from Pass 1 depth
        // - culling_failed buffer contains object IDs that failed Pass 1 Hi-Z
        // - culling_failed_count contains the number of failed objects
        //
        // Pass 2 culling will:
        // - Read object IDs from culling_failed
        // - Test them against the NEW Hi-Z (current frame, just generated)
        // - Append survivors to culling_survivors (via atomicAdd to cull_count)
        // =====================================================================
 
        TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Pass 2 Occlusion Culling", Colors::Orange );
 
        // NOTE: Pass 2 currently uses the SAME Hi-Z as Pass 1 (previous frame's).
        // This is suboptimal but avoids descriptor update issues.
        // TODO: Properly bind both Hi-Z pyramids at frame start and use push constants to select,
        // or use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT to allow mid-frame updates.
        // For now, Pass 2 re-tests failed objects but may still incorrectly cull some disoccluded objects.
 
        // Barrier: ensure Hi-Z writes are complete before reading
        {
            VkMemoryBarrier2 hiZReadBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &hiZReadBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Reset pipeline counters and bin offsets for Pass 2
        // (cull_count is NOT reset - Pass 2 survivors will append to existing count)
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Reset Pass 2 Buffers", Colors::Red );
 
            // Barrier: Ensure Pass 1's compute writes complete before transfer writes (vkCmdFillBuffer)
            // Without this, there's a WRITE_AFTER_WRITE hazard: BinningAllocator (compute) → FillBuffer (transfer)
            VkMemoryBarrier2 computeToTransferBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                .dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT
            };
            VkDependencyInfo preFillDep{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            preFillDep.memoryBarrierCount = 1;
            preFillDep.pMemoryBarriers = &computeToTransferBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &preFillDep );
 
            vkCmdFillBuffer( commandBuffer, currentRenderProcess->getPipelineCountersBuffer().getBuffer(), 0, VK_WHOLE_SIZE, 0 );
            vkCmdFillBuffer( commandBuffer, currentRenderProcess->getPipelineBinOffsetsBuffer().getBuffer(), 0, VK_WHOLE_SIZE, 0 );
 
            VkMemoryBarrier2 fillBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
                .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT
            };
            VkDependencyInfo fillDep{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            fillDep.memoryBarrierCount = 1;
            fillDep.pMemoryBarriers = &fillBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &fillDep );
        }
 
        // Pass 2 Primitive Culling
        const uint32_t primitiveCount = renderingDataManager->getPrimitiveCount();
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Primitive Culling Pass 2", Colors::Red );
            const uint32_t threadCount = getObjectCullingComputePass().getThreadCount();
 
            // Push constants: {primitiveCount, cullingPass}
            // Note: primitiveCount is max dispatch size, shader uses culling_failed_count for actual work
            struct CullingPushConstants {
                uint32_t primitiveCount;
                uint32_t cullingPass;  // 1 = Pass 2
            } pushData = { primitiveCount, 1 };
 
            getObjectCullingComputePass().getComputePipeline()->bind( commandBuffer );
            getObjectCullingComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
            VkPushConstantsInfo pushConstantsInfo = getObjectCullingComputePass().createPushConstantsInfo( sizeof( CullingPushConstants ), &pushData );
            vkCmdPushConstants2( commandBuffer, &pushConstantsInfo );
 
            // Dispatch: we dispatch primitiveCount threads, but Pass 2 shader early-exits
            // for threads beyond culling_failed_count (GPU-driven)
            if ( primitiveCount > 0 )
            {
                vkCmdDispatch( commandBuffer, ( primitiveCount + threadCount - 1 ) / threadCount, 1, 1 );
            }
        }
 
        // Barrier: Pass 2 culling writes → downstream pipeline reads
        {
            VkMemoryBarrier2 cullBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &cullBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Re-run downstream pipeline for ALL survivors (Pass 1 + Pass 2)
        // Note: The survivors buffer now contains both Pass 1 and Pass 2 survivors,
        // and cull_count reflects the total. The pipeline will process all of them.
 
        // Stage 1: Binning Allocator (Pass 2)
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Binning Allocator Pass 2", Colors::Red );
            const uint32_t threadCount = getBinningAllocatorComputePass().getThreadCount();
            getBinningAllocatorComputePass().getComputePipeline()->bind( commandBuffer );
            getBinningAllocatorComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
            if ( primitiveCount > 0 )
            {
                vkCmdDispatch( commandBuffer, ( primitiveCount + threadCount - 1 ) / threadCount, 1, 1 );
            }
        }
 
        // Barrier: Binning → Unpacking
        {
            VkMemoryBarrier2 binningBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &binningBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Meshlet Unpacking Dispatcher (Pass 2)
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Meshlet Unpacking Dispatcher Pass 2", Colors::Red );
            getMeshletUnpackingDispatchComputePass().getComputePipeline()->bind( commandBuffer );
            getMeshletUnpackingDispatchComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
            vkCmdDispatch( commandBuffer, 1, 1, 1 );
        }
 
        // Barrier: Dispatcher → Unpacking
        {
            Vulkan::BarrierBundle bundle;
            VkDependencyInfo dependencyInfo = getMeshletUnpackingDispatchToMeshletUnpackingBarriers( bundle );
            vkCmdPipelineBarrier2( commandBuffer, &dependencyInfo );
        }
 
        // Stage 2: Meshlet Unpacking (Pass 2)
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Meshlet Unpacking Pass 2", Colors::Red );
            getMeshletUnpackingComputePass().getComputePipeline()->bind( commandBuffer );
            getMeshletUnpackingComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
            vkCmdDispatchIndirect( commandBuffer, getDispatchBuffer().getBuffer(), 0 );
        }
 
        // Barrier: Unpacking → Prepare Draw
        {
            VkMemoryBarrier2 memBarrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT
            };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.memoryBarrierCount = 1;
            depInfo.pMemoryBarriers = &memBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // Prepare Draw (Pass 2)
        {
            TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Prepare Draw Pass 2", Colors::Red );
            getDrawPreparationComputePass().getComputePipeline()->bind( commandBuffer );
            getDrawPreparationComputePass().bindDescriptorSets( commandBuffer, currentRenderProcess->getEyeIndex() );
            vkCmdDispatch( commandBuffer, 1, 1, 1 );
        }
 
        // Barrier: Compute → Graphics
        {
            VkBufferMemoryBarrier2 visibleBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            visibleBarrier.srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            visibleBarrier.srcAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            visibleBarrier.dstStageMask = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT;
            visibleBarrier.dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
            visibleBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            visibleBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            visibleBarrier.buffer = currentRenderProcess->getBinnedVisibleMeshletIndexBuffer().getBuffer();
            visibleBarrier.offset = 0;
            visibleBarrier.size = VK_WHOLE_SIZE;
 
            VkBufferMemoryBarrier2 indirectBarrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
            indirectBarrier.srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            indirectBarrier.srcAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
            indirectBarrier.dstStageMask = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
            indirectBarrier.dstAccessMask = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
            indirectBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            indirectBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            indirectBarrier.buffer = currentRenderProcess->getIndirectDrawBuffer().getBuffer();
            indirectBarrier.offset = 0;
            indirectBarrier.size = VK_WHOLE_SIZE;
 
            VkBufferMemoryBarrier2 barriers[] = { visibleBarrier, indirectBarrier };
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.bufferMemoryBarrierCount = 2;
            depInfo.pBufferMemoryBarriers = barriers;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
 
        // =====================================================================
        // PASS 2 RENDERING
        // =====================================================================
        // Use dynamic rendering with VK_ATTACHMENT_LOAD_OP_LOAD to preserve
        // Pass 1 results and add Pass 2 survivors on top.
        // =====================================================================
        recordPass2RenderPass( swapChainImageIndex );
    }
 
    void Renderer::recordPass2RenderPass( const size_t swapChainImageIndex )
    {
        TRACY_ZONE_SCOPED_NAMED( "Pass 2 Render" );
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
        TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Pass 2 Render", Colors::Green );
 
        // Get render target info
        const RenderTarget* renderTarget = headset->getRenderTarget( swapChainImageIndex );
        const VkExtent2D extent = headset->getEyeResolution( 0u );
 
        // Transition images for Pass 2 rendering:
        // - MSAA color: UNDEFINED → COLOR_ATTACHMENT_OPTIMAL (Pass 1 was depth-only, no color write)
        // - Depth: SHADER_READ_ONLY (after Hi-Z) → DEPTH_STENCIL_ATTACHMENT
        // - Swapchain: UNDEFINED → COLOR_ATTACHMENT_OPTIMAL (first use for color this frame)
 
        VkImageMemoryBarrier2 colorBarrier{
            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
            .srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT,  // No prior color work this frame
            .srcAccessMask = VK_ACCESS_2_NONE,
            .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
            .dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
            .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,  // Pass 1 was depth-only
            .newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .image = headset->getColorBufferImage(),
            .subresourceRange = {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 2  // Stereo
            }
        };
 
        VkImageMemoryBarrier2 depthBarrier{
            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
            .srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            .srcAccessMask = VK_ACCESS_2_SHADER_READ_BIT,
            .dstStageMask = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
            .dstAccessMask = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
            .oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
            .newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .image = headset->getDepthBufferImage(),
            .subresourceRange = {
                .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 2  // Stereo
            }
        };
 
        // Swapchain: Already transitioned in recordXrSwapchainImageWritableBarrier,
        // just need sync barrier (no layout change needed)
        VkImageMemoryBarrier2 swapchainBarrier{
            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
            .srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT,  // No prior color work (Pass 1 was depth-only)
            .srcAccessMask = VK_ACCESS_2_NONE,
            .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
            .dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
            .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,  // Set in recordXrSwapchainImageWritableBarrier
            .newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .image = renderTarget->image,
            .subresourceRange = {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 2  // Stereo
            }
        };
 
        std::array<VkImageMemoryBarrier2, 3> barriers = { colorBarrier, depthBarrier, swapchainBarrier };
        VkDependencyInfo dependencyInfo{
            .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
            .imageMemoryBarrierCount = static_cast<uint32_t>( barriers.size() ),
            .pImageMemoryBarriers = barriers.data()
        };
        vkCmdPipelineBarrier2( commandBuffer, &dependencyInfo );
 
        // Use MSAA color buffer (same sample count as depth)
        // NOTE: Using CLEAR instead of LOAD because Pass 2 re-runs the full pipeline
        // on ALL survivors (Pass 1 + Pass 2 combined). We re-render everything and
        // the resolve will overwrite the swapchain with the complete final image.
        VkClearValue clearColor = { .color = { .float32 = { 0.0f, 0.0f, 0.0f, 1.0f } } };
        VkRenderingAttachmentInfo colorAttachment{
            .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
            .imageView = headset->getColorBufferView(),  // MSAA color buffer
            .imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
            .resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT,
            .resolveImageView = renderTarget->imageView,  // Resolve to swapchain
            .resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,   // Clear - we re-render everything
            .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
            .clearValue = clearColor,
        };
 
        VkClearValue clearDepth = { .depthStencil = { .depth = 0.0f, .stencil = 0 } };  // Reverse-Z: 0 = far
        VkRenderingAttachmentInfo depthAttachment{
            .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
            .imageView = headset->getDepthBufferView(),  // MSAA depth buffer
            .imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,   // Clear - we re-render everything
            .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
            .clearValue = clearDepth,
        };
 
        VkRenderingInfo renderingInfo{
            .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
            .renderArea = { .offset = {0, 0}, .extent = extent },
            .layerCount = 1,
            .viewMask = 0b11,  // Stereo: render to both layers
            .colorAttachmentCount = 1,
            .pColorAttachments = &colorAttachment,
            .pDepthAttachment = &depthAttachment,
        };
 
        vkCmdBeginRendering( commandBuffer, &renderingInfo );
 
        // Set viewport and scissor
        VkViewport viewport{
            .x = 0.0f, .y = 0.0f,
            .width = static_cast<float>( extent.width ),
            .height = static_cast<float>( extent.height ),
            .minDepth = 0.0f, .maxDepth = 1.0f
        };
        vkCmdSetViewport( commandBuffer, 0, 1, &viewport );
 
        VkRect2D scissor{ .offset = {0, 0}, .extent = extent };
        vkCmdSetScissor( commandBuffer, 0, 1, &scissor );
 
        // Bind descriptor set
        VkDescriptorSet descriptorSet = currentRenderProcess->getGraphicsDescriptorSet();
        vkCmdBindDescriptorSets(
            commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
            graphicsPipelineLayout, 0, 1, &descriptorSet, 0, nullptr
        );
 
        // Draw single-meshlet geometry using vertex shader path (same as Pass 1)
        // This must be called since we CLEAR the framebuffer and re-render everything
        recordVertexShaderDraws(swapChainImageIndex);
 
        // Draw Pass 2 survivors (same draw calls as Pass 1, but with updated indirect buffer)
        for ( uint32_t pipelineIndex = 0; pipelineIndex < graphicsPipelines.size(); pipelineIndex++ )
        {
            if ( pipelineIndex != 0 )
            {
                VkConditionalRenderingBeginInfoEXT conditionalRenderingBeginInfo = {
                    .sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
                    .buffer = currentRenderProcess->getIndirectDrawBuffer().getBuffer(),
                    .offset = pipelineIndex * sizeof( VkDrawMeshTasksIndirectCommandEXT ) +
                              offsetof( VkDrawMeshTasksIndirectCommandEXT, groupCountX ),
                    .flags = 0
                };
                VulkanHelper::getFunctions().vkCmdBeginConditionalRenderingEXT(
                    commandBuffer, &conditionalRenderingBeginInfo
                );
            }
 
            graphicsPipelines[pipelineIndex]->bind( commandBuffer );
 
            TaskConstants taskConstants( pipelineIndex * MAX_MESHLETS_PER_BIN );
            vkCmdPushConstants(
                commandBuffer, graphicsPipelineLayout,
                VK_SHADER_STAGE_MESH_BIT_EXT | VK_SHADER_STAGE_FRAGMENT_BIT,
                0, sizeof( TaskConstants ), &taskConstants
            );
 
            VulkanHelper::getFunctions().vkCmdDrawMeshTasksIndirectEXT(
                commandBuffer,
                currentRenderProcess->getIndirectDrawBuffer().getBuffer(),
                pipelineIndex * sizeof( VkDrawMeshTasksIndirectCommandEXT ),
                1,
                sizeof( VkDrawMeshTasksIndirectCommandEXT )
            );
 
            if ( pipelineIndex != 0 )
            {
                VulkanHelper::getFunctions().vkCmdEndConditionalRenderingEXT( commandBuffer );
            }
        }
 
        vkCmdEndRendering( commandBuffer );
    }
 
    void Renderer::updateCpuRenderResources( float time )
    {
        // NOTE: processPendingDeletions() moved to submitTransfer() after fence wait
        // to ensure GPU work is complete before deleting buffers
 
        syncCopyObjects.clear();
        // Update the uniform buffer data
        {
            TRACY_ZONE_SCOPED_NAMED( "Update uniform buffers" );
 
            RenderProcess * currentRenderProcess = getCurrentRenderProcess();
            Renderer *      thisRenderer         = this;
 
            std::future<void> futureUpdatePerObjectSSBO =
                updateThreadPool.submit_task(
                [&currentRenderProcess, &thisRenderer]() -> void
                {
                    currentRenderProcess->updateSSBO( thisRenderer );
                }
            );
 
            std::future<void> futureMeshData =
                updateThreadPool.submit_task(
                [&currentRenderProcess]() -> void
                {
                    currentRenderProcess->updateMeshRenderingData();
                }
            );
 
            std::future<void> futureUpdateViewMatrix =
                updateThreadPool.submit_task(
                    [this]() -> void
                    {
                        updateViewMatrix();
                    }
                );
 
            std::future<void> futureUpdateFragmentTime =
                updateThreadPool.submit_task(
                [&currentRenderProcess, time]() -> void
                {
                    currentRenderProcess->updateFragmentTime( time );
                }
            );
 
            std::future<void> futureUpdateObjectMeshletData =
                updateThreadPool.submit_task(
                [&currentRenderProcess]() -> void
                    {
                        currentRenderProcess->updateMeshletDataBuffer();
                    }
                );
 
            {
                TRACY_ZONE_SCOPED_NAMED( "Waiting for buffer creation to finish" );
                futureUpdatePerObjectSSBO.get();
                futureUpdateObjectMeshletData.get();
                futureMeshData.get();
                futureUpdateViewMatrix.get();
                futureUpdateFragmentTime.get();
            }
 
            // uploads data to staging buffers to be transfered later on
            syncCopyObjects.push_back( getCurrentRenderProcess()->uploadFrustumUBO() );
            syncCopyObjects.push_back( getCurrentRenderProcess()->uploadHiZViewProjectionUBO() );  // Per-frame Hi-Z data
            syncCopyObjects.push_back( getCurrentRenderProcess()->uploadUniformBufferData() );
 
            // Add RenderingDataManager staged buffer uploads (structural updates)
            auto& rdmSyncObjects = renderingDataManager->getPendingSyncObjects();
            syncCopyObjects.insert( syncCopyObjects.end(), rdmSyncObjects.begin(), rdmSyncObjects.end() );
            renderingDataManager->clearPendingSyncObjects();
 
            // Add RenderingDataManager transform updates (per-frame dynamic data)
            auto& transformSyncObjects = renderingDataManager->getPendingTransformSyncObjects();
            syncCopyObjects.insert( syncCopyObjects.end(), transformSyncObjects.begin(), transformSyncObjects.end() );
            renderingDataManager->clearPendingTransformSyncObjects();
        }
    }
 
    void Renderer::restartRenderCommandBuffers() const
    {
        TRACY_ZONE_SCOPED_NAMED( "Command buffer setup" );
        PLOG_RETURN_FN_VK( vkResetCommandBuffer( getCurrentRenderProcess()->getGraphicsCommandBuffer(), 0u ) )
 
        VkCommandBufferBeginInfo commandBufferBeginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
        PLOG_RETURN_FN_VK( vkBeginCommandBuffer(
            getCurrentRenderProcess()->getGraphicsCommandBuffer(), &commandBufferBeginInfo
        ) )
    }
 
    void Renderer::recordXrSwapchainImageWritableBarrier( const uint32_t swapChainImageIndex ) const
    {
        TRACY_ZONE_SCOPED_NAMED( "Swapchain image writable barrier" );
        TRACY_VK_ZONE_C(
            tracyVkContext[currentFrame],
            getCurrentRenderProcess()->getGraphicsCommandBuffer(),
            "Swapchain Image Barrier",
            Colors::Gray
        )
 
        VkImageMemoryBarrier2 imageBarrierToAttachment = {};
        imageBarrierToAttachment.sType                 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
 
        // Transition from unknown layout to color attachment for rendering.
        // Wait for any previous render pass to complete before starting new one.
        // Use UNDEFINED as oldLayout since we clear the image (contents don't matter).
        imageBarrierToAttachment.srcStageMask        = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        imageBarrierToAttachment.srcAccessMask       = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
        imageBarrierToAttachment.dstStageMask        = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        imageBarrierToAttachment.dstAccessMask       = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
        imageBarrierToAttachment.oldLayout           = VK_IMAGE_LAYOUT_UNDEFINED;
        imageBarrierToAttachment.newLayout           = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        imageBarrierToAttachment.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageBarrierToAttachment.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageBarrierToAttachment.image               = headset->getSwapchainImage( swapChainImageIndex );
        imageBarrierToAttachment.subresourceRange    = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 2 };
 
        VkDependencyInfo dependencyInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
        dependencyInfo.imageMemoryBarrierCount = 1;
        dependencyInfo.pImageMemoryBarriers    = &imageBarrierToAttachment;
        vkCmdPipelineBarrier2( getCurrentRenderProcess()->getGraphicsCommandBuffer(), &dependencyInfo );
    }
 
    void Renderer::recordRenderPass( const size_t swapChainImageIndex )
    {
        GRAPHICS_GUARD()
        TRACY_ZONE_SCOPED_NAMED( "Pass 1 Render" );
 
        RenderProcess* currentRenderProcess = getCurrentRenderProcess();
        VkCommandBuffer commandBuffer = currentRenderProcess->getGraphicsCommandBuffer();
        TRACY_VK_ZONE_C( getCurrentTracyVkContext(), commandBuffer, "Pass 1 Render", Colors::Green );
 
        // Get render target info
        const RenderTarget* renderTarget = headset->getRenderTarget( swapChainImageIndex );
        const VkExtent2D extent = headset->getEyeResolution( 0u );
 
        // Transition images for Pass 1 (DEPTH-ONLY Z-PREPASS):
        // - Depth: UNDEFINED → DEPTH_STENCIL_ATTACHMENT (cleared)
        // - NO color transition needed - Pass 1 is depth-only for "Double-Speed Z"
        // - Swapchain: Already transitioned in recordXrSwapchainImageWritableBarrier
 
        VkImageMemoryBarrier2 depthBarrier{
            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
            .srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT,
            .srcAccessMask = VK_ACCESS_2_NONE,
            .dstStageMask = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
            .dstAccessMask = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
            .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
            .newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .image = headset->getDepthBufferImage(),
            .subresourceRange = {
                .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 2  // Stereo
            }
        };
 
        VkDependencyInfo dependencyInfo{
            .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
            .imageMemoryBarrierCount = 1,
            .pImageMemoryBarriers = &depthBarrier
        };
        vkCmdPipelineBarrier2( commandBuffer, &dependencyInfo );
 
        // Set up dynamic rendering attachments - DEPTH ONLY (no color attachment)
        // This enables "Double-Speed Z" optimization on NVIDIA/AMD GPUs
        VkClearValue clearDepth = { .depthStencil = { .depth = 0.0f, .stencil = 0 } };  // Reverse-Z: 0 = far
        VkRenderingAttachmentInfo depthAttachment{
            .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
            .imageView = headset->getDepthBufferView(),  // MSAA depth buffer
            .imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
            .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
            .clearValue = clearDepth,
        };
 
        VkRenderingInfo renderingInfo{
            .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
            .renderArea = { .offset = {0, 0}, .extent = extent },
            .layerCount = 1,
            .viewMask = 0b11,  // Stereo: render to both layers
            .colorAttachmentCount = 0,       // NO COLOR - depth-only prepass
            .pColorAttachments = nullptr,    // NO COLOR - depth-only prepass
            .pDepthAttachment = &depthAttachment,
        };
 
        vkCmdBeginRendering( commandBuffer, &renderingInfo );
 
        // Set viewport and scissor
        VkViewport viewport{
            .x = 0.0f, .y = 0.0f,
            .width = static_cast<float>( extent.width ),
            .height = static_cast<float>( extent.height ),
            .minDepth = 0.0f, .maxDepth = 1.0f
        };
        vkCmdSetViewport( commandBuffer, 0, 1, &viewport );
 
        VkRect2D scissor{ .offset = {0, 0}, .extent = extent };
        vkCmdSetScissor( commandBuffer, 0, 1, &scissor );
 
        // Bind descriptor set
        VkDescriptorSet descriptorSet = currentRenderProcess->getGraphicsDescriptorSet();
        vkCmdBindDescriptorSets(
            commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
            graphicsPipelineLayout, 0, 1, &descriptorSet, 0, nullptr
        );
 
        // Draw single-meshlet geometry using vertex shader path (DEPTH-ONLY pipeline)
        recordVertexShaderDrawsDepthOnly(swapChainImageIndex);
 
        // Loop through all DEPTH-ONLY pipelines (mesh shader path for multi-meshlet geometry)
        for ( uint32_t pipelineIndex = 0; pipelineIndex < depthOnlyGraphicsPipelines.size(); pipelineIndex++ )
        {
            if ( pipelineIndex != 0 )
            {
                VkConditionalRenderingBeginInfoEXT conditionalRenderingBeginInfo = {
                    .sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
                    .buffer = currentRenderProcess->getIndirectDrawBuffer().getBuffer(),
                    .offset = pipelineIndex * sizeof( VkDrawMeshTasksIndirectCommandEXT ) +
                              offsetof( VkDrawMeshTasksIndirectCommandEXT, groupCountX ),
                    .flags = 0
                };
                VulkanHelper::getFunctions().vkCmdBeginConditionalRenderingEXT(
                    commandBuffer, &conditionalRenderingBeginInfo
                );
            }
 
            depthOnlyGraphicsPipelines[pipelineIndex]->bind( commandBuffer );
 
            TaskConstants taskConstants( pipelineIndex * MAX_MESHLETS_PER_BIN );
            vkCmdPushConstants(
                commandBuffer, graphicsPipelineLayout,
                VK_SHADER_STAGE_MESH_BIT_EXT | VK_SHADER_STAGE_FRAGMENT_BIT,
                0, sizeof( TaskConstants ), &taskConstants
            );
 
            VulkanHelper::getFunctions().vkCmdDrawMeshTasksIndirectEXT(
                commandBuffer,
                currentRenderProcess->getIndirectDrawBuffer().getBuffer(),
                pipelineIndex * sizeof( VkDrawMeshTasksIndirectCommandEXT ),
                1,
                sizeof( VkDrawMeshTasksIndirectCommandEXT )
            );
 
            if ( pipelineIndex != 0 )
            {
                VulkanHelper::getFunctions().vkCmdEndConditionalRenderingEXT( commandBuffer );
            }
        }
 
        vkCmdEndRendering( commandBuffer );
 
        // Transition depth buffer to SHADER_READ_ONLY for Hi-Z generation
        // NOTE: With dynamic rendering (vkCmdBeginRendering), there's no automatic layout
        // transition at vkCmdEndRendering - we must do it manually.
        {
            VkImageMemoryBarrier2 depthToReadBarrier{
                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
                .srcStageMask = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
                .srcAccessMask = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
                .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
                .dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
                .oldLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                .newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
                .image = headset->getDepthBufferImage(),
                .subresourceRange = {
                    .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
                    .baseMipLevel = 0,
                    .levelCount = 1,
                    .baseArrayLayer = 0,
                    .layerCount = 2  // Stereo
                }
            };
 
            VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
            depInfo.imageMemoryBarrierCount = 1;
            depInfo.pImageMemoryBarriers = &depthToReadBarrier;
            vkCmdPipelineBarrier2( commandBuffer, &depInfo );
        }
    }
 
    void Renderer::recordXrSwapchainImageFinishedWritingBarrier( const uint32_t swapChainImageIndex ) const
    {
        TRACY_ZONE_SCOPED_NAMED( "Swapchain image finished writing barrier" );
 
        // This barrier synchronizes the swapchain image for external consumers:
        // 1. MirrorView's blit operation (TRANSFER_READ at BLIT_BIT)
        // 2. SteamVR compositor's copy operation (TRANSFER_READ at COPY_BIT)
        //
        // IMPORTANT: Per OpenXR spec, we must NOT change the layout - it must remain
        // in COLOR_ATTACHMENT_OPTIMAL when xrReleaseSwapchainImage is called.
        // The runtime is responsible for any layout transitions it needs for compositing.
        //
        // The validation errors about SteamVR expecting TRANSFER_SRC_OPTIMAL are a
        // documented SteamVR spec violation (GitHub issue #1822), not our bug.
 
        VkImageMemoryBarrier2 barrier{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
        barrier.pNext               = nullptr;
        // Wait for render pass color attachment writes to complete
        barrier.srcStageMask        = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        barrier.srcAccessMask       = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
        // Make data available for transfer operations (blit/copy by MirrorView and SteamVR compositor)
        barrier.dstStageMask        = VK_PIPELINE_STAGE_2_BLIT_BIT | VK_PIPELINE_STAGE_2_COPY_BIT;
        barrier.dstAccessMask       = VK_ACCESS_2_TRANSFER_READ_BIT;
        // NO layout transition - keep in COLOR_ATTACHMENT_OPTIMAL per OpenXR spec
        barrier.oldLayout           = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        barrier.newLayout           = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.image               = headset->getSwapchainImage( swapChainImageIndex );
        // Both array layers (for multiview stereo rendering)
        barrier.subresourceRange    = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 2 };
 
        VkDependencyInfo dependencyInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
        dependencyInfo.pNext                   = nullptr;
        dependencyInfo.dependencyFlags         = 0;
        dependencyInfo.memoryBarrierCount      = 0;
        dependencyInfo.pMemoryBarriers         = nullptr;
        dependencyInfo.bufferMemoryBarrierCount = 0;
        dependencyInfo.pBufferMemoryBarriers   = nullptr;
        dependencyInfo.imageMemoryBarrierCount = 1;
        dependencyInfo.pImageMemoryBarriers    = &barrier;
 
        vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &dependencyInfo );
    }
 
    const std::unique_ptr<RenderingDataManager> & Renderer::getRenderingDataManager() const
    {
        return renderingDataManager;
    }
 
    void Renderer::createDispatchBuffer() {
        dispatchBuffer.emplace(context);
        constexpr VkDeviceSize size = sizeof( VkDrawMeshTasksIndirectCommandEXT );
        dispatchBuffer->create( size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT );
        dispatchBuffer->setDebugName("Dispatch Buffer");
    }
 
    void Renderer::createPlaceholderBuffer()
    {
        placeholderBuffer.emplace(context);
        constexpr VkDeviceSize size = sizeof(uint32_t);
        placeholderBuffer->create( size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT );
        placeholderBuffer->setDebugName( "Placeholder Buffer" );
    }
 
    void Renderer::createPlaceholderUniformBuffer()
    {
        placeholderUniformBuffer.emplace(context);
        constexpr VkDeviceSize size = sizeof(uint32_t);
        placeholderUniformBuffer->create( size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT );
        placeholderUniformBuffer->setDebugName( "Placeholder Uniform Buffer" );
    }
 
    void Renderer::createCounterBuffer() {
        counterBuffer.emplace(context);
        constexpr VkDeviceSize size = sizeof(uint32_t);
        counterBuffer->create(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT );
        counterBuffer->setDebugName( "Counter Buffer" );
    }
 
    void Renderer::createObjectIDsBuffer() {
        objectIDsBuffer.emplace(context);
        // Support up to 4096 primitives (4 bytes per uint ID = 16KB)
        constexpr VkDeviceSize size = 4096 * sizeof(uint32_t);
        objectIDsBuffer->create(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        objectIDsBuffer->setDebugName("Object IDs Buffer");
    }
 
    void Renderer::createObjectCullingDataBuffer() {
        objectCullingDataBuffer.emplace(context);
        // Support up to 4096 primitives (32 bytes per ObjectCullingData = 128KB)
        constexpr VkDeviceSize size = 4096 * 32;
        objectCullingDataBuffer->create(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        objectCullingDataBuffer->setDebugName("Object Culling Data Buffer");
    }
 
    void Renderer::createObjectMeshletDataBuffer() {
        objectMeshletDataBuffer.emplace(context);
        // Support up to 4096 primitives (16 bytes per entry = 64KB)
        constexpr VkDeviceSize size = 4096 * 16;
        objectMeshletDataBuffer->create(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        objectMeshletDataBuffer->setDebugName("Object Meshlet Data Buffer");
    }
 
    void Renderer::createMeshUnpackingDataBuffer() {
        meshUnpackingDataBuffer.emplace(context);
        // Support up to 4096 primitives (4 bytes per uint survivor ID = 16KB)
        constexpr VkDeviceSize size = 4096 * sizeof(uint32_t);
        meshUnpackingDataBuffer->create(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
        meshUnpackingDataBuffer->setDebugName("Mesh Unpacking Data Buffer");
    }
 
    const VulkanBuffer & Renderer::getObjectCullingDataBuffer() const
    {
        return objectCullingDataBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getObjectMeshletDataBuffer() const
    {
        return objectMeshletDataBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getObjectIDsBuffer() const
    {
        return objectIDsBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getCounterBuffer() const
    {
        return counterBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getDispatchBuffer() const {
        return dispatchBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getMeshUnpackingDataBuffer() const
    {
        return meshUnpackingDataBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getPlaceholderBuffer() const
    {
        return placeholderBuffer.value();
    }
 
    const VulkanBuffer & Renderer::getPlaceholderUniformBuffer() const
    {
        return placeholderUniformBuffer.value();
    }
 
    bool Renderer::ensureOutputBufferSizes(uint32_t primitiveCount)
    {
        bool anyRecreated = false;
        constexpr VkMemoryPropertyFlags deviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        constexpr VkBufferUsageFlags storageUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
        constexpr VkBufferUsageFlags storageTransferUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 
        // Calculate required sizes based on primitive count
        // meshUnpackingDataBuffer stores uint per surviving primitive (culling output)
        const VkDeviceSize meshUnpackingSize = primitiveCount * sizeof(uint32_t);
        anyRecreated |= meshUnpackingDataBuffer->ensureSize(meshUnpackingSize, storageUsage, deviceLocal);
 
        // objectIDsBuffer stores uint per primitive
        const VkDeviceSize objectIDsSize = primitiveCount * sizeof(uint32_t);
        anyRecreated |= objectIDsBuffer->ensureSize(objectIDsSize, storageTransferUsage, deviceLocal);
 
        // objectCullingDataBuffer stores ObjectCullingData (32 bytes) per primitive
        const VkDeviceSize cullingDataSize = primitiveCount * 32;
        anyRecreated |= objectCullingDataBuffer->ensureSize(cullingDataSize, storageUsage, deviceLocal);
 
        // objectMeshletDataBuffer stores meshlet metadata per primitive
        const VkDeviceSize meshletDataSize = primitiveCount * 16;
        anyRecreated |= objectMeshletDataBuffer->ensureSize(meshletDataSize, storageUsage, deviceLocal);
 
        // Resize RenderProcess buffers for each eye
        for (RenderProcess* renderProcess : renderProcesses) {
            if (renderProcess) {
                anyRecreated |= renderProcess->ensureBufferSizes(primitiveCount);
            }
        }
 
        if (anyRecreated) {
            PLOGI << "Renderer: Output buffers resized for " << primitiveCount << " primitives";
        }
 
        return anyRecreated;
    }
 
    VkDependencyInfo Renderer::getObjectCullingToMeshletUnpackingDispatchBarriers(Vulkan::BarrierBundle & bundle ) const
    {
        bundle.addComputeBufferBarrier(
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_WRITE_BIT,
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_READ_BIT,
            counterBuffer.value()
            );
 
        return bundle.getDependencyInfo();
    }
 
    VkDependencyInfo Renderer::getMeshletUnpackingDispatchToMeshletUnpackingBarriers(Vulkan::BarrierBundle &bundle) const {
        bundle.addComputeBufferBarrier(
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_WRITE_BIT,
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_READ_BIT,
            dispatchBuffer.value()
            );
 
        bundle.addComputeBufferBarrier(
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_WRITE_BIT,
            VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,
            VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT,
            dispatchBuffer.value()
        );
 
        return bundle.getDependencyInfo();
    }
 
    VkDependencyInfo Renderer::getMeshletUnpackingToMeshletCullingDispatchBarriers( Vulkan::BarrierBundle & bundle )
    {
        // Meshlet Unpacking writes to meshletCounterBuffer (counts per pipeline)
        // Meshlet Culling Dispatch reads meshletCounterBuffer to compute dispatch size
        bundle.addComputeBufferBarrier(
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_WRITE_BIT,
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_READ_BIT,
            getCurrentRenderProcess()->getMeshletCounterBuffer()
        );
 
        return bundle.getDependencyInfo();
    }
 
    VkDependencyInfo Renderer::getMeshletCullingDispatchToMeshletCullingBarriers()
    {
        // Meshlet Culling Dispatch writes to dispatchBuffer
        // Meshlet Culling reads dispatchBuffer via vkCmdDispatchIndirect
        static Vulkan::BarrierBundle bundle;
        bundle.clear();
 
        bundle.addComputeBufferBarrier(
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_WRITE_BIT,
            VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,
            VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT,
            dispatchBuffer.value()
        );
 
        return bundle.getDependencyInfo();
    }
 
    VkDependencyInfo Renderer::getMeshletCullingToPrepareDrawBarriers()
    {
        // Meshlet Culling writes to meshletCounterBuffer (visible meshlet counts)
        // Prepare Draw reads meshletCounterBuffer
        static Vulkan::BarrierBundle bundle;
        bundle.clear();
 
        bundle.addComputeBufferBarrier(
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_WRITE_BIT,
            VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
            VK_ACCESS_2_SHADER_READ_BIT,
            getCurrentRenderProcess()->getMeshletCounterBuffer()
        );
 
        return bundle.getDependencyInfo();
    }
 
    void Renderer::resetMeshletUnpackingDispatchBuffers()
    {
        // Barrier: wait for previous frame's fill AND compute reads before new fill
        // Uses ALL_COMMANDS since this buffer is shared across frames
        VkBufferMemoryBarrier2 barrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
        barrier.srcStageMask        = VK_PIPELINE_STAGE_2_CLEAR_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
        barrier.srcAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT | VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
        barrier.dstStageMask        = VK_PIPELINE_STAGE_2_CLEAR_BIT;
        barrier.dstAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.buffer              = counterBuffer->getBuffer();
        barrier.offset              = 0;
        barrier.size                = VK_WHOLE_SIZE;
 
        VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
        depInfo.bufferMemoryBarrierCount = 1;
        depInfo.pBufferMemoryBarriers    = &barrier;
        vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &depInfo );
 
        vkCmdFillBuffer(getCurrentRenderingCommandBuffer(), counterBuffer->getBuffer(), 0, sizeof(uint32_t), 0);
    }
 
    void Renderer::resetMeshletCullingDispatchBuffers()
    {
        // Reset the meshlet counter buffer before meshlet culling writes to it
        // This is needed because meshlet culling uses atomic adds to count visible meshlets
 
        // Barrier: wait for previous frame's fill AND compute reads before new fill
        VkBufferMemoryBarrier2 barrier{ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
        barrier.srcStageMask        = VK_PIPELINE_STAGE_2_CLEAR_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
        barrier.srcAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT | VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
        barrier.dstStageMask        = VK_PIPELINE_STAGE_2_CLEAR_BIT;
        barrier.dstAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.buffer              = getCurrentRenderProcess()->getMeshletCounterBuffer().getBuffer();
        barrier.offset              = 0;
        barrier.size                = VK_WHOLE_SIZE;
 
        VkDependencyInfo depInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
        depInfo.bufferMemoryBarrierCount = 1;
        depInfo.pBufferMemoryBarriers    = &barrier;
        vkCmdPipelineBarrier2( getCurrentRenderingCommandBuffer(), &depInfo );
 
        vkCmdFillBuffer(
            getCurrentRenderingCommandBuffer(),
            getCurrentRenderProcess()->getMeshletCounterBuffer().getBuffer(),
            0,
            VK_WHOLE_SIZE,
            0
        );
    }
 
    bool Renderer::getPipelineIndex( GraphicsPipeline * pipeline, uint32_t & pipelineIndex ) const
    {
        const auto it = pipelineIndices.find( pipeline );
        if ( it != pipelineIndices.end() )
        {
            pipelineIndex = it->second;
            return true;
        }
        return false;
    }
 
    bool Renderer::getPipelineIndex( PipelineNames pipelineName, uint32_t & pipelineIndex ) const
    {
        const auto it = pipelinesByName.find( pipelineName );
        if ( it != pipelinesByName.end() )
        {
            return getPipelineIndex( it->second, pipelineIndex );
        }
        return false;
    }
 
    PipelineConfig Renderer::getPipelineConfig( PipelineNames pipelineName )
    {
        using namespace std::filesystem;
        const path shaderDir = Path::engineShaders() / "Output";
 
        switch ( pipelineName )
        {
            case DIFFUSE_FLAT_COLOR:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_flat.frag.spv"
                };
 
            case DIFFUSE_SHADER:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle.frag.spv"
                };
 
            case MOVABLE_DIFFUSE_SHADER:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable_full.frag.spv"
                };
 
            case NORMALS_SHADER:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable_normals.frag.spv"
                };
 
            case L0_SHADER:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable_l0.frag.spv"
                };
 
            case L1_SHADER:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable_l1.frag.spv"
                };
 
            case L2_SHADER:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable_l2.frag.spv"
                };
 
            case DYNAMIC_TEXTURES:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable.frag.spv"
                };
 
            case STATIC_LIGHTMAP:
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_static_lightmap.frag.spv"
                };
 
            default:
                PLOGW << "Unknown PipelineNames enum: " << static_cast<int>(pipelineName) << ", returning NORMALS_SHADER config";
                return PipelineConfig{
                    .meshShaderPath = shaderDir / "triangle.mesh.spv",
                    .fragmentShaderPath = shaderDir / "triangle_movable_normals.frag.spv"
                };
        }
    }
 
#ifdef ENABLE_TRACY
    TracyVkCtx Renderer::getCurrentTracyVkContext() const
    {
        return tracyVkContext[currentFrame];
    }
#endif
}  // namespace EngineCore