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

src/core/TriangleSplitter.js

@@ -7,13 +7,23 @@
 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 {
@@ -109,6 +119,20 @@
 
 		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 ) {
 
@@ -133,25 +157,30 @@
 				// 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 +218,23 @@
 				// 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 +252,8 @@
 				}
 
 				// 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 +263,7 @@
 				// 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;