@bloomengine/engine 0.4.0 → 0.4.1

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

@@ -1,44 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/DVec3.h>
-#include <Jolt/Math/DMat44.h>
-
-JPH_NAMESPACE_BEGIN
-
-#ifdef JPH_DOUBLE_PRECISION
-
-// Define real to double
-using Real = double;
-using Real3 = Double3;
-using RVec3 = DVec3;
-using RVec3Arg = DVec3Arg;
-using RMat44 = DMat44;
-using RMat44Arg = DMat44Arg;
-
-#define JPH_RVECTOR_ALIGNMENT JPH_DVECTOR_ALIGNMENT
-
-#else
-
-// Define real to float
-using Real = float;
-using Real3 = Float3;
-using RVec3 = Vec3;
-using RVec3Arg = Vec3Arg;
-using RMat44 = Mat44;
-using RMat44Arg = Mat44Arg;
-
-#define JPH_RVECTOR_ALIGNMENT JPH_VECTOR_ALIGNMENT
-
-#endif // JPH_DOUBLE_PRECISION
-
-// Put the 'real' operator in a namespace so that users can opt in to use it:
-// using namespace JPH::literals;
-namespace literals {
-	constexpr Real operator ""_r (long double inValue) { return Real(inValue); }
-};
-
-JPH_NAMESPACE_END

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

@@ -1,19 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// Enum indicating which component to use when swizzling
-enum
-{
-	SWIZZLE_X = 0,			///< Use the X component
-	SWIZZLE_Y = 1,			///< Use the Y component
-	SWIZZLE_Z = 2,			///< Use the Z component
-	SWIZZLE_W = 3,			///< Use the W component
-	SWIZZLE_UNUSED = 2,		///< We always use the Z component when we don't specifically want to initialize a value, this is consistent with what is done in Vec3(x, y, z), Vec3(Float3 &) and Vec3::sLoadFloat3Unsafe
-};
-
-JPH_NAMESPACE_END

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

@@ -1,79 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-// Note that this file exists because std::sin etc. are not platform independent and will lead to non-deterministic simulation
-
-/// Sine of x (input in radians)
-JPH_INLINE float Sin(float inX)
-{
-	Vec4 s, c;
-	Vec4::sReplicate(inX).SinCos(s, c);
-	return s.GetX();
-}
-
-/// Cosine of x (input in radians)
-JPH_INLINE float Cos(float inX)
-{
-	Vec4 s, c;
-	Vec4::sReplicate(inX).SinCos(s, c);
-	return c.GetX();
-}
-
-/// Tangent of x (input in radians)
-JPH_INLINE float Tan(float inX)
-{
-	return Vec4::sReplicate(inX).Tan().GetX();
-}
-
-/// Arc sine of x (returns value in the range [-PI / 2, PI / 2])
-/// Note that all input values will be clamped to the range [-1, 1] and this function will not return NaNs like std::asin
-JPH_INLINE float ASin(float inX)
-{
-	return Vec4::sReplicate(inX).ASin().GetX();
-}
-
-/// Arc cosine of x (returns value in the range [0, PI])
-/// Note that all input values will be clamped to the range [-1, 1] and this function will not return NaNs like std::acos
-JPH_INLINE float ACos(float inX)
-{
-	return Vec4::sReplicate(inX).ACos().GetX();
-}
-
-/// An approximation of ACos, max error is 4.2e-3 over the entire range [-1, 1], is approximately 2.5x faster than ACos
-JPH_INLINE float ACosApproximate(float inX)
-{
-	// See: https://www.johndcook.com/blog/2022/09/06/inverse-cosine-near-1/
-	// See also: https://seblagarde.wordpress.com/2014/12/01/inverse-trigonometric-functions-gpu-optimization-for-amd-gcn-architecture/
-	// Taylor of cos(x) = 1 - x^2 / 2 + ...
-	// Substitute x = sqrt(2 y) we get: cos(sqrt(2 y)) = 1 - y
-	// Substitute z = 1 - y we get: cos(sqrt(2 (1 - z))) = z <=> acos(z) = sqrt(2 (1 - z))
-	// To avoid the discontinuity at 1, instead of using the Taylor expansion of acos(x) we use acos(x) / sqrt(2 (1 - x)) = 1 + (1 - x) / 12 + ...
-	// Since the approximation was made at 1, it has quite a large error at 0 meaning that if we want to extend to the
-	// range [-1, 1] by mirroring the range [0, 1], the value at 0+ is not the same as 0-.
-	// So we observe that the form of the Taylor expansion is f(x) = sqrt(1 - x) * (a + b x) and we fit the function so that f(0) = pi / 2
-	// this gives us a = pi / 2. f(1) = 0 regardless of b. We search for a constant b that minimizes the error in the range [0, 1].
-	float abs_x = min(abs(inX), 1.0f); // Ensure that we don't get a value larger than 1
-	float val = sqrt(1.0f - abs_x) * (JPH_PI / 2 - 0.175394f * abs_x);
-
-	// Our approximation is valid in the range [0, 1], extend it to the range [-1, 1]
-	return inX < 0? JPH_PI - val : val;
-}
-
-/// Arc tangent of x (returns value in the range [-PI / 2, PI / 2])
-JPH_INLINE float ATan(float inX)
-{
-	return Vec4::sReplicate(inX).ATan().GetX();
-}
-
-/// Arc tangent of y / x using the signs of the arguments to determine the correct quadrant (returns value in the range [-PI, PI])
-JPH_INLINE float ATan2(float inY, float inX)
-{
-	return Vec4::sATan2(Vec4::sReplicate(inY), Vec4::sReplicate(inX)).GetX();
-}
-
-JPH_NAMESPACE_END

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

@@ -1,232 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/Vec4.h>
-
-JPH_NAMESPACE_BEGIN
-
-class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) UVec4
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	// Underlying vector type
-#if defined(JPH_USE_SSE)
-	using Type = __m128i;
-#elif defined(JPH_USE_NEON)
-	using Type = uint32x4_t;
-#else
-	using Type = struct { uint32 mData[4]; };
-#endif
-
-	/// Constructor
-								UVec4() = default; ///< Intentionally not initialized for performance reasons
-								UVec4(const UVec4 &inRHS) = default;
-	UVec4 &						operator = (const UVec4 &inRHS) = default;
-	JPH_INLINE					UVec4(Type inRHS) : mValue(inRHS)					{ }
-
-	/// Create a vector from 4 integer components
-	JPH_INLINE					UVec4(uint32 inX, uint32 inY, uint32 inZ, uint32 inW);
-
-	/// Comparison
-	JPH_INLINE bool				operator == (UVec4Arg inV2) const;
-	JPH_INLINE bool				operator != (UVec4Arg inV2) const					{ return !(*this == inV2); }
-
-	/// Swizzle the elements in inV
-	template<uint32 SwizzleX, uint32 SwizzleY, uint32 SwizzleZ, uint32 SwizzleW>
-	JPH_INLINE UVec4			Swizzle() const;
-
-	/// Vector with all zeros
-	static JPH_INLINE UVec4		sZero();
-
-	/// Replicate int inV across all components
-	static JPH_INLINE UVec4		sReplicate(uint32 inV);
-
-	/// Load 1 int from memory and place it in the X component, zeros Y, Z and W
-	static JPH_INLINE UVec4		sLoadInt(const uint32 *inV);
-
-	/// Load 4 ints from memory
-	static JPH_INLINE UVec4		sLoadInt4(const uint32 *inV);
-
-	/// Load 4 ints from memory, aligned to 16 bytes
-	static JPH_INLINE UVec4		sLoadInt4Aligned(const uint32 *inV);
-
-	/// Gather 4 ints from memory at inBase + inOffsets[i] * Scale
-	template <const int Scale>
-	static JPH_INLINE UVec4		sGatherInt4(const uint32 *inBase, UVec4Arg inOffsets);
-
-	/// Return the minimum value of each of the components
-	static JPH_INLINE UVec4		sMin(UVec4Arg inV1, UVec4Arg inV2);
-
-	/// Return the maximum of each of the components
-	static JPH_INLINE UVec4		sMax(UVec4Arg inV1, UVec4Arg inV2);
-
-	/// Equals (component wise)
-	static JPH_INLINE UVec4		sEquals(UVec4Arg inV1, UVec4Arg inV2);
-
-	/// Component wise select, returns inNotSet when highest bit of inControl = 0 and inSet when highest bit of inControl = 1
-	static JPH_INLINE UVec4		sSelect(UVec4Arg inNotSet, UVec4Arg inSet, UVec4Arg inControl);
-
-	/// Logical or (component wise)
-	static JPH_INLINE UVec4		sOr(UVec4Arg inV1, UVec4Arg inV2);
-
-	/// Logical xor (component wise)
-	static JPH_INLINE UVec4		sXor(UVec4Arg inV1, UVec4Arg inV2);
-
-	/// Logical and (component wise)
-	static JPH_INLINE UVec4		sAnd(UVec4Arg inV1, UVec4Arg inV2);
-
-	/// Logical not (component wise)
-	static JPH_INLINE UVec4		sNot(UVec4Arg inV1);
-
-	/// Sorts the elements in inIndex so that the values that correspond to trues in inValue are the first elements.
-	/// The remaining elements will be set to inValue.w.
-	/// I.e. if inValue = (true, false, true, false) and inIndex = (1, 2, 3, 4) the function returns (1, 3, 4, 4).
-	static JPH_INLINE UVec4		sSort4True(UVec4Arg inValue, UVec4Arg inIndex);
-
-	/// Get individual components
-#if defined(JPH_USE_SSE)
-	JPH_INLINE uint32			GetX() const										{ return uint32(_mm_cvtsi128_si32(mValue)); }
-	JPH_INLINE uint32			GetY() const										{ return mU32[1]; }
-	JPH_INLINE uint32			GetZ() const										{ return mU32[2]; }
-	JPH_INLINE uint32			GetW() const										{ return mU32[3]; }
-#elif defined(JPH_USE_NEON)
-	JPH_INLINE uint32			GetX() const										{ return vgetq_lane_u32(mValue, 0); }
-	JPH_INLINE uint32			GetY() const										{ return vgetq_lane_u32(mValue, 1); }
-	JPH_INLINE uint32			GetZ() const										{ return vgetq_lane_u32(mValue, 2); }
-	JPH_INLINE uint32			GetW() const										{ return vgetq_lane_u32(mValue, 3); }
-#else
-	JPH_INLINE uint32			GetX() const										{ return mU32[0]; }
-	JPH_INLINE uint32			GetY() const										{ return mU32[1]; }
-	JPH_INLINE uint32			GetZ() const										{ return mU32[2]; }
-	JPH_INLINE uint32			GetW() const										{ return mU32[3]; }
-#endif
-
-	/// Set individual components
-	JPH_INLINE void				SetX(uint32 inX)									{ mU32[0] = inX; }
-	JPH_INLINE void				SetY(uint32 inY)									{ mU32[1] = inY; }
-	JPH_INLINE void				SetZ(uint32 inZ)									{ mU32[2] = inZ; }
-	JPH_INLINE void				SetW(uint32 inW)									{ mU32[3] = inW; }
-
-	/// Get component by index
-	JPH_INLINE uint32			operator [] (uint inCoordinate) const				{ JPH_ASSERT(inCoordinate < 4); return mU32[inCoordinate]; }
-	JPH_INLINE uint32 &			operator [] (uint inCoordinate)						{ JPH_ASSERT(inCoordinate < 4); return mU32[inCoordinate]; }
-
-	/// Component wise multiplication of two integer vectors (stores low 32 bits of result only)
-	JPH_INLINE UVec4			operator * (UVec4Arg inV2) const;
-
-	/// Add two integer vectors (component wise)
-	JPH_INLINE UVec4			operator + (UVec4Arg inV2) const;
-
-	/// Add two integer vectors (component wise)
-	JPH_INLINE UVec4 &			operator += (UVec4Arg inV2);
-
-	/// Subtract two integer vectors (component wise)
-	JPH_INLINE UVec4			operator - (UVec4Arg inV2) const;
-
-	/// Subtract two integer vectors (component wise)
-	JPH_INLINE UVec4 &			operator -= (UVec4Arg inV2);
-
-	/// Replicate the X component to all components
-	JPH_INLINE UVec4			SplatX() const;
-
-	/// Replicate the Y component to all components
-	JPH_INLINE UVec4			SplatY() const;
-
-	/// Replicate the Z component to all components
-	JPH_INLINE UVec4			SplatZ() const;
-
-	/// Replicate the W component to all components
-	JPH_INLINE UVec4			SplatW() const;
-
-	/// Convert each component from an int to a float
-	JPH_INLINE Vec4				ToFloat() const;
-
-	/// Reinterpret UVec4 as a Vec4 (doesn't change the bits)
-	JPH_INLINE Vec4				ReinterpretAsFloat() const;
-
-	/// Dot product, returns the dot product in X, Y, Z and W components
-	JPH_INLINE UVec4			DotV(UVec4Arg inV2) const;
-
-	/// Dot product
-	JPH_INLINE uint32			Dot(UVec4Arg inV2) const;
-
-	/// Store 4 ints to memory
-	JPH_INLINE void				StoreInt4(uint32 *outV) const;
-
-	/// Store 4 ints to memory, aligned to 16 bytes
-	JPH_INLINE void				StoreInt4Aligned(uint32 *outV) const;
-
-	/// Test if any of the components are true (true is when highest bit of component is set)
-	JPH_INLINE bool				TestAnyTrue() const;
-
-	/// Test if any of X, Y or Z components are true (true is when highest bit of component is set)
-	JPH_INLINE bool				TestAnyXYZTrue() const;
-
-	/// Test if all components are true (true is when highest bit of component is set)
-	JPH_INLINE bool				TestAllTrue() const;
-
-	/// Test if X, Y and Z components are true (true is when highest bit of component is set)
-	JPH_INLINE bool				TestAllXYZTrue() const;
-
-	/// Count the number of components that are true (true is when highest bit of component is set)
-	JPH_INLINE int				CountTrues() const;
-
-	/// Store if X is true in bit 0, Y in bit 1, Z in bit 2 and W in bit 3 (true is when highest bit of component is set)
-	JPH_INLINE int				GetTrues() const;
-
-	/// Shift all components by Count bits to the left (filling with zeros from the left)
-	template <const uint Count>
-	JPH_INLINE UVec4			LogicalShiftLeft() const;
-
-	/// Shift all components by Count bits to the right (filling with zeros from the right)
-	template <const uint Count>
-	JPH_INLINE UVec4			LogicalShiftRight() const;
-
-	/// Shift all components by Count bits to the right (shifting in the value of the highest bit)
-	template <const uint Count>
-	JPH_INLINE UVec4			ArithmeticShiftRight() const;
-
-	/// Takes the lower 4 16 bits and expands them to X, Y, Z and W
-	JPH_INLINE UVec4			Expand4Uint16Lo() const;
-
-	/// Takes the upper 4 16 bits and expands them to X, Y, Z and W
-	JPH_INLINE UVec4			Expand4Uint16Hi() const;
-
-	/// Takes byte 0 .. 3 and expands them to X, Y, Z and W
-	JPH_INLINE UVec4			Expand4Byte0() const;
-
-	/// Takes byte 4 .. 7 and expands them to X, Y, Z and W
-	JPH_INLINE UVec4			Expand4Byte4() const;
-
-	/// Takes byte 8 .. 11 and expands them to X, Y, Z and W
-	JPH_INLINE UVec4			Expand4Byte8() const;
-
-	/// Takes byte 12 .. 15 and expands them to X, Y, Z and W
-	JPH_INLINE UVec4			Expand4Byte12() const;
-
-	/// Shift vector components by 4 - Count floats to the left, so if Count = 1 the resulting vector is (W, 0, 0, 0), when Count = 3 the resulting vector is (Y, Z, W, 0)
-	JPH_INLINE UVec4			ShiftComponents4Minus(int inCount) const;
-
-	/// To String
-	friend ostream &			operator << (ostream &inStream, UVec4Arg inV)
-	{
-		inStream << inV.mU32[0] << ", " << inV.mU32[1] << ", " << inV.mU32[2] << ", " << inV.mU32[3];
-		return inStream;
-	}
-
-	union
-	{
-		Type					mValue;
-		uint32					mU32[4];
-	};
-};
-
-static_assert(std::is_trivial<UVec4>(), "Is supposed to be a trivial type!");
-
-JPH_NAMESPACE_END
-
-#include "UVec4.inl"