qquick3dnode.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dnode_p.h"
#include "qquick3dnode_p_p.h"
 
#include <QtQuick3DRuntimeRender/private/qssgrendernode_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
#include <QtQuick3D/private/qquick3dobject_p.h>
 
#include <QtMath>
 
QT_BEGIN_NAMESPACE
 
QQuick3DNodePrivate::QQuick3DNodePrivate(QQuick3DObjectPrivate::Type t)
    : QQuick3DObjectPrivate(t)
{
 
}
 
QQuick3DNodePrivate::~QQuick3DNodePrivate()
{
 
}
 
void QQuick3DNodePrivate::init()
{
 
}
 
void QQuick3DNodePrivate::setIsHiddenInEditor(bool isHidden)
{
    Q_Q(QQuick3DNode);
    if (isHidden == m_isHiddenInEditor)
        return;
    m_isHiddenInEditor = isHidden;
    q->update();
}
 
QQuick3DNode::QQuick3DNode(QQuick3DNode *parent)
    : QQuick3DObject(*(new QQuick3DNodePrivate(QQuick3DNodePrivate::Type::Node)), parent)
{
    Q_D(QQuick3DNode);
    d->init();
}
 
QQuick3DNode::QQuick3DNode(QQuick3DNodePrivate &dd, QQuick3DNode *parent)
    : QQuick3DObject(dd, parent)
{
    Q_ASSERT_X(QSSGRenderGraphObject::isNodeType(dd.type), "", "Type needs to be identified as a node type!");
 
    Q_D(QQuick3DNode);
    d->init();
}
 
QQuick3DNode::~QQuick3DNode() {}
 
float QQuick3DNode::x() const
{
    Q_D(const QQuick3DNode);
    return d->m_position.x();
}
 
float QQuick3DNode::y() const
{
    Q_D(const QQuick3DNode);
    return d->m_position.y();
}
 
float QQuick3DNode::z() const
{
    Q_D(const QQuick3DNode);
    return d->m_position.z();
}
 
QQuaternion QQuick3DNode::rotation() const
{
    Q_D(const QQuick3DNode);
    return d->m_rotation;
}
 
QVector3D QQuick3DNode::position() const
{
    Q_D(const QQuick3DNode);
    return d->m_position;
}
 
 
QVector3D QQuick3DNode::scale() const
{
    Q_D(const QQuick3DNode);
    return d->m_scale;
}
 
QVector3D QQuick3DNode::pivot() const
{
    Q_D(const QQuick3DNode);
    return d->m_pivot;
}
 
float QQuick3DNode::localOpacity() const
{
    Q_D(const QQuick3DNode);
    return d->m_opacity;
}
 
bool QQuick3DNode::visible() const
{
    Q_D(const QQuick3DNode);
    return d->m_visible;
}
 
int QQuick3DNode::staticFlags() const
{
    Q_D(const QQuick3DNode);
    return d->m_staticFlags;
}
 
QQuick3DNode *QQuick3DNode::parentNode() const
{
    // The parent of a QQuick3DNode should never be anything else than a (subclass
    // of) QQuick3DNode (but the children/leaf nodes can be something else).
    return static_cast<QQuick3DNode *>(parentItem());
}
 
QVector3D QQuick3DNode::forward() const
{
    return mapDirectionToScene(QVector3D(0, 0, -1)).normalized();
}
 
QVector3D QQuick3DNode::up() const
{
    return mapDirectionToScene(QVector3D(0, 1, 0)).normalized();
}
 
QVector3D QQuick3DNode::right() const
{
    return mapDirectionToScene(QVector3D(1, 0, 0)).normalized();
}
QVector3D QQuick3DNode::scenePosition() const
{
    return mat44::getPosition(sceneTransform());
}
 
QQuaternion QQuick3DNode::sceneRotation() const
{
    Q_D(const QQuick3DNode);
    return QQuaternion::fromRotationMatrix(mat44::getUpper3x3(d->sceneRotationMatrix())).normalized();
}
 
QVector3D QQuick3DNode::sceneScale() const
{
    return mat44::getScale(sceneTransform());
}
 
QMatrix4x4 QQuick3DNode::sceneTransform() const
{
    Q_D(const QQuick3DNode);
    if (d->m_sceneTransformDirty)
        const_cast<QQuick3DNodePrivate *>(d)->calculateGlobalVariables();
    return d->m_sceneTransform;
}
 
void QQuick3DNodePrivate::calculateGlobalVariables()
{
    Q_Q(QQuick3DNode);
    m_sceneTransformDirty = false;
    QMatrix4x4 localTransform = QSSGRenderNode::calculateTransformMatrix(m_position, m_scale, m_pivot, m_rotation);
    QQuick3DNode *parent = q->parentNode();
    if (!parent) {
        m_sceneTransform = localTransform;
        m_hasInheritedUniformScale = true;
        return;
    }
    QQuick3DNodePrivate *privateParent = QQuick3DNodePrivate::get(parent);
 
    if (privateParent->m_sceneTransformDirty)
        privateParent->calculateGlobalVariables();
    m_sceneTransform = privateParent->m_sceneTransform * localTransform;
 
    // Check if we have an ancestor with non-uniform scale. This will decide whether
    // or not we can use the sceneTransform to extract sceneRotation and sceneScale.
    m_hasInheritedUniformScale = privateParent->m_hasInheritedUniformScale;
    if (m_hasInheritedUniformScale) {
        const QVector3D ps = privateParent->m_scale;
        m_hasInheritedUniformScale = qFuzzyCompare(ps.x(), ps.y()) && qFuzzyCompare(ps.x(), ps.z());
    }
}
 
QMatrix4x4 QQuick3DNodePrivate::localRotationMatrix() const
{
    return QMatrix4x4(m_rotation.toRotationMatrix());
}
 
QMatrix4x4 QQuick3DNodePrivate::sceneRotationMatrix() const
{
    Q_Q(const QQuick3DNode);
 
    if (m_sceneTransformDirty) {
        // Ensure m_hasInheritedUniformScale is up to date
        const_cast<QQuick3DNodePrivate *>(this)->calculateGlobalVariables();
    }
 
    if (m_hasInheritedUniformScale) {
        // When we know that every node up to the root have a uniform scale, we can extract the
        // rotation directly from the sceneTransform(). This is optimizing, since we reuse that
        // matrix for more than just calculating the sceneRotation.
        QMatrix4x4 rotationMatrix = q->sceneTransform();
        mat44::normalize(rotationMatrix);
        return rotationMatrix;
    }
 
    // When we have an ancestor that has a non-uniform scale, we cannot extract
    // the rotation from the sceneMatrix directly. Instead, we need to calculate
    // it separately, which is slightly more costly.
    const QMatrix4x4 parentRotationMatrix = QQuick3DNodePrivate::get(q->parentNode())->sceneRotationMatrix();
    return parentRotationMatrix * localRotationMatrix();
}
 
void QQuick3DNodePrivate::emitChangesToSceneTransform()
{
    Q_Q(QQuick3DNode);
    const QVector3D prevPosition = mat44::getPosition(m_sceneTransform);
    const QQuaternion prevRotation = QQuaternion::fromRotationMatrix(mat44::getUpper3x3(m_sceneTransform)).normalized();
    const QVector3D prevScale = mat44::getScale(m_sceneTransform);
    QVector3D prevForward, prevUp, prevRight;
    QVector3D newForward, newUp, newRight;
    // Do direction (forward, up, right) calculations only if they have connections
    bool emitDirectionChanges = (m_directionConnectionCount > 0);
    if (emitDirectionChanges) {
        // Instead of calling forward(), up() and right(), calculate them here.
        // This way m_sceneTransform isn't updated due to m_sceneTransformDirty and
        // common theDirMatrix operations are not duplicated.
        QMatrix3x3 theDirMatrix = m_sceneTransform.normalMatrix();
        prevForward = mat33::transform(theDirMatrix, QVector3D(0, 0, -1)).normalized();
        prevUp = mat33::transform(theDirMatrix, QVector3D(0, 1, 0)).normalized();
        prevRight = mat33::transform(theDirMatrix, QVector3D(1, 0, 0)).normalized();
    }
 
    calculateGlobalVariables();
 
    const QVector3D newPosition = mat44::getPosition(m_sceneTransform);
    const QQuaternion newRotation = QQuaternion::fromRotationMatrix(mat44::getUpper3x3(m_sceneTransform)).normalized();
    const QVector3D newScale = mat44::getScale(m_sceneTransform);
    if (emitDirectionChanges) {
        QMatrix3x3 theDirMatrix = m_sceneTransform.normalMatrix();
        newForward = mat33::transform(theDirMatrix, QVector3D(0, 0, -1)).normalized();
        newUp = mat33::transform(theDirMatrix, QVector3D(0, 1, 0)).normalized();
        newRight = mat33::transform(theDirMatrix, QVector3D(1, 0, 0)).normalized();
    }
 
    const bool positionChanged = prevPosition != newPosition;
    const bool rotationChanged = prevRotation != newRotation;
    const bool scaleChanged = !qFuzzyCompare(prevScale, newScale);
 
    if (!positionChanged && !rotationChanged && !scaleChanged)
        return;
 
    emit q->sceneTransformChanged();
 
    if (positionChanged)
        emit q->scenePositionChanged();
    if (rotationChanged)
        emit q->sceneRotationChanged();
    if (scaleChanged)
        emit q->sceneScaleChanged();
    if (emitDirectionChanges) {
        const bool forwardChanged = prevForward != newForward;
        const bool upChanged = prevUp != newUp;
        const bool rightChanged = prevRight != newRight;
        if (forwardChanged)
            Q_EMIT q->forwardChanged();
        if (upChanged)
            Q_EMIT q->upChanged();
        if (rightChanged)
            Q_EMIT q->rightChanged();
    }
}
 
bool QQuick3DNodePrivate::isSceneTransformRelatedSignal(const QMetaMethod &signal) const
{
    // Return true if its likely that we need to emit
    // the given signal when our global transform changes.
    static const QMetaMethod sceneTransformSignal = QMetaMethod::fromSignal(&QQuick3DNode::sceneTransformChanged);
    static const QMetaMethod scenePositionSignal = QMetaMethod::fromSignal(&QQuick3DNode::scenePositionChanged);
    static const QMetaMethod sceneRotationSignal = QMetaMethod::fromSignal(&QQuick3DNode::sceneRotationChanged);
    static const QMetaMethod sceneScaleSignal = QMetaMethod::fromSignal(&QQuick3DNode::sceneScaleChanged);
 
    return (signal == sceneTransformSignal
            || signal == scenePositionSignal
            || signal == sceneRotationSignal
            || signal == sceneScaleSignal);
}
 
bool QQuick3DNodePrivate::isDirectionRelatedSignal(const QMetaMethod &signal) const
{
    // Return true if its likely that we need to emit
    // the given signal when our global transform changes.
    static const QMetaMethod forwardSignal = QMetaMethod::fromSignal(&QQuick3DNode::forwardChanged);
    static const QMetaMethod upSignal = QMetaMethod::fromSignal(&QQuick3DNode::upChanged);
    static const QMetaMethod rightSignal = QMetaMethod::fromSignal(&QQuick3DNode::rightChanged);
 
    return (signal == forwardSignal
            || signal == upSignal
            || signal == rightSignal);
}
 
void QQuick3DNode::connectNotify(const QMetaMethod &signal)
{
    Q_D(QQuick3DNode);
    // Since we want to avoid calculating the global transform in the frontend
    // unnecessary, we keep track of the number of connections/QML bindings
    // that needs it. If there are no connections, we can skip calculating it
    // whenever our geometry changes (unless someone asks for it explicitly).
    if (d->isSceneTransformRelatedSignal(signal))
        d->m_sceneTransformConnectionCount++;
    if (d->isDirectionRelatedSignal(signal))
        d->m_directionConnectionCount++;
}
 
void QQuick3DNode::disconnectNotify(const QMetaMethod &signal)
{
    Q_D(QQuick3DNode);
    if (d->isSceneTransformRelatedSignal(signal))
        d->m_sceneTransformConnectionCount--;
    if (d->isDirectionRelatedSignal(signal))
        d->m_directionConnectionCount--;
}
 
void QQuick3DNode::componentComplete()
{
    Q_D(QQuick3DNode);
    QQuick3DObject::componentComplete();
    if (d->m_sceneTransformConnectionCount > 0 || d->m_directionConnectionCount > 0)
        d->emitChangesToSceneTransform();
}
 
void QQuick3DNodePrivate::markSceneTransformDirty()
{
    Q_Q(QQuick3DNode);
    // Note: we recursively set m_sceneTransformDirty to true whenever our geometry
    // changes. But we only set it back to false if someone actually queries our global
    // transform (because only then do we need to calculate it). This means that if no
    // one ever does that, m_sceneTransformDirty will remain true, perhaps through out
    // the life time of the node. This is in contrast with the backend, which need to
    // update dirty transform nodes for every scene graph sync (and clear the backend
    // dirty transform flags - QQuick3DObjectPrivate::dirtyAttributes).
    // This means that for most nodes, calling markSceneTransformDirty() should be
    // cheap, since we normally expect to return early in the following test.
    if (m_sceneTransformDirty)
        return;
 
    m_sceneTransformDirty = true;
 
    if (m_sceneTransformConnectionCount > 0 || m_directionConnectionCount > 0)
        emitChangesToSceneTransform();
 
    auto children = QQuick3DObjectPrivate::get(q)->childItems;
    for (auto child : children) {
        if (auto node = qobject_cast<QQuick3DNode *>(child)) {
            QQuick3DNodePrivate::get(node)->markSceneTransformDirty();
        }
    }
}
 
void QQuick3DNode::setX(float x)
{
    Q_D(QQuick3DNode);
    if (qFuzzyCompare(d->m_position.x(), x))
        return;
 
    d->m_position.setX(x);
    d->markSceneTransformDirty();
    emit positionChanged();
    emit xChanged();
    update();
}
 
void QQuick3DNode::setY(float y)
{
    Q_D(QQuick3DNode);
    if (qFuzzyCompare(d->m_position.y(), y))
        return;
 
    d->m_position.setY(y);
    d->markSceneTransformDirty();
    emit positionChanged();
    emit yChanged();
    update();
}
 
void QQuick3DNode::setZ(float z)
{
    Q_D(QQuick3DNode);
    if (qFuzzyCompare(d->m_position.z(), z))
        return;
 
    d->m_position.setZ(z);
    d->markSceneTransformDirty();
    emit positionChanged();
    emit zChanged();
    update();
}
 
void QQuick3DNode::setRotation(const QQuaternion &rotation)
{
    Q_D(QQuick3DNode);
    if (d->m_rotation == rotation)
        return;
 
    d->m_rotation = rotation;
    d->markSceneTransformDirty();
    emit rotationChanged();
    emit eulerRotationChanged();
 
    update();
}
 
void QQuick3DNode::setPosition(const QVector3D &position)
{
    Q_D(QQuick3DNode);
    if (d->m_position == position)
        return;
 
    const bool xUnchanged = qFuzzyCompare(position.x(), d->m_position.x());
    const bool yUnchanged = qFuzzyCompare(position.y(), d->m_position.y());
    const bool zUnchanged = qFuzzyCompare(position.z(), d->m_position.z());
 
    d->m_position = position;
    d->markSceneTransformDirty();
    emit positionChanged();
 
    if (!xUnchanged)
        emit xChanged();
    if (!yUnchanged)
        emit yChanged();
    if (!zUnchanged)
        emit zChanged();
 
    update();
}
 
void QQuick3DNode::setScale(const QVector3D &scale)
{
    Q_D(QQuick3DNode);
    if (d->m_scale == scale)
        return;
 
    d->m_scale = scale;
    d->markSceneTransformDirty();
    emit scaleChanged();
    update();
}
 
void QQuick3DNode::setPivot(const QVector3D &pivot)
{
    Q_D(QQuick3DNode);
    if (d->m_pivot == pivot)
        return;
 
    d->m_pivot = pivot;
    d->markSceneTransformDirty();
    emit pivotChanged();
    update();
}
 
void QQuick3DNode::setLocalOpacity(float opacity)
{
    Q_D(QQuick3DNode);
    if (qFuzzyCompare(d->m_opacity, opacity))
        return;
 
    d->m_opacity = opacity;
    emit localOpacityChanged();
    update();
}
 
void QQuick3DNode::setVisible(bool visible)
{
    Q_D(QQuick3DNode);
    if (d->m_visible == visible)
        return;
 
    d->m_visible = visible;
    emit visibleChanged();
    update();
}
 
void QQuick3DNode::setStaticFlags(int staticFlags)
{
    Q_D(QQuick3DNode);
    if (d->m_staticFlags == staticFlags)
        return;
 
    d->m_staticFlags = staticFlags;
    emit staticFlagsChanged();
    update();
}
 
void QQuick3DNode::setEulerRotation(const QVector3D &eulerRotation) {
    Q_D(QQuick3DNode);
 
    if (d->m_rotation == eulerRotation)
        return;
 
    d->m_rotation = eulerRotation;
 
    emit rotationChanged();
    d->markSceneTransformDirty();
    emit eulerRotationChanged();
    update();
}
 
void QQuick3DNode::rotate(qreal degrees, const QVector3D &axis, TransformSpace space)
{
    Q_D(QQuick3DNode);
 
    const QQuaternion addRotationQuat = QQuaternion::fromAxisAndAngle(axis, float(degrees));
    const QMatrix4x4 addRotationMatrix = QMatrix4x4(addRotationQuat.toRotationMatrix());
    QMatrix4x4 newRotationMatrix;
 
    switch (space) {
    case LocalSpace:
        newRotationMatrix = d->localRotationMatrix() * addRotationMatrix;
        break;
    case ParentSpace:
        newRotationMatrix = addRotationMatrix * d->localRotationMatrix();
        break;
    case SceneSpace:
        if (const auto parent = parentNode()) {
            const QMatrix4x4 lrm = d->localRotationMatrix();
            const QMatrix4x4 prm = QQuick3DNodePrivate::get(parent)->sceneRotationMatrix();
            newRotationMatrix = prm.inverted() * addRotationMatrix * prm * lrm;
        } else {
            newRotationMatrix = d->localRotationMatrix() * addRotationMatrix;
        }
        break;
    }
 
    const QQuaternion newRotationQuaternion = QQuaternion::fromRotationMatrix(mat44::getUpper3x3(newRotationMatrix)).normalized();
 
    if (d->m_rotation == newRotationQuaternion)
        return;
 
    d->m_rotation = newRotationQuaternion;
    d->markSceneTransformDirty();
 
    emit rotationChanged();
    emit eulerRotationChanged();
 
    update();
}
 
QSSGRenderGraphObject *QQuick3DNode::updateSpatialNode(QSSGRenderGraphObject *node)
{
    Q_D(QQuick3DNode);
    if (!node) {
        markAllDirty();
        node = new QSSGRenderNode();
    }
    QQuick3DObject::updateSpatialNode(node);
    auto spacialNode = static_cast<QSSGRenderNode *>(node);
    bool transformIsDirty = false;
 
    if (spacialNode->pivot != d->m_pivot) {
        transformIsDirty = true;
        spacialNode->pivot = d->m_pivot;
    }
 
    if (!qFuzzyCompare(spacialNode->localOpacity, d->m_opacity)) {
        spacialNode->localOpacity = d->m_opacity;
        spacialNode->markDirty(QSSGRenderNode::DirtyFlag::OpacityDirty);
    }
 
    if (!transformIsDirty && !qFuzzyCompare(d->m_position, mat44::getPosition(spacialNode->localTransform)))
        transformIsDirty = true;
 
    if (!transformIsDirty && !qFuzzyCompare(d->m_scale, mat44::getScale(spacialNode->localTransform)))
        transformIsDirty = true;
 
    if (!transformIsDirty && !qFuzzyCompare(d->m_rotation, QQuaternion::fromRotationMatrix(mat44::getUpper3x3(spacialNode->localTransform))))
        transformIsDirty = true;
 
    if (transformIsDirty) {
        spacialNode->localTransform = QSSGRenderNode::calculateTransformMatrix(d->m_position, d->m_scale, d->m_pivot, d->m_rotation);;
        spacialNode->markDirty(QSSGRenderNode::DirtyFlag::TransformDirty);
    }
 
    spacialNode->staticFlags = d->m_staticFlags;
 
    // The Hidden in Editor flag overrides the visible value
    if (d->m_isHiddenInEditor)
        spacialNode->setState(QSSGRenderNode::LocalState::Active, false);
    else
        spacialNode->setState(QSSGRenderNode::LocalState::Active, d->m_visible);
 
    DebugViewHelpers::ensureDebugObjectName(spacialNode, this);
 
    return spacialNode;
}
 
QVector3D QQuick3DNode::mapPositionToScene(const QVector3D &localPosition) const
{
    return mat44::transform(sceneTransform(), localPosition);
}
 
QVector3D QQuick3DNode::mapPositionFromScene(const QVector3D &scenePosition) const
{
    return mat44::transform(sceneTransform().inverted(), scenePosition);
}
 
QVector3D QQuick3DNode::mapPositionToNode(const QQuick3DNode *node, const QVector3D &localPosition) const
{
    const auto scenePositionSelf = mapPositionToScene(localPosition);
    return node ? node->mapPositionFromScene(scenePositionSelf) : scenePositionSelf;
}
 
QVector3D QQuick3DNode::mapPositionFromNode(const QQuick3DNode *node, const QVector3D &localPosition) const
{
    const auto scenePositionOther = node ? node->mapPositionToScene(localPosition) : localPosition;
    return mapPositionFromScene(scenePositionOther);
}
 
QVector3D QQuick3DNode::mapDirectionToScene(const QVector3D &localDirection) const
{
    QMatrix3x3 theDirMatrix = sceneTransform().normalMatrix();
    return mat33::transform(theDirMatrix, localDirection);
}
 
QVector3D QQuick3DNode::mapDirectionFromScene(const QVector3D &sceneDirection) const
{
    QMatrix3x3 theDirMatrix = mat44::getUpper3x3(sceneTransform());
    theDirMatrix = theDirMatrix.transposed();
    return mat33::transform(theDirMatrix, sceneDirection);
}
 
QVector3D QQuick3DNode::mapDirectionToNode(const QQuick3DNode *node, const QVector3D &localDirection) const
{
    const auto sceneDirectionSelf = mapDirectionToScene(localDirection);
    return node ? node->mapDirectionFromScene(sceneDirectionSelf) : sceneDirectionSelf;
}
 
QVector3D QQuick3DNode::mapDirectionFromNode(const QQuick3DNode *node, const QVector3D &localDirection) const
{
    const auto sceneDirectionOther = node ? node->mapDirectionToScene(localDirection) : localDirection;
    return mapDirectionFromScene(sceneDirectionOther);
}
 
void QQuick3DNode::markAllDirty()
{
    Q_D(QQuick3DNode);
 
    d->markSceneTransformDirty();
    QQuick3DObject::markAllDirty();
}
 
QVector3D QQuick3DNode::eulerRotation() const
{
    const Q_D(QQuick3DNode);
 
    return d->m_rotation;
}
 
void QQuick3DNode::itemChange(ItemChange change, const ItemChangeData &)
{
    if (change == QQuick3DObject::ItemParentHasChanged)
        QQuick3DNodePrivate::get(this)->markSceneTransformDirty();
}
 
QT_END_NAMESPACE