Skip to content

T
three.js

车家大少爷 / three.js
与 Fork 源项目一致

从无法访问的项目Fork

通知 2
Star 0
Fork 0
T
three.js

体验新版 GitCode，发现更多精彩内容 >>

提交 b42ce88d 编写于 作者: M Mr.doob 提交者： GitHub
浏览文件
操作

Merge pull request #10987 from Mugen87/quickhull 

New ConvexGeometry based on QuickHull
上级 ceb95383 b9e8f90a
隐藏空白更改
内联 并排
Showing with 1878 addition and 176 deletion
docs/examples/geometries/ConvexBufferGeometry.html 0 → 100644
浏览文件 @ b42ce88d
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<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>
[page:BufferGeometry] &rarr;
<h1>[name]</h1>
<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>
<script>
// iOS iframe auto-resize workaround
if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
var scene = document.getElementById( 'scene' );
scene.style.width = getComputedStyle( scene ).width;
scene.style.height = getComputedStyle( scene ).height;
scene.setAttribute( 'scrolling', 'no' );
}
</script>
<h2>Example</h2>
<code>var geometry = new THREE.ConvexBufferGeometry( points );
var material = new THREE.MeshBasicMaterial( {color: 0x00ff00} );
var mesh = new THREE.Mesh( geometry, material );
scene.add( mesh );
</code>
<h2>Constructor</h2>
<h3>[name]( [page:Array points] )</h3>
<div>
points — Array of [page:Vector3 Vector3s] that the resulting convex hull will contain.
</div>
<h2>Source</h2>
[link:https://github.com/mrdoob/three.js/blob/master/examples/js/geometries/ConvexGeometry.js examples/js/geometries/ConvexGeometry.js]
</body>
</html>
docs/examples/geometries/ConvexGeometry.html 0 → 100644
浏览文件 @ b42ce88d
<!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>
[page:Geometry] &rarr;
<h1>[name]</h1>
<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>
<script>
// iOS iframe auto-resize workaround
if ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) {
var scene = document.getElementById( 'scene' );
scene.style.width = getComputedStyle( scene ).width;
scene.style.height = getComputedStyle( scene ).height;
scene.setAttribute( 'scrolling', 'no' );
}
</script>
<h2>Example</h2>
<code>var geometry = new THREE.ConvexGeometry( points );
var material = new THREE.MeshBasicMaterial( {color: 0x00ff00} );
var mesh = new THREE.Mesh( geometry, material );
scene.add( mesh );
</code>
<h2>Constructor</h2>
<h3>[name]( [page:Array points] )</h3>
<div>
points — Array of [page:Vector3 Vector3s] that the resulting convex hull will contain.
</div>
<h2>Source</h2>
[link:https://github.com/mrdoob/three.js/blob/master/examples/js/geometries/ConvexGeometry.js examples/js/geometries/ConvexGeometry.js]
</body>
</html>
docs/examples/quickhull/Face.html 0 → 100644
浏览文件 @ b42ce88d
<!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:VertexNode 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:VertexNode a], [page:VertexNode b], [page:VertexNode c] )</h3>
[page:VertexNode a] - First vertex of the face.<br /><br />
[page:VertexNode b] - Second vertex of the face.<br /><br />
[page:VertexNode 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>
docs/examples/quickhull/HalfEdge.html 0 → 100644
浏览文件 @ b42ce88d
<!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:VertexNode vertex], [page:Face face] )</h3>
[page:VertexNode vertex] - [page:VertexNode] 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:VertexNode 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:VertexNode head]()</h3>
<div>Returns the destintation vertex.</div>
<h3>[method:VertexNode 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>
docs/examples/quickhull/QuickHull.html 0 → 100644
浏览文件 @ b42ce88d
<!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">
General information about the Quickhull algorithm: Dirk Gregorius. March 2014, Game Developers Conference: [link:http://media.steampowered.com/apps/valve/2014/DirkGregorius_ImplementingQuickHull.pdf Implementing QuickHull].
</div>
<h2>Constructor</h2>
<h3>[name]()</h3>
</div>
<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:Array faces]</h3>
<div>
The generated faces of the convex hull. Default is an empty array.
</div>
<h3>[property:Array newFaces]</h3>
<div>
This array holds the faces that are generated within a single iteration. Default is an empty array.
</div>
<h3>[property:VertexList assigned]</h3>
<div>
This [page:VertexList vertex list] holds all vertices that are assigned to a face. Default is an empty vertex list.
</div>
<h3>[property:VertexList unassigned]</h3>
<div>
This [page:VertexList vertex list] holds all vertices that are not assigned to a face. Default is an empty vertex list.
</div>
<h3>[property:Array vertices]</h3>
<div>
The internal representation of the given geometry data (an array of [page:VertexNode vertices]).
</div>
<h2>Methods</h2>
<h3>[method:QuickHull 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>
<h3>[method:QuickHull 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),
accounting for the world transforms of both the object and its childrens.</div>
<h3>[method:QuickHull makeEmpty]()</h3>
<div>Makes this convex hull empty.</div>
<h3>[method:QuickHull addVertexToFace]( [page:VertexNode vertex], [page:Face face] )</h3>
[page:VertexNodeNode 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>
<h3>[method:QuickHull removeVertexFromFace]( [page:VertexNode vertex], [page:Face face] )</h3>
[page:VertexNode 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>
<h3>[method:VertexNode 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>
<h3>[method:QuickHull 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.
<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>
<li>If a vertex cannot see 'absorbingFace', it's added to the 'unassigned' vertex list.</li>
</ul>
</div>
<h3>[method:QuickHull 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>
<h3>[method:Object computeExtremes]()</h3>
<div>Computes the extremes values (min/max vectors) which will be used to compute the inital hull.</div>
<h3>[method:QuickHull computeInitialHull]()</h3>
<div>Computes the initial simplex assigning to its faces all the points that are candidates to form part of the hull.</div>
<h3>[method:QuickHull reindexFaces]()</h3>
<div>Removes inactive (e.g. deleted) faces from the internal face list.</div>
<h3>[method:VertexNode nextVertexToAdd]()</h3>
<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>
<li>Otherwise for each vertex that face sees find the one furthest away from it.</li>
</ul>
</div>
<h3>[method:QuickHull 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>
<h3>[method:HalfEdge addAdjoiningFace]( [page:VertexNode eyeVertex], [page:HalfEdge horizonEdge] )</h3>
[page:VertexNode eyeVertex] - The vertex that is added to the hull.<br /><br />
[page:HalfEdge horizonEdge] - A single edge of the horizon.<br /><br />
<div>Creates a face with the vertices 'eyeVertex.point', 'horizonEdge.tail' and 'horizonEdge.head' in CCW order.
All the half edges are created in CCW order thus the face is always pointing outside the hull</div>
<h3>[method:QuickHull addNewFaces]( [page:VertexNode eyeVertex], [page:HalfEdge horizonEdge] )</h3>
[page:VertexNode eyeVertex] - The vertex that is added to the hull.<br /><br />
[page:HalfEdge horizon] - An array of half-edges that form the horizon.<br /><br />
<div>Adds 'horizon.length' faces to the hull, each face will be linked with the horizon opposite face and the face on the left/right.</div>
<h3>[method:QuickHull addVertexToHull]( [page:VertexNode eyeVertex] )</h3>
[page:VertexNode eyeVertex] - The vertex that is added to the hull.<br /><br />
<div>Adds a vertex to the hull with the following algorithm
<ul>
<li>Compute the 'horizon' which is a chain of half edges. For an edge to belong to this group it must be the edge connecting a face that can see 'eyeVertex' and a face which cannot see 'eyeVertex'.</li>
<li>All the faces that can see 'eyeVertex' have its visible vertices removed from the assigned vertex list.</li>
<li>A new set of faces is created with each edge of the 'horizon' and 'eyeVertex'. Each face is connected with the opposite horizon face and the face on the left/right.</li>
<li>The vertices removed from all the visible faces are assigned to the new faces if possible.</li>
</ul>
</div>
<h3>[method:QuickHull cleanup]()</h3>
<div>Cleans up internal properties after computing the convex hull.</div>
<h3>[method:QuickHull compute]()</h3>
<div>Starts the execution of the quick hull algorithm.</div>
<h2>Source</h2>
[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
</body>
</html>
docs/examples/quickhull/VertexList.html 0 → 100644
浏览文件 @ b42ce88d
<!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">
A doubly linked list of vertices.
</div>
<h2>Constructor</h2>
<h3>[name]()</h3>
</div>
<h2>Properties</h2>
<h3>[property:VertexNode head]</h3>
<div>
Reference to the first vertex of the linked list. Default is null.
</div>
<h3>[property:VertexNode tail]</h3>
<div>
Reference to the last vertex of the linked list. Default is null.
</div>
<h2>Methods</h2>
<h3>[method:VertexNode first]()</h3>
<div>Returns the head reference.</div>
<h3>[method:VertexNode last]()</h3>
<div>Returns the tail reference.</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 />
<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 />
[page:Vertex vertex] - The vertex to insert.<br /><br />
<div>Inserts a vertex <strong>after</strong> a target vertex.</div>
<h3>[method:VertexList append]( [page:Vertex vertex] )</h3>
[page:Vertex vertex] - The vertex to append.<br /><br />
<div>Appends a vertex to the end of the linked list.</div>
<h3>[method:VertexList appendChain]( [page:Vertex vertex] )</h3>
[page:Vertex vertex] - The head vertex of a chain of vertices.<br /><br />
<div>Appends a chain of vertices where the given vertex is the head.</div>
<h3>[method:VertexList remove]( [page:Vertex vertex] )</h3>
[page:Vertex vertex] - The vertex to remove.<br /><br />
<div>Removes a vertex from the linked list.</div>
<h3>[method:VertexList removeSubList]( [page:Vertex a], [page:Vertex b] )</h3>
[page:Vertex a] - The head of the sublist.<br /><br />
[page:Vertex b] - The tail of the sublist.<br /><br />
<div>Removes a sublist of vertices from the linked list.</div>
<h3>[method:Boolean isEmpty]()</h3>
<div>Returns true if the linked list is empty.</div>
<h2>Source</h2>
[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
</body>
</html>
docs/examples/quickhull/VertexNode.html 0 → 100644
浏览文件 @ b42ce88d
<!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">
A vertex as a double linked list node.
</div>
<h2>Constructor</h2>
<h3>[name]( [page:Vector3 point] )</h3>
[page:Vector3 point] - [page:Vector3] A point (x, y, z) in 3D space.<br /><br />
</div>
<h2>Properties</h2>
<h3>[property:Vector3 point]</h3>
<div>
A point (x, y, z) in 3D space. Default is undefined.
</div>
<h3>[property:VertexNode prev]</h3>
<div>
Reference to the previous vertex in the double linked list. Default is null.
</div>
<h3>[property:VertexNode next]</h3>
<div>
Reference to the next vertex in the double linked list. Default is null.
</div>
<h3>[property:Face face]</h3>
<div>
Reference to the face that is able to see this vertex. Default is undefined.
</div>
<h2>Source</h2>
[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]
</body>
</html>
docs/list.js
浏览文件 @ b42ce88d
......@@ -337,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" ],
......@@ -355,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" ]
]
......
docs/scenes/js/geometry.js
浏览文件 @ b42ce88d
......@@ -1330,7 +1330,7 @@ var guis = {
}
var folder = gui.addFolder( 'THREE.ExtrudeGeometry' );
var folder = gui.addFolder( 'THREE.ExtrudeBufferGeometry' );
folder.add( data, 'steps', 1, 10 ).step( 1 ).onChange( generateGeometry );
folder.add( data, 'amount', 1, 20 ).step( 1 ).onChange( generateGeometry );
......
examples/js/QuickHull.js 0 → 100644
浏览文件 @ b42ce88d
/**
* @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;
} ) ();
examples/js/geometries/ConvexGeometry.js
浏览文件 @ b42ce88d
/**
* @author qiao / https://github.com/qiao
* @fileoverview This is a convex hull generator using the incremental method.
* The complexity is O(n^2) where n is the number of vertices.
* O(nlogn) algorithms do exist, but they are much more complicated.
*
* Benchmark:
*
* Platform: CPU: P7350 @2.00GHz Engine: V8
*
* Num Vertices Time(ms)
*
* 10 1
* 20 3
* 30 19
* 40 48
* 50 107
* @author Mugen87 / https://github.com/Mugen87
*/
THREE.ConvexGeometry = function( vertices ) {
( function() {
THREE.Geometry.call( this );
// ConvexGeometry
var faces = [ [ 0, 1, 2 ], [ 0, 2, 1 ] ];
function ConvexGeometry( points ) {
for ( var i = 3; i < vertices.length; i ++ ) {
THREE.Geometry.call( this );
addPoint( i );
this.type = 'ConvexGeometry';
}
function addPoint( vertexId ) {
var vertex = vertices[ vertexId ].clone();
var mag = vertex.length();
vertex.x += mag * randomOffset();
vertex.y += mag * randomOffset();
vertex.z += mag * randomOffset();
var hole = [];
for ( var f = 0; f < faces.length; ) {
var face = faces[ f ];
// for each face, if the vertex can see it,
// then we try to add the face's edges into the hole.
if ( visible( face, vertex ) ) {
for ( var e = 0; e < 3; e ++ ) {
var edge = [ face[ e ], face[ ( e + 1 ) % 3 ] ];
var boundary = true;
// remove duplicated edges.
for ( var h = 0; h < hole.length; h ++ ) {
if ( equalEdge( hole[ h ], edge ) ) {
hole[ h ] = hole[ hole.length - 1 ];
hole.pop();
boundary = false;
break;
}
}
if ( boundary ) {
hole.push( edge );
}
}
// remove faces[ f ]
faces[ f ] = faces[ faces.length - 1 ];
faces.pop();
} else {
// not visible
f ++;
}
}
// construct the new faces formed by the edges of the hole and the vertex
for ( var h = 0; h < hole.length; h ++ ) {
faces.push( [
hole[ h ][ 0 ],
hole[ h ][ 1 ],
vertexId
] );
}
this.fromBufferGeometry( new ConvexBufferGeometry( points ) );
this.mergeVertices();
}
/**
* Whether the face is visible from the vertex
*/
function visible( face, vertex ) {
var va = vertices[ face[ 0 ] ];
var vb = vertices[ face[ 1 ] ];
var vc = vertices[ face[ 2 ] ];
var n = normal( va, vb, vc );
ConvexGeometry.prototype = Object.create( THREE.Geometry.prototype );
ConvexGeometry.prototype.constructor = ConvexGeometry;
// distance from face to origin
var dist = n.dot( va );
// ConvexBufferGeometry
return n.dot( vertex ) >= dist;
function ConvexBufferGeometry( points ) {
}
/**
* Face normal
*/
function normal( va, vb, vc ) {
THREE.BufferGeometry.call( this );
var cb = new THREE.Vector3();
var ab = new THREE.Vector3();
this.type = 'ConvexBufferGeometry';
cb.subVectors( vc, vb );
ab.subVectors( va, vb );
cb.cross( ab );
// buffers
cb.normalize();
var vertices = [];
var normals = [];
return cb;
// execute QuickHull
}
if ( THREE.QuickHull === undefined ) {
/**
* Detect whether two edges are equal.
* Note that when constructing the convex hull, two same edges can only
* be of the negative direction.
*/
function equalEdge( ea, eb ) {
console.error( 'THREE.ConvexBufferGeometry: ConvexBufferGeometry relies on THREE.QuickHull' );
return ea[ 0 ] === eb[ 1 ] && ea[ 1 ] === eb[ 0 ];
}
/**
* Create a random offset between -1e-6 and 1e-6.
*/
function randomOffset() {
}
return ( Math.random() - 0.5 ) * 2 * 1e-6;
var quickHull = new THREE.QuickHull().setFromPoints( points );
}
// generate vertices and normals
// Push vertices into `this.vertices`, skipping those inside the hull
var id = 0;
var newId = new Array( vertices.length ); // map from old vertex id to new id
var faces = quickHull.faces;
for ( var i = 0; i < faces.length; i ++ ) {
for ( var i = 0; i < faces.length; i ++ ) {
var face = faces[ i ];
var face = faces[ i ];
var edge = face.edge;
for ( var j = 0; j < 3; j ++ ) {
// we move along a doubly-connected edge list to access all face points (see HalfEdge docs)
if ( newId[ face[ j ] ] === undefined ) {
do {
newId[ face[ j ] ] = id ++;
this.vertices.push( vertices[ face[ j ] ] );
var point = edge.head().point;
}
vertices.push( point.x, point.y, point.z );
normals.push( face.normal.x, face.normal.y, face.normal.z );
face[ j ] = newId[ face[ j ] ];
edge = edge.next;
}
} while ( edge !== face.edge );
}
}
// Convert faces into instances of THREE.Face3
for ( var i = 0; i < faces.length; i ++ ) {
// build geometry
this.faces.push( new THREE.Face3(
faces[ i ][ 0 ],
faces[ i ][ 1 ],
faces[ i ][ 2 ]
) );
this.addAttribute( 'position', new THREE.Float32BufferAttribute( vertices, 3 ) );
this.addAttribute( 'normal', new THREE.Float32BufferAttribute( normals, 3 ) );
}
this.computeFaceNormals();
// Compute flat vertex normals
for ( var i = 0; i < this.faces.length; i ++ ) {
var face = this.faces[ i ];
var normal = face.normal;
face.vertexNormals[ 0 ] = normal.clone();
face.vertexNormals[ 1 ] = normal.clone();
face.vertexNormals[ 2 ] = normal.clone();
}
ConvexBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
ConvexBufferGeometry.prototype.constructor = ConvexBufferGeometry;
};
// export
THREE.ConvexGeometry.prototype = Object.create( THREE.Geometry.prototype );
THREE.ConvexGeometry.prototype.constructor = THREE.ConvexGeometry;
THREE.ConvexGeometry = ConvexGeometry;
THREE.ConvexBufferGeometry = ConvexBufferGeometry;
} ) ();
examples/webgl_geometry_convex.html
浏览文件 @ b42ce88d
......@@ -30,6 +30,7 @@
<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>
......@@ -53,11 +54,13 @@
document.body.appendChild( renderer.domElement );
// camera
camera = new THREE.PerspectiveCamera( 40, window.innerWidth / window.innerHeight, 1, 1000 );
camera.position.set( 15, 20, 30 );
scene.add( camera );
// controls
controls = new THREE.OrbitControls( camera, renderer.domElement );
controls.minDistance = 20;
controls.maxDistance = 50;
......@@ -65,12 +68,16 @@
scene.add( new THREE.AmbientLight( 0x222222 ) );
// light
var light = new THREE.PointLight( 0xffffff, 1 );
camera.add( light );
// helper
scene.add( new THREE.AxisHelper( 20 ) );
//
// textures
var loader = new THREE.TextureLoader();
var texture = loader.load( 'textures/sprites/disc.png' );
......@@ -108,7 +115,7 @@
transparent: true
} );
var meshGeometry = new THREE.ConvexGeometry( pointsGeometry.vertices );
var meshGeometry = new THREE.ConvexBufferGeometry( pointsGeometry.vertices );
mesh = new THREE.Mesh( meshGeometry, meshMaterial );
mesh.material.side = THREE.BackSide; // back faces
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或