PhysicsSystem.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/Body/BodyInterface.h>
#include <Jolt/Physics/Collision/NarrowPhaseQuery.h>
#include <Jolt/Physics/Collision/ContactListener.h>
#include <Jolt/Physics/Constraints/ContactConstraintManager.h>
#include <Jolt/Physics/Constraints/ConstraintManager.h>
#include <Jolt/Physics/IslandBuilder.h>
#include <Jolt/Physics/LargeIslandSplitter.h>
#include <Jolt/Physics/PhysicsUpdateContext.h>
#include <Jolt/Physics/PhysicsSettings.h>
 
JPH_NAMESPACE_BEGIN
 
class JobSystem;
class StateRecorder;
class TempAllocator;
class PhysicsStepListener;
class SoftBodyContactListener;
class SimShapeFilter;

class JPH_EXPORT PhysicsSystem : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE

                                PhysicsSystem()                                             : mContactManager(mPhysicsSettings) JPH_IF_ENABLE_ASSERTS(, mConstraintManager(&mBodyManager)) { }
                                ~PhysicsSystem();

    static constexpr uint       cMaxBodiesLimit = BodyID::cMaxBodyIndex + 1;

    static constexpr uint       cMaxBodyPairsLimit = ContactConstraintManager::cMaxBodyPairsLimit;

    static constexpr uint       cMaxContactConstraintsLimit = ContactConstraintManager::cMaxContactConstraintsLimit;

    void                        Init(uint inMaxBodies, uint inNumBodyMutexes, uint inMaxBodyPairs, uint inMaxContactConstraints, const BroadPhaseLayerInterface &inBroadPhaseLayerInterface, const ObjectVsBroadPhaseLayerFilter &inObjectVsBroadPhaseLayerFilter, const ObjectLayerPairFilter &inObjectLayerPairFilter);

    void                        SetBodyActivationListener(BodyActivationListener *inListener) { mBodyManager.SetBodyActivationListener(inListener); }
    BodyActivationListener *    GetBodyActivationListener() const                           { return mBodyManager.GetBodyActivationListener(); }

    void                        SetContactListener(ContactListener *inListener)             { mContactManager.SetContactListener(inListener); }
    ContactListener *           GetContactListener() const                                  { return mContactManager.GetContactListener(); }

    void                        SetSoftBodyContactListener(SoftBodyContactListener *inListener) { mSoftBodyContactListener = inListener; }
    SoftBodyContactListener *   GetSoftBodyContactListener() const                          { return mSoftBodyContactListener; }

    void                        SetCombineFriction(ContactConstraintManager::CombineFunction inCombineFriction) { mContactManager.SetCombineFriction(inCombineFriction); }
    ContactConstraintManager::CombineFunction GetCombineFriction() const                    { return mContactManager.GetCombineFriction(); }

    void                        SetCombineRestitution(ContactConstraintManager::CombineFunction inCombineRestitution) { mContactManager.SetCombineRestitution(inCombineRestitution); }
    ContactConstraintManager::CombineFunction GetCombineRestitution() const                 { return mContactManager.GetCombineRestitution(); }

    void                        SetSimShapeFilter(const SimShapeFilter *inShapeFilter)      { mSimShapeFilter = inShapeFilter; }
    const SimShapeFilter *      GetSimShapeFilter() const                                   { return mSimShapeFilter; }

    using SimCollideBodyVsBody = std::function<void(const Body &inBody1, const Body &inBody2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, CollideShapeSettings &ioCollideShapeSettings, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter)>;

    void                        SetSimCollideBodyVsBody(const SimCollideBodyVsBody &inBodyVsBody) { mSimCollideBodyVsBody = inBodyVsBody; }
    const SimCollideBodyVsBody &GetSimCollideBodyVsBody() const                             { return mSimCollideBodyVsBody; }

    static void                 sDefaultSimCollideBodyVsBody(const Body &inBody1, const Body &inBody2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, CollideShapeSettings &ioCollideShapeSettings, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter);

    void                        SetPhysicsSettings(const PhysicsSettings &inSettings)       { mPhysicsSettings = inSettings; }
    const PhysicsSettings &     GetPhysicsSettings() const                                  { return mPhysicsSettings; }

    const BodyInterface &       GetBodyInterface() const                                    { return mBodyInterfaceLocking; }
    BodyInterface &             GetBodyInterface()                                          { return mBodyInterfaceLocking; }
    const BodyInterface &       GetBodyInterfaceNoLock() const                              { return mBodyInterfaceNoLock; } 
    BodyInterface &             GetBodyInterfaceNoLock()                                    { return mBodyInterfaceNoLock; } 

    const BroadPhaseQuery &     GetBroadPhaseQuery() const                                  { return *mBroadPhase; }

    const NarrowPhaseQuery &    GetNarrowPhaseQuery() const                                 { return mNarrowPhaseQueryLocking; }
    const NarrowPhaseQuery &    GetNarrowPhaseQueryNoLock() const                           { return mNarrowPhaseQueryNoLock; } 

    void                        AddConstraint(Constraint *inConstraint)                     { mConstraintManager.Add(&inConstraint, 1); }

    void                        RemoveConstraint(Constraint *inConstraint)                  { mConstraintManager.Remove(&inConstraint, 1); }

    void                        AddConstraints(Constraint **inConstraints, int inNumber)    { mConstraintManager.Add(inConstraints, inNumber); }

    void                        RemoveConstraints(Constraint **inConstraints, int inNumber) { mConstraintManager.Remove(inConstraints, inNumber); }

    Constraints                 GetConstraints() const                                      { return mConstraintManager.GetConstraints(); }

    void                        OptimizeBroadPhase();

    void                        AddStepListener(PhysicsStepListener *inListener);

    void                        RemoveStepListener(PhysicsStepListener *inListener);

    EPhysicsUpdateError         Update(float inDeltaTime, int inCollisionSteps, TempAllocator *inTempAllocator, JobSystem *inJobSystem);

    void                        SaveState(StateRecorder &inStream, EStateRecorderState inState = EStateRecorderState::All, const StateRecorderFilter *inFilter = nullptr) const;

    bool                        RestoreState(StateRecorder &inStream, const StateRecorderFilter *inFilter = nullptr);

    void                        SaveBodyState(const Body &inBody, StateRecorder &inStream) const;

    void                        RestoreBodyState(Body &ioBody, StateRecorder &inStream);
 
#ifdef JPH_DEBUG_RENDERER
    // Drawing properties
    static bool                 sDrawMotionQualityLinearCast;                               

    void                        DrawBodies(const BodyManager::DrawSettings &inSettings, DebugRenderer *inRenderer, const BodyDrawFilter *inBodyFilter = nullptr) { mBodyManager.Draw(inSettings, mPhysicsSettings, inRenderer, inBodyFilter); }

    void                        DrawConstraints(DebugRenderer *inRenderer)                  { mConstraintManager.DrawConstraints(inRenderer); }

    void                        DrawConstraintLimits(DebugRenderer *inRenderer)             { mConstraintManager.DrawConstraintLimits(inRenderer); }

    void                        DrawConstraintReferenceFrame(DebugRenderer *inRenderer)     { mConstraintManager.DrawConstraintReferenceFrame(inRenderer); }
#endif // JPH_DEBUG_RENDERER

    void                        SetGravity(Vec3Arg inGravity)                               { mGravity = inGravity; }
    Vec3                        GetGravity() const                                          { return mGravity; }

    inline const BodyLockInterfaceNoLock &  GetBodyLockInterfaceNoLock() const              { return mBodyLockInterfaceNoLock; }

    inline const BodyLockInterfaceLocking & GetBodyLockInterface() const                    { return mBodyLockInterfaceLocking; }

    const ObjectVsBroadPhaseLayerFilter &GetObjectVsBroadPhaseLayerFilter() const           { return *mObjectVsBroadPhaseLayerFilter; }

    const ObjectLayerPairFilter &GetObjectLayerPairFilter() const                           { return *mObjectLayerPairFilter; }

    DefaultBroadPhaseLayerFilter GetDefaultBroadPhaseLayerFilter(ObjectLayer inLayer) const { return DefaultBroadPhaseLayerFilter(*mObjectVsBroadPhaseLayerFilter, inLayer); }

    DefaultObjectLayerFilter    GetDefaultLayerFilter(ObjectLayer inLayer) const            { return DefaultObjectLayerFilter(*mObjectLayerPairFilter, inLayer); }

    uint                        GetNumBodies() const                                        { return mBodyManager.GetNumBodies(); }

    uint32                      GetNumActiveBodies(EBodyType inType) const                  { return mBodyManager.GetNumActiveBodies(inType); }

    uint                        GetMaxBodies() const                                        { return mBodyManager.GetMaxBodies(); }

    using BodyStats = BodyManager::BodyStats;

    BodyStats                   GetBodyStats() const                                        { return mBodyManager.GetBodyStats(); }

    void                        GetBodies(BodyIDVector &outBodyIDs) const                   { return mBodyManager.GetBodyIDs(outBodyIDs); }

    void                        GetActiveBodies(EBodyType inType, BodyIDVector &outBodyIDs) const { return mBodyManager.GetActiveBodies(inType, outBodyIDs); }

    const BodyID *              GetActiveBodiesUnsafe(EBodyType inType) const               { return mBodyManager.GetActiveBodiesUnsafe(inType); }

    bool                        WereBodiesInContact(const BodyID &inBody1ID, const BodyID &inBody2ID) const { return mContactManager.WereBodiesInContact(inBody1ID, inBody2ID); }

    AABox                       GetBounds() const                                           { return mBroadPhase->GetBounds(); }
 
#ifdef JPH_TRACK_BROADPHASE_STATS
    void                        ReportBroadphaseStats()                                     { mBroadPhase->ReportStats(); }
#endif // JPH_TRACK_BROADPHASE_STATS
 
#if defined(JPH_TRACK_SIMULATION_STATS) && defined(JPH_PROFILE_ENABLED)
    void                        ReportSimulationStats()                                     { mBodyManager.ReportSimulationStats(); }
#endif
 
private:
    using CCDBody = PhysicsUpdateContext::Step::CCDBody;
 
    // Various job entry points
    void                        JobStepListeners(PhysicsUpdateContext::Step *ioStep);
    void                        JobDetermineActiveConstraints(PhysicsUpdateContext::Step *ioStep) const;
    void                        JobApplyGravity(const PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobSetupVelocityConstraints(float inDeltaTime, PhysicsUpdateContext::Step *ioStep) const;
    void                        JobBuildIslandsFromConstraints(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobFindCollisions(PhysicsUpdateContext::Step *ioStep, int inJobIndex);
    void                        JobFinalizeIslands(PhysicsUpdateContext *ioContext);
    void                        JobBodySetIslandIndex();
    void                        JobSolveVelocityConstraints(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobPreIntegrateVelocity(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobIntegrateVelocity(const PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobPostIntegrateVelocity(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep) const;
    void                        JobFindCCDContacts(const PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobResolveCCDContacts(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobContactRemovedCallbacks(const PhysicsUpdateContext::Step *ioStep);
    void                        JobSolvePositionConstraints(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobSoftBodyPrepare(PhysicsUpdateContext *ioContext, PhysicsUpdateContext::Step *ioStep);
    void                        JobSoftBodyCollide(PhysicsUpdateContext *ioContext) const;
    void                        JobSoftBodySimulate(PhysicsUpdateContext *ioContext, uint inThreadIndex) const;
    void                        JobSoftBodyFinalize(PhysicsUpdateContext *ioContext);

    void                        TrySpawnJobFindCollisions(PhysicsUpdateContext::Step *ioStep) const;
 
#ifdef JPH_TRACK_SIMULATION_STATS
    void                        GatherIslandStats();
#endif
 
    using ContactAllocator = ContactConstraintManager::ContactAllocator;

    void                        ProcessBodyPair(ContactAllocator &ioContactAllocator, const BodyPair &inBodyPair);

    class BodiesToSleep;

    void                        CheckSleepAndUpdateBounds(uint32 inIslandIndex, const PhysicsUpdateContext *ioContext, const PhysicsUpdateContext::Step *ioStep, BodiesToSleep &ioBodiesToSleep);

    static constexpr int        cDetermineActiveConstraintsBatchSize = 64;

    static constexpr int        cSetupVelocityConstraintsBatchSize = 256;

    static constexpr int        cApplyGravityBatchSize = 64;

    static constexpr int        cActiveBodiesBatchSize = 16;

    static constexpr int        cIntegrateVelocityBatchSize = 64;

    static constexpr int        cNarrowPhaseBatchSize = 16;

    static constexpr int        cNumCCDBodiesPerJob = 4;

    const ObjectVsBroadPhaseLayerFilter *mObjectVsBroadPhaseLayerFilter = nullptr;

    const ObjectLayerPairFilter *mObjectLayerPairFilter = nullptr;

    BodyManager                 mBodyManager;

    BodyLockInterfaceNoLock     mBodyLockInterfaceNoLock { mBodyManager };
    BodyLockInterfaceLocking    mBodyLockInterfaceLocking { mBodyManager };

    BodyInterface               mBodyInterfaceNoLock;
    BodyInterface               mBodyInterfaceLocking;

    NarrowPhaseQuery            mNarrowPhaseQueryNoLock;
    NarrowPhaseQuery            mNarrowPhaseQueryLocking;

    BroadPhase *                mBroadPhase = nullptr;

    SoftBodyContactListener *   mSoftBodyContactListener = nullptr;

    const SimShapeFilter *      mSimShapeFilter = nullptr;

    SimCollideBodyVsBody        mSimCollideBodyVsBody = &sDefaultSimCollideBodyVsBody;

    PhysicsSettings             mPhysicsSettings;

    ContactConstraintManager    mContactManager;

    ConstraintManager           mConstraintManager;

    IslandBuilder               mIslandBuilder;

    LargeIslandSplitter         mLargeIslandSplitter;

    Mutex                       mStepListenersMutex;

    using StepListeners = Array<PhysicsStepListener *>;
    StepListeners               mStepListeners;

    Vec3                        mGravity = Vec3(0, -9.81f, 0);

    float                       mPreviousStepDeltaTime = 0.0f;
};
 
JPH_NAMESPACE_END