@bloomengine/engine 0.4.0 → 0.4.2

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

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

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

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

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

@@ -1,36 +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 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

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

@@ -1,44 +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 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

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