qphysicsworld_p.h - mozsearch

qt/qtquick3dphysics/src/quick3dphysics/qphysicsworld_p.h (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

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

#define PHYSICSWORLD_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/qtquick3dphysicsglobal.h>

#include <QtCore/QLoggingCategory>

#include <QtCore/QObject>

#include <QtCore/QTimerEvent>

#include <QtCore/QElapsedTimer>

#include <QtCore/QSpan>

#include <QtGui/QVector3D>

#include <QtQml/qqml.h>

#include <QBasicTimer>

#include <QtQuick3DPhysics/private/qquick3dphysicslocationhit_p.h>

#include <QtQuick3D/private/qquick3dviewport_p.h>

namespace physx {

class PxMaterial;

class PxPhysics;

class PxShape;

class PxRigidDynamic;

class PxRigidActor;

class PxRigidStatic;

struct PxCookingParams;

class PxControllerManager;

class PxConvexMesh;

class PxTriangleMesh;

class PxHeightField;

class PxJoint;

QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(lcQuick3dPhysics);

class QAbstractPhysicsNode;

class QAbstractCollisionShape;

class QAbstractRigidBody;

class QAbstractPhysXNode;

class QQuick3DModel;

class QQuick3DGeometry;

class QQuick3DPrincipledMaterial;

class QPhysXWorld;

class FrameAnimator;

class QPhysicsJoint;

class QRaycaster;

class Q_QUICK3DPHYSICS_EXPORT QPhysicsWorld : public QObject, public QQmlParserStatus

    Q_OBJECT

    Q_INTERFACES(QQmlParserStatus)

    Q_PROPERTY(QVector3D gravity READ gravity WRITE setGravity NOTIFY gravityChanged)

    Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)

    Q_PROPERTY(bool forceDebugDraw READ forceDebugDraw WRITE setForceDebugDraw NOTIFY

                       forceDebugDrawChanged)

    Q_PROPERTY(bool enableCCD READ enableCCD WRITE setEnableCCD NOTIFY enableCCDChanged)

    Q_PROPERTY(float typicalLength READ typicalLength WRITE setTypicalLength NOTIFY

                       typicalLengthChanged)

    Q_PROPERTY(

            float typicalSpeed READ typicalSpeed WRITE setTypicalSpeed NOTIFY typicalSpeedChanged)

    Q_PROPERTY(float defaultDensity READ defaultDensity WRITE setDefaultDensity NOTIFY

                       defaultDensityChanged)

    Q_PROPERTY(QQuick3DNode *viewport READ viewport WRITE setViewport NOTIFY viewportChanged

                       REVISION(6, 5))

    Q_PROPERTY(float minimumTimestep READ minimumTimestep WRITE setMinimumTimestep NOTIFY

                       minimumTimestepChanged REVISION(6, 5))

    Q_PROPERTY(float maximumTimestep READ maximumTimestep WRITE setMaximumTimestep NOTIFY

                       maximumTimestepChanged REVISION(6, 5))

    Q_PROPERTY(QQuick3DNode *scene READ scene WRITE setScene NOTIFY sceneChanged REVISION(6, 5))

    Q_PROPERTY(int numThreads READ numThreads WRITE setNumThreads NOTIFY numThreadsChanged

                       REVISION(6, 7))

    Q_PROPERTY(bool reportKinematicKinematicCollisions READ reportKinematicKinematicCollisions WRITE

                       setReportKinematicKinematicCollisions NOTIFY

                               reportKinematicKinematicCollisionsChanged FINAL REVISION(6, 7))

    Q_PROPERTY(bool reportStaticKinematicCollisions READ reportStaticKinematicCollisions WRITE

                       setReportStaticKinematicCollisions NOTIFY

                               reportStaticKinematicCollisionsChanged FINAL REVISION(6, 7))

    Q_PROPERTY(QueryStructure staticQueryStructure READ staticQueryStructure WRITE

                       setStaticQueryStructure NOTIFY staticQueryStructureChanged FINAL REVISION(6, 13))

    Q_PROPERTY(QueryStructure dynamicQueryStructure READ dynamicQueryStructure WRITE

                       setDynamicQueryStructure NOTIFY dynamicQueryStructureChanged FINAL REVISION(6, 13))

    QML_NAMED_ELEMENT(PhysicsWorld)

public:

    enum class QueryStructure {

        NoStructure,  // eNONE

        StaticTree,  // eSTATIC_AABB_TREE

        DynamicTree  // eDYNAMIC_AABB_TREE

};

    Q_ENUM(QueryStructure)

    explicit QPhysicsWorld(QObject *parent = nullptr);

    ~QPhysicsWorld();

    void classBegin() override;

    void componentComplete() override;

    QVector3D gravity() const;

    bool running() const;

    bool forceDebugDraw() const;

    bool enableCCD() const;

    float typicalLength() const;

    float typicalSpeed() const;

    float defaultDensity() const;

    Q_REVISION(6, 5) float minimumTimestep() const;

    Q_REVISION(6, 5) float maximumTimestep() const;

    bool isNodeRemoved(QAbstractPhysicsNode *object);

    static QPhysicsWorld *getWorld(QQuick3DNode *node);

    static QPhysicsWorld *getWorld(QPhysicsJoint *joint);

    static void registerNode(QAbstractPhysicsNode *physicsNode);

    static void deregisterNode(QAbstractPhysicsNode *physicsNode);

    static void registerJoint(QPhysicsJoint *joint);

    static void deregisterJoint(QPhysicsJoint *joint);

    void registerContact(QAbstractPhysicsNode *sender, QAbstractPhysicsNode *receiver,

                         const QVector<QVector3D> &positions, const QVector<QVector3D> &impulses,

                         const QVector<QVector3D> &normals);

    Q_REVISION(6, 5) QQuick3DNode *viewport() const;

    void setHasIndividualDebugDraw();

    physx::PxControllerManager *controllerManager();

    Q_REVISION(6, 5) QQuick3DNode *scene() const;

    Q_REVISION(6, 7) int numThreads() const;

    Q_REVISION(6, 7) bool reportKinematicKinematicCollisions() const;

    Q_REVISION(6, 7)

    void setReportKinematicKinematicCollisions(bool newReportKinematicKinematicCollisions);

    Q_REVISION(6, 7) bool reportStaticKinematicCollisions() const;

    Q_REVISION(6, 7)

    void setReportStaticKinematicCollisions(bool newReportStaticKinematicCollisions);

    void cleanupRemovedJoints();

    Q_REVISION(6, 13) QueryStructure staticQueryStructure() const;

    Q_REVISION(6, 13) void setStaticQueryStructure(QueryStructure newStaticQueryStructure);

    Q_REVISION(6, 13) QueryStructure dynamicQueryStructure() const;

    Q_REVISION(6, 13) void setDynamicQueryStructure(QueryStructure newDynamicQueryStructure);

    Q_REVISION(6, 13) Q_INVOKABLE bool testRaycastQuery(const QVector3D &origin,

                                                        const QVector3D &direction,

                                                        float maxDistance,

                                                        bool includeStatic = true,

                                                        bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE QQuick3DPhysicsLocationHit singleRaycastQuery(const QVector3D &origin,

                                                                                const QVector3D &direction,

                                                                                float maxDistance,

                                                                                bool includeStatic = true,

                                                                                bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE QList<QQuick3DPhysicsLocationHit> multiRaycastQuery(const QVector3D &origin,

                                                                                      const QVector3D &direction,

                                                                                      float maxDistance,

                                                                                      bool includeStatic = true,

                                                                                      bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE bool testSweepQuery(QAbstractCollisionShape *shape,

                                                      const QVector3D &direction,

                                                      float maxDistance,

                                                      bool includeStatic = true,

                                                      bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE QQuick3DPhysicsLocationHit singleSweepQuery(QAbstractCollisionShape *shape,

                                                                              const QVector3D &direction,

                                                                              float maxDistance,

                                                                              bool includeStatic = true,

                                                                              bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE QList<QQuick3DPhysicsLocationHit> multiSweepQuery(QAbstractCollisionShape *shape,

                                                                                    const QVector3D &direction,

                                                                                    float maxDistance,

                                                                                    bool includeStatic = true,

                                                                                    bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE bool testOverlapQuery(QAbstractCollisionShape *shape,

                                                        bool includeStatic = true,

                                                        bool includeDynamic = true) const;

    Q_REVISION(6, 13) Q_INVOKABLE QList<QQuick3DPhysicsQueryHit> multiOverlapQuery(QAbstractCollisionShape *shape,

                                                                                   bool includeStatic = true,

                                                                                   bool includeDynamic = true) const;

public slots:

    void setGravity(QVector3D gravity);

    void setRunning(bool running);

    void setForceDebugDraw(bool forceDebugDraw);

    void setEnableCCD(bool enableCCD);

    void setTypicalLength(float typicalLength);

    void setTypicalSpeed(float typicalSpeed);

    void setDefaultDensity(float defaultDensity);

    Q_REVISION(6, 5) void setViewport(QQuick3DNode *viewport);

    Q_REVISION(6, 5) void setMinimumTimestep(float minTimestep);

    Q_REVISION(6, 5) void setMaximumTimestep(float maxTimestep);

    Q_REVISION(6, 5) void setScene(QQuick3DNode *newScene);

    Q_REVISION(6, 7) void setNumThreads(int newNumThreads);

signals:

    void gravityChanged(QVector3D gravity);

    void runningChanged(bool running);

    void enableCCDChanged(bool enableCCD);

    void forceDebugDrawChanged(bool forceDebugDraw);

    void typicalLengthChanged(float typicalLength);

    void typicalSpeedChanged(float typicalSpeed);

    void defaultDensityChanged(float defaultDensity);

    Q_REVISION(6, 5) void viewportChanged(QQuick3DNode *viewport);

    Q_REVISION(6, 5) void minimumTimestepChanged(float minimumTimestep);

    Q_REVISION(6, 5) void maximumTimestepChanged(float maxTimestep);

    Q_REVISION(6, 5) void frameDone(float timestep);

    Q_REVISION(6, 5) void sceneChanged();

    Q_REVISION(6, 7) void numThreadsChanged();

    Q_REVISION(6, 7) void reportKinematicKinematicCollisionsChanged();

    Q_REVISION(6, 7) void reportStaticKinematicCollisionsChanged();

    Q_REVISION(6, 13) void staticQueryStructureChanged();

    Q_REVISION(6, 13) void dynamicQueryStructureChanged();

private:

    static void registerRaycaster(QRaycaster *raycaster);

    static void deregisterRaycaster(QRaycaster *raycaster);

    QQuick3DPhysicsLocationHit

    closestRaycastHit(const QVector3D &origin, const QVector3D &direction, float maxDistance,

                      bool includeStatic, bool includeDynamic,

                      QSpan<const QAbstractPhysicsNode *const> excludedBodies) const;

    void simulateFrame();

    void frameFinished(float deltaTime);

    void frameFinishedDesignStudio();

    void initPhysics();

    void invalidateTriggerOverlaps(QSpan<QAbstractPhysXNode *const> rebuiltBodies);

    void dropUnreportedTriggerOverlaps();

    void cleanupRemovedNodes();

    void updateDebugDraw();

    void updateDebugDrawDesignStudio();

    void setupDebugMaterials(QQuick3DNode *sceneNode);

    void disableDebugDraw();

    void matchOrphanNodes();

    void matchOrphanJoints();

    void matchOrphanRaycasters();

    void findPhysicsNodes();

    void emitContactCallbacks();

    struct BodyContact

        QAbstractPhysicsNode *sender = nullptr;

        QAbstractPhysicsNode *receiver = nullptr;

        QVector<QVector3D> positions;

        QVector<QVector3D> impulses;

        QVector<QVector3D> normals;

};

    struct DebugModelHolder

        QQuick3DModel *model = nullptr;

        QQuick3DGeometry *geometry = nullptr;

        QVector3D data;

        void *ptr = nullptr;

        void releaseMeshPointer();

        const QVector3D &halfExtents() const;

        void setHalfExtents(const QVector3D &halfExtents);

        float radius() const;

        void setRadius(float radius);

        float heightScale() const;

        void setHeightScale(float heightScale);

        float halfHeight() const;

        void setHalfHeight(float halfHeight);

        float rowScale() const;

        void setRowScale(float rowScale);

        float columnScale() const;

        void setColumnScale(float columnScale);

        physx::PxConvexMesh *getConvexMesh();

        void setConvexMesh(physx::PxConvexMesh *mesh);

        physx::PxTriangleMesh *getTriangleMesh();

        void setTriangleMesh(physx::PxTriangleMesh *mesh);

        physx::PxHeightField *getHeightField();

        void setHeightField(physx::PxHeightField *hf);

};

    QList<QAbstractPhysXNode *> m_physXBodies;

    QList<QPhysicsJoint *> m_joints;

    QList<QRaycaster *> m_raycasters;

    QList<QAbstractPhysicsNode *> m_newPhysicsNodes;

    QHash<QPair<QAbstractCollisionShape *, QAbstractPhysicsNode *>, DebugModelHolder>

            m_DesignStudioDebugModels;

    QHash<QPair<QAbstractCollisionShape *, QAbstractPhysXNode *>, DebugModelHolder>

            m_collisionShapeDebugModels;

    QSet<QAbstractPhysicsNode *> m_removedPhysicsNodes;

    QSet<physx::PxJoint *> m_removedJoints;

    // Whether any trigger is holding shape pairs that are waiting to be reported

    // again after the shapes on one side of them were replaced.

    bool m_triggerOverlapsInvalidated = false;

    QList<BodyContact> m_registeredContacts;

    QVector3D m_gravity = QVector3D(0.f, -981.f, 0.f);

    float m_typicalLength = 100.f; // 100 cm

    float m_typicalSpeed = 1000.f; // 1000 cm/s

    float m_defaultDensity = 0.001f; // 1 g/cm^3

    float m_minTimestep = 1.0f; // 1000 fps

    float m_maxTimestep = 33.333f; // 30 fps

    bool m_running = true;

    bool m_forceDebugDraw = false;

    // For performance, used to keep track if we have indiviually enabled debug drawing for any

    // collision shape

    bool m_hasIndividualDebugDraw = false;

    bool m_physicsInitialized = false;

    bool m_enableCCD = false;

    QPhysXWorld *m_physx = nullptr;

    QQuick3DNode *m_viewport = nullptr;

    QVector<QQuick3DPrincipledMaterial *> m_debugMaterials;

    friend class QQuick3DPhysicsMesh; // TODO: better internal API

    friend class QTriangleMeshShape; //####

    friend class QHeightFieldShape;

    friend class QQuick3DPhysicsHeightField;

    friend class SimulationEventCallback;

    friend class ControllerCallback;

    static physx::PxPhysics *getPhysics();

    static const physx::PxCookingParams *getCookingParams();

    FrameAnimator *m_frameAnimator = nullptr;

    QQuick3DNode *m_scene = nullptr;

    bool m_inDesignStudio = false;

    int m_numThreads = -1;

    bool m_reportKinematicKinematicCollisions = false;

    bool m_reportStaticKinematicCollisions = false;

    QElapsedTimer m_timer;

    float m_currTimeStep = 0.f;

    QList<float> m_frameTimings;

    bool m_frameFetched = false;

    QueryStructure m_staticQueryStructure = QueryStructure::DynamicTree;

    QueryStructure m_dynamicQueryStructure = QueryStructure::DynamicTree;

    friend class QRaycaster;

};

QT_END_NAMESPACE

#endif // PHYSICSWORLD_H