@bloomengine/engine 0.4.0 → 0.4.1

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

@@ -1,208 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/Vec4.h>
-#include <Jolt/Core/FPException.h>
-
-JPH_NAMESPACE_BEGIN
-
-using HalfFloat = uint16;
-
-// Define half float constant values
-static constexpr HalfFloat HALF_FLT_MAX				= 0x7bff;
-static constexpr HalfFloat HALF_FLT_MAX_NEGATIVE	= 0xfbff;
-static constexpr HalfFloat HALF_FLT_INF				= 0x7c00;
-static constexpr HalfFloat HALF_FLT_INF_NEGATIVE	= 0xfc00;
-static constexpr HalfFloat HALF_FLT_NANQ			= 0x7e00;
-static constexpr HalfFloat HALF_FLT_NANQ_NEGATIVE	= 0xfe00;
-
-namespace HalfFloatConversion {
-
-// Layout of a float
-static constexpr int FLOAT_SIGN_POS = 31;
-static constexpr int FLOAT_EXPONENT_POS = 23;
-static constexpr int FLOAT_EXPONENT_BITS = 8;
-static constexpr int FLOAT_EXPONENT_MASK = (1 << FLOAT_EXPONENT_BITS) - 1;
-static constexpr int FLOAT_EXPONENT_BIAS = 127;
-static constexpr int FLOAT_MANTISSA_BITS = 23;
-static constexpr int FLOAT_MANTISSA_MASK = (1 << FLOAT_MANTISSA_BITS) - 1;
-static constexpr int FLOAT_EXPONENT_AND_MANTISSA_MASK = FLOAT_MANTISSA_MASK + (FLOAT_EXPONENT_MASK << FLOAT_EXPONENT_POS);
-
-// Layout of half float
-static constexpr int HALF_FLT_SIGN_POS = 15;
-static constexpr int HALF_FLT_EXPONENT_POS = 10;
-static constexpr int HALF_FLT_EXPONENT_BITS = 5;
-static constexpr int HALF_FLT_EXPONENT_MASK = (1 << HALF_FLT_EXPONENT_BITS) - 1;
-static constexpr int HALF_FLT_EXPONENT_BIAS = 15;
-static constexpr int HALF_FLT_MANTISSA_BITS = 10;
-static constexpr int HALF_FLT_MANTISSA_MASK = (1 << HALF_FLT_MANTISSA_BITS) - 1;
-static constexpr int HALF_FLT_EXPONENT_AND_MANTISSA_MASK = HALF_FLT_MANTISSA_MASK + (HALF_FLT_EXPONENT_MASK << HALF_FLT_EXPONENT_POS);
-
-/// Define half-float rounding modes
-enum ERoundingMode
-{
-	ROUND_TO_NEG_INF,				///< Round to negative infinity
-	ROUND_TO_POS_INF,				///< Round to positive infinity
-	ROUND_TO_NEAREST,				///< Round to nearest value
-};
-
-/// Convert a float (32-bits) to a half float (16-bits), fallback version when no intrinsics available
-template <int RoundingMode>
-inline HalfFloat FromFloatFallback(float inV)
-{
-	// Reinterpret the float as an uint32
-	uint32 value = BitCast<uint32>(inV);
-
-	// Extract exponent
-	uint32 exponent = (value >> FLOAT_EXPONENT_POS) & FLOAT_EXPONENT_MASK;
-
-	// Extract mantissa
-	uint32 mantissa = value & FLOAT_MANTISSA_MASK;
-
-	// Extract the sign and move it into the right spot for the half float (so we can just or it in at the end)
-	HalfFloat hf_sign = HalfFloat(value >> (FLOAT_SIGN_POS - HALF_FLT_SIGN_POS)) & (1 << HALF_FLT_SIGN_POS);
-
-	// Check NaN or INF
-	if (exponent == FLOAT_EXPONENT_MASK) // NaN or INF
-		return hf_sign | (mantissa == 0? HALF_FLT_INF : HALF_FLT_NANQ);
-
-	// Rebias the exponent for half floats
-	int rebiased_exponent = int(exponent) - FLOAT_EXPONENT_BIAS + HALF_FLT_EXPONENT_BIAS;
-
-	// Check overflow to infinity
-	if (rebiased_exponent >= HALF_FLT_EXPONENT_MASK)
-	{
-		bool round_up = RoundingMode == ROUND_TO_NEAREST || (hf_sign == 0) == (RoundingMode == ROUND_TO_POS_INF);
-		return hf_sign | (round_up? HALF_FLT_INF : HALF_FLT_MAX);
-	}
-
-	// Check underflow to zero
-	if (rebiased_exponent < -HALF_FLT_MANTISSA_BITS)
-	{
-		bool round_up = RoundingMode != ROUND_TO_NEAREST && (hf_sign == 0) == (RoundingMode == ROUND_TO_POS_INF) && (value & FLOAT_EXPONENT_AND_MANTISSA_MASK) != 0;
-		return hf_sign | (round_up? 1 : 0);
-	}
-
-	HalfFloat hf_exponent;
-	int shift;
-	if (rebiased_exponent <= 0)
-	{
-		// Underflow to denormalized number
-		hf_exponent = 0;
-		mantissa |= 1 << FLOAT_MANTISSA_BITS; // Add the implicit 1 bit to the mantissa
-		shift = FLOAT_MANTISSA_BITS - HALF_FLT_MANTISSA_BITS + 1 - rebiased_exponent;
-	}
-	else
-	{
-		// Normal half float
-		hf_exponent = HalfFloat(rebiased_exponent << HALF_FLT_EXPONENT_POS);
-		shift = FLOAT_MANTISSA_BITS - HALF_FLT_MANTISSA_BITS;
-	}
-
-	// Compose the half float
-	HalfFloat hf_mantissa = HalfFloat(mantissa >> shift);
-	HalfFloat hf = hf_sign | hf_exponent | hf_mantissa;
-
-	// Calculate the remaining bits that we're discarding
-	uint remainder = mantissa & ((1 << shift) - 1);
-
-	if constexpr (RoundingMode == ROUND_TO_NEAREST)
-	{
-		// Round to nearest
-		uint round_threshold = 1 << (shift - 1);
-		if (remainder > round_threshold // Above threshold, we must always round
-			|| (remainder == round_threshold && (hf_mantissa & 1))) // When equal, round to nearest even
-			hf++; // May overflow to infinity
-	}
-	else
-	{
-		// Round up or down (truncate) depending on the rounding mode
-		bool round_up = (hf_sign == 0) == (RoundingMode == ROUND_TO_POS_INF) && remainder != 0;
-		if (round_up)
-			hf++; // May overflow to infinity
-	}
-
-	return hf;
-}
-
-/// Convert a float (32-bits) to a half float (16-bits)
-template <int RoundingMode>
-JPH_INLINE HalfFloat FromFloat(float inV)
-{
-#ifdef JPH_USE_F16C
-	FPExceptionDisableOverflow disable_overflow;
-	JPH_UNUSED(disable_overflow);
-
-	union
-	{
-		__m128i		u128;
-		HalfFloat	u16[8];
-	} hf;
-	__m128 val = _mm_load_ss(&inV);
-	switch (RoundingMode)
-	{
-	case ROUND_TO_NEG_INF:
-		hf.u128 = _mm_cvtps_ph(val, _MM_FROUND_TO_NEG_INF);
-		break;
-	case ROUND_TO_POS_INF:
-		hf.u128 = _mm_cvtps_ph(val, _MM_FROUND_TO_POS_INF);
-		break;
-	case ROUND_TO_NEAREST:
-		hf.u128 = _mm_cvtps_ph(val, _MM_FROUND_TO_NEAREST_INT);
-		break;
-	}
-	return hf.u16[0];
-#else
-	return FromFloatFallback<RoundingMode>(inV);
-#endif
-}
-
-/// Convert 4 half floats (lower 64 bits) to floats, fallback version when no intrinsics available
-inline Vec4 ToFloatFallback(UVec4Arg inValue)
-{
-	// Unpack half floats to 4 uint32's
-	UVec4 value = inValue.Expand4Uint16Lo();
-
-	// Normal half float path, extract the exponent and mantissa, shift them into place and update the exponent bias
-	UVec4 exponent_mantissa = UVec4::sAnd(value, UVec4::sReplicate(HALF_FLT_EXPONENT_AND_MANTISSA_MASK)).LogicalShiftLeft<FLOAT_EXPONENT_POS - HALF_FLT_EXPONENT_POS>() + UVec4::sReplicate((FLOAT_EXPONENT_BIAS - HALF_FLT_EXPONENT_BIAS) << FLOAT_EXPONENT_POS);
-
-	// Denormalized half float path, renormalize the float
-	UVec4 exponent_mantissa_denormalized = ((exponent_mantissa + UVec4::sReplicate(1 << FLOAT_EXPONENT_POS)).ReinterpretAsFloat() - UVec4::sReplicate((FLOAT_EXPONENT_BIAS - HALF_FLT_EXPONENT_BIAS + 1) << FLOAT_EXPONENT_POS).ReinterpretAsFloat()).ReinterpretAsInt();
-
-	// NaN / INF path, set all exponent bits
-	UVec4 exponent_mantissa_nan_inf = UVec4::sOr(exponent_mantissa, UVec4::sReplicate(FLOAT_EXPONENT_MASK << FLOAT_EXPONENT_POS));
-
-	// Get the exponent to determine which of the paths we should take
-	UVec4 exponent_mask = UVec4::sReplicate(HALF_FLT_EXPONENT_MASK << HALF_FLT_EXPONENT_POS);
-	UVec4 exponent = UVec4::sAnd(value, exponent_mask);
-	UVec4 is_denormalized = UVec4::sEquals(exponent, UVec4::sZero());
-	UVec4 is_nan_inf = UVec4::sEquals(exponent, exponent_mask);
-
-	// Select the correct result
-	UVec4 result_exponent_mantissa = UVec4::sSelect(UVec4::sSelect(exponent_mantissa, exponent_mantissa_nan_inf, is_nan_inf), exponent_mantissa_denormalized, is_denormalized);
-
-	// Extract the sign bit and shift it to the left
-	UVec4 sign = UVec4::sAnd(value, UVec4::sReplicate(1 << HALF_FLT_SIGN_POS)).LogicalShiftLeft<FLOAT_SIGN_POS - HALF_FLT_SIGN_POS>();
-
-	// Construct the float
-	return UVec4::sOr(sign, result_exponent_mantissa).ReinterpretAsFloat();
-}
-
-/// Convert 4 half floats (lower 64 bits) to floats
-JPH_INLINE Vec4 ToFloat(UVec4Arg inValue)
-{
-#if defined(JPH_USE_F16C)
-	return _mm_cvtph_ps(inValue.mValue);
-#elif defined(JPH_USE_NEON)
-	return vcvt_f32_f16(vreinterpret_f16_u32(vget_low_u32(inValue.mValue)));
-#else
-	return ToFloatFallback(inValue);
-#endif
-}
-
-} // HalfFloatConversion
-
-JPH_NAMESPACE_END

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

@@ -1,243 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/MathTypes.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Holds a 4x4 matrix of floats, but supports also operations on the 3x3 upper left part of the matrix.
-class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Mat44
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	// Underlying column type
-	using Type = Vec4::Type;
-
-	// Argument type
-	using ArgType = Mat44Arg;
-
-	/// Constructor
-								Mat44() = default; ///< Intentionally not initialized for performance reasons
-	JPH_INLINE					Mat44(Vec4Arg inC1, Vec4Arg inC2, Vec4Arg inC3, Vec4Arg inC4);
-	JPH_INLINE					Mat44(Vec4Arg inC1, Vec4Arg inC2, Vec4Arg inC3, Vec3Arg inC4);
-								Mat44(const Mat44 &inM2) = default;
-	Mat44 &						operator = (const Mat44 &inM2) = default;
-	JPH_INLINE					Mat44(Type inC1, Type inC2, Type inC3, Type inC4);
-
-	/// Zero matrix
-	static JPH_INLINE Mat44		sZero();
-
-	/// Identity matrix
-	static JPH_INLINE Mat44		sIdentity();
-
-	/// Matrix filled with NaN's
-	static JPH_INLINE Mat44		sNaN();
-
-	/// Load 16 floats from memory
-	static JPH_INLINE Mat44		sLoadFloat4x4(const Float4 *inV);
-
-	/// Load 16 floats from memory, 16 bytes aligned
-	static JPH_INLINE Mat44		sLoadFloat4x4Aligned(const Float4 *inV);
-
-	/// Rotate around X, Y or Z axis (angle in radians)
-	static JPH_INLINE Mat44		sRotationX(float inX);
-	static JPH_INLINE Mat44		sRotationY(float inY);
-	static JPH_INLINE Mat44		sRotationZ(float inZ);
-
-	/// Rotate around arbitrary axis
-	static JPH_INLINE Mat44		sRotation(Vec3Arg inAxis, float inAngle);
-
-	/// Rotate from quaternion
-	static JPH_INLINE Mat44		sRotation(QuatArg inQuat);
-
-	/// Get matrix that translates
-	static JPH_INLINE Mat44		sTranslation(Vec3Arg inV);
-
-	/// Get matrix that rotates and translates
-	static JPH_INLINE Mat44		sRotationTranslation(QuatArg inR, Vec3Arg inT);
-
-	/// Get inverse matrix of sRotationTranslation
-	static JPH_INLINE Mat44		sInverseRotationTranslation(QuatArg inR, Vec3Arg inT);
-
-	/// Get matrix that scales uniformly
-	static JPH_INLINE Mat44		sScale(float inScale);
-
-	/// Get matrix that scales (produces a matrix with (inV, 1) on its diagonal)
-	static JPH_INLINE Mat44		sScale(Vec3Arg inV);
-
-	/// Get outer product of inV and inV2 (equivalent to \f$inV1 \otimes inV2\f$)
-	static JPH_INLINE Mat44		sOuterProduct(Vec3Arg inV1, Vec3Arg inV2);
-
-	/// Get matrix that represents a cross product \f$A \times B = \text{sCrossProduct}(A) \: B\f$
-	static JPH_INLINE Mat44		sCrossProduct(Vec3Arg inV);
-
-	/// Returns matrix ML so that \f$ML(q) \: p = q \: p\f$ (where p and q are quaternions)
-	static JPH_INLINE Mat44		sQuatLeftMultiply(QuatArg inQ);
-
-	/// Returns matrix MR so that \f$MR(q) \: p = p \: q\f$ (where p and q are quaternions)
-	static JPH_INLINE Mat44		sQuatRightMultiply(QuatArg inQ);
-
-	/// Returns a look at matrix that transforms from world space to view space
-	/// @param inPos Position of the camera
-	/// @param inTarget Target of the camera
-	/// @param inUp Up vector
-	static JPH_INLINE Mat44		sLookAt(Vec3Arg inPos, Vec3Arg inTarget, Vec3Arg inUp);
-
-	/// Returns a right-handed perspective projection matrix
-	static JPH_INLINE Mat44		sPerspective(float inFovY, float inAspect, float inNear, float inFar);
-
-	/// Get float component by element index
-	JPH_INLINE float			operator () (uint inRow, uint inColumn) const			{ JPH_ASSERT(inRow < 4); JPH_ASSERT(inColumn < 4); return mCol[inColumn].mF32[inRow]; }
-	JPH_INLINE float &			operator () (uint inRow, uint inColumn)					{ JPH_ASSERT(inRow < 4); JPH_ASSERT(inColumn < 4); return mCol[inColumn].mF32[inRow]; }
-
-	/// Comparison
-	JPH_INLINE bool				operator == (Mat44Arg inM2) const;
-	JPH_INLINE bool				operator != (Mat44Arg inM2) const						{ return !(*this == inM2); }
-
-	/// Test if two matrices are close
-	JPH_INLINE bool				IsClose(Mat44Arg inM2, float inMaxDistSq = 1.0e-12f) const;
-
-	/// Multiply matrix by matrix
-	JPH_INLINE Mat44			operator * (Mat44Arg inM) const;
-
-	/// Multiply vector by matrix
-	JPH_INLINE Vec3				operator * (Vec3Arg inV) const;
-	JPH_INLINE Vec4				operator * (Vec4Arg inV) const;
-
-	/// Multiply vector by only 3x3 part of the matrix
-	JPH_INLINE Vec3				Multiply3x3(Vec3Arg inV) const;
-
-	/// Multiply vector by only 3x3 part of the transpose of the matrix (\f$result = this^T \: inV\f$)
-	JPH_INLINE Vec3				Multiply3x3Transposed(Vec3Arg inV) const;
-
-	/// Multiply 3x3 matrix by 3x3 matrix
-	JPH_INLINE Mat44			Multiply3x3(Mat44Arg inM) const;
-
-	/// Multiply transpose of 3x3 matrix by 3x3 matrix (\f$result = this^T \: inM\f$)
-	JPH_INLINE Mat44			Multiply3x3LeftTransposed(Mat44Arg inM) const;
-
-	/// Multiply 3x3 matrix by the transpose of a 3x3 matrix (\f$result = this \: inM^T\f$)
-	JPH_INLINE Mat44			Multiply3x3RightTransposed(Mat44Arg inM) const;
-
-	/// Multiply matrix with float
-	JPH_INLINE Mat44			operator * (float inV) const;
-	friend JPH_INLINE Mat44		operator * (float inV, Mat44Arg inM)					{ return inM * inV; }
-
-	/// Multiply matrix with float
-	JPH_INLINE Mat44 &			operator *= (float inV);
-
-	/// Per element addition of matrix
-	JPH_INLINE Mat44			operator + (Mat44Arg inM) const;
-
-	/// Negate
-	JPH_INLINE Mat44			operator - () const;
-
-	/// Per element subtraction of matrix
-	JPH_INLINE Mat44			operator - (Mat44Arg inM) const;
-
-	/// Per element addition of matrix
-	JPH_INLINE Mat44 &			operator += (Mat44Arg inM);
-
-	/// Access to the columns
-	JPH_INLINE Vec3				GetAxisX() const										{ return Vec3(mCol[0]); }
-	JPH_INLINE void				SetAxisX(Vec3Arg inV)									{ mCol[0] = Vec4(inV, 0.0f); }
-	JPH_INLINE Vec3				GetAxisY() const										{ return Vec3(mCol[1]); }
-	JPH_INLINE void				SetAxisY(Vec3Arg inV)									{ mCol[1] = Vec4(inV, 0.0f); }
-	JPH_INLINE Vec3				GetAxisZ() const										{ return Vec3(mCol[2]); }
-	JPH_INLINE void				SetAxisZ(Vec3Arg inV)									{ mCol[2] = Vec4(inV, 0.0f); }
-	JPH_INLINE Vec3				GetTranslation() const									{ return Vec3(mCol[3]); }
-	JPH_INLINE void				SetTranslation(Vec3Arg inV)								{ mCol[3] = Vec4(inV, 1.0f); }
-	JPH_INLINE Vec3				GetDiagonal3() const									{ return Vec3(mCol[0][0], mCol[1][1], mCol[2][2]); }
-	JPH_INLINE void				SetDiagonal3(Vec3Arg inV)								{ mCol[0][0] = inV.GetX(); mCol[1][1] = inV.GetY(); mCol[2][2] = inV.GetZ(); }
-	JPH_INLINE Vec4				GetDiagonal4() const									{ return Vec4(mCol[0][0], mCol[1][1], mCol[2][2], mCol[3][3]); }
-	JPH_INLINE void				SetDiagonal4(Vec4Arg inV)								{ mCol[0][0] = inV.GetX(); mCol[1][1] = inV.GetY(); mCol[2][2] = inV.GetZ(); mCol[3][3] = inV.GetW(); }
-	JPH_INLINE Vec3				GetColumn3(uint inCol) const							{ JPH_ASSERT(inCol < 4); return Vec3(mCol[inCol]); }
-	JPH_INLINE void				SetColumn3(uint inCol, Vec3Arg inV)						{ JPH_ASSERT(inCol < 4); mCol[inCol] = Vec4(inV, inCol == 3? 1.0f : 0.0f); }
-	JPH_INLINE Vec4				GetColumn4(uint inCol) const							{ JPH_ASSERT(inCol < 4); return mCol[inCol]; }
-	JPH_INLINE void				SetColumn4(uint inCol, Vec4Arg inV)						{ JPH_ASSERT(inCol < 4); mCol[inCol] = inV; }
-
-	/// Store matrix to memory
-	JPH_INLINE void				StoreFloat4x4(Float4 *outV) const;
-
-	/// Transpose matrix
-	JPH_INLINE Mat44			Transposed() const;
-
-	/// Transpose 3x3 subpart of matrix
-	JPH_INLINE Mat44			Transposed3x3() const;
-
-	/// Inverse 4x4 matrix
-	JPH_INLINE Mat44			Inversed() const;
-
-	/// Inverse 4x4 matrix when it only contains rotation and translation
-	JPH_INLINE Mat44			InversedRotationTranslation() const;
-
-	/// Get the determinant of a 3x3 matrix
-	JPH_INLINE float			GetDeterminant3x3() const;
-
-	/// Get the adjoint of a 3x3 matrix
-	JPH_INLINE Mat44			Adjointed3x3() const;
-
-	/// Inverse 3x3 matrix
-	JPH_INLINE Mat44			Inversed3x3() const;
-
-	/// *this = inM.Inversed3x3(), returns false if the matrix is singular in which case *this is unchanged
-	JPH_INLINE bool				SetInversed3x3(Mat44Arg inM);
-
-	/// Get rotation part only (note: retains the first 3 values from the bottom row)
-	JPH_INLINE Mat44			GetRotation() const;
-
-	/// Get rotation part only (note: also clears the bottom row)
-	JPH_INLINE Mat44			GetRotationSafe() const;
-
-	/// Updates the rotation part of this matrix (the first 3 columns)
-	JPH_INLINE void				SetRotation(Mat44Arg inRotation);
-
-	/// Convert to quaternion
-	JPH_INLINE Quat				GetQuaternion() const;
-
-	/// Get matrix that transforms a direction with the same transform as this matrix (length is not preserved)
-	JPH_INLINE Mat44			GetDirectionPreservingMatrix() const					{ return GetRotation().Inversed3x3().Transposed3x3(); }
-
-	/// Pre multiply by translation matrix: result = this * Mat44::sTranslation(inTranslation)
-	JPH_INLINE Mat44			PreTranslated(Vec3Arg inTranslation) const;
-
-	/// Post multiply by translation matrix: result = Mat44::sTranslation(inTranslation) * this (i.e. add inTranslation to the 4-th column)
-	JPH_INLINE Mat44			PostTranslated(Vec3Arg inTranslation) const;
-
-	/// Scale a matrix: result = this * Mat44::sScale(inScale)
-	JPH_INLINE Mat44			PreScaled(Vec3Arg inScale) const;
-
-	/// Scale a matrix: result = Mat44::sScale(inScale) * this
-	JPH_INLINE Mat44			PostScaled(Vec3Arg inScale) const;
-
-	/// Decompose a matrix into a rotation & translation part and into a scale part so that:
-	/// this = return_value * Mat44::sScale(outScale).
-	/// This equation only holds when the matrix is orthogonal, if it is not the returned matrix
-	/// will be made orthogonal using the modified Gram-Schmidt algorithm (see: https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process)
-	JPH_INLINE Mat44			Decompose(Vec3 &outScale) const;
-
-#ifndef JPH_DOUBLE_PRECISION
-	/// In single precision mode just return the matrix itself
-	JPH_INLINE Mat44			ToMat44() const											{ return *this; }
-#endif // !JPH_DOUBLE_PRECISION
-
-	/// To String
-	friend ostream &			operator << (ostream &inStream, Mat44Arg inM)
-	{
-		inStream << inM.mCol[0] << ", " << inM.mCol[1] << ", " << inM.mCol[2] << ", " << inM.mCol[3];
-		return inStream;
-	}
-
-private:
-	Vec4						mCol[4];												///< Column
-};
-
-static_assert(std::is_trivial<Mat44>(), "Is supposed to be a trivial type!");
-
-JPH_NAMESPACE_END
-
-#include "Mat44.inl"