JoltPhysicsDocs/5.5.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                        mDrawSoftBodyRods = false;

        bool                        mDrawSoftBodyRodStates = false;

        bool                        mDrawSoftBodyRodBendTwistConstraints = 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


#ifdef JPH_TRACK_SIMULATION_STATS

    void                            ResetSimulationStats();


#ifdef JPH_PROFILE_ENABLED

    void                            ReportSimulationStats();

#endif

#endif


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

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

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

ESoftBodyConstraintColor::ConstraintType
@ ConstraintType
Definition BodyManager.h:29

ESoftBodyConstraintColor::ConstraintGroup
@ ConstraintGroup
Draw different types of constraints in different colors.
Definition BodyManager.h:30

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

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

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

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

JPH_EXPORT
#define JPH_EXPORT
Definition Core.h:275

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

uint
unsigned int uint
Definition Core.h:500

JPH_NAMESPACE_END
#define JPH_NAMESPACE_END
Definition Core.h:425

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

JPH_NAMESPACE_BEGIN
#define JPH_NAMESPACE_BEGIN
Definition Core.h:419

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

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
Definition Array.h:36

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

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

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

BodyManager
Definition BodyManager.h:47

BodyManager::AllocateSoftBody
Body * AllocateSoftBody(const SoftBodyCreationSettings &inSoftBodyCreationSettings) const
Create a soft body using creation settings. The returned body will not be part of the body manager ye...
Definition BodyManager.cpp:246

BodyManager::GetNumBodies
uint GetNumBodies() const
Gets the current amount of bodies that are in the body manager.
Definition BodyManager.cpp:136

BodyManager::RemoveBodies
void RemoveBodies(const BodyID *inBodyIDs, int inNumber, Body **outBodies)
Remove a list of bodies from the body manager.
Definition BodyManager.cpp:438

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

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

BodyManager::Init
void Init(uint inMaxBodies, uint inNumBodyMutexes, const BroadPhaseLayerInterface &inLayerInterface)
Initialize the manager.
Definition BodyManager.cpp:106

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

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

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

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

BodyManager::DestroyBodies
void DestroyBodies(const BodyID *inBodyIDs, int inNumber)
Remove a set of bodies from the body manager and frees them.
Definition BodyManager.cpp:471

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

BodyManager::GetBodyStats
BodyStats GetBodyStats() const
Get stats about the bodies in the body manager (slow, iterates through all bodies).
Definition BodyManager.cpp:143

BodyManager::Draw
void Draw(const DrawSettings &inSettings, const PhysicsSettings &inPhysicsSettings, DebugRenderer *inRenderer, const BodyDrawFilter *inBodyFilter=nullptr)
Draw the state of the bodies (debugging purposes).
Definition BodyManager.cpp:916

BodyManager::AddBody
bool AddBody(Body *ioBody)
Add a body to the body manager, assigning it the next available ID. Returns false if no more IDs are ...
Definition BodyManager.cpp:289

BodyManager::GetActiveBodies
void GetActiveBodies(EBodyType inType, BodyIDVector &outBodyIDs) const
Get copy of the list of active bodies under protection of a lock.
Definition BodyManager.cpp:649

BodyManager::AllocateBody
Body * AllocateBody(const BodyCreationSettings &inBodyCreationSettings) const
Create a body using creation settings. The returned body will not be part of the body manager yet.
Definition BodyManager.cpp:186

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

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

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

BodyManager::DeactivateBodies
void DeactivateBodies(const BodyID *inBodyIDs, int inNumber)
Definition BodyManager.cpp:585

BodyManager::FreeBody
void FreeBody(Body *inBody) const
Free a body that has not been added to the body manager yet (if it has, use DestroyBodies).
Definition BodyManager.cpp:282

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

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

BodyManager::AddBodyWithCustomID
bool AddBodyWithCustomID(Body *ioBody, const BodyID &inBodyID)
Add a body to the body manager, assigning it a custom ID. Returns false if the ID is not valid.
Definition BodyManager.cpp:334

BodyManager::EShapeColor
EShapeColor
Definition BodyManager.h:223

BodyManager::EShapeColor::MotionTypeColor
@ MotionTypeColor
Static = grey, keyframed = green, dynamic = random color per instance.
Definition BodyManager.h:226

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

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

BodyManager::ActivateBodies
void ActivateBodies(const BodyID *inBodyIDs, int inNumber)
Definition BodyManager.cpp:548

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

BodyManager::SetMotionQuality
void SetMotionQuality(Body &ioBody, EMotionQuality inMotionQuality)
Update the motion quality for a body.
Definition BodyManager.cpp:629

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

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

DebugRenderer
Definition DebugRenderer.h:47

NonCopyable::NonCopyable
NonCopyable()=default

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

StateRecorder
Definition StateRecorder.h:110

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

BodyManager::BodyStats::mNumBodiesStatic
uint mNumBodiesStatic
Number of static bodies.
Definition BodyManager.h:69

BodyManager::BodyStats::mNumBodiesDynamic
uint mNumBodiesDynamic
Number of dynamic bodies.
Definition BodyManager.h:71

BodyManager::BodyStats::mNumActiveBodiesKinematic
uint mNumActiveBodiesKinematic
Number of kinematic bodies that are currently active.
Definition BodyManager.h:75

BodyManager::BodyStats::mNumActiveBodiesDynamic
uint mNumActiveBodiesDynamic
Number of dynamic bodies that are currently active.
Definition BodyManager.h:72

BodyManager::BodyStats::mNumBodies
uint mNumBodies
Total number of bodies in the body manager.
Definition BodyManager.h:66

BodyManager::BodyStats::mNumBodiesKinematic
uint mNumBodiesKinematic
Number of kinematic bodies.
Definition BodyManager.h:74

BodyManager::BodyStats::mNumActiveSoftBodies
uint mNumActiveSoftBodies
Number of soft bodies that are currently active.
Definition BodyManager.h:78

BodyManager::BodyStats::mNumSoftBodies
uint mNumSoftBodies
Number of soft bodies.
Definition BodyManager.h:77

BodyManager::BodyStats::mMaxBodies
uint mMaxBodies
Max allowed number of bodies in the body manager (as configured in Init(...)).
Definition BodyManager.h:67

BodyManager::DrawSettings
Definition BodyManager.h:244

BodyManager::DrawSettings::mDrawGetSupportFunction
bool mDrawGetSupportFunction
Draw the GetSupport() function, used for convex collision detection.
Definition BodyManager.h:245

BodyManager::DrawSettings::mDrawWorldTransform
bool mDrawWorldTransform
Draw the world transform (which can be different than the center of mass) for each body.
Definition BodyManager.h:253

BodyManager::DrawSettings::mDrawSoftBodyConstraintColor
ESoftBodyConstraintColor mDrawSoftBodyConstraintColor
Coloring scheme to use for soft body constraints.
Definition BodyManager.h:268

BodyManager::DrawSettings::mDrawShapeWireframe
bool mDrawShapeWireframe
When mDrawShape is true and this is true, the shapes will be drawn in wireframe instead of solid.
Definition BodyManager.h:249

BodyManager::DrawSettings::mDrawSoftBodyRodStates
bool mDrawSoftBodyRodStates
Draw the rod states (orientation and angular velocity) of soft bodies.
Definition BodyManager.h:265

BodyManager::DrawSettings::mDrawGetSupportingFace
bool mDrawGetSupportingFace
Draw the faces that were found colliding during collision detection.
Definition BodyManager.h:247

BodyManager::DrawSettings::mDrawSoftBodyPredictedBounds
bool mDrawSoftBodyPredictedBounds
Draw the predicted bounds of soft bodies.
Definition BodyManager.h:267

BodyManager::DrawSettings::mDrawSoftBodyVertices
bool mDrawSoftBodyVertices
Draw the vertices of soft bodies.
Definition BodyManager.h:257

BodyManager::DrawSettings::mDrawShapeColor
EShapeColor mDrawShapeColor
Coloring scheme to use for shapes.
Definition BodyManager.h:250

BodyManager::DrawSettings::mDrawSoftBodyVolumeConstraints
bool mDrawSoftBodyVolumeConstraints
Draw the volume constraints of soft bodies.
Definition BodyManager.h:261

BodyManager::DrawSettings::mDrawVelocity
bool mDrawVelocity
Draw the velocity vector for each body.
Definition BodyManager.h:254

BodyManager::DrawSettings::mDrawSoftBodyLRAConstraints
bool mDrawSoftBodyLRAConstraints
Draw the LRA constraints of soft bodies.
Definition BodyManager.h:263

BodyManager::DrawSettings::mDrawSoftBodyRodBendTwistConstraints
bool mDrawSoftBodyRodBendTwistConstraints
Draw the rod bend twist constraints of soft bodies.
Definition BodyManager.h:266

BodyManager::DrawSettings::mDrawMassAndInertia
bool mDrawMassAndInertia
Draw the mass and inertia (as the box equivalent) for each body.
Definition BodyManager.h:255

BodyManager::DrawSettings::mDrawSoftBodyEdgeConstraints
bool mDrawSoftBodyEdgeConstraints
Draw the edge constraints of soft bodies.
Definition BodyManager.h:259

BodyManager::DrawSettings::mDrawSleepStats
bool mDrawSleepStats
Draw stats regarding the sleeping algorithm of each body.
Definition BodyManager.h:256

BodyManager::DrawSettings::mDrawCenterOfMassTransform
bool mDrawCenterOfMassTransform
Draw the center of mass for each body.
Definition BodyManager.h:252

BodyManager::DrawSettings::mDrawSoftBodyRods
bool mDrawSoftBodyRods
Draw the rods of soft bodies.
Definition BodyManager.h:264

BodyManager::DrawSettings::mDrawSoftBodyBendConstraints
bool mDrawSoftBodyBendConstraints
Draw the bend constraints of soft bodies.
Definition BodyManager.h:260

BodyManager::DrawSettings::mDrawShape
bool mDrawShape
Draw the shapes of all bodies.
Definition BodyManager.h:248

BodyManager::DrawSettings::mDrawSoftBodyVertexVelocities
bool mDrawSoftBodyVertexVelocities
Draw the velocities of the vertices of soft bodies.
Definition BodyManager.h:258

BodyManager::DrawSettings::mDrawBoundingBox
bool mDrawBoundingBox
Draw a bounding box per body.
Definition BodyManager.h:251

BodyManager::DrawSettings::mDrawSoftBodySkinConstraints
bool mDrawSoftBodySkinConstraints
Draw the skin constraints of soft bodies.
Definition BodyManager.h:262

BodyManager::DrawSettings::mDrawSupportDirection
bool mDrawSupportDirection
When drawing the support function, also draw which direction mapped to a specific support point.
Definition BodyManager.h:246

PhysicsSettings
Definition PhysicsSettings.h:28