VulkanContext.cpp

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at < http://www.apache.org/licenses/LICENSE-2.0>
 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissionsand
* limitations under the License.
---------------------- */
 
 
 
#include <iostream>
#include <map>
#include <set>
 
#include "VulkanContext.h"
#include"../WindowAbstract.h"
#include <iostream>
#include <sstream>
 
#ifdef USE_OPENXR
    #include "../WindowOpenXR.h"
#endif // DEBUG
 
// Unique storage for the vulkan dynamic dispatcher
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE;
 
//use code from: https://github.com/KhronosGroup/Vulkan-Hpp/blob/master/samples/01_InitInstance/01_InitInstance.cpp
//and https://vulkan-tutorial.com/
 
#ifdef DEBUG
const bool PRINT_AVAILABLE_EXTENSION = false;
#else
const bool PRINT_AVAILABLE_EXTENSION = false;
#endif // DEBUG
 
const bool verboseDebug = false;
 
 
 
 
//validation layer name
const std::vector<const char*> validationLayers = {
    "VK_LAYER_KHRONOS_validation"
};
 
//pointer to function for debug messenger
#ifdef __ANDROID__
static const char* kTAG = "androidContext";
#define LOGI(...) \
  ((void)__android_log_print(ANDROID_LOG_INFO, kTAG, __VA_ARGS__))
PFN_vkCreateDebugUtilsMessengerEXT  pfnCreateDebugUtilsMessengerEXT;
PFN_vkDestroyDebugUtilsMessengerEXT pfnDestroyDebugUtilsMessengerEXT;
#else
PFN_vkCreateDebugUtilsMessengerEXT  pfnVkCreateDebugUtilsMessengerEXT;
PFN_vkDestroyDebugUtilsMessengerEXT pfnVkDestroyDebugUtilsMessengerEXT;
#endif
 
//Callback for Android
#ifdef __ANDROID__
VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT messageType,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
    void* pUserData) {
 
    const char validation[]  = "Validation";
    const char performance[] = "Performance";
    const char error[]       = "ERROR";
    const char warning[]     = "WARNING";
    const char unknownType[] = "UNKNOWN_TYPE";
    const char unknownSeverity[] = "UNKNOWN_SEVERITY";
    const char* typeString      = unknownType;
    const char* severityString  = unknownSeverity;
    const char* messageIdName   = pCallbackData->pMessageIdName;
    int32_t messageIdNumber     = pCallbackData->messageIdNumber;
    const char* message         = pCallbackData->pMessage;
    android_LogPriority priority = ANDROID_LOG_UNKNOWN;
 
    if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
        severityString = error;
        priority = ANDROID_LOG_ERROR;
    }
    else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
        severityString = warning;
        priority = ANDROID_LOG_WARN;
    }
    if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
        typeString = validation;
    }
    else if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
        typeString = performance;
    }
 
    const int maxSize= 1000;
    std::string longMessage = message;
 
    for(int i = 0; i <= longMessage.length() / maxSize; i++) {
        int start = i * maxSize;
        int end = (i + 1) * maxSize;
        end = end > longMessage.length() ? longMessage.length() : end;
        if(i == 0) {
            __android_log_print(priority,
                                kTAG,
                                "%s %s: [%s] Code %i : %s",
                                typeString,
                                severityString,
                                messageIdName,
                                messageIdNumber,
                                longMessage.substr(start,end).c_str());
        }else{
            LOGI("%s",longMessage.substr(start,end).c_str());
        }
    }
#else
    static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT messageType,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
    void* pUserData) {
        if (VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT != messageSeverity || verboseDebug) {
            std::cerr << "Validation layer: " << pCallbackData->pMessage << std::endl;
        }
#endif
    return VK_FALSE;
}
 
#ifdef __ANDROID__
 
#else
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( VkInstance                                 instance,
                                                               const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
                                                               const VkAllocationCallbacks *              pAllocator,
                                                               VkDebugUtilsMessengerEXT *                 pMessenger )
{
  return pfnVkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
}
 
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( VkInstance                    instance,
                                                            VkDebugUtilsMessengerEXT      messenger,
                                                            VkAllocationCallbacks const * pAllocator )
{
  return pfnVkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
}
#endif
 
void VulkanContext::initVulkan()
{
    try
    {
 
PRINT("Before instance creation;");
 
        createInstance();
 
        PRINT("setupDebug");
 
 
        //LOGI("I'm a test c");
        setupDebugMessenger();
 
 
        window->createSurface();
 
        PRINT("Physical device");
 
#ifdef USE_OPENXR
        if (window->useOpenXR()) {
            static_cast<WindowOpenXR*>(window)->getVulkanPhysicalDevice(reinterpret_cast<VkInstance&>(instance),
                reinterpret_cast<VkPhysicalDevice*>(&physicalDevice));
        }
        else 
#endif
        {
            pickPhysicalDevice();
        }
 
        createLogicalDevice();
        initialized = true;
    }
    catch (vk::SystemError& err)
    {
        std::cout << "vk::SystemError: " << err.what() << std::endl;
        exit(-1);
    }
    catch (std::exception& err)
    {
        std::cout << "std::exception: " << err.what() << std::endl;
        exit(-1);
    }
    catch (std::runtime_error& err)
    {
        std::cout << "std::runtime error: " << err.what() << std::endl;
        exit(-1);
    }
    catch (...)
    {
        std::cout << "unknown error\n";
        exit(-1);
    }
}
 
void VulkanContext::createInstance()
{
        vk::DynamicLoader dl;
        auto getProcAddr = dl.getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
        VULKAN_HPP_DEFAULT_DISPATCHER.init(getProcAddr);
#ifdef __ANDROID__
        LOGI("before Test");
#endif
        if (window->isValidationLayersEnabled() && !checkValidationLayerSupport()) {
            throw std::runtime_error("validation layers requested, but not available!");
        }
        // initialize the vk::ApplicationInfo structure
        vk::ApplicationInfo applicationInfo(AppName.c_str(), 1.1, EngineName.c_str(), 1, VK_API_VERSION_1_2);
 
        // initialize the vk::InstanceCreateInfo
        vk::InstanceCreateInfo instanceCreateInfo({}, &applicationInfo);
        if (window->isValidationLayersEnabled()) {
            instanceCreateInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
            instanceCreateInfo.ppEnabledLayerNames = validationLayers.data();
 
#ifdef __ANDROID__
            //for android we gonna setup this later
#else
            vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
                vk::DebugUtilsMessageSeverityFlagBitsEXT::eError); //| vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose);
            vk::DebugUtilsMessageTypeFlagsEXT     messageTypeFlags(vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
                vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance |
                vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);
            vk::DebugUtilsMessengerCreateInfoEXT createInfo({}, severityFlags, messageTypeFlags, &debugCallback);
            instanceCreateInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &createInfo;
#endif
        }
 
 
        auto extensions = window->getRequiredExtensions();
        //TODO for android we should test if debugUtils extensions is available
 
        instanceCreateInfo.setEnabledExtensionCount(static_cast<uint32_t>(extensions.size()));
        instanceCreateInfo.setPpEnabledExtensionNames(extensions.data());
 
 
 
        // create an Instance
        instance = vk::createInstance(instanceCreateInfo);
 
        VULKAN_HPP_DEFAULT_DISPATCHER.init(instance);
 
 
#ifdef __ANDROID__
    if (PRINT_AVAILABLE_EXTENSION) {
        uint32_t inst_ext_count = 0;
        vkEnumerateInstanceExtensionProperties(nullptr, &inst_ext_count, nullptr);
 
        // Enumerate the instance extensions.
        VkExtensionProperties inst_exts[inst_ext_count];
        vkEnumerateInstanceExtensionProperties(nullptr, &inst_ext_count, inst_exts);
 
        for (const auto& extension : inst_exts) {
            LOGI("%s", extension.extensionName );
        }
    }
#else
        if (PRINT_AVAILABLE_EXTENSION) {
            //get the extensions
            auto extensionsProp = vk::enumerateInstanceExtensionProperties();
            std::cout << "available extensions:\n";
 
            for (const auto& extension : extensionsProp) {
                std::cout << '\t' << extension.extensionName << '\n';
            }
        }
#endif
 
 
}
 
bool VulkanContext::hasStencilComponent(vk::Format format)
{
    return format == vk::Format::eD32SfloatS8Uint || format == vk::Format::eD24UnormS8Uint;
}
 
bool VulkanContext::isIndepFromWindowDimension()
{
    return window->isIndepFromWindowDimension();
}
 
bool VulkanContext::checkValidationLayerSupport()
{
#ifdef __ANDROID__
    // Get the layer count using a null pointer as the last parameter.
    uint32_t instance_layer_present_count = 0;
    vkEnumerateInstanceLayerProperties(&instance_layer_present_count, nullptr);
    // Enumerate layers with a valid pointer in the last parameter.
    VkLayerProperties availableLayers[instance_layer_present_count];
    vkEnumerateInstanceLayerProperties(&instance_layer_present_count, availableLayers);
#else
    auto availableLayers = vk::enumerateInstanceLayerProperties();
 
#endif
    for (const char* layerName : validationLayers) {
        bool layerFound = false;
 
        for (const auto& layerProperties : availableLayers) {
            if (strcmp(layerName, layerProperties.layerName) == 0) {
                layerFound = true;
                break;
            }
        }
 
        if (!layerFound) {
            return false;
        }
    }
    return true;
}
 
void VulkanContext::setupDebugMessenger()
{
    //check this if needed: https://github.com/KhronosGroup/Vulkan-Hpp/blob/master/samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp
#if defined(USE_OPENXR) && defined(__ANDROID__)
 
    if (!window->isValidationLayersEnabled()) createDebugReport();
#else
    if (!window->isValidationLayersEnabled()) return;
#endif
 
#ifdef __ANDROID__
    //need to cast
    VkInstance vkInstance = static_cast<VkInstance>(instance);
    pfnCreateDebugUtilsMessengerEXT =
            (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
                    vkInstance, "vkCreateDebugUtilsMessengerEXT");
    pfnDestroyDebugUtilsMessengerEXT =
            (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
                    vkInstance, "vkDestroyDebugUtilsMessengerEXT");
 
    // Create the debug messenger callback with your the settings you want.
 
    if (pfnCreateDebugUtilsMessengerEXT) {
        VkDebugUtilsMessengerCreateInfoEXT messengerInfo;
        constexpr VkDebugUtilsMessageSeverityFlagsEXT kSeveritiesToLog =
                VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
                VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
 
        constexpr VkDebugUtilsMessageTypeFlagsEXT kMessagesToLog =
                VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
                VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
                VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
 
        messengerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
        messengerInfo.pNext = nullptr;
        messengerInfo.flags = 0;
        messengerInfo.messageSeverity = kSeveritiesToLog;
        messengerInfo.messageType = kMessagesToLog;
 
        messengerInfo.pfnUserCallback = &debugCallback;
        messengerInfo.pUserData = nullptr; // Custom user data passed to callback
 
        VkDebugUtilsMessengerEXT messenger;
        pfnCreateDebugUtilsMessengerEXT(vkInstance, &messengerInfo, nullptr,
                                        &messenger);
        debugMessenger = static_cast<vk::DebugUtilsMessengerEXT>(messenger);
    }
#else
    pfnVkCreateDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(instance.getProcAddr("vkCreateDebugUtilsMessengerEXT"));
    if (!pfnVkCreateDebugUtilsMessengerEXT)
    {
        throw std::runtime_error("GetInstanceProcAddr: Unable to find pfnVkCreateDebugUtilsMessengerEXT function.");
        
    }
 
    pfnVkDestroyDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(instance.getProcAddr("vkDestroyDebugUtilsMessengerEXT"));
    if (!pfnVkDestroyDebugUtilsMessengerEXT)
    {
        throw std::runtime_error("GetInstanceProcAddr: Unable to find pfnVkDestroyDebugUtilsMessengerEXT function.");
    }
 
    vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
        vk::DebugUtilsMessageSeverityFlagBitsEXT::eError| vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo);
    vk::DebugUtilsMessageTypeFlagsEXT     messageTypeFlags(vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
        vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance |
        vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);
    vk::DebugUtilsMessengerCreateInfoEXT createInfo({}, severityFlags, messageTypeFlags, &debugCallback);
 
    debugMessenger = instance.createDebugUtilsMessengerEXT(createInfo);
#endif
    
}
 
void VulkanContext::pickPhysicalDevice()
{
    auto devices = instance.enumeratePhysicalDevices();
    if (devices.size() == 0) {
        throw std::runtime_error("failed to find GPUs with Vulkan support!");
    }
 
    // Use an ordered map to automatically sort candidates by increasing score
    physicalDevice = devices[0];
 
    std::multimap<int, vk::PhysicalDevice> candidates;
    for (const auto& device : devices) {
        int score = rateDeviceSuitability(device);
        candidates.insert(std::make_pair(score, device));
    }
    // Check if the best candidate is suitable at all
    if (candidates.rbegin()->first > 0) {
        physicalDevice = candidates.rbegin()->second;
    }
    else {
        throw std::runtime_error("failed to find a suitable GPU!");
    }
 
    std::cout << "Physical Device Name " << physicalDevice.getProperties().deviceName << std::endl;
}
 
int VulkanContext::rateDeviceSuitability(vk::PhysicalDevice device)
{
 
    auto deviceProperties = device.getProperties();
    auto deviceFeatures = device.getFeatures();
    //vk::PhysicalDeviceVulkan11Features vulkan11Features; //we need at least vulkan 1.2 so using features from 1.1 should be fine 
    //vk::PhysicalDeviceFeatures2 deviceFeatures2;
    //deviceFeatures2.setPNext(&vulkan11Features);
    //device.getFeatures2(deviceFeatures2);
    auto features2 =  device.getFeatures2 <vk::PhysicalDeviceFeatures2, vk::PhysicalDeviceSamplerYcbcrConversionFeatures>();
    int score = 0;
 
    // Discrete GPUs have a significant performance advantage
    if (deviceProperties.deviceType == vk::PhysicalDeviceType::eDiscreteGpu) {
        score += 1000;
    }
 
    // Maximum possible size of textures affects graphics quality
    score += deviceProperties.limits.maxImageDimension2D;
 
    // Application can't function without geometry shaders
    if (!deviceFeatures.geometryShader) {
        return -1;
    }
    if (!deviceFeatures.samplerAnisotropy) {
        return -1;
    }
    vk::PhysicalDeviceSamplerYcbcrConversionFeatures const& samplerYcbcrConversionFeatures = features2.get<vk::PhysicalDeviceSamplerYcbcrConversionFeatures>();
    if (!samplerYcbcrConversionFeatures.samplerYcbcrConversion) {
        return -1;
    }
    //if no queue not suitable device
    if (!findQueueFamilies(device).isComplete()) {
        return -1;
    }
    bool extensionsSupported = checkDeviceExtensionSupport(device);
    bool swapChainAdequate = false;
    if (extensionsSupported) {
        if (window->isSwapChainNeeded()) {
            SwapChainSupportDetails swapChainSupport = window->querySwapChainSupport(device);
            swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
        }
        else {
            swapChainAdequate = true;
        }
    }
    else {
        return -1;
    }
    if (!swapChainAdequate) {
        return -1;
    }
    
    return score;
}
 
bool VulkanContext::checkDeviceExtensionSupport(vk::PhysicalDevice device)
{
    auto availableExtensions = device.enumerateDeviceExtensionProperties();
  
    auto deviceExt = window->getRequiredDeviceExtensions();
    std::set<std::string> requiredExtensions(deviceExt.begin(),deviceExt.end());
 
    for (const auto& extension : availableExtensions) {
        std::string name = extension.extensionName;
        requiredExtensions.erase(name);
    }
    return requiredExtensions.empty();
}
 
QueueFamilyIndices VulkanContext::findQueueFamilies(vk::PhysicalDevice device)
{
    QueueFamilyIndices indices;
    auto queueFamilies = device.getQueueFamilyProperties();
 
    int i = 0;
    for (const auto& queueFamily : queueFamilies) {
        if (queueFamily.queueFlags & vk::QueueFlagBits::eGraphics) {
            indices.graphicsFamily = i;
        } else if(queueFamily.queueFlags & vk::QueueFlagBits::eCompute) {
          //Compute only
        } else if(queueFamily.queueFlags & vk::QueueFlagBits::eTransfer) {
          // Transfer only queue
          indices.transferFamily = i;
        }
        if (window->isDeviceSupportingSufaceKHR(static_cast<VkPhysicalDevice>(device),i)) {
            indices.presentFamily = i;
        }
        if (indices.isComplete()) {
            break;
        }
 
        i++;
    }
 
    if (!indices.presentFamily.has_value() && window->useOpenXR() ) {
        //In some case there is no surface to test for present support for the queue
        //In this corner case --> default to graphism queue for present queue
        indices.presentFamily = indices.graphicsFamily.value();
    }
 
    return indices;
}
 
vk::Format VulkanContext::findSupportedFormat(const std::vector<vk::Format>& candidates, vk::ImageTiling tiling, vk::FormatFeatureFlags features)
{
    for (vk::Format format : candidates) {
        vk::FormatProperties props = physicalDevice.getFormatProperties(format);
        if (tiling == vk::ImageTiling::eLinear && (props.linearTilingFeatures & features) == features) {
            return format;
        }
        else if (tiling == vk::ImageTiling::eOptimal && (props.optimalTilingFeatures & features) == features) {
            return format;
        }
    }
    throw std::runtime_error("failed to find supported format!");
}
 
vk::Format VulkanContext::findDepthFormat()
{
    return findSupportedFormat(
        { vk::Format::eD32Sfloat, vk::Format::eD32SfloatS8Uint, vk::Format::eD24UnormS8Uint },
        vk::ImageTiling::eOptimal,
        vk::FormatFeatureFlagBits::eDepthStencilAttachment
    );
}
 
 
void VulkanContext::createLogicalDevice()
{
    vk::PhysicalDeviceFeatures deviceFeatures{};
    deviceFeatures.samplerAnisotropy = VK_TRUE;
    deviceFeatures.geometryShader = VK_TRUE;
    deviceFeatures.shaderInt64 = VK_TRUE;
    vk::PhysicalDeviceFeatures2 deviceFeature2{};
    vk::PhysicalDeviceVulkan11Features devices11features{};
    devices11features.samplerYcbcrConversion = VK_TRUE;
    vk::PhysicalDeviceShaderAtomicInt64Features atomics64feature(VK_TRUE);
    devices11features.setPNext(&atomics64feature);
    vk::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT atomic64image(VK_TRUE);
    atomics64feature.setPNext(&atomic64image);
    deviceFeature2.setPNext(&devices11features);
    deviceFeature2.features = deviceFeatures;
    
 
 
    QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
 
    // create a Device
    float                     queuePriority = 1.0f;
    std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
    if (!indices.isComplete()) {
        throw std::runtime_error("Some queues families requested by the application are not found");
    }
    std::set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value(), indices.transferFamily.value() };
    for (uint32_t queueFamily : uniqueQueueFamilies) {
        queueCreateInfos.push_back(vk::DeviceQueueCreateInfo(vk::DeviceQueueCreateFlags(), queueFamily, 1, &queuePriority));
    }
    auto deviceExt = window->getRequiredDeviceExtensions();
    deviceExt.push_back(VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME);
#ifdef WIN32
    deviceExt.push_back(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
    deviceExt.push_back(VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
#else
//#error TODO do this for posix, linux
    deviceExt.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
        deviceExt.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
    deviceExt.push_back(VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
    deviceExt.push_back(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
#endif
    vk::DeviceCreateInfo deviceCreateInfo(vk::DeviceCreateFlags(), //flags
        static_cast<uint32_t>(queueCreateInfos.size()), //queueCreateInfoCount
        queueCreateInfos.data(), //queueCreateInfo
        0, // enabledLayerCount
        nullptr, // enabledLayer
        static_cast<uint32_t>(deviceExt.size()), //enabledExtensionCount
        deviceExt.data(), //enabledExtension
        nullptr); //EnabledFeatures
    deviceCreateInfo.setPNext(&deviceFeature2);
 
 
    device = physicalDevice.createDevice(deviceCreateInfo);
    graphicsQueue = device.getQueue(indices.graphicsFamily.value(),0);
    presentQueue = device.getQueue(indices.presentFamily.value(), 0);
    transferQueue = device.getQueue(indices.transferFamily.value(), 0);
    queueFamilyIndex = indices.graphicsFamily.value();
    transferQueueFamilyIndex = indices.transferFamily.value();
 
 
    VULKAN_HPP_DEFAULT_DISPATCHER.init(device);
}
 
VulkanContext::VulkanContext(WindowAbstract* window)
{
    this->window = window;
}
 
 
 
void VulkanContext::cleanUp()
{
    // destroy
 
    window->cleanUpSurface();
    device.destroy();
#ifdef __ANDROID__
    if (window->isValidationLayersEnabled()) {
        VkInstance vkInstance = static_cast<VkInstance>(instance);
        auto messenger = static_cast<VkDebugUtilsMessengerEXT>(debugMessenger);
        pfnDestroyDebugUtilsMessengerEXT(vkInstance,messenger,nullptr);
    }
#else
    if (window->isValidationLayersEnabled()) {
        instance.destroyDebugUtilsMessengerEXT(debugMessenger);
    }
#endif
    instance.destroy();
}
 
bool VulkanContext::isInitialized() {
    return initialized;
}
 
#ifdef ANDROID
 
#ifdef USE_OPENXR
 
static VKAPI_ATTR VkBool32 VKAPI_CALL debugReportThunk(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType,
                                                       uint64_t object, size_t location, int32_t messageCode,
                                                       const char* pLayerPrefix, const char* pMessage, void* pUserData) {
    return static_cast<VulkanContext*>(pUserData)->debugReportFunction(flags, objectType, object, location, messageCode,
                                                                      pLayerPrefix, pMessage);
}
 
VkBool32 VulkanContext::debugReportFunction(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t /*location*/,
                     int32_t /*messageCode*/, const char* pLayerPrefix, const char* pMessage) {
    std::string flagNames;
    std::string objName;
    //Log::Level level = Log::Level::Error;
    android_LogPriority level = ANDROID_LOG_DEBUG;
 
    if ((flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) != 0u) {
        flagNames += "DEBUG:";
        //level = Log::Level::Verbose;
        level = ANDROID_LOG_DEBUG;
    }
    if ((flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) != 0u) {
        flagNames += "INFO:";
        //level = Log::Level::Info;
        level = ANDROID_LOG_INFO;
    }
    if ((flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) != 0u) {
        flagNames += "PERF:";
        //level = Log::Level::Warning;
        level = ANDROID_LOG_WARN;
    }
    if ((flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) != 0u) {
        flagNames += "WARN:";
        //level = Log::Level::Warning;
        level = ANDROID_LOG_WARN;
    }
    if ((flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) != 0u) {
        flagNames += "ERROR:";
        //level = Log::Level::Error;
        level = ANDROID_LOG_ERROR;
    }
 
#define LIST_OBJECT_TYPES(_) \
    _(UNKNOWN)               \
    _(INSTANCE)              \
    _(PHYSICAL_DEVICE)       \
    _(DEVICE)                \
    _(QUEUE)                 \
    _(SEMAPHORE)             \
    _(COMMAND_BUFFER)        \
    _(FENCE)                 \
    _(DEVICE_MEMORY)         \
    _(BUFFER)                \
    _(IMAGE)                 \
    _(EVENT)                 \
    _(QUERY_POOL)            \
    _(BUFFER_VIEW)           \
    _(IMAGE_VIEW)            \
    _(SHADER_MODULE)         \
    _(PIPELINE_CACHE)        \
    _(PIPELINE_LAYOUT)       \
    _(RENDER_PASS)           \
    _(PIPELINE)              \
    _(DESCRIPTOR_SET_LAYOUT) \
    _(SAMPLER)               \
    _(DESCRIPTOR_POOL)       \
    _(DESCRIPTOR_SET)        \
    _(FRAMEBUFFER)           \
    _(COMMAND_POOL)          \
    _(SURFACE_KHR)           \
    _(SWAPCHAIN_KHR)         \
    _(DISPLAY_KHR)           \
    _(DISPLAY_MODE_KHR)
 
    switch (objectType) {
        default:
#define MK_OBJECT_TYPE_CASE(name)                  \
    case VK_DEBUG_REPORT_OBJECT_TYPE_##name##_EXT: \
        objName = #name;                           \
        break;
        LIST_OBJECT_TYPES(MK_OBJECT_TYPE_CASE)
 
#if VK_HEADER_VERSION >= 46
        MK_OBJECT_TYPE_CASE(DESCRIPTOR_UPDATE_TEMPLATE_KHR)
#endif
#if VK_HEADER_VERSION >= 70
        MK_OBJECT_TYPE_CASE(DEBUG_REPORT_CALLBACK_EXT)
#endif
    }
 
    if ((objectType == VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT) && (strcmp(pLayerPrefix, "Loader Message") == 0) &&
        (strncmp(pMessage, "Device Extension:", 17) == 0)) {
        return VK_FALSE;
    }
 
    //Log::Write(level, Fmt("%s (%s 0x%llx) [%s] %s", flagNames.c_str(), objName.c_str(), object, pLayerPrefix, pMessage));
    __android_log_print(level,flagNames.c_str() ,"%s (%s 0x%llx) [%s] %s", flagNames.c_str(), objName.c_str(), object, pLayerPrefix, pMessage);
    if ((flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) != 0u) {
        return VK_FALSE;
    }
    if ((flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) != 0u) {
        return VK_FALSE;
    }
    return VK_FALSE;
}
 
void VulkanContext::createDebugReport() {
    //need to cast
    VkInstance vkInstance = static_cast<VkInstance>(instance);
    vkCreateDebugReportCallbackEXT =
            (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(vkInstance, "vkCreateDebugReportCallbackEXT");
    vkDestroyDebugReportCallbackEXT =
            (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(vkInstance, "vkDestroyDebugReportCallbackEXT");
    VkDebugReportCallbackCreateInfoEXT debugInfo{VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT};
    debugInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
    if(window->isValidationLayersEnabled()){
        debugInfo.flags |=
                VK_DEBUG_REPORT_INFORMATION_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT;
    }
    debugInfo.pfnCallback = debugReportThunk;
    debugInfo.pUserData = this;
    VkResult res = vkCreateDebugReportCallbackEXT(vkInstance, &debugInfo, nullptr, &debugReport);
    if(res != VK_SUCCESS){
        throw std::runtime_error("failed to create debug report");
    }
    LOGI("debug report created");
}
#endif 
#endif