JoltPhysicsDocs/4.0.2/_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


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)]; }


    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);


    enum class EShapeColor

    {

        InstanceColor,

        ShapeTypeColor,

        MotionTypeColor,

        SleepColor,

        IslandColor,

        MaterialColor,

    };


#ifdef JPH_DEBUG_RENDERER

    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                        mDrawSoftBodyEdgeConstraints = false;

        bool                        mDrawSoftBodyVolumeConstraints = false;

        bool                        mDrawSoftBodyPredictedBounds = false;

    };


    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 _DEBUG

    void                            ValidateActiveBodyBounds();

#endif // _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(_DEBUG) && defined(JPH_ENABLE_ASSERTS)

    void                            ValidateFreeList() const;

#endif // defined(_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

BodyVector
Array< Body * > BodyVector
Array of bodies.
Definition: BodyManager.h:25

BodyIDVector
Array< BodyID > BodyIDVector
Array of body ID's.
Definition: BodyManager.h:28

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

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

JPH_EXPORT
#define JPH_EXPORT
Definition: Core.h:214

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

uint
unsigned int uint
Definition: Core.h:426

JPH_NAMESPACE_END
#define JPH_NAMESPACE_END
Definition: Core.h:354

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

JPH_NAMESPACE_BEGIN
#define JPH_NAMESPACE_BEGIN
Definition: Core.h:348

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:29

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
std::vector< T, STLAllocator< T > > Array
Definition: STLAllocator.h:81

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:89

Body
Definition: Body.h:35

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

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:32

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:118

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

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

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

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

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:150

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

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:136

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:105

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

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

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

BodyManager::EShapeColor
EShapeColor
Definition: BodyManager.h:207

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:186

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

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

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

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

DebugRenderer
Simple triangle renderer for debugging purposes.
Definition: DebugRenderer.h:30

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:29

StateRecorder
Definition: StateRecorder.h:48

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

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

PhysicsSettings
Definition: PhysicsSettings.h:28