@bloomengine/engine 0.3.1

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

@@ -0,0 +1,48 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/HashCombine.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Class that holds 3 doubles. Used as a storage class. Convert to DVec3 for calculations.
+class [[nodiscard]] Double3
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+				Double3() = default; ///< Intentionally not initialized for performance reasons
+				Double3(const Double3 &inRHS) = default;
+	Double3 &	operator = (const Double3 &inRHS) = default;
+				Double3(double inX, double inY, double inZ) : x(inX), y(inY), z(inZ) { }
+
+	double		operator [] (int inCoordinate) const
+	{
+		JPH_ASSERT(inCoordinate < 3);
+		return *(&x + inCoordinate);
+	}
+
+	bool		operator == (const Double3 &inRHS) const
+	{
+		return x == inRHS.x && y == inRHS.y && z == inRHS.z;
+	}
+
+	bool		operator != (const Double3 &inRHS) const
+	{
+		return x != inRHS.x || y != inRHS.y || z != inRHS.z;
+	}
+
+	double		x;
+	double		y;
+	double		z;
+};
+
+static_assert(std::is_trivial<Double3>(), "Is supposed to be a trivial type!");
+
+JPH_NAMESPACE_END
+
+// Create a std::hash/JPH::Hash for Double3
+JPH_MAKE_HASHABLE(JPH::Double3, t.x, t.y, t.z)

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

@@ -0,0 +1,31 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Dynamic resizable matrix class
+class [[nodiscard]] DynMatrix
+{
+public:
+	/// Constructor
+					DynMatrix(const DynMatrix &) = default;
+					DynMatrix(uint inRows, uint inCols)			: mRows(inRows), mCols(inCols) { mElements.resize(inRows * inCols); }
+
+	/// Access an element
+	float			operator () (uint inRow, uint inCol) const	{ JPH_ASSERT(inRow < mRows && inCol < mCols); return mElements[inRow * mCols + inCol]; }
+	float &			operator () (uint inRow, uint inCol)		{ JPH_ASSERT(inRow < mRows && inCol < mCols); return mElements[inRow * mCols + inCol]; }
+
+	/// Get dimensions
+	uint			GetCols() const								{ return mCols; }
+	uint			GetRows() const								{ return mRows; }
+
+private:
+	uint			mRows;
+	uint			mCols;
+	Array<float>	mElements;
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,177 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/FPException.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Function to determine the eigen vectors and values of a N x N real symmetric matrix
+/// by Jacobi transformations. This method is most suitable for N < 10.
+///
+/// Taken and adapted from Numerical Recipes paragraph 11.1
+///
+/// An eigen vector is a vector v for which \f$A \: v = \lambda \: v\f$
+///
+/// Where:
+/// A: A square matrix.
+/// \f$\lambda\f$: a non-zero constant value.
+///
+/// @see https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors
+///
+/// Matrix is a matrix type, which has dimensions N x N.
+/// @param inMatrix is the matrix of which to return the eigenvalues and vectors
+/// @param outEigVec will contain a matrix whose columns contain the normalized eigenvectors (must be identity before call)
+/// @param outEigVal will contain the eigenvalues
+template <class Vector, class Matrix>
+bool EigenValueSymmetric(const Matrix &inMatrix, Matrix &outEigVec, Vector &outEigVal)
+{
+	// This algorithm can generate infinite values, see comment below
+	FPExceptionDisableInvalid disable_invalid;
+	JPH_UNUSED(disable_invalid);
+
+	// Maximum number of sweeps to make
+	const int cMaxSweeps = 50;
+
+	// Get problem dimension
+	const uint n = inMatrix.GetRows();
+
+	// Make sure the dimensions are right
+	JPH_ASSERT(inMatrix.GetRows() == n);
+	JPH_ASSERT(inMatrix.GetCols() == n);
+	JPH_ASSERT(outEigVec.GetRows() == n);
+	JPH_ASSERT(outEigVec.GetCols() == n);
+	JPH_ASSERT(outEigVal.GetRows() == n);
+	JPH_ASSERT(outEigVec.IsIdentity());
+
+	// Get the matrix in a so we can mess with it
+	Matrix a = inMatrix;
+
+	Vector b, z;
+
+	for (uint ip = 0; ip < n; ++ip)
+	{
+		// Initialize b to diagonal of a
+		b[ip] = a(ip, ip);
+
+		// Initialize output to diagonal of a
+		outEigVal[ip] = a(ip, ip);
+
+		// Reset z
+		z[ip] = 0.0f;
+	}
+
+	for (int sweep = 0; sweep < cMaxSweeps; ++sweep)
+	{
+		// Get the sum of the off-diagonal elements of a
+		float sm = 0.0f;
+		for (uint ip = 0; ip < n - 1; ++ip)
+			for (uint iq = ip + 1; iq < n; ++iq)
+				sm += abs(a(ip, iq));
+		float avg_sm = sm / Square(n);
+
+		// Normal return, convergence to machine underflow
+		if (avg_sm < FLT_MIN) // Original code: sm == 0.0f, when the average is denormal, we also consider it machine underflow
+		{
+			// Sanity checks
+			#ifdef JPH_ENABLE_ASSERTS
+				for (uint c = 0; c < n; ++c)
+				{
+					// Check if the eigenvector is normalized
+					JPH_ASSERT(outEigVec.GetColumn(c).IsNormalized());
+
+					// Check if inMatrix * eigen_vector = eigen_value * eigen_vector
+					Vector mat_eigvec = inMatrix * outEigVec.GetColumn(c);
+					Vector eigval_eigvec = outEigVal[c] * outEigVec.GetColumn(c);
+					JPH_ASSERT(mat_eigvec.IsClose(eigval_eigvec, max(mat_eigvec.LengthSq(), eigval_eigvec.LengthSq()) * 1.0e-6f));
+				}
+			#endif
+
+			// Success
+			return true;
+		}
+
+		// On the first three sweeps use a fraction of the sum of the off diagonal elements as threshold
+		// Note that we pick a minimum threshold of FLT_MIN because dividing by a denormalized number is likely to result in infinity.
+		float thresh = sweep < 4? 0.2f * avg_sm : FLT_MIN; // Original code: 0.0f instead of FLT_MIN
+
+		for (uint ip = 0; ip < n - 1; ++ip)
+			for (uint iq = ip + 1; iq < n; ++iq)
+			{
+				float &a_pq = a(ip, iq);
+				float &eigval_p = outEigVal[ip];
+				float &eigval_q = outEigVal[iq];
+
+				float abs_a_pq = abs(a_pq);
+				float g = 100.0f * abs_a_pq;
+
+				// After four sweeps, skip the rotation if the off-diagonal element is small
+				if (sweep > 4
+					&& abs(eigval_p) + g == abs(eigval_p)
+					&& abs(eigval_q) + g == abs(eigval_q))
+				{
+					a_pq = 0.0f;
+				}
+				else if (abs_a_pq > thresh)
+				{
+					float h = eigval_q - eigval_p;
+					float abs_h = abs(h);
+
+					float t;
+					if (abs_h + g == abs_h)
+					{
+						t = a_pq / h;
+					}
+					else
+					{
+						float theta = 0.5f * h / a_pq; // Warning: Can become infinite if a(ip, iq) is very small which may trigger an invalid float exception
+						t = 1.0f / (abs(theta) + sqrt(1.0f + theta * theta)); // If theta becomes inf, t will be 0 so the infinite is not a problem for the algorithm
+						if (theta < 0.0f) t = -t;
+					}
+
+					float c = 1.0f / sqrt(1.0f + t * t);
+					float s = t * c;
+					float tau = s / (1.0f + c);
+					h = t * a_pq;
+
+					a_pq = 0.0f;
+
+					z[ip] -= h;
+					z[iq] += h;
+
+					eigval_p -= h;
+					eigval_q += h;
+
+					#define JPH_EVS_ROTATE(a, i, j, k, l)		\
+						g = a(i, j),							\
+						h = a(k, l),							\
+						a(i, j) = g - s * (h + g * tau),		\
+						a(k, l) = h + s * (g - h * tau)
+
+					uint j;
+					for (j = 0; j < ip; ++j)		JPH_EVS_ROTATE(a, j, ip, j, iq);
+					for (j = ip + 1; j < iq; ++j)	JPH_EVS_ROTATE(a, ip, j, j, iq);
+					for (j = iq + 1; j < n; ++j)	JPH_EVS_ROTATE(a, ip, j, iq, j);
+					for (j = 0; j < n; ++j)			JPH_EVS_ROTATE(outEigVec, j, ip, j, iq);
+
+					#undef JPH_EVS_ROTATE
+				}
+			}
+
+		// Update eigenvalues with the sum of ta_pq and reinitialize z
+		for (uint ip = 0; ip < n; ++ip)
+		{
+			b[ip] += z[ip];
+			outEigVal[ip] = b[ip];
+			z[ip] = 0.0f;
+		}
+	}
+
+	// Failure
+	JPH_ASSERT(false, "Too many iterations");
+	return false;
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,42 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Find the roots of \f$inA \: x^2 + inB \: x + inC = 0\f$.
+/// @return The number of roots, actual roots in outX1 and outX2.
+/// If number of roots returned is 1 then outX1 == outX2.
+template <typename T>
+inline int FindRoot(const T inA, const T inB, const T inC, T &outX1, T &outX2)
+{
+	// Check if this is a linear equation
+	if (inA == T(0))
+	{
+		// Check if this is a constant equation
+		if (inB == T(0))
+			return 0;
+
+		// Linear equation with 1 solution
+		outX1 = outX2 = -inC / inB;
+		return 1;
+	}
+
+	// See Numerical Recipes in C, Chapter 5.6 Quadratic and Cubic Equations
+	T det = Square(inB) - T(4) * inA * inC;
+	if (det < T(0))
+		return 0;
+	T q = (inB + Sign(inB) * sqrt(det)) / T(-2);
+	outX1 = q / inA;
+	if (q == T(0))
+	{
+		outX2 = outX1;
+		return 1;
+	}
+	outX2 = inC / q;
+	return 2;
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,36 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Class that holds 2 floats, used as a storage class mainly.
+class [[nodiscard]] Float2
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+						Float2() = default; ///< Intentionally not initialized for performance reasons
+						Float2(const Float2 &inRHS) = default;
+	Float2 &			operator = (const Float2 &inRHS) = default;
+						Float2(float inX, float inY)					: x(inX), y(inY) { }
+
+	bool				operator == (const Float2 &inRHS) const			{ return x == inRHS.x && y == inRHS.y; }
+	bool				operator != (const Float2 &inRHS) const			{ return x != inRHS.x || y != inRHS.y; }
+
+	/// To String
+	friend ostream &	operator << (ostream &inStream, const Float2 &inV)
+	{
+		inStream << inV.x << ", " << inV.y;
+		return inStream;
+	}
+
+	float				x;
+	float				y;
+};
+
+static_assert(std::is_trivial<Float2>(), "Is supposed to be a trivial type!");
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,50 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/HashCombine.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Class that holds 3 floats. Used as a storage class. Convert to Vec3 for calculations.
+class [[nodiscard]] Float3
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+				Float3() = default; ///< Intentionally not initialized for performance reasons
+				Float3(const Float3 &inRHS) = default;
+	Float3 &	operator = (const Float3 &inRHS) = default;
+	constexpr	Float3(float inX, float inY, float inZ) : x(inX), y(inY), z(inZ) { }
+
+	float		operator [] (int inCoordinate) const
+	{
+		JPH_ASSERT(inCoordinate < 3);
+		return *(&x + inCoordinate);
+	}
+
+	bool		operator == (const Float3 &inRHS) const
+	{
+		return x == inRHS.x && y == inRHS.y && z == inRHS.z;
+	}
+
+	bool		operator != (const Float3 &inRHS) const
+	{
+		return x != inRHS.x || y != inRHS.y || z != inRHS.z;
+	}
+
+	float		x;
+	float		y;
+	float		z;
+};
+
+using VertexList = Array<Float3>;
+
+static_assert(std::is_trivial<Float3>(), "Is supposed to be a trivial type!");
+
+JPH_NAMESPACE_END
+
+// Create a std::hash/JPH::Hash for Float3
+JPH_MAKE_HASHABLE(JPH::Float3, t.x, t.y, t.z)

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

@@ -0,0 +1,44 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Class that holds 4 float values. Convert to Vec4 to perform calculations.
+class [[nodiscard]] Float4
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+				Float4() = default; ///< Intentionally not initialized for performance reasons
+				Float4(const Float4 &inRHS) = default;
+				Float4(float inX, float inY, float inZ, float inW) : x(inX), y(inY), z(inZ), w(inW) { }
+	Float4 &	operator = (const Float4 &inRHS) = default;
+
+	float		operator [] (int inCoordinate) const
+	{
+		JPH_ASSERT(inCoordinate < 4);
+		return *(&x + inCoordinate);
+	}
+
+	bool		operator == (const Float4 &inRHS) const
+	{
+		return x == inRHS.x && y == inRHS.y && z == inRHS.z && w == inRHS.w;
+	}
+
+	bool		operator != (const Float4 &inRHS) const
+	{
+		return x != inRHS.x || y != inRHS.y || z != inRHS.z || w != inRHS.w;
+	}
+
+	float		x;
+	float		y;
+	float		z;
+	float		w;
+};
+
+static_assert(std::is_trivial<Float4>(), "Is supposed to be a trivial type!");
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,102 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// This function performs Gauss-Jordan elimination to solve a matrix equation.
+/// A must be an NxN matrix and B must be an NxM matrix forming the equation A * x = B
+/// on output B will contain x and A will be destroyed.
+///
+/// This code can be used for example to compute the inverse of a matrix.
+/// Set A to the matrix to invert, set B to identity and let GaussianElimination solve
+/// the equation, on return B will be the inverse of A. And A is destroyed.
+///
+/// Taken and adapted from Numerical Recipes in C paragraph 2.1
+template <class MatrixA, class MatrixB>
+bool GaussianElimination(MatrixA &ioA, MatrixB &ioB, float inTolerance = 1.0e-16f)
+{
+	// Get problem dimensions
+	const uint n = ioA.GetCols();
+	const uint m = ioB.GetCols();
+
+	// Check matrix requirement
+	JPH_ASSERT(ioA.GetRows() == n);
+	JPH_ASSERT(ioB.GetRows() == n);
+
+	// Create array for bookkeeping on pivoting
+	int *ipiv = (int *)JPH_STACK_ALLOC(n * sizeof(int));
+	memset(ipiv, 0, n * sizeof(int));
+
+	for (uint i = 0; i < n; ++i)
+	{
+		// Initialize pivot element as the diagonal
+		uint pivot_row = i, pivot_col = i;
+
+		// Determine pivot element
+		float largest_element = 0.0f;
+		for (uint j = 0; j < n; ++j)
+			if (ipiv[j] != 1)
+				for (uint k = 0; k < n; ++k)
+				{
+					if (ipiv[k] == 0)
+					{
+						float element = abs(ioA(j, k));
+						if (element >= largest_element)
+						{
+							largest_element = element;
+							pivot_row = j;
+							pivot_col = k;
+						}
+					}
+					else if (ipiv[k] > 1)
+					{
+						return false;
+					}
+				}
+
+		// Mark this column as used
+		++ipiv[pivot_col];
+
+		// Exchange rows when needed so that the pivot element is at ioA(pivot_col, pivot_col) instead of at ioA(pivot_row, pivot_col)
+		if (pivot_row != pivot_col)
+		{
+			for (uint j = 0; j < n; ++j)
+				std::swap(ioA(pivot_row, j), ioA(pivot_col, j));
+			for (uint j = 0; j < m; ++j)
+				std::swap(ioB(pivot_row, j), ioB(pivot_col, j));
+		}
+
+		// Get diagonal element that we are about to set to 1
+		float diagonal_element = ioA(pivot_col, pivot_col);
+		if (abs(diagonal_element) < inTolerance)
+			return false;
+
+		// Divide the whole row by the pivot element, making ioA(pivot_col, pivot_col) = 1
+		for (uint j = 0; j < n; ++j)
+			ioA(pivot_col, j) /= diagonal_element;
+		for (uint j = 0; j < m; ++j)
+			ioB(pivot_col, j) /= diagonal_element;
+		ioA(pivot_col, pivot_col) = 1.0f;
+
+		// Next reduce the rows, except for the pivot one,
+		// after this step the pivot_col column is zero except for the pivot element which is 1
+		for (uint j = 0; j < n; ++j)
+			if (j != pivot_col)
+			{
+				float element = ioA(j, pivot_col);
+				for (uint k = 0; k < n; ++k)
+					ioA(j, k) -= ioA(pivot_col, k) * element;
+				for (uint k = 0; k < m; ++k)
+					ioB(j, k) -= ioB(pivot_col, k) * element;
+				ioA(j, pivot_col) = 0.0f;
+			}
+	}
+
+	// Success
+	return true;
+}
+
+JPH_NAMESPACE_END