WindowOpenXR.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 "WindowOpenXR.h"
 
#include "SourcesVulkan/commonVulkan.h"
#include "SourcesVulkan/VulkanContext.h"
#include "SourcesVulkan/VulkanWrapper.h"
#include "SourcesVulkan/VulkanHelperFunction.h"
#include "SourcesVulkan/VulkanDrawing.h"
 
#include "openXRHelp.h"
#include "SwapchainOpenXR.h"
 
#include <iostream>
#include <sstream>
#include <thread>
 
#include <optional>
 
#define _USE_MATH_DEFINES
#include <math.h>
 
#ifdef WIN32
#ifdef HVT_UDP_CONTROL
#define _WINSOCKAPI_
#endif
#include<Windows.h>
 
#endif
 
#include <chrono> 
//#include <chrono_io>
//D(
//typedef std::chrono::high_resolution_clock Clock;
//using std::chrono::milliseconds;
//using std::chrono::duration_cast;
double count = 0;
 
std::chrono::milliseconds totalChrono{0};
//)
 
#ifdef __ANDROID__
static const char* kTAG = "window";
#define LOGI(...) \
  ((void)__android_log_print(ANDROID_LOG_INFO, kTAG, __VA_ARGS__))
#define LOGW(...) \
  ((void)__android_log_print(ANDROID_LOG_WARN, kTAG, __VA_ARGS__))
#define LOGE(...) \
  ((void)__android_log_print(ANDROID_LOG_ERROR, kTAG, __VA_ARGS__))
 
void handle_cmd_w(android_app* app, int32_t cmd) {
    switch (cmd) {
    case APP_CMD_INIT_WINDOW:
        // The window is being shown, get it ready.
        //initialize(app);
        LOGI("window init");
        break;
    case APP_CMD_TERM_WINDOW:
        // The window is being hidden or closed, clean it up.
        //terminate();
        LOGI("app out");
        break;
    case APP_CMD_WINDOW_RESIZED:
        LOGI("need resize");
 
        break;
    case APP_CMD_INPUT_CHANGED:
        LOGI("Got an input !");
        break;
    default:
        LOGI("test", cmd);
    }
}
OpenXRWindow::OpenXRWindow(android_app* appAndroid)
{
    this->appAndroid = appAndroid;
}
#endif // __ANDROID__
 
 
glm::mat3x3 rotMatFromEuler(glm::vec3 & r) {
    /*(
                    , , 0.f,
                    , , 0.f,
                    0.f, 0.f, 1.f);*/
    /*
    return cv::Matx33f(
        cos(r[1]) + cos(r[2]), -sin(r[2]), sin(r[1]),
        sin(r[2]), cos(r[0]) + cos(r[2]), -sin(r[0]),
        -sin(r[1]), sin(r[0]), cos(r[0]) + cos(r[1])
    );*/
    glm::mat3x3 res = { cos(r[1])+cos(r[2]),sin(r[2]),-sin(r[1]) ,  -sin(r[2]),cos(r[0]) + cos(r[2]),sin(r[0]) , sin(r[1]),-sin(r[0]),cos(r[0]) + cos(r[1]) };
    return res;
};
 
 
void WindowOpenXR::initWindow()
{
    currentTranslation = {0,0,0};
    currentRotation = {0,0,0};
    initialised = true;
 
 
#ifndef __ANDROID__
    if (mirrorActivated) {
        glfwInit();
        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
        glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
        glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
        glfwWindowHint(GLFW_DECORATED, GLFW_TRUE);
        window = glfwCreateWindow(width, height, "Mirror", nullptr, nullptr);
        glfwSetWindowUserPointer(window, this);
        auto funKey = [](GLFWwindow* w, int key, int scancode, int action, int mods) {
            static_cast<WindowOpenXR*>(glfwGetWindowUserPointer(w))->inputKeyCallback(w, key, scancode, action, mods);
        };
        glfwSetKeyCallback(window, funKey);
    }
#endif
 
    initOpenXR();
}
 
void WindowOpenXR::continueInit()
{
 
    graphicsBinding = wrapper->getGraphicsBinding();
    XrSessionCreateInfo createInfoSession{ XR_TYPE_SESSION_CREATE_INFO };
    createInfoSession.next = &graphicsBinding;
    createInfoSession.systemId = systemId;
 
    PRINT("Before session creation");
    CHECK_XRCMD(xrCreateSession(xrInstance, &createInfoSession, &xrSession));
    PRINT("Session created !");
 
    LogReferenceSpaces();
 
    //if we want to create actions, change it here
 
    //create XRSpace
    CreateSpaces();
 
    PRINT("Space created!");
    //create Swapchain
 
    createSurface();
    CreateSwapChain();
    if (mirrorActivated) {
        createMirrorSwapchain();
    }
 
}
 
const bool WindowOpenXR::useOpenXR() {
    return true;
}
 
 
void WindowOpenXR::cleanUp()
{
    /*
    for (Swapchain swapchain : xrSwapchains) {
        xrDestroySwapchain(swapchain.handle);
    }*/
    for (int i = 0; i < swapchains.size(); i++) {
        swapchains[i]->cleanup();
    }
    swapchains.clear();
 
    for (XrSpace visualizedSpace : xrVisualizedSpaces) {
        xrDestroySpace(visualizedSpace);
    }
 
    if (refSpace != XR_NULL_HANDLE) {
        xrDestroySpace(refSpace);
    }
 
    xrDestroySession(xrSession);
 
    wrapper->endCleanUp();
 
    xrDestroyInstance(xrInstance);
 
#ifdef __ANDROID__
    appAndroid->activity->vm->DetachCurrentThread();
#endif // 
#ifndef __ANDROID__
    if (mirrorActivated) {
        glfwDestroyWindow(window);
        glfwTerminate();
    }
#endif // 
}
 
void WindowOpenXR::cleanUpMirrorSwapchain() {
    if (mirrorActivated) {
        for (auto sem : mirrorAvailableSemaphore) {
            wrapper->context.device.destroySemaphore(sem);
        }
        for (auto sem : mirrorFinnishedSemaphore) {
            wrapper->context.device.destroySemaphore(sem);
        }
        mirrorImages.clear();
        mirrorAvailableSemaphore.clear();
        mirrorFinnishedSemaphore.clear();
        wrapper->context.device.destroySwapchainKHR(mirrorSwapchain);
    }
}
 
 
void WindowOpenXR::recreateMirror() {
    int width = 0, height = 0;
    glfwGetFramebufferSize(window, &width, &height);
    if (! (width == 0 || height == 0)) {
        vkDeviceWaitIdle(wrapper->context.device);
        cleanUpMirrorSwapchain();
        createMirrorSwapchain();
        vkDeviceWaitIdle(wrapper->context.device);
    }
}
void WindowOpenXR::cleanUpSurface()
{
    if (mirrorActivated) {
        cleanUpMirrorSwapchain();
        VkInstance instance = static_cast<VkInstance>(wrapper->context.instance);
        vkDestroySurfaceKHR(instance, surface, nullptr);
    }
}
 
void WindowOpenXR::mainLoop(VulkanDrawing* vulkanDrawing)
{
#ifdef __ANDROID__
    //For the moment the loop is on the mainOculus when using the standalone mode 
#else
    bool requestRestart = false;
    while (!requestRestart) {
#ifndef __ANDROID__
        if (mirrorActivated) {
            glfwPollEvents();
            if (glfwWindowShouldClose(window)) {
                xrRequestExitSession(xrSession);
            }
        }
#endif // 
        bool exitRenderLoop = false;
        pollEvents(&exitRenderLoop, &requestRestart);
        if (exitRenderLoop) {
            break;
        }
        if (isSessionRunning()) {
            if (pauseRendering) {
                std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                pauseRendering = false;
            }
            else {
                renderFrame(vulkanDrawing);
            }
        }
        else {
            // Throttle loop since xrWaitFrame won't be called.
            std::this_thread::sleep_for(std::chrono::milliseconds(250));
        }
 
 
    }
#endif
}
 
void WindowOpenXR::createSurface()
{
#ifndef __ANDROID__
    if (mirrorActivated) {
    if (auto res = glfwCreateWindowSurface(wrapper->context.instance, window, nullptr, &surface); res != VK_SUCCESS) {
      throw std::runtime_error("failed to create window surface! (" + std::to_string(res) + ")");
        }
    }
#endif
}
 
std::vector<const char*> WindowOpenXR::getRequiredExtensions()
{
    auto extensions = instanceExtensions;
 
#ifndef __ANDROID__
    PFN_xrGetVulkanInstanceExtensionsKHR pfnGetVulkanInstanceExtensionsKHR = nullptr;
    CHECK_XRCMD(xrGetInstanceProcAddr(xrInstance, "xrGetVulkanInstanceExtensionsKHR",
        reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanInstanceExtensionsKHR)));
 
    uint32_t extensionNamesSize = 0;
    CHECK_XRCMD(pfnGetVulkanInstanceExtensionsKHR(xrInstance, systemId, 0, &extensionNamesSize, nullptr));
 
    extensionNames = std::vector<char>(extensionNamesSize);
    CHECK_XRCMD(pfnGetVulkanInstanceExtensionsKHR(xrInstance, systemId, extensionNamesSize, &extensionNamesSize,
        &extensionNames[0]));
 
 
    std::vector<const char*> requestedExt;
 
    for (int i = 0; i < extensionNames.size(); i++) {
        extensions.push_back(&extensionNames[i]);
        while (i < extensionNames.size()) {
            if (extensionNames[i] == ' ') {
                extensionNames[i] = '\0';
                break;
            }
            i++;
        }
    }
    //extensions.resize(extensions.size() - 1);
#endif
        if (mirrorActivated) {
            uint32_t glfwExtensionCount = 0;
            const char** glfwExtensions;
            glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
            std::vector<const char*> mirrorExtensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
 
            for (auto glfwext : mirrorExtensions) {
                bool found = false;
                for (auto ext : extensions) {
                    if (std::strcmp(glfwext, ext) == 0) {
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    extensions.push_back(glfwext);
                }
            }
        }
 
    if (enableValidationLayers) {
        extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    }
    else {
        extensions.push_back("VK_EXT_debug_report");
        extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
        }
        return extensions;
    }
 
    VkBool32 WindowOpenXR::isDeviceSupportingSufaceKHR(VkPhysicalDevice device, int i)
    {
        if (!mirrorActivated) {
            return false;
        }
        else {
            VkBool32 presentSupport = false;
            vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
            return presentSupport;
        }
 
    }
 
    std::vector<const char*> WindowOpenXR::getRequiredDeviceExtensions()
    {
        PFN_xrGetVulkanDeviceExtensionsKHR pfnGetVulkanDeviceExtensionsKHR = nullptr;
        CHECK_XRCMD(xrGetInstanceProcAddr(xrInstance, "xrGetVulkanDeviceExtensionsKHR",
            reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanDeviceExtensionsKHR)));
 
        uint32_t deviceExtensionNamesSize = 0;
        CHECK_XRCMD(pfnGetVulkanDeviceExtensionsKHR(xrInstance, systemId, 0, &deviceExtensionNamesSize, nullptr));
        deviceExtension = std::vector<char>(deviceExtensionNamesSize);
        CHECK_XRCMD(pfnGetVulkanDeviceExtensionsKHR(xrInstance, systemId, deviceExtensionNamesSize,
            &deviceExtensionNamesSize, &deviceExtension[0]));
 
        std::vector<const char*> extensions = additionalDeviceExtensions;
        for (int i = 0; i < deviceExtension.size(); i++) {
            extensions.push_back(&deviceExtension[i]);
            while (i < deviceExtension.size()) {
                if (deviceExtension[i] == ' ') {
                    deviceExtension[i] = '\0';
                    break;
                }
                i++;
            }
        }
 
 
 
        return extensions;
 
        //return deviceExtensions;
 
 
    }
 
    SwapChainSupportDetails WindowOpenXR::querySwapChainSupport(vk::PhysicalDevice device)
    {
 
        SwapChainSupportDetails details;
        throw std::runtime_error("not autorised with open xr implementation");
        return details;
    }
 
 
    void WindowOpenXR::getFrameBufferSize(int* w, int* h, vk::PhysicalDevice & pDevice) {
 
    }
 
    bool WindowOpenXR::isSynchroWithSemaphore()
    {
        return false;
    }
 
 
 
 
 
    void WindowOpenXR::framebufferResizeCallback()
    {
        wrapper->framebufferResized = true;
    }
 
    void WindowOpenXR::checkForCorrectSize()
    {
    }
 
    std::vector<vk::Image> WindowOpenXR::getBlitDestinations(int view, int elem)
    {
        auto res = std::vector<vk::Image>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize && mirrorShouldRender) {
            res.push_back(mirrorImages[elem]);
        }
        return res;
    }
 
    std::vector<vk::Extent2D> WindowOpenXR::getBlitExtentDestinations(int view, int elem)
    {
        auto res = std::vector<vk::Extent2D>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize && mirrorShouldRender) {
            res.push_back(vk::Extent2D{ width,height });
        }
        return res;
    }
 
    std::vector<vk::Semaphore> WindowOpenXR::getSemaphoreWait(int view, int elem)
    {
        auto res = std::vector<vk::Semaphore>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize) {
            res.push_back(mirrorAvailableSemaphore[elem]);
        }
        return res;
    }
 
    std::vector<vk::Semaphore> WindowOpenXR::getSemaphoreSignal(int view, int elem)
    {
        auto res = std::vector<vk::Semaphore>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize) {
            res.push_back(mirrorFinnishedSemaphore[elem]);
        }
        return res;
    }
 
    void WindowOpenXR::initOpenXR() {
#ifdef __ANDROID__
        PFN_xrInitializeLoaderKHR initializeLoader = nullptr;
        if (XR_SUCCEEDED(
            xrGetInstanceProcAddr(XR_NULL_HANDLE, "xrInitializeLoaderKHR", (PFN_xrVoidFunction*)(&initializeLoader)))) {
            XrLoaderInitInfoAndroidKHR loaderInitInfoAndroid;
            memset(&loaderInitInfoAndroid, 0, sizeof(loaderInitInfoAndroid));
            loaderInitInfoAndroid.type = XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR;
            loaderInitInfoAndroid.next = NULL;
            loaderInitInfoAndroid.applicationVM = appAndroid->activity->vm;
            loaderInitInfoAndroid.applicationContext = appAndroid->activity->clazz;
            initializeLoader((const XrLoaderInitInfoBaseHeaderKHR*)&loaderInitInfoAndroid);
            LOGI("loader");
        }
        else {
            LOGI("This is a failure");
        }
        LOGI("OpenXR");
 
 
        //Instance
        XrInstanceCreateInfoAndroidKHR instanceCreateInfoAndroid = { XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR };
        instanceCreateInfoAndroid.applicationVM = appAndroid->activity->vm;
        instanceCreateInfoAndroid.applicationActivity = appAndroid->activity->clazz;
 
        XrInstanceCreateInfo createInfo{ XR_TYPE_INSTANCE_CREATE_INFO };
        std::vector<const char*> extensions = { XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME, XR_KHR_VULKAN_ENABLE_EXTENSION_NAME };
#else
        checkExtensions();
        XrInstanceCreateInfo createInfo{ XR_TYPE_INSTANCE_CREATE_INFO };
        std::vector<const char*> extensions = { XR_KHR_VULKAN_ENABLE_EXTENSION_NAME };
        if (depthExtensionAvailable) {
            PRINT("Depth extension is now activated !\n");
            extensions.push_back(XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME);
        }
        if (quadViewExtensionAvailable) {
            PRINT("VARJO quad view extension is now activated !\n");
            extensions.push_back(XR_VARJO_QUAD_VIEWS_EXTENSION_NAME);
            separateFromWindowDim = false;
        }
#endif // 
 
#ifdef __ANDROID__
        createInfo.next = (XrBaseInStructure*)&instanceCreateInfoAndroid;
#else
        createInfo.next = nullptr;
#endif // 
 
        createInfo.enabledExtensionCount = (uint32_t)extensions.size();
        createInfo.enabledExtensionNames = extensions.data();
        strcpy(createInfo.applicationInfo.applicationName, "RVSVulkan_OpenXR");
        createInfo.applicationInfo.apiVersion = XR_CURRENT_API_VERSION;
 
        std::vector<const char*> layers = {};
        if (validationXR) { //TODO check if supported
            layers.push_back("XR_LUNARG_core_validation");
        }
 
        createInfo.enabledApiLayerCount = (uint32_t)layers.size();
        createInfo.enabledApiLayerNames = layers.data();
        if (XR_SUCCEEDED(xrCreateInstance(&createInfo, &xrInstance))) {
            PRINT("Success");
        }
        else {
            PRINT("Error Instance");
            exit(-1);
        }
        XrSystemGetInfo systemInfo{ XR_TYPE_SYSTEM_GET_INFO };
        systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY; //The code is for the oculus
        CHECK_XRCMD(xrGetSystem(xrInstance, &systemInfo, &systemId));
        PRINT("%s", Fmt("Using system %d for form factor %s", systemId, to_string(systemInfo.formFactor)).c_str());
        CHECK(xrInstance != XR_NULL_HANDLE);
        CHECK(systemId != XR_NULL_SYSTEM_ID);
 
 
        selectViewConfiguration();
        selectBlendMode();
        logViewConfiguration(xrInstance, systemId);
 
        XrGraphicsRequirementsVulkan2KHR graphicsRequirements{ XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR };
        CHECK_XRCMD(GetVulkanGraphicsRequirements2KHR(xrInstance, systemId, &graphicsRequirements));
 
        uint32_t layerCount;
        vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
 
 
 
 
    }
 
 
 
 
    void WindowOpenXR::LogReferenceSpaces() {
        CHECK(xrSession != XR_NULL_HANDLE);
 
        uint32_t spaceCount;
        CHECK_XRCMD(xrEnumerateReferenceSpaces(xrSession, 0, &spaceCount, nullptr));
        std::vector<XrReferenceSpaceType> spaces(spaceCount);
        CHECK_XRCMD(xrEnumerateReferenceSpaces(xrSession, spaceCount, &spaceCount, spaces.data()));
 
        PRINT("%s", Fmt("Available reference spaces: %d", spaceCount).c_str());
        for (XrReferenceSpaceType space : spaces) {
            PRINT("%s", Fmt("  Name: %s", to_string(space)).c_str());
        }
    }
 
 
    void WindowOpenXR::CreateSpaces() {
        //visual + ref
        //--------------visual space
        CHECK(xrSession != XR_NULL_HANDLE);
        //check wich one we need
        //std::string visualizedSpaces[] = {"ViewFront",        "Local", "Stage", "StageLeft", "StageRight", "StageLeftRotated",
        //                                "StageRightRotated"};
 
        //for (const auto& visualizedSpace : visualizedSpaces) {
        XrReferenceSpaceCreateInfo referenceSpaceCreateInfo{ XR_TYPE_REFERENCE_SPACE_CREATE_INFO };
        XrPosef identity{};
        identity.orientation.w = 1;
        referenceSpaceCreateInfo.poseInReferenceSpace = identity;
        referenceSpaceCreateInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
        //XrReferenceSpaceCreateInfo referenceSpaceCreateInfo = GetXrReferenceSpaceCreateInfo(visualizedSpace);
        XrSpace space;
        XrResult res = xrCreateReferenceSpace(xrSession, &referenceSpaceCreateInfo, &space);
        if (XR_SUCCEEDED(res)) {
            xrVisualizedSpaces.push_back(space);
        }
        else {
            PRINT("%s", Fmt("Failed to create reference space %s with error %d", "Local", res).c_str());
        }
        //--------------------appSpace
 
        XrResult res2 = xrCreateReferenceSpace(xrSession, &referenceSpaceCreateInfo, &refSpace);
        if (!XR_SUCCEEDED(res2)) {
            PRINT("%s", Fmt("Failed to create reference space %s with error %d", "Local", res2).c_str());
        }
 
        //}
    }
    void WindowOpenXR::logViewConfiguration(XrInstance & xrInstance, XrSystemId & systemId) {
        uint32_t viewConfigTypeCount;
        CHECK_XRCMD(xrEnumerateViewConfigurations(xrInstance, systemId, 0, &viewConfigTypeCount, nullptr));
        std::vector<XrViewConfigurationType> viewConfigTypes(viewConfigTypeCount);
        CHECK_XRCMD(xrEnumerateViewConfigurations(xrInstance, systemId, viewConfigTypeCount,
            &viewConfigTypeCount,
            viewConfigTypes.data()));
        CHECK((uint32_t)viewConfigTypes.size() == viewConfigTypeCount);
        PRINT("%s", Fmt("Available View Configuration Types: (%d)", viewConfigTypeCount).c_str());
        for (XrViewConfigurationType viewConfigType : viewConfigTypes) {
            PRINT("%s", Fmt("  View Configuration Type: %s %s", to_string(viewConfigType),
                viewConfigType == xrViewConfType ? "(Selected)" : "").c_str());
 
            XrViewConfigurationProperties viewConfigProperties{ XR_TYPE_VIEW_CONFIGURATION_PROPERTIES };
            CHECK_XRCMD(xrGetViewConfigurationProperties(xrInstance, systemId, viewConfigType,
                &viewConfigProperties));
 
            PRINT("%s",
                Fmt("  View configuration FovMutable=%s",
                    viewConfigProperties.fovMutable == XR_TRUE ? "True" : "False").c_str());
 
            uint32_t viewCount;
            CHECK_XRCMD(
                xrEnumerateViewConfigurationViews(xrInstance, systemId, viewConfigType, 0, &viewCount,
                    nullptr));
            if (viewCount > 0) {
                std::vector<XrViewConfigurationView> views(viewCount, { XR_TYPE_VIEW_CONFIGURATION_VIEW });
                CHECK_XRCMD(
                    xrEnumerateViewConfigurationViews(xrInstance, systemId, viewConfigType, viewCount,
                        &viewCount, views.data()));
 
                for (uint32_t i = 0; i < views.size(); i++) {
                    const XrViewConfigurationView& view = views[i];
 
                    PRINT("%s", Fmt("    View [%d]: Recommended Width=%d Height=%d SampleCount=%d", i,
                        view.recommendedImageRectWidth, view.recommendedImageRectHeight,
                        view.recommendedSwapchainSampleCount).c_str());
                    PRINT("%s",
                        Fmt("    View [%d]:     Maximum Width=%d Height=%d SampleCount=%d", i,
                            view.maxImageRectWidth,
                            view.maxImageRectHeight, view.maxSwapchainSampleCount).c_str());
                }
            }
            else {
                PRINT("%s", Fmt("Empty view configuration type").c_str());
            }
 
            uint32_t count;
            CHECK_XRCMD(xrEnumerateEnvironmentBlendModes(xrInstance, systemId, viewConfigType, 0, &count, nullptr));
            CHECK(count > 0);
 
            PRINT("%s", Fmt("Available Environment Blend Mode count : (%d)", count).c_str());
 
            std::vector<XrEnvironmentBlendMode> blendModes(count);
            CHECK_XRCMD(xrEnumerateEnvironmentBlendModes(xrInstance, systemId, viewConfigType, count, &count, blendModes.data()));
 
            bool blendModeFound = false;
            for (XrEnvironmentBlendMode mode : blendModes) {
                const bool blendModeMatch = (mode == xrBlendMode);
                PRINT("%s", Fmt("Environment Blend Mode (%s) : %s", to_string(mode), blendModeMatch ? "(Selected)" : "").c_str());
                blendModeFound |= blendModeMatch;
            }
            CHECK(blendModeFound);
 
        }
 
    }
 
    XrResult WindowOpenXR::GetVulkanGraphicsRequirements2KHR(XrInstance instance, XrSystemId systemId,
        XrGraphicsRequirementsVulkan2KHR * graphicsRequirements) {
        PFN_xrGetVulkanGraphicsRequirementsKHR pfnGetVulkanGraphicsRequirementsKHR = nullptr;
        CHECK_XRCMD(xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsRequirementsKHR",
            reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanGraphicsRequirementsKHR)));
 
        XrGraphicsRequirementsVulkanKHR legacyRequirements{ XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR };
        CHECK_XRCMD(pfnGetVulkanGraphicsRequirementsKHR(instance, systemId, &legacyRequirements));
 
        graphicsRequirements->maxApiVersionSupported = legacyRequirements.maxApiVersionSupported;
        graphicsRequirements->minApiVersionSupported = legacyRequirements.minApiVersionSupported;
 
        return XR_SUCCESS;
    }
 
    XrResult GetVulkanGraphicsDevice2KHR(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR * getInfo,
        VkPhysicalDevice * vulkanPhysicalDevice) {
        PFN_xrGetVulkanGraphicsDeviceKHR pfnGetVulkanGraphicsDeviceKHR = nullptr;
        CHECK_XRCMD(xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsDeviceKHR",
            reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanGraphicsDeviceKHR)));
 
        if (getInfo->next != nullptr) {
            return XR_ERROR_FEATURE_UNSUPPORTED;
        }
 
        CHECK_XRCMD(pfnGetVulkanGraphicsDeviceKHR(instance, getInfo->systemId, getInfo->vulkanInstance, vulkanPhysicalDevice));
 
        return XR_SUCCESS;
    }
 
 
    void WindowOpenXR::getVulkanPhysicalDevice(VkInstance & vkInstance, VkPhysicalDevice * physicalDevice) {
        XrVulkanGraphicsDeviceGetInfoKHR deviceGetInfo{ XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR };
        deviceGetInfo.systemId = systemId;
        deviceGetInfo.vulkanInstance = vkInstance;
        CHECK_XRCMD(GetVulkanGraphicsDevice2KHR(xrInstance, &deviceGetInfo, physicalDevice));
    }
 
    XrResult CreateVulkanDeviceKHR(XrInstance instance, const XrVulkanDeviceCreateInfoKHR * createInfo,
        VkDevice * vulkanDevice, VkResult * vulkanResult) {
        PFN_xrCreateVulkanDeviceKHR pfnCreateVulkanDeviceKHR = nullptr;
        CHECK_XRCMD(xrGetInstanceProcAddr(instance, "xrCreateVulkanDeviceKHR",
            reinterpret_cast<PFN_xrVoidFunction*>(&pfnCreateVulkanDeviceKHR)));
 
        return pfnCreateVulkanDeviceKHR(instance, createInfo, vulkanDevice, vulkanResult);
    }
 
    void WindowOpenXR::createVulkanDevice(VkPhysicalDevice & physicalDevice, VkDeviceCreateInfo & info, VkDevice * device) {
        XrVulkanDeviceCreateInfoKHR deviceCreateInfo{ XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR };
        deviceCreateInfo.systemId = systemId;
        deviceCreateInfo.pfnGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(&vkGetInstanceProcAddr);
        deviceCreateInfo.vulkanCreateInfo = &info;
        deviceCreateInfo.vulkanPhysicalDevice = physicalDevice;
        deviceCreateInfo.vulkanAllocator = nullptr;
        VkResult err;
        CHECK_XRCMD(CreateVulkanDeviceKHR(xrInstance, &deviceCreateInfo, device, &err));
        if (err != VK_SUCCESS) {
            throw std::runtime_error("Error creating the device");
        }
    }
    int64_t SelectColorSwapchainFormat(const std::vector<int64_t>&runtimeFormats) {
        // List of supported color swapchain formats.
        constexpr int64_t SupportedColorSwapchainFormats[] = { VK_FORMAT_R8G8B8A8_UNORM };//VK_FORMAT_R8G8B8A8_UNORM,VK_FORMAT_B8G8R8A8_UNORM,VK_FORMAT_R32G32B32A32_SFLOAT,VK_FORMAT_R32G32B32_SFLOAT,VK_FORMAT_R8G8B8A8_SRGB };//{VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_R8G8B8A8_SRGB,
                                                             // VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM};
 
        auto swapchainFormatIt =
            std::find_first_of(runtimeFormats.begin(), runtimeFormats.end(), std::begin(SupportedColorSwapchainFormats),
                std::end(SupportedColorSwapchainFormats));
        if (swapchainFormatIt == runtimeFormats.end()) {
            THROW("No runtime swapchain format supported for color swapchain");
        }
 
        return *swapchainFormatIt;
    }
  int64_t SelectDepthSwapchainFormat(const std::vector<int64_t>& runtimeFormats, const std::vector<vk::Format>& supportedFormats) {
    for(auto f : supportedFormats) {
      auto it = std::find_if(runtimeFormats.begin(), runtimeFormats.end(), [&](int64_t format){
          return format == (int64_t)f;
      });
      if(it != runtimeFormats.end()){
        return *it;
      }
    }
    THROW("No runtime swapchain format supported for depth swapchain");
    }
    void WindowOpenXR::CreateSwapChain() {
 
        // Read graphics properties for preferred swapchain length and logging.
        XrSystemProperties systemProperties{ XR_TYPE_SYSTEM_PROPERTIES };
        CHECK_XRCMD(xrGetSystemProperties(xrInstance, systemId, &systemProperties));
 
        // Log system properties.
        PRINT("%s", Fmt("System Properties: Name=%s VendorId=%d", systemProperties.systemName, systemProperties.vendorId).c_str());
        PRINT("%s", Fmt("System Graphics Properties: MaxWidth=%d MaxHeight=%d MaxLayers=%d",
            systemProperties.graphicsProperties.maxSwapchainImageWidth,
            systemProperties.graphicsProperties.maxSwapchainImageHeight,
            systemProperties.graphicsProperties.maxLayerCount).c_str());
        PRINT("%s", Fmt("System Tracking Properties: OrientationTracking=%s PositionTracking=%s",
            systemProperties.trackingProperties.orientationTracking == XR_TRUE ? "True" : "False",
            systemProperties.trackingProperties.positionTracking == XR_TRUE ? "True" : "False").c_str());
 
        // Query and cache view configuration views.
        uint32_t viewCount;
        CHECK_XRCMD(xrEnumerateViewConfigurationViews(xrInstance, systemId, xrViewConfType, 0, &viewCount, nullptr));
        xrConfViews.resize(viewCount, { XR_TYPE_VIEW_CONFIGURATION_VIEW });
        CHECK_XRCMD(xrEnumerateViewConfigurationViews(xrInstance, systemId, xrViewConfType, viewCount, &viewCount,
            xrConfViews.data()));
 
        // create v
        // Create and cache view buffer for xrLocateViews later.
        xrViews.resize(viewCount, { XR_TYPE_VIEW });
 
        // Create the swapchain and get the images.
        if (viewCount > 0) {
            // Select a swapchain format.
            uint32_t swapchainFormatCount;
            CHECK_XRCMD(xrEnumerateSwapchainFormats(xrSession, 0, &swapchainFormatCount, nullptr));
            std::vector<int64_t> swapchainFormats(swapchainFormatCount);
            CHECK_XRCMD(xrEnumerateSwapchainFormats(xrSession, (uint32_t)swapchainFormats.size(), &swapchainFormatCount,
                swapchainFormats.data()));
            CHECK(swapchainFormatCount == swapchainFormats.size());
            colorSwapchainFormat = SelectColorSwapchainFormat(swapchainFormats);
            if (depthExtensionAvailable) {
        depthSwapchainFormat = SelectDepthSwapchainFormat(swapchainFormats, wrapper->getRenderPassSupportedDepthFormats());
            }
            // Print swapchain formats and the selected one.
            {
                std::string swapchainFormatsString;
                for (int64_t format : swapchainFormats) {
                    const bool selected = format == colorSwapchainFormat;
                    swapchainFormatsString += " ";
                    if (selected) {
                        swapchainFormatsString += "[";
                    }
                    swapchainFormatsString += std::to_string(format);
                    if (selected) {
                        swapchainFormatsString += "]";
                    }
                }
                PRINT("%s", Fmt("Swapchain Formats: %s", swapchainFormatsString.c_str()).c_str());
            }
 
            // Create a swapchain for each view.
            swapchains.resize(viewCount);
            translationsOMAF.resize(viewCount);
            translationsOpenXR.resize(viewCount);
 
            if (depthExtensionAvailable) {
                depthSwapchains.resize(viewCount);
            }
            for (uint32_t i = 0; i < viewCount; i++) {
                swapchains[i] = std::unique_ptr<SwapchainOpenXR>(new SwapchainOpenXR(colorSwapchainFormat, xrConfViews[i], this, wrapper, &xrSession));
                if (depthExtensionAvailable) {
          depthSwapchains[i] = std::unique_ptr<SwapchainOpenXR>(new SwapchainOpenXR(depthSwapchainFormat, xrConfViews[i], this, wrapper, &xrSession));
                }
            }
        }
    }
void WindowOpenXR::createMirrorSwapchain()
{
    vk::SwapchainCreateInfoKHR mirrorCreateInfo{};
    //vk::Format colorFormat = static_cast<vk::Format>(colorSwapchainFormat);
    auto availableFormats = wrapper->context.physicalDevice.getSurfaceFormatsKHR(surface);
    auto colorFormat = availableFormats[0];
    for (auto form : availableFormats) {
        if (form.format == vk::Format::eR8G8B8Unorm) {
      colorFormat = form;
        }
    }
    vk::PresentModeKHR presentMode = vk::PresentModeKHR::eMailbox;
 
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    vk::Extent2D extent{ (uint32_t) width, (uint32_t) height};
 
    this->width = width;
    this->height = height;
 
    QueueFamilyIndices indices = wrapper->context.findQueueFamilies(wrapper->context.physicalDevice);
    uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
 
    int queueFamilyIndexCount = 0;
    auto imageSharingMode = vk::SharingMode::eExclusive;
    if (indices.graphicsFamily != indices.presentFamily) {
        imageSharingMode = vk::SharingMode::eConcurrent;
        queueFamilyIndexCount = 2;
    }
 
    vk::SwapchainCreateInfoKHR swapChainCreateInfo(
        vk::SwapchainCreateFlagsKHR(),                              //flags
        static_cast<vk::SurfaceKHR>(surface),         //vk::surface
        mirrorSwapchainSize,                                                 //numberOfImage
        colorFormat.format,                                       //format
        colorFormat.colorSpace,                                   //colorSpace
        extent,                                                     //vk::Extend2D
        1,                                                          //imageArrayLayers
        vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eInputAttachment | vk::ImageUsageFlagBits::eTransferDst,     //imageUsage
        vk::SharingMode::eExclusive,                                           //imageSharingMode
        queueFamilyIndexCount,                                      //Queue family index count
        queueFamilyIndexCount > 0 ? queueFamilyIndices : nullptr,    //Queue family indices
        vk::SurfaceTransformFlagBitsKHR::eIdentity,             //preTransform
        vk::CompositeAlphaFlagBitsKHR::eOpaque,                     //compositeAlpha  //TODO check Alpha
        presentMode,                                                //presentMode   
        true,                                                       //clipped
        nullptr);                                                   //oldSwapchain
 
       mirrorSwapchain = wrapper->context.device.createSwapchainKHR(swapChainCreateInfo);
       mirrorImages = wrapper->context.device.getSwapchainImagesKHR(mirrorSwapchain);
       vk::SemaphoreCreateInfo semaphoreInfo;
       for (int i = 0; i < mirrorSwapchainSize; i++) {
           mirrorAvailableSemaphore.push_back(wrapper->context.device.createSemaphore(semaphoreInfo));
           mirrorFinnishedSemaphore.push_back(wrapper->context.device.createSemaphore(semaphoreInfo));
       }
}
// Return event if one is available, otherwise return null.
const XrEventDataBaseHeader* WindowOpenXR::TryReadNextEvent() {
    // It is sufficient to clear the just the XrEventDataBuffer header to
    // XR_TYPE_EVENT_DATA_BUFFER
    XrEventDataBaseHeader* baseHeader = reinterpret_cast<XrEventDataBaseHeader*>(&eventDataBuffer);
    *baseHeader = {XR_TYPE_EVENT_DATA_BUFFER};
    const XrResult xr = xrPollEvent(xrInstance, &eventDataBuffer);
    if (xr == XR_SUCCESS) {
        if (baseHeader->type == XR_TYPE_EVENT_DATA_EVENTS_LOST) {
            const XrEventDataEventsLost* const eventsLost = reinterpret_cast<const XrEventDataEventsLost*>(baseHeader);
            PRINT("%s", Fmt("%d events lost", eventsLost).c_str());
        }
 
        return baseHeader;
    }
    if (xr == XR_EVENT_UNAVAILABLE) {
        return nullptr;
    }
    THROW_XR(xr, "xrPollEvent");
}
 
void WindowOpenXR::setMirror(bool mirrorActivated)
{
#ifdef __ANDROID__
    throw std::runtime_error("Not supported when the headset is in standalone mode");
#endif // 
    this->mirrorActivated = mirrorActivated;
}
 
bool WindowOpenXR::isDepthRecquired()
{
    if (depthExtensionAvailable) {
        return true;
    }
    else {
        return false;
    }
}
 
 
void WindowOpenXR::pollEvents(bool *exitRenderLoop, bool *requestRestart) {
    *exitRenderLoop = *requestRestart = false;
 
    // Process all pending messages.
    while (const XrEventDataBaseHeader* event = TryReadNextEvent()) {
        switch (event->type) {
            case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING: {
                const auto& instanceLossPending = *reinterpret_cast<const XrEventDataInstanceLossPending*>(event);
                PRINT("%s", Fmt("XrEventDataInstanceLossPending by %lld", instanceLossPending.lossTime).c_str());
                *exitRenderLoop = true;
                *requestRestart = true;
                return;
            }
            case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: {
                auto sessionStateChangedEvent = *reinterpret_cast<const XrEventDataSessionStateChanged*>(event);
                PRINT("sesion state change");
                HandleSessionStateChangedEvent(sessionStateChangedEvent, exitRenderLoop, requestRestart);
                //TODO
                break;
            }
            case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED:
                //no in
                break;
            case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING:
            default: {
                PRINT( "%s", Fmt("Ignoring event type %d", event->type).c_str());
                break;
            }
        }
    }
}
void WindowOpenXR::HandleSessionStateChangedEvent(const XrEventDataSessionStateChanged& stateChangedEvent, bool* exitRenderLoop,
                                    bool* requestRestart) {
    const XrSessionState oldState = xrSessionState;
    xrSessionState = stateChangedEvent.state;
 
    PRINT("%s", Fmt("XrEventDataSessionStateChanged: state %s->%s session=%lld time=%lld", to_string(oldState),
                                     to_string(xrSessionState), stateChangedEvent.session, stateChangedEvent.time).c_str());
 
    if ((stateChangedEvent.session != XR_NULL_HANDLE) && (stateChangedEvent.session != xrSession)) {
        PRINT("%s", "XrEventDataSessionStateChanged for unknown session");
        return;
    }
 
    switch (xrSessionState) {
        case XR_SESSION_STATE_READY: {
            CHECK(xrSession != XR_NULL_HANDLE);
            XrSessionBeginInfo sessionBeginInfo{XR_TYPE_SESSION_BEGIN_INFO};
            sessionBeginInfo.primaryViewConfigurationType = xrViewConfType;
            CHECK_XRCMD(xrBeginSession(xrSession, &sessionBeginInfo));
            runningSession = true;
            break;
        }
        case XR_SESSION_STATE_STOPPING: {
            CHECK(xrSession != XR_NULL_HANDLE);
            runningSession = false;
            CHECK_XRCMD(xrEndSession(xrSession))
            break;
        }
        case XR_SESSION_STATE_EXITING: {
            *exitRenderLoop = true;
            // Do not attempt to restart because user closed this session.
            *requestRestart = false;
            break;
        }
        case XR_SESSION_STATE_LOSS_PENDING: {
            *exitRenderLoop = true;
            // Poll for a new instance.
            *requestRestart = true;
            break;
        }
        default:
            break;
    }
}
 
void WindowOpenXR::selectViewConfiguration()
{
    uint32_t viewConfigTypeCount;
    CHECK_XRCMD(xrEnumerateViewConfigurations(xrInstance, systemId, 0, &viewConfigTypeCount, nullptr));
    std::vector<XrViewConfigurationType> viewConfigTypes(viewConfigTypeCount);
    CHECK_XRCMD(xrEnumerateViewConfigurations(xrInstance, systemId, viewConfigTypeCount,
        &viewConfigTypeCount,
        viewConfigTypes.data()));
    CHECK((uint32_t)viewConfigTypes.size() == viewConfigTypeCount);
    bool foundConfigurationType = false;
    for (auto supportedConf : supportedViewConfigurations) {
        for (XrViewConfigurationType viewConfigType : viewConfigTypes) {
            if (supportedConf == viewConfigType && !((viewConfigType == XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO) && !quadViewExtensionAvailable )) {
                //in the case where the quad view etension has not been selected, this view configuration type should not be selected
                xrViewConfType = supportedConf;
            }
        }
    }
}
 
void WindowOpenXR::selectBlendMode()
{
    /*uint32_t viewConfigTypeCount;
    CHECK_XRCMD(xrEnumerateViewConfigurations(xrInstance, systemId, 0, &viewConfigTypeCount, nullptr));
    std::vector<XrViewConfigurationType> viewConfigTypes(viewConfigTypeCount);
    CHECK_XRCMD(xrEnumerateViewConfigurations(xrInstance, systemId, viewConfigTypeCount,
        &viewConfigTypeCount,
        viewConfigTypes.data()));
    CHECK((uint32_t)viewConfigTypes.size() == viewConfigTypeCount);*/
    bool blendModeFound = false;
    //for (XrViewConfigurationType viewConfigType : viewConfigTypes) {
        uint32_t count;
        CHECK_XRCMD(xrEnumerateEnvironmentBlendModes(xrInstance, systemId, xrViewConfType, 0, &count, nullptr));
        CHECK(count > 0);
        std::vector<XrEnvironmentBlendMode> blendModes(count);
        CHECK_XRCMD(xrEnumerateEnvironmentBlendModes(xrInstance, systemId, xrViewConfType, count, &count, blendModes.data()));
 
        
        for (XrEnvironmentBlendMode mode : blendModes) {
            for (auto supportedBlend : this->supportedBlendModes) {
        if (supportedBlend == mode && !blendModeFound) {
                    xrBlendMode = mode;
                    blendModeFound = true;
                    break;
                }
            }
        }
        CHECK(blendModeFound);
    //}
}
 
void WindowOpenXR::checkExtensions()
{
    PRINT("\n Check for Openxr Extensions:");
    uint32_t instanceExtensionCount;
    CHECK_XRCMD(xrEnumerateInstanceExtensionProperties(nullptr, 0, &instanceExtensionCount, nullptr));
 
    std::vector<XrExtensionProperties> extensions(instanceExtensionCount);
    for (XrExtensionProperties& extension : extensions) {
        extension.type = XR_TYPE_EXTENSION_PROPERTIES;
    }
 
    CHECK_XRCMD(xrEnumerateInstanceExtensionProperties(nullptr, (uint32_t)extensions.size(), &instanceExtensionCount,
        extensions.data()));
 
    for (auto& ext : extensions) {
        if (strcmp(ext.extensionName , XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME) == 0) {
            depthExtensionAvailable = true;
            PRINT("Depth extension available !");
        }
        if (strcmp(ext.extensionName , XR_VARJO_QUAD_VIEWS_EXTENSION_NAME) == 0) {
            quadViewExtensionAvailable = true;
            PRINT("Varjo quad view extension available !" );
        }
        D(PRINT("found extension: %s", ext.extensionName));
    }
    PRINT("\n");
}
 
#ifndef __ANDROID__
void WindowOpenXR::inputKeyCallback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
    const int inputAction = GLFW_PRESS;
    if (key == GLFW_KEY_SPACE && action == inputAction)
    {
        printCoordinates();
    }
    else if ((key == GLFW_KEY_0 || key == GLFW_KEY_KP_0) && action == inputAction) {
        resetOrigin();
    }
    else if (key == GLFW_KEY_ESCAPE) {
        xrRequestExitSession(xrSession);
    }
    else if (key == GLFW_KEY_F3) {
        wrapper->loadConfigurationsFromDisk();
    }
    else if (key == GLFW_KEY_F9) {
        this->pauseRendering = true;
        PRINT("pause rendering for test");
    }
}
#endif
 
void WindowOpenXR::renderFrame(VulkanDrawing* vulkanDrawing) {
    XrFrameWaitInfo frameWaitInfo{XR_TYPE_FRAME_WAIT_INFO};
    XrFrameState frameState{XR_TYPE_FRAME_STATE};
    CHECK_XRCMD(xrWaitFrame(xrSession, &frameWaitInfo, &frameState));
 
    XrFrameBeginInfo frameBeginInfo{XR_TYPE_FRAME_BEGIN_INFO};
    CHECK_XRCMD(xrBeginFrame(xrSession, &frameBeginInfo));
 
    
 
    std::vector<XrCompositionLayerProjectionView> projectionLayerViews;
    std::vector<XrCompositionLayerDepthInfoKHR> depthProjectionLayerViews;
    std::vector<XrCompositionLayerBaseHeader*> layers;
    XrCompositionLayerProjection layer{ XR_TYPE_COMPOSITION_LAYER_PROJECTION };
 
    if (!mirrorActivated) {
        checkKeyboard();
    }
 
    if (frameState.shouldRender == XR_TRUE) {
        
        //if (RenderLayer(frameState.predictedDisplayTime, projectionLayerViews, layer)) {
        XrResult res;
        bool renderOk = true;
 
        XrViewState viewState{XR_TYPE_VIEW_STATE};
        uint32_t viewCapacityInput = (uint32_t)xrViews.size();
        uint32_t viewCountOutput;
 
        XrViewLocateInfo viewLocateInfo{XR_TYPE_VIEW_LOCATE_INFO};
        viewLocateInfo.viewConfigurationType = xrViewConfType;
        viewLocateInfo.displayTime = frameState.predictedDisplayTime;
        viewLocateInfo.space = refSpace;
 
        res = xrLocateViews(xrSession, &viewLocateInfo, &viewState, viewCapacityInput, &viewCountOutput, xrViews.data());
        if (!((viewState.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT) == 0 ||
            (viewState.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT) == 0)) {
            //valid pose
            //D(
                count++;
            auto startTime = std::chrono::high_resolution_clock::now();
            //)
 
            CHECK(viewCountOutput == viewCapacityInput);
            CHECK(viewCountOutput == xrConfViews.size());
            CHECK(viewCountOutput == swapchains.size());
            if (depthExtensionAvailable) {
                CHECK(viewCountOutput == depthSwapchains.size());
            }
 
            projectionLayerViews.resize(viewCountOutput);
            if (depthExtensionAvailable) {
                depthProjectionLayerViews.resize(viewCountOutput);
            }
 
            std::vector<vk::Fence> fences;
            std::vector<uint32_t> indexesSwap;
            std::vector<uint32_t> indexesSwapDepth;
            //-------------------------------------
            // Render view to the appropriate part of the swapchain image.
            for (uint32_t i = 0; i < viewCountOutput; i++) {
                // Each view has a separate swapchain which is acquired, rendered to, and released.
                auto viewSwapchainHandle = swapchains[i]->handle;//swapchains[i]->getSwapchainStruct();
                //std::variant<XrSwapchain,vk::SwapchainKHR> depthHandle;
                /*
                */
                uint32_t swapchainImageIndex;
                std::optional<vk::Semaphore> semaphore;
                std::tie(swapchainImageIndex, semaphore) = swapchains[i]->acquireImage();
                indexesSwap.push_back(swapchainImageIndex);
                std::vector<vk::Semaphore> semaphoresList;
                if (semaphore.has_value()) {
                    semaphoresList.push_back(semaphore.value());
                }
                projectionLayerViews[i] = { XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW };
                projectionLayerViews[i].pose = xrViews[i].pose;
                projectionLayerViews[i].fov = xrViews[i].fov;
                projectionLayerViews[i].subImage.swapchain = std::get<XrSwapchain>(viewSwapchainHandle);
                projectionLayerViews[i].subImage.imageRect.offset = { 0, 0 };
                projectionLayerViews[i].subImage.imageRect.extent.width = swapchains[i]->swapchainExtent.width;
                projectionLayerViews[i].subImage.imageRect.extent.height = swapchains[i]->swapchainExtent.height;
 
                uint32_t depthSwapchainImageIndex = UINT_MAX;
                if (depthExtensionAvailable) {
                    std::optional<vk::Semaphore> dSemaphore;
                    std::tie(depthSwapchainImageIndex, dSemaphore) = depthSwapchains[i]->acquireImage();
                    indexesSwapDepth.push_back(depthSwapchainImageIndex);
                    if (dSemaphore.has_value()) {
                        semaphoresList.push_back(dSemaphore.value());
                    }
                    assert(depthSwapchainImageIndex == swapchainImageIndex);
                    depthProjectionLayerViews[i] = {XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR};
                    depthProjectionLayerViews[i].minDepth = 1;
                    depthProjectionLayerViews[i].maxDepth = 0;
                    //reverse depth so min value is set to far and max to near
                    depthProjectionLayerViews[i].nearZ = wrapper->params.farPlaneHeadset;
                    depthProjectionLayerViews[i].farZ = wrapper->params.nearPlaneHeadset;
                    //--------
                    depthProjectionLayerViews[i].subImage.swapchain = std::get<XrSwapchain>(depthSwapchains[i]->handle);
                    depthProjectionLayerViews[i].subImage.imageArrayIndex = 0;
                    depthProjectionLayerViews[i].subImage.imageRect.offset = { 0,0 };
                    depthProjectionLayerViews[i].subImage.imageRect.extent = { (int) depthSwapchains[i]->swapchainExtent.width, (int) depthSwapchains[i]->swapchainExtent.height };
                    projectionLayerViews[i].next = &(depthProjectionLayerViews[i]);
                }
                else {
                    projectionLayerViews[i].next = nullptr;
                }
                
                translationsOpenXR[i] = { xrViews[i].pose.position.x ,xrViews[i].pose.position.y,xrViews[i].pose.position.z };
                translationsOMAF[i] = conversionMat * translationsOpenXR[i]; 
 
#ifdef HVT_UDP_CONTROL
                mutex.lock();
#endif
                this->currentTranslation = deltaQuat*(translationsOpenXR[i] + deltaPos);
 
#ifdef HVT_UDP_CONTROL
                mutex.unlock();
#endif
 
                auto rot = XrQuaternionToGLMQuat(xrViews[i].pose.orientation);
                this->setRotation(rot, i);
                glm::vec4 fov(xrViews[i].fov.angleLeft, xrViews[i].fov.angleRight, xrViews[i].fov.angleUp,xrViews[i].fov.angleDown);
                wrapper->updateSpaceTransform(currentTranslation, currentRotation,fov, i);
 
                uint32_t mirrorIndex = 0;
                mirrorShouldRender = true;
                if (mirrorActivated && i == 0 && swapchainImageIndex == currentMirror) {
 
                    int width = 0, height = 0;
                    glfwGetFramebufferSize(window, &width, &height);
 
                    if (width == 0 || height == 0) {
                        mirrorShouldRender = false;
                    }else{
                        try {
                            vk::Result acquireResult;
                            std::tie(acquireResult, mirrorIndex) = wrapper->getContext()->device.acquireNextImageKHR(mirrorSwapchain, std::numeric_limits<uint64_t>::max(), mirrorAvailableSemaphore[currentMirror], nullptr);
 
                            if (acquireResult != vk::Result::eSuccess && acquireResult != vk::Result::eSuboptimalKHR) {
                                throw std::runtime_error("failed to acquire swap chain image!");
                            }
                        }
                        catch (vk::OutOfDateKHRError e) {
                            //vulkan hpp raise an exception when vk::Result::eErrorOutOfDateKHR, no need to check for it in return code above
                            recreateMirror();
                            mirrorShouldRender = false;
                        }
                    }
                    if (mirrorShouldRender) {
                        semaphoresList.push_back(mirrorAvailableSemaphore[currentMirror]);
                    }
 
                }
                
                std::tuple<int, uint32_t> idImage = std::make_pair(i,swapchainImageIndex);
                vk::Fence renderfinnished;
                std::vector<vk::Semaphore> sem;
                if (mirrorActivated && i == 0 && swapchainImageIndex == currentMirror && mirrorShouldRender) {
                    sem.push_back(mirrorFinnishedSemaphore[currentMirror]);
                }
 
                if (depthExtensionAvailable) {
                    renderfinnished = vulkanDrawing->submitDrawCall(idImage, semaphoresList, sem ,depthSwapchainImageIndex);
                }
                else {
                    renderfinnished = vulkanDrawing->submitDrawCall(idImage, semaphoresList, sem);
                }
 
                fences.push_back(renderfinnished);
 
                if (mirrorActivated && i == 0 && swapchainImageIndex == currentMirror && mirrorShouldRender) {
                    vk::PresentInfoKHR presentInfo{ 1,
                        &mirrorFinnishedSemaphore[currentMirror],
                        1,
                        &mirrorSwapchain,
                        &mirrorIndex,
                        nullptr };
                    try {
                        vk::Result resultPresent = wrapper->getContext()->presentQueue.presentKHR(presentInfo);
                        
                        if (resultPresent == vk::Result::eSuboptimalKHR) {
                            recreateMirror();
                        }
                        else if (resultPresent != vk::Result::eSuccess) {
                            throw std::runtime_error("failed to present swap chain image!");
                        }
                    }
                    catch (vk::OutOfDateKHRError) {
                        //vulkan hpp raise an exception when vk::Result::eErrorOutOfDateKHR, no need to check for it in return code above
                        recreateMirror();
                    }
                    currentMirror = (currentMirror + 1) % mirrorSwapchainSize;
                }
 
                
                
            }
            for (uint32_t i = 0; i < viewCountOutput; i++) {
                assert(fences.size() == viewCountOutput);
                assert(indexesSwap.size() == viewCountOutput);
 
                swapchains[i]->presentImage(indexesSwap[i], fences[i]);
                if (depthExtensionAvailable) {
                    assert(indexesSwapDepth.size() == viewCountOutput);
                    depthSwapchains[i]->presentImage(indexesSwapDepth[i], fences[i]);
                }
            }
 
            layer.space = refSpace;
            layer.viewCount = (uint32_t)projectionLayerViews.size();
            layer.views = projectionLayerViews.data();
 
            layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&layer));
            //D(
            auto end = std::chrono::high_resolution_clock::now();
            auto t = std::chrono::duration_cast<std::chrono::milliseconds>(end - startTime);
            totalChrono += t;
            if (count == 100) {
                auto res = totalChrono / (count);
                std::cout << res.count() << std::endl;
                totalChrono = std::chrono::milliseconds( 0 );
                count = 0;
            }
            //)
                
        }
    }
 
    XrFrameEndInfo frameEndInfo{XR_TYPE_FRAME_END_INFO};
    frameEndInfo.displayTime = frameState.predictedDisplayTime;
    frameEndInfo.environmentBlendMode = xrBlendMode;
    frameEndInfo.layerCount = (uint32_t)layers.size();
    frameEndInfo.layers = layers.data();
    CHECK_XRCMD(xrEndFrame(xrSession, &frameEndInfo));
 
    depthProjectionLayerViews.clear();
    projectionLayerViews.clear();
 
    
}
 
bool WindowOpenXR::isSessionRunning() {
    return runningSession;
}
 
void WindowOpenXR::setRotation(glm::quat & qR, int view) {
 
    //Math from https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
 
    
 
    assert(quaternionsList.size() == rotationsOMAF.size());
    assert(quaternionsList.size() == rotationsOpenXR.size());
    if (quaternionsList.size() != swapchains.size()) {
        const int s = swapchains.size();
        quaternionsList.resize(s);
        rotationsOMAF.resize(s);
        rotationsOpenXR.resize(s);
    }
 
    quaternionsList[view] = qR;
 
#ifdef HVT_UDP_CONTROL
    mutex.lock();
#endif
    auto q = deltaQuat * qR;
 
#ifdef HVT_UDP_CONTROL
    mutex.unlock();
#endif
 
    //roll
    double siny_cosp = 2 * (q.w * q.z + q.x * q.y);
    double cosy_cosp = 1 - 2 * (q.y * q.y + q.z * q.z);
    rotationsOMAF[view][0] = -1 * std::atan2(siny_cosp, cosy_cosp) * (180.0 / M_PI);
    rotationsOpenXR[view][2] = std::atan2(siny_cosp, cosy_cosp) * (180.0 / M_PI);
 
    // pitch
    double sinp = 2 * (q.w * q.y - q.z * q.x);
    if (std::abs(sinp) >= 1) {
        rotationsOMAF[view][2] = std::copysign(M_PI / 2, sinp) * (180.0 / M_PI); // use 90 degrees if out of range
        rotationsOpenXR[view][1] = std::copysign(M_PI / 2, sinp) * (180.0 / M_PI); // use 90 degrees if out of range
    }
    else {
        rotationsOMAF[view][2] = std::asin(sinp) * (180.0 / M_PI);
        rotationsOpenXR[view][1] = std::asin(sinp) * (180.0 / M_PI);
    }
 
    // Roll
    double sinr_cosp = 2 * (q.w * q.x + q.y * q.z);
    double cosr_cosp = 1 - 2 * (q.x * q.x + q.y * q.y);
    rotationsOMAF[view][1] = -1 * std::atan2(sinr_cosp, cosr_cosp) * (180.0 / M_PI);
    rotationsOpenXR[view][0] =  std::atan2(sinr_cosp, cosr_cosp) * (180.0 / M_PI);
 
    currentRotation =  rotationsOpenXR[view];
 
    
}
 
 
 
vk::Image WindowOpenXR::getSwapchainImage(int view, int index) {
    assert(view < swapchains.size());
    return swapchains[view]->getSwapchainImage(index);//swapChainImagesXr[view][index].image;
}
 
 
void WindowOpenXR::checkKeyboard() {
#if WIN32
    //Windows only
    SHORT keyState0 = GetAsyncKeyState('0');
    bool isToggled0 = keyState0 & 1;
    bool isDown0 = keyState0 & 0x8000;
 
    SHORT keyStateNum0 = GetAsyncKeyState(VK_NUMPAD0);
    auto isToggledNum0 = keyStateNum0 & 1;
    bool isDownNum0 = keyStateNum0 & 0x8000;
 
    SHORT keyStateSpace = GetAsyncKeyState(VK_SPACE);
    bool isToggledSpace = keyStateSpace & 1;
    bool isDownSpace = keyStateSpace & 0x8000;
 
    SHORT keyStateEscape = GetAsyncKeyState(VK_ESCAPE);
    bool isToggledEscape = keyStateEscape & 1;
 
    SHORT keyStateF2 = GetAsyncKeyState(VK_F2);
    bool isToggledF2 = keyStateF2 & 1;
 
    SHORT keyStateF3 = GetAsyncKeyState(VK_F3);
    bool isToggledF3 = keyStateF3 & 1;
 
#else
    //need to test for posix systems
    bool isToggled0 = false;
    bool isToggledSpace = false;
    bool isDown0 = false;
    bool isDownSpace = false;
    bool isToggledNum0 = false;
    bool isDownNum0 = false;
    bool isToggledEscape = false;
    bool isToggledF2 = false;
    bool isToggledF3 = false;
 
 
    //TODO fix that for LINUX
    //maybe:
    //https://stackoverflow.com/questions/29335758/using-kbhit-and-getch-on-linux
    /*
    if (kbhit()) {
        auto c = getch();
        if (c == ' ') {
            isDownSpace = true;
            isToggledSpace = true;
        }
        else if (c == '0') {
            isDown0 = true;
            isToggled0 = true;
        }
    }*/
#endif
 
    if ((isDown0 && isToggled0) || (isDownNum0 && isToggledNum0)) {
        resetOrigin();
    }
 
    if (isDownSpace && isToggledSpace) {
        printCoordinates();
    }
 
    if (isToggledEscape) {
        xrRequestExitSession(xrSession);
    }
 
    /*
    if (isToggledF2) {
        wrapper->saveConfigurationsToDisk();
    }*/
 
    if (isToggledF3) {
        wrapper->loadConfigurationsFromDisk();
    }
}
 
void WindowOpenXR::resetOrigin()
{
    glm::vec3 averagePos = { 0,0,0 };
    for (int i = 0; i < translationsOpenXR.size(); i++) {
        averagePos += translationsOpenXR[i];
    }
    averagePos /= translationsOpenXR.size();
    glm::quat q = quaternionsList[quaternionsList.size() - 1];
 
#ifdef HVT_UDP_CONTROL
    mutex.lock();
#endif
 
    deltaPos = -1.0f * averagePos;
    deltaQuat = glm::inverse(q);
 
#ifdef HVT_UDP_CONTROL
    mutex.unlock();
#endif
 
}
 
void WindowOpenXR::printCoordinates()
{
    std::cout << "--------------" << std::endl;
    for (int i = 0; i < 2; i++) {
        std::cout << "View: " << i << std::endl;
        std::cout << "Translation OpenXR: " << glm::to_string(translationsOpenXR[i]) << "Rotation OpenXR : " << glm::to_string(rotationsOpenXR[i]) << std::endl;
        std::cout << "Translation OMAF: " << glm::to_string(translationsOMAF[i]) << "Rotation OMAF : " << glm::to_string(rotationsOMAF[i]) << std::endl;
        std::cout << "Test: " << glm::to_string(conversionMat * rotationsOMAF[i]) << std::endl;
    }
}