WindowOpenXR.h

Go to the documentation of this file.

/* ---------------------- 
* 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.
---------------------- */
 
 
 
/*****************************************************************/
#pragma once
 
#ifdef __ANDROID__
#include <android/log.h>
#include <android_native_app_glue.h>
#else
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#endif
 
#include"WindowAbstract.h"
#include "SwapchainOpenXR.h"
#include <mutex>
 
class WindowOpenXR: public WindowAbstract {
    public:
#ifdef __ANDROID__
    OpenXRWindow(android_app* appAndroid);
#endif
        void initWindow() override;
        void continueInit() override;
        void cleanUp() override;
        void cleanUpSurface() override; 
        void mainLoop(VulkanDrawing * vulkanDrawing) override; 
        void createSurface() override; 
        std::vector<const char*> getRequiredExtensions() override; 
        VkBool32 isDeviceSupportingSufaceKHR(VkPhysicalDevice device, int i) override; //not usefull
        std::vector<const char*> getRequiredDeviceExtensions() override;
        SwapChainSupportDetails querySwapChainSupport(vk::PhysicalDevice device) override; //not usefull
        void getFrameBufferSize(int* w, int* h, vk::PhysicalDevice & pDevice) override; //not usefull here
        bool isSynchroWithSemaphore() override;
        bool isDepthRecquired() override;
        const bool useOpenXR() override;
        vk::Image getSwapchainImage(int view, int index) override;
 
        void resetOrigin() override;
 
        void framebufferResizeCallback();
        void checkForCorrectSize(); 
        std::vector<vk::Image> getBlitDestinations(int view, int elem) override;
        std::vector<vk::Extent2D> getBlitExtentDestinations(int view, int elem) override;
        virtual std::vector<vk::Semaphore> getSemaphoreWait(int view, int elem) override;
        virtual std::vector<vk::Semaphore> getSemaphoreSignal(int view, int elem) override;
        
        void getVulkanPhysicalDevice(VkInstance & vkInstance, VkPhysicalDevice * physicalDevice);
        void createVulkanDevice(VkPhysicalDevice & physicalDevice, VkDeviceCreateInfo & info, VkDevice * device);
        void pollEvents(bool* exitRenderLoop, bool* requestRestart);
        bool isSessionRunning();
        void setRotation(glm::quat& q, int view);
 
 
        void setMirror(bool mirrorActivated);
 
 
 
 
        
 
    private:
 
    bool mirrorActivated = true;
    bool depthExtensionAvailable = false;
    bool quadViewExtensionAvailable = false;
    bool pauseRendering = false;
 
    //
    glm::mat3x3 conversionMat = {0,-1,0, 0,0,1, -1,0,0};
 
    XrInstance xrInstance = XR_NULL_HANDLE;
    XrSystemId systemId = XR_NULL_SYSTEM_ID;
    XrGraphicsBindingVulkan2KHR graphicsBinding ;
    XrSession xrSession = XR_NULL_HANDLE;
    std::vector<XrSpace> xrVisualizedSpaces;
    XrSpace refSpace = XR_NULL_HANDLE;
    std::vector<XrViewConfigurationView> xrConfViews;
    std::vector<XrView> xrViews;
    uint64_t colorSwapchainFormat = 0;
    uint64_t depthSwapchainFormat = 0;
    bool runningSession = false;
    
    XrSessionState xrSessionState{XR_SESSION_STATE_UNKNOWN};
    
 
    const std::array< XrEnvironmentBlendMode,2> supportedBlendModes {XR_ENVIRONMENT_BLEND_MODE_ADDITIVE, XR_ENVIRONMENT_BLEND_MODE_OPAQUE };
    XrEnvironmentBlendMode xrBlendMode = XR_ENVIRONMENT_BLEND_MODE_ADDITIVE;
    const std::array <XrViewConfigurationType, 2> supportedViewConfigurations = { XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO , XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO };
    XrViewConfigurationType xrViewConfType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
    XrEventDataBuffer eventDataBuffer;
    std::vector<char> extensionNames;
    std::vector<char> deviceExtension;
 
 
#if __ANDROID__
 
    const std::vector<const char*> instanceExtensions = {
        VK_KHR_SURFACE_EXTENSION_NAME,
        VK_KHR_ANDROID_SURFACE_EXTENSION_NAME
    };
        };
        android_app* appAndroid = nullptr;
 
#else
 
    const std::vector<const char*> instanceExtensions = {
        VK_KHR_SURFACE_EXTENSION_NAME
    };
 
    //mirror ressources
    GLFWwindow* window = nullptr;
    VkSurfaceKHR surface = VK_NULL_HANDLE;
    vk::SwapchainKHR mirrorSwapchain;
    std::vector<vk::Image> mirrorImages;
    std::vector<vk::Semaphore> mirrorAvailableSemaphore;
    std::vector<vk::Semaphore> mirrorFinnishedSemaphore;
    uint32_t mirrorSwapchainSize = 3;
    uint32_t currentMirror = 0;
    uint32_t width = 960;
    uint32_t height = 540;
 
    bool mirrorShouldRender = true;
    void cleanUpMirrorSwapchain();
    void recreateMirror();
 
    void inputKeyCallback(GLFWwindow* window, int key, int scancode, int action, int mode);
#endif
    
 
 
 
    //Rotation and translation
    
    std::vector<glm::vec3> rotationsOMAF;
    std::vector<glm::vec3> translationsOMAF;
    std::vector<glm::vec3> rotationsOpenXR;
    std::vector<glm::vec3> translationsOpenXR;
 
    std::vector<glm::quat> quaternionsList;
 
    glm::vec3 deltaPos = { 0,0,0 };
    glm::quat deltaQuat = glm::identity<glm::quat>();
 
    //---------private functions 
    void initOpenXR();
    const XrEventDataBaseHeader *TryReadNextEvent();
    void CreateSpaces();
    void CreateSwapChain();
    void createMirrorSwapchain();
    void LogReferenceSpaces();
    void logViewConfiguration(XrInstance & xrInstance, XrSystemId & systemId);
    static XrResult GetVulkanGraphicsRequirements2KHR(XrInstance instance, XrSystemId systemId,
                                               XrGraphicsRequirementsVulkan2KHR* graphicsRequirements);
    void renderFrame(VulkanDrawing* vulkanDrawing);
    void HandleSessionStateChangedEvent(const XrEventDataSessionStateChanged& stateChangedEvent, bool* exitRenderLoop,
                                        bool* requestRestart);
    void selectViewConfiguration();
    void selectBlendMode();
    void checkExtensions();
    void checkKeyboard();
    void printCoordinates();
    
 
#ifdef HVT_UDP_CONTROL
    std::mutex mutex;
#endif // 
 
    
 
 
 
#if NDEBUG
    const bool validationXR = false;
#else
    const bool validationXR = false;
#endif
 
 
const std::vector<const char*> additionalDeviceExtensions = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
 
 
 
 
};