qopenxritem.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 "qopenxritem_p.h"
#include "qopenxrview_p.h"
#include <QtQuick3D/private/qquick3dnode_p_p.h>
#include <QtQuick/private/qquickrectangle_p.h>
#include <QColor>
 
QT_BEGIN_NAMESPACE
 
 
class QOpenXRItemPrivate : public QQuick3DNodePrivate
{
    Q_DECLARE_PUBLIC(QOpenXRItem)
public:
    QOpenXRItemPrivate() : QQuick3DNodePrivate(QOpenXRItemPrivate::Type::Node)
    {
    }
 
    void setContentItem(QQuickItem *newContentItem)
    {
        Q_Q(QOpenXRItem);
        m_contentItem = newContentItem;
 
        initParentItem();
 
        if (m_contentItemDestroyedConnection) {
            QObject::disconnect(m_contentItemDestroyedConnection);
            m_contentItemDestroyedConnection = {};
        }
        if (m_contentItem) {
            m_contentItem->setParentItem(m_containerItem);
            m_contentItem->setParent(m_containerItem);
            m_contentItemDestroyedConnection = QObject::connect(m_contentItem, &QObject::destroyed, q, [q]() {
                q->setContentItem(nullptr);
            });
        }
 
        updateContent();
    }
 
    void initParentItem()
    {
        Q_Q(QOpenXRItem);
        if (!m_containerItem) {
            m_containerItem = new QQuickRectangle;
            m_containerItem->setTransformOrigin(QQuickItem::TopLeft);
            m_containerItem->setParent(q);
 
            auto dataProp = data();
            dataProp.append(&dataProp, m_containerItem);
        }
    }
 
    void updateContent();
 
    QQuickItem *m_contentItem = nullptr;
    QQuickRectangle *m_containerItem = nullptr;
    QPointer<QOpenXRView> m_XrView;
    QMetaObject::Connection m_contentItemDestroyedConnection;
    QColor m_color = Qt::white;
    qreal m_pixelsPerUnit { 1.0 };
    qreal m_width = 1;
    qreal m_height = 1;
    bool m_manualPixelsPerUnit = false;
};
 
static inline qreal calculatePPU(qreal pxWidth, qreal pxHeight, qreal diagonal)
{
    return (diagonal > 0) ? std::sqrt((pxWidth * pxWidth) + (pxHeight * pxHeight)) / diagonal : 1.0;
}
 
void QOpenXRItemPrivate::updateContent()
{
    if (!componentComplete)
        return;
    Q_Q(QOpenXRItem);
    initParentItem();
    m_containerItem->setColor(m_color);
    if (m_contentItem) {
        if (Q_UNLIKELY(m_manualPixelsPerUnit && m_pixelsPerUnit < 0)) {
            qWarning() << "XrItem invalid pixelPerUnit" << m_pixelsPerUnit;
            return;
        }
        qreal newScale;
        if (m_manualPixelsPerUnit) {
            newScale = 1.0 / m_pixelsPerUnit;
 
        } else {
            qreal diagonal = std::sqrt((m_width * m_width) + (m_height * m_height));
            qreal ppu = calculatePPU(m_contentItem->width(), m_contentItem->height(), diagonal);
            if (ppu <= 0)
                ppu = 1.0;
            q->setPixelsPerUnit(ppu);
            newScale = 1.0 / ppu;
        }
        QSizeF newSize(m_width / newScale, m_height / newScale);
        m_containerItem->setSize(newSize);
        m_containerItem->setScale(newScale);
    }
}
 
QOpenXRItem::QOpenXRItem(QQuick3DNode *parent)
    : QQuick3DNode(*(new QOpenXRItemPrivate()), parent)
{
}
 
QOpenXRItem::~QOpenXRItem()
{
    Q_D(QOpenXRItem);
    if (d->m_XrView)
        d->m_XrView->unregisterXrItem(this);
}
 
void QOpenXRItem::componentComplete()
{
    Q_D(QOpenXRItem);
    QQuick3DNode::componentComplete(); // Sets d->componentComplete, so must be called first
 
    auto findView = [this]() -> QOpenXRView * {
        QQuick3DNode *parent = parentNode();
        while (parent) {
            if (auto *xrView = qobject_cast<QOpenXRView*>(parent))
                return xrView;
            parent = parent->parentNode();
        }
        return nullptr;
    };
    d->m_XrView = findView();
    if (d->m_XrView)
        d->m_XrView->registerXrItem(this);
    else
        qWarning("Could not find XrView for XrItem");
    d->updateContent();
}
 
QQuickItem *QOpenXRItem::contentItem() const
{
    Q_D(const QOpenXRItem);
    return d->m_contentItem;
}
 
void QOpenXRItem::setContentItem(QQuickItem *newContentItem)
{
    Q_D(QOpenXRItem);
    if (d->m_contentItem == newContentItem)
        return;
 
    d->setContentItem(newContentItem);
    emit contentItemChanged();
}
 
qreal QOpenXRItem::pixelsPerUnit() const
{
    Q_D(const QOpenXRItem);
    return d->m_pixelsPerUnit;
}
 
void QOpenXRItem::setPixelsPerUnit(qreal newPixelsPerUnit)
{
    Q_D(QOpenXRItem);
    if (qFuzzyCompare(d->m_pixelsPerUnit, newPixelsPerUnit))
        return;
 
    d->m_pixelsPerUnit = newPixelsPerUnit;
 
    if (d->m_manualPixelsPerUnit)
        d->updateContent();
 
    emit pixelsPerUnitChanged();
}
 
bool QOpenXRItem::manualPixelsPerUnit() const
{
    Q_D(const QOpenXRItem);
    return d->m_manualPixelsPerUnit;
}
 
void QOpenXRItem::setManualPixelsPerUnit(bool newManualPixelsPerUnit)
{
    Q_D(QOpenXRItem);
    if (d->m_manualPixelsPerUnit == newManualPixelsPerUnit)
        return;
    d->m_manualPixelsPerUnit = newManualPixelsPerUnit;
    d->updateContent();
    emit manualPixelsPerUnitChanged();
}
 
qreal QOpenXRItem::width() const
{
    Q_D(const QOpenXRItem);
    return d->m_width;
}
 
void QOpenXRItem::setWidth(qreal newWidth)
{
    Q_D(QOpenXRItem);
    if (d->m_width == newWidth)
        return;
    d->m_width = newWidth;
    emit widthChanged();
 
    d->updateContent();
}
 
qreal QOpenXRItem::height() const
{
    Q_D(const QOpenXRItem);
    return d->m_height;
}
 
void QOpenXRItem::setHeight(qreal newHeight)
{
    Q_D(QOpenXRItem);
    if (d->m_height == newHeight)
        return;
    d->m_height = newHeight;
    emit widthChanged();
 
    d->updateContent();
}
 
// Sends appropriate touch events.
// Updates the touchState and returns true if this item grabs the touch point.
// touchState is input/output, and input contains the previous state if touchState->grabbed is true
 
bool QOpenXRItem::handleVirtualTouch(QOpenXRView *view, const QVector3D &pos, TouchState *touchState, QVector3D *offset)
{
    Q_D(QOpenXRItem);
 
    auto mappedPos = mapPositionFromScene(pos);
 
    QPointF point = {mappedPos.x(), -mappedPos.y()};
 
    constexpr qreal sideMargin = 20; // How far outside the rect do you have to go to cancel the grab (cm)
    constexpr qreal cancelDepth = 50; // How far through the rect do you have to go to cancel the grab (cm)
    constexpr qreal hoverHeight = 10; // How far above does the hover state begin (cm). NOTE: no hover events actually sent
 
    constexpr qreal releaseHeight = 2; // How far to move towards/from the surface to count as a press/release when below
    constexpr qreal smallDistance = 0.5; // Any movement shorter than this distance is ignored for press/release below the surface
    constexpr qreal longDistance = 5; // Any in-surface movement larger than this distance means this is not a press/release below the surface
    constexpr int releaseTime = 500; // How fast does the finger have to move to count as press/release below the surface
    constexpr qreal releaseHeightSquared = releaseHeight * releaseHeight;
    constexpr qreal smallDistanceSquared = smallDistance * smallDistance;
    constexpr qreal longDistanceSquared = longDistance * longDistance;
 
    const float z = mappedPos.z();
 
    const bool wayOutside = point.x() < -sideMargin || point.x() > width() + sideMargin
            || point.y() < -sideMargin || point.y() > height() + sideMargin || z < -cancelDepth;
    const bool inside = point.x() >= 0 && point.x() <= width() && point.y() >= 0 && point.y() <= height() && !wayOutside;
 
    const bool wasGrabbed = touchState->grabbed;
    const bool wasPressed = touchState->pressed;
 
    bool hover = z > 0 && z < hoverHeight;
 
    bool pressed = false;
    bool grab;
    bool resetPrevious = false;
    qint64 now = QDateTime::currentMSecsSinceEpoch();
 
    if (wasGrabbed) {
        // We maintain a grab as long as we don't move too far away while below the surface, or if we hover inside
 
        // We release if we go from below to above, or if we move upwards fast enough
        // We press if we go from above to below, or if we push downwards fast enough
        // We maintain press otherwise
        // If we move outside when pressed, we should maintain pressed state, but send release event
 
        QVector3D distFromPrev = mappedPos - touchState->previous;
        qint64 msSincePrev = now - touchState->timestamp;
 
        const qreal prevZ = touchState->previous.z();
 
        if (prevZ > 0 && z <= 0) {
            // New press from above
            pressed = true;
            resetPrevious = true;
        } else if (msSincePrev > releaseTime || z > 0) {
            resetPrevious = true;
            // If the timestamp of the last significant move is older than the cutoff, we maintain the press state if we're below the surface
            // We're never pressed if we're above the surface
            pressed = z <= 0 && wasPressed;
        } else {
            // We know we're within the cutoff interval, and below the surface.
            const qreal hDistSquared = distFromPrev.x() * distFromPrev.x() + distFromPrev.y() * distFromPrev.y();
            const qreal vDistSquared = distFromPrev.z() * distFromPrev.z();
            const qreal distSquared = hDistSquared + vDistSquared;
 
            if (distSquared < smallDistanceSquared) {
                // Ignore the movement if it's small.
                resetPrevious = false;
                pressed = wasPressed;
            } else if (hDistSquared > longDistanceSquared) {
                // It's not a press/release if it's a long move inside the surface
                resetPrevious = true;
                pressed = wasPressed;
            } else if (vDistSquared > releaseHeightSquared) {
                // Significant vertical move
                resetPrevious = true;
                pressed = distFromPrev.z() < 0;
            } else {
                resetPrevious = false;
                pressed = wasPressed;
            }
        }
 
        grab = (z <= 0 && !wayOutside) || (hover && inside);
    } else {
        // We don't want movement behind the surface to register as pressed, so we need at least one hover before a press
        grab = hover && inside;
        resetPrevious = true;
    }
 
    if (grab) {
        float zOffset = qMin(z, 0.0);
        if (offset)
            *offset = sceneRotation() * QVector3D{ 0, 0, -zOffset };
        touchState->grabbed = true;
        touchState->target = this;
        touchState->touchDistance = z;
        touchState->pressed = pressed;
        touchState->cursorPos = point;
        if (resetPrevious) {
            touchState->previous = mappedPos;
            touchState->timestamp = now;
        }
        view->setTouchpoint(d->m_containerItem, point, touchState->pointId, pressed && inside); // pressed state maintained outside, but release/press events must be sent when leave/enter
        return true;
    }
 
    if (wasGrabbed) {
        touchState->grabbed = false;
        touchState->target = nullptr;
        view->setTouchpoint(d->m_containerItem, point, touchState->pointId, false);
    }
 
    return false;
}
 
QColor QOpenXRItem::color() const
{
    Q_D(const QOpenXRItem);
    return d->m_color;
}
 
void QOpenXRItem::setColor(const QColor &newColor)
{
    Q_D(QOpenXRItem);
    if (d->m_color == newColor)
        return;
    d->m_color = newColor;
    emit colorChanged();
    d->updateContent();
}
 
QT_END_NAMESPACE