JoltPhysicsDocs/5.2.0/_body_manager_8h_source.html

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)

// SPDX-FileCopyrightText: 2021 Jorrit Rouwe

// SPDX-License-Identifier: MIT


#pragma once


#include <Jolt/Physics/Body/Body.h>

#include <Jolt/Core/Mutex.h>

#include <Jolt/Core/MutexArray.h>


JPH_NAMESPACE_BEGIN


// Classes

class BodyCreationSettings;

class SoftBodyCreationSettings;

class BodyActivationListener;

class StateRecorderFilter;

struct PhysicsSettings;

#ifdef JPH_DEBUG_RENDERER

class DebugRenderer;

class BodyDrawFilter;

#endif // JPH_DEBUG_RENDERER


#ifdef JPH_DEBUG_RENDERER


enum class ESoftBodyConstraintColor

{

    ConstraintType,

    ConstraintGroup,

    ConstraintOrder,

};


#endif // JPH_DEBUG_RENDERER


using BodyVector = Array<Body *>;


using BodyIDVector = Array<BodyID>;


class JPH_EXPORT BodyManager : public NonCopyable

{

public:

    JPH_OVERRIDE_NEW_DELETE


                                    ~BodyManager();


    void                            Init(uint inMaxBodies, uint inNumBodyMutexes, const BroadPhaseLayerInterface &inLayerInterface);


    uint                            GetNumBodies() const;


    uint                            GetMaxBodies() const                        { return uint(mBodies.capacity()); }


    struct BodyStats

    {

        uint                        mNumBodies                  = 0;

        uint                        mMaxBodies                  = 0;


        uint                        mNumBodiesStatic            = 0;


        uint                        mNumBodiesDynamic           = 0;

        uint                        mNumActiveBodiesDynamic     = 0;


        uint                        mNumBodiesKinematic         = 0;

        uint                        mNumActiveBodiesKinematic   = 0;


        uint                        mNumSoftBodies              = 0;

        uint                        mNumActiveSoftBodies        = 0;

    };


    BodyStats                       GetBodyStats() const;


    Body *                          AllocateBody(const BodyCreationSettings &inBodyCreationSettings) const;


    Body *                          AllocateSoftBody(const SoftBodyCreationSettings &inSoftBodyCreationSettings) const;


    void                            FreeBody(Body *inBody) const;


    bool                            AddBody(Body *ioBody);


    bool                            AddBodyWithCustomID(Body *ioBody, const BodyID &inBodyID);


    void                            RemoveBodies(const BodyID *inBodyIDs, int inNumber, Body **outBodies);


    void                            DestroyBodies(const BodyID *inBodyIDs, int inNumber);


    void                            ActivateBodies(const BodyID *inBodyIDs, int inNumber);


    void                            DeactivateBodies(const BodyID *inBodyIDs, int inNumber);


    void                            SetMotionQuality(Body &ioBody, EMotionQuality inMotionQuality);


    void                            GetActiveBodies(EBodyType inType, BodyIDVector &outBodyIDs) const;


    const BodyID *                  GetActiveBodiesUnsafe(EBodyType inType) const { return mActiveBodies[int(inType)]; }


    uint32                          GetNumActiveBodies(EBodyType inType) const  { return mNumActiveBodies[int(inType)].load(memory_order_acquire); }


    uint32                          GetNumActiveCCDBodies() const               { return mNumActiveCCDBodies; }


    void                            SetBodyActivationListener(BodyActivationListener *inListener);

    BodyActivationListener *        GetBodyActivationListener() const           { return mActivationListener; }


    static inline bool              sIsValidBodyPointer(const Body *inBody)     { return (uintptr_t(inBody) & cIsFreedBody) == 0; }


    const BodyVector &              GetBodies() const                           { return mBodies; }


    BodyVector &                    GetBodies()                                 { return mBodies; }


    void                            GetBodyIDs(BodyIDVector &outBodies) const;


    const Body &                    GetBody(const BodyID &inID) const           { return *mBodies[inID.GetIndex()]; }


    Body &                          GetBody(const BodyID &inID)                 { return *mBodies[inID.GetIndex()]; }


    const Body *                    TryGetBody(const BodyID &inID) const

    {

        uint32 idx = inID.GetIndex();

        if (idx >= mBodies.size())

            return nullptr;


        const Body *body = mBodies[idx];

        if (sIsValidBodyPointer(body) && body->GetID() == inID)

            return body;


        return nullptr;

    }


    Body *                          TryGetBody(const BodyID &inID)

    {

        uint32 idx = inID.GetIndex();

        if (idx >= mBodies.size())

            return nullptr;


        Body *body = mBodies[idx];

        if (sIsValidBodyPointer(body) && body->GetID() == inID)

            return body;


        return nullptr;

    }


    SharedMutex &                   GetMutexForBody(const BodyID &inID) const   { return mBodyMutexes.GetMutexByObjectIndex(inID.GetIndex()); }


    using MutexMask = uint64;


    MutexMask                       GetAllBodiesMutexMask() const               { return mBodyMutexes.GetNumMutexes() == sizeof(MutexMask) * 8? ~MutexMask(0) : (MutexMask(1) << mBodyMutexes.GetNumMutexes()) - 1; }

    MutexMask                       GetMutexMask(const BodyID *inBodies, int inNumber) const;

    void                            LockRead(MutexMask inMutexMask) const;

    void                            UnlockRead(MutexMask inMutexMask) const;

    void                            LockWrite(MutexMask inMutexMask) const;

    void                            UnlockWrite(MutexMask inMutexMask) const;


    void                            LockAllBodies() const;


    void                            UnlockAllBodies() const;


    inline void                     SetBodyObjectLayerInternal(Body &ioBody, ObjectLayer inLayer) const { ioBody.mObjectLayer = inLayer; ioBody.mBroadPhaseLayer = mBroadPhaseLayerInterface->GetBroadPhaseLayer(inLayer); }


    void                            InvalidateContactCacheForBody(Body &ioBody);


    void                            ValidateContactCacheForAllBodies();


    void                            SaveState(StateRecorder &inStream, const StateRecorderFilter *inFilter) const;


    bool                            RestoreState(StateRecorder &inStream);


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


    void                            RestoreBodyState(Body &inBody, StateRecorder &inStream);


#ifdef JPH_DEBUG_RENDERER

    enum class EShapeColor

    {

        InstanceColor,

        ShapeTypeColor,

        MotionTypeColor,

        SleepColor,

        IslandColor,

        MaterialColor,

    };


    struct DrawSettings

    {

        bool                        mDrawGetSupportFunction = false;

        bool                        mDrawSupportDirection = false;

        bool                        mDrawGetSupportingFace = false;

        bool                        mDrawShape = true;

        bool                        mDrawShapeWireframe = false;

        EShapeColor                 mDrawShapeColor = EShapeColor::MotionTypeColor;

        bool                        mDrawBoundingBox = false;

        bool                        mDrawCenterOfMassTransform = false;

        bool                        mDrawWorldTransform = false;

        bool                        mDrawVelocity = false;

        bool                        mDrawMassAndInertia = false;

        bool                        mDrawSleepStats = false;

        bool                        mDrawSoftBodyVertices = false;

        bool                        mDrawSoftBodyVertexVelocities = false;

        bool                        mDrawSoftBodyEdgeConstraints = false;

        bool                        mDrawSoftBodyBendConstraints = false;

        bool                        mDrawSoftBodyVolumeConstraints = false;

        bool                        mDrawSoftBodySkinConstraints = false;

        bool                        mDrawSoftBodyLRAConstraints = false;

        bool                        mDrawSoftBodyPredictedBounds = false;

        ESoftBodyConstraintColor    mDrawSoftBodyConstraintColor = ESoftBodyConstraintColor::ConstraintType;

    };


    void                            Draw(const DrawSettings &inSettings, const PhysicsSettings &inPhysicsSettings, DebugRenderer *inRenderer, const BodyDrawFilter *inBodyFilter = nullptr);

#endif // JPH_DEBUG_RENDERER


#ifdef JPH_ENABLE_ASSERTS

    void                            SetActiveBodiesLocked(bool inLocked)        { mActiveBodiesLocked = inLocked; }


    class GrantActiveBodiesAccess

    {

    public:

        inline GrantActiveBodiesAccess(bool inAllowActivation, bool inAllowDeactivation)

        {

            JPH_ASSERT(!sGetOverrideAllowActivation());

            sSetOverrideAllowActivation(inAllowActivation);


            JPH_ASSERT(!sGetOverrideAllowDeactivation());

            sSetOverrideAllowDeactivation(inAllowDeactivation);

        }


        inline ~GrantActiveBodiesAccess()

        {

            sSetOverrideAllowActivation(false);

            sSetOverrideAllowDeactivation(false);

        }

    };

#endif


#ifdef JPH_DEBUG

    void                            ValidateActiveBodyBounds();

#endif // JPH_DEBUG


private:

#ifdef JPH_COMPILER_CLANG

    __attribute__((no_sanitize("implicit-conversion"))) // We intentionally overflow the uint8 sequence number

#endif

    inline uint8                    GetNextSequenceNumber(int inBodyIndex)      { return ++mBodySequenceNumbers[inBodyIndex]; }


    inline void                     AddBodyToActiveBodies(Body &ioBody);


    inline void                     RemoveBodyFromActiveBodies(Body &ioBody);


    JPH_INLINE Body *               RemoveBodyInternal(const BodyID &inBodyID);


    inline static void              sDeleteBody(Body *inBody);


#if defined(JPH_DEBUG) && defined(JPH_ENABLE_ASSERTS)

    void                            ValidateFreeList() const;

#endif // defined(JPH_DEBUG) && _defined(JPH_ENABLE_ASSERTS)


    BodyVector                      mBodies;


    uint                            mNumBodies = 0;


    static constexpr uintptr_t      cBodyIDFreeListEnd = ~uintptr_t(0);


    static constexpr uintptr_t      cIsFreedBody = uintptr_t(1);


    static constexpr uint           cFreedBodyIndexShift = 1;


    uintptr_t                       mBodyIDFreeListStart = cBodyIDFreeListEnd;


    mutable Mutex                   mBodiesMutex;


    using BodyMutexes = MutexArray<SharedMutex>;

    mutable BodyMutexes             mBodyMutexes;


    Array<uint8>                    mBodySequenceNumbers;


    mutable Mutex                   mActiveBodiesMutex;


    BodyID *                        mActiveBodies[cBodyTypeCount] = { };


    atomic<uint32>                  mNumActiveBodies[cBodyTypeCount] = { };


    uint32                          mNumActiveCCDBodies = 0;


    mutable Mutex                   mBodiesCacheInvalidMutex;


    BodyIDVector                    mBodiesCacheInvalid;


    BodyActivationListener *        mActivationListener = nullptr;


    const BroadPhaseLayerInterface *mBroadPhaseLayerInterface = nullptr;


#ifdef JPH_ENABLE_ASSERTS

    static bool                     sGetOverrideAllowActivation();

    static void                     sSetOverrideAllowActivation(bool inValue);


    static bool                     sGetOverrideAllowDeactivation();

    static void                     sSetOverrideAllowDeactivation(bool inValue);


    bool                            mActiveBodiesLocked = false;

#endif

};


JPH_NAMESPACE_END

Body.h

ESoftBodyConstraintColor
ESoftBodyConstraintColor
Defines how to color soft body constraints.
Definition: BodyManager.h:28

ESoftBodyConstraintColor::ConstraintType
@ ConstraintType

ESoftBodyConstraintColor::ConstraintGroup
@ ConstraintGroup
Draw different types of constraints in different colors.

ESoftBodyConstraintColor::ConstraintOrder
@ ConstraintOrder
Draw constraints in the same group in the same color, non-parallel group will be red.

EBodyType
EBodyType
Type of body.
Definition: BodyType.h:11

uint8
std::uint8_t uint8
Definition: Core.h:453

JPH_EXPORT
#define JPH_EXPORT
Definition: Core.h:236

uint64
std::uint64_t uint64
Definition: Core.h:456

uint
unsigned int uint
Definition: Core.h:452

JPH_NAMESPACE_END
#define JPH_NAMESPACE_END
Definition: Core.h:378

uint32
std::uint32_t uint32
Definition: Core.h:455

JPH_NAMESPACE_BEGIN
#define JPH_NAMESPACE_BEGIN
Definition: Core.h:372

JPH_ASSERT
#define JPH_ASSERT(...)
Definition: IssueReporting.h:33

JPH_OVERRIDE_NEW_DELETE
#define JPH_OVERRIDE_NEW_DELETE
Macro to override the new and delete functions.
Definition: Memory.h:31

EMotionQuality
EMotionQuality
Motion quality, or how well it detects collisions when it has a high velocity.
Definition: MotionQuality.h:11

Mutex.h

MutexArray.h

ObjectLayer
uint16 ObjectLayer
Definition: ObjectLayer.h:16

Array< Body * >

BodyActivationListener
Definition: BodyActivationListener.h:14

BodyCreationSettings
Settings for constructing a rigid body.
Definition: BodyCreationSettings.h:31

BodyDrawFilter
Class function to filter out bodies for debug rendering, returns true if body should be rendered.
Definition: BodyFilter.h:117

Body
Definition: Body.h:35

Body::GetID
JPH_OVERRIDE_NEW_DELETE const BodyID & GetID() const
Get the id of this body.
Definition: Body.h:40

BodyID
ID of a body. This is a way of reasoning about bodies in a multithreaded simulation while avoiding ra...
Definition: BodyID.h:13

BodyID::GetIndex
uint32 GetIndex() const
Get index in body array.
Definition: BodyID.h:43

BodyManager
Class that contains all bodies.
Definition: BodyManager.h:44

BodyManager::sIsValidBodyPointer
static bool sIsValidBodyPointer(const Body *inBody)
Check if this is a valid body pointer. When a body is freed the memory that the pointer occupies is r...
Definition: BodyManager.h:130

BodyManager::GetBody
Body & GetBody(const BodyID &inID)
Access a body (not protected by lock)
Definition: BodyManager.h:145

BodyManager::GetBodyActivationListener
BodyActivationListener * GetBodyActivationListener() const
Definition: BodyManager.h:127

BodyManager::GetNumActiveCCDBodies
uint32 GetNumActiveCCDBodies() const
Get the number of active bodies that are using continuous collision detection.
Definition: BodyManager.h:123

BodyManager::GetAllBodiesMutexMask
MutexMask GetAllBodiesMutexMask() const
Definition: BodyManager.h:183

BodyManager::TryGetBody
Body * TryGetBody(const BodyID &inID)
Access a body, will return a nullptr if the body ID is no longer valid (not protected by lock)
Definition: BodyManager.h:162

BodyManager::GetMutexForBody
SharedMutex & GetMutexForBody(const BodyID &inID) const
Access the mutex for a single body.
Definition: BodyManager.h:176

BodyManager::TryGetBody
const Body * TryGetBody(const BodyID &inID) const
Access a body, will return a nullptr if the body ID is no longer valid (not protected by lock)
Definition: BodyManager.h:148

BodyManager::GetActiveBodiesUnsafe
const BodyID * GetActiveBodiesUnsafe(EBodyType inType) const
Get the list of active bodies. Note: Not thread safe. The active bodies list can change at any moment...
Definition: BodyManager.h:117

BodyManager::GetBodies
const BodyVector & GetBodies() const
Get all bodies. Note that this can contain invalid body pointers, call sIsValidBodyPointer to check.
Definition: BodyManager.h:133

BodyManager::GetBodies
BodyVector & GetBodies()
Get all bodies. Note that this can contain invalid body pointers, call sIsValidBodyPointer to check.
Definition: BodyManager.h:136

BodyManager::GetMaxBodies
uint GetMaxBodies() const
Gets the max bodies that we can support.
Definition: BodyManager.h:58

BodyManager::EShapeColor
EShapeColor
Definition: BodyManager.h:220

BodyManager::SetBodyObjectLayerInternal
void SetBodyObjectLayerInternal(Body &ioBody, ObjectLayer inLayer) const
Function to update body's layer (should only be called by the BodyInterface since it also requires up...
Definition: BodyManager.h:198

BodyManager::GetBody
const Body & GetBody(const BodyID &inID) const
Access a body (not protected by lock)
Definition: BodyManager.h:142

BodyManager::MutexMask
uint64 MutexMask
Bodies are protected using an array of mutexes (so a fixed number, not 1 per body)....
Definition: BodyManager.h:179

BodyManager::GetNumActiveBodies
uint32 GetNumActiveBodies(EBodyType inType) const
Get the number of active bodies.
Definition: BodyManager.h:120

BroadPhaseLayerInterface
Interface that the application should implement to allow mapping object layers to broadphase layers.
Definition: BroadPhaseLayer.h:61

DebugRenderer
Definition: DebugRenderer.h:47

MutexArray
Definition: MutexArray.h:17

Mutex
Definition: Mutex.h:122

NonCopyable
Class that makes another class non-copyable. Usage: Inherit from NonCopyable.
Definition: NonCopyable.h:11

SharedMutex
Definition: Mutex.h:166

SoftBodyCreationSettings
Definition: SoftBodyCreationSettings.h:18

StateRecorderFilter
User callbacks that allow determining which parts of the simulation should be saved by a StateRecorde...
Definition: StateRecorder.h:74

StateRecorder
Definition: StateRecorder.h:105

BodyManager::BodyStats
Helper struct that counts the number of bodies of each type.
Definition: BodyManager.h:62

BodyManager::DrawSettings
Draw settings.
Definition: BodyManager.h:231

PhysicsSettings
Definition: PhysicsSettings.h:28