qt/qtquick3d/src/xr/quick3dxr/openxr/qquick3dxrmanager_openxr.cpp (file symbol)

Revision control

Copy as Markdown

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qquick3dxrmanager_openxr_p.h"
#include "qquick3dxrcamera_p.h"
#include "qquick3dxrorigin_p.h"
#include "qquick3dxranimationdriver_p.h"
#include "qquick3dxrmanager_p.h"
#include "qquick3dxrinputmanager_p.h"
#include "qopenxrhelpers_p.h"
#include "qopenxrinputmanager_p.h"
#include "qquick3dxranchormanager_openxr_p.h"
#include "qtquick3dxrglobal_p.h"
#include <QtQuick3DUtils/private/qssgassert_p.h>
#include <QtQuick3D/private/qquick3dviewport_p.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuick/qquickrendercontrol.h>
#include <QtGui/qquaternion.h>
#include <QtCore/qobject.h>
#include <openxr/openxr_reflection.h>
#ifdef XR_USE_GRAPHICS_API_VULKAN
# include "qopenxrgraphics_vulkan_p.h"
#endif
#ifdef XR_USE_GRAPHICS_API_D3D11
# include "qopenxrgraphics_d3d11_p.h"
#endif
#ifdef XR_USE_GRAPHICS_API_D3D12
# include "qopenxrgraphics_d3d12_p.h"
#endif
#ifdef XR_USE_GRAPHICS_API_OPENGL
# include "qopenxrgraphics_opengl_p.h"
#endif
#ifdef XR_USE_PLATFORM_ANDROID
# include <QtCore/qnativeinterface.h>
# include <QtCore/QJniEnvironment>
# include <QtCore/QJniObject>
# ifdef XR_USE_GRAPHICS_API_OPENGL_ES
# include "qopenxrgraphics_opengles_p.h"
# endif // XR_USE_GRAPHICS_API_OPENGL_ES
#endif // XR_USE_PLATFORM_ANDROID
#ifdef XR_USE_GRAPHICS_API_METAL
# include "qopenxrgraphics_metal_p.h"
#endif // XR_USE_GRAPHICS_API_METAL
static XrReferenceSpaceType getXrReferenceSpaceType(QtQuick3DXr::ReferenceSpace referenceSpace)
{
switch (referenceSpace) {
case QtQuick3DXr::ReferenceSpace::ReferenceSpaceLocal:
return XR_REFERENCE_SPACE_TYPE_LOCAL;
case QtQuick3DXr::ReferenceSpace::ReferenceSpaceStage:
return XR_REFERENCE_SPACE_TYPE_STAGE;
case QtQuick3DXr::ReferenceSpace::ReferenceSpaceLocalFloor:
return XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT;
default:
return XR_REFERENCE_SPACE_TYPE_LOCAL;
}
}
static QtQuick3DXr::ReferenceSpace getReferenceSpaceType(XrReferenceSpaceType referenceSpace)
{
switch (referenceSpace) {
case XR_REFERENCE_SPACE_TYPE_LOCAL:
return QtQuick3DXr::ReferenceSpace::ReferenceSpaceLocal;
case XR_REFERENCE_SPACE_TYPE_STAGE:
return QtQuick3DXr::ReferenceSpace::ReferenceSpaceStage;
case XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT:
return QtQuick3DXr::ReferenceSpace::ReferenceSpaceLocalFloor;
default:
return QtQuick3DXr::ReferenceSpace::ReferenceSpaceUnknown;
}
}
// Macro to generate stringify functions for OpenXR enumerations based data provided in openxr_reflection.h
#define ENUM_CASE_STR(name, val) case name: return #name;
#define MAKE_TO_STRING_FUNC(enumType) \
static inline const char* to_string(enumType e) { \
switch (e) { \
XR_LIST_ENUM_##enumType(ENUM_CASE_STR) \
default: return "Unknown " #enumType; \
} \
}
MAKE_TO_STRING_FUNC(XrReferenceSpaceType)
MAKE_TO_STRING_FUNC(XrViewConfigurationType)
MAKE_TO_STRING_FUNC(XrEnvironmentBlendMode)
MAKE_TO_STRING_FUNC(XrSessionState)
MAKE_TO_STRING_FUNC(XrResult)
static bool isExtensionSupported(const char *extensionName, const QVector<XrExtensionProperties> &instanceExtensionProperties, uint32_t *extensionVersion = nullptr)
{
for (const auto &extensionProperty : instanceExtensionProperties) {
if (!strcmp(extensionName, extensionProperty.extensionName)) {
if (extensionVersion)
*extensionVersion = extensionProperty.extensionVersion;
return true;
}
}
return false;
}
static bool isApiLayerSupported(const char *layerName, const QVector<XrApiLayerProperties> &apiLayerProperties)
{
for (const auto &prop : apiLayerProperties) {
if (!strcmp(layerName, prop.layerName))
return true;
}
return false;
}
// OpenXR's debug messenger stuff is a carbon copy of the Vulkan one, hence we
// replicate the same behavior on Qt side as well, i.e. route by default
// everything to qDebug. Filtering or further control (that is supported with
// the C++ APIS in the QVulkan* stuff) is not provided here for now.
#ifdef XR_EXT_debug_utils
static XRAPI_ATTR XrBool32 XRAPI_CALL defaultDebugCallbackFunc(XrDebugUtilsMessageSeverityFlagsEXT messageSeverity,
XrDebugUtilsMessageTypeFlagsEXT messageType,
const XrDebugUtilsMessengerCallbackDataEXT *callbackData,
void *userData)
{
Q_UNUSED(messageSeverity);
Q_UNUSED(messageType);
QQuick3DXrManager *self = static_cast<QQuick3DXrManager *>(userData);
// this is qDebug intentionally, not categorized
qDebug("xrDebug [QOpenXRManager %p] %s", self, callbackData->message);
return XR_FALSE;
}
#endif // XR_EXT_debug_utils
static std::pair<XrResult, XrFrameState> waitForNextFrame(XrSession session)
{
XrFrameWaitInfo frameWaitInfo {};
frameWaitInfo.type = XR_TYPE_FRAME_WAIT_INFO;
XrFrameState frameState {};
frameState.type = XR_TYPE_FRAME_STATE;
auto result = xrWaitFrame(session, &frameWaitInfo, &frameState);
return { result, frameState };
}
QT_BEGIN_NAMESPACE
Q_DECLARE_LOGGING_CATEGORY(lcQuick3DXr);
static const char s_workerThreadName[] = "QQuick3DXrWorkerThread";
class QQuick3DOpenXRThreadWorker : public QObject
{
Q_OBJECT
public:
explicit QQuick3DOpenXRThreadWorker(XrSession session, QObject *parent = nullptr)
: QObject(parent), m_session(session)
{
}
using EventT = std::underlying_type_t<QEvent::Type>;
enum Event : EventT {
WaitForFrame = QEvent::User + 1,
};
static constexpr QEvent::Type asQEvent(QQuick3DOpenXRThreadWorker::Event event)
{
return static_cast<QEvent::Type>(event);
}
void startWaitingForFrame()
{
QCoreApplication::postEvent(this, new QEvent(QQuick3DOpenXRThreadWorker::asQEvent(QQuick3DOpenXRThreadWorker::Event::WaitForFrame)));
}
protected:
bool event(QEvent *event) override
{
switch (static_cast<Event>(event->type())) {
case Event::WaitForFrame: {
auto result = waitForNextFrame(m_session);
emit frameWaited(result.first, result.second);
return true;
}
default:
return QObject::event(event);
}
}
signals:
void frameWaited(XrResult result, const XrFrameState &frameState);
private:
XrSession m_session = XR_NULL_HANDLE;
};
void QQuick3DXrManagerPrivate::setErrorString(XrResult result, const char *callName)
{
if (m_runtimeName.isEmpty())
m_errorString = QObject::tr("%1 failed: no OpenXR runtime found").arg(QLatin1StringView(callName));
else
m_errorString = QObject::tr("%1 for runtime %2 %3 failed with %4.")
.arg(QLatin1StringView(callName),
m_runtimeName,
m_runtimeVersion.toString(),
OpenXRHelpers::getXrResultAsString(result, m_instance));
if (result == XR_ERROR_FORM_FACTOR_UNAVAILABLE) // this is very common
m_errorString += QObject::tr("\nThe OpenXR runtime has no connection to the headset; check if connection is active and functional.");
}
QQuick3DXrManagerPrivate::QQuick3DXrManagerPrivate(QQuick3DXrManager &manager)
: q_ptr(&manager)
{
m_multiviewRendering = !QQuick3DXrManager::isMultiviewRenderingDisabled();
}
QQuick3DXrManagerPrivate::~QQuick3DXrManagerPrivate()
{
delete m_graphics; // last, with Vulkan this may own the VkInstance
}
QQuick3DXrManagerPrivate *QQuick3DXrManagerPrivate::get(QQuick3DXrManager *manager)
{
QSSG_ASSERT(manager != nullptr, return nullptr);
return manager->d_func();
}
void QQuick3DXrManagerPrivate::updateCameraHelper(QQuick3DXrEyeCamera *camera, const XrCompositionLayerProjectionView &layerView)
{
camera->setLeftTangent(qTan(layerView.fov.angleLeft));
camera->setRightTangent(qTan(layerView.fov.angleRight));
camera->setUpTangent(qTan(layerView.fov.angleUp));
camera->setDownTangent(qTan(layerView.fov.angleDown));
camera->setPosition(QVector3D(layerView.pose.position.x,
layerView.pose.position.y,
layerView.pose.position.z) * 100.0f); // convert m to cm
camera->setRotation(QQuaternion(layerView.pose.orientation.w,
layerView.pose.orientation.x,
layerView.pose.orientation.y,
layerView.pose.orientation.z));
}
// Set the active camera for the view to the camera for the eye value
// This is set right before updateing/rendering for that eye's view
void QQuick3DXrManagerPrivate::updateCameraNonMultiview(int eye, const XrCompositionLayerProjectionView &layerView)
{
Q_Q(QQuick3DXrManager);
QQuick3DXrOrigin *xrOrigin = q->m_xrOrigin;
QQuick3DXrEyeCamera *eyeCamera = xrOrigin ? xrOrigin->eyeCamera(eye) : nullptr;
if (eyeCamera)
updateCameraHelper(eyeCamera, layerView);
q->m_vrViewport->setCamera(eyeCamera);
}
// The multiview version sets multiple cameras.
void QQuick3DXrManagerPrivate::updateCameraMultiview(int projectionLayerViewStartIndex, int count)
{
Q_Q(QQuick3DXrManager);
QQuick3DXrOrigin *xrOrigin = q->m_xrOrigin;
QQuick3DViewport *vrViewport = q->m_vrViewport;
QVarLengthArray<QQuick3DCamera *, 4> cameras;
for (int i = projectionLayerViewStartIndex; i < projectionLayerViewStartIndex + count; ++i) {
QQuick3DXrEyeCamera *eyeCamera = xrOrigin ? xrOrigin->eyeCamera(i) : nullptr;
if (eyeCamera)
updateCameraHelper(eyeCamera, m_projectionLayerViews[i]);
cameras.append(eyeCamera);
}
vrViewport->setMultiViewCameras(cameras.data(), cameras.count());
}
bool QQuick3DXrManagerPrivate::supportsTransparentBlendMode() const
{
return m_blendModes.contains(XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND)
|| m_blendModes.contains(XR_ENVIRONMENT_BLEND_MODE_ADDITIVE);
}
bool QQuick3DXrManagerPrivate::supportsFBPassthrough() const
{
bool supported = false;
XrSystemPassthroughProperties2FB passthroughSystemProperties{};
passthroughSystemProperties.type = XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB;
XrSystemProperties systemProperties{};
systemProperties.type = XR_TYPE_SYSTEM_PROPERTIES;
systemProperties.next = &passthroughSystemProperties;
XrSystemGetInfo systemGetInfo{};
systemGetInfo.type = XR_TYPE_SYSTEM_GET_INFO;
systemGetInfo.formFactor = m_formFactor;
XrSystemId systemId = XR_NULL_SYSTEM_ID;
xrGetSystem(m_instance, &systemGetInfo, &systemId);
xrGetSystemProperties(m_instance, systemId, &systemProperties);
supported = (passthroughSystemProperties.capabilities & XR_PASSTHROUGH_CAPABILITY_BIT_FB) == XR_PASSTHROUGH_CAPABILITY_BIT_FB;
if (!supported) {
// Try the old one. (the Simulator reports spec version 3 for
// XR_FB_passthrough, yet the capabilities in
// XrSystemPassthroughProperties2FB are 0)
XrSystemPassthroughPropertiesFB oldPassthroughSystemProperties{};
oldPassthroughSystemProperties.type = XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB;
systemProperties.next = &oldPassthroughSystemProperties;
xrGetSystemProperties(m_instance, systemId, &systemProperties);
supported = oldPassthroughSystemProperties.supportsPassthrough;
}
return supported;
}
bool QQuick3DXrManagerPrivate::supportsPassthrough() const
{
// Passthrough is supported if either XR_FB_passthrough extension is available
// or if transparent blend modes (ALPHA_BLEND/ADDITIVE) are supported
return supportsFBPassthrough() || supportsTransparentBlendMode();
}
void QQuick3DXrManagerPrivate::setupWindow(QQuickWindow *window)
{
QSSG_ASSERT(window != nullptr, return);
if (m_graphics)
m_graphics->setupWindow(window);
}
bool QQuick3DXrManagerPrivate::isGraphicsInitialized() const
{
return m_graphics && m_graphics->rhi();
}
bool QQuick3DXrManagerPrivate::setupGraphics(QQuickWindow *window)
{
QSSG_ASSERT(window != nullptr, return false);
QSSG_ASSERT(m_graphics != nullptr, return false);
return m_graphics->setupGraphics(m_instance, m_systemId, window->graphicsConfiguration());
}
void QQuick3DXrManagerPrivate::update()
{
Q_Q(QQuick3DXrManager);
if (m_waitingForFrame) {
m_wantUpdate = true;
return;
}
QCoreApplication::postEvent(q, new QEvent(QEvent::UpdateRequest));
}
void QQuick3DXrManagerPrivate::processXrEvents()
{
Q_Q(QQuick3DXrManager);
bool exitRenderLoop = false;
bool requestrestart = false;
pollEvents(&exitRenderLoop, &requestrestart);
if (exitRenderLoop)
emit q->sessionEnded();
if (m_sessionRunning && m_inputManager) {
QQuick3DXrInputManagerPrivate::get(m_inputManager)->pollActions();
q->renderFrame();
}
}
void QQuick3DXrManagerPrivate::destroySwapchain()
{
for (const Swapchain &swapchain : std::as_const(m_swapchains))
xrDestroySwapchain(swapchain.handle);
m_swapchains.clear();
m_swapchainImages.clear();
m_configViews.clear();
for (const Swapchain &swapchain : std::as_const(m_depthSwapchains))
xrDestroySwapchain(swapchain.handle);
m_depthSwapchains.clear();
m_depthSwapchainImages.clear();
}
void QQuick3DXrManagerPrivate::doRenderFrame()
{
Q_ASSERT(m_session != XR_NULL_HANDLE);
if (m_waitingForFrame)
return;
m_waitingForFrame = true;
if (m_worker) {
m_worker->startWaitingForFrame();
// onFrameWaitCompleted() will be called asynchronoiusly
} else {
auto result = waitForNextFrame(m_session);
onFrameWaitCompleted(result.first, result.second);
}
}
void QQuick3DXrManagerPrivate::onFrameWaitCompleted(XrResult result, const XrFrameState &frameState)
{
if (!m_waitingForFrame)
return;
m_waitingForFrame = false;
if (!checkXrResult(result)) {
qWarning("xrWaitFrame failed");
} else {
doRenderFrameAferWait(frameState);
}
if (m_wantUpdate) {
m_wantUpdate = false;
update();
}
}
void QQuick3DXrManagerPrivate::doRenderFrameAferWait(const XrFrameState &frameState)
{
Q_ASSERT(m_session != XR_NULL_HANDLE);
XrFrameBeginInfo frameBeginInfo{};
frameBeginInfo.type = XR_TYPE_FRAME_BEGIN_INFO;
if (!checkXrResult(xrBeginFrame(m_session, &frameBeginInfo))) {
qWarning("xrBeginFrame failed");
return;
}
QVector<XrCompositionLayerBaseHeader*> layers;
XrCompositionLayerPassthroughFB passthroughCompLayer{};
passthroughCompLayer.type = XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB;
if (m_fbPassthroughEnabled) {
if (m_passthroughLayer == XR_NULL_HANDLE)
createMetaQuestPassthroughLayer();
passthroughCompLayer.layerHandle = m_passthroughLayer;
passthroughCompLayer.flags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT;
passthroughCompLayer.space = XR_NULL_HANDLE;
layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&passthroughCompLayer));
}
XrCompositionLayerProjection layer{};
layer.type = XR_TYPE_COMPOSITION_LAYER_PROJECTION;
layer.layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT;
layer.layerFlags |= XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT;
layer.layerFlags |= XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT;
if (frameState.shouldRender == XR_TRUE) {
if (renderLayer(frameState.predictedDisplayTime, frameState.predictedDisplayPeriod, layer)) {
layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&layer));
}
}
XrFrameEndInfo frameEndInfo{};
frameEndInfo.type = XR_TYPE_FRAME_END_INFO;
frameEndInfo.displayTime = frameState.predictedDisplayTime;
if (!m_fbPassthroughEnabled)
frameEndInfo.environmentBlendMode = m_environmentBlendMode;
else
frameEndInfo.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
frameEndInfo.layerCount = (uint32_t)layers.size();
frameEndInfo.layers = layers.data();
if (!checkXrResult(xrEndFrame(m_session, &frameEndInfo)))
qWarning("xrEndFrame failed");
}
bool QQuick3DXrManagerPrivate::finalizeGraphics(QRhi *rhi)
{
QSSG_ASSERT(rhi != nullptr && m_graphics != nullptr, return false);
if (m_multiviewRendering && !rhi->isFeatureSupported(QRhi::MultiView)) {
qCDebug(lcQuick3DXr) << "Multiview rendering is not supported with the current graphics API";
m_multiviewRendering = false;
}
#if QT_CONFIG(graphicsframecapture)
if (m_frameCapture) {
m_frameCapture->setCapturePath(QLatin1String("."));
m_frameCapture->setCapturePrefix(QLatin1String("quick3dxr"));
m_frameCapture->setRhi(rhi);
if (!m_frameCapture->isLoaded()) {
qWarning("Quick 3D XR: Frame capture was requested but QGraphicsFrameCapture is not initialized"
" (or has no backends enabled in the Qt build)");
} else {
qCDebug(lcQuick3DXr, "Quick 3D XR: Frame capture initialized");
}
}
#endif
m_isGraphicsInitialized = m_graphics->finializeGraphics(rhi);
return m_isGraphicsInitialized;
}
bool QQuick3DXrManagerPrivate::initialize()
{
Q_Q(QQuick3DXrManager);
// This, meaning constructing the QGraphicsFrameCapture if we'll want it,
// must be done as early as possible, before initalizing graphics. In fact
// in hybrid apps it might be too late at this point if Qt Quick (so someone
// outside our control) has initialized graphics which then makes
// RenderDoc's hooking mechanisms disfunctional.
if (qEnvironmentVariableIntValue("QT_QUICK3D_XR_FRAME_CAPTURE")) {
#if QT_CONFIG(graphicsframecapture)
m_frameCapture.reset(new QGraphicsFrameCapture);
#else
qWarning("Quick 3D XR: Frame capture was requested, but Qt is built without QGraphicsFrameCapture");
#endif
}
#ifdef XR_USE_PLATFORM_ANDROID
// Initialize the Loader
PFN_xrInitializeLoaderKHR xrInitializeLoaderKHR;
xrGetInstanceProcAddr(
XR_NULL_HANDLE, "xrInitializeLoaderKHR", (PFN_xrVoidFunction*)&xrInitializeLoaderKHR);
if (xrInitializeLoaderKHR != NULL) {
m_javaVM = QJniEnvironment::javaVM();
m_androidActivity = QNativeInterface::QAndroidApplication::context();
XrLoaderInitInfoAndroidKHR loaderInitializeInfoAndroid;
memset(&loaderInitializeInfoAndroid, 0, sizeof(loaderInitializeInfoAndroid));
loaderInitializeInfoAndroid.type = XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR;
loaderInitializeInfoAndroid.next = NULL;
loaderInitializeInfoAndroid.applicationVM = m_javaVM;
loaderInitializeInfoAndroid.applicationContext = m_androidActivity.object();
XrResult xrResult = xrInitializeLoaderKHR((XrLoaderInitInfoBaseHeaderKHR*)&loaderInitializeInfoAndroid);
if (xrResult != XR_SUCCESS) {
qWarning("Failed to initialize OpenXR Loader: %s", to_string(xrResult));
return false;
}
}
#endif
// Init the Graphics Backend
auto graphicsAPI = QQuickWindow::graphicsApi();
m_graphics = nullptr;
#ifdef XR_USE_GRAPHICS_API_VULKAN
if (graphicsAPI == QSGRendererInterface::Vulkan)
m_graphics = new QOpenXRGraphicsVulkan;
#endif
#ifdef XR_USE_GRAPHICS_API_D3D11
if (graphicsAPI == QSGRendererInterface::Direct3D11)
m_graphics = new QOpenXRGraphicsD3D11;
#endif
#ifdef XR_USE_GRAPHICS_API_D3D12
if (graphicsAPI == QSGRendererInterface::Direct3D12)
m_graphics = new QOpenXRGraphicsD3D12;
#endif
#ifdef XR_USE_GRAPHICS_API_OPENGL
if (graphicsAPI == QSGRendererInterface::OpenGL)
m_graphics = new QOpenXRGraphicsOpenGL;
#endif
#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
if (graphicsAPI == QSGRendererInterface::OpenGL)
m_graphics = new QOpenXRGraphicsOpenGLES;
#endif
#ifdef XR_USE_GRAPHICS_API_METAL
if (graphicsAPI == QSGRendererInterface::Metal)
m_graphics = new QOpenXRGraphicsMetal;
#endif
if (!m_graphics) {
qWarning() << "The Qt Quick Scenegraph is not using a supported RHI mode:" << graphicsAPI;
return false;
}
// Print out extension and layer information
checkXrExtensions(nullptr);
checkXrLayers();
m_spaceExtension = QQuick3DXrAnchorManager::instance();
// Create Instance
XrResult result = createXrInstance();
if (result != XR_SUCCESS) {
setErrorString(result, "xrCreateInstance");
delete m_graphics;
m_graphics = nullptr;
return false;
} else {
checkXrInstance();
}
// Catch OpenXR runtime messages via XR_EXT_debug_utils and route them to qDebug
setupDebugMessenger();
// Load System
result = initializeSystem();
if (result != XR_SUCCESS) {
setErrorString(result, "xrGetSystem");
delete m_graphics;
m_graphics = nullptr;
return false;
}
// Setup Graphics
if (!q->setupGraphics()) {
m_errorString = QObject::tr("Failed to set up 3D API integration");
delete m_graphics;
m_graphics = nullptr;
return false;
}
// Create Session
XrSessionCreateInfo xrSessionInfo{};
xrSessionInfo.type = XR_TYPE_SESSION_CREATE_INFO;
xrSessionInfo.systemId = m_systemId;
auto overlayLayerPlacement = qEnvironmentVariableIntValue("QT_QUICK3D_XR_OVERLAY_PLACEMENT");
if (m_overlayExtensionSupported && overlayLayerPlacement > 0) {
XrSessionCreateInfoOverlayEXTX overlayInfo {};
overlayInfo.type = XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX;
overlayInfo.sessionLayersPlacement = overlayLayerPlacement;
overlayInfo.next = m_graphics->handle();
xrSessionInfo.next = &overlayInfo;
qCDebug(lcQuick3DXr, "requesting overlay placement: %d", overlayLayerPlacement);
} else {
xrSessionInfo.next = m_graphics->handle();
}
result = xrCreateSession(m_instance, &xrSessionInfo, &m_session);
if (result != XR_SUCCESS) {
setErrorString(result, "xrCreateSession");
delete m_graphics;
m_graphics = nullptr;
return false;
}
const bool disableAsyncWait = qEnvironmentVariableIntValue("QT_QUICK3D_XR_DISABLE_ASYNC_WAIT") != 0;
if (Q_LIKELY(!disableAsyncWait))
initWorkerThread();
// Meta Quest Specific Setup
if (m_colorspaceExtensionSupported)
setupMetaQuestColorSpaces();
if (m_displayRefreshRateExtensionSupported)
setupMetaQuestRefreshRates();
if (m_spaceExtensionSupported)
m_spaceExtension->initialize(m_instance, m_session);
checkReferenceSpaces();
// Setup Input
m_inputManager = QQuick3DXrInputManager::instance();
if (QSSG_GUARD(m_inputManager != nullptr))
QQuick3DXrInputManagerPrivate::get(m_inputManager)->init(m_instance, m_session);
if (!setupAppSpace())
return false;
if (!setupViewSpace())
return false;
if (!createSwapchains())
return false;
return true;
}
void QQuick3DXrManagerPrivate::teardown()
{
m_waitingForFrame = false;
m_wantUpdate = false;
destroyWorkerThread();
if (m_inputManager) {
QQuick3DXrInputManagerPrivate::get(m_inputManager)->teardown();
m_inputManager = nullptr;
}
if (m_spaceExtension) {
m_spaceExtension->teardown();
m_spaceExtension = nullptr;
}
if (m_passthroughLayer)
destroyMetaQuestPassthroughLayer();
if (m_passthroughFeature)
destroyMetaQuestPassthrough();
destroySwapchain();
if (m_appSpace != XR_NULL_HANDLE) {
xrDestroySpace(m_appSpace);
}
if (m_viewSpace != XR_NULL_HANDLE)
xrDestroySpace(m_viewSpace);
xrDestroySession(m_session);
#ifdef XR_EXT_debug_utils
if (m_debugMessenger) {
m_xrDestroyDebugUtilsMessengerEXT(m_debugMessenger);
m_debugMessenger = XR_NULL_HANDLE;
}
#endif // XR_EXT_debug_utils
xrDestroyInstance(m_instance);
// early deinit for graphics, so it can destroy owned QRhi resources
// Note: Used to be part of the XRmanager dtor.
if (m_graphics)
m_graphics->releaseResources();
}
void QQuick3DXrManagerPrivate::initWorkerThread()
{
Q_Q(QQuick3DXrManager);
qCDebug(lcQuick3DXr, "Initializing OpenXR worker thread");
m_workerThread = new QThread();
m_workerThread->setObjectName(QLatin1StringView(s_workerThreadName));
m_worker = new QQuick3DOpenXRThreadWorker(m_session);
m_worker->moveToThread(m_workerThread);
QObject::connect(
m_worker,
&QQuick3DOpenXRThreadWorker::frameWaited,
q,
[this](XrResult result, const XrFrameState &frameState) { onFrameWaitCompleted(result, frameState); },
Qt::QueuedConnection);
QObject::connect(m_workerThread, &QThread::finished, m_worker, &QObject::deleteLater);
m_workerThread->start();
}
void QQuick3DXrManagerPrivate::destroyWorkerThread()
{
if (m_workerThread) {
m_workerThread->quit();
m_workerThread->wait();
delete m_workerThread;
m_workerThread = nullptr;
m_worker = nullptr;
qCDebug(lcQuick3DXr, "OpenXR worker thread destroyed");
}
}
void QQuick3DXrManagerPrivate::checkReferenceSpaces()
{
Q_ASSERT(m_session != XR_NULL_HANDLE);
uint32_t spaceCount;
if (!checkXrResult(xrEnumerateReferenceSpaces(m_session, 0, &spaceCount, nullptr))) {
qWarning("Failed to enumerate reference spaces");
return;
}
m_availableReferenceSpace.resize(spaceCount);
if (!checkXrResult(xrEnumerateReferenceSpaces(m_session, spaceCount, &spaceCount, m_availableReferenceSpace.data()))) {
qWarning("Failed to enumerate reference spaces");
return;
}
qCDebug(lcQuick3DXr, "Available reference spaces: %d", spaceCount);
for (XrReferenceSpaceType space : std::as_const(m_availableReferenceSpace)) {
qCDebug(lcQuick3DXr, " Name: %s", to_string(space));
}
}
bool QQuick3DXrManagerPrivate::isReferenceSpaceAvailable(XrReferenceSpaceType type)
{
return m_availableReferenceSpace.contains(type);
}
bool QQuick3DXrManagerPrivate::setupAppSpace()
{
Q_Q(QQuick3DXrManager);
Q_ASSERT(m_session != XR_NULL_HANDLE);
XrPosef identityPose;
identityPose.orientation.w = 1;
identityPose.orientation.x = 0;
identityPose.orientation.y = 0;
identityPose.orientation.z = 0;
identityPose.position.x = 0;
identityPose.position.y = 0;
identityPose.position.z = 0;
XrReferenceSpaceType newReferenceSpace;
XrSpace newAppSpace = XR_NULL_HANDLE;
m_isEmulatingLocalFloor = false;
if (isReferenceSpaceAvailable(m_requestedReferenceSpace)) {
newReferenceSpace = m_requestedReferenceSpace;
} else if (m_requestedReferenceSpace == XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT &&
isReferenceSpaceAvailable(XR_REFERENCE_SPACE_TYPE_STAGE)) {
m_isEmulatingLocalFloor = true;
m_isFloorResetPending = true;
newReferenceSpace = XR_REFERENCE_SPACE_TYPE_LOCAL;
} else {
qWarning("Requested reference space is not available");
newReferenceSpace = XR_REFERENCE_SPACE_TYPE_LOCAL;
}
// App Space
qCDebug(lcQuick3DXr, "Creating new reference space for app space: %s", to_string(newReferenceSpace));
XrReferenceSpaceCreateInfo referenceSpaceCreateInfo{};
referenceSpaceCreateInfo.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
referenceSpaceCreateInfo.poseInReferenceSpace = identityPose;
referenceSpaceCreateInfo.referenceSpaceType = newReferenceSpace;
if (!checkXrResult(xrCreateReferenceSpace(m_session, &referenceSpaceCreateInfo, &newAppSpace))) {
qWarning("Failed to create app space");
return false;
}
if (m_appSpace)
xrDestroySpace(m_appSpace);
m_appSpace = newAppSpace;
m_referenceSpace = newReferenceSpace;
// only broadcast the reference space change if we are not emulating the local floor
// since we'll try and change the referenceSpace again once we have tracking
if (!m_isFloorResetPending)
emit q->referenceSpaceChanged();
return true;
}
void QQuick3DXrManagerPrivate::updateAppSpace(XrTime predictedDisplayTime)
{
Q_Q(QQuick3DXrManager);
// If the requested reference space is not the current one, we need to
// re-create the app space now
if (m_requestedReferenceSpace != m_referenceSpace && !m_isFloorResetPending) {
if (!setupAppSpace()) {
// If we can't set the requested reference space, use the current one
qWarning("Setting requested reference space failed");
m_requestedReferenceSpace = m_referenceSpace;
return;
}
}
// This happens when we setup the emulated LOCAL_FLOOR mode
// We may have requested it on app setup, but we need to have
// some tracking information to calculate the floor height so
// that will only happen once we get here.
if (m_isFloorResetPending) {
if (!resetEmulatedFloorHeight(predictedDisplayTime)) {
// It didn't work, so give up and use local space (which is already setup).
m_requestedReferenceSpace = XR_REFERENCE_SPACE_TYPE_LOCAL;
emit q->referenceSpaceChanged();
}
return;
}
}
bool QQuick3DXrManagerPrivate::setupViewSpace()
{
Q_ASSERT(m_session != XR_NULL_HANDLE);
XrPosef identityPose;
identityPose.orientation.w = 1;
identityPose.orientation.x = 0;
identityPose.orientation.y = 0;
identityPose.orientation.z = 0;
identityPose.position.x = 0;
identityPose.position.y = 0;
identityPose.position.z = 0;
XrSpace newViewSpace = XR_NULL_HANDLE;
XrReferenceSpaceCreateInfo referenceSpaceCreateInfo{};
referenceSpaceCreateInfo.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
referenceSpaceCreateInfo.poseInReferenceSpace = identityPose;
referenceSpaceCreateInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_VIEW;
if (!checkXrResult(xrCreateReferenceSpace(m_session, &referenceSpaceCreateInfo, &newViewSpace))) {
qWarning("Failed to create view space");
return false;
}
if (m_viewSpace != XR_NULL_HANDLE)
xrDestroySpace(m_viewSpace);
m_viewSpace = newViewSpace;
return true;
}
bool QQuick3DXrManagerPrivate::resetEmulatedFloorHeight(XrTime predictedDisplayTime)
{
Q_Q(QQuick3DXrManager);
Q_ASSERT(m_isEmulatingLocalFloor);
m_isFloorResetPending = false;
XrPosef identityPose;
identityPose.orientation.w = 1;
identityPose.orientation.x = 0;
identityPose.orientation.y = 0;
identityPose.orientation.z = 0;
identityPose.position.x = 0;
identityPose.position.y = 0;
identityPose.position.z = 0;
XrSpace localSpace = XR_NULL_HANDLE;
XrSpace stageSpace = XR_NULL_HANDLE;
XrReferenceSpaceCreateInfo createInfo{};
createInfo.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
createInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
createInfo.poseInReferenceSpace = identityPose;
if (!checkXrResult(xrCreateReferenceSpace(m_session, &createInfo, &localSpace))) {
qWarning("Failed to create local space (for emulated LOCAL_FLOOR space)");
return false;
}
createInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE;
if (!checkXrResult(xrCreateReferenceSpace(m_session, &createInfo, &stageSpace))) {
qWarning("Failed to create stage space (for emulated LOCAL_FLOOR space)");
xrDestroySpace(localSpace);
return false;
}
XrSpaceLocation stageLocation{};
stageLocation.type = XR_TYPE_SPACE_LOCATION;
stageLocation.pose = identityPose;
if (!checkXrResult(xrLocateSpace(stageSpace, localSpace, predictedDisplayTime, &stageLocation))) {
qWarning("Failed to locate STAGE space in LOCAL space, in order to emulate LOCAL_FLOOR");
xrDestroySpace(localSpace);
xrDestroySpace(stageSpace);
return false;
}
xrDestroySpace(localSpace);
xrDestroySpace(stageSpace);
XrSpace newAppSpace = XR_NULL_HANDLE;
createInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
createInfo.poseInReferenceSpace.position.y = stageLocation.pose.position.y;
if (!checkXrResult(xrCreateReferenceSpace(m_session, &createInfo, &newAppSpace))) {
qWarning("Failed to recreate emulated LOCAL_FLOOR play space with latest floor estimate");
return false;
}
xrDestroySpace(m_appSpace);
m_appSpace = newAppSpace;
m_referenceSpace = XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT;
emit q->referenceSpaceChanged();
return true;
}
bool QQuick3DXrManagerPrivate::createSwapchains()
{
Q_ASSERT(m_session != XR_NULL_HANDLE);
Q_ASSERT(m_configViews.isEmpty());
Q_ASSERT(m_swapchains.isEmpty());
XrSystemProperties systemProperties{};
systemProperties.type = XR_TYPE_SYSTEM_PROPERTIES;
XrSystemHandTrackingPropertiesEXT handTrackingSystemProperties{};
handTrackingSystemProperties.type = XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT;
systemProperties.next = &handTrackingSystemProperties;
if (!checkXrResult(xrGetSystemProperties(m_instance, m_systemId, &systemProperties))) {
qWarning("Failed to get OpenXR system properties");
return false;
}
qCDebug(lcQuick3DXr, "System Properties: Name=%s VendorId=%d", systemProperties.systemName, systemProperties.vendorId);
qCDebug(lcQuick3DXr, "System Graphics Properties: MaxWidth=%d MaxHeight=%d MaxLayers=%d",
systemProperties.graphicsProperties.maxSwapchainImageWidth,
systemProperties.graphicsProperties.maxSwapchainImageHeight,
systemProperties.graphicsProperties.maxLayerCount);
qCDebug(lcQuick3DXr, "System Tracking Properties: OrientationTracking=%s PositionTracking=%s",
systemProperties.trackingProperties.orientationTracking == XR_TRUE ? "True" : "False",
systemProperties.trackingProperties.positionTracking == XR_TRUE ? "True" : "False");
qCDebug(lcQuick3DXr, "System Hand Tracking Properties: handTracking=%s",
handTrackingSystemProperties.supportsHandTracking == XR_TRUE ? "True" : "False");
quint32 viewCount;
if (!checkXrResult(xrEnumerateViewConfigurationViews(m_instance,
m_systemId,
m_viewConfigType,
0,
&viewCount,
nullptr)))
{
qWarning("Failed to enumerate view configurations");
return false;
}
m_configViews.resize(viewCount, {XR_TYPE_VIEW_CONFIGURATION_VIEW, nullptr, 0, 0, 0, 0, 0, 0});
if (!checkXrResult(xrEnumerateViewConfigurationViews(m_instance,
m_systemId,
m_viewConfigType,
viewCount,
&viewCount,
m_configViews.data())))
{
qWarning("Failed to enumerate view configurations");
return false;
}
m_views.resize(viewCount, {XR_TYPE_VIEW, nullptr, {}, {}});
m_projectionLayerViews.resize(viewCount, {});
m_layerDepthInfos.resize(viewCount, {});
// Create the swapchain and get the images.
if (viewCount > 0) {
// Select a swapchain format.
uint32_t swapchainFormatCount;
if (!checkXrResult(xrEnumerateSwapchainFormats(m_session, 0, &swapchainFormatCount, nullptr))) {
qWarning("Failed to enumerate swapchain formats");
return false;
}
QVector<int64_t> swapchainFormats(swapchainFormatCount);
if (!checkXrResult(xrEnumerateSwapchainFormats(m_session,
swapchainFormats.size(),
&swapchainFormatCount,
swapchainFormats.data())))
{
qWarning("Failed to enumerate swapchain formats");
return false;
}
Q_ASSERT(static_cast<qsizetype>(swapchainFormatCount) == swapchainFormats.size());
m_colorSwapchainFormat = m_graphics->colorSwapchainFormat(swapchainFormats);
if (m_compositionLayerDepthSupported)
m_depthSwapchainFormat = m_graphics->depthSwapchainFormat(swapchainFormats);
// Print swapchain formats and the selected one.
{
QString swapchainFormatsString;
for (int64_t format : std::as_const(swapchainFormats)) {
const bool selectedColor = format == m_colorSwapchainFormat;
const bool selectedDepth = format == m_depthSwapchainFormat;
swapchainFormatsString += u" ";
if (selectedColor)
swapchainFormatsString += u"[";
else if (selectedDepth)
swapchainFormatsString += u"<";
swapchainFormatsString += QString::number(format);
if (selectedColor)
swapchainFormatsString += u"]";
else if (selectedDepth)
swapchainFormatsString += u">";
}
qCDebug(lcQuick3DXr, "Swapchain formats: %s", qPrintable(swapchainFormatsString));
}
const XrViewConfigurationView &vp = m_configViews[0]; // use the first view for all views, the sizes should be the same
// sampleCount for the XrSwapchain is always 1. We could take m_samples
// here, clamp it to vp.maxSwapchainSampleCount, and pass it in to the
// swapchain to get multisample textures (or a multisample texture
// array) out of the swapchain. This we do not do, because it was only
// supported with 1 out of 5 OpenXR(+streaming) combination tested on
// the Quest 3. In most cases, incl. Quest 3 native Android,
// maxSwapchainSampleCount is 1. Therefore, we do MSAA on our own, and
// do not rely on the XrSwapchain for this.
if (m_multiviewRendering) {
// Create a single swapchain with array size > 1
XrSwapchainCreateInfo swapchainCreateInfo{};
swapchainCreateInfo.type = XR_TYPE_SWAPCHAIN_CREATE_INFO;
swapchainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_SAMPLED_BIT | XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT;
swapchainCreateInfo.format = m_colorSwapchainFormat;
swapchainCreateInfo.sampleCount = 1; // we do MSAA on our own, do not need ms textures from the swapchain
swapchainCreateInfo.width = vp.recommendedImageRectWidth;
swapchainCreateInfo.height = vp.recommendedImageRectHeight;
swapchainCreateInfo.faceCount = 1;
swapchainCreateInfo.arraySize = viewCount;
swapchainCreateInfo.mipCount = 1;
qCDebug(lcQuick3DXr, "Creating multiview swapchain for %u view(s) with dimensions Width=%d Height=%d SampleCount=%d Format=%llx",
viewCount,
vp.recommendedImageRectWidth,
vp.recommendedImageRectHeight,
1,
static_cast<long long unsigned int>(m_colorSwapchainFormat));
Swapchain swapchain;
swapchain.width = swapchainCreateInfo.width;
swapchain.height = swapchainCreateInfo.height;
swapchain.arraySize = swapchainCreateInfo.arraySize;
if (checkXrResult(xrCreateSwapchain(m_session, &swapchainCreateInfo, &swapchain.handle))) {
uint32_t imageCount = 0;
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, 0, &imageCount, nullptr))) {
qWarning("Failed to enumerate swapchain images");
return false;
}
auto swapchainImages = m_graphics->allocateSwapchainImages(imageCount, swapchain.handle);
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, imageCount, &imageCount, swapchainImages[0]))) {
qWarning("Failed to enumerate swapchain images");
return false;
}
m_swapchains.append(swapchain);
m_swapchainImages.insert(swapchain.handle, swapchainImages);
} else {
qWarning("xrCreateSwapchain failed (multiview)");
return false;
}
// Create the depth swapchain always when
// XR_KHR_composition_layer_depth is supported. If we are going to
// submit (use the depth image), that's a different question, and is
// dynamically controlled by the user.
if (m_compositionLayerDepthSupported && m_depthSwapchainFormat > 0) {
swapchainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
swapchainCreateInfo.format = m_depthSwapchainFormat;
if (checkXrResult(xrCreateSwapchain(m_session, &swapchainCreateInfo, &swapchain.handle))) {
uint32_t imageCount = 0;
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, 0, &imageCount, nullptr))) {
qWarning("Failed to enumerate depth swapchain images");
return false;
}
auto swapchainImages = m_graphics->allocateSwapchainImages(imageCount, swapchain.handle);
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, imageCount, &imageCount, swapchainImages[0]))) {
qWarning("Failed to enumerate depth swapchain images");
return false;
}
m_depthSwapchains.append(swapchain);
m_depthSwapchainImages.insert(swapchain.handle, swapchainImages);
} else {
qWarning("xrCreateSwapchain failed for depth swapchain (multiview)");
return false;
}
}
} else {
// Create a swapchain for each view.
for (uint32_t i = 0; i < viewCount; i++) {
qCDebug(lcQuick3DXr, "Creating swapchain for view %u with dimensions Width=%d Height=%d SampleCount=%d Format=%llx",
i,
vp.recommendedImageRectWidth,
vp.recommendedImageRectHeight,
1,
static_cast<long long unsigned int>(m_colorSwapchainFormat));
// Create the swapchain.
XrSwapchainCreateInfo swapchainCreateInfo{};
swapchainCreateInfo.type = XR_TYPE_SWAPCHAIN_CREATE_INFO;
swapchainCreateInfo.arraySize = 1;
swapchainCreateInfo.format = m_colorSwapchainFormat;
swapchainCreateInfo.width = vp.recommendedImageRectWidth;
swapchainCreateInfo.height = vp.recommendedImageRectHeight;
swapchainCreateInfo.mipCount = 1;
swapchainCreateInfo.faceCount = 1;
swapchainCreateInfo.sampleCount = 1; // we do MSAA on our own, do not need ms textures from the swapchain
swapchainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_SAMPLED_BIT | XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT;
Swapchain swapchain {};
swapchain.width = swapchainCreateInfo.width;
swapchain.height = swapchainCreateInfo.height;
if (checkXrResult(xrCreateSwapchain(m_session, &swapchainCreateInfo, &swapchain.handle))) {
uint32_t imageCount = 0;
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, 0, &imageCount, nullptr))) {
qWarning("Failed to enumerate swapchain images");
return false;
}
auto swapchainImages = m_graphics->allocateSwapchainImages(imageCount, swapchain.handle);
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, imageCount, &imageCount, swapchainImages[0]))) {
qWarning("Failed to enumerate swapchain images");
return false;
}
m_swapchains.append(swapchain);
m_swapchainImages.insert(swapchain.handle, swapchainImages);
} else {
qWarning("xrCreateSwapchain failed (view %u)", viewCount);
return false;
}
if (m_compositionLayerDepthSupported && m_depthSwapchainFormat > 0) {
swapchainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
swapchainCreateInfo.format = m_depthSwapchainFormat;
if (checkXrResult(xrCreateSwapchain(m_session, &swapchainCreateInfo, &swapchain.handle))) {
uint32_t imageCount = 0;
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, 0, &imageCount, nullptr))) {
qWarning("Failed to enumerate depth swapchain images");
return false;
}
auto swapchainImages = m_graphics->allocateSwapchainImages(imageCount, swapchain.handle);
if (!checkXrResult(xrEnumerateSwapchainImages(swapchain.handle, imageCount, &imageCount, swapchainImages[0]))) {
qWarning("Failed to enumerate depth swapchain images");
return false;
}
m_depthSwapchains.append(swapchain);
m_depthSwapchainImages.insert(swapchain.handle, swapchainImages);
} else {
qWarning("xrCreateSwapchain failed for depth swapchain (view %u)", viewCount);
return false;
}
}
}
}
if (m_multiviewRendering) {
if (m_swapchains.isEmpty())
return false;
if (m_compositionLayerDepthSupported && m_depthSwapchains.isEmpty())
return false;
} else {
if (m_swapchains.count() != qsizetype(viewCount))
return false;
if (m_compositionLayerDepthSupported && m_depthSwapchains.count() != qsizetype(viewCount))
return false;
}
// Setup the projection layer views.
for (uint32_t i = 0; i < viewCount; ++i) {
m_projectionLayerViews[i].type = XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW;
m_projectionLayerViews[i].next = nullptr;
m_projectionLayerViews[i].subImage.swapchain = m_swapchains[0].handle; // for non-multiview this gets overwritten later
m_projectionLayerViews[i].subImage.imageArrayIndex = i; // this too
m_projectionLayerViews[i].subImage.imageRect.offset.x = 0;
m_projectionLayerViews[i].subImage.imageRect.offset.y = 0;
m_projectionLayerViews[i].subImage.imageRect.extent.width = vp.recommendedImageRectWidth;
m_projectionLayerViews[i].subImage.imageRect.extent.height = vp.recommendedImageRectHeight;
if (m_compositionLayerDepthSupported) {
m_layerDepthInfos[i].type = XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR;
m_layerDepthInfos[i].next = nullptr;
m_layerDepthInfos[i].subImage.swapchain = m_depthSwapchains[0].handle; // for non-multiview this gets overwritten later
m_layerDepthInfos[i].subImage.imageArrayIndex = i; // this too
m_layerDepthInfos[i].subImage.imageRect.offset.x = 0;
m_layerDepthInfos[i].subImage.imageRect.offset.y = 0;
m_layerDepthInfos[i].subImage.imageRect.extent.width = vp.recommendedImageRectWidth;
m_layerDepthInfos[i].subImage.imageRect.extent.height = vp.recommendedImageRectHeight;
}
}
}
if (m_foveationExtensionSupported)
setupMetaQuestFoveation();
return true;
}
void QQuick3DXrManagerPrivate::setSamples(int samples)
{
if (m_samples == samples)
return;
m_samples = samples;
// No need to do anything more here (such as destroying and recreating the
// XrSwapchain) since we do not do MSAA through the swapchain.
}
QStringList QQuick3DXrManagerPrivate::enabledExtensions() const
{
return m_enabledExtensions;
}
QString QQuick3DXrManagerPrivate::runtimeName() const
{
return m_runtimeName;
}
QVersionNumber QQuick3DXrManagerPrivate::runtimeVersion() const
{
return m_runtimeVersion;
}
void QQuick3DXrManagerPrivate::setMultiViewRenderingEnabled(bool enable)
{
Q_Q(QQuick3DXrManager);
QRhi *rhi = q->m_renderControl->rhi();
if (m_multiviewRendering == enable || !rhi)
return;
if (enable && !rhi->isFeatureSupported(QRhi::MultiView)) {
qWarning("Quick 3D XR: Multiview rendering was enabled, but is reported as unsupported from the current QRhi backend (%s)",
rhi->backendName());
return;
}
m_multiviewRendering = enable;
qCDebug(lcQuick3DXr, "Multiview rendering %s", m_multiviewRendering ? "enabled" : "disabled");
if (!m_swapchains.isEmpty()) {
qCDebug(lcQuick3DXr, "OpenXR swapchain already exists, creating new one due to change in multiview mode");
destroySwapchain();
createSwapchains();
emit q->multiViewRenderingEnabledChanged();
}
}
bool QQuick3DXrManagerPrivate::isPassthroughEnabled() const
{
// FB passthrough is enabled
if (m_fbPassthroughEnabled)
return true;
// Blend mode passthrough is enabled (ALPHA_BLEND or ADDITIVE)
return m_environmentBlendMode == XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND
|| m_environmentBlendMode == XR_ENVIRONMENT_BLEND_MODE_ADDITIVE;
}
void QQuick3DXrManagerPrivate::setFBPassthroughEnabled(bool enable)
{
m_fbPassthroughEnabled = enable;
if (enable) {
if (m_passthroughFeature == XR_NULL_HANDLE)
createMetaQuestPassthrough();
else
startMetaQuestPassthrough();
if (m_passthroughLayer == XR_NULL_HANDLE)
createMetaQuestPassthroughLayer();
else
resumeMetaQuestPassthroughLayer();
} else {
if (m_passthroughLayer)
pauseMetaQuestPassthroughLayer();
if (m_passthroughFeature)
pauseMetaQuestPassthrough();
}
}
bool QQuick3DXrManagerPrivate::setTransparentBlendMode(bool enable)
{
if (enable) {
if (m_blendModes.contains(XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND))
m_environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND;
else if (m_blendModes.contains(XR_ENVIRONMENT_BLEND_MODE_ADDITIVE))
m_environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_ADDITIVE;
else
return false;
} else {
if (m_blendModes.contains(XR_ENVIRONMENT_BLEND_MODE_OPAQUE))
m_environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
else
return false;
}
qCDebug(lcQuick3DXr, "Environment blend mode set to: %s", to_string(m_environmentBlendMode));
return true;
}
bool QQuick3DXrManagerPrivate::setPassthroughEnabled(bool enable)
{
if (supportsFBPassthrough()) {
setFBPassthroughEnabled(enable);
return true;
}
return setTransparentBlendMode(enable);
}
void QQuick3DXrManagerPrivate::setDepthSubmissionEnabled(bool enable)
{
if (m_submitLayerDepth == enable)
return;
if (m_compositionLayerDepthSupported) {
if (enable)
qCDebug(lcQuick3DXr, "Enabling submitLayerDepth");
m_submitLayerDepth = enable;
}
}
void QQuick3DXrManagerPrivate::setReferenceSpace(QtQuick3DXr::ReferenceSpace newReferenceSpace)
{
XrReferenceSpaceType referenceSpace = getXrReferenceSpaceType(newReferenceSpace);
if (m_referenceSpace == referenceSpace)
return;
m_requestedReferenceSpace = referenceSpace;
// we do not emit a changed signal here because it hasn't
// changed yet.
}
QtQuick3DXr::ReferenceSpace QQuick3DXrManagerPrivate::getReferenceSpace() const
{
return getReferenceSpaceType(m_referenceSpace);
}
void QQuick3DXrManagerPrivate::getDefaultClipDistances(float &nearClip, float &farClip) const
{
// Hardcoded defaults
nearClip = 1.0f;
farClip = 10000.0f;
}
void QQuick3DXrManagerPrivate::pollEvents(bool *exitRenderLoop, bool *requestRestart) {
*exitRenderLoop = false;
*requestRestart = false;
auto readNextEvent = [this]() {
// It is sufficient to clear the just the XrEventDataBuffer header to
// XR_TYPE_EVENT_DATA_BUFFER
XrEventDataBaseHeader* baseHeader = reinterpret_cast<XrEventDataBaseHeader*>(&m_eventDataBuffer);
*baseHeader = {XR_TYPE_EVENT_DATA_BUFFER, nullptr};
const XrResult xr = xrPollEvent(m_instance, &m_eventDataBuffer);
if (xr == XR_SUCCESS) {
if (baseHeader->type == XR_TYPE_EVENT_DATA_EVENTS_LOST) {
const XrEventDataEventsLost* const eventsLost = reinterpret_cast<const XrEventDataEventsLost*>(baseHeader);
qCDebug(lcQuick3DXr, "%d events lost", eventsLost->lostEventCount);
}
return baseHeader;
}
return static_cast<XrEventDataBaseHeader*>(nullptr);
};
auto handleSessionStateChangedEvent = [this](const XrEventDataSessionStateChanged& stateChangedEvent,
bool* exitRenderLoop,
bool* requestRestart) {
const XrSessionState oldState = m_sessionState;
m_sessionState = stateChangedEvent.state;
qCDebug(lcQuick3DXr, "XrEventDataSessionStateChanged: state %s->%s time=%lld",
to_string(oldState),
to_string(m_sessionState),
static_cast<long long int>(stateChangedEvent.time));
if ((stateChangedEvent.session != XR_NULL_HANDLE) && (stateChangedEvent.session != m_session)) {
qCDebug(lcQuick3DXr, "XrEventDataSessionStateChanged for unknown session");
return;
}
switch (m_sessionState) {
case XR_SESSION_STATE_READY: {
Q_ASSERT(m_session != XR_NULL_HANDLE);
XrSessionBeginInfo sessionBeginInfo{};
sessionBeginInfo.type = XR_TYPE_SESSION_BEGIN_INFO;
sessionBeginInfo.primaryViewConfigurationType = m_viewConfigType;
if (!checkXrResult(xrBeginSession(m_session, &sessionBeginInfo))) {
qWarning("xrBeginSession failed");
break;
}
m_sessionRunning = true;
break;
}
case XR_SESSION_STATE_STOPPING: {
Q_ASSERT(m_session != XR_NULL_HANDLE);
m_sessionRunning = false;
if (!checkXrResult(xrEndSession(m_session)))
qWarning("xrEndSession failed");
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;
}
};
// Process all pending messages.
while (const XrEventDataBaseHeader* event = readNextEvent()) {
switch (event->type) {
case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING: {
const auto& instanceLossPending = *reinterpret_cast<const XrEventDataInstanceLossPending*>(event);
qCDebug(lcQuick3DXr, "XrEventDataInstanceLossPending by %lld", static_cast<long long int>(instanceLossPending.lossTime));
*exitRenderLoop = true;
*requestRestart = true;
return;
}
case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: {
auto sessionStateChangedEvent = *reinterpret_cast<const XrEventDataSessionStateChanged*>(event);
handleSessionStateChangedEvent(sessionStateChangedEvent, exitRenderLoop, requestRestart);
break;
}
case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED:
break;
case XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB:
case XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB:
case XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB:
case XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB:
// Handle these events in the space extension
if (m_spaceExtension)
m_spaceExtension->handleEvent(event);
break;
case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING:
default: {
qCDebug(lcQuick3DXr, "Ignoring event type %d", event->type);
break;
}
}
}
}
bool QQuick3DXrManagerPrivate::renderLayer(XrTime predictedDisplayTime,
XrDuration predictedDisplayPeriod,
XrCompositionLayerProjection &layer)
{
Q_Q(QQuick3DXrManager);
auto *xrOrigin = q->m_xrOrigin;
auto *animationDriver = q->m_animationDriver;
auto *renderControl = q->m_renderControl;
XrResult res;
XrViewState viewState{};
viewState.type = XR_TYPE_VIEW_STATE;
quint32 viewCapacityInput = m_views.size();
quint32 viewCountOutput;
// Check if we need to update the app space before we use it
updateAppSpace(predictedDisplayTime);
XrViewLocateInfo viewLocateInfo{};
viewLocateInfo.type = XR_TYPE_VIEW_LOCATE_INFO;
viewLocateInfo.viewConfigurationType = m_viewConfigType;
viewLocateInfo.displayTime = predictedDisplayTime;
viewLocateInfo.space = m_appSpace;
res = xrLocateViews(m_session, &viewLocateInfo, &viewState, viewCapacityInput, &viewCountOutput, m_views.data());
if (XR_UNQUALIFIED_SUCCESS(res)) {
Q_ASSERT(viewCountOutput == viewCapacityInput);
Q_ASSERT(static_cast<qsizetype>(viewCountOutput) == m_configViews.size());
Q_ASSERT(static_cast<qsizetype>(viewCountOutput) == m_projectionLayerViews.size());
Q_ASSERT(m_multiviewRendering ? viewCountOutput == m_swapchains[0].arraySize : static_cast<qsizetype>(viewCountOutput) == m_swapchains.size());
// Update the camera/head position
XrSpaceLocation location{};
location.type = XR_TYPE_SPACE_LOCATION;
if (checkXrResult(xrLocateSpace(m_viewSpace, m_appSpace, predictedDisplayTime, &location))) {
QVector3D position = QVector3D(location.pose.position.x,
location.pose.position.y,
location.pose.position.z) * 100.0f; // convert m to cm
QQuaternion rotation(location.pose.orientation.w,
location.pose.orientation.x,
location.pose.orientation.y,
location.pose.orientation.z);
xrOrigin->updateTrackedCamera(position, rotation);
}
// Set the hand positions
if (QSSG_GUARD(m_inputManager != nullptr))
QQuick3DXrInputManagerPrivate::get(m_inputManager)->updatePoses(predictedDisplayTime, m_appSpace);
// Spatial Anchors
if (m_spaceExtension)
m_spaceExtension->updateAnchors(predictedDisplayTime, m_appSpace);
if (m_handtrackingExtensionSupported && m_inputManager)
QQuick3DXrInputManagerPrivate::get(m_inputManager)->updateHandtracking(predictedDisplayTime, m_appSpace, m_handtrackingAimExtensionSupported);
// Before rendering individual views, advance the animation driver once according
// to the expected display time
const qint64 displayPeriodMS = predictedDisplayPeriod / 1000000;
const qint64 displayDeltaMS = (predictedDisplayTime - m_previousTime) / 1000000;
if (m_previousTime == 0 || !animationDriver->isRunning()) {
animationDriver->setStep(displayPeriodMS);
} else {
if (displayDeltaMS > displayPeriodMS)
animationDriver->setStep(displayPeriodMS);
else
animationDriver->setStep(displayDeltaMS);
animationDriver->advance();
}
m_previousTime = predictedDisplayTime;
#if QT_CONFIG(graphicsframecapture)
if (m_frameCapture)
m_frameCapture->startCaptureFrame();
#endif
if (m_submitLayerDepth && m_samples > 1) {
if (!renderControl->rhi()->isFeatureSupported(QRhi::ResolveDepthStencil)) {
static bool warned = false;
if (!warned) {
warned = true;
qWarning("Quick3D XR: Submitting depth buffer with MSAA cannot be enabled"
" when depth-stencil resolve is not supported by the underlying 3D API (%s)",
renderControl->rhi()->backendName());
}
m_submitLayerDepth = false;
}
}
if (m_multiviewRendering) {
const Swapchain swapchain = m_swapchains[0];
// Acquire the swapchain image array
XrSwapchainImageAcquireInfo acquireInfo{};
acquireInfo.type = XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO;
uint32_t swapchainImageIndex = 0;
if (!checkXrResult(xrAcquireSwapchainImage(swapchain.handle, &acquireInfo, &swapchainImageIndex))) {
qWarning("Failed to acquire swapchain image (multiview)");
return false;
}
XrSwapchainImageWaitInfo waitInfo{};
waitInfo.type = XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO;
waitInfo.timeout = XR_INFINITE_DURATION;
if (!checkXrResult(xrWaitSwapchainImage(swapchain.handle, &waitInfo))) {
qWarning("Failed to wait for swapchain image (multiview)");
return false;
}
XrSwapchainImageBaseHeader *swapchainImage = m_swapchainImages[swapchain.handle][swapchainImageIndex];
XrSwapchainImageBaseHeader *depthSwapchainImage = nullptr;
if (m_submitLayerDepth && !m_depthSwapchains.isEmpty()) {
if (checkXrResult(xrAcquireSwapchainImage(m_depthSwapchains[0].handle, &acquireInfo, &swapchainImageIndex))) {
if (checkXrResult(xrWaitSwapchainImage(m_depthSwapchains[0].handle, &waitInfo)))
depthSwapchainImage = m_depthSwapchainImages[m_depthSwapchains[0].handle][swapchainImageIndex];
else
qWarning("Failed to wait for depth swapchain image (multiview)");
} else {
qWarning("Failed to acquire depth swapchain image (multiview)");
}
}
// First update both cameras with the latest view information and
// then set them on the viewport (since this is going to be
// multiview rendering).
for (uint32_t i = 0; i < viewCountOutput; i++) {
// subImage.swapchain and imageArrayIndex are already set and correct
m_projectionLayerViews[i].pose = m_views[i].pose;
m_projectionLayerViews[i].fov = m_views[i].fov;
}
updateCameraMultiview(0, viewCountOutput);
// Perform the rendering. In multiview mode it is done just once,
// targeting all the views (outputting simultaneously to all texture
// array layers). The subImage dimensions are the same, that's why
// passing in the first layerView's subImage works.
doRender(m_projectionLayerViews[0].subImage,
swapchainImage,
depthSwapchainImage);
for (uint32_t i = 0; i < viewCountOutput; i++) {
if (m_submitLayerDepth) {
m_layerDepthInfos[i].minDepth = 0;
m_layerDepthInfos[i].maxDepth = 1;
QQuick3DXrEyeCamera *cam = xrOrigin ? xrOrigin->eyeCamera(i) : nullptr;
m_layerDepthInfos[i].nearZ = cam ? cam->clipNear() : 1.0f;
m_layerDepthInfos[i].farZ = cam ? cam->clipFar() : 10000.0f;
m_projectionLayerViews[i].next = &m_layerDepthInfos[i];
} else {
m_projectionLayerViews[i].next = nullptr;
}
}
// release the swapchain image array
XrSwapchainImageReleaseInfo releaseInfo{};
releaseInfo.type = XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO;
if (!checkXrResult(xrReleaseSwapchainImage(swapchain.handle, &releaseInfo)))
qWarning("Failed to release swapchain image");
if (depthSwapchainImage) {
if (!checkXrResult(xrReleaseSwapchainImage(m_depthSwapchains[0].handle, &releaseInfo)))
qWarning("Failed to release depth swapchain image");
}
} else {
for (uint32_t i = 0; i < viewCountOutput; i++) {
// Each view has a separate swapchain which is acquired, rendered to, and released.
const Swapchain viewSwapchain = m_swapchains[i];
// Render view to the appropriate part of the swapchain image.
XrSwapchainImageAcquireInfo acquireInfo{};
acquireInfo.type = XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO;
uint32_t swapchainImageIndex = 0;
if (!checkXrResult(xrAcquireSwapchainImage(viewSwapchain.handle, &acquireInfo, &swapchainImageIndex))) {
qWarning("Failed to acquire swapchain image");
return false;
}
XrSwapchainImageWaitInfo waitInfo{};
waitInfo.type = XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO;
waitInfo.timeout = XR_INFINITE_DURATION;
if (!checkXrResult(xrWaitSwapchainImage(viewSwapchain.handle, &waitInfo))) {
qWarning("Failed to wait for swapchain image");
return false;
}
XrSwapchainImageBaseHeader *swapchainImage = m_swapchainImages[viewSwapchain.handle][swapchainImageIndex];
XrSwapchainImageBaseHeader *depthSwapchainImage = nullptr;
if (m_submitLayerDepth && !m_depthSwapchains.isEmpty()) {
if (checkXrResult(xrAcquireSwapchainImage(m_depthSwapchains[i].handle, &acquireInfo, &swapchainImageIndex))) {
if (checkXrResult(xrWaitSwapchainImage(m_depthSwapchains[i].handle, &waitInfo)))
depthSwapchainImage = m_depthSwapchainImages[m_depthSwapchains[i].handle][swapchainImageIndex];
else
qWarning("Failed to wait for depth swapchain image");
} else {
qWarning("Failed to acquire depth swapchain image");
}
}
m_projectionLayerViews[i].subImage.swapchain = viewSwapchain.handle;
m_projectionLayerViews[i].subImage.imageArrayIndex = 0;
m_projectionLayerViews[i].pose = m_views[i].pose;
m_projectionLayerViews[i].fov = m_views[i].fov;
updateCameraNonMultiview(i, m_projectionLayerViews[i]);
doRender(m_projectionLayerViews[i].subImage,
swapchainImage,
depthSwapchainImage);
if (depthSwapchainImage) {
m_layerDepthInfos[i].subImage.swapchain = m_depthSwapchains[i].handle;
m_layerDepthInfos[i].subImage.imageArrayIndex = 0;
m_layerDepthInfos[i].minDepth = 0;
m_layerDepthInfos[i].maxDepth = 1;
QQuick3DXrEyeCamera *cam = xrOrigin ? xrOrigin->eyeCamera(i) : nullptr;
m_layerDepthInfos[i].nearZ = cam ? cam->clipNear() : 1.0f;
m_layerDepthInfos[i].farZ = cam ? cam->clipFar() : 10000.0f;
m_projectionLayerViews[i].next = &m_layerDepthInfos[i];
} else {
m_projectionLayerViews[i].next = nullptr;
}
XrSwapchainImageReleaseInfo releaseInfo{};
releaseInfo.type = XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO;
if (!checkXrResult(xrReleaseSwapchainImage(viewSwapchain.handle, &releaseInfo)))
qWarning("Failed to release swapchain image");
if (depthSwapchainImage) {
if (!checkXrResult(xrReleaseSwapchainImage(m_depthSwapchains[i].handle, &releaseInfo)))
qWarning("Failed to release depth swapchain image");
}
}
}
#if QT_CONFIG(graphicsframecapture)
if (m_frameCapture)
m_frameCapture->endCaptureFrame();
#endif
layer.space = m_appSpace;
layer.viewCount = (uint32_t)m_projectionLayerViews.size();
layer.views = m_projectionLayerViews.data();
return true;
}
qCDebug(lcQuick3DXr, "xrLocateViews returned qualified success code: %s", to_string(res));
return false;
}
void QQuick3DXrManagerPrivate::doRender(const XrSwapchainSubImage &subImage,
const XrSwapchainImageBaseHeader *swapchainImage,
const XrSwapchainImageBaseHeader *depthSwapchainImage)
{
Q_Q(QQuick3DXrManager);
auto *quickWindow = q->m_quickWindow;
auto *renderControl = q->m_renderControl;
const int arraySize = m_multiviewRendering ? m_swapchains[0].arraySize : 1;
quickWindow->setRenderTarget(m_graphics->renderTarget(subImage,
swapchainImage,
m_colorSwapchainFormat,
m_samples,
arraySize,
depthSwapchainImage,
m_depthSwapchainFormat));
quickWindow->setGeometry(0,
0,
subImage.imageRect.extent.width,
subImage.imageRect.extent.height);
quickWindow->contentItem()->setSize(QSizeF(subImage.imageRect.extent.width,
subImage.imageRect.extent.height));
renderControl->polishItems();
renderControl->beginFrame();
renderControl->sync();
renderControl->render();
renderControl->endFrame();
// With multiview this indicates that the frame with both eyes is ready from
// the 3D APIs perspective. Without multiview this is done - and so the
// signal is emitted - multiple times (twice) per "frame" (eye).
QRhiRenderTarget *rt = QQuickWindowPrivate::get(quickWindow)->activeCustomRhiRenderTarget();
if (rt->resourceType() == QRhiResource::TextureRenderTarget && static_cast<QRhiTextureRenderTarget *>(rt)->description().colorAttachmentAt(0)->texture())
emit q->frameReady();
}
void QQuick3DXrManagerPrivate::setupMetaQuestColorSpaces()
{
PFN_xrEnumerateColorSpacesFB pfnxrEnumerateColorSpacesFB = NULL;
OpenXRHelpers::resolveXrFunction(m_instance, "xrEnumerateColorSpacesFB", (PFN_xrVoidFunction*)(&pfnxrEnumerateColorSpacesFB));
if (!pfnxrEnumerateColorSpacesFB) // simulator
return;
uint32_t colorSpaceCountOutput = 0;
if (!checkXrResult(pfnxrEnumerateColorSpacesFB(m_session, 0, &colorSpaceCountOutput, nullptr))) {
qWarning("Failed to enumerate color spaces");
return;
}
XrColorSpaceFB* colorSpaces =
(XrColorSpaceFB*)malloc(colorSpaceCountOutput * sizeof(XrColorSpaceFB));
if (!checkXrResult(pfnxrEnumerateColorSpacesFB(m_session, colorSpaceCountOutput, &colorSpaceCountOutput, colorSpaces))) {
qWarning("Failed to enumerate color spaces");
return;
}
qCDebug(lcQuick3DXr, "Supported color spaces:");
for (uint32_t i = 0; i < colorSpaceCountOutput; i++) {
qCDebug(lcQuick3DXr,"%d:%d", i, colorSpaces[i]);
}
const XrColorSpaceFB requestColorSpace = XR_COLOR_SPACE_QUEST_FB;
PFN_xrSetColorSpaceFB pfnxrSetColorSpaceFB = NULL;
OpenXRHelpers::resolveXrFunction(m_instance, "xrSetColorSpaceFB", (PFN_xrVoidFunction*)(&pfnxrSetColorSpaceFB));
if (!checkXrResult(pfnxrSetColorSpaceFB(m_session, requestColorSpace)))
qWarning("Failed to set color space");
free(colorSpaces);
}
void QQuick3DXrManagerPrivate::setupMetaQuestRefreshRates()
{
PFN_xrEnumerateDisplayRefreshRatesFB pfnxrEnumerateDisplayRefreshRatesFB = NULL;
OpenXRHelpers::resolveXrFunction(m_instance, "xrEnumerateDisplayRefreshRatesFB", (PFN_xrVoidFunction*)(&pfnxrEnumerateDisplayRefreshRatesFB));
if (!pfnxrEnumerateDisplayRefreshRatesFB)
return;
uint32_t numSupportedDisplayRefreshRates;
QVector<float> supportedDisplayRefreshRates;
if (!checkXrResult(pfnxrEnumerateDisplayRefreshRatesFB(m_session, 0, &numSupportedDisplayRefreshRates, nullptr))) {
qWarning("Failed to enumerate display refresh rates");
return;
}
supportedDisplayRefreshRates.resize(numSupportedDisplayRefreshRates);
if (!checkXrResult(pfnxrEnumerateDisplayRefreshRatesFB(
m_session,
numSupportedDisplayRefreshRates,
&numSupportedDisplayRefreshRates,
supportedDisplayRefreshRates.data())))
{
qWarning("Failed to enumerate display refresh rates");
return;
}
qCDebug(lcQuick3DXr, "Supported Refresh Rates:");
for (uint32_t i = 0; i < numSupportedDisplayRefreshRates; i++) {
qCDebug(lcQuick3DXr, "%d:%f", i, supportedDisplayRefreshRates[i]);
}
PFN_xrGetDisplayRefreshRateFB pfnGetDisplayRefreshRate;
OpenXRHelpers::resolveXrFunction(m_instance, "xrGetDisplayRefreshRateFB", (PFN_xrVoidFunction*)(&pfnGetDisplayRefreshRate));
float currentDisplayRefreshRate = 0.0f;
if (!checkXrResult(pfnGetDisplayRefreshRate(m_session, &currentDisplayRefreshRate)))
qWarning("Failed to get display refresh rate");
qCDebug(lcQuick3DXr, "Current System Display Refresh Rate: %f", currentDisplayRefreshRate);
PFN_xrRequestDisplayRefreshRateFB pfnRequestDisplayRefreshRate;
OpenXRHelpers::resolveXrFunction(m_instance, "xrRequestDisplayRefreshRateFB", (PFN_xrVoidFunction*)(&pfnRequestDisplayRefreshRate));
// Test requesting the system default.
if (!checkXrResult(pfnRequestDisplayRefreshRate(m_session, 0.0f)))
qWarning("Failed to request display refresh rate");
qCDebug(lcQuick3DXr, "Requesting system default display refresh rate");
}
void QQuick3DXrManagerPrivate::setupMetaQuestFoveation()
{
PFN_xrCreateFoveationProfileFB pfnCreateFoveationProfileFB;
OpenXRHelpers::resolveXrFunction(m_instance, "xrCreateFoveationProfileFB", (PFN_xrVoidFunction*)(&pfnCreateFoveationProfileFB));
if (!pfnCreateFoveationProfileFB) // simulator
return;
PFN_xrDestroyFoveationProfileFB pfnDestroyFoveationProfileFB;
OpenXRHelpers::resolveXrFunction(m_instance, "xrDestroyFoveationProfileFB", (PFN_xrVoidFunction*)(&pfnDestroyFoveationProfileFB));
PFN_xrUpdateSwapchainFB pfnUpdateSwapchainFB;
OpenXRHelpers::resolveXrFunction(m_instance, "xrUpdateSwapchainFB", (PFN_xrVoidFunction*)(&pfnUpdateSwapchainFB));
for (const auto &swapchain : std::as_const(m_swapchains)) {
XrFoveationLevelProfileCreateInfoFB levelProfileCreateInfo = {};
levelProfileCreateInfo.type = XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB;
levelProfileCreateInfo.level = m_foveationLevel;
levelProfileCreateInfo.verticalOffset = 0;
levelProfileCreateInfo.dynamic = XR_FOVEATION_DYNAMIC_DISABLED_FB;
XrFoveationProfileCreateInfoFB profileCreateInfo = {};
profileCreateInfo.type = XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB;
profileCreateInfo.next = &levelProfileCreateInfo;
XrFoveationProfileFB foveationProfile;
pfnCreateFoveationProfileFB(m_session, &profileCreateInfo, &foveationProfile);
XrSwapchainStateFoveationFB foveationUpdateState = {};
memset(&foveationUpdateState, 0, sizeof(foveationUpdateState));
foveationUpdateState.type = XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB;
foveationUpdateState.profile = foveationProfile;
XrResult updateSwapchainFBResult = OpenXRHelpers::safeCall(pfnUpdateSwapchainFB, swapchain.handle, (const XrSwapchainStateBaseHeaderFB*)(&foveationUpdateState));
if (updateSwapchainFBResult == XR_ERROR_FUNCTION_UNSUPPORTED)
return;
XrResult destroyFoveationProfileFBResult = OpenXRHelpers::safeCall(pfnDestroyFoveationProfileFB, foveationProfile);
if (destroyFoveationProfileFBResult == XR_ERROR_FUNCTION_UNSUPPORTED)
return;
qCDebug(lcQuick3DXr, "Fixed foveated rendering requested with level %d", int(m_foveationLevel));
}
}
void QQuick3DXrManagerPrivate::createMetaQuestPassthrough()
{
// According to the validation layer 'flags' cannot be 0, thus we make sure
// this function is only ever called when we know passthrough is actually
// enabled by the app.
Q_ASSERT(m_fbPassthroughEnabled);
PFN_xrCreatePassthroughFB pfnXrCreatePassthroughFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrCreatePassthroughFB", (PFN_xrVoidFunction*)(&pfnXrCreatePassthroughFBX));
XrPassthroughCreateInfoFB passthroughCreateInfo{};
passthroughCreateInfo.type = XR_TYPE_PASSTHROUGH_CREATE_INFO_FB;
passthroughCreateInfo.flags = XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB;
XrResult xrCreatePassthroughFBXResult = OpenXRHelpers::safeCall(pfnXrCreatePassthroughFBX, m_session, static_cast<const XrPassthroughCreateInfoFB*>(&passthroughCreateInfo), &m_passthroughFeature);
if (!checkXrResult(xrCreatePassthroughFBXResult))
qWarning("Failed to create passthrough object");
}
void QQuick3DXrManagerPrivate::destroyMetaQuestPassthrough()
{
PFN_xrDestroyPassthroughFB pfnXrDestroyPassthroughFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrDestroyPassthroughFB", (PFN_xrVoidFunction*)(&pfnXrDestroyPassthroughFBX));
XrResult xrDestroyPassthroughFBXResult = OpenXRHelpers::safeCall(pfnXrDestroyPassthroughFBX, m_passthroughFeature);
if (!checkXrResult(xrDestroyPassthroughFBXResult))
qWarning("Failed to destroy passthrough object");
m_passthroughFeature = XR_NULL_HANDLE;
}
void QQuick3DXrManagerPrivate::startMetaQuestPassthrough()
{
PFN_xrPassthroughStartFB pfnXrPassthroughStartFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrPassthroughStartFB", (PFN_xrVoidFunction*)(&pfnXrPassthroughStartFBX));
XrResult xrPassthroughStartFBXResult = OpenXRHelpers::safeCall(pfnXrPassthroughStartFBX, m_passthroughFeature);
if (!checkXrResult(xrPassthroughStartFBXResult))
qWarning("Failed to start passthrough");
}
void QQuick3DXrManagerPrivate::pauseMetaQuestPassthrough()
{
PFN_xrPassthroughPauseFB pfnXrPassthroughPauseFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrPassthroughPauseFB", (PFN_xrVoidFunction*)(&pfnXrPassthroughPauseFBX));
XrResult xrPassthroughPauseFBXResult = OpenXRHelpers::safeCall(pfnXrPassthroughPauseFBX, m_passthroughFeature);
if (!checkXrResult(xrPassthroughPauseFBXResult))
qWarning("Failed to pause passthrough");
}
void QQuick3DXrManagerPrivate::createMetaQuestPassthroughLayer()
{
PFN_xrCreatePassthroughLayerFB pfnXrCreatePassthroughLayerFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrCreatePassthroughLayerFB", (PFN_xrVoidFunction*)(&pfnXrCreatePassthroughLayerFBX));
XrPassthroughLayerCreateInfoFB layerCreateInfo{};
layerCreateInfo.type = XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB;
layerCreateInfo.passthrough = m_passthroughFeature;
layerCreateInfo.purpose = XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB;
if (m_fbPassthroughEnabled)
layerCreateInfo.flags = XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB;
XrResult xrCreatePassthroughLayerFBXResult = OpenXRHelpers::safeCall(pfnXrCreatePassthroughLayerFBX, m_session, static_cast<const XrPassthroughLayerCreateInfoFB*>(&layerCreateInfo), &m_passthroughLayer);
if (!checkXrResult(xrCreatePassthroughLayerFBXResult))
qWarning("Failed to create passthrough layer");
}
void QQuick3DXrManagerPrivate::destroyMetaQuestPassthroughLayer()
{
PFN_xrDestroyPassthroughLayerFB pfnXrDestroyPassthroughLayerFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrDestroyPassthroughLayerFB", (PFN_xrVoidFunction*)(&pfnXrDestroyPassthroughLayerFBX));
XrResult xrDestroyPassthroughLayerFBXResult = OpenXRHelpers::safeCall(pfnXrDestroyPassthroughLayerFBX, m_passthroughLayer);
if (!checkXrResult(xrDestroyPassthroughLayerFBXResult))
qWarning("Failed to destroy passthrough layer");
m_passthroughLayer = XR_NULL_HANDLE;
}
void QQuick3DXrManagerPrivate::pauseMetaQuestPassthroughLayer()
{
PFN_xrPassthroughLayerPauseFB pfnXrPassthroughLayerPauseFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrPassthroughLayerPauseFB", (PFN_xrVoidFunction*)(&pfnXrPassthroughLayerPauseFBX));
XrResult xrPassthroughLayerPauseFBXResult = OpenXRHelpers::safeCall(pfnXrPassthroughLayerPauseFBX, m_passthroughLayer);
if (!checkXrResult(xrPassthroughLayerPauseFBXResult))
qWarning("Failed to pause passthrough layer");
}
void QQuick3DXrManagerPrivate::resumeMetaQuestPassthroughLayer()
{
PFN_xrPassthroughLayerResumeFB pfnXrPassthroughLayerResumeFBX = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrPassthroughLayerResumeFB", (PFN_xrVoidFunction*)(&pfnXrPassthroughLayerResumeFBX));
XrResult xrPassthroughLayerResumeFBXResult = OpenXRHelpers::safeCall(pfnXrPassthroughLayerResumeFBX, m_passthroughLayer);
if (!checkXrResult(xrPassthroughLayerResumeFBXResult))
qWarning("Failed to resume passthrough layer");
}
void QQuick3DXrManagerPrivate::checkXrExtensions(const char *layerName, int indent)
{
quint32 instanceExtensionCount;
if (!checkXrResult(xrEnumerateInstanceExtensionProperties(layerName, 0, &instanceExtensionCount, nullptr))) {
qWarning("Failed to enumerate instance extension properties");
return;
}
QVector<XrExtensionProperties> extensions(instanceExtensionCount);
for (XrExtensionProperties& extension : extensions) {
extension.type = XR_TYPE_EXTENSION_PROPERTIES;
extension.next = nullptr;
}
if (!checkXrResult(xrEnumerateInstanceExtensionProperties(layerName,
quint32(extensions.size()),
&instanceExtensionCount,
extensions.data())))
{
qWarning("Failed to enumerate instance extension properties");
}
const QByteArray indentStr(indent, ' ');
qCDebug(lcQuick3DXr, "%sAvailable Extensions: (%d)", indentStr.data(), instanceExtensionCount);
for (const XrExtensionProperties& extension : extensions) {
qCDebug(lcQuick3DXr, "%s Name=%s Version=%d.%d.%d",
indentStr.data(),
extension.extensionName,
XR_VERSION_MAJOR(extension.extensionVersion),
XR_VERSION_MINOR(extension.extensionVersion),
XR_VERSION_PATCH(extension.extensionVersion));
}
}
void QQuick3DXrManagerPrivate::checkXrLayers()
{
quint32 layerCount;
if (!checkXrResult(xrEnumerateApiLayerProperties(0, &layerCount, nullptr))) {
qWarning("Failed to enumerate API layer properties");
return;
}
QVector<XrApiLayerProperties> layers(layerCount);
for (XrApiLayerProperties& layer : layers) {
layer.type = XR_TYPE_API_LAYER_PROPERTIES;
layer.next = nullptr;
}
if (!checkXrResult(xrEnumerateApiLayerProperties(quint32(layers.size()), &layerCount, layers.data()))) {
qWarning("Failed to enumerate API layer properties");
return;
}
qCDebug(lcQuick3DXr, "Available Layers: (%d)", layerCount);
for (const XrApiLayerProperties& layer : layers) {
qCDebug(lcQuick3DXr, " Name=%s SpecVersion=%d.%d.%d LayerVersion=%d.%d.%d Description=%s",
layer.layerName,
XR_VERSION_MAJOR(layer.specVersion),
XR_VERSION_MINOR(layer.specVersion),
XR_VERSION_PATCH(layer.specVersion),
XR_VERSION_MAJOR(layer.layerVersion),
XR_VERSION_MINOR(layer.layerVersion),
XR_VERSION_PATCH(layer.layerVersion),
layer.description);
checkXrExtensions(layer.layerName, 4);
}
}
XrResult QQuick3DXrManagerPrivate::createXrInstance()
{
// Setup Info
XrApplicationInfo appInfo;
strcpy(appInfo.applicationName, QCoreApplication::applicationName().toUtf8());
appInfo.applicationVersion = 7;
strcpy(appInfo.engineName, QStringLiteral("Qt").toUtf8());
appInfo.engineVersion = 6;
// apiVersion must not be XR_CURRENT_API_VERSION. Consider what happens when
// building against 1.1 headers and running on an 1.0-only runtime. (it all
// breaks down) For now, use a known, fixed version: the last 1.0 release.
appInfo.apiVersion = XR_MAKE_VERSION(1, 0, 34);
// Query available API layers
uint32_t apiLayerCount = 0;
xrEnumerateApiLayerProperties(0, &apiLayerCount, nullptr);
QVector<XrApiLayerProperties> apiLayerProperties(apiLayerCount);
for (uint32_t i = 0; i < apiLayerCount; i++) {
apiLayerProperties[i].type = XR_TYPE_API_LAYER_PROPERTIES;
apiLayerProperties[i].next = nullptr;
}
xrEnumerateApiLayerProperties(apiLayerCount, &apiLayerCount, apiLayerProperties.data());
// Decide which API layers to enable
QVector<const char*> enabledApiLayers;
// Now it would be nice if we could use
// QQuickGraphicsConfiguration::isDebugLayerEnabled() but the quickWindow is
// nowhere yet, so just replicate the env.var. for now.
const bool wantsValidationLayer = qEnvironmentVariableIntValue("QSG_RHI_DEBUG_LAYER");
if (wantsValidationLayer) {
if (isApiLayerSupported("XR_APILAYER_LUNARG_core_validation", apiLayerProperties))
enabledApiLayers.append("XR_APILAYER_LUNARG_core_validation");
else
qCDebug(lcQuick3DXr, "OpenXR validation layer requested, but not available");
}
qCDebug(lcQuick3DXr) << "Requesting to enable XR API layers:" << enabledApiLayers;
m_enabledApiLayers.clear();
for (const char *layer : std::as_const(enabledApiLayers))
m_enabledApiLayers.append(QString::fromLatin1(layer));
// Load extensions
uint32_t extensionCount = 0;
xrEnumerateInstanceExtensionProperties(nullptr, 0, &extensionCount, nullptr);
QVector<XrExtensionProperties> extensionProperties(extensionCount);
for (uint32_t i = 0; i < extensionCount; i++) {
// we usually have to fill in the type (for validation) and set
// next to NULL (or a pointer to an extension specific struct)
extensionProperties[i].type = XR_TYPE_EXTENSION_PROPERTIES;
extensionProperties[i].next = nullptr;
}
xrEnumerateInstanceExtensionProperties(nullptr, extensionCount, &extensionCount, extensionProperties.data());
QVector<const char*> enabledExtensions;
if (!m_graphics->initialize(extensionProperties)) {
qWarning("Failed to initialize OpenXR graphics module");
return XR_ERROR_GRAPHICS_DEVICE_INVALID;
}
enabledExtensions.append(m_graphics->getRequiredExtensions());
if (isExtensionSupported("XR_EXT_debug_utils", extensionProperties))
enabledExtensions.append("XR_EXT_debug_utils");
if (isExtensionSupported(XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME);
m_handtrackingExtensionSupported = isExtensionSupported(XR_EXT_HAND_TRACKING_EXTENSION_NAME, extensionProperties);
if (m_handtrackingExtensionSupported)
enabledExtensions.append(XR_EXT_HAND_TRACKING_EXTENSION_NAME);
m_compositionLayerDepthSupported = isExtensionSupported(XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME, extensionProperties);
if (m_compositionLayerDepthSupported) {
// The extension is enabled, whenever supported; however, if we actually
// submit depth in xrEndFrame(), is a different question.
enabledExtensions.append(XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME);
m_submitLayerDepth = qEnvironmentVariableIntValue("QT_QUICK3D_XR_SUBMIT_DEPTH");
if (m_submitLayerDepth)
qCDebug(lcQuick3DXr, "submitLayerDepth defaults to true due to env.var.");
} else {
m_submitLayerDepth = false;
}
// Oculus Quest Specific Extensions
m_handtrackingAimExtensionSupported = isExtensionSupported(XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME, extensionProperties);
if (m_handtrackingAimExtensionSupported)
enabledExtensions.append(XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME);
if (isExtensionSupported(XR_MSFT_HAND_INTERACTION_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_MSFT_HAND_INTERACTION_EXTENSION_NAME);
if (isExtensionSupported(XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME);
// Passthrough extensions (require manifest feature to work)
// <uses-feature android:name="com.oculus.feature.PASSTHROUGH" android:required="true" />
uint32_t passthroughSpecVersion = 0;
if (isExtensionSupported(XR_FB_PASSTHROUGH_EXTENSION_NAME, extensionProperties, &passthroughSpecVersion)) {
qCDebug(lcQuick3DXr, "Passthrough extension is supported, spec version %u", passthroughSpecVersion);
enabledExtensions.append(XR_FB_PASSTHROUGH_EXTENSION_NAME);
} else {
qCDebug(lcQuick3DXr, "Passthrough extension is NOT supported");
}
if (isExtensionSupported(XR_FB_TRIANGLE_MESH_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_FB_TRIANGLE_MESH_EXTENSION_NAME);
m_displayRefreshRateExtensionSupported = isExtensionSupported(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME, extensionProperties);
if (m_displayRefreshRateExtensionSupported)
enabledExtensions.append(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME);
m_colorspaceExtensionSupported = isExtensionSupported(XR_FB_COLOR_SPACE_EXTENSION_NAME, extensionProperties);
if (m_colorspaceExtensionSupported)
enabledExtensions.append(XR_FB_COLOR_SPACE_EXTENSION_NAME);
if (isExtensionSupported(XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME);
m_foveationExtensionSupported = isExtensionSupported(XR_FB_FOVEATION_EXTENSION_NAME, extensionProperties);
if (m_foveationExtensionSupported)
enabledExtensions.append(XR_FB_FOVEATION_EXTENSION_NAME);
if (isExtensionSupported(XR_FB_FOVEATION_CONFIGURATION_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_FB_FOVEATION_CONFIGURATION_EXTENSION_NAME);
if (m_spaceExtension) {
const auto requiredExtensions = m_spaceExtension->requiredExtensions();
bool isSupported = true;
for (const auto extension : requiredExtensions) {
isSupported = isExtensionSupported(extension, extensionProperties) && isSupported;
if (!isSupported)
break;
}
m_spaceExtensionSupported = isSupported;
if (isSupported)
enabledExtensions.append(requiredExtensions);
}
if (isExtensionSupported(XR_EXTX_OVERLAY_EXTENSION_NAME, extensionProperties)) {
m_overlayExtensionSupported = true;
enabledExtensions.append(XR_EXTX_OVERLAY_EXTENSION_NAME);
}
#ifdef Q_OS_ANDROID
if (isExtensionSupported(XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME);
m_androidCreateInstanceExtensionSupported = isExtensionSupported(XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME, extensionProperties);
if (m_androidCreateInstanceExtensionSupported)
enabledExtensions.append(XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME);
auto graphicsAPI = QQuickWindow::graphicsApi();
if (graphicsAPI == QSGRendererInterface::Vulkan) {
if (isExtensionSupported(XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME);
} else if (graphicsAPI == QSGRendererInterface::OpenGL) {
if (isExtensionSupported(XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME, extensionProperties))
enabledExtensions.append(XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME);
}
#endif
qCDebug(lcQuick3DXr) << "Requesting to enable XR extensions:" << enabledExtensions;
m_enabledExtensions.clear();
for (const char *extension : std::as_const(enabledExtensions))
m_enabledExtensions.append(QString::fromLatin1(extension));
// Create Instance
XrInstanceCreateInfo xrInstanceInfo{};
xrInstanceInfo.type = XR_TYPE_INSTANCE_CREATE_INFO;
#ifdef Q_OS_ANDROID
XrInstanceCreateInfoAndroidKHR xrInstanceCreateInfoAndroid {};
if (m_androidCreateInstanceExtensionSupported) {
xrInstanceCreateInfoAndroid.type = XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR;
xrInstanceCreateInfoAndroid.applicationVM = m_javaVM;
xrInstanceCreateInfoAndroid.applicationActivity = m_androidActivity.object();
xrInstanceInfo.next = &xrInstanceCreateInfoAndroid;
}
#endif
xrInstanceInfo.createFlags = 0;
xrInstanceInfo.applicationInfo = appInfo;
xrInstanceInfo.enabledApiLayerCount = enabledApiLayers.count();
xrInstanceInfo.enabledApiLayerNames = enabledApiLayers.constData();
xrInstanceInfo.enabledExtensionCount = enabledExtensions.count();
xrInstanceInfo.enabledExtensionNames = enabledExtensions.constData();
return xrCreateInstance(&xrInstanceInfo, &m_instance);
}
void QQuick3DXrManagerPrivate::checkXrInstance()
{
Q_ASSERT(m_instance != XR_NULL_HANDLE);
XrInstanceProperties instanceProperties{};
instanceProperties.type = XR_TYPE_INSTANCE_PROPERTIES;
if (!checkXrResult(xrGetInstanceProperties(m_instance, &instanceProperties))) {
qWarning("Failed to get instance properties");
return;
}
m_runtimeName = QString::fromUtf8(instanceProperties.runtimeName);
m_runtimeVersion = QVersionNumber(XR_VERSION_MAJOR(instanceProperties.runtimeVersion),
XR_VERSION_MINOR(instanceProperties.runtimeVersion),
XR_VERSION_PATCH(instanceProperties.runtimeVersion));
qCDebug(lcQuick3DXr, "Instance RuntimeName=%s RuntimeVersion=%d.%d.%d",
qPrintable(m_runtimeName),
m_runtimeVersion.majorVersion(),
m_runtimeVersion.minorVersion(),
m_runtimeVersion.microVersion());
}
void QQuick3DXrManagerPrivate::setupDebugMessenger()
{
if (!m_enabledExtensions.contains(QString::fromUtf8("XR_EXT_debug_utils"))) {
qCDebug(lcQuick3DXr, "No debug utils extension, message redirection not set up");
return;
}
#ifdef XR_EXT_debug_utils
PFN_xrCreateDebugUtilsMessengerEXT xrCreateDebugUtilsMessengerEXT = nullptr;
OpenXRHelpers::resolveXrFunction(m_instance, "xrCreateDebugUtilsMessengerEXT", reinterpret_cast<PFN_xrVoidFunction *>(&xrCreateDebugUtilsMessengerEXT));
if (!xrCreateDebugUtilsMessengerEXT)
return;
OpenXRHelpers::resolveXrFunction(m_instance, "xrDestroyDebugUtilsMessengerEXT", reinterpret_cast<PFN_xrVoidFunction *>(&m_xrDestroyDebugUtilsMessengerEXT));
XrDebugUtilsMessengerCreateInfoEXT messengerInfo = {};
messengerInfo.type = XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
messengerInfo.messageSeverities = XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
| XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
messengerInfo.messageTypes = XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
| XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
| XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
| XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT;
messengerInfo.userCallback = defaultDebugCallbackFunc;
messengerInfo.userData = this;
XrResult err = xrCreateDebugUtilsMessengerEXT(m_instance, &messengerInfo, &m_debugMessenger);
if (!checkXrResult(err))
qWarning("Quick 3D XR: Failed to create debug report callback, OpenXR messages will not get redirected (%d)", err);
#endif // XR_EXT_debug_utils
}
XrResult QQuick3DXrManagerPrivate::initializeSystem()
{
Q_ASSERT(m_instance != XR_NULL_HANDLE);
Q_ASSERT(m_systemId == XR_NULL_SYSTEM_ID);
XrSystemGetInfo hmdInfo{};
hmdInfo.type = XR_TYPE_SYSTEM_GET_INFO;
hmdInfo.next = nullptr;
hmdInfo.formFactor = m_formFactor;
const XrResult result = xrGetSystem(m_instance, &hmdInfo, &m_systemId);
const bool success = checkXrResult(result);
if (!success)
return result;
// Check View Configuration
checkViewConfiguration();
return result;
}
void QQuick3DXrManagerPrivate::checkViewConfiguration()
{
quint32 viewConfigTypeCount;
if (!checkXrResult(xrEnumerateViewConfigurations(m_instance,
m_systemId,
0,
&viewConfigTypeCount,
nullptr)))
{
qWarning("Failed to enumerate view configurations");
return;
}
QVector<XrViewConfigurationType> viewConfigTypes(viewConfigTypeCount);
if (!checkXrResult(xrEnumerateViewConfigurations(m_instance,
m_systemId,
viewConfigTypeCount,
&viewConfigTypeCount,
viewConfigTypes.data())))
{
qWarning("Failed to enumerate view configurations");
return;
}
qCDebug(lcQuick3DXr, "Available View Configuration Types: (%d)", viewConfigTypeCount);
for (XrViewConfigurationType viewConfigType : viewConfigTypes) {
qCDebug(lcQuick3DXr, " View Configuration Type: %s %s", to_string(viewConfigType), viewConfigType == m_viewConfigType ? "(Selected)" : "");
XrViewConfigurationProperties viewConfigProperties{};
viewConfigProperties.type = XR_TYPE_VIEW_CONFIGURATION_PROPERTIES;
if (!checkXrResult(xrGetViewConfigurationProperties(m_instance,
m_systemId,
viewConfigType,
&viewConfigProperties)))
{
qWarning("Failed to get view configuration properties");
return;
}
qCDebug(lcQuick3DXr, " View configuration FovMutable=%s", viewConfigProperties.fovMutable == XR_TRUE ? "True" : "False");
uint32_t viewCount;
if (!checkXrResult(xrEnumerateViewConfigurationViews(m_instance,
m_systemId,
viewConfigType,
0,
&viewCount,
nullptr)))
{
qWarning("Failed to enumerate configuration views");
return;
}
if (viewCount > 0) {
QVector<XrViewConfigurationView> views(viewCount, {XR_TYPE_VIEW_CONFIGURATION_VIEW, nullptr, 0, 0, 0, 0, 0, 0});
if (!checkXrResult(xrEnumerateViewConfigurationViews(m_instance,
m_systemId,
viewConfigType,
viewCount,
&viewCount,
views.data())))
{
qWarning("Failed to enumerate configuration views");
return;
}
for (int i = 0; i < views.size(); ++i) {
const XrViewConfigurationView& view = views[i];
qCDebug(lcQuick3DXr, " View [%d]: Recommended Width=%d Height=%d SampleCount=%d",
i,
view.recommendedImageRectWidth,
view.recommendedImageRectHeight,
view.recommendedSwapchainSampleCount);
qCDebug(lcQuick3DXr, " View [%d]: Maximum Width=%d Height=%d SampleCount=%d",
i,
view.maxImageRectWidth,
view.maxImageRectHeight,
view.maxSwapchainSampleCount);
}
} else {
qCDebug(lcQuick3DXr, "Empty view configuration type");
}
checkEnvironmentBlendMode(viewConfigType);
}
// Select view configuration type based on what the runtime supports.
if (!viewConfigTypes.contains(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO)
&& viewConfigTypes.contains(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO)) {
m_viewConfigType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO;
m_multiviewRendering = false;
qCDebug(lcQuick3DXr, "Mono view mode selected (only mode supported by runtime)");
}
}
bool QQuick3DXrManagerPrivate::checkXrResult(const XrResult &result)
{
return OpenXRHelpers::checkXrResult(result, m_instance);
}
void QQuick3DXrManagerPrivate::checkEnvironmentBlendMode(XrViewConfigurationType type)
{
uint32_t count;
if (!checkXrResult(xrEnumerateEnvironmentBlendModes(m_instance,
m_systemId,
type,
0,
&count,
nullptr)))
{
qWarning("Failed to enumerate blend modes");
return;
}
qCDebug(lcQuick3DXr, "Available Environment Blend Mode count : (%d)", count);
QVector<XrEnvironmentBlendMode> blendModes(count);
if (!checkXrResult(xrEnumerateEnvironmentBlendModes(m_instance,
m_systemId,
type,
count,
&count,
blendModes.data())))
{
qWarning("Failed to enumerate blend modes");
return;
}
m_blendModes = blendModes;
// Set initial blend mode, prefer opaque (passthrough disabled)
if (!setTransparentBlendMode(false))
setTransparentBlendMode(true);
}
QT_END_NAMESPACE
#include "qquick3dxrmanager_openxr.moc"