MirrorView.cpp

Go to the documentation of this file.

#include "Engine/Logging/TracyMacros.hpp"
 
#include <Engine/Core/ApplicationContext.h>
#include <Engine/Renderer/Headset.h>
#include <Engine/Renderer/MirrorView.h>
#include <Engine/Renderer/Renderer.h>
#include <glm/common.hpp>
#include <glm/ext/vector_float2.hpp>
#include <plog/Log.h>
#include <sstream>
#include <stdexcept>
#include <unordered_set>
#include <vulkan/vulkan.h>
 
namespace
{
    std::unordered_set<VkFormat> preferredFormats = {VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_R8G8B8A8_SRGB};
    constexpr VkFormat depthFormat    = VK_FORMAT_D32_SFLOAT;
    constexpr size_t   mirrorEyeIndex = 1u;  // Eye index to mirror, 0 = left, 1 = right
}  // namespace
 
namespace EngineCore
{
 
    constexpr const char * windowTitle = "Vulkan Schnee";
 
    bool MirrorView::hasWindowBeenResized = false;
    bool MirrorView::hasBeenRestored = false;
 
    MirrorView::MirrorView( ApplicationContext * context ) : context( context )
    {
        if ( !context )
        {
            throw std::runtime_error( "No valid context pointer provided to mirror surface!" );
        }
 
        TRACY_ZONE_SCOPED_FUNCTION;
 
        // create full screen desktop window
        {
            GLFWmonitor * monitor = glfwGetPrimaryMonitor();
 
            int width, height;
            glfwGetMonitorWorkarea( monitor, nullptr, nullptr, &width, &height );
 
            #ifdef IS_IN_DEBUG
            // half the size of the window on both axis in debug mode.
            width /= 2;
            height /= 2;
            monitor = nullptr;
            #endif
 
            if ( monitor )
                const GLFWvidmode * mode = glfwGetVideoMode( monitor );
 
            glfwWindowHint( GLFW_CLIENT_API, GLFW_NO_API );
            window = glfwCreateWindow( width, height, windowTitle, monitor, nullptr );
            if ( !window )
            {
                std::stringstream error;
                error << width << "x" << height << ( monitor ? " fullscreen" : " windowed" );
                throw std::runtime_error( error.str() );
            }
 
            glfwSetWindowUserPointer( window, this );
            glfwSetFramebufferSizeCallback( window, framebufferResizeCallback );
            glfwSetKeyCallback( window, keyCallback );
            glfwSetWindowIconifyCallback( window, MirrorView::iconifyCallback );
 
            // Hide the mouse cursor
            glfwSetInputMode( window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN );
 
            VkResult createWindowSurfaceResult =
                glfwCreateWindowSurface( context->getVkInstance(), window, nullptr, &mirrorSurface );
            if ( createWindowSurfaceResult != VK_SUCCESS )
            {
                std::stringstream error;
                error << "Failed to create a surface for the mirror";
                PLOGE_VK << error.str();
            }
        }
    }
 
    MirrorView::~MirrorView()
    {
        if ( swapchain )
        {
            vkDestroySwapchainKHR( context->getVkDevice(), swapchain, nullptr );
        }
        if ( mirrorSurface )
        {
            vkDestroySurfaceKHR( context->getVkInstance(), mirrorSurface, nullptr );
        }
    }
 
    void MirrorView::connect( const Headset * headset, const Renderer * renderer )
    {
        this->headset  = headset;
        this->renderer = renderer;
 
        recreateSwapchain();
    }
 
    MirrorView::RenderResult MirrorView::render( uint32_t swapchainImageIndex )
    {
        if ( glfwGetWindowAttrib( window, GLFW_ICONIFIED ) )
        {
            return { RenderResult::Status::Invisible, VK_NULL_HANDLE };
        };
 
        // Handle window restored from minimized state
        if ( hasBeenRestored )
        {
            hasBeenRestored = false;
            recreateSwapchain();
        }
 
        if ( swapchainResolution.width == 0u || swapchainResolution.height == 0u )
        {
            if ( hasWindowBeenResized )
            {
                hasWindowBeenResized = false;
                recreateSwapchain();
            }
            else
            {
                return { RenderResult::Status::Invisible, VK_NULL_HANDLE };
            }
        }
 
        // Store XR swapchain index for present() to use when looking up the correct semaphore
        xrSwapchainImageIndex = swapchainImageIndex;
 
        VkSemaphore imageAvailableSemaphore = renderer->getCurrentMirrorViewSemaphore();
 
        // Use a short timeout to avoid blocking when window is minimized or swapchain is stale
        // 0 = non-blocking, returns VK_NOT_READY if no image available
        VkResult swapchainAcquireResult = vkAcquireNextImageKHR(
            context->getVkDevice(),
            swapchain,
            0,  // Non-blocking acquire
            imageAvailableSemaphore,
            VK_NULL_HANDLE,
            &mirrorDestinationImageIndex
        );
        if ( swapchainAcquireResult == VK_ERROR_OUT_OF_DATE_KHR )
        {
            recreateSwapchain();
            return { RenderResult::Status::Invisible, VK_NULL_HANDLE };
        }
        else if ( swapchainAcquireResult == VK_NOT_READY || swapchainAcquireResult == VK_TIMEOUT )
        {
            // No image available right now, skip this frame's mirror view
            return { RenderResult::Status::Invisible, VK_NULL_HANDLE };
        }
        else if ( swapchainAcquireResult != VK_SUBOPTIMAL_KHR && swapchainAcquireResult != VK_SUCCESS )
        {
            return { RenderResult::Status::Invisible, VK_NULL_HANDLE };
        }
 
        // Convert the incoming image from undef to transfer source
 
        VkCommandBuffer currentCommandBuffer = renderer->getCurrentRenderingCommandBuffer();
        VkImage         sourceImage          = headset->getRenderTarget( swapchainImageIndex )->image;
        VkImage         targetImage          = mirrorSwapchainImages.at( mirrorDestinationImageIndex );
        VkExtent2D      eyeResolution        = headset->getEyeResolution( mirrorEyeIndex );
 
        VkImageMemoryBarrier2 sourceToTransferBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
        sourceToTransferBarrier.pNext                 = nullptr;
        // Wait for render pass color attachment writes AND any copy/transfer operations
        // that SteamVR's compositor might perform. Use BLIT_BIT | COPY_BIT for explicit coverage.
        sourceToTransferBarrier.srcStageMask          = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        sourceToTransferBarrier.srcAccessMask         = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
        sourceToTransferBarrier.dstStageMask          = VK_PIPELINE_STAGE_2_BLIT_BIT | VK_PIPELINE_STAGE_2_COPY_BIT;
        sourceToTransferBarrier.dstAccessMask         = VK_ACCESS_2_TRANSFER_READ_BIT;
        sourceToTransferBarrier.oldLayout             = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        sourceToTransferBarrier.newLayout             = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
        sourceToTransferBarrier.srcQueueFamilyIndex   = VK_QUEUE_FAMILY_IGNORED;
        sourceToTransferBarrier.dstQueueFamilyIndex   = VK_QUEUE_FAMILY_IGNORED;
        sourceToTransferBarrier.image                 = sourceImage;
        // Transition ALL array layers to maintain consistent validation layer tracking
        // with multiview render passes. The render pass affects both eyes (layers 0 and 1),
        // so we must transition both layers even though we only blit from one.
        sourceToTransferBarrier.subresourceRange      = { .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
                                                          .baseMipLevel   = 0u,
                                                          .levelCount     = 1u,
                                                          .baseArrayLayer = 0u,
                                                          .layerCount     = 2u };
 
        VkImageMemoryBarrier2 targetToTransferBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
        targetToTransferBarrier.pNext                 = nullptr;
        targetToTransferBarrier.srcStageMask          = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;
        targetToTransferBarrier.srcAccessMask         = 0;
        targetToTransferBarrier.dstStageMask          = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
        targetToTransferBarrier.dstAccessMask         = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        // Use UNDEFINED since we're overwriting the entire image with a blit.
        // First frame the image is in UNDEFINED, subsequent frames in PRESENT_SRC_KHR.
        targetToTransferBarrier.oldLayout             = VK_IMAGE_LAYOUT_UNDEFINED;
        targetToTransferBarrier.newLayout             = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        targetToTransferBarrier.srcQueueFamilyIndex   = VK_QUEUE_FAMILY_IGNORED;
        targetToTransferBarrier.dstQueueFamilyIndex   = VK_QUEUE_FAMILY_IGNORED;
        targetToTransferBarrier.image                 = targetImage;
        targetToTransferBarrier.subresourceRange      = { .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
                                                          .baseMipLevel   = 0u,
                                                          .levelCount     = 1u,
                                                          .baseArrayLayer = 0u,
                                                          .layerCount     = 1u };
 
        std::vector<VkImageMemoryBarrier2> preBlitBarriers = { sourceToTransferBarrier,
                                                               targetToTransferBarrier };
        VkDependencyInfo                   dependencyInfo{ VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
        dependencyInfo.pNext                   = nullptr;
        // Don't use BY_REGION_BIT - the blit spans the entire image
        dependencyInfo.dependencyFlags         = 0;
        dependencyInfo.imageMemoryBarrierCount = 2u;
        dependencyInfo.pImageMemoryBarriers    = preBlitBarriers.data();
        vkCmdPipelineBarrier2( currentCommandBuffer, &dependencyInfo );
 
        const glm::vec2 sourceResolution = { static_cast<float>( eyeResolution.width ),
                                             static_cast<float>( eyeResolution.height ) };
        const glm::vec2 targetResolution = { static_cast<float>( swapchainResolution.width ),
                                             static_cast<float>( swapchainResolution.height ) };
 
        const float sourceAspectRatio = sourceResolution.x / sourceResolution.y;
        const float targetAspectRatio = targetResolution.x / targetResolution.y;
 
        glm::vec2 cropResolution = sourceResolution;
        glm::vec2 cropOffset     = { 0.0f, 0.0f };
        if ( sourceAspectRatio < targetAspectRatio )
        {
            cropResolution.y = sourceResolution.x / targetAspectRatio;
            cropOffset.y     = ( sourceResolution.y - cropResolution.y ) / 2.0f;
        }
        else if ( sourceAspectRatio > targetAspectRatio )
        {
            cropResolution.x = sourceResolution.y * targetAspectRatio;
            cropOffset.x     = ( sourceResolution.x - cropResolution.x ) / 2.0f;
        }
 
        // Perform the blit operation
        VkImageBlit imageBlit{};
        imageBlit.srcOffsets[0]                 = { static_cast<int32_t>( cropOffset.x ), static_cast<int32_t>( cropOffset.y ), 0 };
        imageBlit.srcOffsets[1]                 = { static_cast<int32_t>( cropOffset.x + cropResolution.x ), static_cast<int32_t>( cropOffset.y + cropResolution.y ), 1 };
        imageBlit.srcSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
        imageBlit.srcSubresource.mipLevel       = 0u;
        imageBlit.srcSubresource.baseArrayLayer = mirrorEyeIndex;
        imageBlit.srcSubresource.layerCount     = 1u;
 
        imageBlit.dstOffsets[0]                 = { 0, 0, 0 };
        imageBlit.dstOffsets[1]                 = { static_cast<int32_t>( targetResolution.x ), static_cast<int32_t>( targetResolution.y ), 1 };
        imageBlit.dstSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
        imageBlit.dstSubresource.layerCount     = 1u;
        imageBlit.dstSubresource.baseArrayLayer = 0u;
        imageBlit.dstSubresource.mipLevel       = 0u;
 
        vkCmdBlitImage(
            currentCommandBuffer,
            sourceImage,
            VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
            targetImage,
            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
            1u,
            &imageBlit,
            VK_FILTER_LINEAR
        );
 
        // Transition XR swapchain image back to COLOR_ATTACHMENT_OPTIMAL as required by OpenXR spec.
        // This barrier synchronizes with:
        // 1. Next frame's render pass (COLOR_ATTACHMENT_OUTPUT / COLOR_ATTACHMENT_WRITE)
        // 2. SteamVR compositor's copy operation (COPY_BIT / TRANSFER_READ)
        //
        // NOTE: Validation errors may still appear due to SteamVR's internal descriptors expecting
        // TRANSFER_SRC_OPTIMAL layout. This is a documented SteamVR spec violation (GitHub #1822),
        // not a bug in our synchronization.
        VkImageMemoryBarrier2 sourceBackBarrier{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
        sourceBackBarrier.pNext               = nullptr;
        // Wait for blit read to complete
        sourceBackBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_BLIT_BIT;
        sourceBackBarrier.srcAccessMask       = VK_ACCESS_2_TRANSFER_READ_BIT;
        // Synchronize with both next frame's render pass AND SteamVR compositor's copy.
        // The copy happens after xrReleaseSwapchainImage when the command buffer has been submitted.
        sourceBackBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT |
                                                VK_PIPELINE_STAGE_2_COPY_BIT;
        sourceBackBarrier.dstAccessMask       = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT |
                                                VK_ACCESS_2_TRANSFER_READ_BIT;
        sourceBackBarrier.oldLayout           = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
        sourceBackBarrier.newLayout           = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        sourceBackBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        sourceBackBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        sourceBackBarrier.image               = sourceImage;
        // Transition ALL array layers back to COLOR_ATTACHMENT_OPTIMAL
        // to match the multiview render pass finalLayout and maintain consistent tracking.
        sourceBackBarrier.subresourceRange    = { .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
                                                  .baseMipLevel   = 0u,
                                                  .levelCount     = 1u,
                                                  .baseArrayLayer = 0u,
                                                  .layerCount     = 2u };
 
        VkImageMemoryBarrier2 targetToPresentBarrier{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
        targetToPresentBarrier.pNext               = nullptr;
        targetToPresentBarrier.srcStageMask        = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
        targetToPresentBarrier.srcAccessMask       = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        targetToPresentBarrier.dstStageMask        = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;
        targetToPresentBarrier.dstAccessMask       = 0;
        targetToPresentBarrier.oldLayout           = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        targetToPresentBarrier.newLayout           = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        targetToPresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        targetToPresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        targetToPresentBarrier.image               = targetImage;
        targetToPresentBarrier.subresourceRange    = { .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
                                                       .baseMipLevel   = 0u,
                                                       .levelCount     = 1u,
                                                       .baseArrayLayer = 0u,
                                                       .layerCount     = 1u };
 
        // Submit post-blit barriers for both XR source and mirror target
        std::vector<VkImageMemoryBarrier2> postBlitBarriers = { sourceBackBarrier, targetToPresentBarrier };
        VkDependencyInfo                   postBlitDependency{
            .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
            .pNext = nullptr,
            // Don't use BY_REGION_BIT - the operations span the entire images
            .dependencyFlags = 0,
            .imageMemoryBarrierCount = static_cast<uint32_t>( postBlitBarriers.size() ),
            .pImageMemoryBarriers = postBlitBarriers.data(),
        };
 
        vkCmdPipelineBarrier2( currentCommandBuffer, &postBlitDependency );
 
        return { RenderResult::Status::Visible, imageAvailableSemaphore };
    }
 
    void MirrorView::present()
    {
        // Use XR swapchain index (not mirror swapchain index) to look up the semaphore
        // that was signaled by the graphics queue for this frame
        const VkSemaphore presentableSemaphore = renderer->getCurrentPresentableSemaphore( xrSwapchainImageIndex );
 
        // Add debug logging about semaphore
        PLOGI << "Present using semaphore: " << presentableSemaphore
              << " (XR image: " << xrSwapchainImageIndex << ", mirror image: " << mirrorDestinationImageIndex << ")";
 
        VkPresentInfoKHR presentInfo{ .sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
                                      .pNext              = nullptr,
                                      .waitSemaphoreCount = 1u,
                                      .pWaitSemaphores    = &presentableSemaphore,
                                      .swapchainCount     = 1u,
                                      .pSwapchains        = &swapchain,
                                      .pImageIndices      = &mirrorDestinationImageIndex };
 
        const VkResult result = vkQueuePresentKHR( context->getPresentQueue(), &presentInfo );
        if ( result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR )
        {
            recreateSwapchain();
        }
        else if ( result != VK_SUCCESS )
        {
            PLOGE << "Failed to present swapchain image. Result: " << result;
            return;
        }
    }
 
    void MirrorView::framebufferResizeCallback( GLFWwindow * window, int width, int height )
    {
        hasWindowBeenResized = true;
    }
 
    void MirrorView::keyCallback( GLFWwindow * window, int key, int scancode, int action, int mods )
    {
        if ( action == GLFW_RELEASE && key == GLFW_KEY_ESCAPE )
        {
            glfwSetWindowShouldClose( window, 1 );
        }
    }
 
    void MirrorView::iconifyCallback( GLFWwindow * window, int iconified )
    {
        if ( !iconified )
        {
            // Don't call recreateSwapchain here - it can deadlock if called while
            // the render loop is in progress. Set a flag and handle it in render().
            hasBeenRestored = true;
        }
    }
 
    VkSurfaceKHR MirrorView::getSurface() const
    {
        return mirrorSurface;
    }
 
    GLFWwindow * MirrorView::getGlfwWindow() const
    {
        return window;
    }
 
    void MirrorView::recreateSwapchain()
    {
        vkDeviceWaitIdle( context->getVkDevice() );
 
        VkSurfaceCapabilities2KHR surfaceCapabilities{ VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR };
        {
            VkPhysicalDeviceSurfaceInfo2KHR physicalDeviceSurfaceInfo{
                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
            };
            physicalDeviceSurfaceInfo.surface = mirrorSurface;
            physicalDeviceSurfaceInfo.pNext   = nullptr;
 
            PLOG_THROW_FN_VK( vkGetPhysicalDeviceSurfaceCapabilities2KHR(
                context->getVkPhysicalDevice(), &physicalDeviceSurfaceInfo, &surfaceCapabilities
            ) );
            if ( !( surfaceCapabilities.surfaceCapabilities.supportedUsageFlags &
                    VK_IMAGE_USAGE_TRANSFER_DST_BIT ) )
            {
                THROW_ERROR(
                    "Cannot transfer the final image to mirror plane as the feature is not supported!"
                );
            }
 
            if ( surfaceCapabilities.surfaceCapabilities.currentExtent.width !=
                     std::numeric_limits<uint32_t>::max() &&
                 surfaceCapabilities.surfaceCapabilities.currentExtent.height !=
                     std::numeric_limits<uint32_t>::max() )
            {
                swapchainResolution = surfaceCapabilities.surfaceCapabilities.currentExtent;
            }
            else
            {
                int width, height;
                glfwGetFramebufferSize( window, &width, &height );
                swapchainResolution.width = glm::clamp(
                    width,
                    static_cast<int>( surfaceCapabilities.surfaceCapabilities.minImageExtent.width ),
                    static_cast<int>( surfaceCapabilities.surfaceCapabilities.maxImageExtent.width )
                );
                swapchainResolution.height = glm::clamp(
                    height,
                    static_cast<int>( surfaceCapabilities.surfaceCapabilities.minImageExtent.height ),
                    static_cast<int>( surfaceCapabilities.surfaceCapabilities.maxImageExtent.height )
                );
            }
 
            if ( swapchainResolution.width == 0u || swapchainResolution.height == 0u )
            {
                return;
            }
        }
 
        // pick desktop color format
        VkSurfaceFormat2KHR surfaceFormat{ VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR };
        {
            VkPhysicalDeviceSurfaceInfo2KHR physicalDeviceSurfaceInfo{
                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
            };
            physicalDeviceSurfaceInfo.surface = mirrorSurface;
            physicalDeviceSurfaceInfo.pNext   = nullptr;
 
            uint32_t surfaceFormatCount = 0u;
            PLOG_THROW_FN_VK( vkGetPhysicalDeviceSurfaceFormats2KHR(
                context->getVkPhysicalDevice(), &physicalDeviceSurfaceInfo, &surfaceFormatCount, nullptr
            ) );
 
            std::vector<VkSurfaceFormat2KHR> surfaceFormats( surfaceFormatCount );
            for ( VkSurfaceFormat2KHR & format : surfaceFormats )
            {
                format.sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
            }
            PLOG_THROW_FN_VK( vkGetPhysicalDeviceSurfaceFormats2KHR(
                context->getVkPhysicalDevice(),
                &physicalDeviceSurfaceInfo,
                &surfaceFormatCount,
                surfaceFormats.data()
            ) );
 
            bool surfaceFormatFound = false;
            for ( const VkSurfaceFormat2KHR & surfaceFormatCandidate : surfaceFormats )
            {
                PLOGI << "Checking color format: " << surfaceFormatCandidate.surfaceFormat.format;
                if ( preferredFormats.contains( surfaceFormatCandidate.surfaceFormat.format ) )
                {
                    surfaceFormat      = surfaceFormatCandidate;
                    surfaceFormatFound = true;
                    break;
                }
            }
 
            if ( !surfaceFormatFound )
            {
                THROW_ERROR( "Could not find mirror surface format" );
            }
        }
 
        // Select the best available vsync present mode
        VkPresentModeKHR presentMode =
            VK_PRESENT_MODE_FIFO_KHR;  // Default fallback (guaranteed to be available)
        {
            uint32_t presentModeCount = 0u;
            PLOG_THROW_FN_VK( vkGetPhysicalDeviceSurfacePresentModesKHR(
                context->getVkPhysicalDevice(), mirrorSurface, &presentModeCount, nullptr
            ) );
 
            std::vector<VkPresentModeKHR> presentModes( presentModeCount );
            PLOG_THROW_FN_VK( vkGetPhysicalDeviceSurfacePresentModesKHR(
                context->getVkPhysicalDevice(), mirrorSurface, &presentModeCount, presentModes.data()
            ) );
 
            // Prefer MAILBOX (triple buffering with vsync) over FIFO (double buffering with vsync)
            for ( VkPresentModeKHR availableMode : presentModes )
            {
                if ( availableMode == VK_PRESENT_MODE_MAILBOX_KHR )
                {
                    presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
                    PLOGI << "Mirror view using MAILBOX present mode (triple buffering with vsync)";
                    break;
                }
            }
 
            if ( presentMode == VK_PRESENT_MODE_FIFO_KHR )
            {
                PLOGI << "Mirror view using FIFO present mode (double buffering with vsync)";
            }
        }
 
        if ( swapchain )
        {
            vkDestroySwapchainKHR( context->getVkDevice(), swapchain, nullptr );
        }
 
        VkSwapchainCreateInfoKHR swapchainCreateInfo{
            .sType            = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
            .pNext            = nullptr,
            .flags            = 0,
            .surface          = mirrorSurface,
            .minImageCount    = surfaceCapabilities.surfaceCapabilities.minImageCount + 1u,
            .imageFormat      = surfaceFormat.surfaceFormat.format,
            .imageColorSpace  = surfaceFormat.surfaceFormat.colorSpace,
            .imageExtent      = swapchainResolution,
            .imageArrayLayers = 1u,
            .imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
            .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
            .preTransform     = surfaceCapabilities.surfaceCapabilities.currentTransform,
            .compositeAlpha   = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
            .presentMode      = presentMode,
            .clipped          = VK_TRUE
        };
        PLOG_THROW_FN_VK(
            vkCreateSwapchainKHR( context->getVkDevice(), &swapchainCreateInfo, nullptr, &swapchain )
        );
 
        uint32_t swapchainImageCount;
        PLOG_THROW_FN_VK(
            vkGetSwapchainImagesKHR( context->getVkDevice(), swapchain, &swapchainImageCount, nullptr )
        );
 
        mirrorSwapchainImages.resize( swapchainImageCount );
        PLOG_THROW_FN_VK( vkGetSwapchainImagesKHR(
            context->getVkDevice(), swapchain, &swapchainImageCount, mirrorSwapchainImages.data()
        ) );
    }
 
    void MirrorView::cleanup()
    {
        if ( context && context->getVkDevice() )
        {
            if ( swapchain )
            {
                vkDestroySwapchainKHR( context->getVkDevice(), swapchain, nullptr );
                swapchain = nullptr;
            }
        }
 
        if ( context && context->getVkInstance() )
        {
            if ( mirrorSurface )
            {
                vkDestroySurfaceKHR( context->getVkInstance(), mirrorSurface, nullptr );
                mirrorSurface = nullptr;
            }
        }
 
        if ( window )
        {
            glfwDestroyWindow( window );
            window = nullptr;
        }
    }
 
}  // namespace EngineCore