qquick3dxrview.cpp

Go to the documentation of this file.

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qtquick3dxrglobal_p.h"
#include "qquick3dxritem_p.h"
#include "qquick3dxrview_p.h"
#include <QQuickWindow>
#include <QQuickItem>
 
#include "qquick3dxrinputmanager_p.h"
 
QT_BEGIN_NAMESPACE
 
QQuick3DXrView::QQuick3DXrView()
    : m_openXRRuntimeInfo(&m_openXRManager)
{
    init();
}
 
QQuick3DXrView::~QQuick3DXrView()
{
    m_inDestructor = true;
}
QQuick3DXrOrigin *QQuick3DXrView::xrOrigin() const
{
    return m_openXRManager.m_xrOrigin;
}
 
QQuick3DSceneEnvironment *QQuick3DXrView::environment() const
{
    return m_openXRManager.m_vrViewport ? m_openXRManager.m_vrViewport->environment() : nullptr;
}
 
QQuick3DViewport *QQuick3DXrView::view3d() const
{
    return m_openXRManager.m_vrViewport;
}
 
bool QQuick3DXrView::passthroughEnabled() const
{
    return m_openXRManager.isPassthroughEnabled();
}
 
QOpenXRRuntimeInfo *QQuick3DXrView::runtimeInfo() const
{
    return &m_openXRRuntimeInfo;
}
 
void QQuick3DXrView::setEnvironment(QQuick3DSceneEnvironment *environment)
{
    if (environment != m_sceneEnvironment)
        m_sceneEnvironment = environment;
 
    if (!m_openXRManager.m_vrViewport)
        return;
 
    auto oldEnvironment = m_openXRManager.m_vrViewport->environment();
    if (oldEnvironment == environment)
        return;
 
    if (oldEnvironment) {
        disconnect(oldEnvironment, &QQuick3DSceneEnvironment::backgroundModeChanged, this, &QQuick3DXrView::handleClearColorChanged);
        disconnect(oldEnvironment, &QQuick3DSceneEnvironment::clearColorChanged, this, &QQuick3DXrView::handleClearColorChanged);
        disconnect(oldEnvironment, &QQuick3DSceneEnvironment::antialiasingModeChanged, this, &QQuick3DXrView::handleAAChanged);
        disconnect(oldEnvironment, &QQuick3DSceneEnvironment::antialiasingQualityChanged, this, &QQuick3DXrView::handleAAChanged);
    }
 
    m_openXRManager.m_vrViewport->setEnvironment(environment);
    handleClearColorChanged();
    handleAAChanged();
 
    if (environment) {
        connect(environment, &QQuick3DSceneEnvironment::backgroundModeChanged, this, &QQuick3DXrView::handleClearColorChanged);
        connect(environment, &QQuick3DSceneEnvironment::clearColorChanged, this, &QQuick3DXrView::handleClearColorChanged);
        connect(environment, &QQuick3DSceneEnvironment::antialiasingModeChanged, this, &QQuick3DXrView::handleAAChanged);
        connect(environment, &QQuick3DSceneEnvironment::antialiasingQualityChanged, this, &QQuick3DXrView::handleAAChanged);
    }
 
    emit environmentChanged(m_openXRManager.m_vrViewport->environment());
}
 
bool QQuick3DXrView::passthroughSupported() const
{
    if (!m_openXRManager.isValid())
        return false;
 
    return m_openXRManager.supportsPassthrough();
}
 
void QQuick3DXrView::setPassthroughEnabled(bool enable)
{
    if (!m_openXRManager.isValid()) {
        qWarning("Attempted to set passthrough mode without a valid XR manager");
        return;
    }
 
    // bail if passthrough is not supported
    if (enable && !m_openXRManager.supportsPassthrough()) {
        qWarning("Enabling Passthrough is not supported.");
        return;
    }
 
    const bool orgPassthroughEnabled = m_openXRManager.isPassthroughEnabled();
    m_openXRManager.setPassthroughEnabled(enable);
 
    if (orgPassthroughEnabled != m_openXRManager.isPassthroughEnabled())
        emit passthroughEnabledChanged();
}
 
QQuick3DXrView::FoveationLevel QQuick3DXrView::fixedFoveation() const
{
    return FoveationLevel(m_openXRManager.getFixedFoveationLevel());
}
 
void QQuick3DXrView::setFixedFoveation(FoveationLevel level)
{
    const auto orgFoviationLevel = m_openXRManager.getFixedFoveationLevel();
    m_openXRManager.setFixedFoveationLevel(QtQuick3DXr::FoveationLevel(level));
    if (orgFoviationLevel != m_openXRManager.getFixedFoveationLevel())
        emit fixedFoveationChanged();
}
 
bool QQuick3DXrView::isQuitOnSessionEndEnabled() const
{
    return m_quitOnSessionEnd;
}
 
void QQuick3DXrView::setQuitOnSessionEnd(bool enable)
{
    if (m_quitOnSessionEnd == enable)
        return;
 
    m_quitOnSessionEnd = enable;
    emit quitOnSessionEndChanged();
}
QQuick3DRenderStats *QQuick3DXrView::renderStats() const
{
    return m_openXRManager.m_vrViewport ? m_openXRManager.m_vrViewport->renderStats() : nullptr;
}
 
void QQuick3DXrView::updateViewportGeometry()
{
    auto contentItem = m_openXRManager.m_quickWindow->contentItem();
    auto viewport = m_openXRManager.m_vrViewport;
    if (viewport->height() != contentItem->height())
        viewport->setHeight(contentItem->height());
    if (viewport->width() != contentItem->width())
        viewport->setWidth(contentItem->width());
    if (viewport->x() != contentItem->x())
        viewport->setX(contentItem->x());
    if (viewport->y() != contentItem->y())
        viewport->setY(contentItem->y());
}
 
void QQuick3DXrView::handleSessionEnded()
{
    emit sessionEnded();
    if (m_quitOnSessionEnd)
        QCoreApplication::quit();
}
 
void QQuick3DXrView::handleClearColorChanged()
{
    auto env = environment();
 
    if (env) {
        if (env->backgroundMode() == QQuick3DSceneEnvironment::Color)
            m_openXRManager.m_quickWindow->setColor(env->clearColor());
        else if (env->backgroundMode() == QQuick3DSceneEnvironment::Transparent)
            m_openXRManager.m_quickWindow->setColor(Qt::transparent);
    }
}
 
void QQuick3DXrView::handleAAChanged()
{
    auto env = environment();
    int samples = 1;
    if (env && env->antialiasingMode() == QQuick3DSceneEnvironment::MSAA) {
        switch (env->antialiasingQuality()) {
        case QQuick3DSceneEnvironment::Medium:
            samples = 2;
            break;
        case QQuick3DSceneEnvironment::High:
            samples = 4;
            break;
        case QQuick3DSceneEnvironment::VeryHigh:
            samples = 8;
            break;
        }
    }
    m_openXRManager.setSamples(samples);
}
 
bool QQuick3DXrView::init()
{
    if (m_isInitialized) {
        qWarning("Already initialized!");
        return false;
    }
 
    if (!m_openXRManager.isReady() && !m_openXRManager.initialize()) {
        qDebug() << "Waiting for XR platform to be initialized...";
        connect(&m_openXRManager, &QQuick3DXrManager::initialized, this, &QQuick3DXrView::init, Qt::UniqueConnection);
        return false;
    }
 
    if (!m_openXRManager.initialize()) {
        QString errorString = m_openXRManager.errorString();
        if (errorString.isEmpty())
            errorString = tr("Failed to initialize XR platform");
        qWarning("\n%s\n", qPrintable(errorString));
        QMetaObject::invokeMethod(this, "initializeFailed", Qt::QueuedConnection, errorString);
        return false;
    }
 
    // Create View3D
    QSSG_CHECK_X(m_openXRManager.m_vrViewport == nullptr, "View3D already created!");
    auto viewport = new QQuick3DViewport();
    viewport->setRenderMode(QQuick3DViewport::Underlay);
    auto contentItem = m_openXRManager.m_quickWindow->contentItem();
    viewport->setParentItem(contentItem);
    m_openXRManager.m_vrViewport = viewport;
    viewport->setImportScene(this);
 
    contentItem->forceActiveFocus(Qt::MouseFocusReason);
 
    connect(contentItem, &QQuickItem::heightChanged, this, &QQuick3DXrView::updateViewportGeometry);
    connect(contentItem, &QQuickItem::widthChanged, this, &QQuick3DXrView::updateViewportGeometry);
    connect(contentItem, &QQuickItem::xChanged, this, &QQuick3DXrView::updateViewportGeometry);
    connect(contentItem, &QQuickItem::yChanged, this, &QQuick3DXrView::updateViewportGeometry);
 
    QQuick3DSceneEnvironment *env = environment();
    if (env) {
        connect(env, &QQuick3DSceneEnvironment::backgroundModeChanged, this, &QQuick3DXrView::handleClearColorChanged);
        connect(env, &QQuick3DSceneEnvironment::clearColorChanged, this, &QQuick3DXrView::handleClearColorChanged);
        connect(env, &QQuick3DSceneEnvironment::antialiasingModeChanged, this, &QQuick3DXrView::handleAAChanged);
        connect(env, &QQuick3DSceneEnvironment::antialiasingQualityChanged, this, &QQuick3DXrView::handleAAChanged);
    }
 
    connect(&m_openXRManager, &QQuick3DXrManager::sessionEnded, this, &QQuick3DXrView::handleSessionEnded);
    connect(&m_openXRManager, &QQuick3DXrManager::frameReady, this, &QQuick3DXrView::frameReady);
    connect(&m_openXRManager, &QQuick3DXrManager::referenceSpaceChanged, this, &QQuick3DXrView::referenceSpaceChanged);
 
    // NOTE: If we're called async we need to make sure the environment etc. is set again
    setEnvironment(m_sceneEnvironment);
 
    m_openXRManager.update();
 
    m_isInitialized = true;
 
    return m_isInitialized;
}
 
QQuick3DPickResult QQuick3DXrView::rayPick(const QVector3D &origin, const QVector3D &direction) const
{
    return m_openXRManager.m_vrViewport->rayPick(origin, direction);
}
 
QList<QQuick3DPickResult> QQuick3DXrView::rayPickAll(const QVector3D &origin, const QVector3D &direction) const
{
    return m_openXRManager.m_vrViewport->rayPickAll(origin, direction);
}
 
void QQuick3DXrView::setTouchpoint(QQuickItem *target, const QPointF &position, int pointId, bool pressed)
{
    view3d()->setTouchpoint(target, position, pointId, pressed);
}
 
// TODO: Maybe do a proper QQuick3DXrViewPrivate instead
struct QQuick3DXrView::XrTouchState
{
    QHash<int, QQuick3DXrItem::TouchState> points;
};
 
QVector3D QQuick3DXrView::processTouch(const QVector3D &pos, int pointId)
{
    QVector3D offset;
    if (m_xrItems.isEmpty())
        return offset;
 
    if (!m_touchState)
        m_touchState = new XrTouchState;
    QQuick3DXrItem::TouchState &state = m_touchState->points[pointId];
    state.pointId = pointId; // in case it's a new point that was default-constructed
 
    auto *prevTarget = state.target;
    bool grabbed = false;
    if (prevTarget) {
        grabbed = prevTarget->handleVirtualTouch(this, pos, &state, &offset);
    }
    for (auto *item : std::as_const(m_xrItems)) {
        if (grabbed)
            break;
        if (item != prevTarget)
            grabbed = item->handleVirtualTouch(this, pos, &state, &offset);
    }
 
    return offset;
}
 
#define Q_TOUCHPOINT_STATE(prop) { QStringLiteral(#prop), QVariant::fromValue(it->prop) }
QVariantMap QQuick3DXrView::touchpointState(int pointId) const
{
    auto constexpr end = QHash<int, QQuick3DXrItem::TouchState>::const_iterator();
    auto it = m_touchState ? m_touchState->points.constFind(pointId) : end;
 
    if (it == end)
        return { { QStringLiteral("grabbed"), QVariant::fromValue(false) } };
 
    return { Q_TOUCHPOINT_STATE(target),
             Q_TOUCHPOINT_STATE(grabbed),
             Q_TOUCHPOINT_STATE(pressed),
             Q_TOUCHPOINT_STATE(cursorPos),
             Q_TOUCHPOINT_STATE(touchDistance) };
}
#undef Q_TOUCHPOINT_STATE
 
QQuick3DXrView::ReferenceSpace QQuick3DXrView::referenceSpace() const
{
    return ReferenceSpace(m_openXRManager.getReferenceSpace());
}
 
void QQuick3DXrView::setReferenceSpace(ReferenceSpace newReferenceSpace)
{
    m_openXRManager.setReferenceSpace(QtQuick3DXr::ReferenceSpace(newReferenceSpace));
}
 
bool QQuick3DXrView::depthSubmissionEnabled() const
{
    if (!m_openXRManager.isValid()) {
        qWarning("Attempted to check depth submission mode without a valid XR manager");
        return false;
    }
 
    return m_openXRManager.isDepthSubmissionEnabled();
}
 
bool QQuick3DXrView::isMultiViewRenderingSupported() const
{
    if (!m_openXRManager.isValid())
        return false;
 
    return m_openXRManager.isMultiViewRenderingSupported();
}
 
bool QQuick3DXrView::multiviewRenderingEnabled() const
{
    if (!m_openXRManager.isValid())
        return false;
 
    return m_openXRManager.isMultiViewRenderingEnabled();
}
 
void QQuick3DXrView::registerXrItem(QQuick3DXrItem *newXrItem)
{
    m_xrItems.append(newXrItem);
}
 
void QQuick3DXrView::unregisterXrItem(QQuick3DXrItem *xrItem)
{
    m_xrItems.removeAll(xrItem);
}
 
void QQuick3DXrView::setDepthSubmissionEnabled(bool enable)
{
    if (!m_openXRManager.isValid()) {
        qWarning("Attempted to set depth submission mode without a valid XR manager");
        return;
    }
 
    const bool orgDepthSubmission = m_openXRManager.isDepthSubmissionEnabled();
 
    m_openXRManager.setDepthSubmissionEnabled(enable);
 
    if (orgDepthSubmission != m_openXRManager.isDepthSubmissionEnabled())
        emit depthSubmissionEnabledChanged();
}
 
void QQuick3DXrView::setMultiviewRenderingEnabled(bool enable)
{
    if (!m_openXRManager.isValid()) {
        qWarning("Attempted to set multiview rendering mode without having m_openXRManager initialized");
        return;
    }
 
    const bool orgMultiView = m_openXRManager.isMultiViewRenderingEnabled();
    m_openXRManager.setMultiviewRenderingEnabled(enable);
 
    if (orgMultiView != m_openXRManager.isMultiViewRenderingEnabled())
        emit multiviewRenderingEnabledChanged();
}
 
QT_END_NAMESPACE