@bloomengine/engine 0.4.0 → 0.4.2

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

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

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

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