Home Explore Help
Sign In
javascript
/
three.js
mirror of https://github.com/tazdij/three.js.git
2
0
Fork 0
Files Issues 0 Wiki
Browse Source

ConvexGeometry: Moved to examples

Mugen87 8 years ago
parent
0ac2f91f1d
commit
2ddb73b235
20 changed files with 1542 additions and 1553 deletions
Split View Show Diff Stats
  1. 0 89
      docs/api/math/convexhull/Face.html
  2. 0 79
      docs/api/math/convexhull/HalfEdge.html
  3. 2 3
      docs/examples/geometries/ConvexBufferGeometry.html
  4. 1 3
      docs/examples/geometries/ConvexGeometry.html
  5. 89 0
      docs/examples/quickhull/Face.html
  6. 79 0
      docs/examples/quickhull/HalfEdge.html
  7. 31 31
      docs/examples/quickhull/QuickHull.html
  8. 16 16
      docs/examples/quickhull/VertexList.html
  9. 6 6
      docs/examples/quickhull/VertexNode.html
  10. 13 10
      docs/list.js
  11. 0 69
      docs/scenes/js/geometry.js
  12. 1218 0
      examples/js/QuickHull.js
  13. 85 0
      examples/js/geometries/ConvexGeometry.js
  14. 2 0
      examples/webgl_geometry_convex.html
  15. 0 2
      src/constants.js
  16. 0 109
      src/math/convexhull/Face.js
  17. 0 74
      src/math/convexhull/HalfEdge.js
  18. 0 846
      src/math/convexhull/QuickHull3.js
  19. 0 17
      src/math/convexhull/Vertex.js
  20. 0 199
      src/math/convexhull/VertexList.js

+ 0 - 89
docs/api/math/convexhull/Face.html
View File 

@@ -1,89 +0,0 @@
 
-<!DOCTYPE html>
 
-<html lang="en">
 
-	<head>
 
-		<meta charset="utf-8" />
 
-		<base href="../../../" />
 
-		<script src="list.js"></script>
 
-		<script src="page.js"></script>
 
-		<link type="text/css" rel="stylesheet" href="page.css" />
 
-	</head>
 
-	<body>
 
-		<h1>[name]</h1>
 
-
 
-		<div class="desc">
 
-      Represents a section bounded by a specific amount of half-edges. The current implmentation assumes that a face always consist of three edges.
 
-		</div>
 
-
 
-
 
-		<h2>Constructor</h2>
 
-
 
-
 
-		<h3>[name]()</h3>
 
-
 
-		</div>
 
-
 
-		<h2>Properties</h2>
 
-
 
-    <h3>[property:Vector3 normal]</h3>
 
-    <div>
 
-      The normal vector of the face. Default is a [page:Vector3] at (0, 0, 0).
 
-    </div>
 
-
 
-    <h3>[property:Vector3 midpoint]</h3>
 
-    <div>
 
-      The midpoint or centroid of the face. Default is a [page:Vector3] at (0, 0, 0).
 
-    </div>
 
-
 
-    <h3>[property:Float area]</h3>
 
-    <div>
 
-      The area of the face. Default is 0.
 
-    </div>
 
-
 
-    <h3>[property:Float constant]</h3>
 
-    <div>
 
-      Signed distance from face to the origin. Default is 0.
 
-    </div>
 
-
 
-    <h3>[property:Vertex outside]</h3>
 
-    <div>
 
-      Reference to a vertex in a vertex list this face can see. Default is null.
 
-    </div>
 
-
 
-    <h3>[property:Integer mark]</h3>
 
-    <div>
 
-      Marks if a face is visible or deleted. Default is 'Visible'.
 
-    </div>
 
-
 
-    <h3>[property:HalfEdge edge]</h3>
 
-    <div>
 
-      Reference to the base edge of a face. To retrieve all edges, you can use the 'next' reference of the current edge. Default is null.
 
-    </div>
 
-
 
-    <h2>Methods</h2>
 
-
 
-    <h3>[method:Face create]( [page:Vertex a], [page:Vertex b], [page:Vertex c] )</h3>
 
-    [page:Vertex a] - First vertex of the face.<br /><br />
 
-    [page:Vertex b] - Second vertex of the face.<br /><br />
 
-    [page:Vertex c] - Third vertex of the face.<br /><br />
 
-
 
-    <div>Creates a face.</div>
 
-
 
-    <h3>[method:HalfEdge getEdge]( [page:Integer i] )</h3>
 
-    [page:Integer i] - The index of the edge.<br /><br />
 
-
 
-    <div>Returns an edge by the given index.</div>
 
-
 
-    <h3>[method:Face compute] ()</h3>
 
-
 
-    <div>Computes all properties of the face.</div>
 
-
 
-    <h3>[method:Float distanceToPoint]( [page:Vector3 point] )</h3>
 
-    [page:Vector3 point] - Any point in 3D space.<br /><br />
 
-
 
-    <div>Returns the signed distance from a given point to the plane representation of this face.</div>
 
-
 
-		<h2>Source</h2>
 
-
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
-	</body>
 
-</html>

+ 0 - 79
docs/api/math/convexhull/HalfEdge.html
View File 

@@ -1,79 +0,0 @@
 
-<!DOCTYPE html>
 
-<html lang="en">
 
-	<head>
 
-		<meta charset="utf-8" />
 
-		<base href="../../../" />
 
-		<script src="list.js"></script>
 
-		<script src="page.js"></script>
 
-		<link type="text/css" rel="stylesheet" href="page.css" />
 
-	</head>
 
-	<body>
 
-		<h1>[name]</h1>
 
-
 
-		<div class="desc">
 
-			The basis for a half-edge data structure, also known as doubly connected edge list (DCEL).<br />
 
-		</div>
 
-
 
-
 
-		<h2>Constructor</h2>
 
-
 
-
 
-		<h3>[name]( [page:Vertex vertex], [page:Face face] )</h3>
 
-		[page:Vertex vertex] - [page:Vertex] A reference to its destination vertex.<br /><br />
 
-		[page:Face face] - [page:Face] A reference to its face.<br />
 
-
 
-		</div>
 
-
 
-		<h2>Properties</h2>
 
-
 
-    <h3>[property:Vertex vertex]</h3>
 
-    <div>
 
-      Reference to the destination vertex. The origin vertex can be obtained by querying the destination of its twin, or of the previous half-edge. Default is undefined.
 
-    </div>
 
-
 
-		<h3>[property:HalfEdge prev]</h3>
 
-		<div>
 
-			Reference to the previous half-edge of the same face. Default is null.
 
-		</div>
 
-
 
-		<h3>[property:HalfEdge next]</h3>
 
-		<div>
 
-			Reference to the next half-edge of the same face. Default is null.
 
-		</div>
 
-
 
-    <h3>[property:HalfEdge twin]</h3>
 
-    <div>
 
-      Reference to the twin half-edge to reach the opposite face. Default is null.
 
-    </div>
 
-
 
-		<h3>[property:Face face]</h3>
 
-		<div>
 
-			 Each half-edge bounds a single face and thus has a reference to that face. Default is undefined.
 
-		</div>
 
-
 
-    <h2>Methods</h2>
 
-
 
-    <h3>[method:Vertex head]()</h3>
 
-		<div>Returns the destintation vertex.</div>
 
-
 
-    <h3>[method:Vertex tail]()</h3>
 
-    <div>Returns the origin vertex.</div>
 
-
 
-    <h3>[method:Float length]()</h3>
 
-    <div>Returns the [link:https://en.wikipedia.org/wiki/Euclidean_distance Euclidean length]
 
-		(straight-line length) of the edge.</div>
 
-
 
-    <h3>[method:Float lengthSquared]()</h3>
 
-    <div>Returns the square of the [link:https://en.wikipedia.org/wiki/Euclidean_distance Euclidean length]
 
-    (straight-line length) of the edge.</div>
 
-
 
-    <h3>[method:HalfEdge setTwin]( [page:HalfEdge edge] )</h3>
 
-    [page:HalfEdge edge] - Any half-edge.<br /><br />
 
-
 
-    <div>Sets the twin edge of this half-edge. It also ensures that the twin reference of the given half-edge is correctly set.</div>
 
-
 
-		<h2>Source</h2>
 
-
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
-	</body>
 
-</html>

+ 2 - 3
docs/api/geometries/ConvexBufferGeometry.html → docs/examples/geometries/ConvexBufferGeometry.html
View File 

@@ -5,6 +5,7 @@
 
 		<base href="../../" />
 
 		<script src="list.js"></script>
 
 		<script src="page.js"></script>
 
+		<script src="page.js"></script>
 
 		<link type="text/css" rel="stylesheet" href="page.css" />
 
 	</head>
 
 	<body>
 
@@ -15,8 +16,6 @@
 
 		<div class="desc">[name] can be used to generate a convex hull for a given array of 3D points.
 
 			The average time complexity for this task is considered to be O(nlog(n)).</div>
 
 
-		<iframe id="scene" src="scenes/geometry-browser.html#ConvexGeometry"></iframe>
 
-
 
 		<script>
 
 
 		// iOS iframe auto-resize workaround
 
@@ -51,6 +50,6 @@
 
 
 		<h2>Source</h2>
 
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/geometries/ConvexGeometry.js examples/js/geometries/ConvexGeometry.js]
 
 	</body>
 
 </html>

+ 1 - 3
docs/api/geometries/ConvexGeometry.html → docs/examples/geometries/ConvexGeometry.html
View File 

@@ -15,8 +15,6 @@
 
 		<div class="desc">[name] can be used to generate a convex hull for a given array of 3D points.
 
 			The average time complexity for this task is considered to be O(nlog(n)).</div>
 
 
-		<iframe id="scene" src="scenes/geometry-browser.html#ConvexGeometry"></iframe>
 
-
 
 		<script>
 
 
 		// iOS iframe auto-resize workaround
 
@@ -51,6 +49,6 @@
 
 
 		<h2>Source</h2>
 
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/geometries/ConvexGeometry.js examples/js/geometries/ConvexGeometry.js]
 
 	</body>
 
 </html>

+ 89 - 0
docs/examples/quickhull/Face.html
View File 

@@ -0,0 +1,89 @@
 
+<!DOCTYPE html>
 
+<html lang="en">
 
+	<head>
 
+		<meta charset="utf-8" />
 
+		<base href="../../" />
 
+		<script src="list.js"></script>
 
+		<script src="page.js"></script>
 
+		<link type="text/css" rel="stylesheet" href="page.css" />
 
+	</head>
 
+	<body>
 
+		<h1>[name]</h1>
 
+
 
+		<div class="desc">
 
+			Represents a section bounded by a specific amount of half-edges. The current implmentation assumes that a face always consist of three edges.
 
+		</div>
 
+
 
+
 
+		<h2>Constructor</h2>
 
+
 
+
 
+		<h3>[name]()</h3>
 
+
 
+		</div>
 
+
 
+		<h2>Properties</h2>
 
+
 
+		<h3>[property:Vector3 normal]</h3>
 
+		<div>
 
+			The normal vector of the face. Default is a [page:Vector3] at (0, 0, 0).
 
+		</div>
 
+
 
+		<h3>[property:Vector3 midpoint]</h3>
 
+		<div>
 
+			The midpoint or centroid of the face. Default is a [page:Vector3] at (0, 0, 0).
 
+		</div>
 
+
 
+		<h3>[property:Float area]</h3>
 
+		<div>
 
+			The area of the face. Default is 0.
 
+		</div>
 
+
 
+		<h3>[property:Float constant]</h3>
 
+		<div>
 
+			Signed distance from face to the origin. Default is 0.
 
+		</div>
 
+
 
+		<h3>[property:Vertex outside]</h3>
 
+		<div>
 
+			Reference to a vertex in a vertex list this face can see. Default is null.
 
+		</div>
 
+
 
+		<h3>[property:Integer mark]</h3>
 
+		<div>
 
+			Marks if a face is visible or deleted. Default is 'Visible'.
 
+		</div>
 
+
 
+		<h3>[property:HalfEdge edge]</h3>
 
+		<div>
 
+			Reference to the base edge of a face. To retrieve all edges, you can use the 'next' reference of the current edge. Default is null.
 
+		</div>
 
+
 
+		<h2>Methods</h2>
 
+
 
+		<h3>[method:Face create]( [page:Vertex a], [page:Vertex b], [page:Vertex c] )</h3>
 
+		[page:Vertex a] - First vertex of the face.<br /><br />
 
+		[page:Vertex b] - Second vertex of the face.<br /><br />
 
+		[page:Vertex c] - Third vertex of the face.<br /><br />
 
+
 
+		<div>Creates a face.</div>
 
+
 
+		<h3>[method:HalfEdge getEdge]( [page:Integer i] )</h3>
 
+		[page:Integer i] - The index of the edge.<br /><br />
 
+
 
+		<div>Returns an edge by the given index.</div>
 
+
 
+		<h3>[method:Face compute] ()</h3>
 
+
 
+		<div>Computes all properties of the face.</div>
 
+
 
+		<h3>[method:Float distanceToPoint]( [page:Vector3 point] )</h3>
 
+		[page:Vector3 point] - Any point in 3D space.<br /><br />
 
+
 
+		<div>Returns the signed distance from a given point to the plane representation of this face.</div>
 
+
 
+		<h2>Source</h2>
 
+
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
 
+	</body>
 
+</html>

+ 79 - 0
docs/examples/quickhull/HalfEdge.html
View File 

@@ -0,0 +1,79 @@
 
+<!DOCTYPE html>
 
+<html lang="en">
 
+	<head>
 
+		<meta charset="utf-8" />
 
+		<base href="../../" />
 
+		<script src="list.js"></script>
 
+		<script src="page.js"></script>
 
+		<link type="text/css" rel="stylesheet" href="page.css" />
 
+	</head>
 
+	<body>
 
+		<h1>[name]</h1>
 
+
 
+		<div class="desc">
 
+			The basis for a half-edge data structure, also known as doubly connected edge list (DCEL).<br />
 
+		</div>
 
+
 
+
 
+		<h2>Constructor</h2>
 
+
 
+
 
+		<h3>[name]( [page:Vertex vertex], [page:Face face] )</h3>
 
+		[page:Vertex vertex] - [page:Vertex] A reference to its destination vertex.<br /><br />
 
+		[page:Face face] - [page:Face] A reference to its face.<br />
 
+
 
+		</div>
 
+
 
+		<h2>Properties</h2>
 
+
 
+		<h3>[property:Vertex vertex]</h3>
 
+		<div>
 
+			Reference to the destination vertex. The origin vertex can be obtained by querying the destination of its twin, or of the previous half-edge. Default is undefined.
 
+		</div>
 
+
 
+		<h3>[property:HalfEdge prev]</h3>
 
+		<div>
 
+			Reference to the previous half-edge of the same face. Default is null.
 
+		</div>
 
+
 
+		<h3>[property:HalfEdge next]</h3>
 
+		<div>
 
+			Reference to the next half-edge of the same face. Default is null.
 
+		</div>
 
+
 
+		<h3>[property:HalfEdge twin]</h3>
 
+		<div>
 
+			Reference to the twin half-edge to reach the opposite face. Default is null.
 
+		</div>
 
+
 
+		<h3>[property:Face face]</h3>
 
+		<div>
 
+			 Each half-edge bounds a single face and thus has a reference to that face. Default is undefined.
 
+		</div>
 
+
 
+		<h2>Methods</h2>
 
+
 
+		<h3>[method:Vertex head]()</h3>
 
+		<div>Returns the destintation vertex.</div>
 
+
 
+		<h3>[method:Vertex tail]()</h3>
 
+		<div>Returns the origin vertex.</div>
 
+
 
+		<h3>[method:Float length]()</h3>
 
+		<div>Returns the [link:https://en.wikipedia.org/wiki/Euclidean_distance Euclidean length]
 
+		(straight-line length) of the edge.</div>
 
+
 
+		<h3>[method:Float lengthSquared]()</h3>
 
+		<div>Returns the square of the [link:https://en.wikipedia.org/wiki/Euclidean_distance Euclidean length]
 
+		(straight-line length) of the edge.</div>
 
+
 
+		<h3>[method:HalfEdge setTwin]( [page:HalfEdge edge] )</h3>
 
+		[page:HalfEdge edge] - Any half-edge.<br /><br />
 
+
 
+		<div>Sets the twin edge of this half-edge. It also ensures that the twin reference of the given half-edge is correctly set.</div>
 
+
 
+		<h2>Source</h2>
 
+
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
 
+	</body>
 
+</html>

+ 31 - 31
docs/api/math/convexhull/QuickHull3.html → docs/examples/quickhull/QuickHull.html
View File 

@@ -2,7 +2,7 @@
 
 <html lang="en">
 
 	<head>
 
 		<meta charset="utf-8" />
 
-		<base href="../../../" />
 
+		<base href="../../" />
 
 		<script src="list.js"></script>
 
 		<script src="page.js"></script>
 
 		<link type="text/css" rel="stylesheet" href="page.css" />
 
@@ -24,10 +24,10 @@
 
 
 		<h2>Properties</h2>
 
 
-    <h3>[property:Float tolerance]</h3>
 
-    <div>
 
-      The epsilon value that is used for internal comparative operations. The calculation of this value depends on the size of the geometry. Default is -1.
 
-    </div>
 
+		<h3>[property:Float tolerance]</h3>
 
+		<div>
 
+			The epsilon value that is used for internal comparative operations. The calculation of this value depends on the size of the geometry. Default is -1.
 
+		</div>
 
 
 		<h3>[property:Array faces]</h3>
 
 		<div>
 
@@ -54,45 +54,45 @@
 
 			The internal representation of the given geometry data (an array of [page:Vertex vertices]).
 
 		</div>
 
 
-    <h2>Methods</h2>
 
+		<h2>Methods</h2>
 
 
-    <h3>[method:QuickHull3 setFromPoints]( [page:Array points] )</h3>
 
-    [page:Array points] - Array of [page:Vector3 Vector3s] that the resulting convex hull will contain.<br /><br />
 
+		<h3>[method:QuickHull3 setFromPoints]( [page:Array points] )</h3>
 
+		[page:Array points] - Array of [page:Vector3 Vector3s] that the resulting convex hull will contain.<br /><br />
 
 
-    <div>Computes to convex hull for the given array of points.</div>
 
+		<div>Computes to convex hull for the given array of points.</div>
 
 
-    <h3>[method:QuickHull3 setFromObject]( [page:Object3D object] )</h3>
 
-    [page:Object3D object] - [page:Object3D] to compute the convex hull of.<br /><br />
 
+		<h3>[method:QuickHull3 setFromObject]( [page:Object3D object] )</h3>
 
+		[page:Object3D object] - [page:Object3D] to compute the convex hull of.<br /><br />
 
 
-    <div>Computes the convex hull of an [page:Object3D] (including its children),
 
+		<div>Computes the convex hull of an [page:Object3D] (including its children),
 
 		accounting for the world transforms of both the object and its childrens.</div>
 
 
-    <h3>[method:QuickHull3 makeEmpty]()</h3>
 
+		<h3>[method:QuickHull3 makeEmpty]()</h3>
 
 
-    <div>Makes this convex hull empty.</div>
 
+		<div>Makes this convex hull empty.</div>
 
 
-    <h3>[method:QuickHull3 addVertexToFace]( [page:Vertex vertex], [page:Face face]  )</h3>
 
+		<h3>[method:QuickHull3 addVertexToFace]( [page:Vertex vertex], [page:Face face]	)</h3>
 
 		[page:Vertex vertex] - The vetex to add.<br /><br />
 
 		[page:Face face] - The target face.<br /><br />
 
 
-    <div>Adds a vertex to the 'assigned' list of vertices and assigns it to the given face.</div>
 
+		<div>Adds a vertex to the 'assigned' list of vertices and assigns it to the given face.</div>
 
 
-    <h3>[method:QuickHull3 removeVertexFromFace]( [page:Vertex vertex], [page:Face face]  )</h3>
 
+		<h3>[method:QuickHull3 removeVertexFromFace]( [page:Vertex vertex], [page:Face face]	)</h3>
 
 		[page:Vertex vertex] - The vetex to remove.<br /><br />
 
 		[page:Face face] - The target face.<br /><br />
 
 
-    <div>Removes a vertex from the 'assigned' list of vertices and from the given face. It also makes sure that the link from 'face' to the first vertex it sees in 'assigned' is linked correctly after the removal.</div>
 
+		<div>Removes a vertex from the 'assigned' list of vertices and from the given face. It also makes sure that the link from 'face' to the first vertex it sees in 'assigned' is linked correctly after the removal.</div>
 
 
-		<h3>[method:Vertex removeAllVerticesFromFace]( [page:Face face]  )</h3>
 
+		<h3>[method:Vertex removeAllVerticesFromFace]( [page:Face face]	)</h3>
 
 		[page:Face face] - The given face.<br /><br />
 
 
-    <div>Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list.</div>
 
+		<div>Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list.</div>
 
 
-		<h3>[method:QuickHull3 deleteFaceVertices]( [page:Face face], [page:Face absorbingFace]  )</h3>
 
+		<h3>[method:QuickHull3 deleteFaceVertices]( [page:Face face], [page:Face absorbingFace]	)</h3>
 
 		[page:Face face] - The given face.<br /><br />
 
 		[page:Face absorbingFace] - An optional face that tries to absorb the vertices of the first face.<br /><br />
 
 
-    <div>Removes all the visible vertices that 'face' is able to see.
 
+		<div>Removes all the visible vertices that 'face' is able to see.
 
 			<ul>
 
 				<li>If 'absorbingFace' doesn't exist, then all the removed vertices will be added to the 'unassigned' vertex list.</li>
 
 				<li>If 'absorbingFace' exists, then this method will assign all the vertices of 'face' that can see 'absorbingFace'.</li>
 
@@ -100,26 +100,26 @@
 
 			</ul>
 
 		</div>
 
 
-		<h3>[method:QuickHull3 resolveUnassignedPoints]( [page:Array newFaces]  )</h3>
 
+		<h3>[method:QuickHull3 resolveUnassignedPoints]( [page:Array newFaces]	)</h3>
 
 		[page:Face newFaces] - An array of new faces.<br /><br />
 
 
-    <div>Reassigns as many vertices as possible from the unassigned list to the new faces.</div>
 
+		<div>Reassigns as many vertices as possible from the unassigned list to the new faces.</div>
 
 
 		<h3>[method:Object computeExtremes]()</h3>
 
 
-    <div>Computes the extremes values (min/max vectors) which will be used to compute the inital hull.</div>
 
+		<div>Computes the extremes values (min/max vectors) which will be used to compute the inital hull.</div>
 
 
 		<h3>[method:QuickHull3 computeInitialHull]()</h3>
 
 
-    <div>Computes the initial simplex assigning to its faces all the points that are candidates to form part of the hull.</div>
 
+		<div>Computes the initial simplex assigning to its faces all the points that are candidates to form part of the hull.</div>
 
 
 		<h3>[method:QuickHull3 reindexFaces]()</h3>
 
 
-    <div>Removes inactive (e.g. deleted) faces from the internal face list.</div>
 
+		<div>Removes inactive (e.g. deleted) faces from the internal face list.</div>
 
 
 		<h3>[method:Vertex nextVertexToAdd]()</h3>
 
 
-    <div>Finds the next vertex to create faces with the current hull.
 
+		<div>Finds the next vertex to create faces with the current hull.
 
 			<ul>
 
 				<li>Let the initial face be the first face existing in the 'assigned' vertex list.</li>
 
 				<li>If a face doesn't exist then return since there're no vertices left.</li>
 
@@ -127,13 +127,13 @@
 
 			</ul>
 
 		</div>
 
 
-		<h3>[method:QuickHull3 computeHorizon]( [page:Vector3 eyePoint], [page:HalfEdge crossEdge], [page:Face face], [page:Array horizon]  )</h3>
 
+		<h3>[method:QuickHull3 computeHorizon]( [page:Vector3 eyePoint], [page:HalfEdge crossEdge], [page:Face face], [page:Array horizon]	)</h3>
 
 		[page:Vector3 eyePoint] - The 3D-coordinates of a point.<br /><br />
 
 		[page:HalfEdge crossEdge] - The edge used to jump to the current face.<br /><br />
 
 		[page:Face face] - The current face being tested.<br /><br />
 
 		[page:Array horizon] - The edges that form part of the horizon in CCW order.<br /><br />
 
 
-    <div>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'.</div>
 
+		<div>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'.</div>
 
 
 		<h3>[method:HalfEdge addAdjoiningFace]( [page:Vertex eyeVertex], [page:HalfEdge horizonEdge] )</h3>
 
 		[page:Vertex eyeVertex] - The vertex that is added to the hull.<br /><br />
 
@@ -170,6 +170,6 @@
 
 
 		<h2>Source</h2>
 
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
 
 	</body>
 
 </html>

+ 16 - 16
docs/api/math/convexhull/VertexList.html → docs/examples/quickhull/VertexList.html
View File 

@@ -2,7 +2,7 @@
 
 <html lang="en">
 
 	<head>
 
 		<meta charset="utf-8" />
 
-		<base href="../../../" />
 
+		<base href="../../" />
 
 		<script src="list.js"></script>
 
 		<script src="page.js"></script>
 
 		<link type="text/css" rel="stylesheet" href="page.css" />
 
@@ -24,32 +24,32 @@
 
 
 		<h2>Properties</h2>
 
 
-    <h3>[property:Vertex head]</h3>
 
-    <div>
 
-      Reference to the first vertex of the linked list. Default is null.
 
-    </div>
 
+		<h3>[property:Vertex head]</h3>
 
+		<div>
 
+			Reference to the first vertex of the linked list. Default is null.
 
+		</div>
 
 
 		<h3>[property:Vertex tail]</h3>
 
 		<div>
 
 			Reference to the last vertex of the linked list. Default is null.
 
 		</div>
 
 
-    <h2>Methods</h2>
 
+		<h2>Methods</h2>
 
 
-    <h3>[method:Vertex first]()</h3>
 
+		<h3>[method:Vertex first]()</h3>
 
 		<div>Returns the head reference.</div>
 
 
-    <h3>[method:Vertex last]()</h3>
 
-    <div>Returns the tail reference.</div>
 
+		<h3>[method:Vertex last]()</h3>
 
+		<div>Returns the tail reference.</div>
 
 
-    <h3>[method:VertexList clear]()</h3>
 
-    <div>Clears the linked list.</div>
 
+		<h3>[method:VertexList clear]()</h3>
 
+		<div>Clears the linked list.</div>
 
 
-    <h3>[method:VertexList insertBefore]( [page:Vertex target], [page:Vertex vertex] )</h3>
 
-    [page:Vertex target] - The target vertex. It's assumed that this vertex belongs to the linked list.<br /><br />
 
-    [page:Vertex vertex] - The vertex to insert.<br /><br />
 
+		<h3>[method:VertexList insertBefore]( [page:Vertex target], [page:Vertex vertex] )</h3>
 
+		[page:Vertex target] - The target vertex. It's assumed that this vertex belongs to the linked list.<br /><br />
 
+		[page:Vertex vertex] - The vertex to insert.<br /><br />
 
 
-    <div>Inserts a vertex <strong>before</strong> a target vertex.</div>
 
+		<div>Inserts a vertex <strong>before</strong> a target vertex.</div>
 
 
 		<h3>[method:VertexList insertAfter]( [page:Vertex target], [page:Vertex vertex] )</h3>
 
 		[page:Vertex target] - The target vertex. It's assumed that this vertex belongs to the linked list.<br /><br />
 
@@ -84,6 +84,6 @@
 
 
 		<h2>Source</h2>
 
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
 
 	</body>
 
 </html>

+ 6 - 6
docs/api/math/convexhull/Vertex.html → docs/examples/quickhull/VertexNode.html
View File 

@@ -2,7 +2,7 @@
 
 <html lang="en">
 
 	<head>
 
 		<meta charset="utf-8" />
 
-		<base href="../../../" />
 
+		<base href="../../" />
 
 		<script src="list.js"></script>
 
 		<script src="page.js"></script>
 
 		<link type="text/css" rel="stylesheet" href="page.css" />
 
@@ -25,10 +25,10 @@
 
 
 		<h2>Properties</h2>
 
 
-    <h3>[property:Vector3 point]</h3>
 
-    <div>
 
-      A point (x, y, z) in 3D space. Default is undefined.
 
-    </div>
 
+		<h3>[property:Vector3 point]</h3>
 
+		<div>
 
+			A point (x, y, z) in 3D space. Default is undefined.
 
+		</div>
 
 
 		<h3>[property:Vertex prev]</h3>
 
 		<div>
 
@@ -47,6 +47,6 @@
 
 
 		<h2>Source</h2>
 
 
-		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
 
+		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
 
 	</body>
 
 </html>

+ 13 - 10
docs/list.js
View File 

@@ -139,8 +139,6 @@ var list = {
 
 			[ "CircleGeometry", "api/geometries/CircleGeometry" ],
 
 			[ "ConeBufferGeometry", "api/geometries/ConeBufferGeometry" ],
 
 			[ "ConeGeometry", "api/geometries/ConeGeometry" ],
 
-			[ "ConvexBufferGeometry", "api/geometries/ConvexBufferGeometry" ],
 
-			[ "ConvexGeometry", "api/geometries/ConvexGeometry" ],
 
 			[ "CylinderBufferGeometry", "api/geometries/CylinderBufferGeometry" ],
 
 			[ "CylinderGeometry", "api/geometries/CylinderGeometry" ],
 
 			[ "DodecahedronBufferGeometry", "api/geometries/DodecahedronBufferGeometry" ],
 
@@ -285,14 +283,6 @@ var list = {
 
 			[ "QuaternionLinearInterpolant", "api/math/interpolants/QuaternionLinearInterpolant" ]
 
 		],
 
 
-		"Math / Convex Hull": [
 
-			[ "Face", "api/math/convexhull/Face" ],
 
-			[ "HalfEdge", "api/math/convexhull/HalfEdge" ],
 
-			[ "QuickHull3", "api/math/convexhull/QuickHull3" ],
 
-			[ "Vertex", "api/math/convexhull/Vertex" ],
 
-			[ "VertexList", "api/math/convexhull/VertexList" ]
 
-		],
 
-
 
 		"Objects": [
 
 			[ "Bone", "api/objects/Bone" ],
 
 			[ "Group", "api/objects/Group" ],
 
@@ -347,6 +337,11 @@ var list = {
 
 			[ "KeyFrameAnimation", "examples/collada/KeyFrameAnimation" ]
 
 		],
 
 
+		"Geometries": [
 
+			[ "ConvexBufferGeometry", "examples/geometries/ConvexBufferGeometry" ],
 
+			[ "ConvexGeometry", "examples/geometries/ConvexGeometry" ]
 
+		],
 
+
 
 		"Loaders": [
 
 			[ "BabylonLoader", "examples/loaders/BabylonLoader" ],
 
 			[ "ColladaLoader", "examples/loaders/ColladaLoader" ],
 
@@ -365,6 +360,14 @@ var list = {
 
 			[ "SpriteCanvasMaterial", "examples/SpriteCanvasMaterial" ]
 
 		],
 
 
+		"QuickHull": [
 
+			[ "Face", "examples/quickhull/Face" ],
 
+			[ "HalfEdge", "examples/quickhull/HalfEdge" ],
 
+			[ "QuickHull", "examples/quickhull/QuickHull" ],
 
+			[ "VertexNode", "examples/quickhull/VertexNode" ],
 
+			[ "VertexList", "examples/quickhull/VertexList" ]
 
+		],
 
+
 
 		"Renderers": [
 
 			[ "CanvasRenderer", "examples/renderers/CanvasRenderer" ]
 
 		]

+ 0 - 69
docs/scenes/js/geometry.js
View File 

@@ -1340,75 +1340,6 @@ var guis = {
 
 
 		generateGeometry();
 
 
-	},
 
-
 
-	ConvexGeometry: function( mesh ) {
 
-
 
-		var data = {
 
-			randomPoints: 1000
 
-		 };
 
-
 
-		function generateGeometry() {
 
-
 
-			var vertices = [];
 
-
 
-			for ( var i = 0; i < data.randomPoints; i ++ ) {
 
-
 
-				var vertex = new THREE.Vector3();
 
-				vertex.x = THREE.Math.randFloat( -10, 10 );
 
-				vertex.y = THREE.Math.randFloat( -10, 10 );
 
-				vertex.z = THREE.Math.randFloat( -10, 10 );
 
-				vertices.push( vertex );
 
-
 
-			}
 
-
 
-			updateGroupGeometry( mesh,
 
-				new THREE.ConvexGeometry( vertices )
 
-			);
 
-
 
-		}
 
-
 
-		var folder = gui.addFolder( 'THREE.ConvexGeometry' );
 
-
 
-		folder.add( data, 'randomPoints', 4, 10000 ).step( 100 ).onChange( generateGeometry );
 
-
 
-		generateGeometry();
 
-
 
-	},
 
-
 
-	ConvexBufferGeometry: function( mesh ) {
 
-
 
-		var data = {
 
-			randomPoints: 1000
 
-		 };
 
-
 
-		function generateGeometry() {
 
-
 
-			var vertices = [];
 
-
 
-			for ( var i = 0; i < data.randomPoints; i ++ ) {
 
-
 
-				var vertex = new THREE.Vector3();
 
-				vertex.x = THREE.Math.randFloat( -10, 10 );
 
-				vertex.y = THREE.Math.randFloat( -10, 10 );
 
-				vertex.z = THREE.Math.randFloat( -10, 10 );
 
-				vertices.push( vertex );
 
-
 
-			}
 
-
 
-			updateGroupGeometry( mesh,
 
-				new THREE.ConvexBufferGeometry( vertices )
 
-
 
-			);
 
-
 
-		}
 
-
 
-		var folder = gui.addFolder( 'THREE.ConvexBufferGeometry' );
 
-
 
-		folder.add( data, 'randomPoints', 4, 10000 ).step( 100 ).onChange( generateGeometry );
 
-
 
-		generateGeometry();
 
-
 
 	}
 
 
 };

+ 1218 - 0
examples/js/QuickHull.js
View File 

@@ -0,0 +1,1218 @@
 
+/**
 
+ * @author Mugen87 / https://github.com/Mugen87
 
+ *
 
+ * Ported from: https://github.com/maurizzzio/quickhull3d/ by Mauricio Poppe (https://github.com/maurizzzio)
 
+ *
 
+ */
 
+
 
+( function() {
 
+
 
+	var Visible = 0;
 
+	var Deleted = 1;
 
+
 
+	function QuickHull() {
 
+
 
+		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
 
+		// let 'v' be points wrapped as instance of 'Vertex'
 
+		//
 
+		//     [v, v, ..., v, v, v, ...]
 
+		//      ^             ^
 
+		//      |             |
 
+		//  a.outside     b.outside
 
+		//
 
+		this.assigned = new VertexList();
 
+		this.unassigned = new VertexList();
 
+
 
+		this.vertices = []; 	// vertices of the hull (internal representation of given geometry data)
 
+
 
+	}
 
+
 
+	Object.assign( QuickHull.prototype, {
 
+
 
+		setFromPoints: function ( points ) {
 
+
 
+			if ( Array.isArray( points ) !== true ) {
 
+
 
+				console.error( 'THREE.QuickHull: Points parameter is not an array.' );
 
+
 
+			}
 
+
 
+			if ( points.length < 4 ) {
 
+
 
+				console.error( 'THREE.QuickHull: The algorithm needs at least four points.' );
 
+
 
+			}
 
+
 
+			this.makeEmpty();
 
+
 
+			for ( var i = 0, l = points.length; i < l; i ++ ) {
 
+
 
+				this.vertices.push( new VertexNode( points[ i ] ) );
 
+
 
+			}
 
+
 
+			this.compute();
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		setFromObject: function ( object ) {
 
+
 
+			var points = [];
 
+
 
+			object.updateMatrixWorld( true );
 
+
 
+			object.traverse( function ( node ) {
 
+
 
+				var i, l, point;
 
+
 
+				var geometry = node.geometry;
 
+
 
+				if ( geometry !== undefined ) {
 
+
 
+					if ( geometry.isGeometry ) {
 
+
 
+						var vertices = geometry.vertices;
 
+
 
+						for ( i = 0, l = vertices.length; i < l; i ++ ) {
 
+
 
+							point = vertices[ i ].clone();
 
+							point.applyMatrix4( node.matrixWorld );
 
+
 
+							points.push( point );
 
+
 
+						}
 
+
 
+					} else if ( geometry.isBufferGeometry ) {
 
+
 
+						var attribute = geometry.attributes.position;
 
+
 
+						if ( attribute !== undefined ) {
 
+
 
+							for ( i = 0, l = attribute.count; i < l; i ++ ) {
 
+
 
+								point = new THREE.Vector3();
 
+
 
+								point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
 
+
 
+								points.push( point );
 
+
 
+							}
 
+
 
+						}
 
+
 
+					}
 
+
 
+				}
 
+
 
+			} );
 
+
 
+			return this.setFromPoints( points );
 
+
 
+		},
 
+
 
+		makeEmpty: function () {
 
+
 
+			this.faces = [];
 
+			this.vertices = [];
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Adds a vertex to the 'assigned' list of vertices and assigns it to the given face
 
+
 
+		addVertexToFace: function ( vertex, face ) {
 
+
 
+			vertex.face = face;
 
+
 
+			if ( face.outside === null ) {
 
+
 
+				this.assigned.append( vertex );
 
+
 
+			} else {
 
+
 
+				this.assigned.insertBefore( face.outside, vertex );
 
+
 
+			}
 
+
 
+			face.outside = vertex;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Removes a vertex from the 'assigned' list of vertices and from the given face
 
+
 
+		removeVertexFromFace: function ( 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;
 
+
 
+				}
 
+
 
+			}
 
+
 
+			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
 
+
 
+		removeAllVerticesFromFace: function ( face ) {
 
+
 
+			if ( face.outside !== null ) {
 
+
 
+				// reference to the first and last vertex of this face
 
+
 
+				var start = face.outside;
 
+				var end = face.outside;
 
+
 
+				while ( end.next !== null && end.next.face === face ) {
 
+
 
+					end = end.next;
 
+
 
+				}
 
+
 
+				this.assigned.removeSubList( start, end );
 
+
 
+				// fix references
 
+
 
+				start.prev = end.next = null;
 
+				face.outside = null;
 
+
 
+				return start;
 
+
 
+			}
 
+
 
+		},
 
+
 
+		// Removes all the visible vertices that 'face' is able to see
 
+
 
+		deleteFaceVertices: function ( face, absorbingFace ) {
 
+
 
+			var 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
 
+
 
+					var 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
 
+
 
+						var nextVertex = vertex.next;
 
+
 
+						var distance = absorbingFace.distanceToPoint( vertex.point );
 
+
 
+						// check if 'vertex' is able to see 'absorbingFace'
 
+
 
+						if ( distance > this.tolerance ) {
 
+
 
+							this.addVertexToFace( vertex, absorbingFace );
 
+
 
+						} else {
 
+
 
+							this.unassigned.append( vertex );
 
+
 
+						}
 
+
 
+						// now assign next vertex
 
+
 
+						vertex = nextVertex;
 
+
 
+					} while ( vertex !== null );
 
+
 
+				}
 
+
 
+			}
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Reassigns as many vertices as possible from the unassigned list to the new faces
 
+
 
+		resolveUnassignedPoints: function ( newFaces ) {
 
+
 
+			if ( this.unassigned.isEmpty() === false ) {
 
+
 
+				var vertex = this.unassigned.first();
 
+
 
+				do {
 
+
 
+					// buffer 'next' reference, see .deleteFaceVertices()
 
+
 
+					var nextVertex = vertex.next;
 
+
 
+					var maxDistance = this.tolerance;
 
+
 
+					var maxFace = null;
 
+
 
+					for ( var i = 0; i < newFaces.length; i ++ ) {
 
+
 
+						var face = newFaces[ i ];
 
+
 
+						if ( face.mark === Visible ) {
 
+
 
+							var distance = face.distanceToPoint( vertex.point );
 
+
 
+							if ( distance > maxDistance ) {
 
+
 
+								maxDistance = distance;
 
+								maxFace = face;
 
+
 
+							}
 
+
 
+							if ( maxDistance > 1000 * this.tolerance ) break;
 
+
 
+						}
 
+
 
+					}
 
+
 
+					// 'maxFace' can be null e.g. if there are identical vertices
 
+
 
+					if ( maxFace !== null ) {
 
+
 
+						this.addVertexToFace( vertex, maxFace );
 
+
 
+					}
 
+
 
+					vertex = nextVertex;
 
+
 
+				} while ( vertex !== null );
 
+
 
+			}
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Computes the extremes of a simplex which will be the initial hull
 
+
 
+		computeExtremes: function () {
 
+
 
+			var min = new THREE.Vector3();
 
+			var max = new THREE.Vector3();
 
+
 
+			var minVertices = [];
 
+			var maxVertices = [];
 
+
 
+			var i, l, j;
 
+
 
+			// initially assume that the first vertex is the min/max
 
+
 
+			for ( i = 0; i < 3; i ++ ) {
 
+
 
+				minVertices[ i ] = maxVertices[ i ] = this.vertices[ 0 ];
 
+
 
+			}
 
+
 
+			min.copy( this.vertices[ 0 ].point );
 
+			max.copy( this.vertices[ 0 ].point );
 
+
 
+			// compute the min/max vertex on all six directions
 
+
 
+			for ( i = 0, l = this.vertices.length; i < l ; i ++ ) {
 
+
 
+				var vertex = this.vertices[ i ];
 
+				var point = vertex.point;
 
+
 
+				// update the min coordinates
 
+
 
+				for ( j = 0; j < 3; j ++ ) {
 
+
 
+					if ( point.getComponent( j ) < min.getComponent( j ) ) {
 
+
 
+						min.setComponent( j, point.getComponent( j ) );
 
+						minVertices[ j ] = vertex;
 
+
 
+					}
 
+
 
+				}
 
+
 
+				// update the max coordinates
 
+
 
+				for ( j = 0; j < 3; j ++ ) {
 
+
 
+					if ( point.getComponent( j ) > max.getComponent( j ) ) {
 
+
 
+						max.setComponent( j, point.getComponent( j ) );
 
+						maxVertices[ j ] = vertex;
 
+
 
+					}
 
+
 
+				}
 
+
 
+			}
 
+
 
+			// 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 { min: minVertices, max: maxVertices };
 
+
 
+		},
 
+
 
+		// Computes the initial simplex assigning to its faces all the points
 
+		// that are candidates to form part of the hull
 
+
 
+		computeInitialHull: function () {
 
+
 
+			var line3, plane, closestPoint;
 
+
 
+			return function computeInitialHull () {
 
+
 
+				if ( line3 === undefined ) {
 
+
 
+					line3 = new THREE.Line3();
 
+					plane = new THREE.Plane();
 
+					closestPoint = new THREE.Vector3();
 
+
 
+				}
 
+
 
+				var vertex, vertices = this.vertices;
 
+				var extremes = this.computeExtremes();
 
+				var min = extremes.min;
 
+				var max = extremes.max;
 
+
 
+				var v0, v1, v2, v3;
 
+				var i, l, j;
 
+
 
+				// 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)
 
+
 
+				var distance, maxDistance = 0;
 
+				var index = 0;
 
+
 
+				for ( i = 0; i < 3; i ++ ) {
 
+
 
+					distance = max[ i ].point.getComponent( i ) - min[ i ].point.getComponent( i );
 
+
 
+					if ( distance > maxDistance ) {
 
+
 
+						maxDistance = distance;
 
+						index = i;
 
+
 
+					}
 
+
 
+				}
 
+
 
+				v0 = min[ index ];
 
+				v1 = max[ index ];
 
+
 
+				// 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 ( i = 0, l = this.vertices.length; i < l; i ++ ) {
 
+
 
+					vertex = vertices[ i ];
 
+
 
+					if ( vertex !== v0 && vertex !== v1 ) {
 
+
 
+						line3.closestPointToPoint( vertex.point, true, closestPoint );
 
+
 
+						distance = closestPoint.distanceToSquared( vertex.point );
 
+
 
+						if ( distance > maxDistance ) {
 
+
 
+							maxDistance = distance;
 
+							v2 = vertex;
 
+
 
+						}
 
+
 
+					}
 
+
 
+				}
 
+
 
+				// 3. The next vertex 'v3' is the one farthest to the plane 'v0', 'v1', 'v2'
 
+
 
+				maxDistance = 0;
 
+				plane.setFromCoplanarPoints( v0.point, v1.point, v2.point );
 
+
 
+				for ( i = 0, l = this.vertices.length; i < l; i ++ ) {
 
+
 
+					vertex = vertices[ i ];
 
+
 
+					if ( vertex !== v0 && vertex !== v1 && vertex !== v2 ) {
 
+
 
+						distance = Math.abs( plane.distanceToPoint( vertex.point ) );
 
+
 
+						if ( distance > maxDistance ) {
 
+
 
+							maxDistance = distance;
 
+							v3 = vertex;
 
+
 
+						}
 
+
 
+					}
 
+
 
+				}
 
+
 
+				var 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
 
+
 
+					for ( i = 0; i < 3; i ++ ) {
 
+
 
+						j = ( i + 1 ) % 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 ) );
 
+
 
+					}
 
+
 
+				} 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
 
+
 
+					for ( i = 0; i < 3; i ++ ) {
 
+
 
+						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 ) );
 
+
 
+						// join face[ i ] with face[ i + 1 ]
 
+
 
+						faces[ i + 1 ].getEdge( 0 ).setTwin( faces[ j + 1 ].getEdge( 1 ) );
 
+
 
+					}
 
+
 
+				}
 
+
 
+				// the initial hull is the tetrahedron
 
+
 
+				for ( i = 0; i < 4; i ++ ) {
 
+
 
+					this.faces.push( faces[ i ] );
 
+
 
+				}
 
+
 
+				// initial assignment of vertices to the faces of the tetrahedron
 
+
 
+				for ( i = 0, l = vertices.length; i < l; i ++ ) {
 
+
 
+					vertex = vertices[i];
 
+
 
+					if ( vertex !== v0 && vertex !== v1 && vertex !== v2 && vertex !== v3 ) {
 
+
 
+						maxDistance = this.tolerance;
 
+						var maxFace = null;
 
+
 
+						for ( j = 0; j < 4; j ++ ) {
 
+
 
+							distance = this.faces[ j ].distanceToPoint( vertex.point );
 
+
 
+							if ( distance > maxDistance ) {
 
+
 
+								maxDistance = distance;
 
+								maxFace = this.faces[ j ];
 
+
 
+							}
 
+
 
+						}
 
+
 
+						if ( maxFace !== null ) {
 
+
 
+	          	this.addVertexToFace( vertex, maxFace );
 
+
 
+	        	}
 
+
 
+					}
 
+
 
+				}
 
+
 
+				return this;
 
+
 
+			};
 
+
 
+		}(),
 
+
 
+		// Removes inactive faces
 
+
 
+		reindexFaces: function () {
 
+
 
+			var activeFaces = [];
 
+
 
+			for ( var i = 0; i < this.faces.length; i ++ ) {
 
+
 
+				var face = this.faces[ i ];
 
+
 
+				if ( face.mark === Visible ) {
 
+
 
+					activeFaces.push( face );
 
+
 
+				}
 
+
 
+			}
 
+
 
+			this.faces = activeFaces;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Finds the next vertex to create faces with the current hull
 
+
 
+		nextVertexToAdd: function () {
 
+
 
+			// if the 'assigned' list of vertices is empty, no vertices are left. return with 'undefined'
 
+
 
+			if ( this.assigned.isEmpty() === false ) {
 
+
 
+				var eyeVertex, maxDistance = 0;
 
+
 
+				// grap the first available face and start with the first visible vertex of that face
 
+
 
+				var eyeFace = this.assigned.first().face;
 
+				var vertex = eyeFace.outside;
 
+
 
+				// now calculate the farthest vertex that face can see
 
+
 
+				do {
 
+
 
+					var distance = eyeFace.distanceToPoint( vertex.point );
 
+
 
+					if ( distance > maxDistance ) {
 
+
 
+						maxDistance = distance;
 
+						eyeVertex = vertex;
 
+
 
+					}
 
+
 
+					vertex = vertex.next;
 
+
 
+				} while ( vertex !== null && vertex.face === eyeFace );
 
+
 
+				return eyeVertex;
 
+
 
+			}
 
+
 
+		},
 
+
 
+		// 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: function ( eyePoint, crossEdge, face, horizon ) {
 
+
 
+			// moves face's vertices to the 'unassigned' vertex list
 
+
 
+			this.deleteFaceVertices( face );
 
+
 
+			face.mark = Deleted;
 
+
 
+			var edge;
 
+
 
+			if ( crossEdge === null ) {
 
+
 
+				edge = crossEdge = face.getEdge( 0 );
 
+
 
+			} else {
 
+
 
+				// start from the next edge since 'crossEdge' was already analyzed
 
+				// (actually 'crossEdge.twin' was the edge who called this method recursively)
 
+
 
+				edge = crossEdge.next;
 
+
 
+			}
 
+
 
+			do {
 
+
 
+				var twinEdge = edge.twin;
 
+				var 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 );
 
+
 
+					}
 
+
 
+				}
 
+
 
+				edge = edge.next;
 
+
 
+			} while ( edge !== crossEdge );
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Creates a face with the vertices 'eyeVertex.point', 'horizonEdge.tail' and 'horizonEdge.head' in CCW order
 
+
 
+		addAdjoiningFace: function ( eyeVertex, horizonEdge ) {
 
+
 
+			// all the half edges are created in ccw order thus the face is always pointing outside the hull
 
+
 
+			var 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 )
 
+
 
+			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
 
+
 
+		addNewFaces: function ( eyeVertex, horizon ) {
 
+
 
+			this.newFaces = [];
 
+
 
+			var firstSideEdge = null;
 
+			var previousSideEdge = null;
 
+
 
+			for ( var i = 0; i < horizon.length; i ++ ) {
 
+
 
+				var horizonEdge = horizon[ i ];
 
+
 
+				// returns the right side edge
 
+
 
+				var sideEdge = this.addAdjoiningFace( eyeVertex, horizonEdge );
 
+
 
+				if ( firstSideEdge === null ) {
 
+
 
+					firstSideEdge = sideEdge;
 
+
 
+				} else {
 
+
 
+					// joins face.getEdge( 1 ) with previousFace.getEdge( 0 )
 
+
 
+					sideEdge.next.setTwin( previousSideEdge );
 
+
 
+				}
 
+
 
+				this.newFaces.push( sideEdge.face );
 
+				previousSideEdge = sideEdge;
 
+
 
+			}
 
+
 
+			// perform final join of new faces
 
+
 
+			firstSideEdge.next.setTwin( previousSideEdge );
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Adds a vertex to the hull
 
+
 
+		addVertexToHull: function ( eyeVertex ) {
 
+
 
+			var horizon = [];
 
+			var i, face;
 
+
 
+			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.resolveUnassignedPoints( this.newFaces );
 
+
 
+			return	this;
 
+
 
+		},
 
+
 
+		cleanup: function () {
 
+
 
+			this.assigned.clear();
 
+			this.unassigned.clear();
 
+			this.newFaces = [];
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		compute: function () {
 
+
 
+			var vertex;
 
+
 
+			this.computeInitialHull();
 
+
 
+			// add all available vertices gradually to the hull
 
+
 
+			while ( ( vertex = this.nextVertexToAdd() ) !== undefined ) {
 
+
 
+				this.addVertexToHull( vertex );
 
+
 
+			}
 
+
 
+			this.reindexFaces();
 
+
 
+			this.cleanup();
 
+
 
+			return this;
 
+
 
+		}
 
+
 
+	} );
 
+
 
+	//
 
+
 
+	function Face() {
 
+
 
+		this.normal = new THREE.Vector3();
 
+		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;
 
+
 
+	}
 
+
 
+	Object.assign( Face, {
 
+
 
+		create: function( a, b, c ) {
 
+
 
+			var face = new Face();
 
+
 
+			var e0 = new HalfEdge( a, face );
 
+			var e1 = new HalfEdge( b, face );
 
+			var 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
 
+
 
+			face.edge = e0;
 
+
 
+			return face.compute();
 
+
 
+		}
 
+
 
+	} );
 
+
 
+	Object.assign( Face.prototype, {
 
+
 
+		getEdge: function ( i ) {
 
+
 
+			var edge = this.edge;
 
+
 
+			while ( i > 0 ) {
 
+
 
+				edge = edge.next;
 
+				i --;
 
+
 
+			}
 
+
 
+			while ( i < 0 ) {
 
+
 
+				edge = edge.prev;
 
+				i ++;
 
+
 
+			}
 
+
 
+			return edge;
 
+
 
+		},
 
+
 
+		compute: function () {
 
+
 
+			var triangle;
 
+
 
+			return function compute () {
 
+
 
+				if ( triangle === undefined ) triangle = new THREE.Triangle();
 
+
 
+				var a = this.edge.tail();
 
+				var b = this.edge.head();
 
+				var c = this.edge.next.head();
 
+
 
+				triangle.set( a.point, b.point, c.point );
 
+
 
+				triangle.normal( this.normal );
 
+				triangle.midpoint( this.midpoint );
 
+				this.area = triangle.area();
 
+
 
+				this.constant = this.normal.dot( this.midpoint );
 
+
 
+				return this;
 
+
 
+			};
 
+
 
+		}(),
 
+
 
+		distanceToPoint: function ( point ) {
 
+
 
+			return this.normal.dot( point ) - this.constant;
 
+
 
+		}
 
+
 
+	} );
 
+
 
+	// Entity for a Doubly-Connected Edge List (DCEL).
 
+
 
+	function HalfEdge( vertex, face ) {
 
+
 
+		this.vertex = vertex;
 
+		this.prev = null;
 
+		this.next = null;
 
+		this.twin = null;
 
+		this.face = face;
 
+
 
+	}
 
+
 
+	Object.assign( HalfEdge.prototype, {
 
+
 
+		head: function () {
 
+
 
+			return this.vertex;
 
+
 
+		},
 
+
 
+		tail: function () {
 
+
 
+			return this.prev ? this.prev.vertex : null;
 
+
 
+		},
 
+
 
+		length: function () {
 
+
 
+			var head = this.head();
 
+			var tail = this.tail();
 
+
 
+			if ( tail !== null ) {
 
+
 
+				return tail.point.distanceTo( head.point );
 
+
 
+			}
 
+
 
+			return - 1;
 
+
 
+		},
 
+
 
+		lengthSquared: function () {
 
+
 
+			var head = this.head();
 
+			var tail = this.tail();
 
+
 
+			if ( tail !== null ) {
 
+
 
+				return tail.point.distanceToSquared( head.point );
 
+
 
+			}
 
+
 
+			return - 1;
 
+
 
+		},
 
+
 
+		setTwin: function ( edge ) {
 
+
 
+			this.twin = edge;
 
+			edge.twin = this;
 
+
 
+			return this;
 
+
 
+		}
 
+
 
+	} );
 
+
 
+	// A vertex as a double linked list node.
 
+
 
+	function VertexNode( point ) {
 
+
 
+		this.point = point;
 
+		this.prev = null;
 
+		this.next = null;
 
+		this.face = null; // the face that is able to see this vertex
 
+
 
+	}
 
+
 
+	// A double linked list that contains vertex nodes.
 
+
 
+	function VertexList() {
 
+
 
+		this.head = null;
 
+		this.tail = null;
 
+
 
+	}
 
+
 
+	Object.assign( VertexList.prototype, {
 
+
 
+		first: function () {
 
+
 
+			return this.head;
 
+
 
+		},
 
+
 
+		last: function () {
 
+
 
+			return this.tail;
 
+
 
+		},
 
+
 
+		clear: function () {
 
+
 
+			this.head = this.tail = null;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Inserts a vertex before the target vertex
 
+
 
+		insertBefore: function ( target, vertex ) {
 
+
 
+			vertex.prev = target.prev;
 
+			vertex.next = target;
 
+
 
+			if ( vertex.prev === null ) {
 
+
 
+				this.head = vertex;
 
+
 
+			} else {
 
+
 
+				vertex.prev.next = vertex;
 
+
 
+			}
 
+
 
+			target.prev = vertex;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Inserts a vertex after the target vertex
 
+
 
+		insertAfter: function ( target, vertex ) {
 
+
 
+			vertex.prev = target;
 
+			vertex.next = target.next;
 
+
 
+			if ( vertex.next === null ) {
 
+
 
+				this.tail = vertex;
 
+
 
+			} else {
 
+
 
+				vertex.next.prev = vertex;
 
+
 
+			}
 
+
 
+			target.next = vertex;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Appends a vertex to the end of the linked list
 
+
 
+		append: function ( vertex ) {
 
+
 
+			if ( this.head === null ) {
 
+
 
+				this.head = vertex;
 
+
 
+			} else {
 
+
 
+				this.tail.next = vertex;
 
+
 
+			}
 
+
 
+			vertex.prev = this.tail;
 
+			vertex.next = null; // the tail has no subsequent vertex
 
+
 
+			this.tail = vertex;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Appends a chain of vertices where 'vertex' is the head.
 
+
 
+		appendChain: function ( vertex ) {
 
+
 
+			if ( this.head === null ) {
 
+
 
+				this.head = vertex;
 
+
 
+			} else {
 
+
 
+				this.tail.next = vertex;
 
+
 
+			}
 
+
 
+			vertex.prev = this.tail;
 
+
 
+			// ensure that the 'tail' reference points to the last vertex of the chain
 
+
 
+			while ( vertex.next !== null ) {
 
+
 
+				vertex = vertex.next;
 
+
 
+			}
 
+
 
+			this.tail = vertex;
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Removes a vertex from the linked list
 
+
 
+		remove: function ( vertex ) {
 
+
 
+			if ( vertex.prev === null ) {
 
+
 
+				this.head = vertex.next;
 
+
 
+			} else {
 
+
 
+				vertex.prev.next = vertex.next;
 
+
 
+			}
 
+
 
+			if ( vertex.next === null ) {
 
+
 
+				this.tail = vertex.prev;
 
+
 
+			} else {
 
+
 
+				vertex.next.prev = vertex.prev;
 
+
 
+			}
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		// Removes a list of vertices whose 'head' is 'a' and whose 'tail' is b
 
+
 
+		removeSubList: function ( a, b ) {
 
+
 
+			if ( a.prev === null ) {
 
+
 
+				this.head = b.next;
 
+
 
+			} else {
 
+
 
+				a.prev.next = b.next;
 
+
 
+			}
 
+
 
+			if ( b.next === null ) {
 
+
 
+				this.tail = a.prev;
 
+
 
+			} else {
 
+
 
+				b.next.prev = a.prev;
 
+
 
+			}
 
+
 
+			return this;
 
+
 
+		},
 
+
 
+		isEmpty: function() {
 
+
 
+			return this.head === null;
 
+
 
+		}
 
+
 
+	} );
 
+
 
+	// export
 
+
 
+	THREE.QuickHull = QuickHull;
 
+
 
+
 
+} ) ();

+ 85 - 0
examples/js/geometries/ConvexGeometry.js
View File 

@@ -0,0 +1,85 @@
 
+/**
 
+ * @author Mugen87 / https://github.com/Mugen87
 
+ */
 
+
 
+( function() {
 
+
 
+	// ConvexGeometry
 
+
 
+	function ConvexGeometry( points ) {
 
+
 
+		THREE.Geometry.call( this );
 
+
 
+		this.type = 'ConvexGeometry';
 
+
 
+		this.fromBufferGeometry( new ConvexBufferGeometry( points ) );
 
+		this.mergeVertices();
 
+
 
+	}
 
+
 
+	ConvexGeometry.prototype = Object.create( THREE.Geometry.prototype );
 
+	ConvexGeometry.prototype.constructor = ConvexGeometry;
 
+
 
+	// ConvexBufferGeometry
 
+
 
+	function ConvexBufferGeometry( points ) {
 
+
 
+	  THREE.BufferGeometry.call( this );
 
+
 
+		this.type = 'ConvexBufferGeometry';
 
+
 
+	  // buffers
 
+
 
+	  var vertices = [];
 
+	  var normals = [];
 
+
 
+	  // execute QuickHull
 
+
 
+		if ( THREE.QuickHull === undefined ) {
 
+
 
+			console.error( 'THREE.ConvexBufferGeometry: ConvexBufferGeometry relies on THREE.QuickHull' );
 
+
 
+		}
 
+
 
+	  var quickHull = new THREE.QuickHull().setFromPoints( points );
 
+
 
+	  // generate vertices and normals
 
+
 
+	  var faces = quickHull.faces;
 
+
 
+	  for ( var i = 0; i < faces.length; i ++ ) {
 
+
 
+	    var face = faces[ i ];
 
+	    var edge = face.edge;
 
+
 
+	    // we move along a doubly-connected edge list to access all face points (see HalfEdge docs)
 
+
 
+	    do {
 
+
 
+	      var point = edge.head().point;
 
+
 
+	      vertices.push( point.x, point.y, point.z );
 
+	      normals.push( face.normal.x, face.normal.y, face.normal.z );
 
+
 
+	      edge = edge.next;
 
+
 
+	    } while ( edge !== face.edge );
 
+
 
+	  }
 
+
 
+	  // build geometry
 
+
 
+	  this.addAttribute( 'position', new THREE.Float32BufferAttribute( vertices, 3 ) );
 
+	  this.addAttribute( 'normal', new THREE.Float32BufferAttribute( normals, 3 ) );
 
+
 
+	}
 
+
 
+	ConvexBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
 
+	ConvexBufferGeometry.prototype.constructor = ConvexBufferGeometry;
 
+
 
+	// export
 
+
 
+	THREE.ConvexGeometry = ConvexGeometry;
 
+	THREE.ConvexBufferGeometry = ConvexBufferGeometry;
 
+
 
+} ) ();

+ 2 - 0
examples/webgl_geometry_convex.html
View File 

@@ -30,6 +30,8 @@
 
 
 		<script src="../build/three.js"></script>
 
 		<script src="js/controls/OrbitControls.js"></script>
 
+		<script src="js/QuickHull.js"></script>
 
+		<script src="js/geometries/ConvexGeometry.js"></script>
 
 		<script src="js/Detector.js"></script>
 
 		<script src="js/libs/stats.min.js"></script>

+ 0 - 2
src/constants.js
View File 

@@ -123,5 +123,3 @@ export var RGBM16Encoding = 3005;
 
 export var RGBDEncoding = 3006;
 
 export var BasicDepthPacking = 3200;
 
 export var RGBADepthPacking = 3201;
 
-export var Visible = 0;
 
-export var Deleted = 1;

+ 0 - 109
src/math/convexhull/Face.js
View File 

@@ -1,109 +0,0 @@
 
-import { HalfEdge } from './HalfEdge';
 
-import { Vector3 } from '../Vector3';
 
-import { Triangle } from '../Triangle';
 
-import { Visible, Deleted } from '../../constants';
 
-
 
-/**
 
- * @author Mugen87 / https://github.com/Mugen87
 
- *
 
- */
 
-
 
-function Face() {
 
-
 
-	this.normal = new Vector3();
 
-	this.midpoint = new 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;
 
-
 
-}
 
-
 
-Object.assign( Face, {
 
-
 
-	create: function( a, b, c ) {
 
-
 
-		var face = new Face();
 
-
 
-		var e0 = new HalfEdge( a, face );
 
-		var e1 = new HalfEdge( b, face );
 
-		var 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
 
-
 
-		face.edge = e0;
 
-
 
-		return face.compute();
 
-
 
-	}
 
-
 
-} );
 
-
 
-Object.assign( Face.prototype, {
 
-
 
-	getEdge: function ( i ) {
 
-
 
-		var edge = this.edge;
 
-
 
-		while ( i > 0 ) {
 
-
 
-			edge = edge.next;
 
-			i --;
 
-
 
-		}
 
-
 
-		while ( i < 0 ) {
 
-
 
-			edge = edge.prev;
 
-			i ++;
 
-
 
-		}
 
-
 
-		return edge;
 
-
 
-	},
 
-
 
-	compute: function () {
 
-
 
-		var triangle;
 
-
 
-		return function compute () {
 
-
 
-			if ( triangle === undefined ) triangle = new Triangle();
 
-
 
-			var a = this.edge.tail();
 
-			var b = this.edge.head();
 
-			var c = this.edge.next.head();
 
-
 
-			triangle.set( a.point, b.point, c.point );
 
-
 
-			triangle.normal( this.normal );
 
-			triangle.midpoint( this.midpoint );
 
-			this.area = triangle.area();
 
-
 
-			this.constant = this.normal.dot( this.midpoint );
 
-
 
-			return this;
 
-
 
-		};
 
-
 
-	}(),
 
-
 
-	distanceToPoint: function ( point ) {
 
-
 
-		return this.normal.dot( point ) - this.constant;
 
-
 
-	}
 
-
 
-} );
 
-
 
-
 
-export { Face };

+ 0 - 74
src/math/convexhull/HalfEdge.js
View File 

@@ -1,74 +0,0 @@
 
-/**
 
- * @author Mugen87 / https://github.com/Mugen87
 
- *
 
- * Entity for a Doubly-Connected Edge List (DCEL).
 
- *
 
- */
 
-
 
-function HalfEdge( vertex, face ) {
 
-
 
-	this.vertex = vertex;
 
-	this.prev = null;
 
-	this.next = null;
 
-	this.twin = null;
 
-	this.face = face;
 
-
 
-}
 
-
 
-Object.assign( HalfEdge.prototype, {
 
-
 
-	head: function () {
 
-
 
-		return this.vertex;
 
-
 
-	},
 
-
 
-	tail: function () {
 
-
 
-		return this.prev ? this.prev.vertex : null;
 
-
 
-	},
 
-
 
-	length: function () {
 
-
 
-		var head = this.head();
 
-		var tail = this.tail();
 
-
 
-		if ( tail !== null ) {
 
-
 
-			return tail.point.distanceTo( head.point );
 
-
 
-		}
 
-
 
-		return - 1;
 
-
 
-	},
 
-
 
-	lengthSquared: function () {
 
-
 
-		var head = this.head();
 
-		var tail = this.tail();
 
-
 
-		if ( tail !== null ) {
 
-
 
-			return tail.point.distanceToSquared( head.point );
 
-
 
-		}
 
-
 
-		return - 1;
 
-
 
-	},
 
-
 
-	setTwin: function ( edge ) {
 
-
 
-		this.twin = edge;
 
-		edge.twin = this;
 
-
 
-		return this;
 
-
 
-	}
 
-
 
-} );
 
-
 
-
 
-export { HalfEdge };

+ 0 - 846
src/math/convexhull/QuickHull3.js
View File 

@@ -1,846 +0,0 @@
 
-import { Vertex } from './Vertex';
 
-import { VertexList } from './VertexList';
 
-import { Face } from './Face';
 
-import { Vector3 } from '../Vector3';
 
-import { Line3 } from '../Line3';
 
-import { Plane } from '../Plane';
 
-import { Visible, Deleted } from '../../constants';
 
-
 
-/**
 
- * @author Mugen87 / https://github.com/Mugen87
 
- *
 
- * Ported from: https://github.com/maurizzzio/quickhull3d/ by Mauricio Poppe (https://github.com/maurizzzio)
 
- *
 
- */
 
-
 
-function QuickHull3() {
 
-
 
-	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
 
-	// let 'v' be points wrapped as instance of 'Vertex'
 
-	//
 
-	//     [v, v, ..., v, v, v, ...]
 
-	//      ^             ^
 
-	//      |             |
 
-	//  a.outside     b.outside
 
-	//
 
-	this.assigned = new VertexList();
 
-	this.unassigned = new VertexList();
 
-
 
-	this.vertices = []; 	// vertices of the hull (internal representation of given geometry data)
 
-
 
-}
 
-
 
-Object.assign( QuickHull3.prototype, {
 
-
 
-	setFromPoints: function ( points ) {
 
-
 
-		if ( Array.isArray( points ) !== true ) {
 
-
 
-			console.error( 'THREE.QuickHull3: Points parameter is not an array.' );
 
-
 
-		}
 
-
 
-		if ( points.length < 4 ) {
 
-
 
-			console.error( 'THREE.QuickHull3: The algorithm needs at least four points.' );
 
-
 
-		}
 
-
 
-		this.makeEmpty();
 
-
 
-		for ( var i = 0, l = points.length; i < l; i ++ ) {
 
-
 
-			this.vertices.push( new Vertex( points[ i ] ) );
 
-
 
-		}
 
-
 
-		this.compute();
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	setFromObject: function ( object ) {
 
-
 
-		var points = [];
 
-
 
-		object.updateMatrixWorld( true );
 
-
 
-		object.traverse( function ( node ) {
 
-
 
-			var i, l, point;
 
-
 
-			var geometry = node.geometry;
 
-
 
-			if ( geometry !== undefined ) {
 
-
 
-				if ( geometry.isGeometry ) {
 
-
 
-					var vertices = geometry.vertices;
 
-
 
-					for ( i = 0, l = vertices.length; i < l; i ++ ) {
 
-
 
-						point = vertices[ i ].clone();
 
-						point.applyMatrix4( node.matrixWorld );
 
-
 
-						points.push( point );
 
-
 
-					}
 
-
 
-				} else if ( geometry.isBufferGeometry ) {
 
-
 
-					var attribute = geometry.attributes.position;
 
-
 
-					if ( attribute !== undefined ) {
 
-
 
-						for ( i = 0, l = attribute.count; i < l; i ++ ) {
 
-
 
-							point = new Vector3();
 
-
 
-							point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
 
-
 
-							points.push( point );
 
-
 
-						}
 
-
 
-					}
 
-
 
-				}
 
-
 
-			}
 
-
 
-		} );
 
-
 
-		return this.setFromPoints( points );
 
-
 
-	},
 
-
 
-	makeEmpty: function () {
 
-
 
-		this.faces = [];
 
-		this.vertices = [];
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Adds a vertex to the 'assigned' list of vertices and assigns it to the given face
 
-
 
-	addVertexToFace: function ( vertex, face ) {
 
-
 
-		vertex.face = face;
 
-
 
-		if ( face.outside === null ) {
 
-
 
-			this.assigned.append( vertex );
 
-
 
-		} else {
 
-
 
-			this.assigned.insertBefore( face.outside, vertex );
 
-
 
-		}
 
-
 
-		face.outside = vertex;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Removes a vertex from the 'assigned' list of vertices and from the given face
 
-
 
-	removeVertexFromFace: function ( 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;
 
-
 
-			}
 
-
 
-		}
 
-
 
-		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
 
-
 
-	removeAllVerticesFromFace: function ( face ) {
 
-
 
-		if ( face.outside !== null ) {
 
-
 
-			// reference to the first and last vertex of this face
 
-
 
-			var start = face.outside;
 
-			var end = face.outside;
 
-
 
-			while ( end.next !== null && end.next.face === face ) {
 
-
 
-				end = end.next;
 
-
 
-			}
 
-
 
-			this.assigned.removeSubList( start, end );
 
-
 
-			// fix references
 
-
 
-			start.prev = end.next = null;
 
-			face.outside = null;
 
-
 
-			return start;
 
-
 
-		}
 
-
 
-	},
 
-
 
-	// Removes all the visible vertices that 'face' is able to see
 
-
 
-	deleteFaceVertices: function ( face, absorbingFace ) {
 
-
 
-		var 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
 
-
 
-				var 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
 
-
 
-					var nextVertex = vertex.next;
 
-
 
-					var distance = absorbingFace.distanceToPoint( vertex.point );
 
-
 
-					// check if 'vertex' is able to see 'absorbingFace'
 
-
 
-					if ( distance > this.tolerance ) {
 
-
 
-						this.addVertexToFace( vertex, absorbingFace );
 
-
 
-					} else {
 
-
 
-						this.unassigned.append( vertex );
 
-
 
-					}
 
-
 
-					// now assign next vertex
 
-
 
-					vertex = nextVertex;
 
-
 
-				} while ( vertex !== null );
 
-
 
-			}
 
-
 
-		}
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Reassigns as many vertices as possible from the unassigned list to the new faces
 
-
 
-	resolveUnassignedPoints: function ( newFaces ) {
 
-
 
-		if ( this.unassigned.isEmpty() === false ) {
 
-
 
-			var vertex = this.unassigned.first();
 
-
 
-			do {
 
-
 
-				// buffer 'next' reference, see .deleteFaceVertices()
 
-
 
-				var nextVertex = vertex.next;
 
-
 
-				var maxDistance = this.tolerance;
 
-
 
-				var maxFace = null;
 
-
 
-				for ( var i = 0; i < newFaces.length; i ++ ) {
 
-
 
-					var face = newFaces[ i ];
 
-
 
-					if ( face.mark === Visible ) {
 
-
 
-						var distance = face.distanceToPoint( vertex.point );
 
-
 
-						if ( distance > maxDistance ) {
 
-
 
-							maxDistance = distance;
 
-							maxFace = face;
 
-
 
-						}
 
-
 
-						if ( maxDistance > 1000 * this.tolerance ) break;
 
-
 
-					}
 
-
 
-				}
 
-
 
-				// 'maxFace' can be null e.g. if there are identical vertices
 
-
 
-				if ( maxFace !== null ) {
 
-
 
-					this.addVertexToFace( vertex, maxFace );
 
-
 
-				}
 
-
 
-				vertex = nextVertex;
 
-
 
-			} while ( vertex !== null );
 
-
 
-		}
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Computes the extremes of a simplex which will be the initial hull
 
-
 
-	computeExtremes: function () {
 
-
 
-		var min = new Vector3();
 
-		var max = new Vector3();
 
-
 
-		var minVertices = [];
 
-		var maxVertices = [];
 
-
 
-		var i, l, j;
 
-
 
-		// initially assume that the first vertex is the min/max
 
-
 
-		for ( i = 0; i < 3; i ++ ) {
 
-
 
-			minVertices[ i ] = maxVertices[ i ] = this.vertices[ 0 ];
 
-
 
-		}
 
-
 
-		min.copy( this.vertices[ 0 ].point );
 
-		max.copy( this.vertices[ 0 ].point );
 
-
 
-		// compute the min/max vertex on all six directions
 
-
 
-		for ( i = 0, l = this.vertices.length; i < l ; i ++ ) {
 
-
 
-			var vertex = this.vertices[ i ];
 
-			var point = vertex.point;
 
-
 
-			// update the min coordinates
 
-
 
-			for ( j = 0; j < 3; j ++ ) {
 
-
 
-				if ( point.getComponent( j ) < min.getComponent( j ) ) {
 
-
 
-					min.setComponent( j, point.getComponent( j ) );
 
-					minVertices[ j ] = vertex;
 
-
 
-				}
 
-
 
-			}
 
-
 
-			// update the max coordinates
 
-
 
-			for ( j = 0; j < 3; j ++ ) {
 
-
 
-				if ( point.getComponent( j ) > max.getComponent( j ) ) {
 
-
 
-					max.setComponent( j, point.getComponent( j ) );
 
-					maxVertices[ j ] = vertex;
 
-
 
-				}
 
-
 
-			}
 
-
 
-		}
 
-
 
-		// 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 { min: minVertices, max: maxVertices };
 
-
 
-	},
 
-
 
-	// Computes the initial simplex assigning to its faces all the points
 
-	// that are candidates to form part of the hull
 
-
 
-	computeInitialHull: function () {
 
-
 
-		var line3, plane, closestPoint;
 
-
 
-		return function computeInitialHull () {
 
-
 
-			if ( line3 === undefined ) {
 
-
 
-				line3 = new Line3();
 
-				plane = new Plane();
 
-				closestPoint = new Vector3();
 
-
 
-			}
 
-
 
-			var vertex, vertices = this.vertices;
 
-			var extremes = this.computeExtremes();
 
-			var min = extremes.min;
 
-			var max = extremes.max;
 
-
 
-			var v0, v1, v2, v3;
 
-			var i, l, j;
 
-
 
-			// 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)
 
-
 
-			var distance, maxDistance = 0;
 
-			var index = 0;
 
-
 
-			for ( i = 0; i < 3; i ++ ) {
 
-
 
-				distance = max[ i ].point.getComponent( i ) - min[ i ].point.getComponent( i );
 
-
 
-				if ( distance > maxDistance ) {
 
-
 
-					maxDistance = distance;
 
-					index = i;
 
-
 
-				}
 
-
 
-			}
 
-
 
-			v0 = min[ index ];
 
-			v1 = max[ index ];
 
-
 
-			// 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 ( i = 0, l = this.vertices.length; i < l; i ++ ) {
 
-
 
-				vertex = vertices[ i ];
 
-
 
-				if ( vertex !== v0 && vertex !== v1 ) {
 
-
 
-					line3.closestPointToPoint( vertex.point, true, closestPoint );
 
-
 
-					distance = closestPoint.distanceToSquared( vertex.point );
 
-
 
-					if ( distance > maxDistance ) {
 
-
 
-						maxDistance = distance;
 
-						v2 = vertex;
 
-
 
-					}
 
-
 
-				}
 
-
 
-			}
 
-
 
-			// 3. The next vertex 'v3' is the one farthest to the plane 'v0', 'v1', 'v2'
 
-
 
-			maxDistance = 0;
 
-			plane.setFromCoplanarPoints( v0.point, v1.point, v2.point );
 
-
 
-			for ( i = 0, l = this.vertices.length; i < l; i ++ ) {
 
-
 
-				vertex = vertices[ i ];
 
-
 
-				if ( vertex !== v0 && vertex !== v1 && vertex !== v2 ) {
 
-
 
-					distance = Math.abs( plane.distanceToPoint( vertex.point ) );
 
-
 
-					if ( distance > maxDistance ) {
 
-
 
-						maxDistance = distance;
 
-						v3 = vertex;
 
-
 
-					}
 
-
 
-				}
 
-
 
-			}
 
-
 
-			var 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
 
-
 
-				for ( i = 0; i < 3; i ++ ) {
 
-
 
-					j = ( i + 1 ) % 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 ) );
 
-
 
-				}
 
-
 
-			} 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
 
-
 
-				for ( i = 0; i < 3; i ++ ) {
 
-
 
-					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 ) );
 
-
 
-					// join face[ i ] with face[ i + 1 ]
 
-
 
-					faces[ i + 1 ].getEdge( 0 ).setTwin( faces[ j + 1 ].getEdge( 1 ) );
 
-
 
-				}
 
-
 
-			}
 
-
 
-			// the initial hull is the tetrahedron
 
-
 
-			for ( i = 0; i < 4; i ++ ) {
 
-
 
-				this.faces.push( faces[ i ] );
 
-
 
-			}
 
-
 
-			// initial assignment of vertices to the faces of the tetrahedron
 
-
 
-			for ( i = 0, l = vertices.length; i < l; i ++ ) {
 
-
 
-				vertex = vertices[i];
 
-
 
-				if ( vertex !== v0 && vertex !== v1 && vertex !== v2 && vertex !== v3 ) {
 
-
 
-					maxDistance = this.tolerance;
 
-					var maxFace = null;
 
-
 
-					for ( j = 0; j < 4; j ++ ) {
 
-
 
-						distance = this.faces[ j ].distanceToPoint( vertex.point );
 
-
 
-						if ( distance > maxDistance ) {
 
-
 
-							maxDistance = distance;
 
-							maxFace = this.faces[ j ];
 
-
 
-						}
 
-
 
-					}
 
-
 
-					if ( maxFace !== null ) {
 
-
 
-          	this.addVertexToFace( vertex, maxFace );
 
-
 
-        	}
 
-
 
-				}
 
-
 
-			}
 
-
 
-			return this;
 
-
 
-		};
 
-
 
-	}(),
 
-
 
-	// Removes inactive faces
 
-
 
-	reindexFaces: function () {
 
-
 
-		var activeFaces = [];
 
-
 
-		for ( var i = 0; i < this.faces.length; i ++ ) {
 
-
 
-			var face = this.faces[ i ];
 
-
 
-			if ( face.mark === Visible ) {
 
-
 
-				activeFaces.push( face );
 
-
 
-			}
 
-
 
-		}
 
-
 
-		this.faces = activeFaces;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Finds the next vertex to create faces with the current hull
 
-
 
-	nextVertexToAdd: function () {
 
-
 
-		// if the 'assigned' list of vertices is empty, no vertices are left. return with 'undefined'
 
-
 
-		if ( this.assigned.isEmpty() === false ) {
 
-
 
-			var eyeVertex, maxDistance = 0;
 
-
 
-			// grap the first available face and start with the first visible vertex of that face
 
-
 
-			var eyeFace = this.assigned.first().face;
 
-			var vertex = eyeFace.outside;
 
-
 
-			// now calculate the farthest vertex that face can see
 
-
 
-			do {
 
-
 
-				var distance = eyeFace.distanceToPoint( vertex.point );
 
-
 
-				if ( distance > maxDistance ) {
 
-
 
-					maxDistance = distance;
 
-					eyeVertex = vertex;
 
-
 
-				}
 
-
 
-				vertex = vertex.next;
 
-
 
-			} while ( vertex !== null && vertex.face === eyeFace );
 
-
 
-			return eyeVertex;
 
-
 
-		}
 
-
 
-	},
 
-
 
-	// 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: function ( eyePoint, crossEdge, face, horizon ) {
 
-
 
-		// moves face's vertices to the 'unassigned' vertex list
 
-
 
-		this.deleteFaceVertices( face );
 
-
 
-		face.mark = Deleted;
 
-
 
-		var edge;
 
-
 
-		if ( crossEdge === null ) {
 
-
 
-			edge = crossEdge = face.getEdge( 0 );
 
-
 
-		} else {
 
-
 
-			// start from the next edge since 'crossEdge' was already analyzed
 
-			// (actually 'crossEdge.twin' was the edge who called this method recursively)
 
-
 
-			edge = crossEdge.next;
 
-
 
-		}
 
-
 
-		do {
 
-
 
-			var twinEdge = edge.twin;
 
-			var 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 );
 
-
 
-				}
 
-
 
-			}
 
-
 
-			edge = edge.next;
 
-
 
-		} while ( edge !== crossEdge );
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Creates a face with the vertices 'eyeVertex.point', 'horizonEdge.tail' and 'horizonEdge.head' in CCW order
 
-
 
-	addAdjoiningFace: function ( eyeVertex, horizonEdge ) {
 
-
 
-		// all the half edges are created in ccw order thus the face is always pointing outside the hull
 
-
 
-		var 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 )
 
-
 
-		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
 
-
 
-	addNewFaces: function ( eyeVertex, horizon ) {
 
-
 
-		this.newFaces = [];
 
-
 
-		var firstSideEdge = null;
 
-		var previousSideEdge = null;
 
-
 
-		for ( var i = 0; i < horizon.length; i ++ ) {
 
-
 
-			var horizonEdge = horizon[ i ];
 
-
 
-			// returns the right side edge
 
-
 
-			var sideEdge = this.addAdjoiningFace( eyeVertex, horizonEdge );
 
-
 
-			if ( firstSideEdge === null ) {
 
-
 
-				firstSideEdge = sideEdge;
 
-
 
-			} else {
 
-
 
-				// joins face.getEdge( 1 ) with previousFace.getEdge( 0 )
 
-
 
-				sideEdge.next.setTwin( previousSideEdge );
 
-
 
-			}
 
-
 
-			this.newFaces.push( sideEdge.face );
 
-			previousSideEdge = sideEdge;
 
-
 
-		}
 
-
 
-		// perform final join of new faces
 
-
 
-		firstSideEdge.next.setTwin( previousSideEdge );
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Adds a vertex to the hull
 
-
 
-	addVertexToHull: function ( eyeVertex ) {
 
-
 
-		var horizon = [];
 
-		var i, face;
 
-
 
-		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.resolveUnassignedPoints( this.newFaces );
 
-
 
-		return	this;
 
-
 
-	},
 
-
 
-	cleanup: function () {
 
-
 
-		this.assigned.clear();
 
-		this.unassigned.clear();
 
-		this.newFaces = [];
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	compute: function () {
 
-
 
-		var vertex;
 
-
 
-		this.computeInitialHull();
 
-
 
-		// add all available vertices gradually to the hull
 
-
 
-		while ( ( vertex = this.nextVertexToAdd() ) !== undefined ) {
 
-
 
-			this.addVertexToHull( vertex );
 
-
 
-		}
 
-
 
-		this.reindexFaces();
 
-
 
-		this.cleanup();
 
-
 
-		return this;
 
-
 
-	}
 
-
 
-} );
 
-
 
-
 
-export { QuickHull3 };

+ 0 - 17
src/math/convexhull/Vertex.js
View File 

@@ -1,17 +0,0 @@
 
-/**
 
- * @author Mugen87 / https://github.com/Mugen87
 
- *
 
- * A vertex as a double linked list node.
 
- *
 
- */
 
-
 
-function Vertex( point ) {
 
-
 
-	this.point = point;
 
-	this.prev = null;
 
-	this.next = null;
 
-	this.face = null; // the face that is able to see this vertex
 
-
 
-}
 
-
 
-export { Vertex };

+ 0 - 199
src/math/convexhull/VertexList.js
View File 

@@ -1,199 +0,0 @@
 
-/**
 
- * @author Mugen87 / https://github.com/Mugen87
 
- *
 
- */
 
-
 
-function VertexList() {
 
-
 
-	this.head = null;
 
-	this.tail = null;
 
-
 
-}
 
-
 
-Object.assign( VertexList.prototype, {
 
-
 
-	first: function () {
 
-
 
-		return this.head;
 
-
 
-	},
 
-
 
-	last: function () {
 
-
 
-		return this.tail;
 
-
 
-	},
 
-
 
-	clear: function () {
 
-
 
-		this.head = this.tail = null;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Inserts a vertex before the target vertex
 
-
 
-	insertBefore: function ( target, vertex ) {
 
-
 
-		vertex.prev = target.prev;
 
-		vertex.next = target;
 
-
 
-		if ( vertex.prev === null ) {
 
-
 
-			this.head = vertex;
 
-
 
-		} else {
 
-
 
-			vertex.prev.next = vertex;
 
-
 
-		}
 
-
 
-		target.prev = vertex;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Inserts a vertex after the target vertex
 
-
 
-	insertAfter: function ( target, vertex ) {
 
-
 
-		vertex.prev = target;
 
-		vertex.next = target.next;
 
-
 
-		if ( vertex.next === null ) {
 
-
 
-			this.tail = vertex;
 
-
 
-		} else {
 
-
 
-			vertex.next.prev = vertex;
 
-
 
-		}
 
-
 
-		target.next = vertex;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Appends a vertex to the end of the linked list
 
-
 
-	append: function ( vertex ) {
 
-
 
-		if ( this.head === null ) {
 
-
 
-			this.head = vertex;
 
-
 
-		} else {
 
-
 
-			this.tail.next = vertex;
 
-
 
-		}
 
-
 
-		vertex.prev = this.tail;
 
-		vertex.next = null; // the tail has no subsequent vertex
 
-
 
-		this.tail = vertex;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Appends a chain of vertices where 'vertex' is the head.
 
-
 
-	appendChain: function ( vertex ) {
 
-
 
-		if ( this.head === null ) {
 
-
 
-			this.head = vertex;
 
-
 
-		} else {
 
-
 
-			this.tail.next = vertex;
 
-
 
-		}
 
-
 
-		vertex.prev = this.tail;
 
-
 
-		// ensure that the 'tail' reference points to the last vertex of the chain
 
-
 
-		while ( vertex.next !== null ) {
 
-
 
-			vertex = vertex.next;
 
-
 
-		}
 
-
 
-		this.tail = vertex;
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Removes a vertex from the linked list
 
-
 
-	remove: function ( vertex ) {
 
-
 
-		if ( vertex.prev === null ) {
 
-
 
-			this.head = vertex.next;
 
-
 
-		} else {
 
-
 
-			vertex.prev.next = vertex.next;
 
-
 
-		}
 
-
 
-		if ( vertex.next === null ) {
 
-
 
-			this.tail = vertex.prev;
 
-
 
-		} else {
 
-
 
-			vertex.next.prev = vertex.prev;
 
-
 
-		}
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	// Removes a list of vertices whose 'head' is 'a' and whose 'tail' is b
 
-
 
-	removeSubList: function ( a, b ) {
 
-
 
-		if ( a.prev === null ) {
 
-
 
-			this.head = b.next;
 
-
 
-		} else {
 
-
 
-			a.prev.next = b.next;
 
-
 
-		}
 
-
 
-		if ( b.next === null ) {
 
-
 
-			this.tail = a.prev;
 
-
 
-		} else {
 
-
 
-			b.next.prev = a.prev;
 
-
 
-		}
 
-
 
-		return this;
 
-
 
-	},
 
-
 
-	isEmpty: function() {
 
-
 
-		return this.head === null;
 
-
 
-	}
 
-
 
-} );
 
-
 
-
 
-export { VertexList };