ApplicationContext.cpp

Go to the documentation of this file.

#include "Engine/Core/VulkanHelper.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Mesh/AssetManager.h"
 
#include <Engine/Core/ApplicationContext.h>
#include <Engine/Core/Exceptions.h>
#include <Engine/Core/OpenXrHelper.h>
#include <GLFW/glfw3.h>
#include <Engine/Core/Settings.h>
#include <openxr/openxr.h>
#include <plog/Log.h>
#include "Engine/Vulkan/NextChainBuilder.h"
 
#ifdef ENABLE_TRACY
#include <tracy/TracyVulkan.hpp>
#endif
 
 
namespace EngineCore
{
 
constexpr XrViewConfigurationType xrViewType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
constexpr XrEnvironmentBlendMode environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
 
void ApplicationContext::createResources()
{
    TRACY_ZONE_SCOPED_FUNCTION;
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
    switch (DEFAULT_OPENXR_LAUNCH_MODE)
    {
    case OPENXR_LAUNCH_MODE::DEFAULT:
    {
        createOpenXrInstance();
        break;
    }
    case OPENXR_LAUNCH_MODE::OCULUS_LAUNCH:
    {
        createOpenXrInstance("C:/Program Files/Oculus/Support/oculus-runtime/oculus_openxr_64.json");
        break;
    }
    }
 
    LoadOpenXrExtensionFunctions();
#ifdef IS_IN_DEBUG
    createOpenXrDebugMessenger();
#endif
    retrieveXrSystemId();
    checkRequiredEnvironmentBlendModeAvailability();
    getVulkanInstanceExtensions();
#else
    PLOGI << "Running in HEADLESS/COMPUTE_DEBUG mode - skipping OpenXR initialization";
    getVulkanInstanceExtensions();
#endif
 
    createVulkanInstance();
 
    VulkanHelper::initializeDebugFunctions( vkInstance );
}
void ApplicationContext::cleanup()
{
    PLOGI << "Destroying Application Context";
 
    // Destroy VMA allocator before device
    if (vmaAllocator_ != VK_NULL_HANDLE)
    {
        vmaDestroyAllocator(vmaAllocator_);
        vmaAllocator_ = VK_NULL_HANDLE;
        PLOGI << "VMA allocator destroyed";
    }
 
    vkDestroyDevice(vkDevice, nullptr);
    vkDestroyInstance(vkInstance, nullptr);
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
    xrSystemId = XR_NULL_SYSTEM_ID;
 
#ifdef IS_IN_DEBUG
    xrDestroyDebugUtilsMessengerEXT(xrDebugMessenger);
#endif
 
    XrResult destroyXrInstanceResult = xrDestroyInstance(xrInstance);
    if(destroyXrInstanceResult != XR_SUCCESS)
    {
        PLOGE_XR << "Failed to destroy xr instance!";
    }
#endif
}
bool ApplicationContext::usesDedicatedTransferQueue() const
{
    return getVkGraphicsQueueFamilyIndex() != getVkTransferQueueFamilyIndex();
}
 
void ApplicationContext::createDevice(VkSurfaceKHR mirrorSurface)
{
    TRACY_ZONE_SCOPED_FUNCTION;
    // pick Vulkan Graphics Device
    {
        XrVulkanGraphicsDeviceGetInfoKHR xrVulkanGraphicsDeviceGetInfo{
            .type = XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR,
            .next = nullptr,
            .systemId = xrSystemId,
            .vulkanInstance = vkInstance,
        };
        PLOG_FN_XR(xrGetVulkanGraphicsDevice2KHR(xrInstance, &xrVulkanGraphicsDeviceGetInfo, &vkPhysicalDevice));
 
        PLOGI << "Picked vulkan graphics device";
    }
 
    pickQueueFamilies(vkPhysicalDevice, mirrorSurface, queueFamily.graphics.index, queueFamily.present.index, queueFamily.transfer.index);
 
    // getSupportedVulkanDeviceExtensions
    {
        uint32_t deviceExtensionCount;
        PLOG_FN_VK(vkEnumerateDeviceExtensionProperties(vkPhysicalDevice, nullptr, &deviceExtensionCount, nullptr));
 
        supportedVulkanDeviceExtensions.resize(deviceExtensionCount);
        PLOG_FN_VK(vkEnumerateDeviceExtensionProperties(vkPhysicalDevice, nullptr, &deviceExtensionCount, supportedVulkanDeviceExtensions.data()));
 
        for (const VkExtensionProperties& extension : supportedVulkanDeviceExtensions)
        {
            PLOGV << "Device Extension: " << extension.extensionName;
        }
    }
 
    // getRequiredVulkanDeviceExtensions
    {
        vulkanDeviceExtensions.push_back( VK_KHR_SWAPCHAIN_EXTENSION_NAME );
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        vulkanDeviceExtensions.push_back( VK_EXT_MESH_SHADER_EXTENSION_NAME );
        vulkanDeviceExtensions.push_back( VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME );
#endif
 
        // VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME is not needed - promoted to Vulkan 1.3 core
        vulkanDeviceExtensions.push_back( VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME );
#ifdef ENABLE_TRACY
        // Tracy profiling extensions (optional - will be checked for support)
        vulkanDeviceExtensions.push_back( VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME );
        vulkanDeviceExtensions.push_back( VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME );
#endif
    }
 
    // checkVulkanDeviceExtensionSupport
    {
        TRACY_ZONE_SCOPED_NAMED("Check vulkan device extension support");
        for ( const char * extensionToEnable : vulkanDeviceExtensions )
        {
            bool isExtensionSupported = false;
            for ( const VkExtensionProperties & supportedExtension : supportedVulkanDeviceExtensions )
            {
                if ( strcmp( extensionToEnable, supportedExtension.extensionName ) == 0 )
                {
                    isExtensionSupported = true;
                    break;
                }
            }
 
            if ( !isExtensionSupported )
            {
                // Tracy extensions are optional - only warn, don't fail
                if ( strcmp( extensionToEnable, VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME ) == 0 ||
                     strcmp( extensionToEnable, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME ) == 0 )
                {
                    PLOGW << "Optional Tracy extension " << extensionToEnable
                          << " not supported - Tracy will use standard profiling";
                }
                else
                {
                    std::stringstream error;
                    error << "Required Vulkan device extension " << extensionToEnable << " is not supported!";
                    PLOGE << error.str();
                    throw std::runtime_error( error.str() );
                }
            }
        }
    }
 
    // pickVulkanDevice
    {
        VkPhysicalDeviceProperties physicalDeviceProperties;
        vkGetPhysicalDeviceProperties(vkPhysicalDevice, &physicalDeviceProperties);
        uniformBufferOffsetAlignment = physicalDeviceProperties.limits.minUniformBufferOffsetAlignment;
 
        // Query push constants limit for optimal sizing
        maxPushConstantsSize = physicalDeviceProperties.limits.maxPushConstantsSize;
        PLOGI << "Max push constants size: " << maxPushConstantsSize << " bytes";
 
        const VkSampleCountFlags sampleCountFlags = physicalDeviceProperties.limits.framebufferColorSampleCounts & physicalDeviceProperties.limits.framebufferDepthSampleCounts;
 
        if (sampleCountFlags & VK_SAMPLE_COUNT_4_BIT)
        {
            multisampleCount = VK_SAMPLE_COUNT_4_BIT;
        }
        else if (sampleCountFlags & VK_SAMPLE_COUNT_2_BIT)
        {
            multisampleCount = VK_SAMPLE_COUNT_2_BIT;
        }
 
        // Verify that the required phyiscal device features are supported.
        VkPhysicalDeviceFeatures physicalDeviceFeatures;
        vkGetPhysicalDeviceFeatures(vkPhysicalDevice, &physicalDeviceFeatures);
 
        VkPhysicalDeviceFeatures2 physicalDeviceFeatures2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        VkPhysicalDeviceFragmentShadingRateFeaturesKHR fragmentShadingRateFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR};
        VkPhysicalDeviceMeshShaderFeaturesEXT meshShaderFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT};
#endif
        VkPhysicalDeviceVulkan11Features vulkan11Features {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES};
        VkPhysicalDeviceVulkan12Features vulkan12Features {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
        VkPhysicalDeviceVulkan13Features vulkan13Features {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES};
        VkPhysicalDeviceVulkan14Features vulkan14Features {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES};
        VkPhysicalDeviceDescriptorIndexingFeatures descriptorIndexingFeatures = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT};
        VkPhysicalDeviceBufferDeviceAddressFeatures bufferDeviceAddressFeatures {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES};
 
        Vulkan::ChainBuilder builder{};
        builder
        .add(physicalDeviceFeatures2)
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        .add(meshShaderFeatures)
        .add(fragmentShadingRateFeatures)
#endif
        .add(vulkan11Features)
        .add(vulkan12Features)
        .add(vulkan13Features)
        .add(vulkan14Features)
        .add(descriptorIndexingFeatures)
        .add(bufferDeviceAddressFeatures);
 
        vkGetPhysicalDeviceFeatures2(vkPhysicalDevice, &physicalDeviceFeatures2);
 
#define VALIDATE_FEATURE(feature, is_not_supported_error) \
    if (!feature) THROW_ERROR(is_not_supported_error); \
    feature = VK_TRUE;
 
        VALIDATE_FEATURE(vulkan11Features.multiview, "Multiview not supported")
        VALIDATE_FEATURE(vulkan11Features.shaderDrawParameters, "Shader draw parameter not supported")
 
        VALIDATE_FEATURE(vulkan12Features.descriptorIndexing, "Descriptor indexing not supported")
        VALIDATE_FEATURE(vulkan12Features.descriptorBindingPartiallyBound, "Descriptor binding partially bound not supported")
        VALIDATE_FEATURE(vulkan12Features.descriptorBindingVariableDescriptorCount, "Descriptor variable descriptor count not supported")
        VALIDATE_FEATURE(vulkan12Features.timelineSemaphore, "timelineSemaphore is not supported!")
 
        VALIDATE_FEATURE(vulkan13Features.maintenance4, "maintenance4 is not supported")
        VALIDATE_FEATURE(vulkan14Features.maintenance5, "maintenance5 is not supported")
        VALIDATE_FEATURE(vulkan14Features.maintenance6, "maintenance6 is not supported")
        VALIDATE_FEATURE(vulkan13Features.synchronization2, "Synchronization2 not supported")
 
        VALIDATE_FEATURE( descriptorIndexingFeatures.runtimeDescriptorArray, "Descriptor indexing not supported" )
        VALIDATE_FEATURE( descriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing, "Shader storage buffer array non uniform indexing not supported" )
 
        VALIDATE_FEATURE( bufferDeviceAddressFeatures.bufferDeviceAddress, "Buffer device addresses are not supported" )
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        VALIDATE_FEATURE(physicalDeviceFeatures2.features.shaderStorageImageMultisample, "Shader storage image multisample is not supported")
 
        VALIDATE_FEATURE(fragmentShadingRateFeatures.primitiveFragmentShadingRate, "Primitive shading rate not supported")
 
        VALIDATE_FEATURE(meshShaderFeatures.meshShader, "meshShader is not supported")
        VALIDATE_FEATURE(meshShaderFeatures.taskShader, "taskShader is not supported")
        VALIDATE_FEATURE(meshShaderFeatures.primitiveFragmentShadingRateMeshShader, "primitiveFragmentShadingRateMeshShader is not supported")
        VALIDATE_FEATURE(meshShaderFeatures.multiviewMeshShader, "multiviewMeshShader is not supported")
#endif
 
#undef VALIDATE_FEATURE
 
        constexpr float queuePriority = 1.0f;
 
        std::vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
 
        VkDeviceQueueCreateInfo graphicsAndPresentDeviceQueueCreateInfo{
            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .queueFamilyIndex = queueFamily.graphics.index,
            .queueCount = 1u,
            .pQueuePriorities = &queuePriority,
        };
        deviceQueueCreateInfos.push_back(graphicsAndPresentDeviceQueueCreateInfo);
 
        if (queueFamily.graphics.index != queueFamily.present.index)
        {
            graphicsAndPresentDeviceQueueCreateInfo.queueFamilyIndex = queueFamily.present.index;
            deviceQueueCreateInfos.push_back(graphicsAndPresentDeviceQueueCreateInfo);
        }
 
        VkDeviceQueueCreateInfo transferQueueDeviceQueueCreateInfo{
            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0u,
            .queueFamilyIndex = queueFamily.transfer.index,
            .queueCount = 1u,
            .pQueuePriorities = &queuePriority,
        };
        deviceQueueCreateInfos.push_back(transferQueueDeviceQueueCreateInfo);
 
        VkDeviceCreateInfo deviceCreateInfo{
            .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
            .pNext = &physicalDeviceFeatures2,
            .flags = 0,
            .queueCreateInfoCount = static_cast<uint32_t>(deviceQueueCreateInfos.size()),
            .pQueueCreateInfos = deviceQueueCreateInfos.data(),
            .enabledLayerCount = 0u,
            .ppEnabledLayerNames = nullptr,
            .enabledExtensionCount = static_cast<uint32_t>(vulkanDeviceExtensions.size()),
            .ppEnabledExtensionNames = vulkanDeviceExtensions.data(),
            .pEnabledFeatures = nullptr
        };
 
        XrVulkanDeviceCreateInfoKHR vkDeviceCreateInfo{
            .type = XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR,
            .next = nullptr,
            .systemId = xrSystemId,
            .createFlags = 0u,
            .pfnGetInstanceProcAddr = vkGetInstanceProcAddr,
            .vulkanPhysicalDevice = vkPhysicalDevice,
            .vulkanCreateInfo = &deviceCreateInfo,
            .vulkanAllocator = nullptr
        };
 
        // load the function dynamcially
        PFN_xrCreateVulkanDeviceKHR xrCreateVulkanDeviceKHR = nullptr;
        OpenXrHelper::LoadXrFunction(xrInstance, "xrCreateVulkanDeviceKHR", xrCreateVulkanDeviceKHR);
 
        VkResult deviceCreationResult{};
        PLOG_FN_XR(xrCreateVulkanDeviceKHR(xrInstance, &vkDeviceCreateInfo, &vkDevice, &deviceCreationResult));
        if (deviceCreationResult != VK_SUCCESS)
        {
            THROW_ERROR("Failed to create a vulkan device");
        }
 
        PLOGI << "Device Created!";
    }
 
    {
        VkPhysicalDeviceProperties2 deviceProps2 {
            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
        };
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        VkPhysicalDeviceMeshShaderPropertiesEXT meshShaderProps {
            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT
        };
#endif
 
        Vulkan::ChainBuilder builder{};
        builder.add(deviceProps2)
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        .add(meshShaderProps)
#endif
        ;
 
        // Query the device properties.
        vkGetPhysicalDeviceProperties2(vkPhysicalDevice, &deviceProps2);
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        // Print out key mesh shader limits.
 
        PLOGV << "=== Mesh Shader Properties ===";
        PLOGV << "Max Task WorkGroup Total Count: " << meshShaderProps.maxTaskWorkGroupTotalCount;
        PLOGV << "Max Task WorkGroup Count: ("
                  << meshShaderProps.maxTaskWorkGroupCount[0] << ", "
                  << meshShaderProps.maxTaskWorkGroupCount[1] << ", "
                  << meshShaderProps.maxTaskWorkGroupCount[2] << ")";
        PLOGV << "Max Task WorkGroup Invocations: " << meshShaderProps.maxTaskWorkGroupInvocations;
        PLOGV << "Max Task WorkGroup Size: ("
                  << meshShaderProps.maxTaskWorkGroupSize[0] << ", "
                  << meshShaderProps.maxTaskWorkGroupSize[1] << ", "
                  << meshShaderProps.maxTaskWorkGroupSize[2] << ")";
        PLOGV << "Max Task Payload Size: " << meshShaderProps.maxTaskPayloadSize;
        PLOGV << "Max Task Shared Memory Size: " << meshShaderProps.maxTaskSharedMemorySize;
        PLOGV << "Max Task Payload and Shared Memory Size: " << meshShaderProps.maxTaskPayloadAndSharedMemorySize;
 
        PLOGV;
 
        PLOGV << "Max Mesh WorkGroup Total Count: " << meshShaderProps.maxMeshWorkGroupTotalCount;
        PLOGV << "Max Mesh WorkGroup Count: ("
                  << meshShaderProps.maxMeshWorkGroupCount[0] << ", "
                  << meshShaderProps.maxMeshWorkGroupCount[1] << ", "
                  << meshShaderProps.maxMeshWorkGroupCount[2] << ")";
        PLOGV << "Max Mesh WorkGroup Invocations: " << meshShaderProps.maxMeshWorkGroupInvocations;
        PLOGV << "Max Mesh WorkGroup Size: ("
                  << meshShaderProps.maxMeshWorkGroupSize[0] << ", "
                  << meshShaderProps.maxMeshWorkGroupSize[1] << ", "
                  << meshShaderProps.maxMeshWorkGroupSize[2] << ")";
        PLOGV << "Max Mesh Shared Memory Size: " << meshShaderProps.maxMeshSharedMemorySize;
        PLOGV << "Max Mesh Payload and Output Memory Size: " << meshShaderProps.maxMeshPayloadAndOutputMemorySize;
 
        PLOGV;
 
        PLOGV << "Max Mesh Output Memory Size: " << meshShaderProps.maxMeshOutputMemorySize;
        PLOGV << "Max Mesh Output Components: " << meshShaderProps.maxMeshOutputComponents;
        PLOGV << "Max Mesh Output Vertices: " << meshShaderProps.maxMeshOutputVertices;
        PLOGV << "Max Mesh Output Primitives: " << meshShaderProps.maxMeshOutputPrimitives;
        PLOGV << "Max Mesh Output Layers: " << meshShaderProps.maxMeshOutputLayers;
        PLOGV << "Max Mesh Multiview View Count: " << meshShaderProps.maxMeshMultiviewViewCount;
 
        PLOGV;
        PLOGV << "Mesh Output Per Vertex Granularity: " << meshShaderProps.meshOutputPerVertexGranularity;
        PLOGV << "Mesh Output Per Primitive Granularity: " << meshShaderProps.meshOutputPerPrimitiveGranularity;
 
        PLOGV;
        PLOGV << "Max Preferred Task WorkGroup Invocations: " << meshShaderProps.maxPreferredTaskWorkGroupInvocations;
        PLOGV << "Max Preferred Mesh WorkGroup Invocations: " << meshShaderProps.maxPreferredMeshWorkGroupInvocations;
        PLOGV << "Prefers Local Invocation Vertex Output: " << (meshShaderProps.prefersLocalInvocationVertexOutput ? "Yes" : "No");
        PLOGV << "Prefers Local Invocation Primitive Output: " << (meshShaderProps.prefersLocalInvocationPrimitiveOutput ? "Yes" : "No");
        PLOGV << "Prefers Compact Vertex Output: " << (meshShaderProps.prefersCompactVertexOutput ? "Yes" : "No");
        PLOGV << "Prefers Compact Primitive Output: " << (meshShaderProps.prefersCompactPrimitiveOutput ? "Yes" : "No");
#endif
    }
 
    // retrieveQueues
    {
        VkDeviceQueueInfo2 drawQueueInfo = {
            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
            .pNext = nullptr,
            .flags = 0u,
            .queueFamilyIndex = queueFamily.graphics.index,
            .queueIndex = 0u
        };
        vkGetDeviceQueue2(vkDevice, &drawQueueInfo, &queueFamily.graphics.queue);
        VulkanHelper::setObjectName(vkDevice, queueFamily.graphics.queue, "Draw Queue");
 
        PLOGI << "Retrieved draw queue";
 
        VkDeviceQueueInfo2 presentQueueInfo {
            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
            .pNext = nullptr,
            .flags = 0u,
            .queueFamilyIndex = queueFamily.present.index,
            .queueIndex = 0u
        };
        vkGetDeviceQueue2(vkDevice, &presentQueueInfo, &queueFamily.present.queue);
        VulkanHelper::setObjectName(vkDevice, queueFamily.present.queue, "Present Queue");
 
        PLOGI << "Retrieved present queue";
 
        VkDeviceQueueInfo2 transferQueueInfo {
            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
            .pNext = nullptr,
            .flags = 0u,
            .queueFamilyIndex = queueFamily.transfer.index,
            .queueIndex = 0u
        };
        vkGetDeviceQueue2(vkDevice, &transferQueueInfo, &queueFamily.transfer.queue);
        VulkanHelper::setObjectName(vkDevice, queueFamily.transfer.queue, "Transfer Queue");
 
        PLOGI << "Retrieved transfer queue";
    }
 
    // Create VMA allocator
    {
        TRACY_ZONE_SCOPED_NAMED("VMA Allocator Creation");
        VmaAllocatorCreateInfo allocatorCI{};
        allocatorCI.physicalDevice = vkPhysicalDevice;
        allocatorCI.device = vkDevice;
        allocatorCI.instance = vkInstance;
        allocatorCI.vulkanApiVersion = VK_API_VERSION_1_3;
 
        if (vmaCreateAllocator(&allocatorCI, &vmaAllocator_) != VK_SUCCESS)
        {
            throw std::runtime_error("Failed to create VMA allocator");
        }
        PLOGI << "VMA allocator created";
    }
}
 
void ApplicationContext::pickQueueFamilies(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                       uint32_t& outGraphicsIndex,
                       uint32_t& outPresentIndex,
                       uint32_t& outTransferIndex)
{
    std::optional<uint32_t> graphicsIndex;
    std::optional<uint32_t> presentIndex;
    std::optional<uint32_t> dedicatedTransferIndex; // Priority 1 for transfer
    std::optional<uint32_t> fallbackTransferIndex;  // Priority 2 for transfer
 
    uint32_t queueFamilyCount = 0;
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
    if (queueFamilyCount == 0) {
         throw std::runtime_error("Physical device has no queue families!");
    }
 
    std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
 
    PLOGI << "Found " << queueFamilyCount << " queue families.";
 
    for (uint32_t i = 0; i < queueFamilyCount; ++i) {
        const auto& props = queueFamilies[i];
        PLOGI << "Family " << i << ": count=" << props.queueCount << ", flags=" << std::hex << props.queueFlags;
 
        if (props.queueCount == 0) {
            continue; // Skip families with no actual queues
        }
 
        // 1. Check for Graphics Support
        if (props.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
            if (!graphicsIndex.has_value()) { // Take the first one we find
                 graphicsIndex = i;
                 PLOGI << "  Found potential Graphics Queue Family: " << i;
            }
            // Also consider this as a fallback transfer queue if it supports transfer
            if (props.queueFlags & VK_QUEUE_TRANSFER_BIT) {
                 if (!fallbackTransferIndex.has_value()) {
                     fallbackTransferIndex = i;
                      PLOGI << "  Marking as Fallback Transfer Queue Family: " << i;
                 }
            }
        }
 
        // 2. Check for Transfer Support (prioritize dedicated)
        if (props.queueFlags & VK_QUEUE_TRANSFER_BIT) {
            // Is it dedicated (Transfer ON, Graphics OFF)?
            if (!(props.queueFlags & VK_QUEUE_GRAPHICS_BIT)) {
                 if (!dedicatedTransferIndex.has_value()) {
                     dedicatedTransferIndex = i;
                     PLOGI << "  Found potential *Dedicated* Transfer Queue Family: " << i;
                 }
            }
             // If it's not dedicated, we already potentially marked it as a fallbackTransferIndex above
             // if it also supported graphics. If it supports *only* transfer and compute (but not graphics)
             // it would also be caught by the dedicated check above.
        }
 
 
        // 3. Check for Presentation Support
        VkBool32 presentSupport = VK_FALSE;
        VkResult presentCheckResult = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
        if (presentCheckResult == VK_SUCCESS && presentSupport) {
            if (!presentIndex.has_value()) { // Take the first one
                presentIndex = i;
                PLOGI << "  Found potential Present Queue Family: " << i;
            }
        } else if (presentCheckResult != VK_SUCCESS) {
            PLOGW << "  vkGetPhysicalDeviceSurfaceSupportKHR failed for family " << i << " with error: " << presentCheckResult;
            // Potentially handle specific errors here if needed
        }
    }
 
    // --- Final Selection and Validation ---
 
    if (!graphicsIndex.has_value()) {
        throw std::runtime_error("Failed to find a suitable Graphics queue family!");
    }
    outGraphicsIndex = graphicsIndex.value();
    PLOGI << "Selected Graphics Queue Family Index: " << outGraphicsIndex;
 
 
    if (!presentIndex.has_value()) {
        // As a last resort, sometimes the graphics queue might implicitly support present
        // Check if the selected graphics queue supports present if no dedicated present queue was found.
        VkBool32 presentSupport = VK_FALSE;
        vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, outGraphicsIndex, surface, &presentSupport);
        if(presentSupport) {
            presentIndex = outGraphicsIndex;
            PLOGI << "  No dedicated Present Queue found, using Graphics Queue Family " << outGraphicsIndex << " for presentation.";
        } else {
            throw std::runtime_error("Failed to find a suitable Present queue family!");
        }
    }
    outPresentIndex = presentIndex.value();
    PLOGI << "Selected Present Queue Family Index: " << outPresentIndex;
 
 
    // Prioritize dedicated transfer, then fallback (which might be the graphics queue), then finally ensure graphics queue can do it
    if (dedicatedTransferIndex.has_value()) {
        outTransferIndex = dedicatedTransferIndex.value();
        PLOGI << "Selected *Dedicated* Transfer Queue Family Index: " << outTransferIndex;
    } else if (fallbackTransferIndex.has_value()) {
        outTransferIndex = fallbackTransferIndex.value();
        PLOGI << "Selected *Fallback* Transfer Queue Family Index (might be same as Graphics): " << outTransferIndex;
    } else {
         // This case should be rare, implies no queue explicitly had TRANSFER_BIT other than maybe dedicated compute?
         // Double check if our chosen graphics queue *definitely* has the transfer bit
         if (queueFamilies[outGraphicsIndex].queueFlags & VK_QUEUE_TRANSFER_BIT) {
              outTransferIndex = outGraphicsIndex;
              PLOGW << "No dedicated or distinct fallback Transfer Queue found. Using Graphics Queue Family " << outGraphicsIndex << " which supports transfer.";
         } else {
              throw std::runtime_error("Failed to find any queue family supporting Transfer operations, including the Graphics queue!");
         }
    }
 
    PLOGI << "Final Queue Selection: Graphics=" << outGraphicsIndex << ", Present=" << outPresentIndex << ", Transfer=" << outTransferIndex;
 
    // Optional: Log if queues are shared
    if (outGraphicsIndex == outPresentIndex) PLOGI << "Note: Graphics and Present queues share the same family.";
    if (outGraphicsIndex == outTransferIndex) PLOGI << "Note: Graphics and Transfer queues share the same family.";
    if (outPresentIndex == outTransferIndex) PLOGI << "Note: Present and Transfer queues share the same family.";
}
 
XrInstance ApplicationContext::getXrInstance() const
{
    return xrInstance;
}
 
XrSystemId ApplicationContext::getXrSystemId() const
{
    return xrSystemId;
}
 
VkInstance ApplicationContext::getVkInstance() const
{
    return vkInstance;
}
 
const VkDevice ApplicationContext::getVkDevice() const
{
    return vkDevice;
}
 
const VkQueue &ApplicationContext::getPresentQueue() const
{
    return queueFamily.present.queue;
}
 
const VkQueue &ApplicationContext::getGraphicsQueue() const
{
    return queueFamily.graphics.queue;
}
 
const VkQueue &ApplicationContext::getTransferQueue() const
{
    return queueFamily.transfer.queue;
}
 
VkSampleCountFlagBits ApplicationContext::getMultisampleCount() const
{
    return multisampleCount;
}
 
const VkPhysicalDevice &ApplicationContext::getVkPhysicalDevice() const
{
    return vkPhysicalDevice;
}
 
uint32_t ApplicationContext::getVkGraphicsQueueFamilyIndex() const
{
    return queueFamily.graphics.index;
}
 
uint32_t ApplicationContext::getVkTransferQueueFamilyIndex() const
{
    return queueFamily.transfer.index;
}
 
VkDeviceSize ApplicationContext::getUniformBufferOffsetAlignment() const
{
    return uniformBufferOffsetAlignment;
}
 
uint32_t ApplicationContext::getMaxPushConstantsSize() const
{
    return maxPushConstantsSize;
}
 
const XrViewConfigurationType ApplicationContext::getXrViewType() const
{
    return xrViewType;
}
 
VmaAllocator ApplicationContext::getVmaAllocator() const
{
    return vmaAllocator_;
}
 
void ApplicationContext::createOpenXrInstance(std::optional<std::filesystem::path> customOpenXrRuntimePath)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_FUNCTION;
#endif
 
    // Log the XR_RUNTIME_JSON environment variable that OpenXR will try to load
    const char* existingRuntime = std::getenv("XR_RUNTIME_JSON");
    if (existingRuntime)
    {
        PLOGI << "[OpenXR Debug] XR_RUNTIME_JSON already set to: " << existingRuntime;
    }
    else
    {
        PLOGI << "[OpenXR Debug] XR_RUNTIME_JSON not set - OpenXR will search default locations";
    }
 
    if (customOpenXrRuntimePath.has_value())
    {
        PLOGI << "[OpenXR Debug] Using custom runtime path: " << customOpenXrRuntimePath.value().string();
#ifdef WIN32
        std::cout << "Set openxr runtime environment varibale to " << customOpenXrRuntimePath.value().string().c_str();
        _putenv_s("XR_RUNTIME_JSON", customOpenXrRuntimePath.value().string().c_str());
#else
        setenv("XR_RUNTIME_JSON", customOpenXrRuntimePath.value().string().c_str(), 1);
#endif
    }
 
    // get supported open xr instance extensions
    {
        uint32_t instanceExtensionCount;
        PLOG_FN_XR(xrEnumerateInstanceExtensionProperties(nullptr, 0u, &instanceExtensionCount, nullptr));
 
        supportedOpenXRInstanceExtensions.resize(instanceExtensionCount);
        for (XrExtensionProperties& property : supportedOpenXRInstanceExtensions)
        {
            property.type = XR_TYPE_EXTENSION_PROPERTIES;
            property.next = nullptr;
        }
 
        PLOG_FN_XR(xrEnumerateInstanceExtensionProperties(nullptr, instanceExtensionCount, &instanceExtensionCount, supportedOpenXRInstanceExtensions.data()));
 
        PLOGI << "Found " << instanceExtensionCount << " XrInstance extensions";
    }
 
    // get supported open xr api layers
    {
        uint32_t apiLayerCount = 0;
        PLOG_FN_XR(xrEnumerateApiLayerProperties(0, &apiLayerCount, nullptr));
        supportedOpenXRApiLayers.resize(apiLayerCount, {XR_TYPE_API_LAYER_PROPERTIES});
        PLOG_FN_XR(xrEnumerateApiLayerProperties(apiLayerCount, &apiLayerCount, supportedOpenXRApiLayers.data()));
    }
 
    PLOGI << "Creating OpenXR instance";
    XrApplicationInfo applicationInfo{};
    applicationInfo.apiVersion = XR_CURRENT_API_VERSION;
    applicationInfo.applicationVersion = static_cast<uint32_t>(XR_MAKE_VERSION(0, 1, 0));
    applicationInfo.engineVersion = static_cast<uint32_t>(XR_MAKE_VERSION(0, 1, 0));
 
    std::string engineName = "betonmischer";
    std::string applicationName = "VulkanSchnee";
 
    memcpy(applicationInfo.engineName, engineName.data(), engineName.length() + 1u);
    memcpy(applicationInfo.applicationName, applicationName.data(), applicationName.length() + 1u);
 
    std::vector<const char*> extensions = {XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME};
 
#if IS_IN_DEBUG
    // if we are in debug mode then add openxr debug instance extension
    extensions.push_back(XR_EXT_DEBUG_UTILS_EXTENSION_NAME);
#endif
    //extensions.push_back(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME);
    //extensions.push_back(XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME);
    //extensions.push_back(XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME);
 
    for (const XrExtensionProperties& supportedExtension : supportedOpenXRInstanceExtensions)
    {
        PLOGV << supportedExtension.extensionName;
    }
 
    // check for extension support
    for (const char* extension : extensions)
    {
        bool isInstanceExtensionSupported = false;
        for (const XrExtensionProperties& supportedExtension : supportedOpenXRInstanceExtensions)
        {
            if (strcmp(extension, supportedExtension.extensionName) == 0)
            {
                isInstanceExtensionSupported = true;
                break;
            }
        }
 
        if (!isInstanceExtensionSupported)
        {
            std::stringstream error;
            error << "OpenXr Instance Extension " << extension << " is not supported!";
            PLOGE << "[OpenXR Debug] " << error.str();
            PLOGE << "[OpenXR Debug] This usually means no OpenXR runtime is installed or running.";
            PLOGE << "[OpenXR Debug] For SteamVR: ensure SteamVR is running";
            PLOGE << "[OpenXR Debug] For Monado: check ~/.config/openxr/1/active_runtime.json exists";
            PLOGE << "[OpenXR Debug] Supported extensions count: " << supportedOpenXRInstanceExtensions.size();
            throw VrHeadsetConnectionException(error.str());
        }
    }
 
    // API layers
    std::vector<std::string> requrestedApiLayers = {"XR_APILAYER_LUNARG_core_validation"};
    std::vector<const char*> enabledLayers = {};
    // Check the requested API layers against the ones from the OpenXR. If found add it to the Active API Layers.
    for (auto& requestedLayer : requrestedApiLayers)
    {
        for (auto& layerProperty : supportedOpenXRApiLayers)
        {
            // strcmp returns 0 if the strings match.
            if (strcmp(requestedLayer.c_str(), layerProperty.layerName) != 0)
            {
                continue;
            }
            else
            {
                enabledLayers.push_back(layerProperty.layerName);
                PLOGI << "Enabled: " << layerProperty.layerName;
                break;
            }
        }
    }
 
    XrInstanceCreateInfo instanceCreateInfo{
        .type = XR_TYPE_INSTANCE_CREATE_INFO,
        .next = nullptr,
        .createFlags = 0u,
        .applicationInfo = applicationInfo,
        .enabledApiLayerCount = static_cast<uint32_t>(enabledLayers.size()),
        .enabledApiLayerNames = enabledLayers.data(),
        .enabledExtensionCount = static_cast<uint32_t>(extensions.size()),
        .enabledExtensionNames = extensions.data()
    };
    XrResult instanceCreationResult = xrCreateInstance(&instanceCreateInfo, &xrInstance);
    if (instanceCreationResult != XR_SUCCESS)
    {
        if (instanceCreationResult == XR_ERROR_RUNTIME_FAILURE)
        {
            throw EnvironmentException("Your steamvr is probably not running!");
        }
        THROW_XR_ERROR(instanceCreationResult);
 
        if (instanceCreationResult == XR_ERROR_RUNTIME_UNAVAILABLE)
        {
            throw MissingOpenXrRuntimeException("Missing runtime");
        }
    }
 
    PLOGI << "OpenXR instance created successfully.";
}
 
void ApplicationContext::LoadOpenXrExtensionFunctions()
{
    TRACY_ZONE_SCOPED_FUNCTION;
    OpenXrHelper::LoadXrFunction(xrInstance, "xrGetVulkanGraphicsDevice2KHR", xrGetVulkanGraphicsDevice2KHR);
    OpenXrHelper::LoadXrFunction(xrInstance, "xrGetVulkanGraphicsRequirements2KHR", xrGetVulkanGraphicsRequirements2KHR);
 
    OpenXrHelper::LoadXrFunction(xrInstance, "xrCreateVulkanInstanceKHR", xrCreateVulkanInstanceKHR);
    OpenXrHelper::LoadXrFunction(xrInstance, "xrCreateVulkanDeviceKHR", xrCreateVulkanDeviceKHR);
#ifdef IS_IN_DEBUG
    OpenXrHelper::LoadXrFunction(xrInstance, "xrCreateDebugUtilsMessengerEXT", xrCreateDebugUtilsMessengerEXT);
    OpenXrHelper::LoadXrFunction(xrInstance, "xrDestroyDebugUtilsMessengerEXT", xrDestroyDebugUtilsMessengerEXT);
#endif
    PLOGI << "Finished loading OpenXR extension functions";
}
 
#ifdef IS_IN_DEBUG
void ApplicationContext::createOpenXrDebugMessenger()
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_FUNCTION;
#endif
    constexpr XrDebugUtilsMessageTypeFlagsEXT typeFlags = XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
                                                          XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT;
 
    constexpr XrDebugUtilsMessageSeverityFlagsEXT severityFlags = XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
                                                                  XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
 
    // Define the callback function
    auto debugCallback = [](XrDebugUtilsMessageSeverityFlagsEXT severity, XrDebugUtilsMessageTypeFlagsEXT type, const XrDebugUtilsMessengerCallbackDataEXT* callbackData, void* userData) -> XrBool32
    {
        switch (severity)
        {
        case XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
        {
            DPLOGI << "OpenXR Debug Message: " << callbackData->message << std::endl;
            break;
        }
        case XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
            PLOGW << "[OpenXR] " << callbackData->message << std::endl;
            break;
        case XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
            PLOGE << "[OpenXR] " << callbackData->message << std::endl;
            break;
        case XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
            PLOGI << "[OpenXR] " << callbackData->message << std::endl;
            break;
        }
        return XR_FALSE;
    };
 
    XrDebugUtilsMessengerCreateInfoEXT createInfo{
        .type = XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
        .next = nullptr,
        .messageSeverities = severityFlags,
        .messageTypes = typeFlags,
        .userCallback = debugCallback,
        .userData = nullptr
    };
    PLOG_FN_XR(xrCreateDebugUtilsMessengerEXT(xrInstance, &createInfo, &xrDebugMessenger));
 
    DPLOGI << "Debug Utils Messenger created successfully.";
}
#endif
 
void ApplicationContext::retrieveXrSystemId()
{
    TRACY_ZONE_SCOPED_FUNCTION;
    XrSystemGetInfo systemInfo{XR_TYPE_SYSTEM_GET_INFO};
    systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
 
    const XrResult systemRetrievalResult = xrGetSystem(xrInstance, &systemInfo, &xrSystemId);
    if (systemRetrievalResult != XR_SUCCESS)
    {
        std::stringstream errorMessage;
        errorMessage << "Failed to retrieve the xr system. Check if ";
        switch (DEFAULT_OPENXR_LAUNCH_MODE)
        {
        case OPENXR_LAUNCH_MODE::DEFAULT:
        {
            errorMessage << "your OpenXR application is running (SteamVR, Oculus)";
            break;
        }
        case OPENXR_LAUNCH_MODE::OCULUS_LAUNCH:
        {
            errorMessage << "the Oculus app is running and your headset is connected.";
            break;
        }
        }
        throw VrHeadsetConnectionException(errorMessage.str());
    }
 
    DPLOGI << "Selected VR system";
    DPLOGI << "VR System ID: " << xrSystemId;
}
 
void ApplicationContext::checkRequiredEnvironmentBlendModeAvailability()
{
    TRACY_ZONE_SCOPED_FUNCTION;
    uint32_t environmentBlendModeCount;
    PLOG_FN_XR(xrEnumerateEnvironmentBlendModes(xrInstance, xrSystemId, xrViewType, 0u, &environmentBlendModeCount, nullptr));
 
    std::vector<XrEnvironmentBlendMode> supportedEnvironmentBlendModes(environmentBlendModeCount);
    PLOG_FN_XR(xrEnumerateEnvironmentBlendModes(xrInstance, xrSystemId, xrViewType, environmentBlendModeCount, &environmentBlendModeCount, supportedEnvironmentBlendModes.data()));
 
    bool blendModeFound = false;
    for (const XrEnvironmentBlendMode& mode : supportedEnvironmentBlendModes)
    {
        if (mode == environmentBlendMode)
        {
            blendModeFound = true;
            break;
        }
    }
 
    if (!blendModeFound)
    {
        PLOGE << "Failed to find a suitable blend mode!";
        throw std::runtime_error("Failed to find suitable blend mode");
    }
}
 
void ApplicationContext::getVulkanInstanceExtensions()
{
    TRACY_ZONE_SCOPED_FUNCTION;
    {
        uint32_t instanceExtensionCount = 0;
        PLOG_FN_VK(vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtensionCount, nullptr));
        supportedVulkanInstanceExtensions.resize(instanceExtensionCount);
        PLOG_FN_VK(vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtensionCount, supportedVulkanInstanceExtensions.data()));
 
        for(int i = 0; i < instanceExtensionCount; i++)
        {
            PLOGV << "Supported vk extension: " << supportedVulkanInstanceExtensions[i].extensionName;
        }
    }
 
    // get glfw instance extension requirements
    {
        uint32_t requiredExtensionCount;
        const char** buffer = glfwGetRequiredInstanceExtensions(&requiredExtensionCount);
        if (!buffer)
        {
            PLOGE << "Failed to get vulkan instance glfw extensions";
            throw std::runtime_error("Failed to get vulkan instance glfw extensions");
        }
 
        for (uint32_t extensionIndex = 0u; extensionIndex < requiredExtensionCount; extensionIndex++)
        {
            vulkanInstanceExtensions.push_back(buffer[extensionIndex]);
        }
    }
 
    vulkanInstanceExtensions.push_back(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME);
#ifdef IS_IN_DEBUG
    vulkanInstanceExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    //vulkanInstanceExtensions.push_back(VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME);
    //vulkanInstanceExtensions.push_back(VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME);
    //vulkanInstanceExtensions.push_back(VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME);
#endif // IS_IN_DEBUG
 
    // check if the hardware supports the required extensions
    {
        for (const char* extension : vulkanInstanceExtensions)
        {
            bool isExtensionSupported = false;
 
            PLOGI << "Checking for extension support: " << extension;
 
            for (const VkExtensionProperties& supportedExtension : supportedVulkanInstanceExtensions)
            {
                if (strcmp(extension, supportedExtension.extensionName) == 0)
                {
                    isExtensionSupported = true;
                    PLOGI << "Extension " << extension << " is supported";
                    break;
                }
            }
 
            if (!isExtensionSupported)
            {
                PLOGE << "Vulkan instance extension " << extension << " is not supported!";
                throw std::runtime_error("Vulkan instance extension not supported!");
            }
        }
    }
}
 
void ApplicationContext::logVulkanRequirements()
{
    XrGraphicsRequirementsVulkan2KHR vulkanRequirements{XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR};
    xrGetVulkanGraphicsRequirements2KHR(xrInstance, xrSystemId, &vulkanRequirements);
    PLOGI << "Vulkan min api version: " << vulkanRequirements.minApiVersionSupported;
    PLOGI << "Vulkan max api version: " << vulkanRequirements.maxApiVersionSupported;
}
 
void ApplicationContext::createVulkanInstance()
{
    TRACY_ZONE_SCOPED_FUNCTION;
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
    logVulkanRequirements();
#endif
 
    VkApplicationInfo appInfo = {
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext = nullptr,
        .pApplicationName = "vulkan_schnee",
        .applicationVersion = VK_MAKE_VERSION(0, 1, 0),
        .pEngineName = "No Engine",
        .engineVersion = VK_MAKE_VERSION(0, 1, 0),
        .apiVersion = VK_API_VERSION_1_4,
    };
 
    std::vector<VkValidationFeatureEnableEXT> enabledValidationFeatures;
    std::vector<VkValidationFeatureDisableEXT> disabledValidationFeatures;
 
    switch (USE_GPU_PRINTF)
    {
        case GPU_DEBUGGING_MODE::NONE:
        {
            PLOGI << "Starting with GPU debuggin mode None";
            // Explicitly disable debug printf when USE_GPU_PRINTF is NONE
            disabledValidationFeatures.push_back(VK_VALIDATION_FEATURE_DISABLE_ALL_EXT);
            break;
        }
        case GPU_DEBUGGING_MODE::GPU_PRINTF:
        {
            PLOGI << "Starting GPU debugging mode GPU printf";
            enabledValidationFeatures = {
                VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT
            };
            break;
        }
        case GPU_DEBUGGING_MODE::GPU_VALIDATION:
        {
            PLOGI << "Starting GPU debugging mode GPU validation";
            enabledValidationFeatures = {
                VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
                VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
                VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT,
                VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT
            };
            break;
        }
    }
 
    VkValidationFeaturesEXT validationFeatures {
        .sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
        .pNext = nullptr,
        .enabledValidationFeatureCount = static_cast<uint32_t>(enabledValidationFeatures.size()),
        .pEnabledValidationFeatures = enabledValidationFeatures.data(),
        .disabledValidationFeatureCount = static_cast<uint32_t>(disabledValidationFeatures.size()),
        .pDisabledValidationFeatures = disabledValidationFeatures.data()
    };
 
    VkInstanceCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext = &validationFeatures,
        .flags = 0u,
        .pApplicationInfo = &appInfo,
        .enabledLayerCount = 0u,
        .ppEnabledLayerNames = nullptr,
        .enabledExtensionCount = static_cast<uint32_t>(vulkanInstanceExtensions.size()),
        .ppEnabledExtensionNames = vulkanInstanceExtensions.data(),
    };
 
#ifdef IS_IN_DEBUG
    if(ARE_VALIDATION_LAYERS_ENABLED)
    {
        constexpr std::array layers = {
            "VK_LAYER_KHRONOS_validation",
            //"VK_LAYER_NV_nomad_release_public_2025_2_0",
            //"VK_LAYER_NV_GPU_Trace_release_public_2025_2_0",
            //"VK_LAYER_NV_ngfx_capture_release_public_2025_2_0",
            //"VK_LAYER_NV_shader_debugger_release_public_2025_2_0"
        };
 
        std::vector<VkLayerProperties> supportedInstanceLayers;
        uint32_t instanceLayerCount;
        PLOG_FN_VK(vkEnumerateInstanceLayerProperties(&instanceLayerCount, nullptr));
        supportedInstanceLayers.resize(instanceLayerCount);
        PLOG_FN_VK(vkEnumerateInstanceLayerProperties(&instanceLayerCount, supportedInstanceLayers.data()));
 
        //for (auto& layer : supportedInstanceLayers)
        //{
        //    PLOGI << layer.layerName;
        //}
 
        for (const char* layer : layers)
        {
            bool isLayerSupported = false;
            for (const VkLayerProperties& supportedLayer : supportedInstanceLayers)
            {
                PLOGI << supportedLayer.layerName << " " << supportedLayer.description;
                if (strcmp(layer, supportedLayer.layerName) == 0)
                {
                    PLOGI << "Layer is supported!";
                    isLayerSupported = true;
                    break;
                }
            }
 
            if (!isLayerSupported)
            {
                std::stringstream error;
                error << "Vulkan instance layer " << layer << " is not supported!";
                PLOGE << error.str();
                throw std::runtime_error(error.str());
            }
        }
 
        createInfo.enabledLayerCount = static_cast<uint32_t>(layers.size());
        createInfo.ppEnabledLayerNames = layers.data();
    }
#endif
 
    XrVulkanInstanceCreateInfoKHR createInfoXr = {};
    createInfoXr.type = XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR;
    createInfoXr.next = nullptr;
    createInfoXr.vulkanCreateInfo = &createInfo;
    createInfoXr.vulkanAllocator = nullptr;
    createInfoXr.systemId = xrSystemId;
    createInfoXr.createFlags = 0;
    createInfoXr.pfnGetInstanceProcAddr = vkGetInstanceProcAddr;
 
    if (xrCreateVulkanInstanceKHR != nullptr)
    {
        VkResult result;
        XrResult xrResult = xrCreateVulkanInstanceKHR(xrInstance, &createInfoXr, &vkInstance, &result);
        if (xrResult != XR_SUCCESS)
        {
            throw std::runtime_error("XrFunctionCall: Failed to create Vulkan instance with error code: " + std::to_string(xrResult));
        }
        if (result != VK_SUCCESS)
        {
            throw std::runtime_error("VulkanResult: Failed to create Vulkan instance with error code: " + std::to_string(result));
        }
    }
 
    PLOGI << "Created Vulkan Instance";
}
} // namespace EngineCore