@bloomengine/engine 0.4.0 → 0.4.2

package/native/third_party/JoltPhysics/Jolt/Geometry/Plane.h

@@ -1,104 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// An infinite plane described by the formula X . Normal + Constant = 0.
-class [[nodiscard]] Plane
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Constructor
-					Plane() = default;
-	explicit		Plane(Vec4Arg inNormalAndConstant)										: mNormalAndConstant(inNormalAndConstant) { }
-					Plane(Vec3Arg inNormal, float inConstant)								: mNormalAndConstant(inNormal, inConstant) { }
-
-	/// Create from point and normal
-	static Plane	sFromPointAndNormal(Vec3Arg inPoint, Vec3Arg inNormal)					{ return Plane(Vec4(inNormal, -inNormal.Dot(inPoint))); }
-
-	/// Create from point and normal, double precision version that more accurately calculates the plane constant
-	static Plane	sFromPointAndNormal(DVec3Arg inPoint, Vec3Arg inNormal)					{ return Plane(Vec4(inNormal, -float(DVec3(inNormal).Dot(inPoint)))); }
-
-	/// Create from 3 counter clockwise points
-	static Plane	sFromPointsCCW(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3)				{ return sFromPointAndNormal(inV1, (inV2 - inV1).Cross(inV3 - inV1).Normalized()); }
-
-	// Properties
-	Vec3			GetNormal() const														{ return Vec3(mNormalAndConstant); }
-	void			SetNormal(Vec3Arg inNormal)												{ mNormalAndConstant = Vec4(inNormal, mNormalAndConstant.GetW()); }
-	float			GetConstant() const														{ return mNormalAndConstant.GetW(); }
-	void			SetConstant(float inConstant)											{ mNormalAndConstant.SetW(inConstant); }
-
-	/// Store as 4 floats
-	void			StoreFloat4(Float4 *outV) const											{ mNormalAndConstant.StoreFloat4(outV); }
-
-	/// Offset the plane (positive value means move it in the direction of the plane normal)
-	Plane			Offset(float inDistance) const											{ return Plane(mNormalAndConstant - Vec4(Vec3::sZero(), inDistance)); }
-
-	/// Transform the plane by a matrix
-	inline Plane	GetTransformed(Mat44Arg inTransform) const
-	{
-		Vec3 transformed_normal = inTransform.Multiply3x3(GetNormal());
-		return Plane(transformed_normal, GetConstant() - inTransform.GetTranslation().Dot(transformed_normal));
-	}
-
-	/// Scale the plane, can handle non-uniform and negative scaling
-	inline Plane	Scaled(Vec3Arg inScale) const
-	{
-		Vec3 scaled_normal = GetNormal() / inScale;
-		float scaled_normal_length = scaled_normal.Length();
-		return Plane(scaled_normal / scaled_normal_length, GetConstant() / scaled_normal_length);
-	}
-
-	/// Distance point to plane
-	float			SignedDistance(Vec3Arg inPoint) const									{ return inPoint.Dot(GetNormal()) + GetConstant(); }
-
-	/// Project inPoint onto the plane
-	Vec3			ProjectPointOnPlane(Vec3Arg inPoint) const								{ return inPoint - GetNormal() * SignedDistance(inPoint); }
-
-	/// Returns intersection point between 3 planes
-	static bool		sIntersectPlanes(const Plane &inP1, const Plane &inP2, const Plane &inP3, Vec3 &outPoint)
-	{
-		// We solve the equation:
-		// |ax, ay, az, aw|   | x |   | 0 |
-		// |bx, by, bz, bw| * | y | = | 0 |
-		// |cx, cy, cz, cw|   | z |   | 0 |
-		// | 0,	 0,	 0,	 1|   | 1 |   | 1 |
-		// Where normal of plane 1 = (ax, ay, az), plane constant of 1 = aw, normal of plane 2 = (bx, by, bz) etc.
-		// This involves inverting the matrix and multiplying it with [0, 0, 0, 1]
-
-		// Fetch the normals and plane constants for the three planes
-		Vec4 a = inP1.mNormalAndConstant;
-		Vec4 b = inP2.mNormalAndConstant;
-		Vec4 c = inP3.mNormalAndConstant;
-
-		// Result is a vector that we have to divide by:
-		float denominator = Vec3(a).Dot(Vec3(b).Cross(Vec3(c)));
-		if (denominator == 0.0f)
-			return false;
-
-		// The numerator is:
-		// [aw*(bz*cy-by*cz)+ay*(bw*cz-bz*cw)+az*(by*cw-bw*cy)]
-		// [aw*(bx*cz-bz*cx)+ax*(bz*cw-bw*cz)+az*(bw*cx-bx*cw)]
-		// [aw*(by*cx-bx*cy)+ax*(bw*cy-by*cw)+ay*(bx*cw-bw*cx)]
-		Vec4 numerator =
-			a.SplatW() * (b.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_UNUSED>() * c.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_UNUSED>() - b.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_UNUSED>() * c.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_UNUSED>())
-			+ a.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_UNUSED>() * (b.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_UNUSED>() * c.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_UNUSED>() - b.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_UNUSED>() * c.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_UNUSED>())
-			+ a.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_UNUSED>() * (b.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_UNUSED>() * c.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_UNUSED>() - b.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_UNUSED>() * c.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_UNUSED>());
-
-		outPoint = Vec3(numerator) / denominator;
-		return true;
-	}
-
-private:
-#ifdef JPH_OBJECT_STREAM
-	friend void		CreateRTTIPlane(class RTTI &);										// For JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS
-#endif
-
-	Vec4			mNormalAndConstant;													///< XYZ = normal, W = constant, plane: x . normal + constant = 0
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Geometry/RayAABox.h

@@ -1,241 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// Helper structure holding the reciprocal of a ray for Ray vs AABox testing
-class RayInvDirection
-{
-public:
-	/// Constructors
-	inline			RayInvDirection() = default;
-	inline explicit	RayInvDirection(Vec3Arg inDirection) { Set(inDirection); }
-
-	/// Set reciprocal from ray direction
-	inline void		Set(Vec3Arg inDirection)
-	{
-		// if (abs(inDirection) <= Epsilon) the ray is nearly parallel to the slab.
-		mIsParallel = Vec3::sLessOrEqual(inDirection.Abs(), Vec3::sReplicate(1.0e-20f));
-
-		// Calculate 1 / direction while avoiding division by zero
-		mInvDirection = Vec3::sSelect(inDirection, Vec3::sOne(), mIsParallel).Reciprocal();
-	}
-
-	Vec3			mInvDirection;					///< 1 / ray direction
-	UVec4			mIsParallel;					///< for each component if it is parallel to the coordinate axis
-};
-
-/// Intersect AABB with ray, returns minimal distance along ray or FLT_MAX if no hit
-/// Note: Can return negative value if ray starts in box
-JPH_INLINE float RayAABox(Vec3Arg inOrigin, const RayInvDirection &inInvDirection, Vec3Arg inBoundsMin, Vec3Arg inBoundsMax)
-{
-	// Constants
-	Vec3 flt_min = Vec3::sReplicate(-FLT_MAX);
-	Vec3 flt_max = Vec3::sReplicate(FLT_MAX);
-
-	// Test against all three axes simultaneously.
-	Vec3 t1 = (inBoundsMin - inOrigin) * inInvDirection.mInvDirection;
-	Vec3 t2 = (inBoundsMax - inOrigin) * inInvDirection.mInvDirection;
-
-	// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
-	// use the results from any directions parallel to the slab.
-	Vec3 t_min = Vec3::sSelect(Vec3::sMin(t1, t2), flt_min, inInvDirection.mIsParallel);
-	Vec3 t_max = Vec3::sSelect(Vec3::sMax(t1, t2), flt_max, inInvDirection.mIsParallel);
-
-	// t_min.xyz = maximum(t_min.x, t_min.y, t_min.z);
-	t_min = Vec3::sMax(t_min, t_min.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>());
-	t_min = Vec3::sMax(t_min, t_min.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>());
-
-	// t_max.xyz = minimum(t_max.x, t_max.y, t_max.z);
-	t_max = Vec3::sMin(t_max, t_max.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>());
-	t_max = Vec3::sMin(t_max, t_max.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>());
-
-	// if (t_min > t_max) return FLT_MAX;
-	UVec4 no_intersection = Vec3::sGreater(t_min, t_max);
-
-	// if (t_max < 0.0f) return FLT_MAX;
-	no_intersection = UVec4::sOr(no_intersection, Vec3::sLess(t_max, Vec3::sZero()));
-
-	// if (inInvDirection.mIsParallel && !(Min <= inOrigin && inOrigin <= Max)) return FLT_MAX; else return t_min;
-	UVec4 no_parallel_overlap = UVec4::sOr(Vec3::sLess(inOrigin, inBoundsMin), Vec3::sGreater(inOrigin, inBoundsMax));
-	no_intersection = UVec4::sOr(no_intersection, UVec4::sAnd(inInvDirection.mIsParallel, no_parallel_overlap));
-	no_intersection = UVec4::sOr(no_intersection, no_intersection.SplatY());
-	no_intersection = UVec4::sOr(no_intersection, no_intersection.SplatZ());
-	return Vec3::sSelect(t_min, flt_max, no_intersection).GetX();
-}
-
-/// Intersect 4 AABBs with ray, returns minimal distance along ray or FLT_MAX if no hit
-/// Note: Can return negative value if ray starts in box
-JPH_INLINE Vec4 RayAABox4(Vec3Arg inOrigin, const RayInvDirection &inInvDirection, Vec4Arg inBoundsMinX, Vec4Arg inBoundsMinY, Vec4Arg inBoundsMinZ, Vec4Arg inBoundsMaxX, Vec4Arg inBoundsMaxY, Vec4Arg inBoundsMaxZ)
-{
-	// Constants
-	Vec4 flt_min = Vec4::sReplicate(-FLT_MAX);
-	Vec4 flt_max = Vec4::sReplicate(FLT_MAX);
-
-	// Origin
-	Vec4 originx = inOrigin.SplatX();
-	Vec4 originy = inOrigin.SplatY();
-	Vec4 originz = inOrigin.SplatZ();
-
-	// Parallel
-	UVec4 parallelx = inInvDirection.mIsParallel.SplatX();
-	UVec4 parallely = inInvDirection.mIsParallel.SplatY();
-	UVec4 parallelz = inInvDirection.mIsParallel.SplatZ();
-
-	// Inverse direction
-	Vec4 invdirx = inInvDirection.mInvDirection.SplatX();
-	Vec4 invdiry = inInvDirection.mInvDirection.SplatY();
-	Vec4 invdirz = inInvDirection.mInvDirection.SplatZ();
-
-	// Test against all three axes simultaneously.
-	Vec4 t1x = (inBoundsMinX - originx) * invdirx;
-	Vec4 t1y = (inBoundsMinY - originy) * invdiry;
-	Vec4 t1z = (inBoundsMinZ - originz) * invdirz;
-	Vec4 t2x = (inBoundsMaxX - originx) * invdirx;
-	Vec4 t2y = (inBoundsMaxY - originy) * invdiry;
-	Vec4 t2z = (inBoundsMaxZ - originz) * invdirz;
-
-	// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
-	// use the results from any directions parallel to the slab.
-	Vec4 t_minx = Vec4::sSelect(Vec4::sMin(t1x, t2x), flt_min, parallelx);
-	Vec4 t_miny = Vec4::sSelect(Vec4::sMin(t1y, t2y), flt_min, parallely);
-	Vec4 t_minz = Vec4::sSelect(Vec4::sMin(t1z, t2z), flt_min, parallelz);
-	Vec4 t_maxx = Vec4::sSelect(Vec4::sMax(t1x, t2x), flt_max, parallelx);
-	Vec4 t_maxy = Vec4::sSelect(Vec4::sMax(t1y, t2y), flt_max, parallely);
-	Vec4 t_maxz = Vec4::sSelect(Vec4::sMax(t1z, t2z), flt_max, parallelz);
-
-	// t_min.xyz = maximum(t_min.x, t_min.y, t_min.z);
-	Vec4 t_min = Vec4::sMax(Vec4::sMax(t_minx, t_miny), t_minz);
-
-	// t_max.xyz = minimum(t_max.x, t_max.y, t_max.z);
-	Vec4 t_max = Vec4::sMin(Vec4::sMin(t_maxx, t_maxy), t_maxz);
-
-	// if (t_min > t_max) return FLT_MAX;
-	UVec4 no_intersection = Vec4::sGreater(t_min, t_max);
-
-	// if (t_max < 0.0f) return FLT_MAX;
-	no_intersection = UVec4::sOr(no_intersection, Vec4::sLess(t_max, Vec4::sZero()));
-
-	// if bounds are invalid return FLOAT_MAX;
-	UVec4 bounds_invalid = UVec4::sOr(UVec4::sOr(Vec4::sGreater(inBoundsMinX, inBoundsMaxX), Vec4::sGreater(inBoundsMinY, inBoundsMaxY)), Vec4::sGreater(inBoundsMinZ, inBoundsMaxZ));
-	no_intersection = UVec4::sOr(no_intersection, bounds_invalid);
-
-	// if (inInvDirection.mIsParallel && !(Min <= inOrigin && inOrigin <= Max)) return FLT_MAX; else return t_min;
-	UVec4 no_parallel_overlapx = UVec4::sAnd(parallelx, UVec4::sOr(Vec4::sLess(originx, inBoundsMinX), Vec4::sGreater(originx, inBoundsMaxX)));
-	UVec4 no_parallel_overlapy = UVec4::sAnd(parallely, UVec4::sOr(Vec4::sLess(originy, inBoundsMinY), Vec4::sGreater(originy, inBoundsMaxY)));
-	UVec4 no_parallel_overlapz = UVec4::sAnd(parallelz, UVec4::sOr(Vec4::sLess(originz, inBoundsMinZ), Vec4::sGreater(originz, inBoundsMaxZ)));
-	no_intersection = UVec4::sOr(no_intersection, UVec4::sOr(UVec4::sOr(no_parallel_overlapx, no_parallel_overlapy), no_parallel_overlapz));
-	return Vec4::sSelect(t_min, flt_max, no_intersection);
-}
-
-/// Intersect AABB with ray, returns minimal and maximal distance along ray or FLT_MAX, -FLT_MAX if no hit
-/// Note: Can return negative value for outMin if ray starts in box
-JPH_INLINE void RayAABox(Vec3Arg inOrigin, const RayInvDirection &inInvDirection, Vec3Arg inBoundsMin, Vec3Arg inBoundsMax, float &outMin, float &outMax)
-{
-	// Constants
-	Vec3 flt_min = Vec3::sReplicate(-FLT_MAX);
-	Vec3 flt_max = Vec3::sReplicate(FLT_MAX);
-
-	// Test against all three axes simultaneously.
-	Vec3 t1 = (inBoundsMin - inOrigin) * inInvDirection.mInvDirection;
-	Vec3 t2 = (inBoundsMax - inOrigin) * inInvDirection.mInvDirection;
-
-	// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
-	// use the results from any directions parallel to the slab.
-	Vec3 t_min = Vec3::sSelect(Vec3::sMin(t1, t2), flt_min, inInvDirection.mIsParallel);
-	Vec3 t_max = Vec3::sSelect(Vec3::sMax(t1, t2), flt_max, inInvDirection.mIsParallel);
-
-	// t_min.xyz = maximum(t_min.x, t_min.y, t_min.z);
-	t_min = Vec3::sMax(t_min, t_min.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>());
-	t_min = Vec3::sMax(t_min, t_min.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>());
-
-	// t_max.xyz = minimum(t_max.x, t_max.y, t_max.z);
-	t_max = Vec3::sMin(t_max, t_max.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>());
-	t_max = Vec3::sMin(t_max, t_max.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>());
-
-	// if (t_min > t_max) return FLT_MAX;
-	UVec4 no_intersection = Vec3::sGreater(t_min, t_max);
-
-	// if (t_max < 0.0f) return FLT_MAX;
-	no_intersection = UVec4::sOr(no_intersection, Vec3::sLess(t_max, Vec3::sZero()));
-
-	// if (inInvDirection.mIsParallel && !(Min <= inOrigin && inOrigin <= Max)) return FLT_MAX; else return t_min;
-	UVec4 no_parallel_overlap = UVec4::sOr(Vec3::sLess(inOrigin, inBoundsMin), Vec3::sGreater(inOrigin, inBoundsMax));
-	no_intersection = UVec4::sOr(no_intersection, UVec4::sAnd(inInvDirection.mIsParallel, no_parallel_overlap));
-	no_intersection = UVec4::sOr(no_intersection, no_intersection.SplatY());
-	no_intersection = UVec4::sOr(no_intersection, no_intersection.SplatZ());
-	outMin = Vec3::sSelect(t_min, flt_max, no_intersection).GetX();
-	outMax = Vec3::sSelect(t_max, flt_min, no_intersection).GetX();
-}
-
-/// Intersect AABB with ray, returns true if there is a hit closer than inClosest
-JPH_INLINE bool RayAABoxHits(Vec3Arg inOrigin, const RayInvDirection &inInvDirection, Vec3Arg inBoundsMin, Vec3Arg inBoundsMax, float inClosest)
-{
-	// Constants
-	Vec3 flt_min = Vec3::sReplicate(-FLT_MAX);
-	Vec3 flt_max = Vec3::sReplicate(FLT_MAX);
-
-	// Test against all three axes simultaneously.
-	Vec3 t1 = (inBoundsMin - inOrigin) * inInvDirection.mInvDirection;
-	Vec3 t2 = (inBoundsMax - inOrigin) * inInvDirection.mInvDirection;
-
-	// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
-	// use the results from any directions parallel to the slab.
-	Vec3 t_min = Vec3::sSelect(Vec3::sMin(t1, t2), flt_min, inInvDirection.mIsParallel);
-	Vec3 t_max = Vec3::sSelect(Vec3::sMax(t1, t2), flt_max, inInvDirection.mIsParallel);
-
-	// t_min.xyz = maximum(t_min.x, t_min.y, t_min.z);
-	t_min = Vec3::sMax(t_min, t_min.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>());
-	t_min = Vec3::sMax(t_min, t_min.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>());
-
-	// t_max.xyz = minimum(t_max.x, t_max.y, t_max.z);
-	t_max = Vec3::sMin(t_max, t_max.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>());
-	t_max = Vec3::sMin(t_max, t_max.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>());
-
-	// if (t_min > t_max) return false;
-	UVec4 no_intersection = Vec3::sGreater(t_min, t_max);
-
-	// if (t_max < 0.0f) return false;
-	no_intersection = UVec4::sOr(no_intersection, Vec3::sLess(t_max, Vec3::sZero()));
-
-	// if (t_min > inClosest) return false;
-	no_intersection = UVec4::sOr(no_intersection, Vec3::sGreater(t_min, Vec3::sReplicate(inClosest)));
-
-	// if (inInvDirection.mIsParallel && !(Min <= inOrigin && inOrigin <= Max)) return false; else return true;
-	UVec4 no_parallel_overlap = UVec4::sOr(Vec3::sLess(inOrigin, inBoundsMin), Vec3::sGreater(inOrigin, inBoundsMax));
-	no_intersection = UVec4::sOr(no_intersection, UVec4::sAnd(inInvDirection.mIsParallel, no_parallel_overlap));
-
-	return !no_intersection.TestAnyXYZTrue();
-}
-
-/// Intersect AABB with ray without hit fraction, based on separating axis test
-/// @see http://www.codercorner.com/RayAABB.cpp
-JPH_INLINE bool RayAABoxHits(Vec3Arg inOrigin, Vec3Arg inDirection, Vec3Arg inBoundsMin, Vec3Arg inBoundsMax)
-{
-	Vec3 extents = inBoundsMax - inBoundsMin;
-
-	Vec3 diff = 2.0f * inOrigin - inBoundsMin - inBoundsMax;
-	Vec3 abs_diff = diff.Abs();
-
-	UVec4 no_intersection = UVec4::sAnd(Vec3::sGreater(abs_diff, extents), Vec3::sGreaterOrEqual(diff * inDirection, Vec3::sZero()));
-
-	Vec3 abs_dir = inDirection.Abs();
-	Vec3 abs_dir_yzz = abs_dir.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>();
-	Vec3 abs_dir_xyx = abs_dir.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>();
-
-	Vec3 extents_yzz = extents.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>();
-	Vec3 extents_xyx = extents.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>();
-
-	Vec3 diff_yzx = diff.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-
-	Vec3 dir_yzx = inDirection.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>();
-
-	no_intersection = UVec4::sOr(no_intersection, Vec3::sGreater((inDirection * diff_yzx - dir_yzx * diff).Abs(), extents_xyx * abs_dir_yzz + extents_yzz * abs_dir_xyx));
-
-	return !no_intersection.TestAnyXYZTrue();
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Geometry/RayCapsule.h

@@ -1,37 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Geometry/RayCylinder.h>
-#include <Jolt/Geometry/RaySphere.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Tests a ray starting at inRayOrigin and extending infinitely in inRayDirection
-/// against a capsule centered around the origin with its axis along the Y axis and half height specified.
-/// @return FLT_MAX if there is no intersection, otherwise the fraction along the ray.
-/// @param inRayDirection Ray direction. Does not need to be normalized.
-/// @param inRayOrigin Origin of the ray. If the ray starts inside the capsule, the returned fraction will be 0.
-/// @param inCapsuleHalfHeight Distance from the origin to the center of the top sphere (or that of the bottom)
-/// @param inCapsuleRadius Radius of the top/bottom sphere
-JPH_INLINE float RayCapsule(Vec3Arg inRayOrigin, Vec3Arg inRayDirection, float inCapsuleHalfHeight, float inCapsuleRadius)
-{
-	// Test infinite cylinder
-	float cylinder = RayCylinder(inRayOrigin, inRayDirection, inCapsuleRadius);
-	if (cylinder == FLT_MAX)
-		return FLT_MAX;
-
-	// If this hit is in the finite cylinder we have our fraction
-	if (abs(inRayOrigin.GetY() + cylinder * inRayDirection.GetY()) <= inCapsuleHalfHeight)
-		return cylinder;
-
-	// Test upper and lower sphere
-	Vec3 sphere_center(0, inCapsuleHalfHeight, 0);
-	float upper = RaySphere(inRayOrigin, inRayDirection, sphere_center, inCapsuleRadius);
-	float lower = RaySphere(inRayOrigin, inRayDirection, -sphere_center, inCapsuleRadius);
-	return min(upper, lower);
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Geometry/RayCylinder.h

@@ -1,101 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/FindRoot.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Tests a ray starting at inRayOrigin and extending infinitely in inRayDirection
-/// against an infinite cylinder centered along the Y axis
-/// @return FLT_MAX if there is no intersection, otherwise the fraction along the ray.
-/// @param inRayDirection Direction of the ray. Does not need to be normalized.
-/// @param inRayOrigin Origin of the ray. If the ray starts inside the cylinder, the returned fraction will be 0.
-/// @param inCylinderRadius Radius of the infinite cylinder
-JPH_INLINE float RayCylinder(Vec3Arg inRayOrigin, Vec3Arg inRayDirection, float inCylinderRadius)
-{
-	// Remove Y component of ray to see of ray intersects with infinite cylinder
-	UVec4 mask_y = UVec4(0, 0xffffffff, 0, 0);
-	Vec3 origin_xz = Vec3::sSelect(inRayOrigin, Vec3::sZero(), mask_y);
-	float origin_xz_len_sq = origin_xz.LengthSq();
-	float r_sq = Square(inCylinderRadius);
-	if (origin_xz_len_sq > r_sq)
-	{
-		// Ray starts outside of the infinite cylinder
-		// Solve: |RayOrigin_xz + fraction * RayDirection_xz|^2 = r^2 to find fraction
-		Vec3 direction_xz = Vec3::sSelect(inRayDirection, Vec3::sZero(), mask_y);
-		float a = direction_xz.LengthSq();
-		float b = 2.0f * origin_xz.Dot(direction_xz);
-		float c = origin_xz_len_sq - r_sq;
-		float fraction1, fraction2;
-		if (FindRoot(a, b, c, fraction1, fraction2) == 0)
-			return FLT_MAX; // No intersection with infinite cylinder
-
-		// Get fraction corresponding to the ray entering the circle
-		float fraction = min(fraction1, fraction2);
-		if (fraction >= 0.0f)
-			return fraction;
-	}
-	else
-	{
-		// Ray starts inside the infinite cylinder
-		return 0.0f;
-	}
-
-	// No collision
-	return FLT_MAX;
-}
-
-/// Test a ray against a cylinder centered around the origin with its axis along the Y axis and half height specified.
-/// @return FLT_MAX if there is no intersection, otherwise the fraction along the ray.
-/// @param inRayDirection Ray direction. Does not need to be normalized.
-/// @param inRayOrigin Origin of the ray. If the ray starts inside the cylinder, the returned fraction will be 0.
-/// @param inCylinderRadius Radius of the cylinder
-/// @param inCylinderHalfHeight Distance from the origin to the top (or bottom) of the cylinder
-JPH_INLINE float RayCylinder(Vec3Arg inRayOrigin, Vec3Arg inRayDirection, float inCylinderHalfHeight, float inCylinderRadius)
-{
-	// Test infinite cylinder
-	float fraction = RayCylinder(inRayOrigin, inRayDirection, inCylinderRadius);
-	if (fraction == FLT_MAX)
-		return FLT_MAX;
-
-	// If this hit is in the finite cylinder we have our fraction
-	if (abs(inRayOrigin.GetY() + fraction * inRayDirection.GetY()) <= inCylinderHalfHeight)
-		return fraction;
-
-	// Check if ray could hit the top or bottom plane of the cylinder
-	float direction_y = inRayDirection.GetY();
-	if (direction_y != 0.0f)
-	{
-		// Solving line equation: x = ray_origin + fraction * ray_direction
-		// and plane equation: plane_normal . x + plane_constant = 0
-		// fraction = (-plane_constant - plane_normal . ray_origin) / (plane_normal . ray_direction)
-		// when the ray_direction.y < 0:
-		// plane_constant = -cylinder_half_height, plane_normal = (0, 1, 0)
-		// else
-		// plane_constant = -cylinder_half_height, plane_normal = (0, -1, 0)
-		float origin_y = inRayOrigin.GetY();
-		float plane_fraction;
-		if (direction_y < 0.0f)
-			plane_fraction = (inCylinderHalfHeight - origin_y) / direction_y;
-		else
-			plane_fraction = -(inCylinderHalfHeight + origin_y) / direction_y;
-
-		// Check if the hit is in front of the ray
-		if (plane_fraction >= 0.0f)
-		{
-			// Test if this hit is inside the cylinder
-			Vec3 point = inRayOrigin + plane_fraction * inRayDirection;
-			float dist_sq = Square(point.GetX()) + Square(point.GetZ());
-			if (dist_sq <= Square(inCylinderRadius))
-				return plane_fraction;
-		}
-	}
-
-	// No collision
-	return FLT_MAX;
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Geometry/RaySphere.h

@@ -1,96 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/FindRoot.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Tests a ray starting at inRayOrigin and extending infinitely in inRayDirection against a sphere,
-/// @return FLT_MAX if there is no intersection, otherwise the fraction along the ray.
-/// @param inRayOrigin Ray origin. If the ray starts inside the sphere, the returned fraction will be 0.
-/// @param inRayDirection Ray direction. Does not need to be normalized.
-/// @param inSphereCenter Position of the center of the sphere
-/// @param inSphereRadius Radius of the sphere
-JPH_INLINE float RaySphere(Vec3Arg inRayOrigin, Vec3Arg inRayDirection, Vec3Arg inSphereCenter, float inSphereRadius)
-{
-	// Solve: |RayOrigin + fraction * RayDirection - SphereCenter|^2 = SphereRadius^2 for fraction
-	Vec3 center_origin = inRayOrigin - inSphereCenter;
-	float a = inRayDirection.LengthSq();
-	float b = 2.0f * inRayDirection.Dot(center_origin);
-	float c = center_origin.LengthSq() - inSphereRadius * inSphereRadius;
-	float fraction1, fraction2;
-	if (FindRoot(a, b, c, fraction1, fraction2) == 0)
-		return c <= 0.0f? 0.0f : FLT_MAX; // Return if origin is inside the sphere
-
-	// Sort so that the smallest is first
-	if (fraction1 > fraction2)
-		std::swap(fraction1, fraction2);
-
-	// Test solution with lowest fraction, this will be the ray entering the sphere
-	if (fraction1 >= 0.0f)
-		return fraction1; // Sphere is before the ray start
-
-	// Test solution with highest fraction, this will be the ray leaving the sphere
-	if (fraction2 >= 0.0f)
-		return 0.0f; // We start inside the sphere
-
-	// No solution
-	return FLT_MAX;
-}
-
-/// Tests a ray starting at inRayOrigin and extending infinitely in inRayDirection against a sphere.
-/// Outputs entry and exit points (outMinFraction and outMaxFraction) along the ray (which could be negative if the hit point is before the start of the ray).
-/// @param inRayOrigin Ray origin. If the ray starts inside the sphere, the returned fraction will be 0.
-/// @param inRayDirection Ray direction. Does not need to be normalized.
-/// @param inSphereCenter Position of the center of the sphere.
-/// @param inSphereRadius Radius of the sphere.
-/// @param outMinFraction Returned lowest intersection fraction
-/// @param outMaxFraction Returned highest intersection fraction
-/// @return The amount of intersections with the sphere.
-/// If 1 intersection is returned outMinFraction will be equal to outMaxFraction
-JPH_INLINE int RaySphere(Vec3Arg inRayOrigin, Vec3Arg inRayDirection, Vec3Arg inSphereCenter, float inSphereRadius, float &outMinFraction, float &outMaxFraction)
-{
-	// Solve: |RayOrigin + fraction * RayDirection - SphereCenter|^2 = SphereRadius^2 for fraction
-	Vec3 center_origin = inRayOrigin - inSphereCenter;
-	float a = inRayDirection.LengthSq();
-	float b = 2.0f * inRayDirection.Dot(center_origin);
-	float c = center_origin.LengthSq() - inSphereRadius * inSphereRadius;
-	float fraction1, fraction2;
-	switch (FindRoot(a, b, c, fraction1, fraction2))
-	{
-	case 0:
-		if (c <= 0.0f)
-		{
-			// Origin inside sphere
-			outMinFraction = outMaxFraction = 0.0f;
-			return 1;
-		}
-		else
-		{
-			// Origin outside of the sphere
-			return 0;
-		}
-		break;
-
-	case 1:
-		// Ray is touching the sphere
-		outMinFraction = outMaxFraction = fraction1;
-		return 1;
-
-	default:
-		// Ray enters and exits the sphere
-
-		// Sort so that the smallest is first
-		if (fraction1 > fraction2)
-			std::swap(fraction1, fraction2);
-
-		outMinFraction = fraction1;
-		outMaxFraction = fraction2;
-		return 2;
-	}
-}
-
-JPH_NAMESPACE_END