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
// Qt-Security score:significant reason:default
 
 
#include "qtquick3dxrglobal_p.h"
#include "qquick3dxritem_p.h"
#include "qquick3dxrview_p.h"
#include <QQuickWindow>
#include <QQuickItem>
#include <QLoggingCategory>
 
#include <QtQuick3DUtils/private/qssgassert_p.h>
 
#include "qquick3dxrinputmanager_p.h"
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(lcQuick3DXr);
 
/*!
    \qmltype XrView
    \inherits Node
    \inqmlmodule QtQuick3D.Xr
    \brief Sets up the view for an Xr application.
 
    An XrView sets up the view for an XR application.
    The following snippet is from the \l{\qxr Simple Example} and shows
    how to use the type.
 
    \quotefromfile xr_simple/main.qml
    \printto XrOrigin
 
    \section1 Platform notes
 
    \section2 Meta Quest Devices
 
    To \l{XrView::passthroughEnabled}{enable passthrough} you need to add the
    following permisson your app's \c AndroidManifest.xml file:
 
    \badcode
    <uses-feature android:name="com.oculus.feature.PASSTHROUGH" android:required="false"/>
    \endcode
 
*/
 
QQuick3DXrView::QQuick3DXrView()
    : m_xrRuntimeInfo(&m_xrManager)
{
    init();
}
 
QQuick3DXrView::~QQuick3DXrView()
{
    m_inDestructor = true;
}
 
/*!
    \qmlproperty XrOrigin QtQuick3D.Xr::XrView::xrOrigin
    \brief Holds the active XR origin.
 
    The XR origin is the point in the scene that is considered the origin of the
    XR coordinate system. The XR origin is used to position tracked objects like
    the camera and controllers in the scene. An application can have multiple XrOrigins
    but only one can be active at a time.
 
    \note This property must be set for the scene to be rendered in XR.
 
    \sa XrOrigin
*/
 
QQuick3DXrOrigin *QQuick3DXrView::xrOrigin() const
{
    return m_xrOrigin;
}
 
/*!
    \qmlproperty SceneEnvironment QtQuick3D.Xr::XrView::environment
    \summary Holds the SceneEnvironment for the XR view.
*/
 
QQuick3DSceneEnvironment *QQuick3DXrView::environment() const
{
    return m_xrManager.m_vrViewport ? m_xrManager.m_vrViewport->environment() : nullptr;
}
 
QQuick3DViewport *QQuick3DXrView::view3d() const
{
    return m_xrManager.m_vrViewport;
}
 
namespace {
 
struct ClosestPointResult
{
    bool grab = false;
    bool inside = false;
    float distance = 0;
    QVector3D position;
    QVector3D scenePosition;
    QVector3D normal;
    QVector3D sceneNormal;
    QVector2D uvPosition;
    QPointF point2D;
    QQuickItem *quickItem = nullptr;
};
 
// We can assume that the transform for an XrItem always has uniform scaling,
// so the closest point in local space is also closest in scene space
// We're not interested in hits from the side; but we probably want a margin around the item
static ClosestPointResult closestPointOnXrItem(const QQuick3DXrItem *xrItem, const QVector3D &pos, const float margin = 0)
{
    const auto mappedPos = xrItem->mapPositionFromScene(pos);
    const qreal width = xrItem->width();
    const qreal height = xrItem->height();
 
    const float x = mappedPos.x();
    const float y = mappedPos.y();
    const float z = mappedPos.z();
 
    const float x1 = 0;
    const float y1 = -height;
    const float x2 = width;
    const float y2 = 0;
 
    const bool insideMargin = x1 - margin <= x && x <= x2 + margin && y1 - margin <= y && y <= y2 + margin;
    if (!insideMargin)
        return {};
    const bool inside = x1 <= x && x <= x2 && y1 <= y && y <= y2 && z <= 0;
 
    const float distance = mappedPos.z();
 
    const QVector3D position{ mappedPos.x(), mappedPos.y(), 0 };
    const QVector3D scenePosition = xrItem->mapPositionToScene(position);
    const QVector3D normal{ 0, 0, 1 };
    const QVector3D sceneNormal = xrItem->mapDirectionToScene(normal);
 
    return {
        true,
        inside,
        distance,
        position,
        scenePosition,
        normal,
        sceneNormal,
        QVector2D{},
        QPointF{mappedPos.x(), -mappedPos.y()},
        xrItem->contentItem()
    };
}
 
 
static ClosestPointResult closestPointOnModel(QQuick3DXrView *view, QQuick3DModel *model, const QVector3D &pos, const float radius = 0)
{
    auto pickResult = view->closestPointPick(pos, radius, model);
    if (pickResult.objectHit() != model)
        return {};
 
    const QVector3D offset = pos - pickResult.scenePosition();
 
    const float signedDistance = QVector3D::dotProduct(offset, pickResult.sceneNormal());
    const bool inside = signedDistance < 0;
 
    QPointF quickPoint;
    QQuickItem *quickItem = pickResult.itemHit();
    auto uv = pickResult.uvPosition();
    if (quickItem) {
        quickPoint = QPointF(quickItem->x() + uv.x() * quickItem->width(),
                             quickItem->y() - uv.y() * quickItem->height() + quickItem->height());
    }
    return {
        true,
        inside,
        signedDistance,
        pickResult.position(),
        pickResult.scenePosition(),
        pickResult.normal(),
        pickResult.sceneNormal().normalized(), //#### TODO: fix sceneNormal
        uv,
        quickPoint,
        quickItem
    };
}
 
 
static inline ClosestPointResult closestPointOnItem(QQuick3DXrView *view, QQuick3DXrView::TouchTarget target, const QVector3D &pos, const float margin)
{
    if (auto *asXrItem = std::get_if<QQuick3DXrItem*>(&target))
        return closestPointOnXrItem(*asXrItem, pos, margin);
    if (auto *asModel =std::get_if<QQuick3DModel*>(&target))
        return closestPointOnModel(view, *asModel, pos, margin);
    return {};
}
 
static inline void sendTouch(QQuick3DXrView *view, const ClosestPointResult &point, int pointId, bool active)
{
    if (point.quickItem)
        view->setTouchpoint(point.quickItem, point.point2D, pointId, active);
}
 
} // anonymous namespace
 
 
// Sends appropriate touch events.
// Updates the touchState and returns true if this target grabs the touch point.
// touchState is input/output, and input contains the previous state if touchState->grabbed is true
bool QQuick3DXrView::handleVirtualTouch(TouchTarget target, const QVector3D &pos, TouchState *touchState, QVector3D *offset)
{
    constexpr qreal sideMargin = 10;
    constexpr qreal hoverHeight = 10;
    constexpr qreal cancelDepth = 50;
 
    constexpr qreal releaseHeight = 2; // Minimum vertical movement to count as a press/release when below
    constexpr qreal releaseHeightSquared = releaseHeight * releaseHeight;
    constexpr qreal smallDistance = 0.5; // Any movement shorter than this distance is insignificant
    constexpr qreal sidewaysMax = 3; // Any horizontal movement larger than this distance means this is never going to be a press/release below the surface
    constexpr qreal sidewaysMaxSquared = sidewaysMax * sidewaysMax;
    constexpr qreal releaseSpeed = 5.0 / 1000; // Minimum vertical speed (cm/ms) to classify as a press/release
    constexpr int interval = 100; // Time between checks to determine insignificant movement
 
    const bool wasGrabbed = touchState->grabbed;
    const bool wasPressed = touchState->pressed;
    const qreal wasInside = wasGrabbed && touchState->touchDepth < 0.0;
 
    const QVector3D oldScenePos = touchState->previous;
    const QVector3D oldSceneNormal = touchState->normal;
 
    // Note: We always grab the closest point on the surface. This means that for thin and flat models,
    // we will snap to the backside, which is probably not what the user wants. If this turns out to
    // be a problem when we evaluate this, we can change this algorithm to ignore points that have a
    // normal vector pointing the wrong way.
 
    auto closest = closestPointOnItem(this, target, pos, sideMargin);
 
    bool grab = false;
    bool pressed = false;
 
    bool resetTimer = false;
    float z = closest.distance; // assumes signed distance
 
    if (wasGrabbed) {
        // maintain grab as long as we don't move outside
        grab = closest.grab && z > -cancelDepth && z < hoverHeight;
 
        // if grab is false, we're definitely not pressed
        if (grab) {
            // We do a press/release transition if we
            // 1. Moved between outside and inside
            // OR
            // 2. Had a fast enough vertical movement below the surface, without a horizontal movement
 
            if (wasInside && closest.inside) {
                // We stayed inside; let's see if we've had a strong vertical movement
                int duration = touchState->timer.elapsed();
                pressed = wasPressed; // We maintain pressed state unless proven otherwise
                const QVector3D movement = pos - oldScenePos; // Movement is positive away from the surface
                const qreal verticalDistance = QVector3D::dotProduct(movement, oldSceneNormal);
                const qreal verticalDistanceSquared = verticalDistance * verticalDistance;
                const qreal horizontalDistanceSquared = movement.lengthSquared() - verticalDistance*verticalDistance;
 
                if (verticalDistanceSquared >= releaseHeightSquared && horizontalDistanceSquared < releaseHeightSquared) {
                    // We have moved a significant distance vertically, without moving horizontally,
                    // so this is a press/release (no-op if it's a press when already pressed)
                    pressed = verticalDistance < 0;
                    resetTimer = true;
                } else if (duration >= interval) {
                    // Check to see if this can become a press/release in the future
                    if (horizontalDistanceSquared >= sidewaysMaxSquared) {
                        // This is sideways motion, and not a press/release
                        resetTimer = true;
                    } else if (pressed ? verticalDistance < smallDistance : verticalDistance > -smallDistance ) {
                        // we haven't had a significant vertical movement in the right direction (positive when pressed),
                        // so this is not the start of a press/release
                        resetTimer = true;
                    } else {
                        // If the speed is high enough, this can still become a press/release in the future
                        // (If we're pressed, we're looking for positive speed)
                        const qreal verticalSpeed = verticalDistance / duration;
                        const bool sufficientSpeed = pressed ? verticalSpeed > releaseSpeed : verticalSpeed < -releaseSpeed;
                        resetTimer = !sufficientSpeed;
                    }
                }
            } else {
                // Either hover or move between outside and inside
                pressed = closest.inside; // closest.inside is only true if z < 0, so we don't have to check for that
                resetTimer = true;
            }
        }
    } else {
        // only grab if hovering, not if inside: we only want to register a press
        // coming from a hover, not when approaching from below
        grab = closest.grab && closest.distance > 0 && closest.distance < hoverHeight;
        resetTimer = true;
    }
 
    if (grab) {
        if (offset && z < 0)
            *offset = closest.scenePosition - pos;
        touchState->grabbed = true;
        touchState->target = target;
        touchState->touchDistance = qMax(z, 0.0); // Documented to be 0 when pressed
        touchState->touchDepth = z;
        touchState->pressed = pressed;
        touchState->cursorPos = closest.point2D;
        touchState->surfacePoint = closest.scenePosition;
        touchState->normal = closest.sceneNormal;
        touchState->uvPosition = closest.uvPosition;
        if (resetTimer) {
            touchState->previous = pos;
            touchState->timer.start();
        }
 
        sendTouch(this, closest, touchState->pointId, pressed);
        return true;
    }
 
    if (wasGrabbed) {
        touchState->grabbed = false;
        touchState->pressed = false;
        touchState->target = {};
        sendTouch(this, closest, touchState->pointId, false);
    }
 
    return false;
}
 
/*!
    \qmlproperty bool QtQuick3D.Xr::XrView::passthroughEnabled
    \summary Holds whether passthrough is enabled for the XR view.
*/
bool QQuick3DXrView::passthroughEnabled() const
{
    return m_xrManager.isPassthroughEnabled();
}
 
/*!
    \qmlproperty QQuick3DXrRuntimeInfo QtQuick3D.Xr::XrView::runtimeInfo
    \summary Provides information about the XR runtime for the XR view.
*/
 
QQuick3DXrRuntimeInfo *QQuick3DXrView::runtimeInfo() const
{
    return &m_xrRuntimeInfo;
}
 
void QQuick3DXrView::setEnvironment(QQuick3DSceneEnvironment *environment)
{
    QQuick3DViewport *view = m_xrManager.m_vrViewport;
 
    // If the view is not created yet, we can't set the environment which means we need to
    // set it again once the view is created...
    if (!view) {
        m_pendingSceneEnvironment = environment;
        return;
    }
 
    auto oldEnvironment = view->environment();
    if (oldEnvironment == environment)
        return;
 
    if (oldEnvironment)
        disconnect(oldEnvironment);
 
    view->setEnvironment(environment);
 
    // The view will always have an environment, setting the environment to null will just mean the default environment
    // is used. So querying the environment from the view is always valid (and we should do it here to make sure we're
    // in sync with the view).
    environment = view->environment();
 
    handleClearColorChanged();
    handleAAChanged();
 
    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(environment);
}
 
/*!
    \qmlproperty bool QtQuick3D.Xr::XrView::passthroughSupported
    \summary Indicates whether passthrough is supported for the XR view.
*/
 
bool QQuick3DXrView::passthroughSupported() const
{
    if (!m_xrManager.isValid())
        return false;
 
    return m_xrManager.supportsPassthrough();
}
 
void QQuick3DXrView::setPassthroughEnabled(bool enable)
{
    if (!m_xrManager.isValid()) {
        qWarning("Attempted to set passthrough mode without a valid XR manager");
        return;
    }
 
    const bool orgPassthroughEnabled = m_xrManager.isPassthroughEnabled();
    if (!m_xrManager.setPassthroughEnabled(enable)) {
        if (enable)
            qWarning("Enabling passthrough is not supported.");
        else
            qWarning("Disabling passthrough is not supported.");
        return;
    }
 
    if (orgPassthroughEnabled != m_xrManager.isPassthroughEnabled())
        emit passthroughEnabledChanged();
}
 
/*!
    \qmlproperty enumeration QtQuick3D.Xr::XrView::fixedFoveation
    \brief Controls the level of fixed foveated rendering for the XrView.
    \default XrView.HighFoveation
 
    Foveated rendering reduces GPU load by reducing image quality (resolution)
    in areas where the difference is less perceptible to the eye. With fixed
    foveated rendering, the areas with reduced visual fidelity are fixed and do
    not change. On some platforms, there is no concept of fixed foveated
    rendering or control over it. For example, VisionOS-based devices perform
    dynamic, eye-tracked foveation; thus, the value of this property is
    ignored in practice. Other devices, such as the Meta Quest 3, only
    support fixed foveation, which makes this property relevant.
 
    The value can be one of:
    \value XrView.NoFoveation 0, no foveation.
    \value XrView.LowFoveation 1, low foveation.
    \value XrView.MediumFoveation 2, medium foveation.
    \value XrView.HighFoveation 3, high foveation.
 
    Where supported, the default is \c HighFoveation. Therefore, changing this
    value in applications should be rarely needed in practice.
*/
 
QQuick3DXrView::FoveationLevel QQuick3DXrView::fixedFoveation() const
{
    return FoveationLevel(m_xrManager.getFixedFoveationLevel());
}
 
void QQuick3DXrView::setFixedFoveation(FoveationLevel level)
{
    const auto orgFoviationLevel = m_xrManager.getFixedFoveationLevel();
    m_xrManager.setFixedFoveationLevel(QtQuick3DXr::FoveationLevel(level));
    if (orgFoviationLevel != m_xrManager.getFixedFoveationLevel())
        emit fixedFoveationChanged();
}
 
/*!
    \qmlproperty bool QtQuick3D.Xr::XrView::isQuitOnSessionEndEnabled
    \brief Holds whether the application should quit when the XR session ends.
*/
 
bool QQuick3DXrView::isQuitOnSessionEndEnabled() const
{
    return m_quitOnSessionEnd;
}
 
void QQuick3DXrView::setQuitOnSessionEnd(bool enable)
{
    if (m_quitOnSessionEnd == enable)
        return;
 
    m_quitOnSessionEnd = enable;
    emit quitOnSessionEndChanged();
}
/*!
    \qmlproperty RenderStats QtQuick3D.Xr::XrView::renderStats
    \summary Holds rendering statistics for the XR view.
*/
 
QQuick3DRenderStats *QQuick3DXrView::renderStats() const
{
    return m_xrManager.m_vrViewport ? m_xrManager.m_vrViewport->renderStats() : nullptr;
}
 
void QQuick3DXrView::updateViewportGeometry()
{
    auto contentItem = m_xrManager.m_quickWindow->contentItem();
    auto viewport = m_xrManager.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_xrManager.m_quickWindow->setColor(env->clearColor());
        else if (env->backgroundMode() == QQuick3DSceneEnvironment::Transparent)
            m_xrManager.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_xrManager.setSamples(samples);
}
 
bool QQuick3DXrView::init()
{
    if (m_isInitialized) {
        qWarning("Already initialized!");
        return false;
    }
 
    connect(&m_xrManager, &QQuick3DXrManager::sessionEnded, this, &QQuick3DXrView::handleSessionEnded);
    connect(&m_xrManager, &QQuick3DXrManager::frameReady, this, &QQuick3DXrView::frameReady);
    connect(&m_xrManager, &QQuick3DXrManager::referenceSpaceChanged, this, &QQuick3DXrView::referenceSpaceChanged);
    connect(&m_xrManager, &QQuick3DXrManager::multiViewRenderingEnabledChanged, this, &QQuick3DXrView::multiViewRenderingEnabledChanged);
    connect(&m_xrManager, &QQuick3DXrManager::initialized, this, &QQuick3DXrView::init, Qt::UniqueConnection);
 
    if (!m_xrManager.isReady() && !m_xrManager.initialize()) {
        qCDebug(lcQuick3DXr, "Waiting for XR platform to be initialized");
 
        return false;
    }
 
    if (!m_xrManager.initialize()) {
        QString errorString = m_xrManager.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_xrManager.m_vrViewport == nullptr, "View3D already created!");
    auto viewport = new QQuick3DViewport(QQuick3DViewport::PrivateInstanceType::XrViewInstance);
    viewport->setRenderMode(QQuick3DViewport::Underlay);
    auto contentItem = m_xrManager.m_quickWindow->contentItem();
    viewport->setParentItem(contentItem);
    m_xrManager.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);
    }
 
    // NOTE: If we've called async, we need to make sure the environment, etc. is set again
    setEnvironment(m_pendingSceneEnvironment);
    m_pendingSceneEnvironment = nullptr;
 
    m_xrManager.update();
 
    m_isInitialized = true;
 
    return m_isInitialized;
}
 
/*!
    \qmlmethod pickResult XrView::rayPick(vector3d origin, vector3d direction)
 
    This method will \e shoot a ray into the scene starting at \a origin and in
    \a direction and return information about the nearest intersection with an
    object in the scene.
 
    For example, pass the position and forward vector of
    any object in a scene to see what object is in front of an item. This
    makes it possible to do picking from any point in the scene.
 */
QQuick3DPickResult QQuick3DXrView::rayPick(const QVector3D &origin, const QVector3D &direction) const
{
    if (!m_xrManager.m_vrViewport)
        return QQuick3DPickResult();
 
    return m_xrManager.m_vrViewport->rayPick(origin, direction);
}
 
/*!
    \qmlmethod List<pickResult> XrView::rayPickAll(vector3d origin, vector3d direction)
 
    This method will \e shoot a ray into the scene starting at \a origin and in
    \a direction and return a list of information about the nearest intersections with
    objects in the scene.
    The list is presorted by distance from the origin along the direction
    vector with the nearest intersections appearing first and the furthest
    appearing last.
 
    This can, for instance, be called with the position and forward vector of
    any object in a scene to see what objects are in front of an item. This
    makes it possible to do picking from any point in the scene.
 */
QList<QQuick3DPickResult> QQuick3DXrView::rayPickAll(const QVector3D &origin, const QVector3D &direction) const
{
    if (!m_xrManager.m_vrViewport)
        return {};
 
    return m_xrManager.m_vrViewport->rayPickAll(origin, direction);
}
 
/*!
    \qmlmethod pickResult XrView::rayPick(vector3d origin, vector3d direction, Model model)
 
    This method will "shoot" a ray into the scene starting at \a origin and in
    \a direction and return information about the intersection between the ray and the specified \a model.
 
    \since 6.11
*/
QQuick3DPickResult QQuick3DXrView::rayPick(const QVector3D &origin, const QVector3D &direction, QQuick3DModel *model) const
{
    if (!m_xrManager.m_vrViewport)
        return QQuick3DPickResult();
 
    return m_xrManager.m_vrViewport->rayPick(origin, direction, model);
}
 
/*!
    \qmlmethod pickResult XrView::closestPointPick(vector3d origin, float radius, Model model)
 
    This method will find the point on the surface of \a model that is nearest to \a origin, within a distance of
    \a radius. If \a model is \c null, the closest object within \a radius will be found.
 
    If no such object exists, \c null is returned.
 
    \since 6.11
*/
QQuick3DPickResult QQuick3DXrView::closestPointPick(const QVector3D &origin, float radius, QQuick3DModel *model) const
{
    if (!m_xrManager.m_vrViewport)
        return QQuick3DPickResult();
 
    return m_xrManager.m_vrViewport->closestPointPick(origin, radius, model);
}
 
/*!
    \qmlmethod XrView::setTouchpoint(Item target, point position, int pointId, bool pressed)
 
    Sends a synthetic touch event to \a target, moving the touch point with ID \a pointId to \a position,
    with \a pressed determining if the point is pressed.
    Also sends the appropriate touch release event if \a pointId was previously active on a different
    item.
*/
 
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::XrTouchStates
{
    QHash<int, TouchState> points;
};
 
/*!
    \qmlmethod vector3d XrView::processTouch(vector3d position, int pointId)
 
    This method will search for an XrItem, or a Model with a
    \l{Texture::sourceItem}{sourceItem texture}, near \a position and send a
    virtual touch event with touch point ID \a pointId if \a position maps to
    a point on the surface.
 
    The return value is the offset between \a position and the touched point on
    the surface. This can be used to prevent a hand model from passing through
    an XrItem.
 
    \sa XrHandModel
 
*/
 
QVector3D QQuick3DXrView::processTouch(const QVector3D &pos, int pointId)
{
    QVector3D offset;
 
    if (!m_touchStates)
        m_touchStates = new XrTouchStates;
    TouchState &state = m_touchStates->points[pointId];
    state.pointId = pointId; // in case it's a new point that was default-constructed
 
    bool grabbed = false;
    const bool prevTarget = !std::holds_alternative<std::monostate>(state.target);
    if (prevTarget) {
        grabbed = handleVirtualTouch(state.target, pos, &state, &offset);
    }
    if (!grabbed) {
        for (auto *item : std::as_const(m_xrItems)) {
            // For simplicity, try handleVirtualTouch on target again, even if we know it's not going to be different
            if (item->visible())
                grabbed = handleVirtualTouch(item, pos, &state, &offset);
            if (grabbed)
                break;
        }
    }
 
    if (!grabbed) {
        constexpr float pickRadius = 10.0;
        auto pickResult = closestPointPick(pos, pickRadius);
        //qDebug() << "pick result" << pickResult.objectHit() << pickResult.position();
        if (QQuick3DModel *obj = pickResult.objectHit())
            grabbed = handleVirtualTouch(obj, pos, &state, &offset); // will call closestPointPick again, but this makes the code simpler
    }
 
    return offset;
}
 
/*!
    \qmlmethod object XrView::touchpointState(int pointId)
 
    This method returns the state of the touch point with ID \a pointId.
    The state is represented by a map from property names to values:
 
    \table
    \header
    \li Key
    \li Type
    \li Description
    \row
    \li \c grabbed
    \li \c bool
    \li Is the point grabbed by an item? If \c false, all other values are \c undefined.
    \row
    \li \c target
    \li XrItem
    \li The item that is grabbing the touch point, or \c null if there is no XrItem.
    \row
    \li \c pressed
    \li \c bool
    \li Is the touch point pressed?
    \row
    \li \c cursorPos
    \li \c point
    \li The 2D position of the touch point within \c target
    \row
    \li \c touchDistance
    \li \c real
    \li The distance from the plane to the touch point. It will be \c 0 if \c pressed is \c true.
    \row
    \li \c surfacePoint
    \li \c vector3d
    \li The position of the touch point in scene space. [since 6.11]
    \row
    \li \c normal
    \li \c vector3d
    \li The normal vector at the touch point in scene space. [since 6.11]
    \row
    \li \c uvPosition
    \li \c vector2d
    \li The UV position at the touch point. [since 6.11]
    \row
    \li \c model
    \li \c Model
    \li The model that is grabbing the touch point, or \c null if there is no Model. [since 6.11]
    \endtable
 */
 
#define Q_TOUCHPOINT_STATE(prop) { QStringLiteral(#prop), QVariant::fromValue(it->prop) }
QVariantMap QQuick3DXrView::touchpointState(int pointId) const
{
    auto constexpr end = QHash<int, TouchState>::const_iterator();
    auto it = m_touchStates ? m_touchStates->points.constFind(pointId) : end;
 
    if (it == end)
        return { { QStringLiteral("grabbed"), QVariant::fromValue(false) } };
    auto *itemPointer = std::get_if<QQuick3DXrItem *>(&it->target);
    QQuick3DXrItem *xrItem = itemPointer ? *itemPointer : nullptr;
    auto *modelPointer = std::get_if<QQuick3DModel *>(&it->target);
    QQuick3DModel *model = modelPointer ? *modelPointer : nullptr;
    return { { QStringLiteral("target"), QVariant::fromValue(xrItem) },
             Q_TOUCHPOINT_STATE(grabbed),
             Q_TOUCHPOINT_STATE(pressed),
             Q_TOUCHPOINT_STATE(cursorPos),
             Q_TOUCHPOINT_STATE(surfacePoint),
             Q_TOUCHPOINT_STATE(normal),
             Q_TOUCHPOINT_STATE(touchDistance),
             Q_TOUCHPOINT_STATE(uvPosition),
             { QStringLiteral("model"), QVariant::fromValue(model) }};
}
#undef Q_TOUCHPOINT_STATE
 
/*!
    \qmlproperty enumeration QtQuick3D.Xr::XrView::referenceSpace
    \brief Gets or sets the reference space for the XR view.
 
     It can be one of:
     \value XrView.ReferenceSpaceUnknown
     \value XrView.ReferenceSpaceLocal Origin is at the default view position (typically defined by a "reset view" operation).
     \value XrView.ReferenceSpaceStage Origin is at floor height in the center of the user's defined area.
     \value XrView.ReferenceSpaceLocalFloor Origin is at floor height, below the default view position.
 
    \c ReferenceSpaceLocal is mainly useful for seated applications where the content is not positioned
    relative to the floor, for example floating menus. The content will move when the user resets the view.
 
    \c ReferenceSpaceStage is mainly useful for room-scale applications where the user will move freely within the
    playing area. The content will not move when the user resets the view.
 
    \c ReferenceSpaceLocalFloor is mainly useful for stationary applications (seated or standing) where the content is
    positioned relative to the floor. The content will move when the user resets the view.
 
    \default XrView.ReferenceSpaceLocal
*/
 
QQuick3DXrView::ReferenceSpace QQuick3DXrView::referenceSpace() const
{
    return ReferenceSpace(m_xrManager.getReferenceSpace());
}
 
void QQuick3DXrView::setReferenceSpace(ReferenceSpace newReferenceSpace)
{
    m_xrManager.setReferenceSpace(QtQuick3DXr::ReferenceSpace(newReferenceSpace));
}
 
bool QQuick3DXrView::depthSubmissionEnabled() const
{
    if (!m_xrManager.isValid()) {
        qWarning("Attempted to check depth submission mode without a valid XR manager");
        return false;
    }
 
    return m_xrManager.isDepthSubmissionEnabled();
}
 
/*!
    \qmlproperty bool QtQuick3D.Xr::XrView::multiViewRenderingSupported
 
    \brief This read-only property reports the availability of \l{Multiview Rendering}.
 
    \sa multiViewRenderingEnabled
 */
bool QQuick3DXrView::isMultiViewRenderingSupported() const
{
    if (!m_xrManager.isValid())
        return false;
 
    return m_xrManager.isMultiViewRenderingSupported();
}
 
/*!
    \qmlproperty bool QtQuick3D.Xr::XrView::multiViewRenderingEnabled
 
    \brief This is a read-only property that reports if \l{Multiview Rendering} is enabled for the XR view.
 
    \default true
 
    This property tells you if multiview rendering is actually in use at run time.
    When not supported, the value will flip back to \c false.
 
    Enabling multiview rendering is recommended. It can improve performance and reduce
    CPU and GPU power usage. It defaults to disabled to ensure maximum
    compatibility. Developers are encouraged to verify that their application
    renders as expected with multiViewRenderingEnabled set to \c true and then
    leave it set afterward.
 
    \note Certain Qt Quick and Quick 3D features that involve shader code that is
    provided by the application may need this code to be modified to be multiview
    compatible. Examples of these are custom 2D and 3D materials and
    postprocessing effects. The \l {Multiview Rendering} documentation provides
    more information on this and how to disable multiview rendering.
 
    \sa multiViewRenderingSupported {Multiview Rendering}
*/
bool QQuick3DXrView::multiViewRenderingEnabled() const
{
    if (!m_xrManager.isValid())
        return false;
 
    return m_xrManager.isMultiViewRenderingEnabled();
}
 
void QQuick3DXrView::registerXrItem(QQuick3DXrItem *newXrItem)
{
    m_xrItems.append(newXrItem);
}
 
void QQuick3DXrView::unregisterXrItem(QQuick3DXrItem *xrItem)
{
    m_xrItems.removeAll(xrItem);
}
 
/*!
    \qmlproperty bool QtQuick3D.Xr::XrView::depthSubmissionEnabled
    \brief Controls whether submitting the depth buffer to the XR compositor
    is enabled.
    \default false
 
    By default, the depth buffer used by the 3D scene in the XrView is not exposed
    to the XR compositor. However, in some platforms, depth submission is implicit
    and cannot be disabled or controlled by the application. An example of this is
    VisionOS. Changing this property has no effect on those platforms. Elsewhere,
    with OpenXR in particular, support depends on the OpenXR implementation used
    at run time.
 
    It is always safe to set depthSubmissionEnabled to \c true. It will just have
    no effect when not supported by the underlying stack. To be sure, you can
    inspect the debug output to see if depth submission is in use.
    Submitting the depth buffer may improve reprojections that the XR compositor
    may perform. Reprojection could happen, for example, when the system cannot
    maintain the target frame rate and thus has to resort to predicting frame
    contents to improve and stabilize the user's perception of the
    scene and reduce possible motion sickness. However, the application and
    Qt have no control over data usage. It could also happen that
    submitting depth data has no practical effects and is ignored by the
    underlying XR runtime and compositor.
 
    In practice, submitting the depth buffer implies rendering into a depth
    texture provided by the XR runtime instead of the intermediate texture/render buffer
    created and managed by Qt. Rendering into a depth texture has certain lower-level
    consequences that can have a performance impact:
 
    When using \l{QtQuick3D::SceneEnvironment::antialiasingMode}{multisample antialiasing}
    (MSAA), enabling depth submission implies rendering into a multisample depth
    texture and resolving the samples into the non-multisample depth texture provided by
    the XR runtime. Without depth submission,
    the resolve step would not be necessary. In addition, some 3D APIs
    do not support resolving multisample depth-stencil data (see
    the \l{QRhi::ResolveDepthStencil} flag for details). Without this support,
    attempts to  enable depth submission in combination with MSAA are gracefully ignored.
 
    Even when MSAA is not used, enabling depth submission triggers writing out
    depth data with 3D APIs that have control over this. The store operation for
    depth/stencil data is typically indicated by Qt as unnecessary, which can
    have positive performance impacts on tiled GPU architectures. This is not
    done with depth submission because depth data must always be written out
    from Qt's perspective.
 
    \note We recommended that developers test their applications with depth
    submission enabled, evaluate the advantages and disadvantages, and make a
    conscious choice based on their testing if they wish to enable it or not.
*/
 
void QQuick3DXrView::setDepthSubmissionEnabled(bool enable)
{
    if (!m_xrManager.isValid()) {
        qWarning("Attempted to set depth submission mode without a valid XR manager");
        return;
    }
 
    const bool orgDepthSubmission = m_xrManager.isDepthSubmissionEnabled();
 
    m_xrManager.setDepthSubmissionEnabled(enable);
 
    if (orgDepthSubmission != m_xrManager.isDepthSubmissionEnabled())
        emit depthSubmissionEnabledChanged();
}
 
void QQuick3DXrView::setXROrigin(QQuick3DXrOrigin *newXrOrigin)
{
    if (m_xrOrigin == newXrOrigin)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DXrView::setXROrigin, newXrOrigin, m_xrOrigin);
 
    m_xrOrigin = newXrOrigin;
 
    // Make sure the XrOrigin has a parent item, if it hasn't, we're it.
    if (m_xrOrigin && !m_xrOrigin->parentItem())
        m_xrOrigin->setParentItem(this);
 
    m_xrManager.setXROrigin(m_xrOrigin);
 
    emit xrOriginChanged();
}
 
QQuick3DViewport *QQuick3DXrViewPrivate::getView3d(QQuick3DXrView *view)
{
    QSSG_ASSERT(view != nullptr, return nullptr);
    return view->view3d();
}
 
/*!
    \qmlsignal XrView::initializeFailed(const QString &errorString)
 
    Emitted when initialization fails, and there is a new \a errorString
    describing the failure.
 */
 
/*!
    \qmlsignal XrView::sessionEnded()
 
    Emitted when the session ends.
 */
 
/*!
    \qmlsignal XrView::frameReady()
    \internal
 
    Emitted when a new frame is ready.
 */
 
QT_END_NAMESPACE