[FIX] Coplanarity test - uncertainty issue - see https://github.com/g…

src/core/TriangleSplitter.js

@@ -7,13 +7,23 @@ import { isTriDegenerate } from './utils/triangleUtils.js';
 const EPSILON = 1e-10;
 const COPLANAR_EPSILON = 1e-10;
 const PARALLEL_EPSILON = 1e-10;
+const COPLANAR_EPSILON_MAX = 1e-4;
+//*/
+
+// XAVIER: increase epsilon values:
+/*const EPSILON = 1e-5;
+const COPLANAR_EPSILON = 1e-5;
+const PARALLEL_EPSILON = 1e-5; //*/
+
 const _edge = new Line3();
 const _foundEdge = new Line3();
 const _vec = new Vector3();
 const _triangleNormal = new Vector3();
 const _planeNormal = new Vector3();
 const _plane = new Plane();
 const _splittingTriangle = new ExtendedTriangle();
+const _planeCenter = new Vector3();
+let _minEdgeSize = Infinity;
 
 // A pool of triangles to avoid unnecessary triangle creation
 class TrianglePool {
@@ -110,6 +120,23 @@ export class TriangleSplitter {
 		const { normal, triangles } = this;
 		triangle.getNormal( _triangleNormal ).normalize();
 
+		// compute triangleMinEdgeSize:
+		let triangleMinEdgeSizeSq = Infinity;
+		const arr = [ triangle.a, triangle.b, triangle.c ];
+		for ( let i = 0; i < 3; i ++ ) {
+
+			const nexti = ( i + 1 ) % 3;
+			const v0 = arr[ i ];
+			const v1 = arr[ nexti ];
+			const edgeSizeSq = v0.distanceToSquared( v1 );
+			triangleMinEdgeSizeSq = Math.min( triangleMinEdgeSizeSq, edgeSizeSq );
+
+		}
+
+		const triangleMinEdgeSize = Math.sqrt( triangleMinEdgeSizeSq );
+		_minEdgeSize = triangleMinEdgeSize;
+
+
 		if ( Math.abs( 1.0 - Math.abs( _triangleNormal.dot( normal ) ) ) < PARALLEL_EPSILON ) {
 
 			this.coplanarTriangleUsed = true;
@@ -133,25 +160,30 @@ export class TriangleSplitter {
 				// plane positive direction is toward triangle center
 				_vec.subVectors( v1, v0 ).normalize();
 				_planeNormal.crossVectors( _triangleNormal, _vec );
+				_minEdgeSize = Math.min( triangleMinEdgeSize, v1.distanceTo( v0 ) );
 				_plane.setFromNormalAndCoplanarPoint( _planeNormal, v0 );
+				_planeCenter.copy( v0 );
 
-				this.splitByPlane( _plane, triangle );
+				// we need to provide planeCenter and minEdgeSize to evaluate the plane uncertainty
+				// the smaller minEdgeSize is, the higher is the uncertainty
+				// the larger from planeCenter we are, the higher is the uncertainty
+				this.splitByPlane( _plane, _planeCenter, _minEdgeSize, triangle );
 
 			}
 
 		} else {
 
 			// otherwise split by the triangle plane
 			triangle.getPlane( _plane );
-			this.splitByPlane( _plane, triangle );
+			this.splitByPlane( _plane, _planeCenter, _minEdgeSize, triangle );
 
 		}
 
 	}
 
 	// Split the triangles by the given plan. If a triangle is provided then we ensure we
 	// intersect the triangle before splitting the plane
-	splitByPlane( plane, clippingTriangle ) {
+	splitByPlane( plane, planeCenter, planeEdgeSize, clippingTriangle ) {
 
 		const { triangles, trianglePool } = this;
 
@@ -189,7 +221,28 @@ export class TriangleSplitter {
 				// so we can use that information to determine whether to split later.
 				const startDist = plane.distanceToPoint( _edge.start );
 				const endDist = plane.distanceToPoint( _edge.end );
-				if ( Math.abs( startDist ) < COPLANAR_EPSILON && Math.abs( endDist ) < COPLANAR_EPSILON ) {
+				let coPlanarEpsilonStart = COPLANAR_EPSILON *	Math.max( 1, 0.5 * _edge.start.distanceTo( planeCenter ) / planeEdgeSize );
+				let coPlanarEpsilonEnd = COPLANAR_EPSILON *	Math.max( 1, 0.5 * _edge.end.distanceTo( planeCenter ) / planeEdgeSize );
+
+				if ( coPlanarEpsilonStart > COPLANAR_EPSILON_MAX ) {
+
+					coPlanarEpsilonStart = COPLANAR_EPSILON_MAX;
+					console.warn( 'High coplanar epsilon start because of degenerate faces' );
+
+				}
+
+				if ( coPlanarEpsilonEnd > COPLANAR_EPSILON_MAX ) {
+
+					coPlanarEpsilonEnd = COPLANAR_EPSILON_MAX;
+					console.warn( 'High coplanar epsilon end because of degenerate faces' );
+
+				}
+
+				if ( Math.abs( startDist ) < coPlanarEpsilonStart && Math.abs( endDist ) < coPlanarEpsilonEnd ) {
+
+					// we project the edge in the plane
+					plane.projectPoint( _edge.start, arr[ t ] );
+					plane.projectPoint( _edge.end, arr[ tNext ] );
 
 					coplanarEdge = true;
 					break;
@@ -207,8 +260,9 @@ export class TriangleSplitter {
 				}
 
 				// we only don't consider this an intersection if the start points hits the plane
-				if ( Math.abs( startDist ) < COPLANAR_EPSILON ) {
+				if ( Math.abs( startDist ) < coPlanarEpsilonStart ) {
 
+					plane.projectPoint( _edge.start, arr[ t ] );
 					continue;
 
 				}
@@ -218,7 +272,7 @@ export class TriangleSplitter {
 				// Because we ignore the start point intersection above we have to make sure we check the end
 				// point intersection here.
 				let didIntersect = ! ! plane.intersectLine( _edge, _vec );
-				if ( ! didIntersect && Math.abs( endDist ) < COPLANAR_EPSILON ) {
+				if ( ! didIntersect && Math.abs( endDist ) < coPlanarEpsilonEnd ) {
 
 					_vec.copy( _edge.end );
 					didIntersect = true;