Jolt Physics
A multi core friendly Game Physics Engine
Loading...
Searching...
No Matches
Body.h
Go to the documentation of this file.
1// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
2// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
3// SPDX-License-Identifier: MIT
4
5#pragma once
6
19
21
22class StateRecorder;
25
34class
35#ifndef JPH_PLATFORM_DOXYGEN // Doxygen gets confused here
37#endif
38 Body : public NonCopyable
39{
40public:
42
44 inline const BodyID & GetID() const { return mID; }
45
47 inline EBodyType GetBodyType() const { return mBodyType; }
48
50 inline bool IsRigidBody() const { return mBodyType == EBodyType::RigidBody; }
51
53 inline bool IsSoftBody() const { return mBodyType == EBodyType::SoftBody; }
54
55 // See comment at GetIndexInActiveBodiesInternal for reasoning why TSAN is disabled here
58 inline bool IsActive() const { return mMotionProperties != nullptr && mMotionProperties->mIndexInActiveBodies != cInactiveIndex; }
59
61 inline bool IsStatic() const { return mMotionType == EMotionType::Static; }
62
64 inline bool IsKinematic() const { return mMotionType == EMotionType::Kinematic; }
65
67 inline bool IsDynamic() const { return mMotionType == EMotionType::Dynamic; }
68
70 inline bool CanBeKinematicOrDynamic() const { return mMotionProperties != nullptr; }
71
77 inline void SetIsSensor(bool inIsSensor) { JPH_ASSERT(IsRigidBody()); if (inIsSensor) mFlags.fetch_or(uint8(EFlags::IsSensor), memory_order_relaxed); else mFlags.fetch_and(uint8(~uint8(EFlags::IsSensor)), memory_order_relaxed); }
78
80 inline bool IsSensor() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::IsSensor)) != 0; }
81
85 inline void SetCollideKinematicVsNonDynamic(bool inCollide) { JPH_ASSERT(IsRigidBody()); if (inCollide) mFlags.fetch_or(uint8(EFlags::CollideKinematicVsNonDynamic), memory_order_relaxed); else mFlags.fetch_and(uint8(~uint8(EFlags::CollideKinematicVsNonDynamic)), memory_order_relaxed); }
86
88 inline bool GetCollideKinematicVsNonDynamic() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::CollideKinematicVsNonDynamic)) != 0; }
89
94 inline void SetUseManifoldReduction(bool inUseReduction) { JPH_ASSERT(IsRigidBody()); if (inUseReduction) mFlags.fetch_or(uint8(EFlags::UseManifoldReduction), memory_order_relaxed); else mFlags.fetch_and(uint8(~uint8(EFlags::UseManifoldReduction)), memory_order_relaxed); }
95
97 inline bool GetUseManifoldReduction() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::UseManifoldReduction)) != 0; }
98
100 inline bool GetUseManifoldReductionWithBody(const Body &inBody2) const { return ((mFlags.load(memory_order_relaxed) & inBody2.mFlags.load(memory_order_relaxed)) & uint8(EFlags::UseManifoldReduction)) != 0; }
101
103 inline void SetApplyGyroscopicForce(bool inApply) { JPH_ASSERT(IsRigidBody()); if (inApply) mFlags.fetch_or(uint8(EFlags::ApplyGyroscopicForce), memory_order_relaxed); else mFlags.fetch_and(uint8(~uint8(EFlags::ApplyGyroscopicForce)), memory_order_relaxed); }
104
106 inline bool GetApplyGyroscopicForce() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::ApplyGyroscopicForce)) != 0; }
107
109 inline void SetEnhancedInternalEdgeRemoval(bool inApply) { JPH_ASSERT(IsRigidBody()); if (inApply) mFlags.fetch_or(uint8(EFlags::EnhancedInternalEdgeRemoval), memory_order_relaxed); else mFlags.fetch_and(uint8(~uint8(EFlags::EnhancedInternalEdgeRemoval)), memory_order_relaxed); }
110
112 inline bool GetEnhancedInternalEdgeRemoval() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::EnhancedInternalEdgeRemoval)) != 0; }
113
115 inline bool GetEnhancedInternalEdgeRemovalWithBody(const Body &inBody2) const { return ((mFlags.load(memory_order_relaxed) | inBody2.mFlags.load(memory_order_relaxed)) & uint8(EFlags::EnhancedInternalEdgeRemoval)) != 0; }
116
118 inline EMotionType GetMotionType() const { return mMotionType; }
119
121 void SetMotionType(EMotionType inMotionType);
122
124 inline BroadPhaseLayer GetBroadPhaseLayer() const { return mBroadPhaseLayer; }
125
127 inline ObjectLayer GetObjectLayer() const { return mObjectLayer; }
128
132 void SetCollisionGroup(const CollisionGroup &inGroup) { mCollisionGroup = inGroup; }
133
135 bool GetAllowSleeping() const { return mMotionProperties->mAllowSleeping; }
136 void SetAllowSleeping(bool inAllow);
137
139 inline void ResetSleepTimer();
140
142 inline float GetFriction() const { return mFriction; }
143 void SetFriction(float inFriction) { mFriction = inFriction; }
144
146 inline float GetRestitution() const { return mRestitution; }
147 void SetRestitution(float inRestitution) { mRestitution = inRestitution; }
148
150 inline Vec3 GetLinearVelocity() const { return !IsStatic()? mMotionProperties->GetLinearVelocity() : Vec3::sZero(); }
151
154 void SetLinearVelocity(Vec3Arg inLinearVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetLinearVelocity(inLinearVelocity); }
155
158 void SetLinearVelocityClamped(Vec3Arg inLinearVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetLinearVelocityClamped(inLinearVelocity); }
159
161 inline Vec3 GetAngularVelocity() const { return !IsStatic()? mMotionProperties->GetAngularVelocity() : Vec3::sZero(); }
162
165 void SetAngularVelocity(Vec3Arg inAngularVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetAngularVelocity(inAngularVelocity); }
166
169 void SetAngularVelocityClamped(Vec3Arg inAngularVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetAngularVelocityClamped(inAngularVelocity); }
170
172 inline Vec3 GetPointVelocityCOM(Vec3Arg inPointRelativeToCOM) const { return !IsStatic()? mMotionProperties->GetPointVelocityCOM(inPointRelativeToCOM) : Vec3::sZero(); }
173
175 inline Vec3 GetPointVelocity(RVec3Arg inPoint) const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read)); return GetPointVelocityCOM(Vec3(inPoint - mPosition)); }
176
179 inline void AddForce(Vec3Arg inForce) { JPH_ASSERT(IsDynamic()); (Vec3::sLoadFloat3Unsafe(mMotionProperties->mForce) + inForce).StoreFloat3(&mMotionProperties->mForce); }
180
183 inline void AddForce(Vec3Arg inForce, RVec3Arg inPosition);
184
187 inline void AddTorque(Vec3Arg inTorque) { JPH_ASSERT(IsDynamic()); (Vec3::sLoadFloat3Unsafe(mMotionProperties->mTorque) + inTorque).StoreFloat3(&mMotionProperties->mTorque); }
188
189 // Get the total amount of force applied to the center of mass this time step (through AddForce calls). Note that it will reset to zero after PhysicsSystem::Update.
190 inline Vec3 GetAccumulatedForce() const { JPH_ASSERT(IsDynamic()); return mMotionProperties->GetAccumulatedForce(); }
191
192 // Get the total amount of torque applied to the center of mass this time step (through AddForce/AddTorque calls). Note that it will reset to zero after PhysicsSystem::Update.
193 inline Vec3 GetAccumulatedTorque() const { JPH_ASSERT(IsDynamic()); return mMotionProperties->GetAccumulatedTorque(); }
194
195 // Reset the total accumulated force, not that this will be done automatically after every time step.
196 JPH_INLINE void ResetForce() { JPH_ASSERT(IsDynamic()); return mMotionProperties->ResetForce(); }
197
198 // Reset the total accumulated torque, not that this will be done automatically after every time step.
199 JPH_INLINE void ResetTorque() { JPH_ASSERT(IsDynamic()); return mMotionProperties->ResetTorque(); }
200
201 // Reset the current velocity and accumulated force and torque.
202 JPH_INLINE void ResetMotion() { JPH_ASSERT(!IsStatic()); return mMotionProperties->ResetMotion(); }
203
205 inline Mat44 GetInverseInertia() const;
206
209 inline void AddImpulse(Vec3Arg inImpulse);
210
213 inline void AddImpulse(Vec3Arg inImpulse, RVec3Arg inPosition);
214
217 inline void AddAngularImpulse(Vec3Arg inAngularImpulse);
218
221 void MoveKinematic(RVec3Arg inTargetPosition, QuatArg inTargetRotation, float inDeltaTime);
222
229 void GetSubmergedVolume(RVec3Arg inSurfacePosition, Vec3Arg inSurfaceNormal, float &outTotalVolume, float &outSubmergedVolume, Vec3 &outRelativeCenterOfBuoyancy) const;
230
242 bool ApplyBuoyancyImpulse(RVec3Arg inSurfacePosition, Vec3Arg inSurfaceNormal, float inBuoyancy, float inLinearDrag, float inAngularDrag, Vec3Arg inFluidVelocity, Vec3Arg inGravity, float inDeltaTime);
243
256 bool ApplyBuoyancyImpulse(float inTotalVolume, float inSubmergedVolume, Vec3Arg inRelativeCenterOfBuoyancy, float inBuoyancy, float inLinearDrag, float inAngularDrag, Vec3Arg inFluidVelocity, Vec3Arg inGravity, float inDeltaTime);
257
259 inline bool IsInBroadPhase() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::IsInBroadPhase)) != 0; }
260
262 inline bool IsCollisionCacheInvalid() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::InvalidateContactCache)) != 0; }
263
265 inline const Shape * GetShape() const { return mShape; }
266
268 inline RVec3 GetPosition() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read)); return mPosition - mRotation * mShape->GetCenterOfMass(); }
269
271 inline Quat GetRotation() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read)); return mRotation; }
272
274 inline RMat44 GetWorldTransform() const;
275
277 inline RVec3 GetCenterOfMassPosition() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read)); return mPosition; }
278
280 inline RMat44 GetCenterOfMassTransform() const;
281
283 inline RMat44 GetInverseCenterOfMassTransform() const;
284
286 inline const AABox & GetWorldSpaceBounds() const { return mBounds; }
287
289 const MotionProperties *GetMotionProperties() const { JPH_ASSERT(!IsStatic()); return mMotionProperties; }
290 MotionProperties * GetMotionProperties() { JPH_ASSERT(!IsStatic()); return mMotionProperties; }
291
293 const MotionProperties *GetMotionPropertiesUnchecked() const { return mMotionProperties; }
294 MotionProperties * GetMotionPropertiesUnchecked() { return mMotionProperties; }
295
297 uint64 GetUserData() const { return mUserData; }
298 void SetUserData(uint64 inUserData) { mUserData = inUserData; }
299
301 inline Vec3 GetWorldSpaceSurfaceNormal(const SubShapeID &inSubShapeID, RVec3Arg inPosition) const;
302
304 inline TransformedShape GetTransformedShape() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read)); return TransformedShape(mPosition, mRotation, mShape, mID); }
305
307 BodyCreationSettings GetBodyCreationSettings() const;
308
310 SoftBodyCreationSettings GetSoftBodyCreationSettings() const;
311
314
317
320 static inline bool sFindCollidingPairsCanCollide(const Body &inBody1, const Body &inBody2);
321
323 inline void AddPositionStep(Vec3Arg inLinearVelocityTimesDeltaTime) { JPH_ASSERT(IsRigidBody()); JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::ReadWrite)); mPosition += mMotionProperties->LockTranslation(inLinearVelocityTimesDeltaTime); JPH_ASSERT(!mPosition.IsNaN()); }
324 inline void SubPositionStep(Vec3Arg inLinearVelocityTimesDeltaTime) { JPH_ASSERT(IsRigidBody()); JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::ReadWrite)); mPosition -= mMotionProperties->LockTranslation(inLinearVelocityTimesDeltaTime); JPH_ASSERT(!mPosition.IsNaN()); }
325
327 inline void AddRotationStep(Vec3Arg inAngularVelocityTimesDeltaTime);
328 inline void SubRotationStep(Vec3Arg inAngularVelocityTimesDeltaTime);
329
331 inline void SetInBroadPhaseInternal(bool inInBroadPhase) { if (inInBroadPhase) mFlags.fetch_or(uint8(EFlags::IsInBroadPhase), memory_order_relaxed); else mFlags.fetch_and(uint8(~uint8(EFlags::IsInBroadPhase)), memory_order_relaxed); }
332
334 inline bool InvalidateContactCacheInternal() { return (mFlags.fetch_or(uint8(EFlags::InvalidateContactCache), memory_order_relaxed) & uint8(EFlags::InvalidateContactCache)) == 0; }
335
337 inline void ValidateContactCacheInternal() { JPH_IF_ENABLE_ASSERTS(uint8 old_val = ) mFlags.fetch_and(uint8(~uint8(EFlags::InvalidateContactCache)), memory_order_relaxed); JPH_ASSERT((old_val & uint8(EFlags::InvalidateContactCache)) != 0); }
338
340 void CalculateWorldSpaceBoundsInternal();
341
343 void SetPositionAndRotationInternal(RVec3Arg inPosition, QuatArg inRotation, bool inResetSleepTimer = true);
344
348 void UpdateCenterOfMassInternal(Vec3Arg inPreviousCenterOfMass, bool inUpdateMassProperties);
349
353 void SetShapeInternal(const Shape *inShape, bool inUpdateMassProperties);
354
355 // TSAN detects a race between BodyManager::AddBodyToActiveBodies coming from PhysicsSystem::ProcessBodyPair and Body::GetIndexInActiveBodiesInternal coming from PhysicsSystem::ProcessBodyPair.
356 // When PhysicsSystem::ProcessBodyPair activates a body, it updates mIndexInActiveBodies and then updates BodyManager::mNumActiveBodies with release semantics. PhysicsSystem::ProcessBodyPair will
357 // then finish its loop of active bodies and at the end of the loop it will read BodyManager::mNumActiveBodies with acquire semantics to see if any bodies were activated during the loop.
358 // This means that changes to mIndexInActiveBodies must be visible to the thread, so TSANs report must be a false positive. We suppress the warning here.
361 uint32 GetIndexInActiveBodiesInternal() const { return mMotionProperties != nullptr? mMotionProperties->mIndexInActiveBodies : cInactiveIndex; }
362
364 ECanSleep UpdateSleepStateInternal(float inDeltaTime, float inMaxMovement, float inTimeBeforeSleep);
365
367 void SaveState(StateRecorder &inStream) const;
368
370 void RestoreState(StateRecorder &inStream);
371
373
374 static constexpr uint32 cInactiveIndex = MotionProperties::cInactiveIndex;
375
376private:
377 friend class BodyManager;
380
381 Body() = default;
382
383 explicit Body(bool);
384
385 ~Body() { JPH_ASSERT(mMotionProperties == nullptr); }
386
387 inline void GetSleepTestPoints(RVec3 *outPoints) const;
388
389 enum class EFlags : uint8
390 {
391 IsSensor = 1 << 0,
392 CollideKinematicVsNonDynamic = 1 << 1,
393 IsInBroadPhase = 1 << 2,
394 InvalidateContactCache = 1 << 3,
395 UseManifoldReduction = 1 << 4,
396 ApplyGyroscopicForce = 1 << 5,
397 EnhancedInternalEdgeRemoval = 1 << 6,
398 };
399
400 // 16 byte aligned
401 RVec3 mPosition;
402 Quat mRotation;
403 AABox mBounds;
404
405 // 8 byte aligned
408 uint64 mUserData = 0;
409 CollisionGroup mCollisionGroup;
410
411 // 4 byte aligned
412 float mFriction;
413 float mRestitution;
414 BodyID mID;
415
416 // 2 or 4 bytes aligned
417 ObjectLayer mObjectLayer;
418
419 // 1 byte aligned
420 EBodyType mBodyType;
421 BroadPhaseLayer mBroadPhaseLayer;
422 EMotionType mMotionType;
423 atomic<uint8> mFlags = 0;
424
425 // 122 bytes up to here (64-bit mode, single precision, 16-bit ObjectLayer)
426};
427
428static_assert(JPH_CPU_ADDRESS_BITS != 64 || sizeof(Body) == JPH_IF_SINGLE_PRECISION_ELSE(128, 160), "Body size is incorrect");
429static_assert(alignof(Body) == JPH_RVECTOR_ALIGNMENT, "Body should properly align");
430
432
433#include "Body.inl"
EBodyType
Type of body.
Definition BodyType.h:11
@ RigidBody
Rigid body consisting of a rigid shape.
@ SoftBody
Soft body consisting of a deformable shape.
std::uint8_t uint8
Definition Core.h:486
std::uint64_t uint64
Definition Core.h:489
#define JPH_TSAN_NO_SANITIZE
Definition Core.h:629
#define JPH_NAMESPACE_END
Definition Core.h:418
std::uint32_t uint32
Definition Core.h:488
#define JPH_EXPORT_GCC_BUG_WORKAROUND
Definition Core.h:279
#define JPH_IF_SINGLE_PRECISION_ELSE(s, d)
Definition Core.h:563
#define JPH_NAMESPACE_BEGIN
Definition Core.h:412
#define JPH_IF_ENABLE_ASSERTS(...)
Definition IssueReporting.h:35
#define JPH_ASSERT(...)
Definition IssueReporting.h:33
#define JPH_OVERRIDE_NEW_DELETE
Macro to override the new and delete functions.
Definition Memory.h:31
ECanSleep
Enum that determines if an object can go to sleep.
Definition MotionProperties.h:22
EMotionType
Motion type of a physics body.
Definition MotionType.h:11
@ Kinematic
Movable using velocities only, does not respond to forces.
@ Static
Non movable.
@ Dynamic
Responds to forces as a normal physics object.
uint16 ObjectLayer
Definition ObjectLayer.h:16
#define JPH_RVECTOR_ALIGNMENT
Definition Real.h:34
Axis aligned box.
Definition AABox.h:16
Settings for constructing a rigid body.
Definition BodyCreationSettings.h:31
Definition Body.h:39
Vec3 GetPointVelocity(RVec3Arg inPoint) const
Velocity of point inPoint (in world space, e.g. on the surface of the body) of the body (unit: m/s)
Definition Body.h:175
bool IsInBroadPhase() const
Check if this body has been added to the physics system.
Definition Body.h:259
const MotionProperties * GetMotionProperties() const
Access to the motion properties.
Definition Body.h:289
RVec3 GetCenterOfMassPosition() const
Gets the world space position of this body's center of mass.
Definition Body.h:277
EMotionType GetMotionType() const
Get the bodies motion type.
Definition Body.h:118
void SetAngularVelocity(Vec3Arg inAngularVelocity)
Definition Body.h:165
void SetCollisionGroup(const CollisionGroup &inGroup)
Definition Body.h:132
Vec3 GetPointVelocityCOM(Vec3Arg inPointRelativeToCOM) const
Velocity of point inPoint (in center of mass space, e.g. on the surface of the body) of the body (uni...
Definition Body.h:172
bool IsDynamic() const
Check if this body is dynamic, which means that it moves and forces can act on it.
Definition Body.h:67
bool GetAllowSleeping() const
If this body can go to sleep. Note that disabling sleeping on a sleeping object will not wake it up.
Definition Body.h:135
bool IsSensor() const
Check if this body is a sensor.
Definition Body.h:80
bool GetEnhancedInternalEdgeRemovalWithBody(const Body &inBody2) const
Checks if the combination of this body and inBody2 should use enhanced internal edge removal.
Definition Body.h:115
const AABox & GetWorldSpaceBounds() const
Get world space bounding box.
Definition Body.h:286
void SubPositionStep(Vec3Arg inLinearVelocityTimesDeltaTime)
Definition Body.h:324
void SetUserData(uint64 inUserData)
Definition Body.h:298
bool IsSoftBody() const
Check if this body is a soft body.
Definition Body.h:53
const Shape * GetShape() const
Get the shape of this body.
Definition Body.h:265
bool InvalidateContactCacheInternal()
Invalidate the contact cache (should only be called by the BodyManager), will be reset the next simul...
Definition Body.h:334
uint64 GetUserData() const
Access to the user data, can be used for anything by the application.
Definition Body.h:297
BroadPhaseLayer GetBroadPhaseLayer() const
Get broadphase layer, this determines in which broad phase sub-tree the object is placed.
Definition Body.h:124
float GetRestitution() const
Restitution (dimensionless number, usually between 0 and 1, 0 = completely inelastic collision respon...
Definition Body.h:146
const CollisionGroup & GetCollisionGroup() const
Collision group and sub-group ID, determines which other objects it collides with.
Definition Body.h:130
void SetIsSensor(bool inIsSensor)
Definition Body.h:77
void SetLinearVelocityClamped(Vec3Arg inLinearVelocity)
Definition Body.h:158
JPH_TSAN_NO_SANITIZE uint32 GetIndexInActiveBodiesInternal() const
Access to the index in the BodyManager::mActiveBodies list.
Definition Body.h:361
bool GetUseManifoldReductionWithBody(const Body &inBody2) const
Checks if the combination of this body and inBody2 should use manifold reduction.
Definition Body.h:100
void SetLinearVelocity(Vec3Arg inLinearVelocity)
Definition Body.h:154
Vec3 GetLinearVelocity() const
Get world space linear velocity of the center of mass (unit: m/s)
Definition Body.h:150
ObjectLayer GetObjectLayer() const
Get object layer, this determines which other objects it collides with.
Definition Body.h:127
void SetRestitution(float inRestitution)
Definition Body.h:147
bool IsCollisionCacheInvalid() const
Check if this body has been changed in such a way that the collision cache should be considered inval...
Definition Body.h:262
bool IsRigidBody() const
Check if this body is a rigid body.
Definition Body.h:50
bool IsStatic() const
Check if this body is static (not movable)
Definition Body.h:61
EBodyType GetBodyType() const
Get the type of body (rigid or soft)
Definition Body.h:47
void SetEnhancedInternalEdgeRemoval(bool inApply)
Set to indicate that extra effort should be made to try to remove ghost contacts (collisions with int...
Definition Body.h:109
bool GetCollideKinematicVsNonDynamic() const
Check if kinematic objects can generate contact points against other kinematic or static objects.
Definition Body.h:88
void SetUseManifoldReduction(bool inUseReduction)
Definition Body.h:94
static Body sFixedToWorld
A dummy body that can be used by constraints to attach a constraint to the world instead of another b...
Definition Body.h:313
void SetAngularVelocityClamped(Vec3Arg inAngularVelocity)
Definition Body.h:169
JPH_INLINE void ResetForce()
Definition Body.h:196
Vec3 GetAccumulatedTorque() const
Definition Body.h:193
bool CanBeKinematicOrDynamic() const
Check if a body could be made kinematic or dynamic (if it was created dynamic or with mAllowDynamicOr...
Definition Body.h:70
bool GetEnhancedInternalEdgeRemoval() const
Check if enhanced internal edge removal is turned on.
Definition Body.h:112
JPH_TSAN_NO_SANITIZE bool IsActive() const
If this body is currently actively simulating (true) or sleeping (false)
Definition Body.h:58
void SetInBroadPhaseInternal(bool inInBroadPhase)
Flag if body is in the broadphase (should only be called by the BroadPhase)
Definition Body.h:331
MotionProperties * GetMotionProperties()
Definition Body.h:290
Quat GetRotation() const
World space rotation of the body.
Definition Body.h:271
TransformedShape GetTransformedShape() const
Get the transformed shape of this body, which can be used to do collision detection outside of a body...
Definition Body.h:304
JPH_INLINE void ResetTorque()
Definition Body.h:199
bool IsKinematic() const
Check if this body is kinematic (keyframed), which means that it will move according to its current v...
Definition Body.h:64
float GetFriction() const
Friction (dimensionless number, usually between 0 and 1, 0 = no friction, 1 = friction force equals f...
Definition Body.h:142
const MotionProperties * GetMotionPropertiesUnchecked() const
Access to the motion properties (version that does not check if the object is kinematic or dynamic)
Definition Body.h:293
CollisionGroup & GetCollisionGroup()
Definition Body.h:131
void SetApplyGyroscopicForce(bool inApply)
Set to indicate that the gyroscopic force should be applied to this body (aka Dzhanibekov effect,...
Definition Body.h:103
JPH_OVERRIDE_NEW_DELETE const BodyID & GetID() const
Get the id of this body.
Definition Body.h:44
MotionProperties * GetMotionPropertiesUnchecked()
Definition Body.h:294
Vec3 GetAccumulatedForce() const
Definition Body.h:190
Vec3 GetAngularVelocity() const
Get world space angular velocity of the center of mass (unit: rad/s)
Definition Body.h:161
RVec3 GetPosition() const
World space position of the body.
Definition Body.h:268
void AddForce(Vec3Arg inForce)
Definition Body.h:179
void SetCollideKinematicVsNonDynamic(bool inCollide)
Definition Body.h:85
bool GetUseManifoldReduction() const
Check if this body can use manifold reduction.
Definition Body.h:97
JPH_INLINE void ResetMotion()
Definition Body.h:202
void AddTorque(Vec3Arg inTorque)
Definition Body.h:187
void ValidateContactCacheInternal()
Reset the collision cache invalid flag (should only be called by the BodyManager).
Definition Body.h:337
void SetFriction(float inFriction)
Definition Body.h:143
bool GetApplyGyroscopicForce() const
Check if the gyroscopic force is being applied for this body.
Definition Body.h:106
void AddPositionStep(Vec3Arg inLinearVelocityTimesDeltaTime)
Update position using an Euler step (used during position integrate & constraint solving)
Definition Body.h:323
ID of a body. This is a way of reasoning about bodies in a multithreaded simulation while avoiding ra...
Definition BodyID.h:13
Class that contains all bodies.
Definition BodyManager.h:44
Definition BodyManager.cpp:52
Definition BroadPhaseLayer.h:18
Definition CollisionGroup.h:20
Holds a 4x4 matrix of floats, but supports also operations on the 3x3 upper left part of the matrix.
Definition Mat44.h:13
The Body class only keeps track of state for static bodies, the MotionProperties class keeps the addi...
Definition MotionProperties.h:29
static constexpr uint32 cInactiveIndex
Constant indicating that body is not active.
Definition MotionProperties.h:233
Class that makes another class non-copyable. Usage: Inherit from NonCopyable.
Definition NonCopyable.h:11
Definition Quat.h:33
Definition Reference.h:163
Base class for all shapes (collision volume of a body). Defines a virtual interface for collision det...
Definition Shape.h:186
Definition SoftBodyCreationSettings.h:18
float mFriction
Friction coefficient when colliding.
Definition SoftBodyCreationSettings.h:65
Quat mRotation
Initial rotation of the soft body.
Definition SoftBodyCreationSettings.h:52
RVec3 mPosition
Initial position of the soft body.
Definition SoftBodyCreationSettings.h:51
float mRestitution
Restitution when colliding.
Definition SoftBodyCreationSettings.h:64
uint64 mUserData
User data value (can be used by application)
Definition SoftBodyCreationSettings.h:55
CollisionGroup mCollisionGroup
The collision group this body belongs to (determines if two objects can collide)
Definition SoftBodyCreationSettings.h:59
ObjectLayer mObjectLayer
The collision layer this body belongs to (determines if two objects can collide)
Definition SoftBodyCreationSettings.h:58
Definition BodyManager.cpp:61
SoftBodyShape mShape
Definition BodyManager.cpp:69
SoftBodyMotionProperties mMotionProperties
Definition BodyManager.cpp:68
Definition StateRecorder.h:110
A sub shape id contains a path to an element (usually a triangle or other primitive type) of a compou...
Definition SubShapeID.h:23
Definition TransformedShape.h:26
Definition Vec3.h:17
static JPH_INLINE Vec3 sZero()
Vector with all zeros.
Definition Vec3.inl:103
JPH_INLINE bool IsNaN() const
Test if vector contains NaN elements.
Definition Vec3.inl:757
static JPH_INLINE Vec3 sLoadFloat3Unsafe(const Float3 &inV)
Load 3 floats from memory (reads 32 bits extra which it doesn't use)
Definition Vec3.inl:135