qdynamicrigidbody_p.h

// Copyright (C) 2021 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef DYNAMICRIGIDBODY_H

#define DYNAMICRIGIDBODY_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <QtQuick3DPhysics/private/qabstractphysicsbody_p.h>

#include <QtQml/QQmlEngine>

#include <QtCore/QQueue>

#include <QtQuick3DUtils/private/qssgutils_p.h>

#include <QtGui/qquaternion.h>

QT_BEGIN_NAMESPACE

class QPhysicsCommand;

class Q_QUICK3DPHYSICS_EXPORT QDynamicRigidBody : public QAbstractPhysicsBody

public:

    enum class MassMode {

        DefaultDensity,

        CustomDensity,

        Mass,

        MassAndInertiaTensor,

        MassAndInertiaMatrix,

};

    Q_ENUM(MassMode)

    enum class CCDType {

        None,

        SpeculativeCCD,

        SweepBasedCCD,

};

    Q_ENUM(CCDType)

    enum AxisLock {

        LockNone = 0,

        LockX = 1,

        LockY = 2,

        LockZ = 4,

};

    Q_ENUM(AxisLock)

    Q_OBJECT

    Q_PROPERTY(float mass READ mass WRITE setMass NOTIFY massChanged)

    Q_PROPERTY(float density READ density WRITE setDensity NOTIFY densityChanged)

    Q_PROPERTY(AxisLock linearAxisLock READ linearAxisLock WRITE setLinearAxisLock NOTIFY

                       linearAxisLockChanged REVISION(6, 5))

    Q_PROPERTY(AxisLock angularAxisLock READ angularAxisLock WRITE setAngularAxisLock NOTIFY

                       angularAxisLockChanged REVISION(6, 5))

    Q_PROPERTY(CCDType ccd READ ccd WRITE setCCD NOTIFY ccdChanged REVISION(6, 13))

    Q_PROPERTY(bool isKinematic READ isKinematic WRITE setIsKinematic NOTIFY isKinematicChanged)

    Q_PROPERTY(bool gravityEnabled READ gravityEnabled WRITE setGravityEnabled NOTIFY

                       gravityEnabledChanged)

    Q_PROPERTY(MassMode massMode READ massMode WRITE setMassMode NOTIFY massModeChanged)

    Q_PROPERTY(QVector3D inertiaTensor READ inertiaTensor WRITE setInertiaTensor NOTIFY

                       inertiaTensorChanged)

    Q_PROPERTY(QVector3D centerOfMassPosition READ centerOfMassPosition WRITE

                       setCenterOfMassPosition NOTIFY centerOfMassPositionChanged)

    Q_PROPERTY(QQuaternion centerOfMassRotation READ centerOfMassRotation WRITE

                       setCenterOfMassRotation NOTIFY centerOfMassRotationChanged)

    Q_PROPERTY(QList<float> inertiaMatrix READ readInertiaMatrix WRITE setInertiaMatrix NOTIFY

                       inertiaMatrixChanged);

    Q_PROPERTY(QVector3D kinematicPosition READ kinematicPosition WRITE setKinematicPosition NOTIFY

                       kinematicPositionChanged REVISION(6, 5));

    Q_PROPERTY(QVector3D kinematicEulerRotation READ kinematicEulerRotation WRITE

                       setKinematicEulerRotation NOTIFY kinematicEulerRotationChanged REVISION(6,

                                                                                               5));

    Q_PROPERTY(QQuaternion kinematicRotation READ kinematicRotation WRITE setKinematicRotation

                       NOTIFY kinematicRotationChanged REVISION(6, 5));

    Q_PROPERTY(QVector3D kinematicPivot READ kinematicPivot WRITE setKinematicPivot NOTIFY

                       kinematicPivotChanged REVISION(6, 5));

    Q_PROPERTY(bool isSleeping READ isSleeping WRITE setIsSleeping NOTIFY isSleepingChanged

                       REVISION(6, 9));

    Q_PROPERTY(QVector3D linearVelocity READ linearVelocity NOTIFY linearVelocityChanged

                       REVISION(6, 13))

    Q_PROPERTY(QVector3D angularVelocity READ angularVelocity NOTIFY angularVelocityChanged

                       REVISION(6, 13))

    // clang-format off

//    // ??? separate simulation control object? --- some of these have default values in the engine, so we need tristate

//    Q_PROPERTY(float sleepThreshold READ sleepThreshold WRITE setSleepThreshold NOTIFY sleepThresholdChanged)

//    Q_PROPERTY(float stabilizationThreshold READ stabilizationThreshold WRITE setStabilizationThreshold NOTIFY stabilizationThresholdChanged)

//    Q_PROPERTY(float contactReportThreshold READ contactReportThreshold WRITE setContactReportThreshold NOTIFY contactReportThresholdChanged)

//    Q_PROPERTY(float maxContactImpulse READ maxContactImpulse WRITE setMaxContactImpulse NOTIFY maxContactImpulseChanged)

//    Q_PROPERTY(float maxDepenetrationVelocity READ maxDepenetrationVelocity WRITE setMaxDepenetrationVelocity NOTIFY maxDepenetrationVelocityChanged)

//    Q_PROPERTY(float maxAngularVelocity READ maxAngularVelocity WRITE setMaxAngularVelocity NOTIFY maxAngularVelocityChanged)

//    Q_PROPERTY(int minPositionIterationCount READ minPositionIterationCount WRITE setMinPositionIterationCount NOTIFY minPositionIterationCountChanged)

//    Q_PROPERTY(int minVelocityIterationCount READ minVelocityIterationCount WRITE setMinVelocityIterationCount NOTIFY minVelocityIterationCountChanged)

    // clang-format on

    QML_NAMED_ELEMENT(DynamicRigidBody)

public:

    QDynamicRigidBody();

    ~QDynamicRigidBody();

    float mass() const;

    void setMass(float mass);

    float density() const;

    void setDensity(float density);

    bool isKinematic() const;

    void setIsKinematic(bool isKinematic);

    Q_REVISION(6, 13) CCDType ccd() const;

    Q_REVISION(6, 13) void setCCD(CCDType newCCD);

    Q_REVISION(6, 5) AxisLock linearAxisLock() const;

    Q_REVISION(6, 5) void setLinearAxisLock(AxisLock newAxisLockLinear);

    Q_REVISION(6, 5) AxisLock angularAxisLock() const;

    Q_REVISION(6, 5) void setAngularAxisLock(AxisLock newAxisLockAngular);

    bool gravityEnabled() const;

    void setGravityEnabled(bool gravityEnabled);

    Q_INVOKABLE void applyCentralForce(const QVector3D &force);

    Q_INVOKABLE void applyForce(const QVector3D &force, const QVector3D &position);

    Q_INVOKABLE void applyTorque(const QVector3D &torque);

    Q_INVOKABLE void applyCentralImpulse(const QVector3D &impulse);

    Q_INVOKABLE void applyImpulse(const QVector3D &impulse, const QVector3D &position);

    Q_INVOKABLE void applyTorqueImpulse(const QVector3D &impulse);

    Q_INVOKABLE void setAngularVelocity(const QVector3D &angularVelocity);

    Q_INVOKABLE void setLinearVelocity(const QVector3D &linearVelocity);

    Q_INVOKABLE void reset(const QVector3D &position, const QVector3D &eulerRotation);

    // Internal

    QQueue<QPhysicsCommand *> &commandQueue();

    void updateDefaultDensity(float defaultDensity);

    MassMode massMode() const;

    void setMassMode(const MassMode newMassMode);

    const QVector3D &inertiaTensor() const;

    void setInertiaTensor(const QVector3D &newInertiaTensor);

    const QVector3D &centerOfMassPosition() const;

    void setCenterOfMassPosition(const QVector3D &newCenterOfMassPosition);

    const QQuaternion &centerOfMassRotation() const;

    void setCenterOfMassRotation(const QQuaternion &newCenterOfMassRotation);

    const QList<float> &readInertiaMatrix() const;

    void setInertiaMatrix(const QList<float> &newInertiaMatrix);

    const QMatrix3x3 &inertiaMatrix() const;

    Q_REVISION(6, 5) void setKinematicPosition(const QVector3D &position);

    Q_REVISION(6, 5) QVector3D kinematicPosition() const;

    Q_REVISION(6, 5) void setKinematicRotation(const QQuaternion &rotation);

    Q_REVISION(6, 5) QQuaternion kinematicRotation() const;

    Q_REVISION(6, 5) void setKinematicEulerRotation(const QVector3D &rotation);

    Q_REVISION(6, 5) QVector3D kinematicEulerRotation() const;

    Q_REVISION(6, 5) void setKinematicPivot(const QVector3D &pivot);

    Q_REVISION(6, 5) QVector3D kinematicPivot() const;

    Q_REVISION(6, 9) void setIsSleeping(bool newIsSleeping);

    Q_REVISION(6, 9) bool isSleeping() const;

    Q_REVISION(6, 13) QVector3D linearVelocity() const;

    Q_REVISION(6, 13) QVector3D angularVelocity() const;

    void updateLinearVelocity(const QVector3D &velocity);

    void updateAngularVelocity(const QVector3D &velocity);

    QAbstractPhysXNode *createPhysXBackend() final;

Q_SIGNALS:

    void massChanged(float mass);

    void densityChanged(float density);

    void isKinematicChanged(bool isKinematic);

    Q_REVISION(6, 13) void ccdChanged();

    Q_REVISION(6, 5) void linearAxisLockChanged();

    Q_REVISION(6, 5) void angularAxisLockChanged();

    void gravityEnabledChanged();

    void massModeChanged();

    void inertiaTensorChanged();

    void centerOfMassPositionChanged();

    void centerOfMassRotationChanged();

    void inertiaMatrixChanged();

    Q_REVISION(6, 5) void kinematicPositionChanged(const QVector3D &kinematicPosition);

    Q_REVISION(6, 5) void kinematicRotationChanged(const QQuaternion &kinematicRotation);

    Q_REVISION(6, 5) void kinematicEulerRotationChanged(const QVector3D &kinematicEulerRotation);

    Q_REVISION(6, 5) void kinematicPivotChanged(const QVector3D &kinematicPivot);

    Q_REVISION(6, 9) void isSleepingChanged(bool isSleeping);

    Q_REVISION(6, 13) void linearVelocityChanged(const QVector3D &linearVelocity);

    Q_REVISION(6, 13) void angularVelocityChanged(const QVector3D &angularVelocity);

private:

    float m_mass = 1.f;

    float m_density = 0.001f;

    QVector3D m_centerOfMassPosition;

    QQuaternion m_centerOfMassRotation;

    QList<float> m_inertiaMatrixList;

    QMatrix3x3 m_inertiaMatrix;

    QVector3D m_inertiaTensor;

    CCDType m_CCD = CCDType::None;

    bool m_isKinematic = false;

    AxisLock m_linearAxisLock = AxisLock::LockNone;

    AxisLock m_angularAxisLock = AxisLock::LockNone;

    QQueue<QPhysicsCommand *> m_commandQueue;

    bool m_gravityEnabled = true;

    MassMode m_massMode = MassMode::DefaultDensity;

    QVector3D m_kinematicPosition;

    RotationData m_kinematicRotation;

    QVector3D m_kinematicPivot;

    bool m_isSleeping = false;

    QVector3D m_linearVelocity;

    QVector3D m_angularVelocity;

};

QT_END_NAMESPACE

#endif // DYNAMICRIGIDBODY_H

Revision control

Copy as Markdown