PhysicsUpdateContext.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/BodyPair.h>
#include <Jolt/Physics/Collision/ContactListener.h>
#include <Jolt/Physics/Collision/BroadPhase/BroadPhase.h>
#include <Jolt/Core/StaticArray.h>
#include <Jolt/Core/JobSystem.h>
#include <Jolt/Core/STLTempAllocator.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;
class IslandBuilder;
class Constraint;
class TempAllocator;
 
class PhysicsUpdateContext : public NonCopyable
{
public:
    explicit                PhysicsUpdateContext(TempAllocator &inTempAllocator);
                            ~PhysicsUpdateContext();
 
    static constexpr int    cMaxConcurrency = 32;                                   
    static constexpr int    cMaxSubSteps = 4;                                       
 
    using JobHandleArray = StaticArray<JobHandle, cMaxConcurrency>;
 
    struct Step;
 
    struct SubStep
    {
        Step *              mStep;                                                  
 
        bool                mIsFirst;                                               
        bool                mIsLast;                                                
        bool                mIsFirstOfAll;                                          
        bool                mIsLastOfAll;                                           
 
        atomic<uint32>      mSolveVelocityConstraintsNextIsland { 0 };              
        atomic<uint32>      mSolvePositionConstraintsNextIsland { 0 };              
 
        struct CCDBody
        {
                            CCDBody(BodyID inBodyID1, Vec3Arg inDeltaPosition, float inLinearCastThresholdSq, float inMaxPenetration) : mDeltaPosition(inDeltaPosition), mBodyID1(inBodyID1), mLinearCastThresholdSq(inLinearCastThresholdSq), mMaxPenetration(inMaxPenetration) { }
 
            Vec3            mDeltaPosition;                                         
            Vec3            mContactNormal;                                         
            RVec3           mContactPointOn2;                                       
            BodyID          mBodyID1;                                               
            BodyID          mBodyID2;                                               
            float           mFraction = 1.0f;                                       
            float           mFractionPlusSlop = 1.0f;                               
            float           mLinearCastThresholdSq;                                 
            float           mMaxPenetration;                                        
            ContactSettings mContactSettings;                                       
        };
        atomic<uint32>      mIntegrateVelocityReadIdx { 0 };                        
        CCDBody *           mCCDBodies = nullptr;                                   
        uint32              mCCDBodiesCapacity = 0;                                 
        atomic<uint32>      mNumCCDBodies = 0;                                      
        atomic<uint32>      mNextCCDBody { 0 };                                     
        int *               mActiveBodyToCCDBody = nullptr;                         
        uint32              mNumActiveBodyToCCDBody = 0;                            
 
        JobHandleArray      mSolveVelocityConstraints;                              
        JobHandle           mPreIntegrateVelocity;                                  
        JobHandleArray      mIntegrateVelocity;                                     
        JobHandle           mPostIntegrateVelocity;                                 
        JobHandle           mResolveCCDContacts;                                    
        JobHandleArray      mSolvePositionConstraints;                              
        JobHandle           mStartNextSubStep;                                      
    };
 
    using SubSteps = StaticArray<SubStep, cMaxSubSteps>;
 
    struct BodyPairQueue
    {
        atomic<uint32>      mWriteIdx { 0 };                                        
        uint8               mPadding1[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
 
        atomic<uint32>      mReadIdx { 0 };                                         
        uint8               mPadding2[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
    };
 
    using BodyPairQueues = StaticArray<BodyPairQueue, cMaxConcurrency>;
 
    using JobMask = uint32;                                                         
    static_assert(sizeof(JobMask) * 8 >= cMaxConcurrency);
 
    struct Step
    {
                            Step() = default;
                            Step(const Step &)                                      { JPH_ASSERT(false); } // vector needs a copy constructor, but we're never going to call it
 
        PhysicsUpdateContext *mContext;                                             
 
        BroadPhase::UpdateState mBroadPhaseUpdateState;                             
 
        uint32              mNumActiveBodiesAtStepStart;                            
 
        atomic<uint32>      mConstraintReadIdx { 0 };                               
        uint8               mPadding1[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
        
        atomic<uint32>      mNumActiveConstraints { 0 };                            
        uint8               mPadding2[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
        
        atomic<uint32>      mStepListenerReadIdx { 0 };                             
        uint8               mPadding3[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
        
        atomic<uint32>      mApplyGravityReadIdx { 0 };                             
        uint8               mPadding4[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
 
        atomic<uint32>      mActiveBodyReadIdx { 0 };                               
        uint8               mPadding5[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];
 
        BodyPairQueues      mBodyPairQueues;                                        
 
        uint32              mMaxBodyPairsPerQueue;                                  
 
        atomic<JobMask>     mActiveFindCollisionJobs;                               
 
        atomic<uint>        mNumBodyPairs { 0 };                                    
        atomic<uint>        mNumManifolds { 0 };                                    
 
        // Jobs in order of execution (some run in parallel)
        JobHandle           mBroadPhasePrepare;                                     
        JobHandleArray      mStepListeners;                                         
        JobHandleArray      mDetermineActiveConstraints;                            
        JobHandleArray      mApplyGravity;                                          
        JobHandleArray      mFindCollisions;                                        
        JobHandle           mUpdateBroadphaseFinalize;                              
        JobHandle           mSetupVelocityConstraints;                              
        JobHandle           mBuildIslandsFromConstraints;                           
        JobHandle           mFinalizeIslands;                                       
        JobHandle           mBodySetIslandIndex;                                    
        SubSteps            mSubSteps;                                              
        JobHandle           mContactRemovedCallbacks;                               
        JobHandle           mStartNextStep;                                         
    };
 
    using Steps = std::vector<Step, STLTempAllocator<Step>>;
 
    int                     GetMaxConcurrency() const                               { const int max_concurrency = PhysicsUpdateContext::cMaxConcurrency; return min(max_concurrency, mJobSystem->GetMaxConcurrency()); } 
 
    PhysicsSystem *         mPhysicsSystem;                                         
    TempAllocator *         mTempAllocator;                                         
    JobSystem *             mJobSystem;                                             
    JobSystem::Barrier *    mBarrier;                                               
 
    float                   mStepDeltaTime;                                         
    float                   mSubStepDeltaTime;                                      
    float                   mWarmStartImpulseRatio;                                 
    bool                    mUseLargeIslandSplitter;                                
    atomic<uint32>          mErrors { 0 };                                          
 
    Constraint **           mActiveConstraints = nullptr;                           
 
    BodyPair *              mBodyPairs = nullptr;                                   
 
    IslandBuilder *         mIslandBuilder;                                         
 
    Steps                   mSteps;
};
 
JPH_NAMESPACE_END