Jolt Physics
A multi core friendly Game Physics Engine
Loading...
Searching...
No Matches
MotionProperties.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
7#include <Jolt/Core/Atomics.h>
16
18
19class StateRecorder;
20
22enum class ECanSleep
23{
26};
27
30{
31public:
33
35 EMotionQuality GetMotionQuality() const { return mMotionQuality; }
36
38 inline EAllowedDOFs GetAllowedDOFs() const { return mAllowedDOFs; }
39
41 inline bool GetAllowSleeping() const { return mAllowSleeping; }
42
44 inline Vec3 GetLinearVelocity() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::Read)); return mLinearVelocity; }
45
49 void SetLinearVelocity(Vec3Arg inLinearVelocity) { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::ReadWrite)); JPH_ASSERT(inLinearVelocity.Length() <= mMaxLinearVelocity); mLinearVelocity = LockTranslation(inLinearVelocity); }
50
54 void SetLinearVelocityClamped(Vec3Arg inLinearVelocity) { mLinearVelocity = LockTranslation(inLinearVelocity); ClampLinearVelocity(); }
55
57 inline Vec3 GetAngularVelocity() const { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::Read)); return mAngularVelocity; }
58
62 void SetAngularVelocity(Vec3Arg inAngularVelocity) { JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::ReadWrite)); JPH_ASSERT(inAngularVelocity.Length() <= mMaxAngularVelocity); mAngularVelocity = LockAngular(inAngularVelocity); }
63
67 void SetAngularVelocityClamped(Vec3Arg inAngularVelocity) { mAngularVelocity = LockAngular(inAngularVelocity); ClampAngularVelocity(); }
68
72 inline void MoveKinematic(Vec3Arg inDeltaPosition, QuatArg inDeltaRotation, float inDeltaTime);
73
76
78 inline float GetMaxLinearVelocity() const { return mMaxLinearVelocity; }
79 inline void SetMaxLinearVelocity(float inLinearVelocity) { JPH_ASSERT(inLinearVelocity >= 0.0f); mMaxLinearVelocity = inLinearVelocity; }
80
82 inline float GetMaxAngularVelocity() const { return mMaxAngularVelocity; }
83 inline void SetMaxAngularVelocity(float inAngularVelocity) { JPH_ASSERT(inAngularVelocity >= 0.0f); mMaxAngularVelocity = inAngularVelocity; }
85
87 inline void ClampLinearVelocity();
88 inline void ClampAngularVelocity();
89
91 inline float GetLinearDamping() const { return mLinearDamping; }
92 void SetLinearDamping(float inLinearDamping) { JPH_ASSERT(inLinearDamping >= 0.0f); mLinearDamping = inLinearDamping; }
93
95 inline float GetAngularDamping() const { return mAngularDamping; }
96 void SetAngularDamping(float inAngularDamping) { JPH_ASSERT(inAngularDamping >= 0.0f); mAngularDamping = inAngularDamping; }
97
99 inline float GetGravityFactor() const { return mGravityFactor; }
100 void SetGravityFactor(float inGravityFactor) { mGravityFactor = inGravityFactor; }
101
103 void SetMassProperties(EAllowedDOFs inAllowedDOFs, const MassProperties &inMassProperties);
104
106 inline float GetInverseMass() const { JPH_ASSERT(mCachedMotionType == EMotionType::Dynamic); return mInvMass; }
107 inline float GetInverseMassUnchecked() const { return mInvMass; }
108
113 void SetInverseMass(float inInverseMass) { mInvMass = inInverseMass; }
114
116 inline Vec3 GetInverseInertiaDiagonal() const { JPH_ASSERT(mCachedMotionType == EMotionType::Dynamic); return mInvInertiaDiagonal; }
117
119 inline Quat GetInertiaRotation() const { return mInertiaRotation; }
120
125 void SetInverseInertia(Vec3Arg inDiagonal, QuatArg inRot) { mInvInertiaDiagonal = inDiagonal; mInertiaRotation = inRot; }
126
129 void ScaleToMass(float inMass);
130
132 inline Mat44 GetLocalSpaceInverseInertia() const;
133
135 inline Mat44 GetLocalSpaceInverseInertiaUnchecked() const;
136
138 inline Mat44 GetInverseInertiaForRotation(Mat44Arg inRotation) const;
139
141 JPH_INLINE Vec3 MultiplyWorldSpaceInverseInertiaByVector(QuatArg inBodyRotation, Vec3Arg inV) const;
142
144 JPH_INLINE Vec3 GetPointVelocityCOM(Vec3Arg inPointRelativeToCOM) const { return mLinearVelocity + mAngularVelocity.Cross(inPointRelativeToCOM); }
145
146 // Get the total amount of force applied to the center of mass this time step (through Body::AddForce calls). Note that it will reset to zero after PhysicsSystem::Update.
147 JPH_INLINE Vec3 GetAccumulatedForce() const { return Vec3::sLoadFloat3Unsafe(mForce); }
148
149 // Get the total amount of torque applied to the center of mass this time step (through Body::AddForce/Body::AddTorque calls). Note that it will reset to zero after PhysicsSystem::Update.
150 JPH_INLINE Vec3 GetAccumulatedTorque() const { return Vec3::sLoadFloat3Unsafe(mTorque); }
151
152 // Reset the total accumulated force, note that this will be done automatically after every time step.
153 JPH_INLINE void ResetForce() { mForce = Float3(0, 0, 0); }
154
155 // Reset the total accumulated torque, note that this will be done automatically after every time step.
156 JPH_INLINE void ResetTorque() { mTorque = Float3(0, 0, 0); }
157
158 // Reset the current velocity and accumulated force and torque.
159 JPH_INLINE void ResetMotion()
160 {
161 JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::ReadWrite));
162 mLinearVelocity = mAngularVelocity = Vec3::sZero();
163 mForce = mTorque = Float3(0, 0, 0);
164 }
165
172
174 JPH_INLINE Vec3 LockTranslation(Vec3Arg inV) const
175 {
176 return Vec3::sAnd(inV, Vec3(GetLinearDOFsMask().ReinterpretAsFloat()));
177 }
178
185
187 JPH_INLINE Vec3 LockAngular(Vec3Arg inV) const
188 {
189 return Vec3::sAnd(inV, Vec3(GetAngularDOFsMask().ReinterpretAsFloat()));
190 }
191
193 void SetNumVelocityStepsOverride(uint inN) { JPH_ASSERT(inN < 256); mNumVelocityStepsOverride = uint8(inN); }
194 uint GetNumVelocityStepsOverride() const { return mNumVelocityStepsOverride; }
195
197 void SetNumPositionStepsOverride(uint inN) { JPH_ASSERT(inN < 256); mNumPositionStepsOverride = uint8(inN); }
198 uint GetNumPositionStepsOverride() const { return mNumPositionStepsOverride; }
199
200#ifdef JPH_TRACK_SIMULATION_STATS
202 struct SimulationStats
203 {
204 void Reset() { mBroadPhaseTicks = 0; mNarrowPhaseTicks.store(0, memory_order_relaxed); mVelocityConstraintTicks = 0; mPositionConstraintTicks = 0; mUpdateBoundsTicks = 0; mCCDTicks.store(0, memory_order_relaxed); mNumContactConstraints.store(0, memory_order_relaxed); mNumCollisionSteps = 0; mNumVelocitySteps = 0; mNumPositionSteps = 0; mIsLargeIsland = false; }
205
206 uint64 mBroadPhaseTicks = 0;
207 atomic<uint64> mNarrowPhaseTicks = 0;
208 uint64 mVelocityConstraintTicks = 0;
209 uint64 mPositionConstraintTicks = 0;
210 uint64 mUpdateBoundsTicks = 0;
211 atomic<uint64> mCCDTicks = 0;
212 atomic<uint32> mNumContactConstraints = 0;
213 uint8 mNumCollisionSteps = 0;
214 uint8 mNumVelocitySteps = 0;
215 uint8 mNumPositionSteps = 0;
216 bool mIsLargeIsland = false;
217 };
218
219 const SimulationStats & GetSimulationStats() const { return mSimulationStats; }
220 SimulationStats & GetSimulationStats() { return mSimulationStats; }
221#endif // JPH_TRACK_SIMULATION_STATS
222
224 // FUNCTIONS BELOW THIS LINE ARE FOR INTERNAL USE ONLY
226
229 inline void ApplyLinearVelocityStep(Vec3Arg inLinearVelocity)
230 {
231 JPH_DET_LOG("ApplyLinearVelocityStep: " << inLinearVelocity);
232 JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::ReadWrite));
233 JPH_ASSERT(mCachedMotionType == EMotionType::Dynamic);
234 JPH_ASSERT(!inLinearVelocity.IsNaN());
235 mLinearVelocity = LockTranslation(inLinearVelocity);
236 }
237 inline void AddLinearVelocityStep(Vec3Arg inLinearVelocityChange) { ApplyLinearVelocityStep(mLinearVelocity + inLinearVelocityChange); }
238 inline void SubLinearVelocityStep(Vec3Arg inLinearVelocityChange) { ApplyLinearVelocityStep(mLinearVelocity - inLinearVelocityChange); }
239
240 inline void ApplyAngularVelocityStep(Vec3Arg inAngularVelocity)
241 {
242 JPH_DET_LOG("ApplyAngularVelocityStep: " << inAngularVelocity);
243 JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sVelocityAccess(), BodyAccess::EAccess::ReadWrite));
244 JPH_ASSERT(mCachedMotionType == EMotionType::Dynamic);
245 JPH_ASSERT(!inAngularVelocity.IsNaN());
246 mAngularVelocity = inAngularVelocity;
247 }
248 inline void AddAngularVelocityStep(Vec3Arg inAngularVelocityChange) { ApplyAngularVelocityStep(mAngularVelocity + inAngularVelocityChange); }
249 inline void SubAngularVelocityStep(Vec3Arg inAngularVelocityChange) { ApplyAngularVelocityStep(mAngularVelocity - inAngularVelocityChange); }
251
253 inline void ApplyGyroscopicForceInternal(QuatArg inBodyRotation, float inDeltaTime);
254
256 inline void ApplyForceTorqueAndDragInternal(QuatArg inBodyRotation, Vec3Arg inGravity, float inDeltaTime);
257
259 uint32 GetIslandIndexInternal() const { return mIslandIndex; }
260 void SetIslandIndexInternal(uint32 inIndex) { mIslandIndex = inIndex; }
261
263 uint32 GetIndexInActiveBodiesInternal() const { return mIndexInActiveBodies.load(memory_order_relaxed); }
264
265#ifdef JPH_DOUBLE_PRECISION
266 inline DVec3 GetSleepTestOffset() const { return DVec3::sLoadDouble3Unsafe(mSleepTestOffset); }
267#endif // JPH_DOUBLE_PRECISION
268
270 inline void ResetSleepTestSpheres(const RVec3 *inPoints);
271
273 inline void ResetSleepTestTimer() { mSleepTestTimer = 0.0f; }
274
276 inline ECanSleep AccumulateSleepTime(float inDeltaTime, float inTimeBeforeSleep);
277
279 void SaveState(StateRecorder &inStream) const;
280
282 void RestoreState(StateRecorder &inStream);
283
284 static constexpr uint32 cInactiveIndex = uint32(-1);
285
286private:
287 friend class BodyManager;
288 friend class Body;
289
290 // 1st cache line
291 // 16 byte aligned
292 Vec3 mLinearVelocity { Vec3::sZero() };
293 Vec3 mAngularVelocity { Vec3::sZero() };
294 Vec3 mInvInertiaDiagonal;
295 Quat mInertiaRotation;
296
297 // 2nd cache line
298 // 4 byte aligned
299 Float3 mForce { 0, 0, 0 };
300 Float3 mTorque { 0, 0, 0 };
301 float mInvMass;
302 float mLinearDamping;
303 float mAngularDamping;
304 float mMaxLinearVelocity;
305 float mMaxAngularVelocity;
306 float mGravityFactor;
307 atomic<uint32> mIndexInActiveBodies = cInactiveIndex;
308 uint32 mIslandIndex = cInactiveIndex;
309
310 // 1 byte aligned
311 EMotionQuality mMotionQuality;
312 bool mAllowSleeping;
313 EAllowedDOFs mAllowedDOFs = EAllowedDOFs::All;
314 uint8 mNumVelocityStepsOverride = 0;
315 uint8 mNumPositionStepsOverride = 0;
316
317 // 3rd cache line (least frequently used)
318 // 4 byte aligned (or 8 byte if running in double precision)
319#ifdef JPH_DOUBLE_PRECISION
320 Double3 mSleepTestOffset;
321#endif // JPH_DOUBLE_PRECISION
322 Sphere mSleepTestSpheres[3];
323 float mSleepTestTimer;
324
325#ifdef JPH_ENABLE_ASSERTS
326 EBodyType mCachedBodyType;
327 EMotionType mCachedMotionType;
328#endif
329
330#ifdef JPH_TRACK_SIMULATION_STATS
331 SimulationStats mSimulationStats;
332#endif // JPH_TRACK_SIMULATION_STATS
333};
334
336
337#include "MotionProperties.inl"
EAllowedDOFs
Enum used in BodyCreationSettings and MotionProperties to indicate which degrees of freedom a body ha...
Definition AllowedDOFs.h:11
@ RotationX
Body can rotate around world space X axis.
Definition AllowedDOFs.h:17
@ TranslationY
Body can move in world space Y axis.
Definition AllowedDOFs.h:15
@ RotationY
Body can rotate around world space Y axis.
Definition AllowedDOFs.h:18
@ TranslationZ
Body can move in world space Z axis.
Definition AllowedDOFs.h:16
@ All
All degrees of freedom are allowed.
Definition AllowedDOFs.h:13
@ TranslationX
Body can move in world space X axis.
Definition AllowedDOFs.h:14
@ RotationZ
Body can rotate around world space Z axis.
Definition AllowedDOFs.h:19
EBodyType
Type of body.
Definition BodyType.h:11
std::uint8_t uint8
Definition Core.h:565
#define JPH_EXPORT
Definition Core.h:303
std::uint64_t uint64
Definition Core.h:569
unsigned int uint
Definition Core.h:564
#define JPH_NAMESPACE_END
Definition Core.h:487
std::uint32_t uint32
Definition Core.h:567
#define JPH_NAMESPACE_BEGIN
Definition Core.h:481
#define JPH_DET_LOG(...)
Definition DeterminismLog.h:177
#define JPH_ASSERT(...)
Definition IssueReporting.h:28
const Quat QuatArg
Definition MathTypes.h:28
const Vec3 Vec3Arg
Definition MathTypes.h:19
const Mat44 & Mat44Arg
Definition MathTypes.h:29
#define JPH_OVERRIDE_NEW_DELETE
Macro to override the new and delete functions.
Definition Memory.h:51
ECanSleep
Enum that determines if an object can go to sleep.
Definition MotionProperties.h:23
@ CanSleep
Object can go to sleep.
Definition MotionProperties.h:25
@ CannotSleep
Object cannot go to sleep.
Definition MotionProperties.h:24
EMotionQuality
Motion quality, or how well it detects collisions when it has a high velocity.
Definition MotionQuality.h:11
EMotionType
Motion type of a physics body.
Definition MotionType.h:11
@ Dynamic
Responds to forces as a normal physics object.
Definition MotionType.h:14
Vec3 RVec3
Definition Real.h:29
@ Sphere
Definition Shape.h:78
Definition DVec3.h:14
static JPH_INLINE DVec3 sLoadDouble3Unsafe(const Double3 &inV)
Load 3 doubles from memory (reads 64 bits extra which it doesn't use).
Definition DVec3.inl:188
Class that holds 3 floats. Used as a storage class. Convert to Vec3 for calculations.
Definition Float3.h:13
Describes the mass and inertia properties of a body. Used during body construction only.
Definition MassProperties.h:16
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:30
void SetLinearVelocity(Vec3Arg inLinearVelocity)
Definition MotionProperties.h:49
uint32 GetIslandIndexInternal() const
Access to the island index.
Definition MotionProperties.h:259
void ClampAngularVelocity()
Definition MotionProperties.inl:33
void SetNumVelocityStepsOverride(uint inN)
Used only when this body is dynamic and colliding. Override for the number of solver velocity iterati...
Definition MotionProperties.h:193
void SetAngularVelocityClamped(Vec3Arg inAngularVelocity)
Definition MotionProperties.h:67
void ClampLinearVelocity()
Clamp velocity according to limit.
Definition MotionProperties.inl:23
Quat GetInertiaRotation() const
Rotation (R) that takes inverse inertia diagonal to local space: .
Definition MotionProperties.h:119
float GetMaxLinearVelocity() const
Maximum linear velocity that a body can achieve. Used to prevent the system from exploding.
Definition MotionProperties.h:78
JPH_INLINE 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 MotionProperties.h:144
Vec3 GetInverseInertiaDiagonal() const
Diagonal of inverse inertia matrix: D. Should only be called on a dynamic object (static or kinematic...
Definition MotionProperties.h:116
void ApplyAngularVelocityStep(Vec3Arg inAngularVelocity)
Definition MotionProperties.h:240
uint GetNumPositionStepsOverride() const
Definition MotionProperties.h:198
void SetInverseInertia(Vec3Arg inDiagonal, QuatArg inRot)
Definition MotionProperties.h:125
float GetGravityFactor() const
Get gravity factor (1 = normal gravity, 0 = no gravity).
Definition MotionProperties.h:99
friend class BodyManager
Definition MotionProperties.h:287
void AddLinearVelocityStep(Vec3Arg inLinearVelocityChange)
Definition MotionProperties.h:237
float GetMaxAngularVelocity() const
Maximum angular velocity that a body can achieve. Used to prevent the system from exploding.
Definition MotionProperties.h:82
void SetLinearVelocityClamped(Vec3Arg inLinearVelocity)
Definition MotionProperties.h:54
uint GetNumVelocityStepsOverride() const
Definition MotionProperties.h:194
float GetInverseMassUnchecked() const
Definition MotionProperties.h:107
Vec3 GetLinearVelocity() const
Get world space linear velocity of the center of mass.
Definition MotionProperties.h:44
Vec3 GetAngularVelocity() const
Get world space angular velocity of the center of mass.
Definition MotionProperties.h:57
void SetMaxAngularVelocity(float inAngularVelocity)
Definition MotionProperties.h:83
JPH_INLINE Vec3 LockAngular(Vec3Arg inV) const
Takes an angular velocity / torque vector inV and returns a vector where the components that are not ...
Definition MotionProperties.h:187
JPH_INLINE void ResetMotion()
Definition MotionProperties.h:159
JPH_INLINE Vec3 GetAccumulatedTorque() const
Definition MotionProperties.h:150
void SetIslandIndexInternal(uint32 inIndex)
Definition MotionProperties.h:260
float GetAngularDamping() const
Get angular damping: dw/dt = -c * w. c. Value should be zero or positive and is usually close to 0.
Definition MotionProperties.h:95
void SubLinearVelocityStep(Vec3Arg inLinearVelocityChange)
Definition MotionProperties.h:238
friend class Body
Definition MotionProperties.h:288
float GetInverseMass() const
Get inverse mass (1 / mass). Should only be called on a dynamic object (static or kinematic bodies ha...
Definition MotionProperties.h:106
void SetGravityFactor(float inGravityFactor)
Definition MotionProperties.h:100
JPH_INLINE UVec4 GetLinearDOFsMask() const
Returns a vector where the linear components that are not allowed by mAllowedDOFs are set to 0 and th...
Definition MotionProperties.h:167
uint32 GetIndexInActiveBodiesInternal() const
Access to the index in the active bodies array.
Definition MotionProperties.h:263
float GetLinearDamping() const
Get linear damping: dv/dt = -c * v. c. Value should be zero or positive and is usually close to 0.
Definition MotionProperties.h:91
void SubAngularVelocityStep(Vec3Arg inAngularVelocityChange)
Definition MotionProperties.h:249
JPH_INLINE void ResetForce()
Definition MotionProperties.h:153
void SetInverseMass(float inInverseMass)
Definition MotionProperties.h:113
void ResetSleepTestTimer()
Reset the sleep test timer without resetting the sleep test spheres.
Definition MotionProperties.h:273
void SetAngularVelocity(Vec3Arg inAngularVelocity)
Definition MotionProperties.h:62
void ApplyLinearVelocityStep(Vec3Arg inLinearVelocity)
Definition MotionProperties.h:229
static constexpr uint32 cInactiveIndex
Constant indicating that body is not active.
Definition MotionProperties.h:284
JPH_INLINE Vec3 GetAccumulatedForce() const
Definition MotionProperties.h:147
JPH_INLINE Vec3 LockTranslation(Vec3Arg inV) const
Takes a translation vector inV and returns a vector where the components that are not allowed by mAll...
Definition MotionProperties.h:174
void SetMaxLinearVelocity(float inLinearVelocity)
Definition MotionProperties.h:79
JPH_OVERRIDE_NEW_DELETE EMotionQuality GetMotionQuality() const
Motion quality, or how well it detects collisions when it has a high velocity.
Definition MotionProperties.h:35
void SetLinearDamping(float inLinearDamping)
Definition MotionProperties.h:92
void SetAngularDamping(float inAngularDamping)
Definition MotionProperties.h:96
JPH_INLINE UVec4 GetAngularDOFsMask() const
Returns a vector where the angular components that are not allowed by mAllowedDOFs are set to 0 and t...
Definition MotionProperties.h:180
void SetNumPositionStepsOverride(uint inN)
Used only when this body is dynamic and colliding. Override for the number of solver position iterati...
Definition MotionProperties.h:197
EAllowedDOFs GetAllowedDOFs() const
Get the allowed degrees of freedom that this body has (this can be changed by calling SetMassProperti...
Definition MotionProperties.h:38
bool GetAllowSleeping() const
If this body can go to sleep.
Definition MotionProperties.h:41
void AddAngularVelocityStep(Vec3Arg inAngularVelocityChange)
Definition MotionProperties.h:248
JPH_INLINE void ResetTorque()
Definition MotionProperties.h:156
Definition Quat.h:33
Definition StateRecorder.h:110
Definition UVec4.h:12
static JPH_INLINE UVec4 sReplicate(uint32 inV)
Replicate int inV across all components.
Definition UVec4.inl:75
static JPH_INLINE UVec4 sAnd(UVec4Arg inV1, UVec4Arg inV2)
Logical and (component wise).
Definition UVec4.inl:292
static JPH_INLINE UVec4 sEquals(UVec4Arg inV1, UVec4Arg inV2)
Equals (component wise).
Definition UVec4.inl:198
Definition Vec3.h:17
JPH_INLINE Vec3 Cross(Vec3Arg inV2) const
Cross product.
Definition Vec3.inl:855
JPH_INLINE float Length() const
Length of vector.
Definition Vec3.inl:951
static JPH_INLINE Vec3 sAnd(Vec3Arg inV1, Vec3Arg inV2)
Logical and (component wise).
Definition Vec3.inl:447
static JPH_INLINE Vec3 sZero()
Vector with all zeros.
Definition Vec3.inl:125
JPH_INLINE bool IsNaN() const
Test if vector contains NaN elements.
Definition Vec3.inl:1035
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:167
float4 Quat
Definition HLSLToCPP.h:485