PhysicsUpdateContext.h 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172
  1. // Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
  2. // SPDX-FileCopyrightText: 2021 Jorrit Rouwe
  3. // SPDX-License-Identifier: MIT
  4. #pragma once
  5. #include <Jolt/Physics/Body/BodyPair.h>
  6. #include <Jolt/Physics/Collision/ContactListener.h>
  7. #include <Jolt/Physics/Collision/BroadPhase/BroadPhase.h>
  8. #include <Jolt/Core/StaticArray.h>
  9. #include <Jolt/Core/JobSystem.h>
  10. #include <Jolt/Core/STLTempAllocator.h>
  11. JPH_NAMESPACE_BEGIN
  12. class PhysicsSystem;
  13. class IslandBuilder;
  14. class Constraint;
  15. class TempAllocator;
  16. class SoftBodyUpdateContext;
  17. /// Information used during the Update call
  18. class PhysicsUpdateContext : public NonCopyable
  19. {
  20. public:
  21. /// Destructor
  22. explicit PhysicsUpdateContext(TempAllocator &inTempAllocator);
  23. ~PhysicsUpdateContext();
  24. static constexpr int cMaxConcurrency = 32; ///< Maximum supported amount of concurrent jobs
  25. using JobHandleArray = StaticArray<JobHandle, cMaxConcurrency>;
  26. struct Step;
  27. struct BodyPairQueue
  28. {
  29. atomic<uint32> mWriteIdx { 0 }; ///< Next index to write in mBodyPair array (need to add thread index * mMaxBodyPairsPerQueue and modulo mMaxBodyPairsPerQueue)
  30. uint8 mPadding1[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Moved to own cache line to avoid conflicts with consumer jobs
  31. atomic<uint32> mReadIdx { 0 }; ///< Next index to read in mBodyPair array (need to add thread index * mMaxBodyPairsPerQueue and modulo mMaxBodyPairsPerQueue)
  32. uint8 mPadding2[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Moved to own cache line to avoid conflicts with producer/consumer jobs
  33. };
  34. using BodyPairQueues = StaticArray<BodyPairQueue, cMaxConcurrency>;
  35. using JobMask = uint32; ///< A mask that has as many bits as we can have concurrent jobs
  36. static_assert(sizeof(JobMask) * 8 >= cMaxConcurrency);
  37. /// Structure that contains data needed for each collision step.
  38. struct Step
  39. {
  40. Step() = default;
  41. Step(const Step &) { JPH_ASSERT(false); } // vector needs a copy constructor, but we're never going to call it
  42. PhysicsUpdateContext *mContext; ///< The physics update context
  43. bool mIsFirst; ///< If this is the first step
  44. bool mIsLast; ///< If this is the last step
  45. BroadPhase::UpdateState mBroadPhaseUpdateState; ///< Handle returned by Broadphase::UpdatePrepare
  46. uint32 mNumActiveBodiesAtStepStart; ///< Number of bodies that were active at the start of the physics update step. Only these bodies will receive gravity (they are the first N in the active body list).
  47. atomic<uint32> mDetermineActiveConstraintReadIdx { 0 }; ///< Next constraint for determine active constraints
  48. uint8 mPadding1[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Padding to avoid sharing cache line with the next atomic
  49. atomic<uint32> mNumActiveConstraints { 0 }; ///< Number of constraints in the mActiveConstraints array
  50. uint8 mPadding2[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Padding to avoid sharing cache line with the next atomic
  51. atomic<uint32> mSetupVelocityConstraintsReadIdx { 0 }; ///< Next constraint for setting up velocity constraints
  52. uint8 mPadding3[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Padding to avoid sharing cache line with the next atomic
  53. atomic<uint32> mStepListenerReadIdx { 0 }; ///< Next step listener to call
  54. uint8 mPadding4[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Padding to avoid sharing cache line with the next atomic
  55. atomic<uint32> mApplyGravityReadIdx { 0 }; ///< Next body to apply gravity to
  56. uint8 mPadding5[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Padding to avoid sharing cache line with the next atomic
  57. atomic<uint32> mActiveBodyReadIdx { 0 }; ///< Index of fist active body that has not yet been processed by the broadphase
  58. uint8 mPadding6[JPH_CACHE_LINE_SIZE - sizeof(atomic<uint32>)];///< Padding to avoid sharing cache line with the next atomic
  59. BodyPairQueues mBodyPairQueues; ///< Queues in which to put body pairs that need to be tested by the narrowphase
  60. uint32 mMaxBodyPairsPerQueue; ///< Amount of body pairs that we can queue per queue
  61. atomic<JobMask> mActiveFindCollisionJobs; ///< A bitmask that indicates which jobs are still active
  62. atomic<uint> mNumBodyPairs { 0 }; ///< The number of body pairs found in this step (used to size the contact cache in the next step)
  63. atomic<uint> mNumManifolds { 0 }; ///< The number of manifolds found in this step (used to size the contact cache in the next step)
  64. atomic<uint32> mSolveVelocityConstraintsNextIsland { 0 }; ///< Next island that needs to be processed for the solve velocity constraints step (doesn't need own cache line since position jobs don't run at same time)
  65. atomic<uint32> mSolvePositionConstraintsNextIsland { 0 }; ///< Next island that needs to be processed for the solve position constraints step (doesn't need own cache line since velocity jobs don't run at same time)
  66. /// Contains the information needed to cast a body through the scene to do continuous collision detection
  67. struct CCDBody
  68. {
  69. CCDBody(BodyID inBodyID1, Vec3Arg inDeltaPosition, float inLinearCastThresholdSq, float inMaxPenetration) : mDeltaPosition(inDeltaPosition), mBodyID1(inBodyID1), mLinearCastThresholdSq(inLinearCastThresholdSq), mMaxPenetration(inMaxPenetration) { }
  70. Vec3 mDeltaPosition; ///< Desired rotation step
  71. Vec3 mContactNormal; ///< World space normal of closest hit (only valid if mFractionPlusSlop < 1)
  72. RVec3 mContactPointOn2; ///< World space contact point on body 2 of closest hit (only valid if mFractionPlusSlop < 1)
  73. BodyID mBodyID1; ///< Body 1 (the body that is performing collision detection)
  74. BodyID mBodyID2; ///< Body 2 (the body of the closest hit, only valid if mFractionPlusSlop < 1)
  75. SubShapeID mSubShapeID2; ///< Sub shape of body 2 that was hit (only valid if mFractionPlusSlop < 1)
  76. float mFraction = 1.0f; ///< Fraction at which the hit occurred
  77. float mFractionPlusSlop = 1.0f; ///< Fraction at which the hit occurred + extra delta to allow body to penetrate by mMaxPenetration
  78. float mLinearCastThresholdSq; ///< Maximum allowed squared movement before doing a linear cast (determined by inner radius of shape)
  79. float mMaxPenetration; ///< Maximum allowed penetration (determined by inner radius of shape)
  80. ContactSettings mContactSettings; ///< The contact settings for this contact
  81. };
  82. atomic<uint32> mIntegrateVelocityReadIdx { 0 }; ///< Next active body index to take when integrating velocities
  83. CCDBody * mCCDBodies = nullptr; ///< List of bodies that need to do continuous collision detection
  84. uint32 mCCDBodiesCapacity = 0; ///< Capacity of the mCCDBodies list
  85. atomic<uint32> mNumCCDBodies = 0; ///< Number of CCD bodies in mCCDBodies
  86. atomic<uint32> mNextCCDBody { 0 }; ///< Next unprocessed body index in mCCDBodies
  87. int * mActiveBodyToCCDBody = nullptr; ///< A mapping between an index in BodyManager::mActiveBodies and the index in mCCDBodies
  88. uint32 mNumActiveBodyToCCDBody = 0; ///< Number of indices in mActiveBodyToCCDBody
  89. // Jobs in order of execution (some run in parallel)
  90. JobHandle mBroadPhasePrepare; ///< Prepares the new tree in the background
  91. JobHandleArray mStepListeners; ///< Listeners to notify of the beginning of a physics step
  92. JobHandleArray mDetermineActiveConstraints; ///< Determine which constraints will be active during this step
  93. JobHandleArray mApplyGravity; ///< Update velocities of bodies with gravity
  94. JobHandleArray mFindCollisions; ///< Find all collisions between active bodies an the world
  95. JobHandle mUpdateBroadphaseFinalize; ///< Swap the newly built tree with the current tree
  96. JobHandleArray mSetupVelocityConstraints; ///< Calculate properties for all constraints in the constraint manager
  97. JobHandle mBuildIslandsFromConstraints; ///< Go over all constraints and assign the bodies they're attached to to an island
  98. JobHandle mFinalizeIslands; ///< Finalize calculation simulation islands
  99. JobHandle mBodySetIslandIndex; ///< Set the current island index on each body (not used by the simulation, only for drawing purposes)
  100. JobHandleArray mSolveVelocityConstraints; ///< Solve the constraints in the velocity domain
  101. JobHandle mPreIntegrateVelocity; ///< Setup integration of all body positions
  102. JobHandleArray mIntegrateVelocity; ///< Integrate all body positions
  103. JobHandle mPostIntegrateVelocity; ///< Finalize integration of all body positions
  104. JobHandle mResolveCCDContacts; ///< Updates the positions and velocities for all bodies that need continuous collision detection
  105. JobHandleArray mSolvePositionConstraints; ///< Solve all constraints in the position domain
  106. JobHandle mContactRemovedCallbacks; ///< Calls the contact removed callbacks
  107. JobHandle mSoftBodyPrepare; ///< Prepares updating the soft bodies
  108. JobHandleArray mSoftBodyCollide; ///< Finds all colliding shapes for soft bodies
  109. JobHandleArray mSoftBodySimulate; ///< Simulates all particles
  110. JobHandle mSoftBodyFinalize; ///< Finalizes the soft body update
  111. JobHandle mStartNextStep; ///< Job that kicks the next step (empty for the last step)
  112. };
  113. using Steps = std::vector<Step, STLTempAllocator<Step>>;
  114. /// Maximum amount of concurrent jobs on this machine
  115. int GetMaxConcurrency() const { const int max_concurrency = PhysicsUpdateContext::cMaxConcurrency; return min(max_concurrency, mJobSystem->GetMaxConcurrency()); } ///< Need to put max concurrency in temp var as min requires a reference
  116. PhysicsSystem * mPhysicsSystem; ///< The physics system we belong to
  117. TempAllocator * mTempAllocator; ///< Temporary allocator used during the update
  118. JobSystem * mJobSystem; ///< Job system that processes jobs
  119. JobSystem::Barrier * mBarrier; ///< Barrier used to wait for all physics jobs to complete
  120. float mStepDeltaTime; ///< Delta time for a simulation step (collision step)
  121. float mWarmStartImpulseRatio; ///< Ratio of this step delta time vs last step
  122. atomic<uint32> mErrors { 0 }; ///< Errors that occurred during the update, actual type is EPhysicsUpdateError
  123. Constraint ** mActiveConstraints = nullptr; ///< Constraints that were active at the start of the physics update step (activating bodies can activate constraints and we need a consistent snapshot). Only these constraints will be resolved.
  124. BodyPair * mBodyPairs = nullptr; ///< A list of body pairs found by the broadphase
  125. IslandBuilder * mIslandBuilder; ///< Keeps track of connected bodies and builds islands for multithreaded velocity/position update
  126. Steps mSteps;
  127. uint mNumSoftBodies; ///< Number of active soft bodies in the simulation
  128. SoftBodyUpdateContext * mSoftBodyUpdateContexts = nullptr; ///< Contexts for updating soft bodies
  129. atomic<uint> mSoftBodyToCollide { 0 }; ///< Next soft body to take when running SoftBodyCollide jobs
  130. };
  131. JPH_NAMESPACE_END