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();
 
    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 = void (*)(const Body &inBody1, const Body &inBody2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, CollideShapeSettings &ioCollideShapeSettings, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter);
 
    void                        SetSimCollideBodyVsBody(SimCollideBodyVsBody inBodyVsBody)  { mSimCollideBodyVsBody = inBodyVsBody; }
    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; }
 
    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
 
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;
 
    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