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 alignas(JPH_RVECTOR_ALIGNMENT) JPH_EXPORT_GCC_BUG_WORKAROUND Body : public NonCopyable
35{
36public:
38
40 Body() = default;
41
43 ~Body() { JPH_ASSERT(mMotionProperties == nullptr); }
44
46 inline const BodyID & GetID() const { return mID; }
47
49 inline EBodyType GetBodyType() const { return mBodyType; }
50
52 inline bool IsRigidBody() const { return mBodyType == EBodyType::RigidBody; }
53
55 inline bool IsSoftBody() const { return mBodyType == EBodyType::SoftBody; }
56
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
130 const CollisionGroup & GetCollisionGroup() const { return mCollisionGroup; }
131 CollisionGroup & GetCollisionGroup() { return mCollisionGroup; }
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
153 void SetLinearVelocity(Vec3Arg inLinearVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetLinearVelocity(inLinearVelocity); }
154
156 void SetLinearVelocityClamped(Vec3Arg inLinearVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetLinearVelocityClamped(inLinearVelocity); }
157
159 inline Vec3 GetAngularVelocity() const { return !IsStatic()? mMotionProperties->GetAngularVelocity() : Vec3::sZero(); }
160
162 void SetAngularVelocity(Vec3Arg inAngularVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetAngularVelocity(inAngularVelocity); }
163
165 void SetAngularVelocityClamped(Vec3Arg inAngularVelocity) { JPH_ASSERT(!IsStatic()); mMotionProperties->SetAngularVelocityClamped(inAngularVelocity); }
166
168 inline Vec3 GetPointVelocityCOM(Vec3Arg inPointRelativeToCOM) const { return !IsStatic()? mMotionProperties->GetPointVelocityCOM(inPointRelativeToCOM) : Vec3::sZero(); }
169
171 inline Vec3 GetPointVelocity(RVec3Arg inPoint) const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess, BodyAccess::EAccess::Read)); return GetPointVelocityCOM(Vec3(inPoint - mPosition)); }
172
174 inline void AddForce(Vec3Arg inForce) { JPH_ASSERT(IsDynamic()); (Vec3::sLoadFloat3Unsafe(mMotionProperties->mForce) + inForce).StoreFloat3(&mMotionProperties->mForce); }
175
177 inline void AddForce(Vec3Arg inForce, RVec3Arg inPosition);
178
180 inline void AddTorque(Vec3Arg inTorque) { JPH_ASSERT(IsDynamic()); (Vec3::sLoadFloat3Unsafe(mMotionProperties->mTorque) + inTorque).StoreFloat3(&mMotionProperties->mTorque); }
181
182 // 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.
183 inline Vec3 GetAccumulatedForce() const { JPH_ASSERT(IsDynamic()); return mMotionProperties->GetAccumulatedForce(); }
184
185 // 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.
186 inline Vec3 GetAccumulatedTorque() const { JPH_ASSERT(IsDynamic()); return mMotionProperties->GetAccumulatedTorque(); }
187
188 // Reset the total accumulated force, not that this will be done automatically after every time step.
189 JPH_INLINE void ResetForce() { JPH_ASSERT(IsDynamic()); return mMotionProperties->ResetForce(); }
190
191 // Reset the total accumulated torque, not that this will be done automatically after every time step.
192 JPH_INLINE void ResetTorque() { JPH_ASSERT(IsDynamic()); return mMotionProperties->ResetTorque(); }
193
194 // Reset the current velocity and accumulated force and torque.
195 JPH_INLINE void ResetMotion() { JPH_ASSERT(!IsStatic()); return mMotionProperties->ResetMotion(); }
196
198 inline Mat44 GetInverseInertia() const;
199
201 inline void AddImpulse(Vec3Arg inImpulse);
202
204 inline void AddImpulse(Vec3Arg inImpulse, RVec3Arg inPosition);
205
207 inline void AddAngularImpulse(Vec3Arg inAngularImpulse);
208
210 void MoveKinematic(RVec3Arg inTargetPosition, QuatArg inTargetRotation, float inDeltaTime);
211
222 bool ApplyBuoyancyImpulse(RVec3Arg inSurfacePosition, Vec3Arg inSurfaceNormal, float inBuoyancy, float inLinearDrag, float inAngularDrag, Vec3Arg inFluidVelocity, Vec3Arg inGravity, float inDeltaTime);
223
225 inline bool IsInBroadPhase() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::IsInBroadPhase)) != 0; }
226
228 inline bool IsCollisionCacheInvalid() const { return (mFlags.load(memory_order_relaxed) & uint8(EFlags::InvalidateContactCache)) != 0; }
229
231 inline const Shape * GetShape() const { return mShape; }
232
234 inline RVec3 GetPosition() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess, BodyAccess::EAccess::Read)); return mPosition - mRotation * mShape->GetCenterOfMass(); }
235
237 inline Quat GetRotation() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess, BodyAccess::EAccess::Read)); return mRotation; }
238
240 inline RMat44 GetWorldTransform() const;
241
243 inline RVec3 GetCenterOfMassPosition() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess, BodyAccess::EAccess::Read)); return mPosition; }
244
246 inline RMat44 GetCenterOfMassTransform() const;
247
249 inline RMat44 GetInverseCenterOfMassTransform() const;
250
252 inline const AABox & GetWorldSpaceBounds() const { return mBounds; }
253
255 const MotionProperties *GetMotionProperties() const { JPH_ASSERT(!IsStatic()); return mMotionProperties; }
256 MotionProperties * GetMotionProperties() { JPH_ASSERT(!IsStatic()); return mMotionProperties; }
257
259 const MotionProperties *GetMotionPropertiesUnchecked() const { return mMotionProperties; }
260 MotionProperties * GetMotionPropertiesUnchecked() { return mMotionProperties; }
261
263 uint64 GetUserData() const { return mUserData; }
264 void SetUserData(uint64 inUserData) { mUserData = inUserData; }
265
267 inline Vec3 GetWorldSpaceSurfaceNormal(const SubShapeID &inSubShapeID, RVec3Arg inPosition) const;
268
270 inline TransformedShape GetTransformedShape() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess, BodyAccess::EAccess::Read)); return TransformedShape(mPosition, mRotation, mShape, mID); }
271
273 BodyCreationSettings GetBodyCreationSettings() const;
274
276 SoftBodyCreationSettings GetSoftBodyCreationSettings() const;
277
280
283
286 static inline bool sFindCollidingPairsCanCollide(const Body &inBody1, const Body &inBody2);
287
289 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()); }
290 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()); }
291
293 inline void AddRotationStep(Vec3Arg inAngularVelocityTimesDeltaTime);
294 inline void SubRotationStep(Vec3Arg inAngularVelocityTimesDeltaTime);
295
297 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); }
298
300 inline bool InvalidateContactCacheInternal() { return (mFlags.fetch_or(uint8(EFlags::InvalidateContactCache), memory_order_relaxed) & uint8(EFlags::InvalidateContactCache)) == 0; }
301
303 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); }
304
306 void CalculateWorldSpaceBoundsInternal();
307
309 void SetPositionAndRotationInternal(RVec3Arg inPosition, QuatArg inRotation, bool inResetSleepTimer = true);
310
314 void UpdateCenterOfMassInternal(Vec3Arg inPreviousCenterOfMass, bool inUpdateMassProperties);
315
319 void SetShapeInternal(const Shape *inShape, bool inUpdateMassProperties);
320
322 uint32 GetIndexInActiveBodiesInternal() const { return mMotionProperties != nullptr? mMotionProperties->mIndexInActiveBodies : cInactiveIndex; }
323
325 ECanSleep UpdateSleepStateInternal(float inDeltaTime, float inMaxMovement, float inTimeBeforeSleep);
326
328 void SaveState(StateRecorder &inStream) const;
329
331 void RestoreState(StateRecorder &inStream);
332
334
335 static constexpr uint32 cInactiveIndex = MotionProperties::cInactiveIndex;
336
337private:
338 friend class BodyManager;
339
340 explicit Body(bool);
341
342 inline void GetSleepTestPoints(RVec3 *outPoints) const;
343
344 enum class EFlags : uint8
345 {
346 IsSensor = 1 << 0,
347 CollideKinematicVsNonDynamic = 1 << 1,
348 IsInBroadPhase = 1 << 2,
349 InvalidateContactCache = 1 << 3,
350 UseManifoldReduction = 1 << 4,
351 ApplyGyroscopicForce = 1 << 5,
352 EnhancedInternalEdgeRemoval = 1 << 6,
353 };
354
355 // 16 byte aligned
356 RVec3 mPosition;
357 Quat mRotation;
358 AABox mBounds;
359
360 // 8 byte aligned
361 RefConst<Shape> mShape;
362 MotionProperties * mMotionProperties = nullptr;
363 uint64 mUserData = 0;
364 CollisionGroup mCollisionGroup;
365
366 // 4 byte aligned
367 float mFriction;
368 float mRestitution;
369 BodyID mID;
370
371 // 2 or 4 bytes aligned
372 ObjectLayer mObjectLayer;
373
374 // 1 byte aligned
375 EBodyType mBodyType;
376 BroadPhaseLayer mBroadPhaseLayer;
377 EMotionType mMotionType;
378 atomic<uint8> mFlags = 0;
379
380 // 122 bytes up to here (64-bit mode, single precision, 16-bit ObjectLayer)
381};
382
383static_assert(JPH_CPU_ADDRESS_BITS != 64 || sizeof(Body) == JPH_IF_SINGLE_PRECISION_ELSE(128, 160), "Body size is incorrect");
384static_assert(alignof(Body) == JPH_RVECTOR_ALIGNMENT, "Body should properly align");
385
387
388#include "Body.inl"
EBodyType
Type of body.
Definition: BodyType.h:11
std::uint8_t uint8
Definition: Core.h:440
std::uint64_t uint64
Definition: Core.h:443
#define JPH_NAMESPACE_END
Definition: Core.h:367
std::uint32_t uint32
Definition: Core.h:442
#define JPH_EXPORT_GCC_BUG_WORKAROUND
Definition: Core.h:231
#define JPH_IF_SINGLE_PRECISION_ELSE(s, d)
Definition: Core.h:504
#define JPH_NAMESPACE_BEGIN
Definition: Core.h:361
#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:29
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
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:35
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:171
bool IsInBroadPhase() const
Check if this body has been added to the physics system.
Definition: Body.h:225
const MotionProperties * GetMotionProperties() const
Access to the motion properties.
Definition: Body.h:255
RVec3 GetCenterOfMassPosition() const
Gets the world space position of this body's center of mass.
Definition: Body.h:243
EMotionType GetMotionType() const
Get the bodies motion type.
Definition: Body.h:118
void SetAngularVelocity(Vec3Arg inAngularVelocity)
Set world space angular velocity of the center of mass (unit: rad/s)
Definition: Body.h:162
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:168
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:252
void SubPositionStep(Vec3Arg inLinearVelocityTimesDeltaTime)
Definition: Body.h:290
void SetUserData(uint64 inUserData)
Definition: Body.h:264
bool IsSoftBody() const
Check if this body is a soft body.
Definition: Body.h:55
const Shape * GetShape() const
Get the shape of this body.
Definition: Body.h:231
bool InvalidateContactCacheInternal()
Invalidate the contact cache (should only be called by the BodyManager), will be reset the next simul...
Definition: Body.h:300
uint64 GetUserData() const
Access to the user data, can be used for anything by the application.
Definition: Body.h:263
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)
Set world space linear velocity of the center of mass, will make sure the value is clamped against th...
Definition: Body.h:156
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)
Set world space linear velocity of the center of mass (unit: m/s)
Definition: Body.h:153
uint32 GetIndexInActiveBodiesInternal() const
Access to the index in the BodyManager::mActiveBodies list.
Definition: Body.h:322
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:228
JPH_OVERRIDE_NEW_DELETE Body()=default
Default constructor.
bool IsRigidBody() const
Check if this body is a rigid body.
Definition: Body.h:52
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:49
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:279
void SetAngularVelocityClamped(Vec3Arg inAngularVelocity)
Set world space angular velocity of the center of mass, will make sure the value is clamped against t...
Definition: Body.h:165
JPH_INLINE void ResetForce()
Definition: Body.h:189
Vec3 GetAccumulatedTorque() const
Definition: Body.h:186
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
void SetInBroadPhaseInternal(bool inInBroadPhase)
Flag if body is in the broadphase (should only be called by the BroadPhase)
Definition: Body.h:297
MotionProperties * GetMotionProperties()
Definition: Body.h:256
Quat GetRotation() const
World space rotation of the body.
Definition: Body.h:237
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:270
JPH_INLINE void ResetTorque()
Definition: Body.h:192
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
const BodyID & GetID() const
Get the id of this body.
Definition: Body.h:46
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:259
~Body()
Destructor.
Definition: Body.h:43
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
MotionProperties * GetMotionPropertiesUnchecked()
Definition: Body.h:260
Vec3 GetAccumulatedForce() const
Definition: Body.h:183
Vec3 GetAngularVelocity() const
Get world space angular velocity of the center of mass (unit: rad/s)
Definition: Body.h:159
RVec3 GetPosition() const
World space position of the body.
Definition: Body.h:234
void AddForce(Vec3Arg inForce)
Add force (unit: N) at center of mass for the next time step, will be reset after the next call to Ph...
Definition: Body.h:174
void SetCollideKinematicVsNonDynamic(bool inCollide)
Definition: Body.h:85
bool IsActive() const
If this body is currently actively simulating (true) or sleeping (false)
Definition: Body.h:58
bool GetUseManifoldReduction() const
Check if this body can use manifold reduction.
Definition: Body.h:97
JPH_INLINE void ResetMotion()
Definition: Body.h:195
void AddTorque(Vec3Arg inTorque)
Add torque (unit: N m) for the next time step, will be reset after the next call to PhysicsSystem::Up...
Definition: Body.h:180
void ValidateContactCacheInternal()
Reset the collision cache invalid flag (should only be called by the BodyManager).
Definition: Body.h:303
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:289
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:32
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:229
Class that makes another class non-copyable. Usage: Inherit from NonCopyable.
Definition: NonCopyable.h:11
Definition: Quat.h:33
Definition: Reference.h:151
Base class for all shapes (collision volume of a body). Defines a virtual interface for collision det...
Definition: Shape.h:178
Definition: SoftBodyCreationSettings.h:18
Definition: StateRecorder.h:48
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:16
static JPH_INLINE Vec3 sZero()
Vector with all zeros.
Definition: Vec3.inl:107
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:134