Headset.cpp

Go to the documentation of this file.

#include "Engine/Logging/TracyMacros.hpp"
 
#include <cmath>
#include <Engine/Core/ApplicationContext.h>
#include <Engine/Core/OpenXrHelper.h>
#include <Engine/Core/VulkanHelper.h>
#include <Engine/Renderer/Headset.h>
#include <Engine/Renderer/NamedThreadPool.h>
#include <array>
#include <chrono>
#include <future>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/string_cast.hpp>
#include <plog/Log.h>
#include <vulkan/vulkan_core.h>
 
#include "Engine/Renderer/Renderer.h"
 
namespace
{
constexpr XrReferenceSpaceType spaceType = XR_REFERENCE_SPACE_TYPE_STAGE;
constexpr VkFormat colorFormat = VK_FORMAT_R8G8B8A8_SRGB; //_RGBA8UnormSrgb
constexpr VkFormat depthFormat = VK_FORMAT_D32_SFLOAT;
} // namespace
 
namespace EngineCore
{
Headset::Headset(const ApplicationContext* context) : context(context)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_FUNCTION;
#endif
    // Create named thread pool for xrWaitFrame timeout handling (visible in Tracy as "XR Wait 1")
    xrWaitThreadPool_ = std::make_unique<NamedThreadPool>(1, "XR Wait");
 
    const VkDevice device = context->getVkDevice();
    const VkSampleCountFlagBits multisampleCount = context->getMultisampleCount();
 
    // create Render Pass
    {
        constexpr uint32_t viewMask = 0b00000011;
        constexpr uint32_t correlationMask = 0b00000011;
 
        VkRenderPassMultiviewCreateInfo renderPassMultiviewCreateInfo{};
        renderPassMultiviewCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
        renderPassMultiviewCreateInfo.subpassCount = 1u;
        renderPassMultiviewCreateInfo.pViewMasks = &viewMask;
        renderPassMultiviewCreateInfo.correlationMaskCount = 1u;
        renderPassMultiviewCreateInfo.pCorrelationMasks = &correlationMask;
 
        VkAttachmentDescription colorAttachmentDescription{};
        colorAttachmentDescription.format = colorFormat;
        colorAttachmentDescription.samples = multisampleCount;
        colorAttachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
        colorAttachmentDescription.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; // Use DONT_CARE for multisampled attachments for lazy memory allocation
        colorAttachmentDescription.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        colorAttachmentDescription.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        colorAttachmentDescription.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        colorAttachmentDescription.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
        VkAttachmentReference colorAttachmentReference{};
        colorAttachmentReference.attachment = 0u;
        colorAttachmentReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
        VkAttachmentDescription depthAttachmentDescription{};
        depthAttachmentDescription.format = depthFormat;
        depthAttachmentDescription.samples = multisampleCount;
        depthAttachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
        depthAttachmentDescription.storeOp = VK_ATTACHMENT_STORE_OP_STORE;  // Store for Hi-Z generation
        depthAttachmentDescription.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        depthAttachmentDescription.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        // Use UNDEFINED since we CLEAR the depth buffer - contents are discarded anyway.
        // This avoids synchronization issues with shared depth buffer across frames.
        depthAttachmentDescription.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        depthAttachmentDescription.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;  // For Hi-Z sampling
 
        VkAttachmentReference depthAttachmentReference;
        depthAttachmentReference.attachment = 1u;
        depthAttachmentReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 
        VkAttachmentDescription resolveAttachmentDescription{};
        resolveAttachmentDescription.format = colorFormat;
        resolveAttachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
        resolveAttachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        resolveAttachmentDescription.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
        resolveAttachmentDescription.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        resolveAttachmentDescription.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        // Use UNDEFINED as initial layout since the pre-render barrier transitions
        // the swapchain image from UNDEFINED to COLOR_ATTACHMENT_OPTIMAL before the render pass.
        // This is safe because the MSAA resolve operation will completely overwrite the image.
        resolveAttachmentDescription.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        resolveAttachmentDescription.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
        VkAttachmentReference resolveAttachmentReference{};
        resolveAttachmentReference.attachment = 2u;
        resolveAttachmentReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
        VkSubpassDescription subpassDescription{};
        subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
        subpassDescription.colorAttachmentCount = 1u;
        subpassDescription.pColorAttachments = &colorAttachmentReference;
        subpassDescription.pDepthStencilAttachment = &depthAttachmentReference;
        subpassDescription.pResolveAttachments = &resolveAttachmentReference;
 
        const std::array attachments = {
            colorAttachmentDescription,
            depthAttachmentDescription,
            resolveAttachmentDescription
        };
 
        // Subpass dependencies for external synchronization
        // These ensure proper synchronization between render passes across frames
        std::array<VkSubpassDependency, 2> dependencies{};
 
        // External -> Subpass 0: Synchronize with previous frame's render pass
        // Wait for previous color/depth writes to complete before starting new render pass
        dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
        dependencies[0].dstSubpass = 0;
        dependencies[0].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
                                       VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
                                       VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
        dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
                                       VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
                                       VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
        dependencies[0].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                                        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
        dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                                        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
        dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
 
        // Subpass 0 -> External: Ensure render pass completes before external operations
        // This synchronizes with the MirrorView's blit operation and SteamVR's compositor copy operations
        dependencies[1].srcSubpass = 0;
        dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
        dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
                                       VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
                                       VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
        // Use TRANSFER_BIT to cover both blit and copy operations (MirrorView blit + SteamVR compositor copy)
        dependencies[1].dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
        dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                                        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
        dependencies[1].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
        // Remove BY_REGION_BIT as the transfer operations may not be region-local
        dependencies[1].dependencyFlags = 0;
 
        VkRenderPassCreateInfo renderPassCreateInfo{VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO};
        renderPassCreateInfo.pNext = &renderPassMultiviewCreateInfo;
        renderPassCreateInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
        renderPassCreateInfo.pAttachments = attachments.data();
        renderPassCreateInfo.subpassCount = 1u;
        renderPassCreateInfo.pSubpasses = &subpassDescription;
        renderPassCreateInfo.dependencyCount = static_cast<uint32_t>(dependencies.size());
        renderPassCreateInfo.pDependencies = dependencies.data();
        PLOG_FN_VK(vkCreateRenderPass(context->getVkDevice(), &renderPassCreateInfo, nullptr, &vkRenderPass));
        VulkanHelper::setObjectName(context->getVkDevice(), vkRenderPass, "Headset render pass");
 
        PLOGI << "Renderpass created!";
    }
 
    const uint32_t vkDrawQueueFamilyIndex = context->getVkGraphicsQueueFamilyIndex();

    {
        XrGraphicsBindingVulkan2KHR graphicsBinding{XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR};
        graphicsBinding.device = device;
        graphicsBinding.instance = context->getVkInstance();
        graphicsBinding.physicalDevice = context->getVkPhysicalDevice();
        graphicsBinding.queueFamilyIndex = vkDrawQueueFamilyIndex;
        graphicsBinding.queueIndex = 0u;
 
        XrSessionCreateInfo xrSessionCreateInfo{XR_TYPE_SESSION_CREATE_INFO};
        xrSessionCreateInfo.next = &graphicsBinding;
        xrSessionCreateInfo.systemId = context->getXrSystemId();
        PLOG_THROW_FN_XR(xrCreateSession(context->getXrInstance(), &xrSessionCreateInfo, &xrSession));
    }

    {
        XrReferenceSpaceCreateInfo referenceSpaceCreateInfo{XR_TYPE_REFERENCE_SPACE_CREATE_INFO};
        referenceSpaceCreateInfo.referenceSpaceType = spaceType;
        referenceSpaceCreateInfo.poseInReferenceSpace = OpenXrHelper::makeIdentityPose();
        PLOG_THROW_FN_XR(xrCreateReferenceSpace(xrSession, &referenceSpaceCreateInfo, &xrReferenceSpace));
    }
 
    const XrViewConfigurationType xrViewType = context->getXrViewType();

    {
        PLOG_THROW_FN_XR(xrEnumerateViewConfigurationViews(context->getXrInstance(), context->getXrSystemId(),
                                                           xrViewType, 0u, reinterpret_cast<uint32_t*>(&eyeCount),
                                                           nullptr));
 
        eyeImageInfos.resize(eyeCount);
        for(XrViewConfigurationView& eyeInfo : eyeImageInfos)
        {
            eyeInfo.type = XR_TYPE_VIEW_CONFIGURATION_VIEW;
            eyeInfo.next = nullptr;
        }
 
        PLOG_THROW_FN_XR(xrEnumerateViewConfigurationViews(context->getXrInstance(), context->getXrSystemId(),
                                                           xrViewType, eyeCount, reinterpret_cast<uint32_t*>(&eyeCount),
                                                           eyeImageInfos.data()));
    }

    {
        eyePoses.resize(eyeCount);
        for(XrView& eyePose : eyePoses)
        {
            eyePose.type = XR_TYPE_VIEW;
            eyePose.next = nullptr;
        }
    }

    {
        uint32_t swapchainFormatCount = 0u;
        PLOG_FN_XR(xrEnumerateSwapchainFormats(xrSession, 0u, &swapchainFormatCount, nullptr));
 
        std::vector<int64_t> swapchainFormats(swapchainFormatCount);
        PLOG_FN_XR(xrEnumerateSwapchainFormats(xrSession, swapchainFormatCount, &swapchainFormatCount,
                                               swapchainFormats.data()));
 
        bool doesSwapchainFormatExist = false;
        for(const int64_t& format : swapchainFormats)
        {
            if(format == static_cast<int64_t>(colorFormat))
            {
                doesSwapchainFormatExist = true;
                break;
            }
        }
 
        if(!doesSwapchainFormatExist)
        {
            THROW_ERROR("Color swapchain format does not exist!");
        }
 
        PLOGI << "Color format is supported by eyes";
    }
 
    const VkExtent2D eyeResolution = getEyeResolution(0u);

    uint32_t layerCount = 2u;
    // color
    {
        colorBuffer = ImageBuffer();
 
        VkImageCreateInfo imageCreateInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
        imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
        imageCreateInfo.extent.width = eyeResolution.width;
        imageCreateInfo.extent.height = eyeResolution.height;
        imageCreateInfo.extent.depth = 1u;
        imageCreateInfo.mipLevels = 1u;
        imageCreateInfo.arrayLayers = static_cast<uint32_t>(layerCount);
        imageCreateInfo.format = colorFormat;
        imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
        imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageCreateInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
        imageCreateInfo.samples = multisampleCount;
        imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        PLOG_THROW_FN_VK(vkCreateImage(device, &imageCreateInfo, nullptr, &colorBuffer.image));
        VulkanHelper::setObjectName(context->getVkDevice(), colorBuffer.image, "color buffer image");
 
        // get memory
        VkImageMemoryRequirementsInfo2 memoryRequirementsInfo{};
        memoryRequirementsInfo.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
        memoryRequirementsInfo.image = colorBuffer.image;
        memoryRequirementsInfo.pNext = nullptr;
 
        VkMemoryRequirements2 memoryRequirements{VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
        vkGetImageMemoryRequirements2(device, &memoryRequirementsInfo, &memoryRequirements);
 
        uint32_t suiteableMemoryTypeIndex = 0u;
        if(!VulkanHelper::findSuitableMemoryType(context->getVkPhysicalDevice(), memoryRequirements,
                                                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, suiteableMemoryTypeIndex))
        {
            THROW_ERROR("Could not find a suitable memory type for the image buffer");
        }
 
        // Allocate image memory
        VkMemoryAllocateInfo memoryAllocateInfo{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
        memoryAllocateInfo.allocationSize = memoryRequirements.memoryRequirements.size;
        memoryAllocateInfo.memoryTypeIndex = suiteableMemoryTypeIndex;
        PLOG_FN_VK(vkAllocateMemory(device, &memoryAllocateInfo, nullptr, &colorBuffer.deviceMemory));
        VulkanHelper::setObjectName(context->getVkDevice(), colorBuffer.deviceMemory, "color buffer memory");
 
        VkBindImageMemoryInfo bindImageMemoryInfo{VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO};
        bindImageMemoryInfo.image = colorBuffer.image;
        bindImageMemoryInfo.memory = colorBuffer.deviceMemory;
        bindImageMemoryInfo.memoryOffset = 0u;
        bindImageMemoryInfo.pNext = nullptr;
        PLOG_FN_VK(vkBindImageMemory2(device, 1u, &bindImageMemoryInfo));
 
        // create image view
        VkImageViewCreateInfo imageViewCreateInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
        imageViewCreateInfo.image = colorBuffer.image;
        imageViewCreateInfo.format = colorFormat;
        imageViewCreateInfo.viewType = (layerCount == 1u ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
        imageViewCreateInfo.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
                                          VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
        imageViewCreateInfo.subresourceRange.layerCount = static_cast<uint32_t>(layerCount);
        imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        imageViewCreateInfo.subresourceRange.baseArrayLayer = 0u;
        imageViewCreateInfo.subresourceRange.baseMipLevel = 0u;
        imageViewCreateInfo.subresourceRange.levelCount = 1u;
        PLOG_FN_VK(vkCreateImageView(device, &imageViewCreateInfo, nullptr, &colorBuffer.imageView));
        VulkanHelper::setObjectName(context->getVkDevice(), colorBuffer.imageView, "color buffer image view");
 
        PLOGI << "Created color buffer";
    }
 
    {
        depthBuffer = ImageBuffer();
 
        VkImageCreateInfo imageCreateInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
        imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
        imageCreateInfo.extent.width = eyeResolution.width;
        imageCreateInfo.extent.height = eyeResolution.height;
        imageCreateInfo.extent.depth = 1u;
        imageCreateInfo.mipLevels = 1u;
        imageCreateInfo.arrayLayers = static_cast<uint32_t>(layerCount);
        imageCreateInfo.format = depthFormat;
        imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
        imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageCreateInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;  // SAMPLED for Hi-Z
        imageCreateInfo.samples = multisampleCount;
        imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        PLOG_FN_VK(vkCreateImage(device, &imageCreateInfo, nullptr, &depthBuffer.image));
        VulkanHelper::setObjectName(context->getVkDevice(), depthBuffer.image, "depth buffer image");
 
        // get memory
        VkImageMemoryRequirementsInfo2 memoryRequirementsInfo;
        memoryRequirementsInfo.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
        memoryRequirementsInfo.image = depthBuffer.image;
        memoryRequirementsInfo.pNext = nullptr;
 
        VkMemoryRequirements2 memoryRequirements{VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
        vkGetImageMemoryRequirements2(device, &memoryRequirementsInfo, &memoryRequirements);
 
        uint32_t suiteableMemoryTypeIndex = 0u;
        if(!VulkanHelper::findSuitableMemoryType(context->getVkPhysicalDevice(), memoryRequirements,
                                                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, suiteableMemoryTypeIndex))
        {
            THROW_ERROR("Could not find a suitable memory type for the image buffer");
        }
 
        // Allocate image memory
        VkMemoryAllocateInfo memoryAllocateInfo{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
        memoryAllocateInfo.allocationSize = memoryRequirements.memoryRequirements.size;
        memoryAllocateInfo.memoryTypeIndex = suiteableMemoryTypeIndex;
        PLOG_FN_VK(vkAllocateMemory(device, &memoryAllocateInfo, nullptr, &depthBuffer.deviceMemory));
        VulkanHelper::setObjectName(context->getVkDevice(), depthBuffer.deviceMemory, "depth buffer device memory");
 
        VkBindImageMemoryInfo bindImageMemoryInfo{VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO};
        bindImageMemoryInfo.image = depthBuffer.image;
        bindImageMemoryInfo.memory = depthBuffer.deviceMemory;
        bindImageMemoryInfo.memoryOffset = 0u;
        bindImageMemoryInfo.pNext = nullptr;
        PLOG_FN_VK(vkBindImageMemory2(device, 1u, &bindImageMemoryInfo));
 
        // create image view
        VkImageViewCreateInfo imageViewCreateInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
        imageViewCreateInfo.image = depthBuffer.image;
        imageViewCreateInfo.format = depthFormat;
        imageViewCreateInfo.viewType = (layerCount == 1u ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
        imageViewCreateInfo.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
                                          VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
        imageViewCreateInfo.subresourceRange.layerCount = static_cast<uint32_t>(layerCount);
        imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
        imageViewCreateInfo.subresourceRange.baseArrayLayer = 0u;
        imageViewCreateInfo.subresourceRange.baseMipLevel = 0u;
        imageViewCreateInfo.subresourceRange.levelCount = 1u;
        PLOG_FN_VK(vkCreateImageView(device, &imageViewCreateInfo, nullptr, &depthBuffer.imageView));
        VulkanHelper::setObjectName(context->getVkDevice(), depthBuffer.imageView, "depth buffer image view");
 
        PLOGI << "Created depth buffer";
    }
 
    {
        PLOGI << "Performing initial layout transitions for render target images...";
 
        // Create a temporary command pool for the setup commands
        VkCommandPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
        poolInfo.queueFamilyIndex = vkDrawQueueFamilyIndex;
        poolInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
        VkCommandPool tempPool;
        PLOG_FN_VK(vkCreateCommandPool(device, &poolInfo, nullptr, &tempPool));
        VulkanHelper::setObjectName(context->getVkDevice(), tempPool, "Render target image layout transition command pool");
 
        // Begin a one-time command buffer using your helper
        VkCommandBuffer cmd = VulkanHelper::beginSingleTimeCommands(device, tempPool);
        VulkanHelper::setObjectName(context->getVkDevice(), tempPool, "Render target image command buffer");
 
 
        // Transition the multisampled color buffer (both layers)
        VulkanHelper::transitionImageLayout(cmd, device, context->getGraphicsQueue(), tempPool,
                                            colorBuffer.image, colorFormat,
                                            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                                            2u); // Pass layerCount = 2
 
        // Transition the multisampled depth buffer (both layers)
        VulkanHelper::transitionImageLayout(cmd, device, context->getGraphicsQueue(), tempPool,
                                            depthBuffer.image, depthFormat,
                                            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                                            2u); // Pass layerCount = 2
 
        // End and submit the commands using your helper
        VulkanHelper::endSingleTimeCommands(device, context->getGraphicsQueue(), tempPool, cmd);
 
        // Clean up the temporary pool
        vkDestroyCommandPool(device, tempPool, nullptr);
        PLOGI << "Initial layout transitions complete.";
    }

    {
        const XrViewConfigurationView& eyeImageInfo = eyeImageInfos.at(0u);
 
        XrSwapchainCreateInfo xrSwapchainCreateInfo{XR_TYPE_SWAPCHAIN_CREATE_INFO};
        xrSwapchainCreateInfo.format = colorFormat;
        xrSwapchainCreateInfo.sampleCount = eyeImageInfo.recommendedSwapchainSampleCount;
        xrSwapchainCreateInfo.width = eyeImageInfo.recommendedImageRectWidth;
        xrSwapchainCreateInfo.height = eyeImageInfo.recommendedImageRectHeight;
        xrSwapchainCreateInfo.arraySize = 2u; // multiview
        xrSwapchainCreateInfo.faceCount = 1u;
        xrSwapchainCreateInfo.mipCount = 1u;
        // Critical: Include COLOR_ATTACHMENT_BIT so we can render to these images
        // Also include TRANSFER_SRC_BIT for mirror view blitting
        xrSwapchainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_SAMPLED_BIT | XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT;
 
        PLOG_THROW_FN_XR(xrCreateSwapchain(xrSession, &xrSwapchainCreateInfo, &xrSwapchain));
        PLOGI << "OpenXR swapchain created";
    }

    {
        uint32_t swapchainImageCount;
        PLOG_FN_XR(xrEnumerateSwapchainImages(xrSwapchain, 0u, &swapchainImageCount, nullptr));
 
        std::vector<XrSwapchainImageVulkan2KHR> swapchainImages(swapchainImageCount);
        for(XrSwapchainImageVulkan2KHR& swapchainImage : swapchainImages)
        {
            swapchainImage.type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR;
        }
 
        XrSwapchainImageBaseHeader* data = reinterpret_cast<XrSwapchainImageBaseHeader*>(swapchainImages.data());
        PLOG_FN_XR(xrEnumerateSwapchainImages(xrSwapchain, static_cast<uint32_t>(swapchainImages.size()),
                                              &swapchainImageCount, data));
 
        PLOGI << "Found " << swapchainImages.size() << " xr swapchain images!";
 
        swapchainRenderTargets.resize(swapchainImages.size());
        constexpr uint32_t layerCount = 2u;
        VkExtent2D eyeResolution = getEyeResolution(0u);
        for(size_t renderTargetsIndex = 0u; renderTargetsIndex < swapchainRenderTargets.size(); renderTargetsIndex++)
        {
            RenderTarget& renderTarget = swapchainRenderTargets.at(renderTargetsIndex);
 
            const VkImage image = swapchainImages.at(renderTargetsIndex).image;
            renderTarget = RenderTarget();
            renderTarget.image = image;
            VulkanHelper::setObjectName(context->getVkDevice(), renderTarget.image, "OpenXR Swapchain Image " + std::to_string(renderTargetsIndex));
 
            VkImageViewCreateInfo imageViewCreateInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
            imageViewCreateInfo.image = image;
            imageViewCreateInfo.format = colorFormat;
            imageViewCreateInfo.viewType = (layerCount == 1u ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
            imageViewCreateInfo.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
                                              VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
            imageViewCreateInfo.subresourceRange.layerCount = layerCount;
            imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            imageViewCreateInfo.subresourceRange.baseArrayLayer = 0u;
            imageViewCreateInfo.subresourceRange.baseMipLevel = 0u;
            imageViewCreateInfo.subresourceRange.levelCount = 1u;
            PLOG_FN_VK(vkCreateImageView(device, &imageViewCreateInfo, nullptr, &renderTarget.imageView));
 
            const std::array<VkImageView, 3> attachments = {colorBuffer.imageView, depthBuffer.imageView, renderTarget.imageView};
 
            // create a frame buffer
            VkFramebufferCreateInfo framebufferCreateInfo{VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
            framebufferCreateInfo.renderPass = vkRenderPass;
            framebufferCreateInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
            framebufferCreateInfo.pAttachments = attachments.data();
            framebufferCreateInfo.width = eyeResolution.width;
            framebufferCreateInfo.height = eyeResolution.height;
            framebufferCreateInfo.layers = 1u;
            PLOG_FN_VK(vkCreateFramebuffer(device, &framebufferCreateInfo, nullptr, &renderTarget.framebuffer));
            PLOGI << "Created Frame buffer";
        }
 
        PLOGI << "Created swapchain and bound images to multiview";
    }

    {
        eyeRenderInfos.resize(eyeCount);
        for(size_t eyeIndex = 0u; eyeIndex < eyeRenderInfos.size(); eyeIndex++)
        {
            XrCompositionLayerProjectionView& eyeRenderInfo = eyeRenderInfos.at(eyeIndex);
            eyeRenderInfo.type = XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW;
            eyeRenderInfo.next = nullptr;
 
            const XrViewConfigurationView& eyeImageInfo = eyeImageInfos.at(eyeIndex);
            eyeRenderInfo.subImage.swapchain = xrSwapchain;
            eyeRenderInfo.subImage.imageArrayIndex = static_cast<uint32_t>(eyeIndex);
            eyeRenderInfo.subImage.imageRect.offset = {0, 0};
            eyeRenderInfo.subImage.imageRect.extent = {static_cast<int32_t>(eyeImageInfo.recommendedImageRectWidth),
                                                       static_cast<int32_t>(eyeImageInfo.recommendedImageRectHeight)};
        }
 
        eyes.resize(eyeCount);
    }

    {
        createHiZSampler(device);
    }
}
Headset::~Headset() {}
void Headset::cleanup()
{
    // Clean up Hi-Z sampler (pyramids are now per-frame in RenderProcess)
    if (hiZSampler_ != VK_NULL_HANDLE)
    {
        vkDestroySampler(context->getVkDevice(), hiZSampler_, nullptr);
        hiZSampler_ = VK_NULL_HANDLE;
    }
 
    colorBuffer.cleanup(context);
    depthBuffer.cleanup(context);
 
    // Destroy the OpenXR swapchain FIRST, before cleaning up render targets
    if(xrSwapchain != XR_NULL_HANDLE)
    {
        xrDestroySwapchain(xrSwapchain);
        xrSwapchain = XR_NULL_HANDLE;
    }
 
    // Now clean up the render targets (framebuffers and image views)
    for(auto& renderTarget : swapchainRenderTargets)
    {
        renderTarget.cleanup(context);
    }
    swapchainRenderTargets.clear();
 
    if (vkRenderPass != VK_NULL_HANDLE)
    {
        vkDestroyRenderPass(context->getVkDevice(), vkRenderPass, nullptr);
        vkRenderPass = VK_NULL_HANDLE;
    }
 
    if(xrReferenceSpace != XR_NULL_HANDLE)
    {
        xrDestroySpace(xrReferenceSpace);
        xrReferenceSpace = XR_NULL_HANDLE;
    }
 
    if(xrSession != XR_NULL_HANDLE)
    {
        xrDestroySession(xrSession);
        xrSession = XR_NULL_HANDLE;
    }
}
 
void Headset::ImageBuffer::cleanup(const ApplicationContext* context)
{
    const VkDevice device = context->getVkDevice();
    if(imageView != VK_NULL_HANDLE)
    {
        vkDestroyImageView(device, imageView, nullptr);
        imageView = VK_NULL_HANDLE;
    }
    if(image != VK_NULL_HANDLE)
    {
        vkDestroyImage(device, image, nullptr);
        image = VK_NULL_HANDLE;
    }
    if(deviceMemory != VK_NULL_HANDLE)
    {
        vkFreeMemory(device, deviceMemory, nullptr);
        deviceMemory = VK_NULL_HANDLE;
    }
}
 
void Headset::updateViewMatrix()
{
    TRACY_ZONE_SCOPED_NAMED("Get view matrix from openxr");
    for(size_t eyeIndex = 0u; eyeIndex < eyeCount; eyeIndex++)
    {
        XrCompositionLayerProjectionView& eyeRenderInfo = eyeRenderInfos.at(eyeIndex);
        const XrView& eyePose = eyePoses.at(eyeIndex);
        eyeRenderInfo.pose = eyePose.pose;
        eyeRenderInfo.fov = eyePose.fov;
 
        const XrPosef& pose = eyeRenderInfo.pose;
 
        eyes.at(eyeIndex).eyeViewMatrix = glm::inverse(OpenXrHelper::poseToMatrix(pose));
        eyes.at(eyeIndex).eyeProjectionMatrix = OpenXrHelper::createProjectionMatrix(eyeRenderInfo.fov, 0.05f, 1250.0f);
    }
}
 
Headset::WaitFrameResult Headset::waitForXrFrame(Renderer* renderer)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_FUNCTION;
#endif
    WaitFrameResult waitResult;
    waitResult.result = BeginFrameResult::SkipFully;
    waitResult.shouldCallBeginFrame = false;
 
    // Poll openxr events
    XrEventDataBuffer eventBuffer{XR_TYPE_EVENT_DATA_BUFFER};
    {
#ifdef ENABLE_TRACY
        TRACY_ZONE_SCOPED_NAMED("Poll all xr events");
#endif
        while(xrPollEvent(context->getXrInstance(), &eventBuffer) == XR_SUCCESS)
        {
#ifdef ENABLE_TRACY
            std::stringstream tracyZoneName;
            tracyZoneName << "Poll xr Event: ";
            const std::string zone = tracyZoneName.str();
            ZoneName(zone.c_str(), zone.size());
#endif
            PLOGI_XR << "Polled event " << OpenXrHelper::GetXrStructureTypeName(eventBuffer.type);
            switch(eventBuffer.type)
            {
            case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING:
            {
                isExistRequested = true;
#ifdef ENABLE_TRACY
                tracyZoneName << "Xr Type Event Data Instance Loss Pending";
                const std::string zoneName = tracyZoneName.str();
                ZoneName(zoneName.c_str(), zoneName.size());
#endif
                return waitResult; // SkipFully, shouldCallBeginFrame = false
            }
            case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED:
            {
                XrEventDataSessionStateChanged* event = reinterpret_cast<XrEventDataSessionStateChanged*>(&eventBuffer);
                XrSessionState previousState = xrSessionState;
                xrSessionState = event->state;
 
                PLOGI_XR << "Session state changed to: " << OpenXrHelper::sessionStateToString(event->state);
 
                // Session state transition synchronization
                // Wait for GPU idle during state transitions to ensure:
                // 1. All in-flight commands referencing swapchain images complete
                // 2. SteamVR compositor internal state is clean before we resume rendering
                // 3. No race conditions with BlankEyeBuffer or compositor copies
 
                bool wasRendering = (previousState == XR_SESSION_STATE_VISIBLE ||
                                     previousState == XR_SESSION_STATE_FOCUSED);
                bool isRendering = (xrSessionState == XR_SESSION_STATE_VISIBLE ||
                                    xrSessionState == XR_SESSION_STATE_FOCUSED);
                bool isNotRendering = (xrSessionState == XR_SESSION_STATE_SYNCHRONIZED ||
                                       xrSessionState == XR_SESSION_STATE_STOPPING ||
                                       xrSessionState == XR_SESSION_STATE_IDLE);
                bool wasNotRendering = (previousState == XR_SESSION_STATE_SYNCHRONIZED ||
                                        previousState == XR_SESSION_STATE_READY ||
                                        previousState == XR_SESSION_STATE_IDLE);
 
                // Wait when transitioning FROM rendering TO non-rendering
                // Ensures our GPU work completes before runtime takes over swapchain
                if(wasRendering && isNotRendering)
                {
                    PLOGI_XR << "Waiting for GPU idle before transitioning to non-rendering state";
                    vkDeviceWaitIdle(context->getVkDevice());
                }
 
                // Also wait when transitioning FROM non-rendering TO rendering
                // Ensures SteamVR compositor's internal operations (BlankEyeBuffer, etc.)
                // are complete before we start rendering to swapchain images again
                if(wasNotRendering && isRendering)
                {
                    PLOGI_XR << "Waiting for GPU idle before transitioning to rendering state";
                    vkDeviceWaitIdle(context->getVkDevice());
 
#ifdef ENABLE_TRACY
                    // Reset Tracy Vulkan contexts to fix query pool state.
                    // Tracy's query pools have stale queries that weren't collected/reset
                    // while the session was in non-rendering state. Recreating the contexts
                    // resets the query pools and prevents validation errors.
                    if(renderer != nullptr)
                    {
                        PLOGI_XR << "Resetting Tracy contexts after state transition";
                        renderer->resetTracyContexts();
                    }
#endif
                }
 
                if(xrSessionState == XR_SESSION_STATE_READY)
                {
                    beginXrSession();
                    TRACY_ZONE_SCOPED_NAMED("XR_SESSION_STATE_READY");
                }
                else if(xrSessionState == XR_SESSION_STATE_STOPPING)
                {
                    PLOGI_XR << "Session stopping, ending XR session";
                    endXrSession();
                    TRACY_ZONE_SCOPED_NAMED("XR_SESSION_STATE_STOPPING");
                    // Continue polling to process remaining state changes
                }
                else if(xrSessionState == XR_SESSION_STATE_IDLE)
                {
                    // Session has ended, waiting for EXITING
                    PLOGI_XR << "Session idle after ending";
                    TRACY_ZONE_SCOPED_NAMED("XR_SESSION_STATE_IDLE");
                    // Continue polling to get EXITING state
                }
                else if(xrSessionState == XR_SESSION_STATE_EXITING)
                {
                    // Graceful exit requested - this is not an error
                    PLOGI_XR << "Session exiting gracefully";
                    isExistRequested = true;
                    TRACY_ZONE_SCOPED_NAMED("XR_SESSION_STATE_EXITING");
                    return waitResult; // SkipFully, shouldCallBeginFrame = false
                }
                else if(xrSessionState == XR_SESSION_STATE_LOSS_PENDING)
                {
                    // Session loss is an error condition
                    PLOGE_XR << "Session loss pending";
                    isExistRequested = true;
                    TRACY_ZONE_SCOPED_NAMED("XR_SESSION_STATE_LOSS_PENDING");
                    waitResult.result = BeginFrameResult::Error;
                    return waitResult;
                }
                break;
            }
            }
 
            eventBuffer.type = XR_TYPE_EVENT_DATA_BUFFER;
        }
    }
 
    if(xrSessionState != XR_SESSION_STATE_READY && xrSessionState != XR_SESSION_STATE_SYNCHRONIZED &&
       xrSessionState != XR_SESSION_STATE_VISIBLE && xrSessionState != XR_SESSION_STATE_FOCUSED)
    {
        return waitResult; // SkipFully, shouldCallBeginFrame = false
    }
 
    {
        TRACY_ZONE_SCOPED_NAMED("Wait Frame");
 
        xrFrameState.type = XR_TYPE_FRAME_STATE;
        XrFrameWaitInfo frameWaitInfo{XR_TYPE_FRAME_WAIT_INFO};
 
        PLOGI_XR << "Calling xrWaitFrame (session state: " << OpenXrHelper::sessionStateToString(xrSessionState) << ")";
 
        // Use async with timeout to prevent indefinite blocking when headset is removed
        // This handles the race condition where xrWaitFrame is called before the runtime
        // delivers the STOPPING event
        auto waitFuture = xrWaitThreadPool_->submit_task([this, &frameWaitInfo]() {
            TRACY_ZONE_SCOPED_NAMED("xrWaitFrame (Async)");
            return xrWaitFrame(xrSession, &frameWaitInfo, &xrFrameState);
        });
 
        constexpr auto waitTimeout = std::chrono::seconds(5);
        auto status = waitFuture.wait_for(waitTimeout);
 
        if (status == std::future_status::timeout)
        {
            PLOGW_XR << "xrWaitFrame timed out after 5 seconds - headset may have been removed";
            PLOGW_XR << "Requesting session exit to unblock...";
 
            // Request exit to trigger the OpenXR state machine
            // This should cause xrWaitFrame to return
            XrResult exitResult = xrRequestExitSession(xrSession);
            if (exitResult != XR_SUCCESS)
            {
                PLOGW_XR << "xrRequestExitSession failed: " << exitResult;
            }
 
            // Wait for the async call to complete (it should unblock after exit request)
            XrResult result = waitFuture.get();
            if (XR_FAILED(result))
            {
                PLOGE_XR << "xrWaitFrame failed after timeout: " << result;
            }
 
            isExistRequested = true;
            return waitResult; // SkipFully, shouldCallBeginFrame = false
        }
 
        XrResult result = waitFuture.get();
        if (XR_FAILED(result))
        {
            PLOGE_XR << "xrWaitFrame failed: " << result;
            return waitResult; // SkipFully, shouldCallBeginFrame = false
        }
 
        PLOGI_XR << "xrWaitFrame returned successfully";
    }
 
    // xrWaitFrame succeeded - we need to call xrBeginFrame later
    waitResult.shouldCallBeginFrame = true;
 
    // Pre-determine if we'll be rendering based on shouldRender flag
    // The actual begin frame and swapchain acquisition happens in beginXrFrameAfterWait
    if(!xrFrameState.shouldRender)
    {
        waitResult.result = BeginFrameResult::SkipRender;
    }
    else
    {
        waitResult.result = BeginFrameResult::RenderFully;
    }
 
    return waitResult;
}
 
Headset::BeginFrameResult Headset::beginXrFrameAfterWait(uint32_t& swapchainImageIndex)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_FUNCTION;
#endif
 
    // Call xrBeginFrame - this MUST happen after previous frame's xrEndFrame completes
    XrFrameBeginInfo frameBeginInfo{XR_TYPE_FRAME_BEGIN_INFO};
    PLOG_FN_XR(xrBeginFrame(xrSession, &frameBeginInfo));
 
    if(!xrFrameState.shouldRender)
    {
        return BeginFrameResult::SkipRender;
    }
 
    xrViewState.type = XR_TYPE_VIEW_STATE;
    uint32_t viewCount;
    XrViewLocateInfo viewLocateInfo{XR_TYPE_VIEW_LOCATE_INFO};
    viewLocateInfo.viewConfigurationType = context->getXrViewType();
    viewLocateInfo.displayTime = xrFrameState.predictedDisplayTime;
    viewLocateInfo.space = xrReferenceSpace;
    PLOG_THROW_FN_XR(xrLocateViews(xrSession, &viewLocateInfo, &xrViewState, static_cast<uint32_t>(eyePoses.size()),
                                   &viewCount, eyePoses.data()));
    updateViewMatrix();
    if(viewCount != eyeCount)
    {
        THROW_ERROR("View count is not equal eye count");
    }
 
    XrSwapchainImageAcquireInfo swapchainImageAcquireInfo{XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO};
    PLOG_THROW_FN_XR(xrAcquireSwapchainImage(xrSwapchain, &swapchainImageAcquireInfo, &swapchainImageIndex));
 
    XrSwapchainImageWaitInfo swapchainImageWaitInfo{XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO};
    swapchainImageWaitInfo.timeout = XR_INFINITE_DURATION;
    PLOG_THROW_FN_XR(xrWaitSwapchainImage(xrSwapchain, &swapchainImageWaitInfo));
 
    return BeginFrameResult::RenderFully;
}
 
Headset::BeginFrameResult Headset::beginXrFrame(uint32_t& swapchainImageIndex, Renderer *renderer)
{
    // Legacy function: combines both phases for backward compatibility
    auto waitResult = waitForXrFrame(renderer);
 
    if (!waitResult.shouldCallBeginFrame)
    {
        return waitResult.result;
    }
 
    return beginXrFrameAfterWait(swapchainImageIndex);
}
 
void Headset::endXrFrame()
{
    {
        TRACY_ZONE_SCOPED_NAMED("Release Swapchain Image");
        XrSwapchainImageReleaseInfo swapchainImageReleaseInfo{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO};
        PLOG_THROW_FN_XR(xrReleaseSwapchainImage(xrSwapchain, &swapchainImageReleaseInfo));
    }
 
    {
        TRACY_ZONE_SCOPED_NAMED("End XR Frame");
        XrCompositionLayerProjection compositionLayerProjection{XR_TYPE_COMPOSITION_LAYER_PROJECTION};
        compositionLayerProjection.space = xrReferenceSpace;
        compositionLayerProjection.viewCount = static_cast<uint32_t>(eyeRenderInfos.size());
        compositionLayerProjection.views = eyeRenderInfos.data();
 
        std::vector<XrCompositionLayerBaseHeader*> layers;
 
        const bool positionValid = xrViewState.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT;
        const bool orientationValid = xrViewState.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT;
        if(xrFrameState.shouldRender && positionValid && orientationValid)
        {
            layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&compositionLayerProjection));
        }
 
        XrFrameEndInfo frameEndInfo{XR_TYPE_FRAME_END_INFO};
        frameEndInfo.displayTime = xrFrameState.predictedDisplayTime;
        frameEndInfo.layerCount = static_cast<uint32_t>(layers.size());
        frameEndInfo.layers = layers.data();
        frameEndInfo.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
        PLOG_THROW_FN_XR(xrEndFrame(xrSession, &frameEndInfo));
    }
}
 
void Headset::endXrFrameNoRender()
{
    // End frame without releasing swapchain image since none was acquired
    // This is used when beginXrFrame returned SkipRender
    XrFrameEndInfo frameEndInfo{XR_TYPE_FRAME_END_INFO};
    frameEndInfo.displayTime = xrFrameState.predictedDisplayTime;
    frameEndInfo.layerCount = 0; // No layers since we didn't render anything
    frameEndInfo.layers = nullptr;
    frameEndInfo.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
    PLOG_THROW_FN_XR(xrEndFrame(xrSession, &frameEndInfo));
}
 
void Headset::beginXrSession() const
{
    XrSessionBeginInfo sessionBeginInfo{XR_TYPE_SESSION_BEGIN_INFO};
    sessionBeginInfo.primaryViewConfigurationType = context->getXrViewType();
    PLOG_THROW_FN_XR(xrBeginSession(xrSession, &sessionBeginInfo));
}
 
VkImage Headset::getSwapchainImage(size_t swapchainImageIndex) const {
    return swapchainRenderTargets[swapchainImageIndex].image;
}
 
std::vector<RenderTarget> Headset::getSwapchainRenderTargets() {
    return swapchainRenderTargets;
}
 
void Headset::endXrSession() const
{
    PLOG_THROW_FN_XR(xrEndSession(xrSession));
}
 
void Headset::requestExitSession()
{
    if (xrSession != XR_NULL_HANDLE && !isExistRequested)
    {
        PLOGI << "Requesting XR session exit";
        XrResult result = xrRequestExitSession(xrSession);
        if (result == XR_SUCCESS)
        {
            isExistRequested = true;
        }
        else
        {
            PLOGW << "xrRequestExitSession failed with result: " << result;
        }
    }
}
 
uint32_t Headset::getEyeCount() const
{
    return eyeCount;
}
 
VkExtent2D Headset::getEyeResolution(size_t eyeIndex) const
{
    const XrViewConfigurationView& eyeInfo = eyeImageInfos.at(eyeIndex);
    return {eyeInfo.recommendedImageRectWidth, eyeInfo.recommendedImageRectHeight};
}
 
VkRenderPass Headset::getRenderPass() const
{
    return vkRenderPass;
}
 
void RenderTarget::cleanup(const ApplicationContext* context)
{
    const VkDevice device = context->getVkDevice();
    if(framebuffer != VK_NULL_HANDLE)
    {
        vkDestroyFramebuffer(device, framebuffer, nullptr);
        framebuffer = VK_NULL_HANDLE;
    }
    if(imageView != VK_NULL_HANDLE)
    {
        vkDestroyImageView(device, imageView, nullptr);
        imageView = VK_NULL_HANDLE;
    }
    // The VkImage is owned by the swapchain, so we don't destroy it here.
    image = VK_NULL_HANDLE;
}
 
glm::mat4 Headset::getEyeViewMatrix(size_t eyeIndex) const
{
    // Apply player position offset: translate the view by negative player position
    // This effectively moves the world opposite to player movement
    glm::mat4 playerTranslation = glm::translate(glm::mat4(1.0f), -playerPosition_);
    return eyes.at(eyeIndex).eyeViewMatrix * playerTranslation;
}
 
glm::mat4 Headset::getEyeProjectionMatrix(size_t eyeIndex) const
{
    return eyes.at(eyeIndex).eyeProjectionMatrix;
}
 
glm::mat4 Headset::getViewProjectionMatrix(size_t eyeIndex) const
{
    return getEyeProjectionMatrix(eyeIndex) * getEyeViewMatrix(eyeIndex);
}
 
XrSpace Headset::getReferenceSpace() const
{
    return xrReferenceSpace;
}
 
XrSession Headset::getSession() const
{
    return xrSession;
}
 
bool Headset::getIsExitRequested() const
{
    return isExistRequested;
}
XrFrameState Headset::getXrFrameState() const
{
    return xrFrameState;
}
 
const RenderTarget* Headset::getRenderTarget(size_t swapchainImageIndex) const
{
    return &swapchainRenderTargets[swapchainImageIndex];
}
 
void Headset::createHiZSampler(VkDevice device)
{
    // Use MIN reduction mode for reverse-Z depth buffer (1=near, 0=far)
    // MIN gives us the FARTHEST depth when filtering, which is correct for conservative occlusion culling
    // (we need the farthest depth to avoid culling objects visible through gaps)
 
    VkSamplerReductionModeCreateInfo reductionModeInfo{VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO};
    reductionModeInfo.reductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
 
    // Calculate max mip levels based on eye resolution (same logic as per-frame pyramids)
    VkExtent2D eyeRes = getEyeResolution(0);
    uint32_t maxMipLevels = static_cast<uint32_t>(
        std::floor(std::log2(std::max(eyeRes.width, eyeRes.height)))) + 1;
 
    VkSamplerCreateInfo samplerInfo{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
    samplerInfo.pNext = &reductionModeInfo;
    samplerInfo.magFilter = VK_FILTER_NEAREST;
    samplerInfo.minFilter = VK_FILTER_NEAREST;
    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
    samplerInfo.mipLodBias = 0.0f;
    samplerInfo.anisotropyEnable = VK_FALSE;
    samplerInfo.maxAnisotropy = 1.0f;
    samplerInfo.compareEnable = VK_FALSE;
    samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
    samplerInfo.minLod = 0.0f;
    samplerInfo.maxLod = static_cast<float>(maxMipLevels);
    samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;  // 0.0 = far depth in reverse-Z for out-of-bounds
    samplerInfo.unnormalizedCoordinates = VK_FALSE;
 
    PLOG_FN_VK(vkCreateSampler(device, &samplerInfo, nullptr, &hiZSampler_));
    VulkanHelper::setObjectName(device, hiZSampler_, "Hi-Z Sampler (MIN reduction)");
 
    PLOGI << "Hi-Z sampler created with MIN reduction mode for reverse-Z";
}
 
} // namespace EngineCore