qdynamicrigidbody.cpp

Go to the documentation of this file.

// 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