|
|
@@ -1,7 +1,13 @@
|
|
|
import { BufferGeometry } from '../core/BufferGeometry.js';
|
|
|
import { Float32BufferAttribute } from '../core/BufferAttribute.js';
|
|
|
-import { Geometry } from '../core/Geometry.js';
|
|
|
import { MathUtils } from '../math/MathUtils.js';
|
|
|
+import { Triangle } from '../math/Triangle.js';
|
|
|
+import { Vector3 } from '../math/Vector3.js';
|
|
|
+
|
|
|
+const _v0 = new Vector3();
|
|
|
+const _v1 = new Vector3();
|
|
|
+const _normal = new Vector3();
|
|
|
+const _triangle = new Triangle();
|
|
|
|
|
|
class EdgesGeometry extends BufferGeometry {
|
|
|
|
|
|
@@ -17,94 +23,123 @@ class EdgesGeometry extends BufferGeometry {
|
|
|
|
|
|
thresholdAngle = ( thresholdAngle !== undefined ) ? thresholdAngle : 1;
|
|
|
|
|
|
- // buffer
|
|
|
+ if ( geometry.isGeometry ) {
|
|
|
|
|
|
- const vertices = [];
|
|
|
+ geometry = new BufferGeometry().fromGeometry( geometry );
|
|
|
|
|
|
- // helper variables
|
|
|
+ }
|
|
|
|
|
|
+ const precisionPoints = 4;
|
|
|
+ const precision = Math.pow( 10, precisionPoints );
|
|
|
const thresholdDot = Math.cos( MathUtils.DEG2RAD * thresholdAngle );
|
|
|
- const edge = [ 0, 0 ], edges = {};
|
|
|
- let edge1, edge2, key;
|
|
|
- const keys = [ 'a', 'b', 'c' ];
|
|
|
|
|
|
- // prepare source geometry
|
|
|
+ const indexAttr = geometry.getIndex();
|
|
|
+ const positionAttr = geometry.getAttribute( 'position' );
|
|
|
+ const indexCount = indexAttr ? indexAttr.count : positionAttr.count;
|
|
|
|
|
|
- let geometry2;
|
|
|
+ const indexArr = [ 0, 0, 0 ];
|
|
|
+ const vertKeys = [ 'a', 'b', 'c' ];
|
|
|
+ const hashes = new Array( 3 );
|
|
|
|
|
|
- if ( geometry.isBufferGeometry ) {
|
|
|
+ const edgeData = {};
|
|
|
+ const vertices = [];
|
|
|
+ for ( let i = 0; i < indexCount; i += 3 ) {
|
|
|
|
|
|
- geometry2 = new Geometry();
|
|
|
- geometry2.fromBufferGeometry( geometry );
|
|
|
+ if ( indexAttr ) {
|
|
|
|
|
|
- } else {
|
|
|
+ indexArr[ 0 ] = indexAttr.getX( i );
|
|
|
+ indexArr[ 1 ] = indexAttr.getX( i + 1 );
|
|
|
+ indexArr[ 2 ] = indexAttr.getX( i + 2 );
|
|
|
|
|
|
- geometry2 = geometry.clone();
|
|
|
+ } else {
|
|
|
|
|
|
- }
|
|
|
+ indexArr[ 0 ] = i;
|
|
|
+ indexArr[ 1 ] = i + 1;
|
|
|
+ indexArr[ 2 ] = i + 2;
|
|
|
|
|
|
- geometry2.mergeVertices();
|
|
|
- geometry2.computeFaceNormals();
|
|
|
+ }
|
|
|
+
|
|
|
+ const { a, b, c } = _triangle;
|
|
|
+ a.fromBufferAttribute( positionAttr, indexArr[ 0 ] );
|
|
|
+ b.fromBufferAttribute( positionAttr, indexArr[ 1 ] );
|
|
|
+ c.fromBufferAttribute( positionAttr, indexArr[ 2 ] );
|
|
|
+ _triangle.getNormal( _normal );
|
|
|
|
|
|
- const sourceVertices = geometry2.vertices;
|
|
|
- const faces = geometry2.faces;
|
|
|
+ // create hashes for the edge from the vertices
|
|
|
+ hashes[ 0 ] = `${ Math.round( a.x * precision ) },${ Math.round( a.y * precision ) },${ Math.round( a.z * precision ) }`;
|
|
|
+ hashes[ 1 ] = `${ Math.round( b.x * precision ) },${ Math.round( b.y * precision ) },${ Math.round( b.z * precision ) }`;
|
|
|
+ hashes[ 2 ] = `${ Math.round( c.x * precision ) },${ Math.round( c.y * precision ) },${ Math.round( c.z * precision ) }`;
|
|
|
|
|
|
- // now create a data structure where each entry represents an edge with its adjoining faces
|
|
|
+ // skip degenerate triangles
|
|
|
+ if ( hashes[ 0 ] === hashes[ 1 ] || hashes[ 1 ] === hashes[ 2 ] || hashes[ 2 ] === hashes[ 0 ] ) {
|
|
|
|
|
|
- for ( let i = 0, l = faces.length; i < l; i ++ ) {
|
|
|
+ continue;
|
|
|
|
|
|
- const face = faces[ i ];
|
|
|
+ }
|
|
|
|
|
|
+ // iterate over every edge
|
|
|
for ( let j = 0; j < 3; j ++ ) {
|
|
|
|
|
|
- edge1 = face[ keys[ j ] ];
|
|
|
- edge2 = face[ keys[ ( j + 1 ) % 3 ] ];
|
|
|
- edge[ 0 ] = Math.min( edge1, edge2 );
|
|
|
- edge[ 1 ] = Math.max( edge1, edge2 );
|
|
|
+ // get the first and next vertex making up the edge
|
|
|
+ const jNext = ( j + 1 ) % 3;
|
|
|
+ const vecHash0 = hashes[ j ];
|
|
|
+ const vecHash1 = hashes[ jNext ];
|
|
|
+ const v0 = _triangle[ vertKeys[ j ] ];
|
|
|
+ const v1 = _triangle[ vertKeys[ jNext ] ];
|
|
|
|
|
|
- key = edge[ 0 ] + ',' + edge[ 1 ];
|
|
|
+ const hash = `${ vecHash0 }_${ vecHash1 }`;
|
|
|
+ const reverseHash = `${ vecHash1 }_${ vecHash0 }`;
|
|
|
|
|
|
- if ( edges[ key ] === undefined ) {
|
|
|
+ if ( reverseHash in edgeData && edgeData[ reverseHash ] ) {
|
|
|
|
|
|
- edges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ], face1: i, face2: undefined };
|
|
|
+ // if we found a sibling edge add it into the vertex array if
|
|
|
+ // it meets the angle threshold and delete the edge from the map.
|
|
|
+ if ( _normal.dot( edgeData[ reverseHash ].normal ) <= thresholdDot ) {
|
|
|
|
|
|
- } else {
|
|
|
+ vertices.push( v0.x, v0.y, v0.z );
|
|
|
+ vertices.push( v1.x, v1.y, v1.z );
|
|
|
|
|
|
- edges[ key ].face2 = i;
|
|
|
+ }
|
|
|
|
|
|
- }
|
|
|
+ edgeData[ reverseHash ] = null;
|
|
|
|
|
|
- }
|
|
|
+ } else if ( ! ( hash in edgeData ) ) {
|
|
|
|
|
|
- }
|
|
|
+ // if we've already got an edge here then skip adding a new one
|
|
|
+ edgeData[ hash ] = {
|
|
|
|
|
|
- // generate vertices
|
|
|
+ index0: indexArr[ j ],
|
|
|
+ index1: indexArr[ jNext ],
|
|
|
+ normal: _normal.clone(),
|
|
|
|
|
|
- for ( key in edges ) {
|
|
|
+ };
|
|
|
|
|
|
- const e = edges[ key ];
|
|
|
+ }
|
|
|
|
|
|
- // an edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. default = 1 degree.
|
|
|
+ }
|
|
|
|
|
|
- if ( e.face2 === undefined || faces[ e.face1 ].normal.dot( faces[ e.face2 ].normal ) <= thresholdDot ) {
|
|
|
+ }
|
|
|
|
|
|
- let vertex = sourceVertices[ e.index1 ];
|
|
|
- vertices.push( vertex.x, vertex.y, vertex.z );
|
|
|
+ // iterate over all remaining, unmatched edges and add them to the vertex array
|
|
|
+ for ( const key in edgeData ) {
|
|
|
|
|
|
- vertex = sourceVertices[ e.index2 ];
|
|
|
- vertices.push( vertex.x, vertex.y, vertex.z );
|
|
|
+ if ( edgeData[ key ] ) {
|
|
|
+
|
|
|
+ const { index0, index1 } = edgeData[ key ];
|
|
|
+ _v0.fromBufferAttribute( positionAttr, index0 );
|
|
|
+ _v1.fromBufferAttribute( positionAttr, index1 );
|
|
|
+
|
|
|
+ vertices.push( _v0.x, _v0.y, _v0.z );
|
|
|
+ vertices.push( _v1.x, _v1.y, _v1.z );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
- // build geometry
|
|
|
-
|
|
|
this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
-
|
|
|
export { EdgesGeometry };
|
Amos