@bloomengine/engine 0.4.0 → 0.4.1

package/native/third_party/JoltPhysics/Jolt/Math/Quat.h

@@ -1,268 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/Vec3.h>
-#include <Jolt/Math/Vec4.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Quaternion class, quaternions are 4 dimensional vectors which can describe rotations in 3 dimensional
-/// space if their length is 1.
-///
-/// They are written as:
-///
-/// \f$q = w + x \: i + y \: j + z \: k\f$
-///
-/// or in vector notation:
-///
-/// \f$q = [w, v] = [w, x, y, z]\f$
-///
-/// Where:
-///
-/// w = the real part
-/// v = the imaginary part, (x, y, z)
-///
-/// Note that we store the quaternion in a Vec4 as [x, y, z, w] because that makes
-/// it easy to extract the rotation axis of the quaternion:
-///
-/// q = [cos(angle / 2), sin(angle / 2) * rotation_axis]
-class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Quat
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	///@name Constructors
-	///@{
-	inline						Quat() = default; ///< Intentionally not initialized for performance reasons
-								Quat(const Quat &inRHS) = default;
-	Quat &						operator = (const Quat &inRHS) = default;
-	inline						Quat(float inX, float inY, float inZ, float inW)				: mValue(inX, inY, inZ, inW) { }
-	inline explicit				Quat(const Float4 &inV)											: mValue(Vec4::sLoadFloat4(&inV)) { }
-	inline explicit				Quat(Vec4Arg inV)												: mValue(inV) { }
-	///@}
-
-	///@name Tests
-	///@{
-
-	/// Check if two quaternions are exactly equal
-	inline bool					operator == (QuatArg inRHS) const								{ return mValue == inRHS.mValue; }
-
-	/// Check if two quaternions are different
-	inline bool					operator != (QuatArg inRHS) const								{ return mValue != inRHS.mValue; }
-
-	/// If this quaternion is close to inRHS. Note that q and -q represent the same rotation, this is not checked here.
-	inline bool					IsClose(QuatArg inRHS, float inMaxDistSq = 1.0e-12f) const		{ return mValue.IsClose(inRHS.mValue, inMaxDistSq); }
-
-	/// If the length of this quaternion is 1 +/- inTolerance
-	inline bool					IsNormalized(float inTolerance = 1.0e-5f) const					{ return mValue.IsNormalized(inTolerance); }
-
-	/// If any component of this quaternion is a NaN (not a number)
-	inline bool					IsNaN() const													{ return mValue.IsNaN(); }
-
-	///@}
-	///@name Get components
-	///@{
-
-	/// Get X component (imaginary part i)
-	JPH_INLINE float			GetX() const													{ return mValue.GetX(); }
-
-	/// Get Y component (imaginary part j)
-	JPH_INLINE float			GetY() const													{ return mValue.GetY(); }
-
-	/// Get Z component (imaginary part k)
-	JPH_INLINE float			GetZ() const													{ return mValue.GetZ(); }
-
-	/// Get W component (real part)
-	JPH_INLINE float			GetW() const													{ return mValue.GetW(); }
-
-	/// Get the imaginary part of the quaternion
-	JPH_INLINE Vec3				GetXYZ() const													{ return Vec3(mValue); }
-
-	/// Get the quaternion as a Vec4
-	JPH_INLINE Vec4				GetXYZW() const													{ return mValue; }
-
-	/// Set individual components
-	JPH_INLINE void				SetX(float inX)													{ mValue.SetX(inX); }
-	JPH_INLINE void				SetY(float inY)													{ mValue.SetY(inY); }
-	JPH_INLINE void				SetZ(float inZ)													{ mValue.SetZ(inZ); }
-	JPH_INLINE void				SetW(float inW)													{ mValue.SetW(inW); }
-
-	/// Set all components
-	JPH_INLINE void				Set(float inX, float inY, float inZ, float inW)					{ mValue.Set(inX, inY, inZ, inW); }
-
-	///@}
-	///@name Default quaternions
-	///@{
-
-	/// @return [0, 0, 0, 0]
-	JPH_INLINE static Quat		sZero()															{ return Quat(Vec4::sZero()); }
-
-	/// @return [1, 0, 0, 0] (or in storage format Quat(0, 0, 0, 1))
-	JPH_INLINE static Quat		sIdentity()														{ return Quat(0, 0, 0, 1); }
-
-	///@}
-
-	/// Rotation from axis and angle
-	JPH_INLINE static Quat		sRotation(Vec3Arg inAxis, float inAngle);
-
-	/// Get axis and angle that represents this quaternion, outAngle will always be in the range \f$[0, \pi]\f$
-	JPH_INLINE void				GetAxisAngle(Vec3 &outAxis, float &outAngle) const;
-
-	/// Create quaternion that rotates a vector from the direction of inFrom to the direction of inTo along the shortest path
-	/// @see https://www.euclideanspace.com/maths/algebra/vectors/angleBetween/index.htm
-	JPH_INLINE static Quat		sFromTo(Vec3Arg inFrom, Vec3Arg inTo);
-
-	/// Random unit quaternion
-	template <class Random>
-	inline static Quat			sRandom(Random &inRandom);
-
-	/// Conversion from Euler angles. Rotation order is X then Y then Z (RotZ * RotY * RotX). Angles in radians.
-	inline static Quat			sEulerAngles(Vec3Arg inAngles);
-
-	/// Conversion to Euler angles. Rotation order is X then Y then Z (RotZ * RotY * RotX). Angles in radians.
-	inline Vec3					GetEulerAngles() const;
-
-	///@name Length / normalization operations
-	///@{
-
-	/// Squared length of quaternion.
-	/// @return Squared length of quaternion (\f$|v|^2\f$)
-	JPH_INLINE float			LengthSq() const												{ return mValue.LengthSq(); }
-
-	/// Length of quaternion.
-	/// @return Length of quaternion (\f$|v|\f$)
-	JPH_INLINE float			Length() const													{ return mValue.Length(); }
-
-	/// Normalize the quaternion (make it length 1)
-	JPH_INLINE Quat				Normalized() const												{ return Quat(mValue.Normalized()); }
-
-	///@}
-	///@name Additions / multiplications
-	///@{
-
-	JPH_INLINE void				operator += (QuatArg inRHS)										{ mValue += inRHS.mValue; }
-	JPH_INLINE void				operator -= (QuatArg inRHS)										{ mValue -= inRHS.mValue; }
-	JPH_INLINE void				operator *= (float inValue)										{ mValue *= inValue; }
-	JPH_INLINE void				operator /= (float inValue)										{ mValue /= inValue; }
-	JPH_INLINE Quat				operator - () const												{ return Quat(-mValue); }
-	JPH_INLINE Quat				operator + (QuatArg inRHS) const								{ return Quat(mValue + inRHS.mValue); }
-	JPH_INLINE Quat				operator - (QuatArg inRHS) const								{ return Quat(mValue - inRHS.mValue); }
-	JPH_INLINE Quat				operator * (QuatArg inRHS) const;
-	JPH_INLINE Quat				operator * (float inValue) const								{ return Quat(mValue * inValue); }
-	inline friend Quat			operator * (float inValue, QuatArg inRHS)						{ return Quat(inRHS.mValue * inValue); }
-	JPH_INLINE Quat				operator / (float inValue) const								{ return Quat(mValue / inValue); }
-
-	///@}
-
-	/// Rotate a vector by this quaternion
-	JPH_INLINE Vec3				operator * (Vec3Arg inValue) const;
-
-	/// Multiply a quaternion with imaginary components and no real component (x, y, z, 0) with a quaternion
-	static JPH_INLINE Quat		sMultiplyImaginary(Vec3Arg inLHS, QuatArg inRHS);
-
-	/// Rotate a vector by the inverse of this quaternion
-	JPH_INLINE Vec3				InverseRotate(Vec3Arg inValue) const;
-
-	/// Rotate a the vector (1, 0, 0) with this quaternion
-	JPH_INLINE Vec3				RotateAxisX() const;
-
-	/// Rotate a the vector (0, 1, 0) with this quaternion
-	JPH_INLINE Vec3				RotateAxisY() const;
-
-	/// Rotate a the vector (0, 0, 1) with this quaternion
-	JPH_INLINE Vec3				RotateAxisZ() const;
-
-	/// Dot product
-	JPH_INLINE float			Dot(QuatArg inRHS) const										{ return mValue.Dot(inRHS.mValue); }
-
-	/// The conjugate [w, -x, -y, -z] is the same as the inverse for unit quaternions
-	JPH_INLINE Quat				Conjugated() const												{ return Quat(mValue.FlipSign<-1, -1, -1, 1>()); }
-
-	/// Get inverse quaternion
-	JPH_INLINE Quat				Inversed() const												{ return Conjugated() / Length(); }
-
-	/// Ensures that the W component is positive by negating the entire quaternion if it is not. This is useful when you want to store a quaternion as a 3 vector by discarding W and reconstructing it as sqrt(1 - x^2 - y^2 - z^2).
-	JPH_INLINE Quat				EnsureWPositive() const											{ return Quat(Vec4::sXor(mValue, Vec4::sAnd(mValue.SplatW(), UVec4::sReplicate(0x80000000).ReinterpretAsFloat()))); }
-
-	/// Get a quaternion that is perpendicular to this quaternion
-	JPH_INLINE Quat				GetPerpendicular() const										{ return Quat(mValue.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>().FlipSign<1, -1, 1, -1>()); }
-
-	/// Get rotation angle around inAxis (uses Swing Twist Decomposition to get the twist quaternion and uses q(axis, angle) = [cos(angle / 2), axis * sin(angle / 2)])
-	JPH_INLINE float			GetRotationAngle(Vec3Arg inAxis) const							{ return GetW() == 0.0f? JPH_PI : 2.0f * ATan(GetXYZ().Dot(inAxis) / GetW()); }
-
-	/// Swing Twist Decomposition: any quaternion can be split up as:
-	///
-	/// \f[q = q_{swing} \: q_{twist}\f]
-	///
-	/// where \f$q_{twist}\f$ rotates only around axis v.
-	///
-	/// \f$q_{twist}\f$ is:
-	///
-	/// \f[q_{twist} = \frac{[q_w, q_{ijk} \cdot v \: v]}{\left|[q_w, q_{ijk} \cdot v \: v]\right|}\f]
-	///
-	/// where q_w is the real part of the quaternion and q_i the imaginary part (a 3 vector).
-	///
-	/// The swing can then be calculated as:
-	///
-	/// \f[q_{swing} = q \: q_{twist}^* \f]
-	///
-	/// Where \f$q_{twist}^*\f$ = complex conjugate of \f$q_{twist}\f$
-	JPH_INLINE Quat				GetTwist(Vec3Arg inAxis) const;
-
-	/// Decomposes quaternion into swing and twist component:
-	///
-	/// \f$q = q_{swing} \: q_{twist}\f$
-	///
-	/// where \f$q_{swing} \: \hat{x} = q_{twist} \: \hat{y} = q_{twist} \: \hat{z} = 0\f$
-	///
-	/// In other words:
-	///
-	/// - \f$q_{twist}\f$ only rotates around the X-axis.
-	/// - \f$q_{swing}\f$ only rotates around the Y and Z-axis.
-	///
-	/// @see Gino van den Bergen - Rotational Joint Limits in Quaternion Space - GDC 2016
-	JPH_INLINE void				GetSwingTwist(Quat &outSwing, Quat &outTwist) const;
-
-	/// Linear interpolation between two quaternions (for small steps).
-	/// @param inFraction is in the range [0, 1]
-	/// @param inDestination The destination quaternion
-	/// @return (1 - inFraction) * this + fraction * inDestination
-	JPH_INLINE Quat				LERP(QuatArg inDestination, float inFraction) const;
-
-	/// Spherical linear interpolation between two quaternions.
-	/// @param inFraction is in the range [0, 1]
-	/// @param inDestination The destination quaternion
-	/// @return When fraction is zero this quaternion is returned, when fraction is 1 inDestination is returned.
-	/// When fraction is between 0 and 1 an interpolation along the shortest path is returned.
-	JPH_INLINE Quat				SLERP(QuatArg inDestination, float inFraction) const;
-
-	/// Load 3 floats from memory (X, Y and Z component and then calculates W) reads 32 bits extra which it doesn't use
-	static JPH_INLINE Quat		sLoadFloat3Unsafe(const Float3 &inV);
-
-	/// Store as 3 floats to memory (X, Y and Z component). Ensures that W is positive before storing.
-	JPH_INLINE void				StoreFloat3(Float3 *outV) const;
-
-	/// Store as 4 floats
-	JPH_INLINE void				StoreFloat4(Float4 *outV) const;
-
-	/// Compress a unit quaternion to a 32 bit value, precision is around 0.5 degree
-	JPH_INLINE uint32			CompressUnitQuat() const										{ return mValue.CompressUnitVector(); }
-
-	/// Decompress a unit quaternion from a 32 bit value
-	JPH_INLINE static Quat		sDecompressUnitQuat(uint32 inValue)								{ return Quat(Vec4::sDecompressUnitVector(inValue)); }
-
-	/// To String
-	friend ostream &			operator << (ostream &inStream, QuatArg inQ)					{ inStream << inQ.mValue; return inStream; }
-
-	/// 4 vector that stores [x, y, z, w] parts of the quaternion
-	Vec4						mValue;
-};
-
-static_assert(std::is_trivial<Quat>(), "Is supposed to be a trivial type!");
-
-JPH_NAMESPACE_END
-
-#include "Quat.inl"

package/native/third_party/JoltPhysics/Jolt/Math/Quat.inl

@@ -1,406 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-JPH_NAMESPACE_BEGIN
-
-Quat Quat::operator * (QuatArg inRHS) const
-{
-#if defined(JPH_USE_SSE4_1)
-	// Taken from: http://momchil-velikov.blogspot.nl/2013/10/fast-sse-quternion-multiplication.html
-	__m128 abcd = mValue.mValue;
-	__m128 xyzw = inRHS.mValue.mValue;
-
-	__m128 t0 = _mm_shuffle_ps(abcd, abcd, _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 t1 = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(2, 3, 0, 1));
-
-	__m128 t3 = _mm_shuffle_ps(abcd, abcd, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 t4 = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(1, 0, 3, 2));
-
-	__m128 t5 = _mm_shuffle_ps(abcd, abcd, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 t6 = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(2, 0, 3, 1));
-
-	// [d,d,d,d] * [z,w,x,y] = [dz,dw,dx,dy]
-	__m128 m0 = _mm_mul_ps(t0, t1);
-
-	// [a,a,a,a] * [y,x,w,z] = [ay,ax,aw,az]
-	__m128 m1 = _mm_mul_ps(t3, t4);
-
-	// [b,b,b,b] * [z,x,w,y] = [bz,bx,bw,by]
-	__m128 m2 = _mm_mul_ps(t5, t6);
-
-	// [c,c,c,c] * [w,z,x,y] = [cw,cz,cx,cy]
-	__m128 t7 = _mm_shuffle_ps(abcd, abcd, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 t8 = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(3, 2, 0, 1));
-	__m128 m3 = _mm_mul_ps(t7, t8);
-
-	// [dz,dw,dx,dy] + -[ay,ax,aw,az] = [dz+ay,dw-ax,dx+aw,dy-az]
-	__m128 e = _mm_addsub_ps(m0, m1);
-
-	// [dx+aw,dz+ay,dy-az,dw-ax]
-	e = _mm_shuffle_ps(e, e, _MM_SHUFFLE(1, 3, 0, 2));
-
-	// [dx+aw,dz+ay,dy-az,dw-ax] + -[bz,bx,bw,by] = [dx+aw+bz,dz+ay-bx,dy-az+bw,dw-ax-by]
-	e = _mm_addsub_ps(e, m2);
-
-	// [dz+ay-bx,dw-ax-by,dy-az+bw,dx+aw+bz]
-	e = _mm_shuffle_ps(e, e, _MM_SHUFFLE(2, 0, 1, 3));
-
-	// [dz+ay-bx,dw-ax-by,dy-az+bw,dx+aw+bz] + -[cw,cz,cx,cy] = [dz+ay-bx+cw,dw-ax-by-cz,dy-az+bw+cx,dx+aw+bz-cy]
-	e = _mm_addsub_ps(e, m3);
-
-	// [dw-ax-by-cz,dz+ay-bx+cw,dy-az+bw+cx,dx+aw+bz-cy]
-	return Quat(Vec4(_mm_shuffle_ps(e, e, _MM_SHUFFLE(2, 3, 1, 0))));
-#else
-	float lx = mValue.GetX();
-	float ly = mValue.GetY();
-	float lz = mValue.GetZ();
-	float lw = mValue.GetW();
-
-	float rx = inRHS.mValue.GetX();
-	float ry = inRHS.mValue.GetY();
-	float rz = inRHS.mValue.GetZ();
-	float rw = inRHS.mValue.GetW();
-
-	float x = lw * rx + lx * rw + ly * rz - lz * ry;
-	float y = lw * ry - lx * rz + ly * rw + lz * rx;
-	float z = lw * rz + lx * ry - ly * rx + lz * rw;
-	float w = lw * rw - lx * rx - ly * ry - lz * rz;
-
-	return Quat(x, y, z, w);
-#endif
-}
-
-Quat Quat::sMultiplyImaginary(Vec3Arg inLHS, QuatArg inRHS)
-{
-#if defined(JPH_USE_SSE4_1)
-	__m128 abc0 = inLHS.mValue;
-	__m128 xyzw = inRHS.mValue.mValue;
-
-	// [a,a,a,a] * [w,y,z,x] = [aw,ay,az,ax]
-	__m128 aaaa = _mm_shuffle_ps(abc0, abc0, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 xzyw = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(3, 1, 2, 0));
-	__m128 axazayaw = _mm_mul_ps(aaaa, xzyw);
-
-	// [b,b,b,b] * [z,x,w,y] = [bz,bx,bw,by]
-	__m128 bbbb = _mm_shuffle_ps(abc0, abc0, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 ywxz = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(2, 0, 3, 1));
-	__m128 bybwbxbz = _mm_mul_ps(bbbb, ywxz);
-
-	// [c,c,c,c] * [w,z,x,y] = [cw,cz,cx,cy]
-	__m128 cccc = _mm_shuffle_ps(abc0, abc0, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 yxzw = _mm_shuffle_ps(xyzw, xyzw, _MM_SHUFFLE(3, 2, 0, 1));
-	__m128 cycxczcw = _mm_mul_ps(cccc, yxzw);
-
-	// [+aw,+ay,-az,-ax]
-	__m128 e = _mm_xor_ps(axazayaw, _mm_set_ps(0.0f, 0.0f, -0.0f, -0.0f));
-
-	// [+aw,+ay,-az,-ax] + -[bz,bx,bw,by] = [+aw+bz,+ay-bx,-az+bw,-ax-by]
-	e = _mm_addsub_ps(e, bybwbxbz);
-
-	// [+ay-bx,-ax-by,-az+bw,+aw+bz]
-	e = _mm_shuffle_ps(e, e, _MM_SHUFFLE(2, 0, 1, 3));
-
-	// [+ay-bx,-ax-by,-az+bw,+aw+bz] + -[cw,cz,cx,cy] = [+ay-bx+cw,-ax-by-cz,-az+bw+cx,+aw+bz-cy]
-	e = _mm_addsub_ps(e, cycxczcw);
-
-	// [-ax-by-cz,+ay-bx+cw,-az+bw+cx,+aw+bz-cy]
-	return Quat(Vec4(_mm_shuffle_ps(e, e, _MM_SHUFFLE(2, 3, 1, 0))));
-#else
-	float lx = inLHS.GetX();
-	float ly = inLHS.GetY();
-	float lz = inLHS.GetZ();
-
-	float rx = inRHS.mValue.GetX();
-	float ry = inRHS.mValue.GetY();
-	float rz = inRHS.mValue.GetZ();
-	float rw = inRHS.mValue.GetW();
-
-	float x =  (lx * rw) + ly * rz - lz * ry;
-	float y = -(lx * rz) + ly * rw + lz * rx;
-	float z =  (lx * ry) - ly * rx + lz * rw;
-	float w = -(lx * rx) - ly * ry - lz * rz;
-
-	return Quat(x, y, z, w);
-#endif
-}
-
-Quat Quat::sRotation(Vec3Arg inAxis, float inAngle)
-{
-	// returns [inAxis * sin(0.5f * inAngle), cos(0.5f * inAngle)]
-	JPH_ASSERT(inAxis.IsNormalized());
-	Vec4 s, c;
-	Vec4::sReplicate(0.5f * inAngle).SinCos(s, c);
-	return Quat(Vec4::sSelect(Vec4(inAxis) * s, c, UVec4(0, 0, 0, 0xffffffffU)));
-}
-
-void Quat::GetAxisAngle(Vec3 &outAxis, float &outAngle) const
-{
-	JPH_ASSERT(IsNormalized());
-	Quat w_pos = EnsureWPositive();
-	float abs_w = w_pos.GetW();
-	if (abs_w >= 1.0f)
-	{
-		outAxis = Vec3::sZero();
-		outAngle = 0.0f;
-	}
-	else
-	{
-		outAngle = 2.0f * ACos(abs_w);
-		outAxis = w_pos.GetXYZ().NormalizedOr(Vec3::sZero());
-	}
-}
-
-Quat Quat::sFromTo(Vec3Arg inFrom, Vec3Arg inTo)
-{
-	/*
-		Uses (inFrom = v1, inTo = v2):
-
-		angle = arcos(v1 . v2 / |v1||v2|)
-		axis = normalize(v1 x v2)
-
-		Quaternion is then:
-
-		s = sin(angle / 2)
-		x = axis.x * s
-		y = axis.y * s
-		z = axis.z * s
-		w = cos(angle / 2)
-
-		Using identities:
-
-		sin(2 * a) = 2 * sin(a) * cos(a)
-		cos(2 * a) = cos(a)^2 - sin(a)^2
-		sin(a)^2 + cos(a)^2 = 1
-
-		This reduces to:
-
-		x = (v1 x v2).x
-		y = (v1 x v2).y
-		z = (v1 x v2).z
-		w = |v1||v2| + v1 . v2
-
-		which then needs to be normalized because the whole equation was multiplied by 2 cos(angle / 2)
-	*/
-
-	float len_v1_v2 = sqrt(inFrom.LengthSq() * inTo.LengthSq());
-	float w = len_v1_v2 + inFrom.Dot(inTo);
-
-	if (w == 0.0f)
-	{
-		if (len_v1_v2 == 0.0f)
-		{
-			// If either of the vectors has zero length, there is no rotation and we return identity
-			return Quat::sIdentity();
-		}
-		else
-		{
-			// If vectors are perpendicular, take one of the many 180 degree rotations that exist
-			return Quat(Vec4(inFrom.GetNormalizedPerpendicular(), 0));
-		}
-	}
-
-	Vec3 v = inFrom.Cross(inTo);
-	return Quat(Vec4(v, w)).Normalized();
-}
-
-template <class Random>
-Quat Quat::sRandom(Random &inRandom)
-{
-	std::uniform_real_distribution<float> zero_to_one(0.0f, 1.0f);
-	float x0 = zero_to_one(inRandom);
-	float r1 = sqrt(1.0f - x0), r2 = sqrt(x0);
-	std::uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
-	Vec4 s, c;
-	Vec4(zero_to_two_pi(inRandom), zero_to_two_pi(inRandom), 0, 0).SinCos(s, c);
-	return Quat(s.GetX() * r1, c.GetX() * r1, s.GetY() * r2, c.GetY() * r2);
-}
-
-Quat Quat::sEulerAngles(Vec3Arg inAngles)
-{
-	Vec4 half(0.5f * inAngles);
-	Vec4 s, c;
-	half.SinCos(s, c);
-
-	float cx = c.GetX();
-	float sx = s.GetX();
-	float cy = c.GetY();
-	float sy = s.GetY();
-	float cz = c.GetZ();
-	float sz = s.GetZ();
-
-	return Quat(
-		cz * sx * cy - sz * cx * sy,
-		cz * cx * sy + sz * sx * cy,
-		sz * cx * cy - cz * sx * sy,
-		cz * cx * cy + sz * sx * sy);
-}
-
-Vec3 Quat::GetEulerAngles() const
-{
-	float y_sq = GetY() * GetY();
-
-	// X
-	float t0 = 2.0f * (GetW() * GetX() + GetY() * GetZ());
-	float t1 = 1.0f - 2.0f * (GetX() * GetX() + y_sq);
-
-	// Y
-	float t2 = 2.0f * (GetW() * GetY() - GetZ() * GetX());
-	t2 = t2 > 1.0f? 1.0f : t2;
-	t2 = t2 < -1.0f? -1.0f : t2;
-
-	// Z
-	float t3 = 2.0f * (GetW() * GetZ() + GetX() * GetY());
-	float t4 = 1.0f - 2.0f * (y_sq + GetZ() * GetZ());
-
-	return Vec3(ATan2(t0, t1), ASin(t2), ATan2(t3, t4));
-}
-
-Quat Quat::GetTwist(Vec3Arg inAxis) const
-{
-	Quat twist(Vec4(GetXYZ().Dot(inAxis) * inAxis, GetW()));
-	float twist_len = twist.LengthSq();
-	if (twist_len != 0.0f)
-		return twist / sqrt(twist_len);
-	else
-		return Quat::sIdentity();
-}
-
-void Quat::GetSwingTwist(Quat &outSwing, Quat &outTwist) const
-{
-	float x = GetX(), y = GetY(), z = GetZ(), w = GetW();
-	float s = sqrt(Square(w) + Square(x));
-	if (s != 0.0f)
-	{
-		outTwist = Quat(x / s, 0, 0, w / s);
-		outSwing = Quat(0, (w * y - x * z) / s, (w * z + x * y) / s, s);
-	}
-	else
-	{
-		// If both x and w are zero, this must be a 180 degree rotation around either y or z
-		outTwist = Quat::sIdentity();
-		outSwing = *this;
-	}
-}
-
-Quat Quat::LERP(QuatArg inDestination, float inFraction) const
-{
-	float scale0 = 1.0f - inFraction;
-	return Quat(Vec4::sReplicate(scale0) * mValue + Vec4::sReplicate(inFraction) * inDestination.mValue);
-}
-
-Quat Quat::SLERP(QuatArg inDestination, float inFraction) const
-{
-	// Difference at which to LERP instead of SLERP
-	const float delta = 0.0001f;
-
-	// Calc cosine
-	float sign_scale1 = 1.0f;
-	float cos_omega = Dot(inDestination);
-
-	// Adjust signs (if necessary)
-	if (cos_omega < 0.0f)
-	{
-		cos_omega = -cos_omega;
-		sign_scale1 = -1.0f;
-	}
-
-	// Calculate coefficients
-	float scale0, scale1;
-	if (1.0f - cos_omega > delta)
-	{
-		// Standard case (slerp)
-		float omega = ACos(cos_omega);
-		float sin_omega = Sin(omega);
-		scale0 = Sin((1.0f - inFraction) * omega) / sin_omega;
-		scale1 = sign_scale1 * Sin(inFraction * omega) / sin_omega;
-	}
-	else
-	{
-		// Quaternions are very close so we can do a linear interpolation
-		scale0 = 1.0f - inFraction;
-		scale1 = sign_scale1 * inFraction;
-	}
-
-	// Interpolate between the two quaternions
-	return Quat(Vec4::sReplicate(scale0) * mValue + Vec4::sReplicate(scale1) * inDestination.mValue).Normalized();
-}
-
-Vec3 Quat::operator * (Vec3Arg inValue) const
-{
-	// Rotating a vector by a quaternion is done by: p' = q * (p, 0) * q^-1 (q^-1 = conjugated(q) for a unit quaternion)
-	// Using Rodrigues formula: https://en.m.wikipedia.org/wiki/Euler%E2%80%93Rodrigues_formula
-	// This is equivalent to: p' = p + 2 * (q.w * q.xyz x p + q.xyz x (q.xyz x p))
-	//
-	// This is:
-	//
-	// Vec3 xyz = GetXYZ();
-	// Vec3 q_cross_p = xyz.Cross(inValue);
-	// Vec3 q_cross_q_cross_p = xyz.Cross(q_cross_p);
-	// Vec3 v = mValue.SplatW3() * q_cross_p + q_cross_q_cross_p;
-	// return inValue + (v + v);
-	//
-	// But we can write out the cross products in a more efficient way:
-	JPH_ASSERT(IsNormalized());
-	Vec3 xyz = GetXYZ();
-	Vec3 yzx = xyz.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-	Vec3 q_cross_p = (inValue.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() * xyz - yzx * inValue).Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-	Vec3 q_cross_q_cross_p = (q_cross_p.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() * xyz - yzx * q_cross_p).Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-	Vec3 v = mValue.SplatW3() * q_cross_p + q_cross_q_cross_p;
-	return inValue + (v + v);
-}
-
-Vec3 Quat::InverseRotate(Vec3Arg inValue) const
-{
-	JPH_ASSERT(IsNormalized());
-	Vec3 xyz = GetXYZ(); // Needs to be negated, but we do this in the equations below
-	Vec3 yzx = xyz.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-	Vec3 q_cross_p = (yzx * inValue - inValue.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() * xyz).Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-	Vec3 q_cross_q_cross_p = (yzx * q_cross_p - q_cross_p.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() * xyz).Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-	Vec3 v = mValue.SplatW3() * q_cross_p + q_cross_q_cross_p;
-	return inValue + (v + v);
-}
-
-Vec3 Quat::RotateAxisX() const
-{
-	// This is *this * Vec3::sAxisX() written out:
-	JPH_ASSERT(IsNormalized());
-	Vec4 t = mValue + mValue;
-	return Vec3(t.SplatX() * mValue + (t.SplatW() * mValue.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>()).FlipSign<1, 1, -1, 1>() - Vec4(1, 0, 0, 0));
-}
-
-Vec3 Quat::RotateAxisY() const
-{
-	// This is *this * Vec3::sAxisY() written out:
-	JPH_ASSERT(IsNormalized());
-	Vec4 t = mValue + mValue;
-	return Vec3(t.SplatY() * mValue + (t.SplatW() * mValue.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>()).FlipSign<-1, 1, 1, 1>() - Vec4(0, 1, 0, 0));
-}
-
-Vec3 Quat::RotateAxisZ() const
-{
-	// This is *this * Vec3::sAxisZ() written out:
-	JPH_ASSERT(IsNormalized());
-	Vec4 t = mValue + mValue;
-	return Vec3(t.SplatZ() * mValue + (t.SplatW() * mValue.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>()).FlipSign<1, -1, 1, 1>() - Vec4(0, 0, 1, 0));
-}
-
-void Quat::StoreFloat3(Float3 *outV) const
-{
-	JPH_ASSERT(IsNormalized());
-	EnsureWPositive().GetXYZ().StoreFloat3(outV);
-}
-
-void Quat::StoreFloat4(Float4 *outV) const
-{
-	mValue.StoreFloat4(outV);
-}
-
-Quat Quat::sLoadFloat3Unsafe(const Float3 &inV)
-{
-	Vec3 v = Vec3::sLoadFloat3Unsafe(inV);
-	float w = sqrt(max(1.0f - v.LengthSq(), 0.0f)); // It is possible that the length of v is a fraction above 1, and we don't want to introduce NaN's in that case so we clamp to 0
-	return Quat(Vec4(v, w));
-}
-
-JPH_NAMESPACE_END