Fix EPA contact point for mesh triangles with long edges

When a convex shape collides with a mesh triangle whose edge length is
much larger than the penetration depth (e.g. ~84 m edge vs ~5 cm
penetration), EPA converges to the wrong Minkowski polytope facet due to
float32 precision loss. GetPenetrationDepthStepEPA returns true but
point2 can end up far from point1, producing degenerate contact data.

If point2 is farther from point1 than the query shape bounding-box
diagonal, snap it to the closest point on the triangle and update
penetration_axis. On the same geometry GJK can also return EStatus::Colliding
with a garbage point1; that is caught by checking point1 against a 2x-expanded
mBoundsOf1 and redirecting to EPA.

Reproducible with open-world game levels where large floor/wall tiles are
used directly as physics mesh geometry. Subdividing such meshes is not always
viable: the BVH codec has a hard size limit that is exceeded when large terrain
meshes are split to a safe edge length.

Regression test uses the exact triangle vertices from a production crash.
Requires CROSS_PLATFORM_DETERMINISTIC to reproduce; with FMA enabled the GJK
arithmetic avoids the bad path.

Author: AndreiPotapov

Jolt/Physics/Collision/CollideConvexVsTriangles.cpp

@@ -12,6 +12,7 @@
 #include <Jolt/Physics/Collision/NarrowPhaseStats.h>
 #include <Jolt/Geometry/EPAPenetrationDepth.h>
 #include <Jolt/Geometry/Plane.h>
+#include <Jolt/Geometry/ClosestPoint.h>
 
 JPH_NAMESPACE_BEGIN
 
@@ -83,7 +84,22 @@ void CollideConvexVsTriangles::Collide(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2,
 	// Check result of collision detection
 	if (status == EPAPenetrationDepth::EStatus::NotColliding)
 		return;
-	else if (status == EPAPenetrationDepth::EStatus::Indeterminate)
+
+	// When a mesh triangle has edges much longer than the query shape, GJK can compute
+	// wrong barycentric weights on the simplex (float32 cancellation in cross products of
+	// large vectors), returning Colliding with point1 far outside the shape's bounding box.
+	// Use a generous 2x tolerance so floating-point rounding at the boundary of large
+	// separation-distance shapes does not trigger a false positive.
+	// Treat it as Indeterminate so EPA re-derives the contact from scratch.
+	if (status == EPAPenetrationDepth::EStatus::Colliding)
+	{
+		Vec3 bounds_size = mBoundsOf1.mMax - mBoundsOf1.mMin;
+		AABox expanded_bounds(mBoundsOf1.mMin - bounds_size, mBoundsOf1.mMax + bounds_size);
+		if (!expanded_bounds.Contains(point1))
+			status = EPAPenetrationDepth::EStatus::Indeterminate;
+	}
+
+	if (status == EPAPenetrationDepth::EStatus::Indeterminate)
 	{
 		// Need to run expensive EPA algorithm
 
@@ -103,6 +119,18 @@ void CollideConvexVsTriangles::Collide(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2,
 		// Perform EPA step
 		if (!pen_depth.GetPenetrationDepthStepEPA(shape1_add_max_separation_distance, triangle, mCollideShapeSettings.mPenetrationTolerance, penetration_axis, point1, point2))
 			return;
+
+		// For triangles with edges much longer than the query shape, EPA can converge
+		// to the wrong facet and report point2 far from point1 (even snapped onto a far
+		// vertex of the triangle). A valid contact keeps point2 within the shape's size
+		// of point1; otherwise snap point2 to the closest point on the triangle.
+		Vec3 extent = mBoundsOf1.mMax - mBoundsOf1.mMin;
+		if ((point2 - point1).LengthSq() > extent.LengthSq())
+		{
+			uint32 set;
+			point2 = ClosestPoint::GetClosestPointOnTriangle(v0 - point1, v1 - point1, v2 - point1, set) + point1;
+			penetration_axis = point2 - point1;
+		}
 	}
 
 	// Check if the penetration is bigger than the early out fraction

UnitTests/Physics/ConvexVsTrianglesTest.cpp

@@ -5,6 +5,7 @@
 #include "UnitTestFramework.h"
 #include "PhysicsTestContext.h"
 #include <Jolt/Physics/Collision/Shape/SphereShape.h>
+#include <Jolt/Physics/Collision/Shape/CapsuleShape.h>
 #include <Jolt/Physics/Collision/Shape/TriangleShape.h>
 #include <Jolt/Physics/Collision/Shape/MeshShape.h>
 #include <Jolt/Physics/Collision/CollideShape.h>
@@ -358,4 +359,58 @@ TEST_SUITE("ConvexVsTrianglesTest")
 	{
 		sTestConvexVsTriangles<CollideSphereVsTriangles>();
 	}
+
+	// Regression test for EPA producing a degenerate contact when the mesh triangle has
+	// a very long edge relative to the query shape.  In production a ~200 m needle triangle
+	// against a 0.25 m capsule caused EPA to converge to the wrong Minkowski polytope facet
+	// (float32 precision loss in cross products of 200 m vectors) and report point2 ~100 m
+	// from point1, failing a downstream sanity assert.
+	TEST_CASE("TestCapsuleVsNeedleTriangle")
+	{
+		// CapsuleShape from the crash dump: halfHeight=0.5, radius=0.25.
+		Ref<CapsuleShape> capsule = new CapsuleShape(0.5f, 0.25f);
+
+		Mat44 transform1 = Mat44::sIdentity();
+		Mat44 transform2 = Mat44::sIdentity();
+
+		Vec3 inV0(0.252283931f, -172.936920f, -0.093847394f);
+		Vec3 inV1(0.242991686f,   27.608593f, -0.127187848f);
+		Vec3 inV2(0.228017807f,   27.608591f, -0.140446782f);
+
+		CollideShapeSettings settings;
+		settings.mBackFaceMode          = EBackFaceMode::IgnoreBackFaces;
+		settings.mActiveEdgeMode        = EActiveEdgeMode::CollideOnlyWithActive;
+		settings.mCollisionTolerance    = 1.0e-4f;
+		settings.mPenetrationTolerance  = 1.0e-4f;
+		settings.mMaxSeparationDistance = 0.05f;
+
+		AllHitCollisionCollector<CollideShapeCollector> collector;
+		CollideConvexVsTriangles collider(capsule, Vec3::sOne(), Vec3::sOne(),
+			transform1, transform2,
+			SubShapeID(), settings, collector);
+		collider.Collide(inV0, inV1, inV2, 0b011, SubShapeID());
+
+		CHECK(collector.mHits.size() == 1);
+		if (collector.mHits.empty()) return;
+		const CollideShapeResult &hit = collector.mHits[0];
+
+		// Without the fix, EPA snaps point2 to a far triangle vertex ~100 m from point1,
+		// giving mPenetrationDepth ~ -100 m.  With the fix the contact must lie within
+		// the capsule's own size (radius 0.25 + halfHeight 0.5 = 0.75 m; 2x as margin).
+		float capsule_max_extent = 2.0f * (0.5f + 0.25f); // 1.5 m
+		CHECK(hit.mPenetrationDepth > -capsule_max_extent);
+		CHECK(hit.mPenetrationDepth < capsule_max_extent);
+
+		// point2 must be close to point1, not 100 m away.
+		float dist = (hit.mContactPointOn2 - hit.mContactPointOn1).Length();
+		CHECK(dist < capsule_max_extent);
+
+		// The penetration axis must point from the capsule towards the triangle, i.e.
+		// against the triangle's (v1-v0)x(v2-v0) normal (the capsule center sits on the
+		// positive-normal side of the triangle plane).  Guards the contact normal that
+		// feeds collision response from coming out backwards.
+		Vec3 triangle_normal = (inV1 - inV0).Cross(inV2 - inV0);
+		CHECK(hit.mPenetrationAxis.Dot(triangle_normal) < 0.0f);
+	}
+
 }