Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qabstractphysicsnode_p.h"
++ #include <QtQuick3D/private/qquick3dobject_p.h>
++ #include <foundation/PxTransform.h>
++
++ #include "qphysicsworld_p.h"
++
++ #include <QtGui/qquaternion.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype PhysicsNode
++ \inherits Node
++ \inqmlmodule QtQuick3D.Physics
++ \since 6.4
++ \brief Base type for all objects in the physics scene.
++
++ PhysicsNode is the base type for all the objects that take part in the physics simulation. These
++ objects have a position in three-dimensional space and a geometrical shape.
++ */
++
++ /*!
++ \qmlproperty list<CollisionShape> PhysicsNode::collisionShapes
++
++ This property contains the list of collision shapes. These shapes will be combined and act as a
++ single rigid body when interacting with other bodies.
++
++ \sa {Qt Quick 3D Physics Shapes, Bodies and Joints}
++ */
++
++ /*!
++ \qmlproperty bool PhysicsNode::sendContactReports
++ This property determines whether this body will send contact reports when colliding with other
++ bodies.
++
++ Default value: \c{false}
++ */
++
++ /*!
++ \qmlproperty bool PhysicsNode::receiveContactReports
++ This property determines whether this body will receive contact reports when colliding with
++ other bodies. If activated, this means that the bodyContact signal will be emitted on a
++ collision with a body that has sendContactReports set to true.
++
++ Default value: \c{false}
++ */
++
++ /*!
++ \qmlproperty bool PhysicsNode::sendTriggerReports
++ This property determines whether this body will send reports when entering or leaving a trigger
++ body.
++
++ Read as this body enters a trigger body, and what it says then decides what is reported for
++ that stay.
++
++ Default value: \c{false}
++ */
++
++ /*!
++ \qmlproperty bool PhysicsNode::receiveTriggerReports
++ This property determines whether this body will receive reports when entering or leaving a
++ trigger body.
++
++ Read as this body enters a trigger body, and what it says then decides what is reported for
++ that stay.
++
++ Default value: \c{false}
++ */
++
++ /*!
++ \qmlproperty int PhysicsNode::filterGroup
++ This property determines what filter group this body is part of.
++
++ Default value is \c 0.
++
++ Range: \c{[0, 31]}
++
++ \sa PhysicsNode::filterIgnoreGroups
++ */
++
++ /*!
++ \qmlproperty int PhysicsNode::filterIgnoreGroups
++ This property determines what groups this body should filter out collisions with.
++
++ \note This number is interpreted as a bitmask, meaning that if bit \c i is set then collisions
++ with \l filterGroup number \c i will be filtered. For instance, to filter groups \c{1}, \c{3}
++ and \c{4} then set the value to \c{0b11010}.
++
++ \sa PhysicsNode::filterGroup
++ */
++
++ /*!
++ \qmlsignal PhysicsNode::bodyContact(PhysicsNode *body, list<vector3D> positions,
++ list<vector3D> impulses, list<vector3D> normals)
++
++ This signal is emitted when there is a collision between a dynamic body and any
++ other body. The \l {PhysicsNode::} {receiveContactReports} in this body and \l {PhysicsNode::}
++ {sendContactReports} in the colliding body need to be set to true. The parameters \a body, \a
++ positions, \a impulses and \a normals contain the other body, position, impulse force and normal
++ for each contact point at the same index.
++
++ \sa CharacterController::shapeHit
++ \sa PhysicsWorld::reportKinematicKinematicCollisions
++ \sa PhysicsWorld::reportStaticKinematicCollisions
++ */
++
++ /*!
++ \qmlsignal PhysicsNode::enteredTriggerBody(TriggerBody *body)
++
++ This signal is emitted when this body enters the specified trigger \a body.
++
++ Emitted once per trigger body, however many collision shapes this body and that trigger body
++ have inside each other.
++
++ \note Only emitted when receiveTriggerReports was \c true as this body entered
++ \sa receiveTriggerReports exitedTriggerBody
++ */
++
++ /*!
++ \qmlsignal PhysicsNode::exitedTriggerBody(TriggerBody *body)
++
++ This signal is emitted when this body exits the specified trigger \a body.
++
++ Emitted once the last of this body's collision shapes has left the trigger body, not when the
++ first one does.
++
++ \note Only emitted when receiveTriggerReports was \c true as this body entered, and not
++ emitted for a trigger body that is deleted while this body is still inside it.
++ \sa receiveTriggerReports enteredTriggerBody
++ */
++
++ QAbstractPhysicsNode::QAbstractPhysicsNode()
++ {
++ QPhysicsWorld::registerNode(this);
++ }
++
++ QAbstractPhysicsNode::~QAbstractPhysicsNode()
++ {
++ for (auto shape : std::as_const(m_collisionShapes))
++ shape->disconnect(this);
++ QPhysicsWorld::deregisterNode(this);
++ }
++
++ QQmlListProperty<QAbstractCollisionShape> QAbstractPhysicsNode::collisionShapes()
++ {
++ return QQmlListProperty<QAbstractCollisionShape>(
++ this, nullptr, QAbstractPhysicsNode::qmlAppendShape,
++ QAbstractPhysicsNode::qmlShapeCount, QAbstractPhysicsNode::qmlShapeAt,
++ QAbstractPhysicsNode::qmlClearShapes);
++ }
++
++ const QVector<QAbstractCollisionShape *> &QAbstractPhysicsNode::getCollisionShapesList() const
++ {
++ return m_collisionShapes;
++ }
++
++ void QAbstractPhysicsNode::updateFromPhysicsTransform(const physx::PxTransform &transform)
++ {
++ const auto pos = transform.p;
++ const auto rotation = transform.q;
++ const auto qtPosition = QVector3D(pos.x, pos.y, pos.z);
++ const auto qtRotation = QQuaternion(rotation.w, rotation.x, rotation.y, rotation.z);
++
++ // Get this nodes parent transform
++ const QQuick3DNode *parentNode = static_cast<QQuick3DNode *>(parentItem());
++
++ // setPosition() and setRotation() run this node's bindings, which can move
++ // the parent, so the parent is read before either write. A binding that
++ // deletes the node cannot be survived from here: setPosition() goes on
++ // writing to the node after running them. The backends ask whether the node
++ // is still there once a write has returned.
++ //
++ // No parent is the same space.
++ const QVector3D localPosition =
++ parentNode ? parentNode->mapPositionFromScene(qtPosition) : qtPosition;
++ const QQuaternion localRotation =
++ parentNode ? parentNode->sceneRotation().inverted() * qtRotation : qtRotation;
++
++ setPosition(localPosition);
++ setRotation(localRotation);
++ }
++
++ bool QAbstractPhysicsNode::sendContactReports() const
++ {
++ return m_sendContactReports;
++ }
++
++ void QAbstractPhysicsNode::setSendContactReports(bool sendContactReports)
++ {
++ if (m_sendContactReports == sendContactReports)
++ return;
++
++ m_sendContactReports = sendContactReports;
++ emit sendContactReportsChanged(m_sendContactReports);
++ }
++
++ bool QAbstractPhysicsNode::receiveContactReports() const
++ {
++ return m_receiveContactReports;
++ }
++
++ void QAbstractPhysicsNode::setReceiveContactReports(bool receiveContactReports)
++ {
++ if (m_receiveContactReports == receiveContactReports)
++ return;
++
++ m_receiveContactReports = receiveContactReports;
++ emit receiveContactReportsChanged(m_receiveContactReports);
++ }
++
++ bool QAbstractPhysicsNode::sendTriggerReports() const
++ {
++ return m_sendTriggerReports;
++ }
++
++ void QAbstractPhysicsNode::setSendTriggerReports(bool sendTriggerReports)
++ {
++ if (m_sendTriggerReports == sendTriggerReports)
++ return;
++
++ m_sendTriggerReports = sendTriggerReports;
++ emit sendTriggerReportsChanged(m_sendTriggerReports);
++ }
++
++ bool QAbstractPhysicsNode::receiveTriggerReports() const
++ {
++ return m_receiveTriggerReports;
++ }
++
++ void QAbstractPhysicsNode::setReceiveTriggerReports(bool receiveTriggerReports)
++ {
++ if (m_receiveTriggerReports == receiveTriggerReports)
++ return;
++
++ m_receiveTriggerReports = receiveTriggerReports;
++ emit receiveTriggerReportsChanged(m_receiveTriggerReports);
++ }
++
++ void QAbstractPhysicsNode::registerContact(QAbstractPhysicsNode *body,
++ const QVector<QVector3D> &positions,
++ const QVector<QVector3D> &impulses,
++ const QVector<QVector3D> &normals)
++ {
++ emit bodyContact(body, positions, impulses, normals);
++ }
++
++ void QAbstractPhysicsNode::onShapeDestroyed(QObject *object)
++ {
++ m_collisionShapes.removeAll(static_cast<QAbstractCollisionShape *>(object));
++ }
++
++ void QAbstractPhysicsNode::onShapeNeedsRebuild(QObject * /*object*/)
++ {
++ m_shapesDirty = true;
++ }
++
++ void QAbstractPhysicsNode::qmlAppendShape(QQmlListProperty<QAbstractCollisionShape> *list,
++ QAbstractCollisionShape *shape)
++ {
++ if (shape == nullptr)
++ return;
++ QAbstractPhysicsNode *self = static_cast<QAbstractPhysicsNode *>(list->object);
++ self->m_collisionShapes.push_back(shape);
++ self->m_hasStaticShapes = self->m_hasStaticShapes || shape->isStaticShape();
++
++ if (shape->parentItem() == nullptr) {
++ // If the material has no parent, check if it has a hierarchical parent that's a
++ // QQuick3DObject and re-parent it to that, e.g., inline materials
++ QQuick3DObject *parentItem = qobject_cast<QQuick3DObject *>(shape->parent());
++ if (parentItem) {
++ shape->setParentItem(parentItem);
++ } else { // If no valid parent was found, make sure the material refs our scene manager
++ const auto &scenManager = QQuick3DObjectPrivate::get(self)->sceneManager;
++ if (scenManager)
++ QQuick3DObjectPrivate::refSceneManager(shape, *scenManager);
++ // else: If there's no scene manager, defer until one is set, see itemChange()
++ }
++ }
++
++ // Make sure materials are removed when destroyed
++ connect(shape, &QAbstractCollisionShape::destroyed, self,
++ &QAbstractPhysicsNode::onShapeDestroyed);
++
++ // Connect to rebuild signal
++ connect(shape, &QAbstractCollisionShape::needsRebuild, self,
++ &QAbstractPhysicsNode::onShapeNeedsRebuild);
++ }
++
++ QAbstractCollisionShape *
++ QAbstractPhysicsNode::qmlShapeAt(QQmlListProperty<QAbstractCollisionShape> *list, qsizetype index)
++ {
++ QAbstractPhysicsNode *self = static_cast<QAbstractPhysicsNode *>(list->object);
++ return self->m_collisionShapes.at(index);
++ }
++
++ qsizetype QAbstractPhysicsNode::qmlShapeCount(QQmlListProperty<QAbstractCollisionShape> *list)
++ {
++ QAbstractPhysicsNode *self = static_cast<QAbstractPhysicsNode *>(list->object);
++ return self->m_collisionShapes.count();
++ }
++
++ void QAbstractPhysicsNode::qmlClearShapes(QQmlListProperty<QAbstractCollisionShape> *list)
++ {
++ QAbstractPhysicsNode *self = static_cast<QAbstractPhysicsNode *>(list->object);
++ for (const auto &shape : std::as_const(self->m_collisionShapes)) {
++ if (shape->parentItem() == nullptr)
++ QQuick3DObjectPrivate::get(shape)->derefSceneManager();
++ }
++ self->m_hasStaticShapes = false;
++ for (auto shape : std::as_const(self->m_collisionShapes))
++ shape->disconnect(self);
++ self->m_collisionShapes.clear();
++ }
++
++ int QAbstractPhysicsNode::filterGroup() const
++ {
++ return m_filterGroup;
++ }
++
++ void QAbstractPhysicsNode::setfilterGroup(int newfilterGroup)
++ {
++ if (m_filterGroup == newfilterGroup)
++ return;
++
++ if (newfilterGroup < 0 || newfilterGroup >= 32) {
++ qWarning() << "PhysicsNode: filterGroup" << newfilterGroup
++ << "is out of range [0, 31], ignoring. Values outside this range are"
++ " silently excluded from collision filtering by the underlying engine.";
++ return;
++ }
++
++ m_filterGroup = newfilterGroup;
++ m_filtersDirty = true;
++ emit filterGroupChanged();
++ }
++
++ int QAbstractPhysicsNode::filterIgnoreGroups() const
++ {
++ return m_filterIgnoreGroups;
++ }
++
++ void QAbstractPhysicsNode::setFilterIgnoreGroups(int newFilterIgnoreGroups)
++ {
++ if (m_filterIgnoreGroups == newFilterIgnoreGroups)
++ return;
++ m_filterIgnoreGroups = newFilterIgnoreGroups;
++ m_filtersDirty = true;
++ emit filterIgnoreGroupsChanged();
++ }
++
++ QT_END_NAMESPACE