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 "qdynamicrigidbody_p.h"
++ #include "qphysicscommands_p.h"
++ #include "qphysicsutils_p.h"
++ #include "qphysicsworld_p.h"
++ #include "physxnode/qphysxdynamicbody_p.h"
++
++ #include <foundation/PxSimpleTypes.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype DynamicRigidBody
++ \inqmlmodule QtQuick3D.Physics
++ \inherits PhysicsBody
++ \since 6.4
++ \brief A physical body that can move or be moved.
++
++ This type defines a dynamic rigid body: an object that is part of the physics
++ scene and behaves like a physical object with mass and velocity.
++
++ \note \l{TriangleMeshShape}{triangle mesh}, \l{HeightFieldShape}{height field} and
++ \l{PlaneShape}{plane} geometry shapes are not allowed as collision shapes when
++ \l isKinematic is \c false.
++ */
++
++ /*!
++ \qmlproperty real DynamicRigidBody::mass
++
++ This property defines the mass of the body. Note that this is only used when massMode is not
++ \c {DynamicRigidBody.CustomDensity} or \c {DynamicRigidBody.DefaultDensity}. Also note that
++ a value of 0 is interpreted as infinite mass and that negative numbers are not allowed.
++
++ Default value: \c 1
++
++ Range: \c{[0, inf]}
++
++ \sa massMode
++ */
++
++ /*!
++ \qmlproperty real DynamicRigidBody::density
++
++ This property defines the density of the body. This is only used when massMode is set to \c
++ {DynamicRigidBody.CustomDensity}.
++
++ Default value: \c{0.001}
++
++ Range: \c{(0, inf]}
++ \sa massMode
++ */
++
++ /*!
++ \qmlproperty AxisLock DynamicRigidBody::linearAxisLock
++
++ This property locks the linear velocity of the body along the axes defined by the
++ DynamicRigidBody.AxisLock enum. To lock several axes just bitwise-or their enum values.
++
++ Available options:
++
++ \value DynamicRigidBody.None
++ No axis lock.
++
++ \value DynamicRigidBody.LockX
++ Lock X axis.
++
++ \value DynamicRigidBody.LockY
++ Lock Y axis.
++
++ \value DynamicRigidBody.LockZ
++ Lock Z axis.
++
++ Default value: \c{DynamicRigidBody.None}
++ */
++
++ /*!
++ \qmlproperty AxisLock DynamicRigidBody::angularAxisLock
++
++ This property locks the angular velocity of the body along the axes defined by the
++ DynamicRigidBody.AxisLock enum. To lock several axes just bitwise-or their enum values.
++
++ Available options:
++
++ \value DynamicRigidBody.None
++ No axis lock.
++
++ \value DynamicRigidBody.LockX
++ Lock X axis.
++
++ \value DynamicRigidBody.LockY
++ Lock Y axis.
++
++ \value DynamicRigidBody.LockZ
++ Lock Z axis.
++
++ Default value: \c{DynamicRigidBody.None}
++ */
++
++ /*!
++ \qmlproperty enumeration DynamicRigidBody::ccd
++ \since 6.13
++
++ This property determines the continuous collision detection (CCD) mode
++ used for this body. Enabling CCD reduces the risk of fast-moving objects passing
++ through geometry between physics frames (tunnelling). The following values
++ are available:
++
++ \value DynamicRigidBody.None
++ CCD is disabled for this body unless enabled globally by \l PhysicsWorld::enableCCD.
++
++ \value DynamicRigidBody.SpeculativeCCD
++ Uses speculative continuous collision detection. Supported for both dynamic and
++ kinematic bodies.
++
++ \value DynamicRigidBody.SweepBasedCCD
++ Uses sweep-based continuous collision detection. This mode is supported only
++ for non-kinematic dynamic bodies. If applied to a kinematic body, it automatically
++ falls back to \c SpeculativeCCD.
++
++ \default DynamicRigidBody.None
++
++ \note CCD processing can significantly impact simulation performance. Enable it only for
++ objects moving at high velocities or having small bounds relative to their speed.
++
++ \sa PhysicsWorld::enableCCD
++ */
++
++ /*!
++ \qmlproperty bool DynamicRigidBody::isKinematic
++ This property defines whether the object is kinematic or not. A kinematic object does not get
++ influenced by external forces and can be seen as an object of infinite mass. If this property is
++ set then in every simulation frame the physical object will be moved to its target position
++ regardless of external forces. Note that to move and rotate the kinematic object you need to use
++ the kinematicPosition, kinematicRotation, kinematicEulerRotation and kinematicPivot properties.
++
++ Default value: \c{false}
++
++ \sa kinematicPosition, kinematicRotation, kinematicEulerRotation, kinematicPivot
++ */
++
++ /*!
++ \qmlproperty bool DynamicRigidBody::gravityEnabled
++ This property defines whether the object is going to be affected by gravity or not.
++
++ Default value: \c{true}
++ */
++
++ /*!
++ \qmlproperty MassMode DynamicRigidBody::massMode
++
++ This property holds the enum which describes how mass and inertia are calculated for this body.
++
++ Available options:
++
++ \value DynamicRigidBody.DefaultDensity
++ Use the density specified in the \l {PhysicsWorld::}{defaultDensity} property in
++ PhysicsWorld to calculate mass and inertia assuming a uniform density.
++
++ \value DynamicRigidBody.CustomDensity
++ Use specified density in the specified in the \l {DynamicRigidBody::}{density} to
++ calculate mass and inertia assuming a uniform density.
++
++ \value DynamicRigidBody.Mass
++ Use the specified mass to calculate inertia assuming a uniform density.
++
++ \value DynamicRigidBody.MassAndInertiaTensor
++ Use the specified mass value and inertia tensor.
++
++ \value DynamicRigidBody.MassAndInertiaMatrix
++ Use the specified mass value and calculate inertia from the specified inertia
++ matrix.
++
++ Default value: \c{DynamicRigidBody.DefaultDensity}
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::inertiaTensor
++
++ Defines the inertia tensor vector, using a parameter specified in mass space coordinates.
++
++ This is the diagonal vector of a 3x3 diagonal matrix, if you have a non diagonal world/actor
++ space inertia tensor then you should use \l{DynamicRigidBody::inertiaMatrix}{inertiaMatrix}
++ instead.
++
++ The inertia tensor components must be positive and a value of 0 in any component is
++ interpreted as infinite inertia along that axis. Note that this is only used when
++ massMode is set to \c DynamicRigidBody.MassAndInertiaTensor.
++
++ Default value: \c{(1, 1, 1)}
++
++ \sa massMode, inertiaMatrix
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::centerOfMassPosition
++
++ Defines the position of the center of mass relative to the body. Note that this is only used
++ when massMode is set to \c DynamicRigidBody.MassAndInertiaTensor.
++
++ Default value: \c{(0, 0, 0)}
++
++ \sa massMode, inertiaTensor
++ */
++
++ /*!
++ \qmlproperty quaternion DynamicRigidBody::centerOfMassRotation
++
++ Defines the rotation of the center of mass pose, i.e. it specifies the orientation of the body's
++ principal inertia axes relative to the body. Note that this is only used when massMode is set to
++ \c DynamicRigidBody.MassAndInertiaTensor.
++
++ Default value: \c{(1, 0, 0, 0)}
++
++ \sa massMode, inertiaTensor
++ */
++
++ /*!
++ \qmlproperty list<real> DynamicRigidBody::inertiaMatrix
++
++ Defines the inertia tensor matrix. This is a 3x3 matrix in column-major order. Note that this
++ matrix is expected to be diagonalizable. Note that this is only used when massMode is set to
++ \c DynamicRigidBody.MassAndInertiaMatrix.
++
++ Default value: A 3x3 identity matrix
++
++ \sa massMode, inertiaTensor
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::kinematicPosition
++ \since 6.5
++
++ Defines the position of the object when it is kinematic, i.e. when \l isKinematic is set to \c
++ true. On each iteration of the simulation the physical object will be updated according to this
++ value.
++
++ Default value: \c{(0, 0, 0)}
++
++ \sa isKinematic, kinematicRotation, kinematicEulerRotation, kinematicPivot
++ */
++
++ /*!
++ \qmlproperty quaternion DynamicRigidBody::kinematicRotation
++ \since 6.5
++
++ Defines the rotation of the object when it is kinematic, i.e. when \l isKinematic is set to \c
++ true. On each iteration of the simulation the physical object will be updated according to this
++ value.
++
++ Default value: \c{(1, 0, 0, 0)}
++
++ \sa isKinematic, kinematicPosition, kinematicEulerRotation, kinematicPivot
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::kinematicEulerRotation
++ \since 6.5
++
++ Defines the euler rotation of the object when it is kinematic, i.e. when \l isKinematic is set to \c
++ true. On each iteration of the simulation the physical object will be updated according to this
++ value.
++
++ Default value: \c{(0, 0, 0)}
++
++ \sa isKinematic, kinematicPosition, kinematicEulerRotation, kinematicPivot
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::kinematicPivot
++ \since 6.5
++
++ Defines the pivot of the object when it is kinematic, i.e. when \l isKinematic is set to \c
++ true. On each iteration of the simulation the physical object will be updated according to this
++ value.
++
++ Default value: \c{(0, 0, 0)}
++
++ \sa isKinematic, kinematicPosition, kinematicEulerRotation, kinematicRotation
++ */
++
++ /*!
++ \qmlproperty bool DynamicRigidBody::isSleeping
++ \since 6.9
++
++ Is set to \c{true} if the body is sleeping. While it is technically possible to set this property
++ it should be seen as a read-only property that is set on every frame the physics simulation is
++ running.
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::linearVelocity
++ \readonly
++ \since 6.13
++
++ The linear velocity of the body in scene units per second. The value is updated after each
++ physics frame, making the simulated velocity directly available to physics calculations in
++ QML.
++
++ The value is computed by the simulation, so it changes in response to gravity, contacts and
++ joints as well as to any applied force or impulse.
++ \l setLinearVelocity() overrides it directly, but like the other imperative calls it is
++ queued and applied on the next physics frame, so this property keeps its old value
++ until then.
++
++ For a kinematic body this is the velocity implied by its kinematic target. It is zero
++ while the body is sleeping, and a body whose \l {PhysicsBody::}{simulationEnabled} is
++ \c false counts as sleeping.
++
++ \sa setLinearVelocity(), applyCentralForce(), applyCentralImpulse(), angularVelocity
++ */
++
++ /*!
++ \qmlproperty vector3d DynamicRigidBody::angularVelocity
++ \readonly
++ \since 6.13
++
++ The angular velocity of the body in radians per second. The value is updated after each
++ physics frame, making the simulated velocity directly available to physics calculations
++ in QML.
++
++ The value is computed by the simulation, so it changes in response to contacts, joints
++ and damping as well as to any applied torque or impulse.
++ \l setAngularVelocity() overrides it directly, but like the other imperative calls it
++ is queued and applied on the next physics frame, so this property keeps its old value
++ until then. Note that the underlying engine damps angular motion by default, so a
++ freely spinning body slows down even without contacts.
++
++ For a kinematic body this is the velocity implied by its kinematic target. It is zero
++ while the body is sleeping, and a body whose \l {PhysicsBody::}{simulationEnabled} is
++ \c false counts as sleeping.
++
++ \sa setAngularVelocity(), applyTorque(), applyTorqueImpulse(), linearVelocity
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::applyCentralForce(vector3d force)
++
++ Applies a \a force on the center of the body.
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::applyForce(vector3d force, vector3d position)
++
++ Applies a \a force at a \a position on the body.
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::applyTorque(vector3d torque)
++
++ Applies a \a torque on the body.
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::applyCentralImpulse(vector3d impulse)
++
++ Applies an \a impulse on the center of the body.
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::applyImpulse(vector3d impulse, vector3d position)
++
++ Applies an \a impulse at a \a position on the body.
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::applyTorqueImpulse(vector3d impulse)
++
++ Applies a torque \a impulse on the body.
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::setAngularVelocity(vector3d angularVelocity)
++
++ Sets the \a angularVelocity of the body.
++
++ \sa angularVelocity
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::setLinearVelocity(vector3d linearVelocity)
++
++ Sets the \a linearVelocity of the body.
++
++ \sa linearVelocity
++ */
++
++ /*!
++ \qmlmethod void DynamicRigidBody::reset(vector3d position, vector3d eulerRotation)
++
++ Resets the body's \a position and \a eulerRotation.
++ */
++
++ QDynamicRigidBody::QDynamicRigidBody() = default;
++
++ QDynamicRigidBody::~QDynamicRigidBody()
++ {
++ qDeleteAll(m_commandQueue);
++ m_commandQueue.clear();
++ }
++
++ const QQuaternion &QDynamicRigidBody::centerOfMassRotation() const
++ {
++ return m_centerOfMassRotation;
++ }
++
++ void QDynamicRigidBody::setCenterOfMassRotation(const QQuaternion &newCenterOfMassRotation)
++ {
++ if (!QPhysicsUtils::isFinite(newCenterOfMassRotation)) {
++ qWarning() << "DynamicRigidBody: centerOfMassRotation must be finite, ignoring"
++ << newCenterOfMassRotation;
++ return;
++ }
++
++ if (qFuzzyCompare(m_centerOfMassRotation, newCenterOfMassRotation))
++ return;
++ m_centerOfMassRotation = newCenterOfMassRotation;
++
++ // Only inertia tensor is using rotation
++ if (m_massMode == MassMode::MassAndInertiaTensor)
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaTensor(m_mass, m_inertiaTensor));
++
++ emit centerOfMassRotationChanged();
++ }
++
++ const QVector3D &QDynamicRigidBody::centerOfMassPosition() const
++ {
++ return m_centerOfMassPosition;
++ }
++
++ void QDynamicRigidBody::setCenterOfMassPosition(const QVector3D &newCenterOfMassPosition)
++ {
++ if (!QPhysicsUtils::isFinite(newCenterOfMassPosition)) {
++ qWarning() << "DynamicRigidBody: centerOfMassPosition must be finite, ignoring"
++ << newCenterOfMassPosition;
++ return;
++ }
++
++ if (qFuzzyCompare(m_centerOfMassPosition, newCenterOfMassPosition))
++ return;
++
++ switch (m_massMode) {
++ case MassMode::MassAndInertiaTensor: {
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaTensor(m_mass, m_inertiaTensor));
++ break;
++ }
++ case MassMode::MassAndInertiaMatrix: {
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaMatrix(m_mass, m_inertiaMatrix));
++ break;
++ }
++ case MassMode::DefaultDensity:
++ case MassMode::CustomDensity:
++ case MassMode::Mass:
++ break;
++ }
++
++ m_centerOfMassPosition = newCenterOfMassPosition;
++ emit centerOfMassPositionChanged();
++ }
++
++ QDynamicRigidBody::MassMode QDynamicRigidBody::massMode() const
++ {
++ return m_massMode;
++ }
++
++ void QDynamicRigidBody::setMassMode(const MassMode newMassMode)
++ {
++ if (m_massMode == newMassMode)
++ return;
++
++ switch (newMassMode) {
++ case MassMode::DefaultDensity: {
++ auto world = QPhysicsWorld::getWorld(this);
++ if (world) {
++ m_commandQueue.enqueue(new QPhysicsCommandSetDensity(world->defaultDensity()));
++ } else {
++ qWarning() << "No physics world found, cannot set default density.";
++ }
++ break;
++ }
++ case MassMode::CustomDensity: {
++ m_commandQueue.enqueue(new QPhysicsCommandSetDensity(m_density));
++ break;
++ }
++ case MassMode::Mass: {
++ m_commandQueue.enqueue(new QPhysicsCommandSetMass(m_mass));
++ break;
++ }
++ case MassMode::MassAndInertiaTensor: {
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaTensor(m_mass, m_inertiaTensor));
++ break;
++ }
++ case MassMode::MassAndInertiaMatrix: {
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaMatrix(m_mass, m_inertiaMatrix));
++ break;
++ }
++ }
++
++ m_massMode = newMassMode;
++ emit massModeChanged();
++ }
++
++ const QVector3D &QDynamicRigidBody::inertiaTensor() const
++ {
++ return m_inertiaTensor;
++ }
++
++ void QDynamicRigidBody::setInertiaTensor(const QVector3D &newInertiaTensor)
++ {
++ if (!QPhysicsUtils::isFinite(newInertiaTensor) || newInertiaTensor.x() < 0.f
++ || newInertiaTensor.y() < 0.f || newInertiaTensor.z() < 0.f) {
++ qWarning() << "DynamicRigidBody: inertiaTensor" << newInertiaTensor
++ << "must be finite and non-negative, ignoring.";
++ return;
++ }
++
++ if (qFuzzyCompare(m_inertiaTensor, newInertiaTensor))
++ return;
++ m_inertiaTensor = newInertiaTensor;
++
++ if (m_massMode == MassMode::MassAndInertiaTensor)
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaTensor(m_mass, m_inertiaTensor));
++
++ emit inertiaTensorChanged();
++ }
++
++ const QList<float> &QDynamicRigidBody::readInertiaMatrix() const
++ {
++ return m_inertiaMatrixList;
++ }
++
++ static bool fuzzyEquals(const QList<float> &a, const QList<float> &b)
++ {
++ if (a.length() != b.length())
++ return false;
++
++ const int length = a.length();
++ for (int i = 0; i < length; i++)
++ if (!qFuzzyCompare(a[i], b[i]))
++ return false;
++
++ return true;
++ }
++
++ void QDynamicRigidBody::setInertiaMatrix(const QList<float> &newInertiaMatrix)
++ {
++ if (fuzzyEquals(m_inertiaMatrixList, newInertiaMatrix))
++ return;
++
++ m_inertiaMatrixList = newInertiaMatrix;
++ const int elemsToCopy = qMin(m_inertiaMatrixList.length(), 9);
++ memcpy(m_inertiaMatrix.data(), m_inertiaMatrixList.data(), elemsToCopy * sizeof(float));
++ memset(m_inertiaMatrix.data() + elemsToCopy, 0, (9 - elemsToCopy) * sizeof(float));
++
++ if (m_massMode == MassMode::MassAndInertiaMatrix)
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaMatrix(m_mass, m_inertiaMatrix));
++
++ emit inertiaMatrixChanged();
++ }
++
++ const QMatrix3x3 &QDynamicRigidBody::inertiaMatrix() const
++ {
++ return m_inertiaMatrix;
++ }
++
++ float QDynamicRigidBody::mass() const
++ {
++ return m_mass;
++ }
++
++ bool QDynamicRigidBody::isKinematic() const
++ {
++ return m_isKinematic;
++ }
++
++ QDynamicRigidBody::CCDType QDynamicRigidBody::ccd() const
++ {
++ return m_CCD;
++ }
++
++ bool QDynamicRigidBody::gravityEnabled() const
++ {
++ return m_gravityEnabled;
++ }
++
++ void QDynamicRigidBody::setMass(float mass)
++ {
++ if (!qIsFinite(mass) || mass < 0.f || qFuzzyCompare(m_mass, mass))
++ return;
++
++ switch (m_massMode) {
++ case QDynamicRigidBody::MassMode::Mass:
++ m_commandQueue.enqueue(new QPhysicsCommandSetMass(mass));
++ break;
++ case QDynamicRigidBody::MassMode::MassAndInertiaTensor:
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaTensor(mass, m_inertiaTensor));
++ break;
++ case QDynamicRigidBody::MassMode::MassAndInertiaMatrix:
++ m_commandQueue.enqueue(new QPhysicsCommandSetMassAndInertiaMatrix(mass, m_inertiaMatrix));
++ break;
++ case QDynamicRigidBody::MassMode::DefaultDensity:
++ case QDynamicRigidBody::MassMode::CustomDensity:
++ break;
++ }
++
++ m_mass = mass;
++ emit massChanged(m_mass);
++ }
++
++ float QDynamicRigidBody::density() const
++ {
++ return m_density;
++ }
++
++ void QDynamicRigidBody::setDensity(float density)
++ {
++ density = qBound(0.0000001f, density, PX_MAX_F32);
++
++ if (qFuzzyCompare(m_density, density))
++ return;
++
++ if (m_massMode == MassMode::CustomDensity)
++ m_commandQueue.enqueue(new QPhysicsCommandSetDensity(density));
++
++ m_density = density;
++ emit densityChanged(m_density);
++ }
++
++ void QDynamicRigidBody::setIsKinematic(bool isKinematic)
++ {
++ if (m_isKinematic == isKinematic)
++ return;
++
++ if (hasStaticShapes() && !isKinematic) {
++ qWarning()
++ << "Cannot make body containing trimesh/heightfield/plane non-kinematic, ignoring.";
++ return;
++ }
++
++ m_isKinematic = isKinematic;
++ auto world = QPhysicsWorld::getWorld(this);
++ m_commandQueue.enqueue(
++ new QPhysicsCommandSetIsKinematic(m_isKinematic, world && world->enableCCD()));
++ emit isKinematicChanged(m_isKinematic);
++ }
++
++ void QDynamicRigidBody::setCCD(CCDType newCCD)
++ {
++ if (m_CCD == newCCD)
++ return;
++
++ m_CCD = newCCD;
++ auto world = QPhysicsWorld::getWorld(this);
++ m_commandQueue.enqueue(new QPhysicsCommandSetCCD(m_CCD, world && world->enableCCD()));
++ emit ccdChanged();
++ }
++
++ void QDynamicRigidBody::setGravityEnabled(bool gravityEnabled)
++ {
++ if (m_gravityEnabled == gravityEnabled)
++ return;
++
++ m_gravityEnabled = gravityEnabled;
++ m_commandQueue.enqueue(new QPhysicsCommandSetGravityEnabled(m_gravityEnabled));
++ emit gravityEnabledChanged();
++ }
++
++ void QDynamicRigidBody::setAngularVelocity(const QVector3D &angularVelocity)
++ {
++ if (!QPhysicsUtils::isFinite(angularVelocity)) {
++ qWarning() << "DynamicRigidBody: angularVelocity must be finite, ignoring"
++ << angularVelocity;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandSetAngularVelocity(angularVelocity));
++ }
++
++ QDynamicRigidBody::AxisLock QDynamicRigidBody::linearAxisLock() const
++ {
++ return m_linearAxisLock;
++ }
++
++ void QDynamicRigidBody::setLinearAxisLock(AxisLock newAxisLockLinear)
++ {
++ if (m_linearAxisLock == newAxisLockLinear)
++ return;
++ m_linearAxisLock = newAxisLockLinear;
++ emit linearAxisLockChanged();
++ }
++
++ QDynamicRigidBody::AxisLock QDynamicRigidBody::angularAxisLock() const
++ {
++ return m_angularAxisLock;
++ }
++
++ void QDynamicRigidBody::setAngularAxisLock(AxisLock newAxisLockAngular)
++ {
++ if (m_angularAxisLock == newAxisLockAngular)
++ return;
++ m_angularAxisLock = newAxisLockAngular;
++ emit angularAxisLockChanged();
++ }
++
++ QQueue<QPhysicsCommand *> &QDynamicRigidBody::commandQueue()
++ {
++ return m_commandQueue;
++ }
++
++ void QDynamicRigidBody::updateDefaultDensity(float defaultDensity)
++ {
++ if (m_massMode == MassMode::DefaultDensity)
++ m_commandQueue.enqueue(new QPhysicsCommandSetDensity(defaultDensity));
++ }
++
++ void QDynamicRigidBody::applyCentralForce(const QVector3D &force)
++ {
++ if (!QPhysicsUtils::isFinite(force)) {
++ qWarning() << "DynamicRigidBody: applyCentralForce() force must be finite, ignoring"
++ << force;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandApplyCentralForce(force));
++ }
++
++ void QDynamicRigidBody::applyForce(const QVector3D &force, const QVector3D &position)
++ {
++ if (!QPhysicsUtils::isFinite(force) || !QPhysicsUtils::isFinite(position)) {
++ qWarning() << "DynamicRigidBody: applyForce() force/position must be finite, ignoring"
++ << force << position;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandApplyForce(force, position));
++ }
++
++ void QDynamicRigidBody::applyTorque(const QVector3D &torque)
++ {
++ if (!QPhysicsUtils::isFinite(torque)) {
++ qWarning() << "DynamicRigidBody: applyTorque() torque must be finite, ignoring" << torque;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandApplyTorque(torque));
++ }
++
++ void QDynamicRigidBody::applyCentralImpulse(const QVector3D &impulse)
++ {
++ if (!QPhysicsUtils::isFinite(impulse)) {
++ qWarning() << "DynamicRigidBody: applyCentralImpulse() impulse must be finite, ignoring"
++ << impulse;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandApplyCentralImpulse(impulse));
++ }
++
++ void QDynamicRigidBody::applyImpulse(const QVector3D &impulse, const QVector3D &position)
++ {
++ if (!QPhysicsUtils::isFinite(impulse) || !QPhysicsUtils::isFinite(position)) {
++ qWarning() << "DynamicRigidBody: applyImpulse() impulse/position must be finite, ignoring"
++ << impulse << position;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandApplyImpulse(impulse, position));
++ }
++
++ void QDynamicRigidBody::applyTorqueImpulse(const QVector3D &impulse)
++ {
++ if (!QPhysicsUtils::isFinite(impulse)) {
++ qWarning() << "DynamicRigidBody: applyTorqueImpulse() impulse must be finite, ignoring"
++ << impulse;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandApplyTorqueImpulse(impulse));
++ }
++
++ void QDynamicRigidBody::setLinearVelocity(const QVector3D &linearVelocity)
++ {
++ if (!QPhysicsUtils::isFinite(linearVelocity)) {
++ qWarning() << "DynamicRigidBody: linearVelocity must be finite, ignoring"
++ << linearVelocity;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandSetLinearVelocity(linearVelocity));
++ }
++
++ void QDynamicRigidBody::reset(const QVector3D &position, const QVector3D &eulerRotation)
++ {
++ if (!QPhysicsUtils::isFinite(position) || !QPhysicsUtils::isFinite(eulerRotation)) {
++ qWarning() << "DynamicRigidBody: reset() position/eulerRotation must be finite, ignoring"
++ << position << eulerRotation;
++ return;
++ }
++ m_commandQueue.enqueue(new QPhysicsCommandReset(position, eulerRotation));
++ }
++
++ void QDynamicRigidBody::setKinematicRotation(const QQuaternion &rotation)
++ {
++ if (!QPhysicsUtils::isFinite(rotation)) {
++ qWarning() << "DynamicRigidBody: kinematicRotation must be finite, ignoring" << rotation;
++ return;
++ }
++ if (m_kinematicRotation == rotation)
++ return;
++
++ m_kinematicRotation = rotation;
++ emit kinematicRotationChanged(m_kinematicRotation.toQuaternion());
++ emit kinematicEulerRotationChanged(m_kinematicRotation.toEulerAngles());
++ }
++
++ QQuaternion QDynamicRigidBody::kinematicRotation() const
++ {
++ return m_kinematicRotation.toQuaternion();
++ }
++
++ void QDynamicRigidBody::setKinematicEulerRotation(const QVector3D &rotation)
++ {
++ if (!QPhysicsUtils::isFinite(rotation)) {
++ qWarning() << "DynamicRigidBody: kinematicEulerRotation must be finite, ignoring"
++ << rotation;
++ return;
++ }
++ if (m_kinematicRotation == rotation)
++ return;
++
++ m_kinematicRotation = rotation;
++ emit kinematicEulerRotationChanged(m_kinematicRotation.toEulerAngles());
++ emit kinematicRotationChanged(m_kinematicRotation.toQuaternion());
++ }
++
++ QVector3D QDynamicRigidBody::kinematicEulerRotation() const
++ {
++ return m_kinematicRotation.toEulerAngles();
++ }
++
++ void QDynamicRigidBody::setKinematicPivot(const QVector3D &pivot)
++ {
++ if (!QPhysicsUtils::isFinite(pivot)) {
++ qWarning() << "DynamicRigidBody: kinematicPivot must be finite, ignoring" << pivot;
++ return;
++ }
++
++ m_kinematicPivot = pivot;
++ emit kinematicPivotChanged(m_kinematicPivot);
++ }
++
++ QVector3D QDynamicRigidBody::kinematicPivot() const
++ {
++ return m_kinematicPivot;
++ }
++
++ bool QDynamicRigidBody::isSleeping() const
++ {
++ return m_isSleeping;
++ }
++
++ QVector3D QDynamicRigidBody::linearVelocity() const
++ {
++ return m_linearVelocity;
++ }
++
++ QVector3D QDynamicRigidBody::angularVelocity() const
++ {
++ return m_angularVelocity;
++ }
++
++ void QDynamicRigidBody::updateLinearVelocity(const QVector3D &velocity)
++ {
++ if (m_linearVelocity == velocity)
++ return;
++ m_linearVelocity = velocity;
++ emit linearVelocityChanged(m_linearVelocity);
++ }
++
++ void QDynamicRigidBody::updateAngularVelocity(const QVector3D &velocity)
++ {
++ if (m_angularVelocity == velocity)
++ return;
++ m_angularVelocity = velocity;
++ emit angularVelocityChanged(m_angularVelocity);
++ }
++
++ void QDynamicRigidBody::setIsSleeping(bool newIsSleeping)
++ {
++ if (m_isSleeping == newIsSleeping)
++ return;
++
++ m_isSleeping = newIsSleeping;
++ emit isSleepingChanged(newIsSleeping);
++ }
++
++ QAbstractPhysXNode *QDynamicRigidBody::createPhysXBackend()
++ {
++ return new QPhysXDynamicBody(this);
++ }
++
++ void QDynamicRigidBody::setKinematicPosition(const QVector3D &position)
++ {
++ if (!QPhysicsUtils::isFinite(position)) {
++ qWarning() << "DynamicRigidBody: kinematicPosition must be finite, ignoring" << position;
++ return;
++ }
++
++ m_kinematicPosition = position;
++ emit kinematicPositionChanged(m_kinematicPosition);
++ }
++
++ QVector3D QDynamicRigidBody::kinematicPosition() const
++ {
++ return m_kinematicPosition;
++ }
++
++ QT_END_NAMESPACE