HoviTron Video Pipeline: WindowOpenXR Class Reference

Class that take care of the tasks linked to OpenXR (input and display), is used when HMD support is requested.
More...

#include <WindowOpenXR.h>

Inheritance diagram for WindowOpenXR:

Public Member Functions
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

std::vector< const char * >	getRequiredDeviceExtensions () override

SwapChainSupportDetails	querySwapChainSupport (vk::PhysicalDevice device) override

void	getFrameBufferSize (int w, int h, vk::PhysicalDevice &pDevice) override

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)

Public Member Functions inherited from WindowAbstract
virtual void	initWindow ()=0

virtual void	continueInit ()=0

virtual void	cleanUp ()=0

virtual void	cleanUpSurface ()=0

virtual void	mainLoop (VulkanDrawing *vulkanDrawing)=0

virtual void	createSurface ()=0

virtual std::vector< const char * >	getRequiredExtensions ()=0

const bool	isValidationLayersEnabled ()

virtual VkBool32	isDeviceSupportingSufaceKHR (VkPhysicalDevice device, int i)=0

virtual std::vector< const char * >	getRequiredDeviceExtensions ()=0

virtual SwapChainSupportDetails	querySwapChainSupport (vk::PhysicalDevice device)=0

bool	isSwapChainNeeded ()

bool	isIndepFromWindowDimension ()

virtual const bool	useOpenXR ()

virtual bool	isDepthRecquired ()

virtual bool	isSynchroWithSemaphore ()=0

virtual void	getFrameBufferSize (int w, int h, vk::PhysicalDevice &pDevice)=0

void	setWrapper (VulkanWrapper *wraps)

virtual void	checkForCorrectSize ()=0

virtual vk::Buffer	getRenderingDestination ()

virtual vk::Image	getSwapchainImage (int view, int index)

virtual vk::Image	getDepthSwapchainImage (int view, int index)

glm::vec3	getTranslation ()

void	setRotation (float v0, float v1, float v3)

glm::vec3	getRotation ()

virtual std::vector< vk::Image >	getBlitDestinations (int view, int elem)

virtual std::vector< vk::Extent2D >	getBlitExtentDestinations (int view, int elem)

virtual std::vector< vk::Semaphore >	getSemaphoreWait (int view, int elem)

virtual std::vector< vk::Semaphore >	getSemaphoreSignal (int view, int elem)

vk::ImageView	getSwapchainImageView (int view, int elem)

vk::ImageView	getDepthSwapchainImageView (int view, int elem)

int	getViewNumber ()

int	getAttachmentSize ()

virtual vk::Extent2D	getSwapchainExtent (int view)

virtual vk::Format	getSwapchainFormat (int view)

virtual vk::Format	getDepthSwapchainFormat (int view)

virtual void	resetOrigin ()=0

virtual	~WindowAbstract ()=default

Additional Inherited Members
Protected Attributes inherited from WindowAbstract
std::vector< std::unique_ptr< SwapchainAbstract > >	swapchains

std::vector< std::unique_ptr< SwapchainAbstract > >	depthSwapchains

bool	separateFromWindowDim = false

const std::vector< const char * >	deviceExtensions

VulkanWrapper *	wrapper = nullptr

glm::vec3	currentRotation = {0,0,0}

glm::vec3	currentTranslation = {0,0,0}

bool	needSwapchain = true

bool	initialised = false

const bool	enableValidationLayers = false

bool	qualibrationMode = false

int	selectedCamera = -1

Detailed Description

Class that take care of the tasks linked to OpenXR (input and display), is used when HMD support is requested.

This class have to take care of all the task linked to OpenXR (initialization, main loop, input handling, ... ). To properly use the light field in Creal headset, 2 extensions of OpenXR should be supported: XR_VARJO_QUAD_VIEWS and XR_KHR_COMPOSITION_LAYER_DEPTH The management of the swapchain is delegated to SwapchainOpenXR class. This class is also able to create a "mirror" window that will show the result of the rendering of the first view (usually left eye) Contains a lot of platform dependent code. Android related code is present as a legacy, please don't use it.

Definition at line 52 of file WindowOpenXR.h.

Member Function Documentation

◆ checkForCorrectSize()

void WindowOpenXR::checkForCorrectSize ( )

virtual

Make no sense in this context

Implements WindowAbstract.

Definition at line 426 of file WindowOpenXR.cpp.

427 {

428 }

◆ cleanUp()

void WindowOpenXR::cleanUp ( )

overridevirtual

Clean up allocated ressources

Implements WindowAbstract.

Definition at line 171 of file WindowOpenXR.cpp.

{
    /*
    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 // 
}

◆ cleanUpSurface()

void WindowOpenXR::cleanUpSurface ( )

overridevirtual

Clean up mirror swapchain if needed

Implements WindowAbstract.

Definition at line 233 of file WindowOpenXR.cpp.

{
    if (mirrorActivated) {
        cleanUpMirrorSwapchain();
        VkInstance instance = static_cast<VkInstance>(wrapper->context.instance);
        vkDestroySurfaceKHR(instance, surface, nullptr);
    }
}

◆ continueInit()

void WindowOpenXR::continueInit ( )

overridevirtual

Continue initialisation after context

Implements WindowAbstract.

Definition at line 136 of file WindowOpenXR.cpp.

{
 
    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();
    }
 
}

◆ createSurface()

void WindowOpenXR::createSurface ( )

overridevirtual

Create surface for the mirror if needed

Implements WindowAbstract.

Definition at line 281 of file WindowOpenXR.cpp.

{
#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
}

◆ createVulkanDevice()

void WindowOpenXR::createVulkanDevice	(	VkPhysicalDevice &	physicalDevice,
		VkDeviceCreateInfo &	info,
		VkDevice *	device
	)

Let OpenXR create the Vulkan Device

Definition at line 721 of file WindowOpenXR.cpp.

                                                                                                                         {
        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");
        }
    }

◆ framebufferResizeCallback()

void WindowOpenXR::framebufferResizeCallback ( )

Callback to resize framebuffer

Definition at line 421 of file WindowOpenXR.cpp.

    {
        wrapper->framebufferResized = true;
    }

◆ getBlitDestinations()

std::vector< vk::Image > WindowOpenXR::getBlitDestinations	(	int	view,
		int	elem
	)

overridevirtual

Obtain destination for blit operation

Reimplemented from WindowAbstract.

Definition at line 430 of file WindowOpenXR.cpp.

    {
        auto res = std::vector<vk::Image>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize && mirrorShouldRender) {
            res.push_back(mirrorImages[elem]);
        }
        return res;
    }

◆ getBlitExtentDestinations()

std::vector< vk::Extent2D > WindowOpenXR::getBlitExtentDestinations	(	int	view,
		int	elem
	)

overridevirtual

Obtain extent destination for blit operation

Reimplemented from WindowAbstract.

Definition at line 439 of file WindowOpenXR.cpp.

    {
        auto res = std::vector<vk::Extent2D>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize && mirrorShouldRender) {
            res.push_back(vk::Extent2D{ width,height });
        }
        return res;
    }

◆ getFrameBufferSize()

void WindowOpenXR::getFrameBufferSize	(	int *	w,
		int *	h,
		vk::PhysicalDevice &	pDevice
	)

overridevirtual

return the framebuffer size

Implements WindowAbstract.

Definition at line 408 of file WindowOpenXR.cpp.

                                                                                    {
 
    }

◆ getRequiredDeviceExtensions()

std::vector< const char * > WindowOpenXR::getRequiredDeviceExtensions ( )

overridevirtual

Return required extensions for the Vulkan Device

Implements WindowAbstract.

Definition at line 366 of file WindowOpenXR.cpp.

    {
        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;
 
 
    }

◆ getRequiredExtensions()

std::vector< const char * > WindowOpenXR::getRequiredExtensions ( )

overridevirtual

Return required extensions for Vulkan Instance

Implements WindowAbstract.

Definition at line 292 of file WindowOpenXR.cpp.

{
    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;
    }

◆ getSemaphoreSignal()

std::vector< vk::Semaphore > WindowOpenXR::getSemaphoreSignal	(	int	view,
		int	elem
	)

overridevirtual

Return semaphore to signal end of rendering

Reimplemented from WindowAbstract.

Definition at line 457 of file WindowOpenXR.cpp.

    {
        auto res = std::vector<vk::Semaphore>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize) {
            res.push_back(mirrorFinnishedSemaphore[elem]);
        }
        return res;
    }

◆ getSemaphoreWait()

std::vector< vk::Semaphore > WindowOpenXR::getSemaphoreWait	(	int	view,
		int	elem
	)

overridevirtual

Return semaphore to wait for mirror image acquisition

Reimplemented from WindowAbstract.

Definition at line 448 of file WindowOpenXR.cpp.

    {
        auto res = std::vector<vk::Semaphore>();
        if (mirrorActivated && view == 0 && elem < mirrorSwapchainSize) {
            res.push_back(mirrorAvailableSemaphore[elem]);
        }
        return res;
    }

◆ getSwapchainImage()

vk::Image WindowOpenXR::getSwapchainImage	(	int	view,
		int	index
	)

overridevirtual

Return the image of the swapchain image at a certain index

Reimplemented from WindowAbstract.

Definition at line 1409 of file WindowOpenXR.cpp.

                                                           {
    assert(view < swapchains.size());
    return swapchains[view]->getSwapchainImage(index);//swapChainImagesXr[view][index].image;
}

◆ getVulkanPhysicalDevice()

void WindowOpenXR::getVulkanPhysicalDevice	(	VkInstance &	vkInstance,
		VkPhysicalDevice *	physicalDevice
	)

Let OpenXR choose the device

Definition at line 705 of file WindowOpenXR.cpp.

                                                                                                         {
        XrVulkanGraphicsDeviceGetInfoKHR deviceGetInfo{ XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR };
        deviceGetInfo.systemId = systemId;
        deviceGetInfo.vulkanInstance = vkInstance;
        CHECK_XRCMD(GetVulkanGraphicsDevice2KHR(xrInstance, &deviceGetInfo, physicalDevice));
    }

◆ initWindow()

void WindowOpenXR::initWindow ( )

overridevirtual

Start the initialization of OpenXR

Implements WindowAbstract.

Definition at line 110 of file WindowOpenXR.cpp.

{
    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();
}

◆ isDepthRecquired()

bool WindowOpenXR::isDepthRecquired ( )

overridevirtual

return true if depth is needed by the window

Reimplemented from WindowAbstract.

Definition at line 917 of file WindowOpenXR.cpp.

{
    if (depthExtensionAvailable) {
        return true;
    }
    else {
        return false;
    }
}

◆ isDeviceSupportingSufaceKHR()

VkBool32 WindowOpenXR::isDeviceSupportingSufaceKHR	(	VkPhysicalDevice	device,
		int	i
	)

overridevirtual

Return true if the device support the surface

Implements WindowAbstract.

Definition at line 353 of file WindowOpenXR.cpp.

    {
        if (!mirrorActivated) {
            return false;
        }
        else {
            VkBool32 presentSupport = false;
            vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
            return presentSupport;
        }
 
    }

◆ isSessionRunning()

bool WindowOpenXR::isSessionRunning ( )

Return true if the session is still running

Definition at line 1349 of file WindowOpenXR.cpp.

                                    {
    return runningSession;
}

◆ isSynchroWithSemaphore()

bool WindowOpenXR::isSynchroWithSemaphore ( )

overridevirtual

return true if semaphore are used for synchronization

Implements WindowAbstract.

Definition at line 412 of file WindowOpenXR.cpp.

    {
        return false;
    }

◆ mainLoop()

void WindowOpenXR::mainLoop ( VulkanDrawing * vulkanDrawing )

overridevirtual

Main rendering loop

Implements WindowAbstract.

Definition at line 242 of file WindowOpenXR.cpp.

{
#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
}

◆ pollEvents()

void WindowOpenXR::pollEvents	(	bool *	exitRenderLoop,
		bool *	requestRestart
	)

Process OpenXR events

Definition at line 928 of file WindowOpenXR.cpp.

                                                                        {
    *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;
            }
        }
    }
}

◆ querySwapChainSupport()

SwapChainSupportDetails WindowOpenXR::querySwapChainSupport ( vk::PhysicalDevice device )

overridevirtual

Check for what format and present mode the swapchain support

Implements WindowAbstract.

Definition at line 399 of file WindowOpenXR.cpp.

    {
 
        SwapChainSupportDetails details;
        throw std::runtime_error("not autorised with open xr implementation");
        return details;
    }

◆ resetOrigin()

void WindowOpenXR::resetOrigin ( )

overridevirtual

Reset the origin, Which means that we will store some offset values to cancel the rotation and translation return by the OpenXR runtime.

Implements WindowAbstract.

Definition at line 1491 of file WindowOpenXR.cpp.

{
    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
 
}

◆ setMirror()

void WindowOpenXR::setMirror ( bool mirrorActivated )

activate the glfw mirror

Definition at line 909 of file WindowOpenXR.cpp.

{
#ifdef __ANDROID__
    throw std::runtime_error("Not supported when the headset is in standalone mode");
#endif // 
    this->mirrorActivated = mirrorActivated;
}

◆ setRotation()

void WindowOpenXR::setRotation	(	glm::quat &	q,
		int	view
	)

Use the quaternion to set the current rotation (euler angles)

Definition at line 1353 of file WindowOpenXR.cpp.

                                                     {
 
    //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];
 
    
}

◆ useOpenXR()

const bool WindowOpenXR::useOpenXR ( )

overridevirtual

Return true (because OpenXr is used)

Reimplemented from WindowAbstract.

Definition at line 166 of file WindowOpenXR.cpp.

                                   {
    return true;
}

The documentation for this class was generated from the following files:

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ checkForCorrectSize()

◆ cleanUp()

◆ cleanUpSurface()

◆ continueInit()

◆ createSurface()

◆ createVulkanDevice()

◆ framebufferResizeCallback()

◆ getBlitDestinations()

◆ getBlitExtentDestinations()

◆ getFrameBufferSize()

◆ getRequiredDeviceExtensions()

◆ getRequiredExtensions()

◆ getSemaphoreSignal()

◆ getSemaphoreWait()

◆ getSwapchainImage()

◆ getVulkanPhysicalDevice()

◆ initWindow()

◆ isDepthRecquired()

◆ isDeviceSupportingSufaceKHR()

◆ isSessionRunning()

◆ isSynchroWithSemaphore()

◆ mainLoop()

◆ pollEvents()

◆ querySwapChainSupport()

◆ resetOrigin()

◆ setMirror()

◆ setRotation()

◆ useOpenXR()