@bloomengine/engine 0.4.0 → 0.4.2

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

@@ -1,223 +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/CastSphereVsTriangles.h>
-#include <Jolt/Physics/Collision/TransformedShape.h>
-#include <Jolt/Physics/Collision/Shape/ScaleHelpers.h>
-#include <Jolt/Physics/Collision/Shape/SphereShape.h>
-#include <Jolt/Physics/Collision/ActiveEdges.h>
-#include <Jolt/Physics/Collision/NarrowPhaseStats.h>
-#include <Jolt/Geometry/ClosestPoint.h>
-#include <Jolt/Geometry/RaySphere.h>
-#include <Jolt/Core/Profiler.h>
-
-JPH_NAMESPACE_BEGIN
-
-CastSphereVsTriangles::CastSphereVsTriangles(const ShapeCast &inShapeCast, const ShapeCastSettings &inShapeCastSettings, Vec3Arg inScale, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, CastShapeCollector &ioCollector) :
-	mStart(inShapeCast.mCenterOfMassStart.GetTranslation()),
-	mDirection(inShapeCast.mDirection),
-	mShapeCastSettings(inShapeCastSettings),
-	mCenterOfMassTransform2(inCenterOfMassTransform2),
-	mScale(inScale),
-	mSubShapeIDCreator1(inSubShapeIDCreator1),
-	mCollector(ioCollector)
-{
-	// Cast to sphere shape
-	JPH_ASSERT(inShapeCast.mShape->GetSubType() == EShapeSubType::Sphere);
-	const SphereShape *sphere = static_cast<const SphereShape *>(inShapeCast.mShape);
-
-	// Scale the radius
-	mRadius = sphere->GetRadius() * abs(inShapeCast.mScale.GetX());
-
-	// Determine if shape is inside out or not
-	mScaleSign = ScaleHelpers::IsInsideOut(inScale)? -1.0f : 1.0f;
-}
-
-void CastSphereVsTriangles::AddHit(bool inBackFacing, const SubShapeID &inSubShapeID2, float inFraction, Vec3Arg inContactPointA, Vec3Arg inContactPointB, Vec3Arg inContactNormal)
-{
-	// Convert to world space
-	Vec3 contact_point_a = mCenterOfMassTransform2 * (mStart + inContactPointA);
-	Vec3 contact_point_b = mCenterOfMassTransform2 * (mStart + inContactPointB);
-	Vec3 contact_normal_world = mCenterOfMassTransform2.Multiply3x3(inContactNormal);
-
-	// Its a hit, store the sub shape id's
-	ShapeCastResult result(inFraction, contact_point_a, contact_point_b, contact_normal_world, inBackFacing, mSubShapeIDCreator1.GetID(), inSubShapeID2, TransformedShape::sGetBodyID(mCollector.GetContext()));
-
-	// Note: We don't gather faces here because that's only useful if both shapes have a face. Since the sphere always has only 1 contact point, the manifold is always a point.
-
-	JPH_IF_TRACK_NARROWPHASE_STATS(TrackNarrowPhaseCollector track;)
-	mCollector.AddHit(result);
-}
-
-void CastSphereVsTriangles::AddHitWithActiveEdgeDetection(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, bool inBackFacing, Vec3Arg inTriangleNormal, uint8 inActiveEdges, const SubShapeID &inSubShapeID2, float inFraction, Vec3Arg inContactPointA, Vec3Arg inContactPointB, Vec3Arg inContactNormal)
-{
-	// Check if we have enabled active edge detection
-	Vec3 contact_normal = inContactNormal;
-	if (mShapeCastSettings.mActiveEdgeMode == EActiveEdgeMode::CollideOnlyWithActive && inActiveEdges != 0b111)
-	{
-		// Convert the active edge velocity hint to local space
-		Vec3 active_edge_movement_direction = mCenterOfMassTransform2.Multiply3x3Transposed(mShapeCastSettings.mActiveEdgeMovementDirection);
-
-		// Update the contact normal to account for active edges
-		// Note that we flip the triangle normal as the penetration axis is pointing towards the triangle instead of away
-		contact_normal = ActiveEdges::FixNormal(inV0, inV1, inV2, inBackFacing? inTriangleNormal : -inTriangleNormal, inActiveEdges, inContactPointB, inContactNormal, active_edge_movement_direction);
-	}
-
-	AddHit(inBackFacing, inSubShapeID2, inFraction, inContactPointA, inContactPointB, contact_normal);
-}
-
-// This is a simplified version of the ray cylinder test from: Real Time Collision Detection - Christer Ericson
-// Chapter 5.3.7, page 194-197. Some conditions have been removed as we're not interested in hitting the caps of the cylinder.
-// Note that the ray origin is assumed to be the origin here.
-float CastSphereVsTriangles::RayCylinder(Vec3Arg inRayDirection, Vec3Arg inCylinderA, Vec3Arg inCylinderB, float inRadius) const
-{
-	// Calculate cylinder axis
-	Vec3 axis = inCylinderB - inCylinderA;
-
-	// Make ray start relative to cylinder side A (moving cylinder A to the origin)
-	Vec3 start = -inCylinderA;
-
-	// Test if segment is fully on the A side of the cylinder
-	float start_dot_axis = start.Dot(axis);
-	float direction_dot_axis = inRayDirection.Dot(axis);
-	float end_dot_axis = start_dot_axis + direction_dot_axis;
-	if (start_dot_axis < 0.0f && end_dot_axis < 0.0f)
-		return FLT_MAX;
-
-	// Test if segment is fully on the B side of the cylinder
-	float axis_len_sq = axis.LengthSq();
-	if (start_dot_axis > axis_len_sq && end_dot_axis > axis_len_sq)
-		return FLT_MAX;
-
-	// Calculate a, b and c, the factors for quadratic equation
-	// We're basically solving the ray: x = start + direction * t
-	// The closest point to x on the segment A B is: w = (x . axis) * axis / (axis . axis)
-	// The distance between x and w should be radius: (x - w) . (x - w) = radius^2
-	// Solving this gives the following:
-	float a = axis_len_sq * inRayDirection.LengthSq() - Square(direction_dot_axis);
-	if (abs(a) < 1.0e-6f)
-		return FLT_MAX; // Segment runs parallel to cylinder axis, stop processing, we will either hit at fraction = 0 or we'll hit a vertex
-	float b = axis_len_sq * start.Dot(inRayDirection) - direction_dot_axis * start_dot_axis; // should be multiplied by 2, instead we'll divide a and c by 2 when we solve the quadratic equation
-	float c = axis_len_sq * (start.LengthSq() - Square(inRadius)) - Square(start_dot_axis);
-	float det = Square(b) - a * c; // normally 4 * a * c but since both a and c need to be divided by 2 we lose the 4
-	if (det < 0.0f)
-		return FLT_MAX; // No solution to quadratic equation
-
-	// Solve fraction t where the ray hits the cylinder
-	float t = -(b + sqrt(det)) / a; // normally divided by 2 * a but since a should be divided by 2 we lose the 2
-	if (t < 0.0f || t > 1.0f)
-		return FLT_MAX; // Intersection lies outside segment
-	if (start_dot_axis + t * direction_dot_axis < 0.0f || start_dot_axis + t * direction_dot_axis > axis_len_sq)
-		return FLT_MAX; // Intersection outside the end point of the cylinder, stop processing, we will possibly hit a vertex
-	return t;
-}
-
-void CastSphereVsTriangles::Cast(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, uint8 inActiveEdges, const SubShapeID &inSubShapeID2)
-{
-	// Scale triangle and make it relative to the start of the cast
-	Vec3 v0 = mScale * inV0 - mStart;
-	Vec3 v1 = mScale * inV1 - mStart;
-	Vec3 v2 = mScale * inV2 - mStart;
-
-	// Calculate triangle normal
-	Vec3 triangle_normal = mScaleSign * (v1 - v0).Cross(v2 - v0);
-	float triangle_normal_len = triangle_normal.Length();
-	if (triangle_normal_len == 0.0f)
-		return; // Degenerate triangle
-	triangle_normal /= triangle_normal_len;
-
-	// Backface check
-	float normal_dot_direction = triangle_normal.Dot(mDirection);
-	bool back_facing = normal_dot_direction > 0.0f;
-	if (mShapeCastSettings.mBackFaceModeTriangles == EBackFaceMode::IgnoreBackFaces && back_facing)
-		return;
-
-	// Test if distance between the sphere and plane of triangle is smaller or equal than the radius
-	if (abs(v0.Dot(triangle_normal)) <= mRadius)
-	{
-		// Check if the sphere intersects at the start of the cast
-		uint32 closest_feature;
-		Vec3 q = ClosestPoint::GetClosestPointOnTriangle(v0, v1, v2, closest_feature);
-		float q_len_sq = q.LengthSq();
-		if (q_len_sq <= Square(mRadius))
-		{
-			// Early out if this hit is deeper than the collector's early out value
-			float q_len = sqrt(q_len_sq);
-			float penetration_depth = mRadius - q_len;
-			if (-penetration_depth >= mCollector.GetEarlyOutFraction())
-				return;
-
-			// Generate contact point
-			Vec3 contact_normal = q_len > 0.0f? q / q_len : Vec3::sAxisY();
-			Vec3 contact_point_a = q + contact_normal * penetration_depth;
-			Vec3 contact_point_b = q;
-			AddHitWithActiveEdgeDetection(v0, v1, v2, back_facing, triangle_normal, inActiveEdges, inSubShapeID2, 0.0f, contact_point_a, contact_point_b, contact_normal);
-			return;
-		}
-	}
-	else
-	{
-		// Check if cast is not parallel to the plane of the triangle
-		float abs_normal_dot_direction = abs(normal_dot_direction);
-		if (abs_normal_dot_direction > 1.0e-6f)
-		{
-			// Calculate the point on the sphere that will hit the triangle's plane first and calculate a fraction where it will do so
-			Vec3 d = Sign(normal_dot_direction) * mRadius * triangle_normal;
-			float plane_intersection = (v0 - d).Dot(triangle_normal) / normal_dot_direction;
-
-			// Check if sphere will hit in the interval that we're interested in
-			if (plane_intersection * abs_normal_dot_direction < -mRadius	// Sphere hits the plane before the sweep, cannot intersect
-				|| plane_intersection >= mCollector.GetEarlyOutFraction())	// Sphere hits the plane after the sweep / early out fraction, cannot intersect
-				return;
-
-			// We can only report an interior hit if we're hitting the plane during our sweep and not before
-			if (plane_intersection >= 0.0f)
-			{
-				// Calculate the point of contact on the plane
-				Vec3 p = d + plane_intersection * mDirection;
-
-				// Check if this is an interior point
-				float u, v, w;
-				if (ClosestPoint::GetBaryCentricCoordinates(v0 - p, v1 - p, v2 - p, u, v, w)
-					&& u >= 0.0f && v >= 0.0f && w >= 0.0f)
-				{
-					// Interior point, we found the collision point. We don't need to check active edges.
-					AddHit(back_facing, inSubShapeID2, plane_intersection, p, p, back_facing? triangle_normal : -triangle_normal);
-					return;
-				}
-			}
-		}
-	}
-
-	// Test 3 edges
-	float fraction = RayCylinder(mDirection, v0, v1, mRadius);
-	fraction = min(fraction, RayCylinder(mDirection, v1, v2, mRadius));
-	fraction = min(fraction, RayCylinder(mDirection, v2, v0, mRadius));
-
-	// Test 3 vertices
-	fraction = min(fraction, RaySphere(Vec3::sZero(), mDirection, v0, mRadius));
-	fraction = min(fraction, RaySphere(Vec3::sZero(), mDirection, v1, mRadius));
-	fraction = min(fraction, RaySphere(Vec3::sZero(), mDirection, v2, mRadius));
-
-	// Check if we have a collision
-	JPH_ASSERT(fraction >= 0.0f);
-	if (fraction < mCollector.GetEarlyOutFraction())
-	{
-		// Calculate the center of the sphere at the point of contact
-		Vec3 p = fraction * mDirection;
-
-		// Get contact point and normal
-		uint32 closest_feature;
-		Vec3 q = ClosestPoint::GetClosestPointOnTriangle(v0 - p, v1 - p, v2 - p, closest_feature);
-		// The distance between p and the triangle should be mRadius, but for very long casts,
-		// floating point accuracy can become low enough so that p is on the plane and q is zero
-		Vec3 contact_normal = q.NormalizedOr(back_facing? triangle_normal : -triangle_normal);
-		Vec3 contact_point_ab = p + q;
-		AddHitWithActiveEdgeDetection(v0, v1, v2, back_facing, triangle_normal, inActiveEdges, inSubShapeID2, fraction, contact_point_ab, contact_point_ab, contact_normal);
-	}
-}
-
-JPH_NAMESPACE_END

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

@@ -1,49 +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/ShapeCast.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Collision detection helper that casts a sphere vs one or more triangles
-class JPH_EXPORT CastSphereVsTriangles
-{
-public:
-	/// Constructor
-	/// @param inShapeCast The sphere to cast against the triangles and its start and direction
-	/// @param inShapeCastSettings Settings for performing the cast
-	/// @param inScale Local space scale for the shape to cast against (scales relative to its center of mass).
-	/// @param inCenterOfMassTransform2 Is the center of mass transform of shape 2 (excluding scale), this is used to provide a transform to the shape cast result so that local quantities can be transformed into world space.
-	/// @param inSubShapeIDCreator1 Class that tracks the current sub shape ID for the casting shape
-	/// @param ioCollector The collector that receives the results.
-									CastSphereVsTriangles(const ShapeCast &inShapeCast, const ShapeCastSettings &inShapeCastSettings, Vec3Arg inScale, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, CastShapeCollector &ioCollector);
-
-	/// Cast 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							Cast(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, uint8 inActiveEdges, const SubShapeID &inSubShapeID2);
-
-protected:
-	Vec3							mStart;								///< Starting location of the sphere
-	Vec3							mDirection;							///< Direction and length of movement of sphere
-	float							mRadius;							///< Scaled radius of sphere
-	const ShapeCastSettings &		mShapeCastSettings;
-	const Mat44 &					mCenterOfMassTransform2;
-	Vec3							mScale;
-	SubShapeIDCreator				mSubShapeIDCreator1;
-	CastShapeCollector &			mCollector;
-
-private:
-	void							AddHit(bool inBackFacing, const SubShapeID &inSubShapeID2, float inFraction, Vec3Arg inContactPointA, Vec3Arg inContactPointB, Vec3Arg inContactNormal);
-	void							AddHitWithActiveEdgeDetection(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, bool inBackFacing, Vec3Arg inTriangleNormal, uint8 inActiveEdges, const SubShapeID &inSubShapeID2, float inFraction, Vec3Arg inContactPointA, Vec3Arg inContactPointB, Vec3Arg inContactNormal);
-	float							RayCylinder(Vec3Arg inRayDirection, Vec3Arg inCylinderA, Vec3Arg inCylinderB, float inRadius) const;
-
-	float							mScaleSign;							///< Sign of the scale, -1 if object is inside out, 1 if not
-};
-
-JPH_NAMESPACE_END

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

@@ -1,16 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// Whether or not to collect faces, used by CastShape and CollideShape
-enum class ECollectFacesMode : uint8
-{
-	CollectFaces,										///< mShape1/2Face is desired
-	NoFaces												///< mShape1/2Face is not desired
-};
-
-JPH_NAMESPACE_END

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

@@ -1,155 +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/CollideConvexVsTriangles.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/Geometry/EPAPenetrationDepth.h>
-#include <Jolt/Geometry/Plane.h>
-
-JPH_NAMESPACE_BEGIN
-
-CollideConvexVsTriangles::CollideConvexVsTriangles(const ConvexShape *inShape1, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeID &inSubShapeID1, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector) :
-	mCollideShapeSettings(inCollideShapeSettings),
-	mCollector(ioCollector),
-	mShape1(inShape1),
-	mScale1(inScale1),
-	mScale2(inScale2),
-	mTransform1(inCenterOfMassTransform1),
-	mSubShapeID1(inSubShapeID1)
-{
-	// Get transforms
-	Mat44 inverse_transform2 = inCenterOfMassTransform2.InversedRotationTranslation();
-	Mat44 transform1_to_2 = inverse_transform2 * inCenterOfMassTransform1;
-	mTransform2To1 = transform1_to_2.InversedRotationTranslation();
-
-	// Calculate bounds
-	mBoundsOf1 = inShape1->GetLocalBounds().Scaled(inScale1);
-	mBoundsOf1.ExpandBy(Vec3::sReplicate(inCollideShapeSettings.mMaxSeparationDistance));
-	mBoundsOf1InSpaceOf2 = mBoundsOf1.Transformed(transform1_to_2);	// Convert bounding box of 1 into space of 2
-
-	// Determine if shape 2 is inside out or not
-	mScaleSign2 = ScaleHelpers::IsInsideOut(inScale2)? -1.0f : 1.0f;
-}
-
-void CollideConvexVsTriangles::Collide(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, uint8 inActiveEdges, const SubShapeID &inSubShapeID2)
-{
-	// Scale triangle and transform it to the space of 1
-	Vec3 v0 = mTransform2To1 * (mScale2 * inV0);
-	Vec3 v1 = mTransform2To1 * (mScale2 * inV1);
-	Vec3 v2 = mTransform2To1 * (mScale2 * inV2);
-
-	// 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;
-
-	// Get bounding box for triangle
-	AABox triangle_bbox = AABox::sFromTwoPoints(v0, v1);
-	triangle_bbox.Encapsulate(v2);
-
-	// Get intersection between triangle and shape box, if there is none, we're done
-	if (!triangle_bbox.Overlaps(mBoundsOf1))
-		return;
-
-	// Create triangle support function
-	TriangleConvexSupport triangle(v0, v1, v2);
-
-	// Perform collision detection
-	// Note: As we don't remember the penetration axis from the last iteration, and it is likely that the shape (A) we're colliding the triangle (B) against is in front of the triangle,
-	// and the penetration axis is the shortest distance along to push B out of collision, we use the inverse of the triangle normal as an initial penetration axis. This has been seen
-	// to improve performance by approx. 5% over using a fixed axis like (1, 0, 0).
-	Vec3 penetration_axis = -triangle_normal, point1, point2;
-	EPAPenetrationDepth pen_depth;
-	EPAPenetrationDepth::EStatus status;
-
-	// Get the support function
-	if (mShape1ExCvxRadius == nullptr)
-		mShape1ExCvxRadius = mShape1->GetSupportFunction(ConvexShape::ESupportMode::ExcludeConvexRadius, mBufferExCvxRadius, mScale1);
-
-	// Perform GJK step
-	float max_separation_distance = mCollideShapeSettings.mMaxSeparationDistance;
-	status = pen_depth.GetPenetrationDepthStepGJK(*mShape1ExCvxRadius, mShape1ExCvxRadius->GetConvexRadius() + max_separation_distance, triangle, 0.0f, mCollideShapeSettings.mCollisionTolerance, penetration_axis, point1, point2);
-
-	// Check result of collision detection
-	if (status == EPAPenetrationDepth::EStatus::NotColliding)
-		return;
-	else if (status == EPAPenetrationDepth::EStatus::Indeterminate)
-	{
-		// Need to run expensive EPA algorithm
-
-		// We know we're overlapping at this point, so we can set the max separation distance to 0.
-		// Numerically it is possible that GJK finds that the shapes are overlapping but EPA finds that they're separated.
-		// In order to avoid this, we clamp the max separation distance to 1 so that we don't excessively inflate the shape,
-		// but we still inflate it enough to avoid the case where EPA misses the collision.
-		max_separation_distance = min(max_separation_distance, 1.0f);
-
-		// Get the support function
-		if (mShape1IncCvxRadius == nullptr)
-			mShape1IncCvxRadius = mShape1->GetSupportFunction(ConvexShape::ESupportMode::IncludeConvexRadius, mBufferIncCvxRadius, mScale1);
-
-		// Add convex radius
-		AddConvexRadius shape1_add_max_separation_distance(*mShape1IncCvxRadius, max_separation_distance);
-
-		// Perform EPA step
-		if (!pen_depth.GetPenetrationDepthStepEPA(shape1_add_max_separation_distance, triangle, mCollideShapeSettings.mPenetrationTolerance, penetration_axis, point1, point2))
-			return;
-	}
-
-	// Check if the penetration is bigger than the early out fraction
-	float penetration_depth = (point2 - point1).Length() - max_separation_distance;
-	if (-penetration_depth >= mCollector.GetEarlyOutFraction())
-		return;
-
-	// Correct point1 for the added separation distance
-	float penetration_axis_len = penetration_axis.Length();
-	if (penetration_axis_len > 0.0f)
-		point1 -= penetration_axis * (max_separation_distance / penetration_axis_len);
-
-	// Check if we have enabled active edge detection
-	if (mCollideShapeSettings.mActiveEdgeMode == EActiveEdgeMode::CollideOnlyWithActive && inActiveEdges != 0b111)
-	{
-		// Convert the active edge velocity hint to local space
-		Vec3 active_edge_movement_direction = mTransform1.Multiply3x3Transposed(mCollideShapeSettings.mActiveEdgeMovementDirection);
-
-		// Update the penetration axis to account for active edges
-		// Note that we flip the triangle normal as the penetration axis is pointing towards the triangle instead of away
-		penetration_axis = ActiveEdges::FixNormal(v0, v1, v2, back_facing? triangle_normal : -triangle_normal, inActiveEdges, point2, penetration_axis, active_edge_movement_direction);
-	}
-
-	// Convert to world space
-	point1 = mTransform1 * point1;
-	point2 = mTransform1 * point2;
-	Vec3 penetration_axis_world = mTransform1.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)
-	{
-		// Get supporting face of shape 1
-		mShape1->GetSupportingFace(SubShapeID(), -penetration_axis, mScale1, mTransform1, result.mShape1Face);
-
-		// Get face of the triangle
-		result.mShape2Face.resize(3);
-		result.mShape2Face[0] = mTransform1 * v0;
-		result.mShape2Face[1] = mTransform1 * v1;
-		result.mShape2Face[2] = mTransform1 * 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/CollideConvexVsTriangles.h

@@ -1,56 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Geometry/AABox.h>
-#include <Jolt/Physics/Collision/Shape/Shape.h>
-#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
-#include <Jolt/Physics/Collision/Shape/ConvexShape.h>
-
-JPH_NAMESPACE_BEGIN
-
-class CollideShapeSettings;
-
-/// Collision detection helper that collides a convex object vs one or more triangles
-class JPH_EXPORT CollideConvexVsTriangles
-{
-public:
-	/// Constructor
-	/// @param inShape1 The convex shape to collide against triangles
-	/// @param inScale1 Local space scale for the convex object (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
-									CollideConvexVsTriangles(const ConvexShape *inShape1, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeID &inSubShapeID1, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector);
-
-	/// Collide convex object 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 ConvexShape *				mShape1;								///< The shape that we're colliding with
-	Vec3							mScale1;								///< The scale of the shape (in shape local space) of the shape we're colliding with
-	Vec3							mScale2;								///< The scale of the shape (in shape local space) of the shape we're colliding against
-	Mat44							mTransform1;							///< Transform of the shape we're colliding with
-	Mat44							mTransform2To1;							///< Transform that takes a point in space of the colliding shape to the shape we're colliding with
-	AABox							mBoundsOf1;								///< Bounds of the colliding shape in local space
-	AABox							mBoundsOf1InSpaceOf2;					///< Bounds of the colliding shape in space of shape we're colliding with
-	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
-	ConvexShape::SupportBuffer		mBufferExCvxRadius;						///< Buffer that holds the support function data excluding convex radius
-	ConvexShape::SupportBuffer		mBufferIncCvxRadius;					///< Buffer that holds the support function data including convex radius
-	const ConvexShape::Support *	mShape1ExCvxRadius = nullptr;			///< Actual support function object excluding convex radius
-	const ConvexShape::Support *	mShape1IncCvxRadius = nullptr;			///< Actual support function object including convex radius
-};
-
-JPH_NAMESPACE_END

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

@@ -1,25 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Body/BodyID.h>
-#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Structure that holds the result of colliding a point against a shape
-class CollidePointResult
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Function required by the CollisionCollector. A smaller fraction is considered to be a 'better hit'. For point queries there is no sensible return value.
-	inline float	GetEarlyOutFraction() const			{ return 0.0f; }
-
-	BodyID			mBodyID;							///< Body that was hit
-	SubShapeID		mSubShapeID2;						///< Sub shape ID of shape that we collided against
-};
-
-JPH_NAMESPACE_END

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

@@ -1,106 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/StaticArray.h>
-#include <Jolt/Physics/Collision/BackFaceMode.h>
-#include <Jolt/Physics/Collision/ActiveEdgeMode.h>
-#include <Jolt/Physics/Collision/CollectFacesMode.h>
-#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
-#include <Jolt/Physics/Body/BodyID.h>
-#include <Jolt/Physics/PhysicsSettings.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Class that contains all information of two colliding shapes
-class CollideShapeResult
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Default constructor
-								CollideShapeResult() = default;
-
-	/// Constructor
-								CollideShapeResult(Vec3Arg inContactPointOn1, Vec3Arg inContactPointOn2, Vec3Arg inPenetrationAxis, float inPenetrationDepth, const SubShapeID &inSubShapeID1, const SubShapeID &inSubShapeID2, const BodyID &inBodyID2) :
-		mContactPointOn1(inContactPointOn1),
-		mContactPointOn2(inContactPointOn2),
-		mPenetrationAxis(inPenetrationAxis),
-		mPenetrationDepth(inPenetrationDepth),
-		mSubShapeID1(inSubShapeID1),
-		mSubShapeID2(inSubShapeID2),
-		mBodyID2(inBodyID2)
-	{
-	}
-
-	/// Function required by the CollisionCollector. A smaller fraction is considered to be a 'better hit'. We use -penetration depth to get the hit with the biggest penetration depth
-	inline float				GetEarlyOutFraction() const	{ return -mPenetrationDepth; }
-
-	/// Reverses the hit result, swapping contact point 1 with contact point 2 etc.
-	inline CollideShapeResult	Reversed() const
-	{
-		CollideShapeResult result;
-		result.mContactPointOn2 = mContactPointOn1;
-		result.mContactPointOn1 = mContactPointOn2;
-		result.mPenetrationAxis = -mPenetrationAxis;
-		result.mPenetrationDepth = mPenetrationDepth;
-		result.mSubShapeID2 = mSubShapeID1;
-		result.mSubShapeID1 = mSubShapeID2;
-		result.mBodyID2 = mBodyID2;
-		result.mShape2Face = mShape1Face;
-		result.mShape1Face = mShape2Face;
-		return result;
-	}
-
-	using Face = StaticArray<Vec3, 32>;
-
-	Vec3						mContactPointOn1;			///< Contact point on the surface of shape 1 (in world space or relative to base offset)
-	Vec3						mContactPointOn2;			///< Contact point on the surface of shape 2 (in world space or relative to base offset). If the penetration depth is 0, this will be the same as mContactPointOn1.
-	Vec3						mPenetrationAxis;			///< Direction to move shape 2 out of collision along the shortest path (magnitude is meaningless, in world space). You can use -mPenetrationAxis.Normalized() as contact normal.
-	float						mPenetrationDepth;			///< Penetration depth (move shape 2 by this distance to resolve the collision). If CollideShapeSettings::mMaxSeparationDistance > 0 this number can be negative to indicate that the objects are separated by -mPenetrationDepth. The contact points are the closest points in that case.
-	SubShapeID					mSubShapeID1;				///< Sub shape ID that identifies the face on shape 1
-	SubShapeID					mSubShapeID2;				///< Sub shape ID that identifies the face on shape 2
-	BodyID						mBodyID2;					///< BodyID to which shape 2 belongs to
-	Face						mShape1Face;				///< Colliding face on shape 1 (optional result, in world space or relative to base offset)
-	Face						mShape2Face;				///< Colliding face on shape 2 (optional result, in world space or relative to base offset)
-};
-
-/// Settings to be passed with a collision query
-class CollideSettingsBase
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// How active edges (edges that a moving object should bump into) are handled
-	EActiveEdgeMode				mActiveEdgeMode				= EActiveEdgeMode::CollideOnlyWithActive;
-
-	/// If colliding faces should be collected or only the collision point
-	ECollectFacesMode			mCollectFacesMode			= ECollectFacesMode::NoFaces;
-
-	/// If objects are closer than this distance, they are considered to be colliding (used for GJK) (unit: meter)
-	float						mCollisionTolerance			= cDefaultCollisionTolerance;
-
-	/// A factor that determines the accuracy of the penetration depth calculation. If the change of the squared distance is less than tolerance * current_penetration_depth^2 the algorithm will terminate. (unit: dimensionless)
-	float						mPenetrationTolerance		= cDefaultPenetrationTolerance;
-
-	/// When mActiveEdgeMode is CollideOnlyWithActive a movement direction can be provided. When hitting an inactive edge, the system will select the triangle normal as penetration depth only if it impedes the movement less than with the calculated penetration depth.
-	Vec3						mActiveEdgeMovementDirection = Vec3::sZero();
-};
-
-/// Settings to be passed with a collision query
-class CollideShapeSettings : public CollideSettingsBase
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// When > 0 contacts in the vicinity of the query shape can be found. All nearest contacts that are not further away than this distance will be found.
-	/// Note that in this case CollideShapeResult::mPenetrationDepth can become negative to indicate that objects are not overlapping. (unit: meter)
-	float						mMaxSeparationDistance		= 0.0f;
-
-	/// How backfacing triangles should be treated
-	EBackFaceMode				mBackFaceMode				= EBackFaceMode::IgnoreBackFaces;
-};
-
-JPH_NAMESPACE_END