@bloomengine/engine 0.3.1

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

@@ -0,0 +1,208 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// The constant \f$\pi\f$
+static constexpr float JPH_PI = 3.14159265358979323846f;
+
+/// A large floating point value which, when squared, is still much smaller than FLT_MAX
+static constexpr float cLargeFloat = 1.0e15f;
+
+/// Convert a value from degrees to radians
+JPH_INLINE constexpr float DegreesToRadians(float inV)
+{
+	return inV * (JPH_PI / 180.0f);
+}
+
+/// Convert a value from radians to degrees
+JPH_INLINE constexpr float RadiansToDegrees(float inV)
+{
+	return inV * (180.0f / JPH_PI);
+}
+
+/// Convert angle in radians to the range \f$[-\pi, \pi]\f$
+inline float CenterAngleAroundZero(float inV)
+{
+	if (inV < -JPH_PI)
+	{
+		do
+			inV += 2.0f * JPH_PI;
+		while (inV < -JPH_PI);
+	}
+	else if (inV > JPH_PI)
+	{
+		do
+			inV -= 2.0f * JPH_PI;
+		while (inV > JPH_PI);
+	}
+	JPH_ASSERT(inV >= -JPH_PI && inV <= JPH_PI);
+	return inV;
+}
+
+/// Clamp a value between two values
+template <typename T>
+JPH_INLINE constexpr T Clamp(T inV, T inMin, T inMax)
+{
+	return min(max(inV, inMin), inMax);
+}
+
+/// Square a value
+template <typename T>
+JPH_INLINE constexpr T Square(T inV)
+{
+	return inV * inV;
+}
+
+/// Returns \f$inV^3\f$.
+template <typename T>
+JPH_INLINE constexpr T Cubed(T inV)
+{
+	return inV * inV * inV;
+}
+
+/// Get the sign of a value
+template <typename T>
+JPH_INLINE constexpr T Sign(T inV)
+{
+	return inV < 0? T(-1) : T(1);
+}
+
+/// Check if inV is a power of 2
+template <typename T>
+constexpr bool IsPowerOf2(T inV)
+{
+	return inV > 0 && (inV & (inV - 1)) == 0;
+}
+
+/// Align inV up to the next inAlignment bytes
+template <typename T>
+inline T AlignUp(T inV, uint64 inAlignment)
+{
+	JPH_ASSERT(IsPowerOf2(inAlignment));
+	return T((uint64(inV) + inAlignment - 1) & ~(inAlignment - 1));
+}
+
+/// Check if inV is inAlignment aligned
+template <typename T>
+inline bool IsAligned(T inV, uint64 inAlignment)
+{
+	JPH_ASSERT(IsPowerOf2(inAlignment));
+	return (uint64(inV) & (inAlignment - 1)) == 0;
+}
+
+/// Compute number of trailing zero bits (how many low bits are zero)
+inline uint CountTrailingZeros(uint32 inValue)
+{
+#if defined(JPH_CPU_X86) || defined(JPH_CPU_WASM)
+	#if defined(JPH_USE_TZCNT)
+		return _tzcnt_u32(inValue);
+	#elif defined(JPH_COMPILER_MSVC)
+		if (inValue == 0)
+			return 32;
+		unsigned long result;
+		_BitScanForward(&result, inValue);
+		return result;
+	#else
+		if (inValue == 0)
+			return 32;
+		return __builtin_ctz(inValue);
+	#endif
+#elif defined(JPH_CPU_ARM)
+	#if defined(JPH_COMPILER_MSVC)
+		if (inValue == 0)
+			return 32;
+		unsigned long result;
+		_BitScanForward(&result, inValue);
+		return result;
+	#else
+		if (inValue == 0)
+			return 32;
+		return __builtin_ctz(inValue);
+	#endif
+#elif defined(JPH_CPU_E2K) || defined(JPH_CPU_RISCV) || defined(JPH_CPU_PPC) || defined(JPH_CPU_LOONGARCH)
+	return inValue ? __builtin_ctz(inValue) : 32;
+#else
+	#error Undefined
+#endif
+}
+
+/// Compute the number of leading zero bits (how many high bits are zero)
+inline uint CountLeadingZeros(uint32 inValue)
+{
+#if defined(JPH_CPU_X86) || defined(JPH_CPU_WASM)
+	#if defined(JPH_USE_LZCNT)
+		return _lzcnt_u32(inValue);
+	#elif defined(JPH_COMPILER_MSVC)
+		if (inValue == 0)
+			return 32;
+		unsigned long result;
+		_BitScanReverse(&result, inValue);
+		return 31 - result;
+	#else
+		if (inValue == 0)
+			return 32;
+		return __builtin_clz(inValue);
+	#endif
+#elif defined(JPH_CPU_ARM)
+	#if defined(JPH_COMPILER_MSVC)
+		return _CountLeadingZeros(inValue);
+	#else
+		return __builtin_clz(inValue);
+	#endif
+#elif defined(JPH_CPU_E2K) || defined(JPH_CPU_RISCV) || defined(JPH_CPU_PPC) || defined(JPH_CPU_LOONGARCH)
+	return inValue ? __builtin_clz(inValue) : 32;
+#else
+	#error Undefined
+#endif
+}
+
+/// Count the number of 1 bits in a value
+inline uint CountBits(uint32 inValue)
+{
+#if defined(JPH_COMPILER_CLANG) || defined(JPH_COMPILER_GCC)
+	return __builtin_popcount(inValue);
+#elif defined(JPH_COMPILER_MSVC)
+	#if defined(JPH_USE_SSE4_2)
+		return _mm_popcnt_u32(inValue);
+	#elif defined(JPH_USE_NEON) && (_MSC_VER >= 1930) // _CountOneBits not available on MSVC2019
+		return _CountOneBits(inValue);
+	#else
+		inValue = inValue - ((inValue >> 1) & 0x55555555);
+		inValue = (inValue & 0x33333333) + ((inValue >> 2) & 0x33333333);
+		inValue = (inValue + (inValue >> 4)) & 0x0F0F0F0F;
+		return (inValue * 0x01010101) >> 24;
+	#endif
+#else
+	#error Undefined
+#endif
+}
+
+/// Get the next higher power of 2 of a value, or the value itself if the value is already a power of 2
+inline uint32 GetNextPowerOf2(uint32 inValue)
+{
+	return inValue <= 1? uint32(1) : uint32(1) << (32 - CountLeadingZeros(inValue - 1));
+}
+
+// Simple implementation of C++20 std::bit_cast (unfortunately not constexpr)
+template <class To, class From>
+JPH_INLINE To BitCast(const From &inValue)
+{
+	static_assert(std::is_trivially_constructible_v<To>);
+	static_assert(sizeof(From) == sizeof(To));
+
+	union FromTo
+	{
+		To			mTo;
+		From		mFrom;
+	};
+
+	FromTo convert;
+	convert.mFrom = inValue;
+	return convert.mTo;
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,32 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+class Vec3;
+class DVec3;
+class Vec4;
+class UVec4;
+class BVec16;
+class Quat;
+class Mat44;
+class DMat44;
+
+// Types to use for passing arguments to functions
+using Vec3Arg = const Vec3;
+#ifdef JPH_USE_AVX
+	using DVec3Arg = const DVec3;
+#else
+	using DVec3Arg = const DVec3 &;
+#endif
+using Vec4Arg = const Vec4;
+using UVec4Arg = const UVec4;
+using BVec16Arg = const BVec16;
+using QuatArg = const Quat;
+using Mat44Arg = const Mat44 &;
+using DMat44Arg = const DMat44 &;
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,259 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Math/Vector.h>
+#include <Jolt/Math/GaussianElimination.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Templatized matrix class
+template <uint Rows, uint Cols>
+class [[nodiscard]] Matrix
+{
+public:
+	/// Constructor
+	inline									Matrix() = default;
+	inline									Matrix(const Matrix &inM2)								{ *this = inM2; }
+
+	/// Dimensions
+	inline uint								GetRows() const											{ return Rows; }
+	inline uint								GetCols() const											{ return Cols; }
+
+	/// Zero matrix
+	inline void								SetZero()
+	{
+		for (uint c = 0; c < Cols; ++c)
+			mCol[c].SetZero();
+	}
+
+	inline static Matrix					sZero()													{ Matrix m; m.SetZero(); return m; }
+
+	/// Check if this matrix consists of all zeros
+	inline bool								IsZero() const
+	{
+		for (uint c = 0; c < Cols; ++c)
+			if (!mCol[c].IsZero())
+				return false;
+
+		return true;
+	}
+
+	/// Identity matrix
+	inline void								SetIdentity()
+	{
+		// Clear matrix
+		SetZero();
+
+		// Set diagonal to 1
+		for (uint rc = 0, min_rc = min(Rows, Cols); rc < min_rc; ++rc)
+			mCol[rc].mF32[rc] = 1.0f;
+	}
+
+	inline static Matrix					sIdentity()												{ Matrix m; m.SetIdentity(); return m; }
+
+	/// Check if this matrix is identity
+	bool									IsIdentity() const										{ return *this == sIdentity(); }
+
+	/// Diagonal matrix
+	inline void								SetDiagonal(const Vector<Rows < Cols? Rows : Cols> &inV)
+	{
+		// Clear matrix
+		SetZero();
+
+		// Set diagonal
+		for (uint rc = 0, min_rc = min(Rows, Cols); rc < min_rc; ++rc)
+			mCol[rc].mF32[rc] = inV[rc];
+	}
+
+	inline static Matrix					sDiagonal(const Vector<Rows < Cols? Rows : Cols> &inV)
+	{
+		Matrix m;
+		m.SetDiagonal(inV);
+		return m;
+	}
+
+	/// Copy a (part) of another matrix into this matrix
+	template <class OtherMatrix>
+		void								CopyPart(const OtherMatrix &inM, uint inSourceRow, uint inSourceCol, uint inNumRows, uint inNumCols, uint inDestRow, uint inDestCol)
+		{
+			for (uint c = 0; c < inNumCols; ++c)
+				for (uint r = 0; r < inNumRows; ++r)
+					mCol[inDestCol + c].mF32[inDestRow + r] = inM(inSourceRow + r, inSourceCol + c);
+		}
+
+	/// Get float component by element index
+	inline float							operator () (uint inRow, uint inColumn) const
+	{
+		JPH_ASSERT(inRow < Rows);
+		JPH_ASSERT(inColumn < Cols);
+		return mCol[inColumn].mF32[inRow];
+	}
+
+	inline float &							operator () (uint inRow, uint inColumn)
+	{
+		JPH_ASSERT(inRow < Rows);
+		JPH_ASSERT(inColumn < Cols);
+		return mCol[inColumn].mF32[inRow];
+	}
+
+	/// Comparison
+	inline bool								operator == (const Matrix &inM2) const
+	{
+		for (uint c = 0; c < Cols; ++c)
+			if (mCol[c] != inM2.mCol[c])
+				return false;
+		return true;
+	}
+
+	inline bool								operator != (const Matrix &inM2) const
+	{
+		for (uint c = 0; c < Cols; ++c)
+			if (mCol[c] != inM2.mCol[c])
+				return true;
+		return false;
+	}
+
+	/// Assignment
+	inline Matrix &							operator = (const Matrix &inM2)
+	{
+		for (uint c = 0; c < Cols; ++c)
+			mCol[c] = inM2.mCol[c];
+		return *this;
+	}
+
+	/// Multiply matrix by matrix
+	template <uint OtherCols>
+	inline Matrix<Rows, OtherCols>	operator * (const Matrix<Cols, OtherCols> &inM) const
+	{
+		Matrix<Rows, OtherCols> m;
+		for (uint c = 0; c < OtherCols; ++c)
+			for (uint r = 0; r < Rows; ++r)
+			{
+				float dot = 0.0f;
+				for (uint i = 0; i < Cols; ++i)
+					dot += mCol[i].mF32[r] * inM.mCol[c].mF32[i];
+				m.mCol[c].mF32[r] = dot;
+			}
+		return m;
+	}
+
+	/// Multiply vector by matrix
+	inline Vector<Rows>						operator * (const Vector<Cols> &inV) const
+	{
+		Vector<Rows> v;
+		for (uint r = 0; r < Rows; ++r)
+		{
+			float dot = 0.0f;
+			for (uint c = 0; c < Cols; ++c)
+				dot += mCol[c].mF32[r] * inV.mF32[c];
+			v.mF32[r] = dot;
+		}
+		return v;
+	}
+
+	/// Multiply matrix with float
+	inline Matrix							operator * (float inV) const
+	{
+		Matrix m;
+		for (uint c = 0; c < Cols; ++c)
+			m.mCol[c] = mCol[c] * inV;
+		return m;
+	}
+
+	inline friend Matrix					operator * (float inV, const Matrix &inM)
+	{
+		return inM * inV;
+	}
+
+	/// Per element addition of matrix
+	inline Matrix							operator + (const Matrix &inM) const
+	{
+		Matrix m;
+		for (uint c = 0; c < Cols; ++c)
+			m.mCol[c] = mCol[c] + inM.mCol[c];
+		return m;
+	}
+
+	/// Per element subtraction of matrix
+	inline Matrix							operator - (const Matrix &inM) const
+	{
+		Matrix m;
+		for (uint c = 0; c < Cols; ++c)
+			m.mCol[c] = mCol[c] - inM.mCol[c];
+		return m;
+	}
+
+	/// Transpose matrix
+	inline Matrix<Cols, Rows>				Transposed() const
+	{
+		Matrix<Cols, Rows> m;
+		for (uint r = 0; r < Rows; ++r)
+			for (uint c = 0; c < Cols; ++c)
+				m.mCol[r].mF32[c] = mCol[c].mF32[r];
+		return m;
+	}
+
+	/// Inverse matrix
+	bool									SetInversed(const Matrix &inM)
+	{
+		if constexpr (Rows != Cols) JPH_ASSERT(false);
+		Matrix copy(inM);
+		SetIdentity();
+		return GaussianElimination(copy, *this);
+	}
+
+	inline Matrix							Inversed() const
+	{
+		Matrix m;
+		m.SetInversed(*this);
+		return m;
+	}
+
+	/// To String
+	friend ostream &						operator << (ostream &inStream, const Matrix &inM)
+	{
+		for (uint i = 0; i < Cols - 1; ++i)
+			inStream << inM.mCol[i] << ", ";
+		inStream << inM.mCol[Cols - 1];
+		return inStream;
+	}
+
+	/// Column access
+	const Vector<Rows> &					GetColumn(int inIdx) const					{ return mCol[inIdx]; }
+	Vector<Rows> &							GetColumn(int inIdx)						{ return mCol[inIdx]; }
+
+	Vector<Rows>							mCol[Cols];									///< Column
+};
+
+// The template specialization doesn't sit well with Doxygen
+#ifndef JPH_PLATFORM_DOXYGEN
+
+/// Specialization of SetInversed for 2x2 matrix
+template <>
+inline bool Matrix<2, 2>::SetInversed(const Matrix<2, 2> &inM)
+{
+	// Fetch elements
+	float a = inM.mCol[0].mF32[0];
+	float b = inM.mCol[1].mF32[0];
+	float c = inM.mCol[0].mF32[1];
+	float d = inM.mCol[1].mF32[1];
+
+	// Calculate determinant
+	float det = a * d - b * c;
+	if (det == 0.0f)
+		return false;
+
+	// Construct inverse
+	mCol[0].mF32[0] = d / det;
+	mCol[1].mF32[0] = -b / det;
+	mCol[0].mF32[1] = -c / det;
+	mCol[1].mF32[1] = a / det;
+	return true;
+}
+
+#endif // !JPH_PLATFORM_DOXYGEN
+
+JPH_NAMESPACE_END