@needle-tools/three 0.145.4 → 0.146.2

package/examples/js/math/ConvexHull.js

@@ -6,25 +6,19 @@
 
 	const Visible = 0;
 	const Deleted = 1;
-
 	const _v1 = new THREE.Vector3();
-
 	const _line3 = new THREE.Line3();
-
 	const _plane = new THREE.Plane();
-
 	const _closestPoint = new THREE.Vector3();
-
 	const _triangle = new THREE.Triangle();
-
 	class ConvexHull {
 
 		constructor() {
 
 			this.tolerance = - 1;
 			this.faces = []; // the generated faces of the convex hull
-
 			this.newFaces = []; // this array holds the faces that are generated within a single iteration
+
 			// the vertex lists work as follows:
 			//
 			// let 'a' and 'b' be 'Face' instances
@@ -35,7 +29,6 @@
 			//      |             |
 			//  a.outside     b.outside
 			//
-
 			this.assigned = new VertexList();
 			this.unassigned = new VertexList();
 			this.vertices = []; // vertices of the hull (internal representation of given geometry data)
@@ -45,10 +38,10 @@
 		setFromPoints( points ) {
 
 			// The algorithm needs at least four points.
+
 			if ( points.length >= 4 ) {
 
 				this.makeEmpty();
-
 				for ( let i = 0, l = points.length; i < l; i ++ ) {
 
 					this.vertices.push( new VertexNode( points[ i ] ) );
@@ -62,7 +55,6 @@
 			return this;
 
 		}
-
 		setFromObject( object ) {
 
 			const points = [];
@@ -70,11 +62,9 @@
 			object.traverse( function ( node ) {
 
 				const geometry = node.geometry;
-
 				if ( geometry !== undefined ) {
 
 					const attribute = geometry.attributes.position;
-
 					if ( attribute !== undefined ) {
 
 						for ( let i = 0, l = attribute.count; i < l; i ++ ) {
@@ -93,14 +83,14 @@
 			return this.setFromPoints( points );
 
 		}
-
 		containsPoint( point ) {
 
 			const faces = this.faces;
-
 			for ( let i = 0, l = faces.length; i < l; i ++ ) {
 
-				const face = faces[ i ]; // compute signed distance and check on what half space the point lies
+				const face = faces[ i ];
+
+				// compute signed distance and check on what half space the point lies
 
 				if ( face.distanceToPoint( point ) > this.tolerance ) return false;
 
@@ -109,37 +99,48 @@
 			return true;
 
 		}
-
 		intersectRay( ray, target ) {
 
 			// based on "Fast Ray-Convex Polyhedron Intersection"  by Eric Haines, GRAPHICS GEMS II
+
 			const faces = this.faces;
 			let tNear = - Infinity;
 			let tFar = Infinity;
-
 			for ( let i = 0, l = faces.length; i < l; i ++ ) {
 
-				const face = faces[ i ]; // interpret faces as planes for the further computation
+				const face = faces[ i ];
+
+				// interpret faces as planes for the further computation
 
 				const vN = face.distanceToPoint( ray.origin );
-				const vD = face.normal.dot( ray.direction ); // if the origin is on the positive side of a plane (so the plane can "see" the origin) and
+				const vD = face.normal.dot( ray.direction );
+
+				// if the origin is on the positive side of a plane (so the plane can "see" the origin) and
 				// the ray is turned away or parallel to the plane, there is no intersection
 
-				if ( vN > 0 && vD >= 0 ) return null; // compute the distance from the ray’s origin to the intersection with the plane
+				if ( vN > 0 && vD >= 0 ) return null;
 
-				const t = vD !== 0 ? - vN / vD : 0; // only proceed if the distance is positive. a negative distance means the intersection point
+				// compute the distance from the ray’s origin to the intersection with the plane
+
+				const t = vD !== 0 ? - vN / vD : 0;
+
+				// only proceed if the distance is positive. a negative distance means the intersection point
 				// lies "behind" the origin
 
-				if ( t <= 0 ) continue; // now categorized plane as front-facing or back-facing
+				if ( t <= 0 ) continue;
+
+				// now categorized plane as front-facing or back-facing
 
 				if ( vD > 0 ) {
 
 					//  plane faces away from the ray, so this plane is a back-face
+
 					tFar = Math.min( t, tFar );
 
 				} else {
 
 					// front-face
+
 					tNear = Math.max( t, tNear );
 
 				}
@@ -147,13 +148,16 @@
 				if ( tNear > tFar ) {
 
 					// if tNear ever is greater than tFar, the ray must miss the convex hull
+
 					return null;
 
 				}
 
-			} // evaluate intersection point
-			// always try tNear first since its the closer intersection point
+			}
 
+			// evaluate intersection point
+
+			// always try tNear first since its the closer intersection point
 
 			if ( tNear !== - Infinity ) {
 
@@ -168,26 +172,24 @@
 			return target;
 
 		}
-
 		intersectsRay( ray ) {
 
 			return this.intersectRay( ray, _v1 ) !== null;
 
 		}
-
 		makeEmpty() {
 
 			this.faces = [];
 			this.vertices = [];
 			return this;
 
-		} // Adds a vertex to the 'assigned' list of vertices and assigns it to the given face
+		}
 
+		// Adds a vertex to the 'assigned' list of vertices and assigns it to the given face
 
 		addVertexToFace( vertex, face ) {
 
 			vertex.face = face;
-
 			if ( face.outside === null ) {
 
 				this.assigned.append( vertex );
@@ -201,22 +203,26 @@
 			face.outside = vertex;
 			return this;
 
-		} // Removes a vertex from the 'assigned' list of vertices and from the given face
+		}
 
+		// Removes a vertex from the 'assigned' list of vertices and from the given face
 
 		removeVertexFromFace( vertex, face ) {
 
 			if ( vertex === face.outside ) {
 
 				// fix face.outside link
+
 				if ( vertex.next !== null && vertex.next.face === face ) {
 
 					// face has at least 2 outside vertices, move the 'outside' reference
+
 					face.outside = vertex.next;
 
 				} else {
 
 					// vertex was the only outside vertex that face had
+
 					face.outside = null;
 
 				}
@@ -226,24 +232,27 @@
 			this.assigned.remove( vertex );
 			return this;
 
-		} // Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list
+		}
 
+		// Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list
 
 		removeAllVerticesFromFace( face ) {
 
 			if ( face.outside !== null ) {
 
 				// reference to the first and last vertex of this face
+
 				const start = face.outside;
 				let end = face.outside;
-
 				while ( end.next !== null && end.next.face === face ) {
 
 					end = end.next;
 
 				}
 
-				this.assigned.removeSubList( start, end ); // fix references
+				this.assigned.removeSubList( start, end );
+
+				// fix references
 
 				start.prev = end.next = null;
 				face.outside = null;
@@ -251,31 +260,35 @@
 
 			}
 
-		} // Removes all the visible vertices that 'face' is able to see
+		}
 
+		// Removes all the visible vertices that 'face' is able to see
 
 		deleteFaceVertices( face, absorbingFace ) {
 
 			const faceVertices = this.removeAllVerticesFromFace( face );
-
 			if ( faceVertices !== undefined ) {
 
 				if ( absorbingFace === undefined ) {
 
 					// mark the vertices to be reassigned to some other face
+
 					this.unassigned.appendChain( faceVertices );
 
 				} else {
 
 					// if there's an absorbing face try to assign as many vertices as possible to it
-					let vertex = faceVertices;
 
+					let vertex = faceVertices;
 					do {
 
 						// we need to buffer the subsequent vertex at this point because the 'vertex.next' reference
 						// will be changed by upcoming method calls
+
 						const nextVertex = vertex.next;
-						const distance = absorbingFace.distanceToPoint( vertex.point ); // check if 'vertex' is able to see 'absorbingFace'
+						const distance = absorbingFace.distanceToPoint( vertex.point );
+
+						// check if 'vertex' is able to see 'absorbingFace'
 
 						if ( distance > this.tolerance ) {
 
@@ -285,8 +298,9 @@
 
 							this.unassigned.append( vertex );
 
-						} // now assign next vertex
+						}
 
+						// now assign next vertex
 
 						vertex = nextVertex;
 
@@ -298,30 +312,28 @@
 
 			return this;
 
-		} // Reassigns as many vertices as possible from the unassigned list to the new faces
+		}
 
+		// Reassigns as many vertices as possible from the unassigned list to the new faces
 
 		resolveUnassignedPoints( newFaces ) {
 
 			if ( this.unassigned.isEmpty() === false ) {
 
 				let vertex = this.unassigned.first();
-
 				do {
 
 					// buffer 'next' reference, see .deleteFaceVertices()
+
 					const nextVertex = vertex.next;
 					let maxDistance = this.tolerance;
 					let maxFace = null;
-
 					for ( let i = 0; i < newFaces.length; i ++ ) {
 
 						const face = newFaces[ i ];
-
 						if ( face.mark === Visible ) {
 
 							const distance = face.distanceToPoint( vertex.point );
-
 							if ( distance > maxDistance ) {
 
 								maxDistance = distance;
@@ -333,8 +345,9 @@
 
 						}
 
-					} // 'maxFace' can be null e.g. if there are identical vertices
+					}
 
+					// 'maxFace' can be null e.g. if there are identical vertices
 
 					if ( maxFace !== null ) {
 
@@ -350,15 +363,18 @@
 
 			return this;
 
-		} // Computes the extremes of a simplex which will be the initial hull
+		}
 
+		// Computes the extremes of a simplex which will be the initial hull
 
 		computeExtremes() {
 
 			const min = new THREE.Vector3();
 			const max = new THREE.Vector3();
 			const minVertices = [];
-			const maxVertices = []; // initially assume that the first vertex is the min/max
+			const maxVertices = [];
+
+			// initially assume that the first vertex is the min/max
 
 			for ( let i = 0; i < 3; i ++ ) {
 
@@ -367,12 +383,16 @@
 			}
 
 			min.copy( this.vertices[ 0 ].point );
-			max.copy( this.vertices[ 0 ].point ); // compute the min/max vertex on all six directions
+			max.copy( this.vertices[ 0 ].point );
+
+			// compute the min/max vertex on all six directions
 
 			for ( let i = 0, l = this.vertices.length; i < l; i ++ ) {
 
 				const vertex = this.vertices[ i ];
-				const point = vertex.point; // update the min coordinates
+				const point = vertex.point;
+
+				// update the min coordinates
 
 				for ( let j = 0; j < 3; j ++ ) {
 
@@ -383,8 +403,9 @@
 
 					}
 
-				} // update the max coordinates
+				}
 
+				// update the max coordinates
 
 				for ( let j = 0; j < 3; j ++ ) {
 
@@ -397,8 +418,9 @@
 
 				}
 
-			} // use min/max vectors to compute an optimal epsilon
+			}
 
+			// use min/max vectors to compute an optimal epsilon
 
 			this.tolerance = 3 * Number.EPSILON * ( Math.max( Math.abs( min.x ), Math.abs( max.x ) ) + Math.max( Math.abs( min.y ), Math.abs( max.y ) ) + Math.max( Math.abs( min.z ), Math.abs( max.z ) ) );
 			return {
@@ -406,27 +428,28 @@
 				max: maxVertices
 			};
 
-		} // Computes the initial simplex assigning to its faces all the points
-		// that are candidates to form part of the hull
+		}
 
+		// Computes the initial simplex assigning to its faces all the points
+		// that are candidates to form part of the hull
 
 		computeInitialHull() {
 
 			const vertices = this.vertices;
 			const extremes = this.computeExtremes();
 			const min = extremes.min;
-			const max = extremes.max; // 1. Find the two vertices 'v0' and 'v1' with the greatest 1d separation
+			const max = extremes.max;
+
+			// 1. Find the two vertices 'v0' and 'v1' with the greatest 1d separation
 			// (max.x - min.x)
 			// (max.y - min.y)
 			// (max.z - min.z)
 
 			let maxDistance = 0;
 			let index = 0;
-
 			for ( let i = 0; i < 3; i ++ ) {
 
 				const distance = max[ i ].point.getComponent( i ) - min[ i ].point.getComponent( i );
-
 				if ( distance > maxDistance ) {
 
 					maxDistance = distance;
@@ -439,22 +462,19 @@
 			const v0 = min[ index ];
 			const v1 = max[ index ];
 			let v2;
-			let v3; // 2. The next vertex 'v2' is the one farthest to the line formed by 'v0' and 'v1'
+			let v3;
 
-			maxDistance = 0;
+			// 2. The next vertex 'v2' is the one farthest to the line formed by 'v0' and 'v1'
 
+			maxDistance = 0;
 			_line3.set( v0.point, v1.point );
-
 			for ( let i = 0, l = this.vertices.length; i < l; i ++ ) {
 
 				const vertex = vertices[ i ];
-
 				if ( vertex !== v0 && vertex !== v1 ) {
 
 					_line3.closestPointToPoint( vertex.point, true, _closestPoint );
-
 					const distance = _closestPoint.distanceToSquared( vertex.point );
-
 					if ( distance > maxDistance ) {
 
 						maxDistance = distance;
@@ -464,21 +484,18 @@
 
 				}
 
-			} // 3. The next vertex 'v3' is the one farthest to the plane 'v0', 'v1', 'v2'
+			}
 
+			// 3. The next vertex 'v3' is the one farthest to the plane 'v0', 'v1', 'v2'
 
 			maxDistance = - 1;
-
 			_plane.setFromCoplanarPoints( v0.point, v1.point, v2.point );
-
 			for ( let i = 0, l = this.vertices.length; i < l; i ++ ) {
 
 				const vertex = vertices[ i ];
-
 				if ( vertex !== v0 && vertex !== v1 && vertex !== v2 ) {
 
 					const distance = Math.abs( _plane.distanceToPoint( vertex.point ) );
-
 					if ( distance > maxDistance ) {
 
 						maxDistance = distance;
@@ -491,17 +508,23 @@
 			}
 
 			const faces = [];
-
 			if ( _plane.distanceToPoint( v3.point ) < 0 ) {
 
 				// the face is not able to see the point so 'plane.normal' is pointing outside the tetrahedron
-				faces.push( Face.create( v0, v1, v2 ), Face.create( v3, v1, v0 ), Face.create( v3, v2, v1 ), Face.create( v3, v0, v2 ) ); // set the twin edge
+
+				faces.push( Face.create( v0, v1, v2 ), Face.create( v3, v1, v0 ), Face.create( v3, v2, v1 ), Face.create( v3, v0, v2 ) );
+
+				// set the twin edge
 
 				for ( let i = 0; i < 3; i ++ ) {
 
-					const j = ( i + 1 ) % 3; // join face[ i ] i > 0, with the first face
+					const j = ( i + 1 ) % 3;
 
-					faces[ i + 1 ].getEdge( 2 ).setTwin( faces[ 0 ].getEdge( j ) ); // join face[ i ] with face[ i + 1 ], 1 <= i <= 3
+					// join face[ i ] i > 0, with the first face
+
+					faces[ i + 1 ].getEdge( 2 ).setTwin( faces[ 0 ].getEdge( j ) );
+
+					// join face[ i ] with face[ i + 1 ], 1 <= i <= 3
 
 					faces[ i + 1 ].getEdge( 1 ).setTwin( faces[ j + 1 ].getEdge( 0 ) );
 
@@ -510,41 +533,47 @@
 			} else {
 
 				// the face is able to see the point so 'plane.normal' is pointing inside the tetrahedron
-				faces.push( Face.create( v0, v2, v1 ), Face.create( v3, v0, v1 ), Face.create( v3, v1, v2 ), Face.create( v3, v2, v0 ) ); // set the twin edge
+
+				faces.push( Face.create( v0, v2, v1 ), Face.create( v3, v0, v1 ), Face.create( v3, v1, v2 ), Face.create( v3, v2, v0 ) );
+
+				// set the twin edge
 
 				for ( let i = 0; i < 3; i ++ ) {
 
-					const j = ( i + 1 ) % 3; // join face[ i ] i > 0, with the first face
+					const j = ( i + 1 ) % 3;
+
+					// join face[ i ] i > 0, with the first face
+
+					faces[ i + 1 ].getEdge( 2 ).setTwin( faces[ 0 ].getEdge( ( 3 - i ) % 3 ) );
 
-					faces[ i + 1 ].getEdge( 2 ).setTwin( faces[ 0 ].getEdge( ( 3 - i ) % 3 ) ); // join face[ i ] with face[ i + 1 ]
+					// join face[ i ] with face[ i + 1 ]
 
 					faces[ i + 1 ].getEdge( 0 ).setTwin( faces[ j + 1 ].getEdge( 1 ) );
 
 				}
 
-			} // the initial hull is the tetrahedron
+			}
 
+			// the initial hull is the tetrahedron
 
 			for ( let i = 0; i < 4; i ++ ) {
 
 				this.faces.push( faces[ i ] );
 
-			} // initial assignment of vertices to the faces of the tetrahedron
+			}
 
+			// initial assignment of vertices to the faces of the tetrahedron
 
 			for ( let i = 0, l = vertices.length; i < l; i ++ ) {
 
 				const vertex = vertices[ i ];
-
 				if ( vertex !== v0 && vertex !== v1 && vertex !== v2 && vertex !== v3 ) {
 
 					maxDistance = this.tolerance;
 					let maxFace = null;
-
 					for ( let j = 0; j < 4; j ++ ) {
 
 						const distance = this.faces[ j ].distanceToPoint( vertex.point );
-
 						if ( distance > maxDistance ) {
 
 							maxDistance = distance;
@@ -566,17 +595,16 @@
 
 			return this;
 
-		} // Removes inactive faces
+		}
 
+		// Removes inactive faces
 
 		reindexFaces() {
 
 			const activeFaces = [];
-
 			for ( let i = 0; i < this.faces.length; i ++ ) {
 
 				const face = this.faces[ i ];
-
 				if ( face.mark === Visible ) {
 
 					activeFaces.push( face );
@@ -588,24 +616,29 @@
 			this.faces = activeFaces;
 			return this;
 
-		} // Finds the next vertex to create faces with the current hull
+		}
 
+		// Finds the next vertex to create faces with the current hull
 
 		nextVertexToAdd() {
 
 			// if the 'assigned' list of vertices is empty, no vertices are left. return with 'undefined'
+
 			if ( this.assigned.isEmpty() === false ) {
 
 				let eyeVertex,
-					maxDistance = 0; // grap the first available face and start with the first visible vertex of that face
+					maxDistance = 0;
+
+				// grap the first available face and start with the first visible vertex of that face
 
 				const eyeFace = this.assigned.first().face;
-				let vertex = eyeFace.outside; // now calculate the farthest vertex that face can see
+				let vertex = eyeFace.outside;
+
+				// now calculate the farthest vertex that face can see
 
 				do {
 
 					const distance = eyeFace.distanceToPoint( vertex.point );
-
 					if ( distance > maxDistance ) {
 
 						maxDistance = distance;
@@ -621,18 +654,19 @@
 
 			}
 
-		} // Computes a chain of half edges in CCW order called the 'horizon'.
+		}
+
+		// Computes a chain of half edges in CCW order called the 'horizon'.
 		// For an edge to be part of the horizon it must join a face that can see
 		// 'eyePoint' and a face that cannot see 'eyePoint'.
 
-
 		computeHorizon( eyePoint, crossEdge, face, horizon ) {
 
 			// moves face's vertices to the 'unassigned' vertex list
+
 			this.deleteFaceVertices( face );
 			face.mark = Deleted;
 			let edge;
-
 			if ( crossEdge === null ) {
 
 				edge = crossEdge = face.getEdge( 0 );
@@ -641,6 +675,7 @@
 
 				// start from the next edge since 'crossEdge' was already analyzed
 				// (actually 'crossEdge.twin' was the edge who called this method recursively)
+
 				edge = crossEdge.next;
 
 			}
@@ -649,17 +684,18 @@
 
 				const twinEdge = edge.twin;
 				const oppositeFace = twinEdge.face;
-
 				if ( oppositeFace.mark === Visible ) {
 
 					if ( oppositeFace.distanceToPoint( eyePoint ) > this.tolerance ) {
 
 						// the opposite face can see the vertex, so proceed with next edge
+
 						this.computeHorizon( eyePoint, twinEdge, oppositeFace, horizon );
 
 					} else {
 
 						// the opposite face can't see the vertex, so this edge is part of the horizon
+
 						horizon.push( edge );
 
 					}
@@ -672,34 +708,39 @@
 
 			return this;
 
-		} // Creates a face with the vertices 'eyeVertex.point', 'horizonEdge.tail' and 'horizonEdge.head' in CCW order
+		}
 
+		// Creates a face with the vertices 'eyeVertex.point', 'horizonEdge.tail' and 'horizonEdge.head' in CCW order
 
 		addAdjoiningFace( eyeVertex, horizonEdge ) {
 
 			// all the half edges are created in ccw order thus the face is always pointing outside the hull
+
 			const face = Face.create( eyeVertex, horizonEdge.tail(), horizonEdge.head() );
-			this.faces.push( face ); // join face.getEdge( - 1 ) with the horizon's opposite edge face.getEdge( - 1 ) = face.getEdge( 2 )
+			this.faces.push( face );
+
+			// join face.getEdge( - 1 ) with the horizon's opposite edge face.getEdge( - 1 ) = face.getEdge( 2 )
 
 			face.getEdge( - 1 ).setTwin( horizonEdge.twin );
 			return face.getEdge( 0 ); // the half edge whose vertex is the eyeVertex
 
-		} //  Adds 'horizon.length' faces to the hull, each face will be linked with the
-		//  horizon opposite face and the face on the left/right
+		}
 
+		//  Adds 'horizon.length' faces to the hull, each face will be linked with the
+		//  horizon opposite face and the face on the left/right
 
 		addNewFaces( eyeVertex, horizon ) {
 
 			this.newFaces = [];
 			let firstSideEdge = null;
 			let previousSideEdge = null;
-
 			for ( let i = 0; i < horizon.length; i ++ ) {
 
-				const horizonEdge = horizon[ i ]; // returns the right side edge
+				const horizonEdge = horizon[ i ];
 
-				const sideEdge = this.addAdjoiningFace( eyeVertex, horizonEdge );
+				// returns the right side edge
 
+				const sideEdge = this.addAdjoiningFace( eyeVertex, horizonEdge );
 				if ( firstSideEdge === null ) {
 
 					firstSideEdge = sideEdge;
@@ -707,6 +748,7 @@
 				} else {
 
 					// joins face.getEdge( 1 ) with previousFace.getEdge( 0 )
+
 					sideEdge.next.setTwin( previousSideEdge );
 
 				}
@@ -714,29 +756,34 @@
 				this.newFaces.push( sideEdge.face );
 				previousSideEdge = sideEdge;
 
-			} // perform final join of new faces
+			}
 
+			// perform final join of new faces
 
 			firstSideEdge.next.setTwin( previousSideEdge );
 			return this;
 
-		} // Adds a vertex to the hull
+		}
 
+		// Adds a vertex to the hull
 
 		addVertexToHull( eyeVertex ) {
 
 			const horizon = [];
-			this.unassigned.clear(); // remove 'eyeVertex' from 'eyeVertex.face' so that it can't be added to the 'unassigned' vertex list
+			this.unassigned.clear();
+
+			// remove 'eyeVertex' from 'eyeVertex.face' so that it can't be added to the 'unassigned' vertex list
 
 			this.removeVertexFromFace( eyeVertex, eyeVertex.face );
 			this.computeHorizon( eyeVertex.point, null, eyeVertex.face, horizon );
-			this.addNewFaces( eyeVertex, horizon ); // reassign 'unassigned' vertices to the new faces
+			this.addNewFaces( eyeVertex, horizon );
+
+			// reassign 'unassigned' vertices to the new faces
 
 			this.resolveUnassignedPoints( this.newFaces );
 			return this;
 
 		}
-
 		cleanup() {
 
 			this.assigned.clear();
@@ -745,11 +792,12 @@
 			return this;
 
 		}
-
 		compute() {
 
 			let vertex;
-			this.computeInitialHull(); // add all available vertices gradually to the hull
+			this.computeInitialHull();
+
+			// add all available vertices gradually to the hull
 
 			while ( ( vertex = this.nextVertexToAdd() ) !== undefined ) {
 
@@ -763,8 +811,9 @@
 
 		}
 
-	} //
+	}
 
+	//
 
 	class Face {
 
@@ -774,34 +823,33 @@
 			this.midpoint = new THREE.Vector3();
 			this.area = 0;
 			this.constant = 0; // signed distance from face to the origin
-
 			this.outside = null; // reference to a vertex in a vertex list this face can see
-
 			this.mark = Visible;
 			this.edge = null;
 
 		}
-
 		static create( a, b, c ) {
 
 			const face = new Face();
 			const e0 = new HalfEdge( a, face );
 			const e1 = new HalfEdge( b, face );
-			const e2 = new HalfEdge( c, face ); // join edges
+			const e2 = new HalfEdge( c, face );
+
+			// join edges
 
 			e0.next = e2.prev = e1;
 			e1.next = e0.prev = e2;
-			e2.next = e1.prev = e0; // main half edge reference
+			e2.next = e1.prev = e0;
+
+			// main half edge reference
 
 			face.edge = e0;
 			return face.compute();
 
 		}
-
 		getEdge( i ) {
 
 			let edge = this.edge;
-
 			while ( i > 0 ) {
 
 				edge = edge.next;
@@ -819,33 +867,28 @@
 			return edge;
 
 		}
-
 		compute() {
 
 			const a = this.edge.tail();
 			const b = this.edge.head();
 			const c = this.edge.next.head();
-
 			_triangle.set( a.point, b.point, c.point );
-
 			_triangle.getNormal( this.normal );
-
 			_triangle.getMidpoint( this.midpoint );
-
 			this.area = _triangle.getArea();
 			this.constant = this.normal.dot( this.midpoint );
 			return this;
 
 		}
-
 		distanceToPoint( point ) {
 
 			return this.normal.dot( point ) - this.constant;
 
 		}
 
-	} // Entity for a Doubly-Connected Edge List (DCEL).
+	}
 
+	// Entity for a Doubly-Connected Edge List (DCEL).
 
 	class HalfEdge {
 
@@ -858,24 +901,20 @@
 			this.face = face;
 
 		}
-
 		head() {
 
 			return this.vertex;
 
 		}
-
 		tail() {
 
 			return this.prev ? this.prev.vertex : null;
 
 		}
-
 		length() {
 
 			const head = this.head();
 			const tail = this.tail();
-
 			if ( tail !== null ) {
 
 				return tail.point.distanceTo( head.point );
@@ -885,12 +924,10 @@
 			return - 1;
 
 		}
-
 		lengthSquared() {
 
 			const head = this.head();
 			const tail = this.tail();
-
 			if ( tail !== null ) {
 
 				return tail.point.distanceToSquared( head.point );
@@ -900,7 +937,6 @@
 			return - 1;
 
 		}
-
 		setTwin( edge ) {
 
 			this.twin = edge;
@@ -909,8 +945,9 @@
 
 		}
 
-	} // A vertex as a double linked list node.
+	}
 
+	// A vertex as a double linked list node.
 
 	class VertexNode {
 
@@ -923,8 +960,9 @@
 
 		}
 
-	} // A double linked list that contains vertex nodes.
+	}
 
+	// A double linked list that contains vertex nodes.
 
 	class VertexList {
 
@@ -934,32 +972,29 @@
 			this.tail = null;
 
 		}
-
 		first() {
 
 			return this.head;
 
 		}
-
 		last() {
 
 			return this.tail;
 
 		}
-
 		clear() {
 
 			this.head = this.tail = null;
 			return this;
 
-		} // Inserts a vertex before the target vertex
+		}
 
+		// Inserts a vertex before the target vertex
 
 		insertBefore( target, vertex ) {
 
 			vertex.prev = target.prev;
 			vertex.next = target;
-
 			if ( vertex.prev === null ) {
 
 				this.head = vertex;
@@ -973,14 +1008,14 @@
 			target.prev = vertex;
 			return this;
 
-		} // Inserts a vertex after the target vertex
+		}
 
+		// Inserts a vertex after the target vertex
 
 		insertAfter( target, vertex ) {
 
 			vertex.prev = target;
 			vertex.next = target.next;
-
 			if ( vertex.next === null ) {
 
 				this.tail = vertex;
@@ -994,8 +1029,9 @@
 			target.next = vertex;
 			return this;
 
-		} // Appends a vertex to the end of the linked list
+		}
 
+		// Appends a vertex to the end of the linked list
 
 		append( vertex ) {
 
@@ -1015,8 +1051,9 @@
 			this.tail = vertex;
 			return this;
 
-		} // Appends a chain of vertices where 'vertex' is the head.
+		}
 
+		// Appends a chain of vertices where 'vertex' is the head.
 
 		appendChain( vertex ) {
 
@@ -1030,7 +1067,9 @@
 
 			}
 
-			vertex.prev = this.tail; // ensure that the 'tail' reference points to the last vertex of the chain
+			vertex.prev = this.tail;
+
+			// ensure that the 'tail' reference points to the last vertex of the chain
 
 			while ( vertex.next !== null ) {
 
@@ -1041,8 +1080,9 @@
 			this.tail = vertex;
 			return this;
 
-		} // Removes a vertex from the linked list
+		}
 
+		// Removes a vertex from the linked list
 
 		remove( vertex ) {
 
@@ -1068,8 +1108,9 @@
 
 			return this;
 
-		} // Removes a list of vertices whose 'head' is 'a' and whose 'tail' is b
+		}
 
+		// Removes a list of vertices whose 'head' is 'a' and whose 'tail' is b
 
 		removeSubList( a, b ) {
 
@@ -1096,7 +1137,6 @@
 			return this;
 
 		}
-
 		isEmpty() {
 
 			return this.head === null;
@@ -1106,5 +1146,9 @@
 	}
 
 	THREE.ConvexHull = ConvexHull;
+	THREE.Face = Face;
+	THREE.HalfEdge = HalfEdge;
+	THREE.VertexList = VertexList;
+	THREE.VertexNode = VertexNode;
 
 } )();