@bloomengine/engine 0.4.0 → 0.4.1

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/CollideShapeVsShapePerLeaf.h

@@ -1,94 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2025 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/CollideShape.h>
-#include <Jolt/Physics/Collision/CollisionDispatch.h>
-#include <Jolt/Physics/Collision/TransformedShape.h>
-#include <Jolt/Core/STLLocalAllocator.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Collide 2 shapes and returns at most 1 hit per leaf shape pairs that overlapping. This can be used when not all contacts between the shapes are needed.
-/// E.g. when testing a compound with 2 MeshShapes A and B against a compound with 2 SphereShapes C and D, then at most you'll get 4 collisions: AC, AD, BC, BD.
-/// The default CollisionDispatch::sCollideShapeVsShape function would return all intersecting triangles in A against C, all in B against C etc.
-/// @param inShape1 The first shape
-/// @param inShape2 The second shape
-/// @param inScale1 Local space scale of shape 1 (scales relative to its center of mass)
-/// @param inScale2 Local space scale of shape 2 (scales relative to its center of mass)
-/// @param inCenterOfMassTransform1 Transform to transform center of mass of shape 1 into world space
-/// @param inCenterOfMassTransform2 Transform to transform center of mass of shape 2 into world space
-/// @param inSubShapeIDCreator1 Class that tracks the current sub shape ID for shape 1
-/// @param inSubShapeIDCreator2 Class that tracks the current sub shape ID for shape 2
-/// @param inCollideShapeSettings Options for the CollideShape test
-/// @param ioCollector The collector that receives the results.
-/// @param inShapeFilter allows selectively disabling collisions between pairs of (sub) shapes.
-/// @tparam LeafCollector The type of the collector that will be used to collect hits between leaf pairs. Must be either AnyHitCollisionCollector<CollideShapeCollector> to get any hit (cheapest) or ClosestHitCollisionCollector<CollideShapeCollector> to get the deepest hit (more expensive).
-template <class LeafCollector>
-void CollideShapeVsShapePerLeaf(const Shape *inShape1, const Shape *inShape2, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, const SubShapeIDCreator &inSubShapeIDCreator2, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter = { })
-{
-	// Tracks information we need about a leaf shape
-	struct LeafShape
-	{
-							LeafShape() = default;
-
-							LeafShape(const AABox &inBounds, Mat44Arg inCenterOfMassTransform, Vec3Arg inScale, const Shape *inShape, const SubShapeIDCreator &inSubShapeIDCreator) :
-			mBounds(inBounds),
-			mCenterOfMassTransform(inCenterOfMassTransform),
-			mScale(inScale),
-			mShape(inShape),
-			mSubShapeIDCreator(inSubShapeIDCreator)
-		{
-		}
-
-		AABox				mBounds;
-		Mat44				mCenterOfMassTransform;
-		Vec3				mScale;
-		const Shape *		mShape;
-		SubShapeIDCreator	mSubShapeIDCreator;
-	};
-
-	constexpr uint cMaxLocalLeafShapes = 32;
-
-	// A collector that stores the information we need from a leaf shape in an array that is usually on the stack but can fall back to the heap if needed
-	class MyCollector : public TransformedShapeCollector
-	{
-	public:
-							MyCollector()
-		{
-			mHits.reserve(cMaxLocalLeafShapes);
-		}
-
-		void				AddHit(const TransformedShape &inShape) override
-		{
-			mHits.emplace_back(inShape.GetWorldSpaceBounds(), inShape.GetCenterOfMassTransform().ToMat44(), inShape.GetShapeScale(), inShape.mShape, inShape.mSubShapeIDCreator);
-		}
-
-		Array<LeafShape, STLLocalAllocator<LeafShape, cMaxLocalLeafShapes>> mHits;
-	};
-
-	// Get bounds of both shapes
-	AABox bounds1 = inShape1->GetWorldSpaceBounds(inCenterOfMassTransform1, inScale1);
-	AABox bounds2 = inShape2->GetWorldSpaceBounds(inCenterOfMassTransform2, inScale2);
-
-	// Get leaf shapes that overlap with the bounds of the other shape
-	MyCollector leaf_shapes1, leaf_shapes2;
-	inShape1->CollectTransformedShapes(bounds2, inCenterOfMassTransform1.GetTranslation(), inCenterOfMassTransform1.GetQuaternion(), inScale1, inSubShapeIDCreator1, leaf_shapes1, inShapeFilter);
-	inShape2->CollectTransformedShapes(bounds1, inCenterOfMassTransform2.GetTranslation(), inCenterOfMassTransform2.GetQuaternion(), inScale2, inSubShapeIDCreator2, leaf_shapes2, inShapeFilter);
-
-	// Now test each leaf shape against each other leaf
-	for (const LeafShape &leaf1 : leaf_shapes1.mHits)
-		for (const LeafShape &leaf2 : leaf_shapes2.mHits)
-			if (leaf1.mBounds.Overlaps(leaf2.mBounds))
-			{
-				// Use the leaf collector to collect max 1 hit for this pair and pass it on to ioCollector
-				LeafCollector collector;
-				CollisionDispatch::sCollideShapeVsShape(leaf1.mShape, leaf2.mShape, leaf1.mScale, leaf2.mScale, leaf1.mCenterOfMassTransform, leaf2.mCenterOfMassTransform, leaf1.mSubShapeIDCreator, leaf2.mSubShapeIDCreator, inCollideShapeSettings, collector, inShapeFilter);
-				if (collector.HadHit())
-					ioCollector.AddHit(collector.mHit);
-			}
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/CollideSoftBodyVertexIterator.h

@@ -1,110 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/SoftBody/SoftBodyVertex.h>
-#include <Jolt/Core/StridedPtr.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Class that allows iterating over the vertices of a soft body.
-/// It tracks the largest penetration and allows storing the resulting collision in a different structure than the soft body vertex itself.
-class CollideSoftBodyVertexIterator
-{
-public:
-	/// Default constructor
-									CollideSoftBodyVertexIterator() = default;
-									CollideSoftBodyVertexIterator(const CollideSoftBodyVertexIterator &) = default;
-
-	/// Construct using (strided) pointers
-									CollideSoftBodyVertexIterator(const StridedPtr<const Vec3> &inPosition, const StridedPtr<const float> &inInvMass, const StridedPtr<Plane> &inCollisionPlane, const StridedPtr<float> &inLargestPenetration, const StridedPtr<int> &inCollidingShapeIndex) :
-		mPosition(inPosition),
-		mInvMass(inInvMass),
-		mCollisionPlane(inCollisionPlane),
-		mLargestPenetration(inLargestPenetration),
-		mCollidingShapeIndex(inCollidingShapeIndex)
-	{
-	}
-
-	/// Construct using a soft body vertex
-	explicit						CollideSoftBodyVertexIterator(SoftBodyVertex *inVertices) :
-		mPosition(&inVertices->mPosition, sizeof(SoftBodyVertex)),
-		mInvMass(&inVertices->mInvMass, sizeof(SoftBodyVertex)),
-		mCollisionPlane(&inVertices->mCollisionPlane, sizeof(SoftBodyVertex)),
-		mLargestPenetration(&inVertices->mLargestPenetration, sizeof(SoftBodyVertex)),
-		mCollidingShapeIndex(&inVertices->mCollidingShapeIndex, sizeof(SoftBodyVertex))
-	{
-	}
-
-	/// Default assignment
-	CollideSoftBodyVertexIterator &	operator = (const CollideSoftBodyVertexIterator &) = default;
-
-	/// Equality operator.
-	/// Note: Only used to determine end iterator, so we only compare position.
-	bool							operator != (const CollideSoftBodyVertexIterator &inRHS) const
-	{
-		return mPosition != inRHS.mPosition;
-	}
-
-	/// Next vertex
-	CollideSoftBodyVertexIterator &	operator ++ ()
-	{
-		++mPosition;
-		++mInvMass;
-		++mCollisionPlane;
-		++mLargestPenetration;
-		++mCollidingShapeIndex;
-		return *this;
-	}
-
-	/// Add an offset
-	/// Note: Only used to determine end iterator, so we only set position.
-	CollideSoftBodyVertexIterator	operator + (int inOffset) const
-	{
-		return CollideSoftBodyVertexIterator(mPosition + inOffset, StridedPtr<const float>(), StridedPtr<Plane>(), StridedPtr<float>(), StridedPtr<int>());
-	}
-
-	/// Get the position of the current vertex
-	Vec3							GetPosition() const
-	{
-		return *mPosition;
-	}
-
-	/// Get the inverse mass of the current vertex
-	float							GetInvMass() const
-	{
-		return *mInvMass;
-	}
-
-	/// Update penetration of the current vertex
-	/// @return Returns true if the vertex has the largest penetration so far, this means you need to follow up by calling SetCollision
-	bool							UpdatePenetration(float inLargestPenetration) const
-	{
-		float &penetration = *mLargestPenetration;
-		if (penetration >= inLargestPenetration)
-			return false;
-		penetration = inLargestPenetration;
-		return true;
-	}
-
-	/// Update the collision of the current vertex
-	void							SetCollision(const Plane &inCollisionPlane, int inCollidingShapeIndex) const
-	{
-		*mCollisionPlane = inCollisionPlane;
-		*mCollidingShapeIndex = inCollidingShapeIndex;
-	}
-
-private:
-	/// Input data
-	StridedPtr<const Vec3>			mPosition;
-	StridedPtr<const float>			mInvMass;
-
-	/// Output data
-	StridedPtr<Plane>				mCollisionPlane;
-	StridedPtr<float>				mLargestPenetration;
-	StridedPtr<int>					mCollidingShapeIndex;
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/CollideSoftBodyVerticesVsTriangles.h

@@ -1,102 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/CollideSoftBodyVertexIterator.h>
-#include <Jolt/Geometry/ClosestPoint.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Collision detection helper that collides soft body vertices vs triangles
-class JPH_EXPORT CollideSoftBodyVerticesVsTriangles
-{
-public:
-						CollideSoftBodyVerticesVsTriangles(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale) :
-		mTransform(inCenterOfMassTransform),
-		mInvTransform(mTransform.InversedRotationTranslation()),
-		mScale(inScale),
-		mNormalSign(ScaleHelpers::IsInsideOut(inScale)? -1.0f : 1.0f)
-	{
-	}
-
-	JPH_INLINE void		StartVertex(const CollideSoftBodyVertexIterator &inVertex)
-	{
-		mLocalPosition = mInvTransform * inVertex.GetPosition();
-		mClosestDistanceSq = FLT_MAX;
-	}
-
-	JPH_INLINE void		ProcessTriangle(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2)
-	{
-		// Apply the scale to the triangle
-		Vec3 v0 = mScale * inV0;
-		Vec3 v1 = mScale * inV1;
-		Vec3 v2 = mScale * inV2;
-
-		// Get the closest point from the vertex to the triangle
-		uint32 set;
-		Vec3 closest_point = ClosestPoint::GetClosestPointOnTriangle(v0 - mLocalPosition, v1 - mLocalPosition, v2 - mLocalPosition, set);
-		float dist_sq = closest_point.LengthSq();
-		if (dist_sq < mClosestDistanceSq)
-		{
-			mV0 = v0;
-			mV1 = v1;
-			mV2 = v2;
-			mClosestPoint = closest_point;
-			mClosestDistanceSq = dist_sq;
-			mSet = set;
-		}
-	}
-
-	JPH_INLINE void		FinishVertex(const CollideSoftBodyVertexIterator &ioVertex, int inCollidingShapeIndex) const
-	{
-		if (mClosestDistanceSq < FLT_MAX)
-		{
-			// Convert triangle to world space
-			Vec3 v0 = mTransform * mV0;
-			Vec3 v1 = mTransform * mV1;
-			Vec3 v2 = mTransform * mV2;
-			Vec3 triangle_normal = mNormalSign * (v1 - v0).Cross(v2 - v0).NormalizedOr(Vec3::sAxisY());
-
-			if (mSet == 0b111)
-			{
-				// Closest is interior to the triangle, use plane as collision plane but don't allow more than sTriangleThickness penetration
-				// because otherwise a triangle half a level a way will have a huge penetration if it is back facing
-				float penetration = triangle_normal.Dot(v0 - ioVertex.GetPosition());
-				if (penetration < sTriangleThickness && ioVertex.UpdatePenetration(penetration))
-					ioVertex.SetCollision(Plane::sFromPointAndNormal(v0, triangle_normal), inCollidingShapeIndex);
-			}
-			else
-			{
-				// Closest point is on an edge or vertex, use closest point as collision plane
-				Vec3 closest_point = mTransform * (mLocalPosition + mClosestPoint);
-				Vec3 normal = ioVertex.GetPosition() - closest_point;
-				if (normal.Dot(triangle_normal) > 0.0f) // Ignore back facing edges
-				{
-					float normal_length = normal.Length();
-					float penetration = -normal_length;
-					if (ioVertex.UpdatePenetration(penetration))
-						ioVertex.SetCollision(Plane::sFromPointAndNormal(closest_point, normal_length > 0.0f? normal / normal_length : triangle_normal), inCollidingShapeIndex);
-				}
-			}
-		}
-	}
-
-	/// Triangles are considered to have some thickness. This thickness extends backwards along the negative triangle normal.
-	/// Make this value smaller than the smallest 'wall thickness' so that the back side of the triangle doesn't protrude through the other side.
-	/// Make this value too small and tunneling is more likely to occur.
-	static inline float	sTriangleThickness = 0.1f;
-
-	Mat44				mTransform;
-	Mat44				mInvTransform;
-	Vec3				mScale;
-	Vec3				mLocalPosition;
-	Vec3				mV0, mV1, mV2;
-	Vec3				mClosestPoint;
-	float				mNormalSign;
-	float				mClosestDistanceSq;
-	uint32				mSet;
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/CollideSphereVsTriangles.cpp

@@ -1,121 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Physics/Collision/CollideSphereVsTriangles.h>
-#include <Jolt/Physics/Collision/Shape/ScaleHelpers.h>
-#include <Jolt/Physics/Collision/CollideShape.h>
-#include <Jolt/Physics/Collision/TransformedShape.h>
-#include <Jolt/Physics/Collision/ActiveEdges.h>
-#include <Jolt/Physics/Collision/NarrowPhaseStats.h>
-#include <Jolt/Core/Profiler.h>
-
-JPH_NAMESPACE_BEGIN
-
-static constexpr uint8 sClosestFeatureToActiveEdgesMask[] = {
-	0b000,		// 0b000: Invalid, guarded by an assert
-	0b101,		// 0b001: Vertex 1 -> edge 1 or 3
-	0b011,		// 0b010: Vertex 2 -> edge 1 or 2
-	0b001,		// 0b011: Vertex 1 & 2 -> edge 1
-	0b110,		// 0b100: Vertex 3 -> edge 2 or 3
-	0b100,		// 0b101: Vertex 1 & 3 -> edge 3
-	0b010,		// 0b110: Vertex 2 & 3 -> edge 2
-	// 0b111: Vertex 1, 2 & 3 -> interior, guarded by an if
-};
-
-CollideSphereVsTriangles::CollideSphereVsTriangles(const SphereShape *inShape1, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeID &inSubShapeID1, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector) :
-	mCollideShapeSettings(inCollideShapeSettings),
-	mCollector(ioCollector),
-	mShape1(inShape1),
-	mScale2(inScale2),
-	mTransform2(inCenterOfMassTransform2),
-	mSubShapeID1(inSubShapeID1)
-{
-	// Calculate the center of the sphere in the space of 2
-	mSphereCenterIn2 = inCenterOfMassTransform2.Multiply3x3Transposed(inCenterOfMassTransform1.GetTranslation() - inCenterOfMassTransform2.GetTranslation());
-
-	// Determine if shape 2 is inside out or not
-	mScaleSign2 = ScaleHelpers::IsInsideOut(inScale2)? -1.0f : 1.0f;
-
-	// Check that the sphere is uniformly scaled
-	JPH_ASSERT(ScaleHelpers::IsUniformScale(inScale1.Abs()));
-	mRadius = abs(inScale1.GetX()) * inShape1->GetRadius();
-	mRadiusPlusMaxSeparationSq = Square(mRadius + inCollideShapeSettings.mMaxSeparationDistance);
-}
-
-void CollideSphereVsTriangles::Collide(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, uint8 inActiveEdges, const SubShapeID &inSubShapeID2)
-{
-	// Scale triangle and make it relative to the center of the sphere
-	Vec3 v0 = mScale2 * inV0 - mSphereCenterIn2;
-	Vec3 v1 = mScale2 * inV1 - mSphereCenterIn2;
-	Vec3 v2 = mScale2 * inV2 - mSphereCenterIn2;
-
-	// Calculate triangle normal
-	Vec3 triangle_normal = mScaleSign2 * (v1 - v0).Cross(v2 - v0);
-
-	// Backface check
-	bool back_facing = triangle_normal.Dot(v0) > 0.0f;
-	if (mCollideShapeSettings.mBackFaceMode == EBackFaceMode::IgnoreBackFaces && back_facing)
-		return;
-
-	// Check if we collide with the sphere
-	uint32 closest_feature;
-	Vec3 point2 = ClosestPoint::GetClosestPointOnTriangle(v0, v1, v2, closest_feature);
-	float point2_len_sq = point2.LengthSq();
-	if (point2_len_sq > mRadiusPlusMaxSeparationSq)
-		return;
-
-	// Calculate penetration depth
-	float penetration_depth = mRadius - sqrt(point2_len_sq);
-	if (-penetration_depth >= mCollector.GetEarlyOutFraction())
-		return;
-
-	// Calculate penetration axis, direction along which to push 2 to move it out of collision (this is always away from the sphere center)
-	Vec3 penetration_axis = point2.NormalizedOr(Vec3::sAxisY());
-
-	// Calculate the point on the sphere
-	Vec3 point1 = mRadius * penetration_axis;
-
-	// Check if we have enabled active edge detection
-	JPH_ASSERT(closest_feature != 0);
-	if (mCollideShapeSettings.mActiveEdgeMode == EActiveEdgeMode::CollideOnlyWithActive
-		&& closest_feature != 0b111 // For an interior hit we should already have the right normal
-		&& (inActiveEdges & sClosestFeatureToActiveEdgesMask[closest_feature]) == 0) // If we didn't hit an active edge we should take the triangle normal
-	{
-		// Convert the active edge velocity hint to local space
-		Vec3 active_edge_movement_direction = mTransform2.Multiply3x3Transposed(mCollideShapeSettings.mActiveEdgeMovementDirection);
-
-		// See ActiveEdges::FixNormal. If penetration_axis affects the movement less than the triangle normal we keep penetration_axis.
-		Vec3 new_penetration_axis = back_facing? triangle_normal : -triangle_normal;
-		if (active_edge_movement_direction.Dot(penetration_axis) * new_penetration_axis.Length() >= active_edge_movement_direction.Dot(new_penetration_axis))
-			penetration_axis = new_penetration_axis;
-	}
-
-	// Convert to world space
-	point1 = mTransform2 * (mSphereCenterIn2 + point1);
-	point2 = mTransform2 * (mSphereCenterIn2 + point2);
-	Vec3 penetration_axis_world = mTransform2.Multiply3x3(penetration_axis);
-
-	// Create collision result
-	CollideShapeResult result(point1, point2, penetration_axis_world, penetration_depth, mSubShapeID1, inSubShapeID2, TransformedShape::sGetBodyID(mCollector.GetContext()));
-
-	// Gather faces
-	if (mCollideShapeSettings.mCollectFacesMode == ECollectFacesMode::CollectFaces)
-	{
-		// The sphere doesn't have a supporting face
-
-		// Get face of triangle 2
-		result.mShape2Face.resize(3);
-		result.mShape2Face[0] = mTransform2 * (mSphereCenterIn2 + v0);
-		result.mShape2Face[1] = mTransform2 * (mSphereCenterIn2 + v1);
-		result.mShape2Face[2] = mTransform2 * (mSphereCenterIn2 + v2);
-	}
-
-	// Notify the collector
-	JPH_IF_TRACK_NARROWPHASE_STATS(TrackNarrowPhaseCollector track;)
-	mCollector.AddHit(result);
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/CollideSphereVsTriangles.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/Physics/Collision/Shape/Shape.h>
-#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
-#include <Jolt/Physics/Collision/Shape/SphereShape.h>
-
-JPH_NAMESPACE_BEGIN
-
-class CollideShapeSettings;
-
-/// Collision detection helper that collides a sphere vs one or more triangles
-class JPH_EXPORT CollideSphereVsTriangles
-{
-public:
-	/// Constructor
-	/// @param inShape1 The sphere to collide against triangles
-	/// @param inScale1 Local space scale for the sphere (scales relative to its center of mass)
-	/// @param inScale2 Local space scale for the triangles
-	/// @param inCenterOfMassTransform1 Transform that takes the center of mass of 1 into world space
-	/// @param inCenterOfMassTransform2 Transform that takes the center of mass of 2 into world space
-	/// @param inSubShapeID1 Sub shape ID of the convex object
-	/// @param inCollideShapeSettings Settings for the collide shape query
-	/// @param ioCollector The collector that will receive the results
-									CollideSphereVsTriangles(const SphereShape *inShape1, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeID &inSubShapeID1, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector);
-
-	/// Collide sphere with a single triangle
-	/// @param inV0 , inV1 , inV2: CCW triangle vertices
-	/// @param inActiveEdges bit 0 = edge v0..v1 is active, bit 1 = edge v1..v2 is active, bit 2 = edge v2..v0 is active
-	/// An active edge is an edge that is not connected to another triangle in such a way that it is impossible to collide with the edge
-	/// @param inSubShapeID2 The sub shape ID for the triangle
-	void							Collide(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, uint8 inActiveEdges, const SubShapeID &inSubShapeID2);
-
-protected:
-	const CollideShapeSettings &	mCollideShapeSettings;					///< Settings for this collision operation
-	CollideShapeCollector &			mCollector;								///< The collector that will receive the results
-	const SphereShape *				mShape1;								///< The shape that we're colliding with
-	Vec3							mScale2;								///< The scale of the shape (in shape local space) of the shape we're colliding against
-	Mat44							mTransform2;							///< Transform of the shape we're colliding against
-	Vec3							mSphereCenterIn2;						///< The center of the sphere in the space of 2
-	SubShapeID						mSubShapeID1;							///< Sub shape ID of colliding shape
-	float							mScaleSign2;							///< Sign of the scale of object 2, -1 if object is inside out, 1 if not
-	float							mRadius;								///< Radius of the sphere
-	float							mRadiusPlusMaxSeparationSq;				///< (Radius + Max SeparationDistance)^2
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/CollisionCollector.h

@@ -1,109 +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 Body;
-class TransformedShape;
-
-/// Traits to use for CastRay
-class CollisionCollectorTraitsCastRay
-{
-public:
-	/// For rays the early out fraction is the fraction along the line to order hits.
-	static constexpr float InitialEarlyOutFraction = 1.0f + FLT_EPSILON;	///< Furthest hit: Fraction is 1 + epsilon
-	static constexpr float ShouldEarlyOutFraction = 0.0f;					///< Closest hit: Fraction is 0
-};
-
-/// Traits to use for CastShape
-class CollisionCollectorTraitsCastShape
-{
-public:
-	/// For rays the early out fraction is the fraction along the line to order hits.
-	static constexpr float InitialEarlyOutFraction = 1.0f + FLT_EPSILON;	///< Furthest hit: Fraction is 1 + epsilon
-	static constexpr float ShouldEarlyOutFraction = -FLT_MAX;				///< Deepest hit: Penetration is infinite
-};
-
-/// Traits to use for CollideShape
-class CollisionCollectorTraitsCollideShape
-{
-public:
-	/// For shape collisions we use -penetration depth to order hits.
-	static constexpr float InitialEarlyOutFraction = FLT_MAX;				///< Most shallow hit: Separation is infinite
-	static constexpr float ShouldEarlyOutFraction = -FLT_MAX;				///< Deepest hit: Penetration is infinite
-};
-
-/// Traits to use for CollidePoint
-using CollisionCollectorTraitsCollidePoint = CollisionCollectorTraitsCollideShape;
-
-/// Virtual interface that allows collecting multiple collision results
-template <class ResultTypeArg, class TraitsType>
-class CollisionCollector
-{
-public:
-	/// Declare ResultType so that derived classes can use it
-	using ResultType = ResultTypeArg;
-
-	/// Default constructor
-							CollisionCollector() = default;
-
-	/// Constructor to initialize from another collector
-	template <class ResultTypeArg2>
-	explicit				CollisionCollector(const CollisionCollector<ResultTypeArg2, TraitsType> &inRHS) : mEarlyOutFraction(inRHS.GetEarlyOutFraction()), mContext(inRHS.GetContext()) { }
-							CollisionCollector(const CollisionCollector<ResultTypeArg, TraitsType> &inRHS) = default;
-
-	/// Destructor
-	virtual					~CollisionCollector() = default;
-
-	/// If you want to reuse this collector, call Reset()
-	virtual void			Reset()											{ mEarlyOutFraction = TraitsType::InitialEarlyOutFraction; }
-
-	/// When running a query through the NarrowPhaseQuery class, this will be called for every body that is potentially colliding.
-	/// It allows collecting additional information needed by the collision collector implementation from the body under lock protection
-	/// before AddHit is called (e.g. the user data pointer or the velocity of the body).
-	virtual void			OnBody([[maybe_unused]] const Body &inBody)		{ /* Collects nothing by default */ }
-
-	/// When running a query through the NarrowPhaseQuery class, this will be called after all AddHit calls have been made for a particular body.
-	virtual void			OnBodyEnd()										{ /* Does nothing by default */ }
-
-	/// Set by the collision detection functions to the current TransformedShape that we're colliding against before calling the AddHit function.
-	/// Note: Only valid during AddHit! For performance reasons, the pointer is not reset after leaving AddHit so the context may point to freed memory.
-	void					SetContext(const TransformedShape *inContext)	{ mContext = inContext; }
-	const TransformedShape *GetContext() const								{ return mContext; }
-
-	/// This function can be used to set some user data on the collision collector
-	virtual void			SetUserData(uint64 inUserData)					{ /* Does nothing by default */ }
-
-	/// This function will be called for every hit found, it's up to the application to decide how to store the hit
-	virtual void			AddHit(const ResultType &inResult) = 0;
-
-	/// Update the early out fraction (should be lower than before)
-	inline void				UpdateEarlyOutFraction(float inFraction)		{ JPH_ASSERT(inFraction <= mEarlyOutFraction); mEarlyOutFraction = inFraction; }
-
-	/// Reset the early out fraction to a specific value
-	inline void				ResetEarlyOutFraction(float inFraction = TraitsType::InitialEarlyOutFraction) { mEarlyOutFraction = inFraction; }
-
-	/// Force the collision detection algorithm to terminate as soon as possible. Call this from the AddHit function when a satisfying hit is found.
-	inline void				ForceEarlyOut()									{ mEarlyOutFraction = TraitsType::ShouldEarlyOutFraction; }
-
-	/// When true, the collector will no longer accept any additional hits and the collision detection routine should early out as soon as possible
-	inline bool				ShouldEarlyOut() const							{ return mEarlyOutFraction <= TraitsType::ShouldEarlyOutFraction; }
-
-	/// Get the current early out value
-	inline float			GetEarlyOutFraction() const						{ return mEarlyOutFraction; }
-
-	/// Get the current early out value but make sure it's bigger than zero, this is used for shape casting as negative values are used for penetration
-	inline float			GetPositiveEarlyOutFraction() const				{ return max(FLT_MIN, mEarlyOutFraction); }
-
-private:
-	/// The early out fraction determines the fraction below which the collector is still accepting a hit (can be used to reduce the amount of work)
-	float					mEarlyOutFraction = TraitsType::InitialEarlyOutFraction;
-
-	/// Set by the collision detection functions to the current TransformedShape of the body that we're colliding against before calling the AddHit function
-	const TransformedShape *mContext = nullptr;
-};
-
-JPH_NAMESPACE_END