Jolt Physics
A multi core friendly Game Physics Engine
Loading...
Searching...
No Matches
Quat.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/Math/Vec3.h>
8#include <Jolt/Math/Vec4.h>
9
11
32class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Quat
33{
34public:
36
39 inline Quat() = default;
40 Quat(const Quat &inRHS) = default;
41 Quat & operator = (const Quat &inRHS) = default;
42 inline Quat(float inX, float inY, float inZ, float inW) : mValue(inX, inY, inZ, inW) { }
43 inline explicit Quat(Vec4Arg inV) : mValue(inV) { }
45
48
50 inline bool operator == (QuatArg inRHS) const { return mValue == inRHS.mValue; }
51
53 inline bool operator != (QuatArg inRHS) const { return mValue != inRHS.mValue; }
54
56 inline bool IsClose(QuatArg inRHS, float inMaxDistSq = 1.0e-12f) const { return mValue.IsClose(inRHS.mValue, inMaxDistSq); }
57
59 inline bool IsNormalized(float inTolerance = 1.0e-5f) const { return mValue.IsNormalized(inTolerance); }
60
62 inline bool IsNaN() const { return mValue.IsNaN(); }
63
67
69 JPH_INLINE float GetX() const { return mValue.GetX(); }
70
72 JPH_INLINE float GetY() const { return mValue.GetY(); }
73
75 JPH_INLINE float GetZ() const { return mValue.GetZ(); }
76
78 JPH_INLINE float GetW() const { return mValue.GetW(); }
79
81 JPH_INLINE Vec3 GetXYZ() const { return Vec3(mValue); }
82
84 JPH_INLINE Vec4 GetXYZW() const { return mValue; }
85
87 JPH_INLINE void SetX(float inX) { mValue.SetX(inX); }
88 JPH_INLINE void SetY(float inY) { mValue.SetY(inY); }
89 JPH_INLINE void SetZ(float inZ) { mValue.SetZ(inZ); }
90 JPH_INLINE void SetW(float inW) { mValue.SetW(inW); }
91
93 JPH_INLINE void Set(float inX, float inY, float inZ, float inW) { mValue.Set(inX, inY, inZ, inW); }
94
98
100 JPH_INLINE static Quat sZero() { return Quat(Vec4::sZero()); }
101
103 JPH_INLINE static Quat sIdentity() { return Quat(0, 0, 0, 1); }
104
106
108 JPH_INLINE static Quat sRotation(Vec3Arg inAxis, float inAngle);
109
111 JPH_INLINE void GetAxisAngle(Vec3 &outAxis, float &outAngle) const;
112
115 JPH_INLINE static Quat sFromTo(Vec3Arg inFrom, Vec3Arg inTo);
116
118 template <class Random>
119 inline static Quat sRandom(Random &inRandom);
120
122 inline static Quat sEulerAngles(Vec3Arg inAngles);
123
125 inline Vec3 GetEulerAngles() const;
126
129
132 JPH_INLINE float LengthSq() const { return mValue.LengthSq(); }
133
136 JPH_INLINE float Length() const { return mValue.Length(); }
137
139 JPH_INLINE Quat Normalized() const { return Quat(mValue.Normalized()); }
140
144
145 JPH_INLINE void operator += (QuatArg inRHS) { mValue += inRHS.mValue; }
146 JPH_INLINE void operator -= (QuatArg inRHS) { mValue -= inRHS.mValue; }
147 JPH_INLINE void operator *= (float inValue) { mValue *= inValue; }
148 JPH_INLINE void operator /= (float inValue) { mValue /= inValue; }
149 JPH_INLINE Quat operator - () const { return Quat(-mValue); }
150 JPH_INLINE Quat operator + (QuatArg inRHS) const { return Quat(mValue + inRHS.mValue); }
151 JPH_INLINE Quat operator - (QuatArg inRHS) const { return Quat(mValue - inRHS.mValue); }
152 JPH_INLINE Quat operator * (QuatArg inRHS) const;
153 JPH_INLINE Quat operator * (float inValue) const { return Quat(mValue * inValue); }
154 inline friend Quat operator * (float inValue, QuatArg inRHS) { return Quat(inRHS.mValue * inValue); }
155 JPH_INLINE Quat operator / (float inValue) const { return Quat(mValue / inValue); }
156
158
160 JPH_INLINE Vec3 operator * (Vec3Arg inValue) const;
161
163 JPH_INLINE Vec3 InverseRotate(Vec3Arg inValue) const;
164
166 JPH_INLINE Vec3 RotateAxisX() const;
167
169 JPH_INLINE Vec3 RotateAxisY() const;
170
172 JPH_INLINE Vec3 RotateAxisZ() const;
173
175 JPH_INLINE float Dot(QuatArg inRHS) const { return mValue.Dot(inRHS.mValue); }
176
178 JPH_INLINE Quat Conjugated() const { return Quat(Vec4::sXor(mValue, UVec4(0x80000000, 0x80000000, 0x80000000, 0).ReinterpretAsFloat())); }
179
181 JPH_INLINE Quat Inversed() const { return Conjugated() / Length(); }
182
184 JPH_INLINE Quat EnsureWPositive() const { return Quat(Vec4::sXor(mValue, Vec4::sAnd(mValue.SplatW(), UVec4::sReplicate(0x80000000).ReinterpretAsFloat()))); }
185
187 JPH_INLINE Quat GetPerpendicular() const { return Quat(Vec4(1, -1, 1, -1) * mValue.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>()); }
188
190 JPH_INLINE float GetRotationAngle(Vec3Arg inAxis) const { return GetW() == 0.0f? JPH_PI : 2.0f * ATan(GetXYZ().Dot(inAxis) / GetW()); }
191
209 JPH_INLINE Quat GetTwist(Vec3Arg inAxis) const;
210
223 JPH_INLINE void GetSwingTwist(Quat &outSwing, Quat &outTwist) const;
224
229 JPH_INLINE Quat LERP(QuatArg inDestination, float inFraction) const;
230
236 JPH_INLINE Quat SLERP(QuatArg inDestination, float inFraction) const;
237
239 static JPH_INLINE Quat sLoadFloat3Unsafe(const Float3 &inV);
240
242 JPH_INLINE void StoreFloat3(Float3 *outV) const;
243
245 friend ostream & operator << (ostream &inStream, QuatArg inQ) { inStream << inQ.mValue; return inStream; }
246
249};
250
251static_assert(is_trivial<Quat>(), "Is supposed to be a trivial type!");
252
254
255#include "Quat.inl"
#define JPH_NAMESPACE_END
Definition: Core.h:367
#define JPH_NAMESPACE_BEGIN
Definition: Core.h:361
DVec3 operator*(double inV1, DVec3Arg inV2)
Definition: DVec3.inl:447
#define JPH_OVERRIDE_NEW_DELETE
Macro to override the new and delete functions.
Definition: Memory.h:29
@ SWIZZLE_Z
Use the Z component.
Definition: Swizzle.h:14
@ SWIZZLE_W
Use the W component.
Definition: Swizzle.h:15
@ SWIZZLE_X
Use the X component.
Definition: Swizzle.h:12
@ SWIZZLE_Y
Use the Y component.
Definition: Swizzle.h:13
JPH_INLINE float ATan(float inX)
Arc tangent of x (returns value in the range [-PI / 2, PI / 2])
Definition: Trigonometry.h:48
Class that holds 3 floats. Used as a storage class. Convert to Vec3 for calculations.
Definition: Float3.h:13
Definition: Quat.h:33
Quat(const Quat &inRHS)=default
JPH_INLINE float GetW() const
Get W component (real part)
Definition: Quat.h:78
JPH_INLINE float GetY() const
Get Y component (imaginary part j)
Definition: Quat.h:72
JPH_INLINE float GetZ() const
Get Z component (imaginary part k)
Definition: Quat.h:75
JPH_INLINE void SetZ(float inZ)
Definition: Quat.h:89
JPH_INLINE float GetX() const
Get X component (imaginary part i)
Definition: Quat.h:69
JPH_INLINE void SetY(float inY)
Definition: Quat.h:88
JPH_INLINE float LengthSq() const
Definition: Quat.h:132
bool IsNaN() const
If any component of this quaternion is a NaN (not a number)
Definition: Quat.h:62
static JPH_INLINE Quat sIdentity()
Definition: Quat.h:103
JPH_INLINE Vec4 GetXYZW() const
Get the quaternion as a Vec4.
Definition: Quat.h:84
bool IsClose(QuatArg inRHS, float inMaxDistSq=1.0e-12f) const
If this quaternion is close to inRHS. Note that q and -q represent the same rotation,...
Definition: Quat.h:56
JPH_INLINE Quat Normalized() const
Normalize the quaternion (make it length 1)
Definition: Quat.h:139
JPH_INLINE Quat EnsureWPositive() const
Ensures that the W component is positive by negating the entire quaternion if it is not....
Definition: Quat.h:184
JPH_INLINE void Set(float inX, float inY, float inZ, float inW)
Set all components.
Definition: Quat.h:93
Quat(Vec4Arg inV)
Definition: Quat.h:43
JPH_INLINE float Dot(QuatArg inRHS) const
Dot product.
Definition: Quat.h:175
Quat()=default
Intentionally not initialized for performance reasons.
JPH_INLINE float Length() const
Definition: Quat.h:136
JPH_INLINE Quat GetPerpendicular() const
Get a quaternion that is perpendicular to this quaternion.
Definition: Quat.h:187
JPH_INLINE Quat Inversed() const
Get inverse quaternion.
Definition: Quat.h:181
JPH_INLINE Quat Conjugated() const
The conjugate [w, -x, -y, -z] is the same as the inverse for unit quaternions.
Definition: Quat.h:178
JPH_INLINE float GetRotationAngle(Vec3Arg inAxis) const
Get rotation angle around inAxis (uses Swing Twist Decomposition to get the twist quaternion and uses...
Definition: Quat.h:190
Quat(float inX, float inY, float inZ, float inW)
Definition: Quat.h:42
JPH_INLINE void SetW(float inW)
Definition: Quat.h:90
JPH_INLINE void SetX(float inX)
Set individual components.
Definition: Quat.h:87
bool IsNormalized(float inTolerance=1.0e-5f) const
If the length of this quaternion is 1 +/- inTolerance.
Definition: Quat.h:59
static JPH_INLINE Quat sZero()
Definition: Quat.h:100
JPH_INLINE Vec3 GetXYZ() const
Get the imaginary part of the quaternion.
Definition: Quat.h:81
Vec4 mValue
4 vector that stores [x, y, z, w] parts of the quaternion
Definition: Quat.h:248
Definition: UVec4.h:12
static JPH_INLINE UVec4 sReplicate(uint32 inV)
Replicate int inV across all components.
Definition: UVec4.inl:56
JPH_INLINE Vec4 ReinterpretAsFloat() const
Reinterpret UVec4 as a Vec4 (doesn't change the bits)
Definition: UVec4.inl:332
Definition: Vec3.h:16
Definition: Vec4.h:14
static JPH_INLINE Vec4 sAnd(Vec4Arg inV1, Vec4Arg inV2)
Logical and (component wise)
Definition: Vec4.inl:290
static JPH_INLINE Vec4 sXor(Vec4Arg inV1, Vec4Arg inV2)
Logical xor (component wise)
Definition: Vec4.inl:279
static JPH_INLINE Vec4 sZero()
Vector with all zeros.
Definition: Vec4.inl:63
JPH_INLINE Vec4 Swizzle() const
Swizzle the elements in inV.