@bloomengine/engine 0.3.1

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

@@ -0,0 +1,208 @@
+// 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

@@ -0,0 +1,243 @@
+// 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"