webvr js meetup initial commit
This commit is contained in:
Senad Uka
793
node_modules/three/examples/js/modifiers/BufferSubdivisionModifier.js
generated
vendored
Normal file
793
node_modules/three/examples/js/modifiers/BufferSubdivisionModifier.js
generated
vendored
Normal file
@@ -0,0 +1,793 @@
|
||||
/*
|
||||
* @author zz85 / http://twitter.com/blurspline / http://www.lab4games.net/zz85/blog
|
||||
* @author Matthew Adams / http://www.centerionware.com - added UV support and rewrote to use buffergeometry.
|
||||
*
|
||||
* Subdivision Geometry Modifier using Loop Subdivision Scheme for Geometry / BufferGeometry
|
||||
*
|
||||
* References:
|
||||
* http://graphics.stanford.edu/~mdfisher/subdivision.html
|
||||
* http://www.holmes3d.net/graphics/subdivision/
|
||||
* http://www.cs.rutgers.edu/~decarlo/readings/subdiv-sg00c.pdf
|
||||
*
|
||||
* Known Issues:
|
||||
* - currently doesn't handle "Sharp Edges"
|
||||
* - no checks to prevent breaking when uv's don't exist.
|
||||
* - vertex colors are unsupported.
|
||||
* **DDS Images when using corrected uv's passed to subdivision modifier will have their uv's flipy'd within the correct uv set
|
||||
* **Either flipy the DDS image, or use shaders. Don't try correcting the uv's before passing into subdiv (eg: v=1-v).
|
||||
*
|
||||
* @input THREE.Geometry, or index'd THREE.BufferGeometry with faceUV's (Not vertex uv's)
|
||||
* @output non-indexed vertex points, uv's, normals.
|
||||
*
|
||||
* The TypedArrayHelper class is designed to assist managing typed arrays, and to allow the removal of all 'new Vector3, new Face3, new Vector2'.
|
||||
*
|
||||
* It will automatically resize them if trying to push a new element to an array that isn't long enough
|
||||
* It provides 'registers' that the units can be mapped to. This allows a small set of objects
|
||||
* (ex: vector3's, face3's, vector2's) to be allocated then used, to eliminate any need to rewrite all
|
||||
* the features those classes offer while not requiring some_huge_number to be allocated.
|
||||
* It should be moved into it's own file honestly, then included before the BufferSubdivisionModifier - maybe in three's core?
|
||||
*
|
||||
*/
|
||||
|
||||
THREE.Face3.prototype.set = function( a, b, c ) {
|
||||
|
||||
this.a = a;
|
||||
this.b = b;
|
||||
this.c = c;
|
||||
|
||||
};
|
||||
|
||||
var TypedArrayHelper = function( size, registers, register_type, array_type, unit_size, accessors ) {
|
||||
|
||||
this.array_type = array_type;
|
||||
this.register_type = register_type;
|
||||
this.unit_size = unit_size;
|
||||
this.accessors = accessors;
|
||||
this.buffer = new array_type( size * unit_size );
|
||||
this.register = [];
|
||||
this.length = 0;
|
||||
this.real_length = size;
|
||||
this.available_registers = registers;
|
||||
|
||||
for ( var i = 0; i < registers; i++ ) {
|
||||
|
||||
this.register.push( new register_type() );
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
TypedArrayHelper.prototype = {
|
||||
|
||||
constructor: TypedArrayHelper,
|
||||
|
||||
index_to_register: function( index, register, isLoop ) {
|
||||
|
||||
var base = index * this.unit_size;
|
||||
|
||||
if ( register >= this.available_registers ) {
|
||||
|
||||
throw new Error( 'THREE.BufferSubdivisionModifier: Not enough registers in TypedArrayHelper.' );
|
||||
|
||||
}
|
||||
|
||||
if ( index > this.length ) {
|
||||
|
||||
throw new Error( 'THREE.BufferSubdivisionModifier: Index is out of range in TypedArrayHelper.' );
|
||||
|
||||
}
|
||||
|
||||
for ( var i = 0; i < this.unit_size; i++ ) {
|
||||
|
||||
( this.register[ register ] )[ this.accessors[ i ] ] = this.buffer[ base + i ];
|
||||
|
||||
}
|
||||
|
||||
},
|
||||
|
||||
resize: function( new_size ) {
|
||||
|
||||
if ( new_size === 0 ) {
|
||||
|
||||
new_size = 8;
|
||||
|
||||
}
|
||||
|
||||
if ( new_size < this.length ) {
|
||||
|
||||
this.buffer = this.buffer.subarray( 0, this.length * this.unit_size );
|
||||
|
||||
} else {
|
||||
|
||||
var nBuffer;
|
||||
|
||||
if ( this.buffer.length < new_size * this.unit_size ) {
|
||||
|
||||
nBuffer = new this.array_type( new_size * this.unit_size );
|
||||
nBuffer.set( this.buffer );
|
||||
this.buffer = nBuffer;
|
||||
this.real_length = new_size;
|
||||
|
||||
} else {
|
||||
|
||||
nBuffer = new this.array_type( new_size * this.unit_size );
|
||||
nBuffer.set( this.buffer.subarray( 0, this.length * this.unit_size ) );
|
||||
this.buffer = nBuffer;
|
||||
this.real_length = new_size;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
},
|
||||
|
||||
from_existing: function( oldArray ) {
|
||||
|
||||
var new_size = oldArray.length;
|
||||
this.buffer = new this.array_type( new_size );
|
||||
this.buffer.set( oldArray );
|
||||
this.length = oldArray.length / this.unit_size;
|
||||
this.real_length = this.length;
|
||||
|
||||
},
|
||||
|
||||
push_element: function( vector ) {
|
||||
|
||||
if ( this.length + 1 > this.real_length ) {
|
||||
|
||||
this.resize( this.real_length * 2 );
|
||||
|
||||
}
|
||||
|
||||
var bpos = this.length * this.unit_size;
|
||||
|
||||
for ( var i = 0; i < this.unit_size; i++ ) {
|
||||
|
||||
this.buffer[ bpos + i ] = vector[ this.accessors[ i ] ];
|
||||
|
||||
}
|
||||
|
||||
this.length++;
|
||||
|
||||
},
|
||||
|
||||
trim_size: function() {
|
||||
|
||||
if ( this.length < this.real_length ) {
|
||||
|
||||
this.resize( this.length );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
function convertGeometryToIndexedBuffer( geometry ) {
|
||||
|
||||
var BGeom = new THREE.BufferGeometry();
|
||||
|
||||
// create a new typed array
|
||||
var vertArray = new TypedArrayHelper( geometry.vertices.length, 0, THREE.Vector3, Float32Array, 3, [ 'x', 'y', 'z' ] );
|
||||
var indexArray = new TypedArrayHelper( geometry.faces.length, 0, THREE.Face3, Uint32Array, 3, [ 'a', 'b', 'c' ] );
|
||||
var uvArray = new TypedArrayHelper( geometry.faceVertexUvs[0].length * 3 * 3, 0, THREE.Vector2, Float32Array, 2, [ 'x', 'y' ] );
|
||||
|
||||
var i, il;
|
||||
|
||||
for ( i = 0, il = geometry.vertices.length; i < il; i++ ) {
|
||||
|
||||
vertArray.push_element( geometry.vertices[ i ] );
|
||||
|
||||
}
|
||||
|
||||
for ( i = 0, il = geometry.faces.length; i < il; i++ ) {
|
||||
|
||||
indexArray.push_element( geometry.faces[ i ] );
|
||||
|
||||
}
|
||||
|
||||
for ( i = 0, il = geometry.faceVertexUvs[ 0 ].length; i < il; i++ ) {
|
||||
|
||||
uvArray.push_element( geometry.faceVertexUvs[ 0 ][ i ][ 0 ] );
|
||||
uvArray.push_element( geometry.faceVertexUvs[ 0 ][ i ][ 1 ] );
|
||||
uvArray.push_element( geometry.faceVertexUvs[ 0 ][ i ][ 2 ] );
|
||||
|
||||
}
|
||||
|
||||
indexArray.trim_size();
|
||||
vertArray.trim_size();
|
||||
uvArray.trim_size();
|
||||
|
||||
BGeom.setIndex( new THREE.BufferAttribute( indexArray.buffer, 3 ) );
|
||||
BGeom.addAttribute( 'position', new THREE.BufferAttribute( vertArray.buffer, 3 ) );
|
||||
BGeom.addAttribute( 'uv', new THREE.BufferAttribute( uvArray.buffer, 2 ) );
|
||||
|
||||
return BGeom;
|
||||
|
||||
}
|
||||
|
||||
function compute_vertex_normals( geometry ) {
|
||||
|
||||
var ABC = [ 'a', 'b', 'c' ];
|
||||
var XYZ = [ 'x', 'y', 'z' ];
|
||||
var XY = [ 'x', 'y' ];
|
||||
|
||||
var oldVertices = new TypedArrayHelper( 0, 5, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
var oldFaces = new TypedArrayHelper( 0, 3, THREE.Face3, Uint32Array, 3, ABC );
|
||||
oldVertices.from_existing( geometry.getAttribute( 'position' ).array );
|
||||
var newNormals = new TypedArrayHelper( oldVertices.length * 3, 4, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
var newNormalFaces = new TypedArrayHelper( oldVertices.length, 1, function () { this.x = 0; }, Float32Array, 1, [ 'x' ] );
|
||||
|
||||
newNormals.length = oldVertices.length;
|
||||
oldFaces.from_existing( geometry.index.array );
|
||||
var a, b, c;
|
||||
var i, j, jl;
|
||||
var my_weight;
|
||||
var full_weights = [ 0.0, 0.0, 0.0 ];
|
||||
|
||||
for ( i = 0, il = oldFaces.length; i < il; i++ ) {
|
||||
|
||||
oldFaces.index_to_register( i, 0 );
|
||||
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].a, 0 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].b, 1 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].c, 2 );
|
||||
|
||||
newNormals.register[ 0 ].subVectors( oldVertices.register[ 1 ], oldVertices.register[ 0 ] );
|
||||
newNormals.register[ 1 ].subVectors( oldVertices.register[ 2 ], oldVertices.register[ 1 ] );
|
||||
newNormals.register[ 0 ].cross( newNormals.register[ 1 ] );
|
||||
my_weight = Math.abs( newNormals.register[ 0 ].length() );
|
||||
|
||||
newNormalFaces.buffer[ oldFaces.register[ 0 ].a ] += my_weight;
|
||||
newNormalFaces.buffer[ oldFaces.register[ 0 ].b ] += my_weight;
|
||||
newNormalFaces.buffer[ oldFaces.register[ 0 ].c ] += my_weight;
|
||||
|
||||
}
|
||||
|
||||
var tmpx, tmpy, tmpz;
|
||||
var t_len;
|
||||
|
||||
for ( i = 0, il = oldFaces.length; i < il; i++ ) {
|
||||
|
||||
oldFaces.index_to_register( i, 0 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].a, 0 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].b, 1 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].c, 2 );
|
||||
|
||||
newNormals.register[ 0 ].subVectors( oldVertices.register[ 1 ], oldVertices.register[ 0 ] );
|
||||
newNormals.register[ 1 ].subVectors( oldVertices.register[ 2 ], oldVertices.register[ 0 ] );
|
||||
|
||||
newNormals.register[ 3 ].set( 0, 0, 0 );
|
||||
newNormals.register[ 3 ].x = ( newNormals.register[ 0 ].y * newNormals.register[ 1 ].z ) - ( newNormals.register[ 0 ].z * newNormals.register[ 1 ].y );
|
||||
newNormals.register[ 3 ].y = ( newNormals.register[ 0 ].z * newNormals.register[ 1 ].x ) - ( newNormals.register[ 0 ].x * newNormals.register[ 1 ].z );
|
||||
newNormals.register[ 3 ].z = ( newNormals.register[ 0 ].x * newNormals.register[ 1 ].y ) - ( newNormals.register[ 0 ].y * newNormals.register[ 1 ].x );
|
||||
|
||||
newNormals.register[ 0 ].cross( newNormals.register[ 1 ] );
|
||||
|
||||
my_weight = Math.abs( newNormals.register[ 0 ].length() );
|
||||
|
||||
full_weights[ 0 ] = ( my_weight / newNormalFaces.buffer[ oldFaces.register[ 0 ].a ] );
|
||||
full_weights[ 1 ] = ( my_weight / newNormalFaces.buffer[ oldFaces.register[ 0 ].b ] );
|
||||
full_weights[ 2 ] = ( my_weight / newNormalFaces.buffer[ oldFaces.register[ 0 ].c ] );
|
||||
|
||||
tmpx = newNormals.register[ 3 ].x * full_weights[ 0 ];
|
||||
tmpy = newNormals.register[ 3 ].y * full_weights[ 0 ];
|
||||
tmpz = newNormals.register[ 3 ].z * full_weights[ 0 ];
|
||||
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].a * 3 ) + 0 ] += newNormals.register[ 3 ].x * full_weights[ 0 ];
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].a * 3 ) + 1 ] += newNormals.register[ 3 ].y * full_weights[ 0 ];
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].a * 3 ) + 2 ] += newNormals.register[ 3 ].z * full_weights[ 0 ];
|
||||
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].b * 3 ) + 0 ] += newNormals.register[ 3 ].x * full_weights[ 1 ];
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].b * 3 ) + 1 ] += newNormals.register[ 3 ].y * full_weights[ 1 ];
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].b * 3 ) + 2 ] += newNormals.register[ 3 ].z * full_weights[ 1 ];
|
||||
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].c * 3 ) + 0 ] += newNormals.register[ 3 ].x * full_weights[ 2 ];
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].c * 3 ) + 1 ] += newNormals.register[ 3 ].y * full_weights[ 2 ];
|
||||
newNormals.buffer[ ( oldFaces.register[ 0 ].c * 3 ) + 2 ] += newNormals.register[ 3 ].z * full_weights[ 2 ];
|
||||
|
||||
}
|
||||
|
||||
newNormals.trim_size();
|
||||
geometry.addAttribute( 'normal', new THREE.BufferAttribute( newNormals.buffer, 3 ) );
|
||||
|
||||
}
|
||||
|
||||
function unIndexIndexedGeometry( geometry ) {
|
||||
|
||||
var ABC = [ 'a', 'b', 'c' ];
|
||||
var XYZ = [ 'x', 'y', 'z' ];
|
||||
var XY = [ 'x', 'y' ];
|
||||
|
||||
var oldVertices = new TypedArrayHelper( 0, 3, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
var oldFaces = new TypedArrayHelper( 0, 3, THREE.Face3, Uint32Array, 3, ABC );
|
||||
var oldUvs = new TypedArrayHelper( 0, 3, THREE.Vector2, Float32Array, 2, XY );
|
||||
var oldNormals = new TypedArrayHelper( 0, 3, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
|
||||
oldVertices.from_existing( geometry.getAttribute( 'position' ).array );
|
||||
oldFaces.from_existing( geometry.index.array );
|
||||
oldUvs.from_existing( geometry.getAttribute( 'uv' ).array );
|
||||
|
||||
compute_vertex_normals( geometry );
|
||||
oldNormals.from_existing( geometry.getAttribute( 'normal' ).array );
|
||||
|
||||
var newVertices = new TypedArrayHelper( oldFaces.length * 3, 3, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
var newNormals = new TypedArrayHelper( oldFaces.length * 3, 3, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
var newUvs = new TypedArrayHelper( oldFaces.length * 3, 3, THREE.Vector2, Float32Array, 2, XY );
|
||||
var v, w;
|
||||
|
||||
for ( var i = 0, il = oldFaces.length; i < il; i++ ) {
|
||||
|
||||
oldFaces.index_to_register( i, 0 );
|
||||
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].a, 0 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].b, 1 );
|
||||
oldVertices.index_to_register( oldFaces.register[ 0 ].c, 2 );
|
||||
|
||||
newVertices.push_element( oldVertices.register[ 0 ] );
|
||||
newVertices.push_element( oldVertices.register[ 1 ] );
|
||||
newVertices.push_element( oldVertices.register[ 2 ] );
|
||||
|
||||
if ( oldUvs.length !== 0 ) {
|
||||
|
||||
oldUvs.index_to_register( ( i * 3 ) + 0, 0 );
|
||||
oldUvs.index_to_register( ( i * 3 ) + 1, 1 );
|
||||
oldUvs.index_to_register( ( i * 3 ) + 2, 2 );
|
||||
|
||||
newUvs.push_element( oldUvs.register[ 0 ] );
|
||||
newUvs.push_element( oldUvs.register[ 1 ] );
|
||||
newUvs.push_element( oldUvs.register[ 2 ] );
|
||||
|
||||
}
|
||||
|
||||
oldNormals.index_to_register( oldFaces.register[ 0 ].a, 0 );
|
||||
oldNormals.index_to_register( oldFaces.register[ 0 ].b, 1 );
|
||||
oldNormals.index_to_register( oldFaces.register[ 0 ].c, 2 );
|
||||
|
||||
newNormals.push_element( oldNormals.register[ 0 ] );
|
||||
newNormals.push_element( oldNormals.register[ 1 ] );
|
||||
newNormals.push_element( oldNormals.register[ 2 ] );
|
||||
|
||||
}
|
||||
|
||||
newVertices.trim_size();
|
||||
newUvs.trim_size();
|
||||
newNormals.trim_size();
|
||||
|
||||
geometry.index = null;
|
||||
|
||||
geometry.addAttribute( 'position', new THREE.BufferAttribute( newVertices.buffer, 3 ) );
|
||||
geometry.addAttribute( 'normal', new THREE.BufferAttribute( newNormals.buffer, 3 ) );
|
||||
|
||||
if ( newUvs.length !== 0 ) {
|
||||
|
||||
geometry.addAttribute( 'uv', new THREE.BufferAttribute( newUvs.buffer, 2 ) );
|
||||
|
||||
}
|
||||
|
||||
return geometry;
|
||||
|
||||
}
|
||||
|
||||
THREE.BufferSubdivisionModifier = function( subdivisions ) {
|
||||
|
||||
this.subdivisions = ( subdivisions === undefined ) ? 1 : subdivisions;
|
||||
|
||||
};
|
||||
|
||||
THREE.BufferSubdivisionModifier.prototype.modify = function( geometry ) {
|
||||
|
||||
if ( geometry instanceof THREE.Geometry ) {
|
||||
|
||||
geometry.mergeVertices();
|
||||
|
||||
if ( typeof geometry.normals === 'undefined' ) {
|
||||
|
||||
geometry.normals = [];
|
||||
|
||||
}
|
||||
|
||||
geometry = convertGeometryToIndexedBuffer( geometry );
|
||||
|
||||
} else if ( !( geometry instanceof THREE.BufferGeometry ) ) {
|
||||
|
||||
console.error( 'THREE.BufferSubdivisionModifier: Geometry is not an instance of THREE.BufferGeometry or THREE.Geometry' );
|
||||
|
||||
}
|
||||
|
||||
var repeats = this.subdivisions;
|
||||
|
||||
while ( repeats -- > 0 ) {
|
||||
|
||||
this.smooth( geometry );
|
||||
|
||||
}
|
||||
|
||||
return unIndexIndexedGeometry( geometry );
|
||||
|
||||
};
|
||||
|
||||
var edge_type = function ( a, b ) {
|
||||
|
||||
this.a = a;
|
||||
this.b = b;
|
||||
this.faces = [];
|
||||
this.newEdge = null;
|
||||
|
||||
};
|
||||
|
||||
( function () {
|
||||
|
||||
// Some constants
|
||||
var ABC = [ 'a', 'b', 'c' ];
|
||||
var XYZ = [ 'x', 'y', 'z' ];
|
||||
var XY = [ 'x', 'y' ];
|
||||
|
||||
function getEdge( a, b, map ) {
|
||||
|
||||
var key = Math.min( a, b ) + '_' + Math.max( a, b );
|
||||
return map[ key ];
|
||||
|
||||
}
|
||||
|
||||
|
||||
function processEdge( a, b, vertices, map, face, metaVertices ) {
|
||||
|
||||
var vertexIndexA = Math.min( a, b );
|
||||
var vertexIndexB = Math.max( a, b );
|
||||
|
||||
var key = vertexIndexA + '_' + vertexIndexB;
|
||||
|
||||
var edge;
|
||||
|
||||
if ( key in map ) {
|
||||
|
||||
edge = map[ key ];
|
||||
|
||||
} else {
|
||||
|
||||
edge = new edge_type( vertexIndexA,vertexIndexB );
|
||||
map[key] = edge;
|
||||
|
||||
}
|
||||
|
||||
edge.faces.push( face );
|
||||
|
||||
metaVertices[ a ].edges.push( edge );
|
||||
metaVertices[ b ].edges.push( edge );
|
||||
|
||||
}
|
||||
|
||||
function generateLookups( vertices, faces, metaVertices, edges ) {
|
||||
|
||||
var i, il, face, edge;
|
||||
|
||||
for ( i = 0, il = vertices.length; i < il; i++ ) {
|
||||
|
||||
metaVertices[ i ] = { edges: [] };
|
||||
|
||||
}
|
||||
|
||||
for ( i = 0, il = faces.length; i < il; i++ ) {
|
||||
|
||||
faces.index_to_register( i, 0 );
|
||||
face = faces.register[ 0 ]; // Faces is now a TypedArrayHelper class, not a face3.
|
||||
|
||||
processEdge( face.a, face.b, vertices, edges, i, metaVertices );
|
||||
processEdge( face.b, face.c, vertices, edges, i, metaVertices );
|
||||
processEdge( face.c, face.a, vertices, edges, i, metaVertices );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function newFace( newFaces, face ) {
|
||||
|
||||
newFaces.push_element( face );
|
||||
|
||||
}
|
||||
|
||||
function midpoint( a, b ) {
|
||||
|
||||
return ( Math.abs( b - a ) / 2 ) + Math.min( a, b );
|
||||
|
||||
}
|
||||
|
||||
function newUv( newUvs, a, b, c ) {
|
||||
|
||||
newUvs.push_element( a );
|
||||
newUvs.push_element( b );
|
||||
newUvs.push_element( c );
|
||||
|
||||
}
|
||||
|
||||
/////////////////////////////
|
||||
|
||||
// Performs one iteration of Subdivision
|
||||
|
||||
THREE.BufferSubdivisionModifier.prototype.smooth = function ( geometry ) {
|
||||
|
||||
var oldVertices, oldFaces, oldUvs;
|
||||
var newVertices, newFaces, newUVs;
|
||||
|
||||
var n, l, i, il, j, k;
|
||||
var metaVertices, sourceEdges;
|
||||
|
||||
oldVertices = new TypedArrayHelper( 0, 3, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
oldFaces = new TypedArrayHelper( 0, 3, THREE.Face3, Uint32Array, 3, ABC );
|
||||
oldUvs = new TypedArrayHelper( 0, 3, THREE.Vector2, Float32Array, 2, XY );
|
||||
oldVertices.from_existing( geometry.getAttribute( 'position' ).array );
|
||||
oldFaces.from_existing( geometry.index.array );
|
||||
oldUvs.from_existing( geometry.getAttribute( 'uv' ).array );
|
||||
|
||||
var doUvs = false;
|
||||
|
||||
if ( typeof oldUvs !== 'undefined' && oldUvs.length !== 0 ) {
|
||||
|
||||
doUvs = true;
|
||||
|
||||
}
|
||||
/******************************************************
|
||||
*
|
||||
* Step 0: Preprocess Geometry to Generate edges Lookup
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
metaVertices = new Array( oldVertices.length );
|
||||
sourceEdges = {}; // Edge => { oldVertex1, oldVertex2, faces[] }
|
||||
|
||||
generateLookups( oldVertices, oldFaces, metaVertices, sourceEdges );
|
||||
|
||||
|
||||
/******************************************************
|
||||
*
|
||||
* Step 1.
|
||||
* For each edge, create a new Edge Vertex,
|
||||
* then position it.
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
newVertices = new TypedArrayHelper( ( geometry.getAttribute( 'position' ).array.length * 2 ) / 3, 2, THREE.Vector3, Float32Array, 3, XYZ );
|
||||
var other, currentEdge, newEdge, face;
|
||||
var edgeVertexWeight, adjacentVertexWeight, connectedFaces;
|
||||
|
||||
var tmp = newVertices.register[ 1 ];
|
||||
for ( i in sourceEdges ) {
|
||||
|
||||
currentEdge = sourceEdges[ i ];
|
||||
newEdge = newVertices.register[ 0 ];
|
||||
|
||||
edgeVertexWeight = 3 / 8;
|
||||
adjacentVertexWeight = 1 / 8;
|
||||
|
||||
connectedFaces = currentEdge.faces.length;
|
||||
|
||||
// check how many linked faces. 2 should be correct.
|
||||
if ( connectedFaces !== 2 ) {
|
||||
|
||||
// if length is not 2, handle condition
|
||||
edgeVertexWeight = 0.5;
|
||||
adjacentVertexWeight = 0;
|
||||
|
||||
}
|
||||
|
||||
oldVertices.index_to_register( currentEdge.a, 0 );
|
||||
oldVertices.index_to_register( currentEdge.b, 1 );
|
||||
newEdge.addVectors( oldVertices.register[ 0 ], oldVertices.register[ 1 ] ).multiplyScalar( edgeVertexWeight );
|
||||
|
||||
tmp.set( 0, 0, 0 );
|
||||
|
||||
for ( j = 0; j < connectedFaces; j++ ) {
|
||||
|
||||
oldFaces.index_to_register( currentEdge.faces[ j ], 0 );
|
||||
face = oldFaces.register[ 0 ];
|
||||
|
||||
for ( k = 0; k < 3; k++ ) {
|
||||
|
||||
oldVertices.index_to_register( face[ ABC[ k ] ], 2 );
|
||||
other = oldVertices.register[ 2 ];
|
||||
|
||||
if ( face[ ABC[ k ] ] !== currentEdge.a && face[ ABC[ k ] ] !== currentEdge.b) {
|
||||
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
tmp.add( other );
|
||||
|
||||
}
|
||||
|
||||
tmp.multiplyScalar( adjacentVertexWeight );
|
||||
newEdge.add( tmp );
|
||||
|
||||
currentEdge.newEdge = newVertices.length;
|
||||
newVertices.push_element( newEdge );
|
||||
|
||||
}
|
||||
|
||||
var edgeLength = newVertices.length;
|
||||
/******************************************************
|
||||
*
|
||||
* Step 2.
|
||||
* Reposition each source vertices.
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
var beta, sourceVertexWeight, connectingVertexWeight;
|
||||
var connectingEdge, connectingEdges, oldVertex, newSourceVertex;
|
||||
|
||||
for ( i = 0, il = oldVertices.length; i < il; i++ ) {
|
||||
|
||||
oldVertices.index_to_register( i, 0, XYZ );
|
||||
oldVertex = oldVertices.register[ 0 ];
|
||||
|
||||
// find all connecting edges (using lookupTable)
|
||||
connectingEdges = metaVertices[ i ].edges;
|
||||
n = connectingEdges.length;
|
||||
|
||||
if ( n === 3 ) {
|
||||
|
||||
beta = 3 / 16;
|
||||
|
||||
} else if (n > 3) {
|
||||
|
||||
beta = 3 / (8 * n); // Warren's modified formula
|
||||
|
||||
}
|
||||
|
||||
// Loop's original beta formula
|
||||
// beta = 1 / n * ( 5/8 - Math.pow( 3/8 + 1/4 * Math.cos( 2 * Math. PI / n ), 2) );
|
||||
|
||||
sourceVertexWeight = 1 - n * beta;
|
||||
connectingVertexWeight = beta;
|
||||
|
||||
if ( n <= 2 ) {
|
||||
|
||||
// crease and boundary rules
|
||||
|
||||
if ( n === 2 ) {
|
||||
|
||||
sourceVertexWeight = 3 / 4;
|
||||
connectingVertexWeight = 1 / 8;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
newSourceVertex = oldVertex.multiplyScalar( sourceVertexWeight );
|
||||
|
||||
tmp.set( 0, 0, 0 );
|
||||
|
||||
for ( j = 0; j < n; j++ ) {
|
||||
|
||||
connectingEdge = connectingEdges[ j ];
|
||||
other = connectingEdge.a !== i ? connectingEdge.a : connectingEdge.b;
|
||||
oldVertices.index_to_register( other, 1, XYZ );
|
||||
tmp.add( oldVertices.register[ 1 ] );
|
||||
|
||||
}
|
||||
|
||||
tmp.multiplyScalar( connectingVertexWeight );
|
||||
newSourceVertex.add( tmp );
|
||||
|
||||
newVertices.push_element( newSourceVertex,XYZ );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/******************************************************
|
||||
*
|
||||
* Step 3.
|
||||
* Generate faces between source vertices and edge vertices.
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
|
||||
var edge1, edge2, edge3;
|
||||
newFaces = new TypedArrayHelper( ( geometry.index.array.length * 4 ) / 3, 1, THREE.Face3, Float32Array, 3, ABC );
|
||||
newUVs = new TypedArrayHelper( ( geometry.getAttribute( 'uv' ).array.length * 4 ) / 2, 3, THREE.Vector2, Float32Array, 2, XY );
|
||||
var x3 = newUVs.register[ 0 ];
|
||||
var x4 = newUVs.register[ 1 ];
|
||||
var x5 = newUVs.register[ 2 ];
|
||||
var tFace = newFaces.register[ 0 ];
|
||||
|
||||
for ( i = 0, il = oldFaces.length; i < il; i++ ) {
|
||||
|
||||
oldFaces.index_to_register( i, 0 );
|
||||
face = oldFaces.register[ 0 ];
|
||||
|
||||
// find the 3 new edges vertex of each old face
|
||||
// The new source verts are added after the new edge verts now..
|
||||
|
||||
edge1 = getEdge( face.a, face.b, sourceEdges ).newEdge;
|
||||
edge2 = getEdge( face.b, face.c, sourceEdges ).newEdge;
|
||||
edge3 = getEdge( face.c, face.a, sourceEdges ).newEdge;
|
||||
|
||||
// create 4 faces.
|
||||
tFace.set( edge1, edge2, edge3 );
|
||||
newFace( newFaces, tFace );
|
||||
tFace.set( face.a + edgeLength, edge1, edge3 );
|
||||
newFace( newFaces, tFace );
|
||||
tFace.set( face.b + edgeLength, edge2, edge1 );
|
||||
newFace( newFaces, tFace );
|
||||
tFace.set( face.c + edgeLength, edge3, edge2 );
|
||||
newFace( newFaces, tFace );
|
||||
|
||||
|
||||
/*
|
||||
|
||||
|
||||
0___________________C___________________2
|
||||
\ /\ /
|
||||
\ / \ F4 /
|
||||
\ F2 / \ /
|
||||
\ / \ /
|
||||
\ / \ /
|
||||
\ / F1 \ /
|
||||
\/_______________________\/
|
||||
A \ / B
|
||||
\ F3 /
|
||||
\ /
|
||||
\ /
|
||||
\ /
|
||||
\ /
|
||||
\ /
|
||||
\ /
|
||||
\/
|
||||
1
|
||||
|
||||
|
||||
Draw orders:
|
||||
F1: ABC x3,x4,x5
|
||||
F2: 0AC x0,x3,x5
|
||||
F3: 1BA x1,x4,x3
|
||||
F4: 2CB x2,x5,x4
|
||||
|
||||
0: x0
|
||||
1: x1
|
||||
2: x2
|
||||
A: x3
|
||||
B: x4
|
||||
C: x5
|
||||
*/
|
||||
|
||||
if ( doUvs === true ) {
|
||||
|
||||
oldUvs.index_to_register( ( i * 3 ) + 0, 0 );
|
||||
oldUvs.index_to_register( ( i * 3 ) + 1, 1 );
|
||||
oldUvs.index_to_register( ( i * 3 ) + 2, 2 );
|
||||
|
||||
x0 = oldUvs.register[ 0 ]; //uv[0];
|
||||
x1 = oldUvs.register[ 1 ]; //uv[1];
|
||||
x2 = oldUvs.register[ 2 ]; //uv[2];
|
||||
|
||||
x3.set( midpoint( x0.x, x1.x ), midpoint( x0.y, x1.y ) );
|
||||
x4.set( midpoint( x1.x, x2.x ), midpoint( x1.y, x2.y ) );
|
||||
x5.set( midpoint( x0.x, x2.x ), midpoint( x0.y, x2.y ) );
|
||||
|
||||
newUv( newUVs, x3, x4, x5 );
|
||||
newUv( newUVs, x0, x3, x5 );
|
||||
|
||||
newUv( newUVs, x1, x4, x3 );
|
||||
newUv( newUVs, x2, x5, x4 );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Overwrite old arrays
|
||||
|
||||
newFaces.trim_size();
|
||||
newVertices.trim_size();
|
||||
newUVs.trim_size();
|
||||
|
||||
geometry.setIndex( new THREE.BufferAttribute( newFaces.buffer ,3 ) );
|
||||
geometry.addAttribute( 'position', new THREE.BufferAttribute( newVertices.buffer, 3 ) );
|
||||
geometry.addAttribute( 'uv', new THREE.BufferAttribute( newUVs.buffer, 2 ) );
|
||||
|
||||
};
|
||||
|
||||
} ) ();
|
||||
42
node_modules/three/examples/js/modifiers/ExplodeModifier.js
generated
vendored
Normal file
42
node_modules/three/examples/js/modifiers/ExplodeModifier.js
generated
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* Make all faces use unique vertices
|
||||
* so that each face can be separated from others
|
||||
*
|
||||
* @author alteredq / http://alteredqualia.com/
|
||||
*/
|
||||
|
||||
THREE.ExplodeModifier = function () {
|
||||
|
||||
};
|
||||
|
||||
THREE.ExplodeModifier.prototype.modify = function ( geometry ) {
|
||||
|
||||
var vertices = [];
|
||||
|
||||
for ( var i = 0, il = geometry.faces.length; i < il; i ++ ) {
|
||||
|
||||
var n = vertices.length;
|
||||
|
||||
var face = geometry.faces[ i ];
|
||||
|
||||
var a = face.a;
|
||||
var b = face.b;
|
||||
var c = face.c;
|
||||
|
||||
var va = geometry.vertices[ a ];
|
||||
var vb = geometry.vertices[ b ];
|
||||
var vc = geometry.vertices[ c ];
|
||||
|
||||
vertices.push( va.clone() );
|
||||
vertices.push( vb.clone() );
|
||||
vertices.push( vc.clone() );
|
||||
|
||||
face.a = n;
|
||||
face.b = n + 1;
|
||||
face.c = n + 2;
|
||||
|
||||
}
|
||||
|
||||
geometry.vertices = vertices;
|
||||
|
||||
};
|
||||
461
node_modules/three/examples/js/modifiers/SimplifyModifier.js
generated
vendored
Normal file
461
node_modules/three/examples/js/modifiers/SimplifyModifier.js
generated
vendored
Normal file
@@ -0,0 +1,461 @@
|
||||
/*
|
||||
* @author zz85 / http://twitter.com/blurspline / http://www.lab4games.net/zz85/blog
|
||||
*
|
||||
* Simplification Geometry Modifier
|
||||
* - based on code and technique
|
||||
* - by Stan Melax in 1998
|
||||
* - Progressive Mesh type Polygon Reduction Algorithm
|
||||
* - http://www.melax.com/polychop/
|
||||
*/
|
||||
|
||||
THREE.SimplifyModifier = function() {
|
||||
|
||||
};
|
||||
|
||||
(function() {
|
||||
|
||||
var cb = new THREE.Vector3(), ab = new THREE.Vector3();
|
||||
|
||||
function pushIfUnique( array, object ) {
|
||||
|
||||
if ( array.indexOf( object ) === -1 ) array.push( object );
|
||||
|
||||
}
|
||||
|
||||
function removeFromArray( array, object ) {
|
||||
|
||||
var k = array.indexOf( object );
|
||||
if ( k > -1 ) array.splice( k, 1 );
|
||||
|
||||
}
|
||||
|
||||
function computeEdgeCollapseCost( u, v ) {
|
||||
|
||||
// if we collapse edge uv by moving u to v then how
|
||||
// much different will the model change, i.e. the "error".
|
||||
|
||||
var edgelength = v.position.distanceTo( u.position );
|
||||
var curvature = 0;
|
||||
|
||||
var sideFaces = [];
|
||||
var i, uFaces = u.faces, il = u.faces.length, face, sideFace;
|
||||
|
||||
// find the "sides" triangles that are on the edge uv
|
||||
for ( i = 0 ; i < il; i ++ ) {
|
||||
|
||||
face = u.faces[ i ];
|
||||
|
||||
if ( face.hasVertex(v) ) {
|
||||
|
||||
sideFaces.push( face );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// use the triangle facing most away from the sides
|
||||
// to determine our curvature term
|
||||
for ( i = 0 ; i < il; i ++ ) {
|
||||
|
||||
var minCurvature = 1;
|
||||
face = u.faces[ i ];
|
||||
|
||||
for( var j = 0; j < sideFaces.length; j ++ ) {
|
||||
|
||||
sideFace = sideFaces[ j ];
|
||||
// use dot product of face normals.
|
||||
var dotProd = face.normal.dot( sideFace.normal );
|
||||
minCurvature = Math.min( minCurvature, ( 1.001 - dotProd ) / 2);
|
||||
}
|
||||
|
||||
curvature = Math.max( curvature, minCurvature );
|
||||
}
|
||||
|
||||
// crude approach in attempt to preserve borders
|
||||
// though it seems not to be totally correct
|
||||
var borders = 0;
|
||||
if ( sideFaces.length < 2 ) {
|
||||
|
||||
// we add some arbitrary cost for borders,
|
||||
// borders += 10;
|
||||
curvature = 1;
|
||||
}
|
||||
|
||||
var amt = edgelength * curvature + borders;
|
||||
|
||||
return amt;
|
||||
|
||||
}
|
||||
|
||||
function computeEdgeCostAtVertex( v ) {
|
||||
// compute the edge collapse cost for all edges that start
|
||||
// from vertex v. Since we are only interested in reducing
|
||||
// the object by selecting the min cost edge at each step, we
|
||||
// only cache the cost of the least cost edge at this vertex
|
||||
// (in member variable collapse) as well as the value of the
|
||||
// cost (in member variable collapseCost).
|
||||
|
||||
if ( v.neighbors.length === 0 ) {
|
||||
|
||||
// collapse if no neighbors.
|
||||
v.collapseNeighbor = null;
|
||||
v.collapseCost = - 0.01;
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
v.collapseCost = 100000;
|
||||
v.collapseNeighbor = null;
|
||||
|
||||
// search all neighboring edges for "least cost" edge
|
||||
for ( var i = 0; i < v.neighbors.length; i ++ ) {
|
||||
|
||||
var collapseCost = computeEdgeCollapseCost( v, v.neighbors[ i ] );
|
||||
|
||||
if ( !v.collapseNeighbor ) {
|
||||
v.collapseNeighbor = v.neighbors[ i ];
|
||||
v.collapseCost = collapseCost;
|
||||
v.minCost = collapseCost;
|
||||
v.totalCost = 0;
|
||||
v.costCount = 0;
|
||||
}
|
||||
|
||||
v.costCount ++;
|
||||
v.totalCost += collapseCost;
|
||||
|
||||
if ( collapseCost < v.minCost ) {
|
||||
|
||||
v.collapseNeighbor = v.neighbors[ i ];
|
||||
v.minCost = collapseCost;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// we average the cost of collapsing at this vertex
|
||||
v.collapseCost = v.totalCost / v.costCount;
|
||||
// v.collapseCost = v.minCost;
|
||||
|
||||
}
|
||||
|
||||
function removeVertex( v, vertices ) {
|
||||
|
||||
console.assert( v.faces.length === 0 );
|
||||
|
||||
while ( v.neighbors.length ) {
|
||||
|
||||
var n = v.neighbors.pop();
|
||||
removeFromArray( n.neighbors, v );
|
||||
|
||||
}
|
||||
|
||||
removeFromArray( vertices, v );
|
||||
|
||||
}
|
||||
|
||||
function removeFace( f, faces ) {
|
||||
|
||||
removeFromArray( faces, f );
|
||||
|
||||
if ( f.v1 ) removeFromArray( f.v1.faces, f );
|
||||
if ( f.v2 ) removeFromArray( f.v2.faces, f );
|
||||
if ( f.v3 ) removeFromArray( f.v3.faces, f );
|
||||
|
||||
// TODO optimize this!
|
||||
var vs = [ this.v1, this.v2, this.v3 ];
|
||||
var v1, v2;
|
||||
|
||||
for( var i = 0 ; i < 3 ; i ++ ) {
|
||||
v1 = vs[ i ];
|
||||
v2 = vs[( i+1) % 3 ];
|
||||
|
||||
if( !v1 || !v2 ) continue;
|
||||
v1.removeIfNonNeighbor( v2 );
|
||||
v2.removeIfNonNeighbor( v1 );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function collapse( vertices, faces, u, v ) { // u and v are pointers to vertices of an edge
|
||||
|
||||
// Collapse the edge uv by moving vertex u onto v
|
||||
|
||||
if ( !v ) {
|
||||
|
||||
// u is a vertex all by itself so just delete it..
|
||||
removeVertex( u, vertices );
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
var i;
|
||||
var tmpVertices = [];
|
||||
|
||||
for( i = 0 ; i < u.neighbors.length; i ++ ) {
|
||||
|
||||
tmpVertices.push( u.neighbors[ i ] );
|
||||
|
||||
}
|
||||
|
||||
|
||||
// delete triangles on edge uv:
|
||||
for( i = u.faces.length - 1; i >= 0; i -- ) {
|
||||
|
||||
if ( u.faces[ i ].hasVertex( v ) ) {
|
||||
|
||||
removeFace( u.faces[ i ], faces );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// update remaining triangles to have v instead of u
|
||||
for( i = u.faces.length -1 ; i >= 0; i -- ) {
|
||||
|
||||
u.faces[i].replaceVertex( u, v );
|
||||
|
||||
}
|
||||
|
||||
|
||||
removeVertex( u, vertices );
|
||||
|
||||
// recompute the edge collapse costs in neighborhood
|
||||
for( i = 0; i < tmpVertices.length; i ++ ) {
|
||||
|
||||
computeEdgeCostAtVertex( tmpVertices[ i ] );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
function minimumCostEdge( vertices ) {
|
||||
|
||||
// O(n * n) approach. TODO optimize this
|
||||
|
||||
var least = vertices[ 0 ];
|
||||
|
||||
for (var i = 0; i < vertices.length; i ++ ) {
|
||||
|
||||
if ( vertices[ i ].collapseCost < least.collapseCost ) {
|
||||
|
||||
least = vertices[ i ];
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return least;
|
||||
|
||||
}
|
||||
|
||||
// we use a triangle class to represent structure of face slightly differently
|
||||
|
||||
function Triangle( v1, v2, v3, a, b, c ) {
|
||||
this.a = a;
|
||||
this.b = b;
|
||||
this.c = c;
|
||||
|
||||
this.v1 = v1;
|
||||
this.v2 = v2;
|
||||
this.v3 = v3;
|
||||
|
||||
this.normal = new THREE.Vector3();
|
||||
|
||||
this.computeNormal();
|
||||
|
||||
v1.faces.push( this );
|
||||
v1.addUniqueNeighbor( v2 );
|
||||
v1.addUniqueNeighbor( v3 );
|
||||
|
||||
v2.faces.push( this );
|
||||
v2.addUniqueNeighbor( v1 );
|
||||
v2.addUniqueNeighbor( v3 );
|
||||
|
||||
|
||||
v3.faces.push( this );
|
||||
v3.addUniqueNeighbor( v1 );
|
||||
v3.addUniqueNeighbor( v2 );
|
||||
|
||||
}
|
||||
|
||||
Triangle.prototype.computeNormal = function() {
|
||||
|
||||
var vA = this.v1.position;
|
||||
var vB = this.v2.position;
|
||||
var vC = this.v3.position;
|
||||
|
||||
cb.subVectors( vC, vB );
|
||||
ab.subVectors( vA, vB );
|
||||
cb.cross( ab ).normalize();
|
||||
|
||||
this.normal.copy( cb );
|
||||
|
||||
};
|
||||
|
||||
Triangle.prototype.hasVertex = function( v ) {
|
||||
|
||||
return v === this.v1 || v === this.v2 || v === this.v3;
|
||||
|
||||
};
|
||||
|
||||
Triangle.prototype.replaceVertex = function( oldv, newv ) {
|
||||
|
||||
if ( oldv === this.v1 ) this.v1 = newv;
|
||||
else if ( oldv === this.v2 ) this.v2 = newv;
|
||||
else if ( oldv === this.v3 ) this.v3 = newv;
|
||||
|
||||
removeFromArray( oldv.faces, this );
|
||||
newv.faces.push( this );
|
||||
|
||||
|
||||
oldv.removeIfNonNeighbor( this.v1 );
|
||||
this.v1.removeIfNonNeighbor( oldv );
|
||||
|
||||
oldv.removeIfNonNeighbor( this.v2 );
|
||||
this.v2.removeIfNonNeighbor( oldv );
|
||||
|
||||
oldv.removeIfNonNeighbor( this.v3 );
|
||||
this.v3.removeIfNonNeighbor( oldv );
|
||||
|
||||
this.v1.addUniqueNeighbor( this.v2 );
|
||||
this.v1.addUniqueNeighbor( this.v3 );
|
||||
|
||||
this.v2.addUniqueNeighbor( this.v1 );
|
||||
this.v2.addUniqueNeighbor( this.v3 );
|
||||
|
||||
this.v3.addUniqueNeighbor( this.v1 );
|
||||
this.v3.addUniqueNeighbor( this.v2 );
|
||||
|
||||
this.computeNormal();
|
||||
|
||||
};
|
||||
|
||||
function Vertex( v, id ) {
|
||||
|
||||
this.position = v;
|
||||
|
||||
this.id = id; // old index id
|
||||
|
||||
this.faces = []; // faces vertex is connected
|
||||
this.neighbors = []; // neighbouring vertices aka "adjacentVertices"
|
||||
|
||||
// these will be computed in computeEdgeCostAtVertex()
|
||||
this.collapseCost = 0; // cost of collapsing this vertex, the less the better. aka objdist
|
||||
this.collapseNeighbor = null; // best candinate for collapsing
|
||||
|
||||
}
|
||||
|
||||
Vertex.prototype.addUniqueNeighbor = function( vertex ) {
|
||||
pushIfUnique(this.neighbors, vertex);
|
||||
};
|
||||
|
||||
Vertex.prototype.removeIfNonNeighbor = function( n ) {
|
||||
|
||||
var neighbors = this.neighbors;
|
||||
var faces = this.faces;
|
||||
|
||||
var offset = neighbors.indexOf( n );
|
||||
if ( offset === -1 ) return;
|
||||
for ( var i = 0; i < faces.length; i ++ ) {
|
||||
|
||||
if ( faces[ i ].hasVertex( n ) ) return;
|
||||
|
||||
}
|
||||
|
||||
neighbors.splice( offset, 1 );
|
||||
};
|
||||
|
||||
THREE.SimplifyModifier.prototype.modify = function( geometry, count ) {
|
||||
|
||||
if ( geometry instanceof THREE.BufferGeometry && !geometry.vertices && !geometry.faces ) {
|
||||
console.log('converting BufferGeometry to Geometry');
|
||||
geometry = new THREE.Geometry().fromBufferGeometry( geometry );
|
||||
}
|
||||
|
||||
geometry.mergeVertices();
|
||||
|
||||
var oldVertices = geometry.vertices; // Three Position
|
||||
var oldFaces = geometry.faces; // Three Face
|
||||
|
||||
var newGeometry = new THREE.Geometry();
|
||||
|
||||
// conversion
|
||||
var vertices = new Array( oldVertices.length ); // Simplify Custom Vertex Struct
|
||||
var faces = new Array( oldFaces.length ); // Simplify Custom Traignle Struct
|
||||
|
||||
var i, il, face;
|
||||
|
||||
//
|
||||
// put data of original geometry in different data structures
|
||||
//
|
||||
|
||||
// add vertices
|
||||
for ( i = 0, il = oldVertices.length; i < il; i ++ ) {
|
||||
|
||||
vertices[ i ] = new Vertex( oldVertices[ i ], i );
|
||||
|
||||
}
|
||||
|
||||
// add faces
|
||||
for ( i = 0, il = oldFaces.length; i < il; i ++ ) {
|
||||
|
||||
face = oldFaces[ i ];
|
||||
faces[ i ] = new Triangle( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ], face.a, face.b, face.c );
|
||||
|
||||
}
|
||||
|
||||
// compute all edge collapse costs
|
||||
for ( i = 0, il = vertices.length; i < il; i ++ ) {
|
||||
|
||||
computeEdgeCostAtVertex( vertices[ i ] );
|
||||
|
||||
}
|
||||
|
||||
var permutation = new Array( vertices.length );
|
||||
var map = new Array( vertices.length );
|
||||
|
||||
var nextVertex;
|
||||
|
||||
var z = count;
|
||||
|
||||
// console.time('z')
|
||||
// console.profile('zz');
|
||||
|
||||
while( z-- ) {
|
||||
nextVertex = minimumCostEdge( vertices );
|
||||
if (!nextVertex) {
|
||||
console.log('no next vertex');
|
||||
break;
|
||||
}
|
||||
collapse( vertices, faces, nextVertex, nextVertex.collapseNeighbor );
|
||||
}
|
||||
|
||||
// console.profileEnd('zz');
|
||||
// console.timeEnd('z')
|
||||
|
||||
// TODO convert to buffer geometry.
|
||||
var newGeo = new THREE.Geometry();
|
||||
|
||||
for ( i = 0; i < vertices.length; i ++ ) {
|
||||
|
||||
var v = vertices[ i ];
|
||||
newGeo.vertices.push( v.position )
|
||||
|
||||
}
|
||||
|
||||
for ( i = 0; i < faces.length; i ++ ) {
|
||||
|
||||
var tri = faces[ i ];
|
||||
newGeo.faces.push( new THREE.Face3(
|
||||
vertices.indexOf(tri.v1),
|
||||
vertices.indexOf(tri.v2),
|
||||
vertices.indexOf(tri.v3)
|
||||
) )
|
||||
|
||||
}
|
||||
|
||||
return newGeo;
|
||||
};
|
||||
})();
|
||||
387
node_modules/three/examples/js/modifiers/SubdivisionModifier.js
generated
vendored
Normal file
387
node_modules/three/examples/js/modifiers/SubdivisionModifier.js
generated
vendored
Normal file
@@ -0,0 +1,387 @@
|
||||
/*
|
||||
* @author zz85 / http://twitter.com/blurspline / http://www.lab4games.net/zz85/blog
|
||||
* @author centerionware / http://www.centerionware.com
|
||||
*
|
||||
* Subdivision Geometry Modifier
|
||||
* using Loop Subdivision Scheme
|
||||
*
|
||||
* References:
|
||||
* http://graphics.stanford.edu/~mdfisher/subdivision.html
|
||||
* http://www.holmes3d.net/graphics/subdivision/
|
||||
* http://www.cs.rutgers.edu/~decarlo/readings/subdiv-sg00c.pdf
|
||||
*
|
||||
* Known Issues:
|
||||
* - currently doesn't handle "Sharp Edges"
|
||||
*/
|
||||
|
||||
THREE.SubdivisionModifier = function ( subdivisions ) {
|
||||
|
||||
this.subdivisions = ( subdivisions === undefined ) ? 1 : subdivisions;
|
||||
|
||||
};
|
||||
|
||||
// Applies the "modify" pattern
|
||||
THREE.SubdivisionModifier.prototype.modify = function ( geometry ) {
|
||||
|
||||
var repeats = this.subdivisions;
|
||||
|
||||
while ( repeats -- > 0 ) {
|
||||
|
||||
this.smooth( geometry );
|
||||
|
||||
}
|
||||
|
||||
geometry.computeFaceNormals();
|
||||
geometry.computeVertexNormals();
|
||||
|
||||
};
|
||||
|
||||
( function() {
|
||||
|
||||
// Some constants
|
||||
var WARNINGS = ! true; // Set to true for development
|
||||
var ABC = [ 'a', 'b', 'c' ];
|
||||
|
||||
|
||||
function getEdge( a, b, map ) {
|
||||
|
||||
var vertexIndexA = Math.min( a, b );
|
||||
var vertexIndexB = Math.max( a, b );
|
||||
|
||||
var key = vertexIndexA + "_" + vertexIndexB;
|
||||
|
||||
return map[ key ];
|
||||
|
||||
}
|
||||
|
||||
|
||||
function processEdge( a, b, vertices, map, face, metaVertices ) {
|
||||
|
||||
var vertexIndexA = Math.min( a, b );
|
||||
var vertexIndexB = Math.max( a, b );
|
||||
|
||||
var key = vertexIndexA + "_" + vertexIndexB;
|
||||
|
||||
var edge;
|
||||
|
||||
if ( key in map ) {
|
||||
|
||||
edge = map[ key ];
|
||||
|
||||
} else {
|
||||
|
||||
var vertexA = vertices[ vertexIndexA ];
|
||||
var vertexB = vertices[ vertexIndexB ];
|
||||
|
||||
edge = {
|
||||
|
||||
a: vertexA, // pointer reference
|
||||
b: vertexB,
|
||||
newEdge: null,
|
||||
// aIndex: a, // numbered reference
|
||||
// bIndex: b,
|
||||
faces: [] // pointers to face
|
||||
|
||||
};
|
||||
|
||||
map[ key ] = edge;
|
||||
|
||||
}
|
||||
|
||||
edge.faces.push( face );
|
||||
|
||||
metaVertices[ a ].edges.push( edge );
|
||||
metaVertices[ b ].edges.push( edge );
|
||||
|
||||
|
||||
}
|
||||
|
||||
function generateLookups( vertices, faces, metaVertices, edges ) {
|
||||
|
||||
var i, il, face, edge;
|
||||
|
||||
for ( i = 0, il = vertices.length; i < il; i ++ ) {
|
||||
|
||||
metaVertices[ i ] = { edges: [] };
|
||||
|
||||
}
|
||||
|
||||
for ( i = 0, il = faces.length; i < il; i ++ ) {
|
||||
|
||||
face = faces[ i ];
|
||||
|
||||
processEdge( face.a, face.b, vertices, edges, face, metaVertices );
|
||||
processEdge( face.b, face.c, vertices, edges, face, metaVertices );
|
||||
processEdge( face.c, face.a, vertices, edges, face, metaVertices );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function newFace( newFaces, a, b, c ) {
|
||||
|
||||
newFaces.push( new THREE.Face3( a, b, c ) );
|
||||
|
||||
}
|
||||
|
||||
function midpoint( a, b ) {
|
||||
|
||||
return ( Math.abs( b - a ) / 2 ) + Math.min( a, b );
|
||||
|
||||
}
|
||||
|
||||
function newUv( newUvs, a, b, c ) {
|
||||
|
||||
newUvs.push( [ a.clone(), b.clone(), c.clone() ] );
|
||||
|
||||
}
|
||||
|
||||
/////////////////////////////
|
||||
|
||||
// Performs one iteration of Subdivision
|
||||
THREE.SubdivisionModifier.prototype.smooth = function ( geometry ) {
|
||||
|
||||
var tmp = new THREE.Vector3();
|
||||
|
||||
var oldVertices, oldFaces, oldUvs;
|
||||
var newVertices, newFaces, newUVs = [];
|
||||
|
||||
var n, l, i, il, j, k;
|
||||
var metaVertices, sourceEdges;
|
||||
|
||||
// new stuff.
|
||||
var sourceEdges, newEdgeVertices, newSourceVertices;
|
||||
|
||||
oldVertices = geometry.vertices; // { x, y, z}
|
||||
oldFaces = geometry.faces; // { a: oldVertex1, b: oldVertex2, c: oldVertex3 }
|
||||
oldUvs = geometry.faceVertexUvs[ 0 ];
|
||||
|
||||
var hasUvs = oldUvs !== undefined && oldUvs.length > 0;
|
||||
|
||||
/******************************************************
|
||||
*
|
||||
* Step 0: Preprocess Geometry to Generate edges Lookup
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
metaVertices = new Array( oldVertices.length );
|
||||
sourceEdges = {}; // Edge => { oldVertex1, oldVertex2, faces[] }
|
||||
|
||||
generateLookups( oldVertices, oldFaces, metaVertices, sourceEdges );
|
||||
|
||||
|
||||
/******************************************************
|
||||
*
|
||||
* Step 1.
|
||||
* For each edge, create a new Edge Vertex,
|
||||
* then position it.
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
newEdgeVertices = [];
|
||||
var other, currentEdge, newEdge, face;
|
||||
var edgeVertexWeight, adjacentVertexWeight, connectedFaces;
|
||||
|
||||
for ( i in sourceEdges ) {
|
||||
|
||||
currentEdge = sourceEdges[ i ];
|
||||
newEdge = new THREE.Vector3();
|
||||
|
||||
edgeVertexWeight = 3 / 8;
|
||||
adjacentVertexWeight = 1 / 8;
|
||||
|
||||
connectedFaces = currentEdge.faces.length;
|
||||
|
||||
// check how many linked faces. 2 should be correct.
|
||||
if ( connectedFaces != 2 ) {
|
||||
|
||||
// if length is not 2, handle condition
|
||||
edgeVertexWeight = 0.5;
|
||||
adjacentVertexWeight = 0;
|
||||
|
||||
if ( connectedFaces != 1 ) {
|
||||
|
||||
if ( WARNINGS ) console.warn( 'Subdivision Modifier: Number of connected faces != 2, is: ', connectedFaces, currentEdge );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
newEdge.addVectors( currentEdge.a, currentEdge.b ).multiplyScalar( edgeVertexWeight );
|
||||
|
||||
tmp.set( 0, 0, 0 );
|
||||
|
||||
for ( j = 0; j < connectedFaces; j ++ ) {
|
||||
|
||||
face = currentEdge.faces[ j ];
|
||||
|
||||
for ( k = 0; k < 3; k ++ ) {
|
||||
|
||||
other = oldVertices[ face[ ABC[ k ] ] ];
|
||||
if ( other !== currentEdge.a && other !== currentEdge.b ) break;
|
||||
|
||||
}
|
||||
|
||||
tmp.add( other );
|
||||
|
||||
}
|
||||
|
||||
tmp.multiplyScalar( adjacentVertexWeight );
|
||||
newEdge.add( tmp );
|
||||
|
||||
currentEdge.newEdge = newEdgeVertices.length;
|
||||
newEdgeVertices.push( newEdge );
|
||||
|
||||
// console.log(currentEdge, newEdge);
|
||||
|
||||
}
|
||||
|
||||
/******************************************************
|
||||
*
|
||||
* Step 2.
|
||||
* Reposition each source vertices.
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
var beta, sourceVertexWeight, connectingVertexWeight;
|
||||
var connectingEdge, connectingEdges, oldVertex, newSourceVertex;
|
||||
newSourceVertices = [];
|
||||
|
||||
for ( i = 0, il = oldVertices.length; i < il; i ++ ) {
|
||||
|
||||
oldVertex = oldVertices[ i ];
|
||||
|
||||
// find all connecting edges (using lookupTable)
|
||||
connectingEdges = metaVertices[ i ].edges;
|
||||
n = connectingEdges.length;
|
||||
|
||||
if ( n == 3 ) {
|
||||
|
||||
beta = 3 / 16;
|
||||
|
||||
} else if ( n > 3 ) {
|
||||
|
||||
beta = 3 / ( 8 * n ); // Warren's modified formula
|
||||
|
||||
}
|
||||
|
||||
// Loop's original beta formula
|
||||
// beta = 1 / n * ( 5/8 - Math.pow( 3/8 + 1/4 * Math.cos( 2 * Math. PI / n ), 2) );
|
||||
|
||||
sourceVertexWeight = 1 - n * beta;
|
||||
connectingVertexWeight = beta;
|
||||
|
||||
if ( n <= 2 ) {
|
||||
|
||||
// crease and boundary rules
|
||||
// console.warn('crease and boundary rules');
|
||||
|
||||
if ( n == 2 ) {
|
||||
|
||||
if ( WARNINGS ) console.warn( '2 connecting edges', connectingEdges );
|
||||
sourceVertexWeight = 3 / 4;
|
||||
connectingVertexWeight = 1 / 8;
|
||||
|
||||
// sourceVertexWeight = 1;
|
||||
// connectingVertexWeight = 0;
|
||||
|
||||
} else if ( n == 1 ) {
|
||||
|
||||
if ( WARNINGS ) console.warn( 'only 1 connecting edge' );
|
||||
|
||||
} else if ( n == 0 ) {
|
||||
|
||||
if ( WARNINGS ) console.warn( '0 connecting edges' );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
newSourceVertex = oldVertex.clone().multiplyScalar( sourceVertexWeight );
|
||||
|
||||
tmp.set( 0, 0, 0 );
|
||||
|
||||
for ( j = 0; j < n; j ++ ) {
|
||||
|
||||
connectingEdge = connectingEdges[ j ];
|
||||
other = connectingEdge.a !== oldVertex ? connectingEdge.a : connectingEdge.b;
|
||||
tmp.add( other );
|
||||
|
||||
}
|
||||
|
||||
tmp.multiplyScalar( connectingVertexWeight );
|
||||
newSourceVertex.add( tmp );
|
||||
|
||||
newSourceVertices.push( newSourceVertex );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/******************************************************
|
||||
*
|
||||
* Step 3.
|
||||
* Generate Faces between source vertices
|
||||
* and edge vertices.
|
||||
*
|
||||
*******************************************************/
|
||||
|
||||
newVertices = newSourceVertices.concat( newEdgeVertices );
|
||||
var sl = newSourceVertices.length, edge1, edge2, edge3;
|
||||
newFaces = [];
|
||||
|
||||
var uv, x0, x1, x2;
|
||||
var x3 = new THREE.Vector2();
|
||||
var x4 = new THREE.Vector2();
|
||||
var x5 = new THREE.Vector2();
|
||||
|
||||
for ( i = 0, il = oldFaces.length; i < il; i ++ ) {
|
||||
|
||||
face = oldFaces[ i ];
|
||||
|
||||
// find the 3 new edges vertex of each old face
|
||||
|
||||
edge1 = getEdge( face.a, face.b, sourceEdges ).newEdge + sl;
|
||||
edge2 = getEdge( face.b, face.c, sourceEdges ).newEdge + sl;
|
||||
edge3 = getEdge( face.c, face.a, sourceEdges ).newEdge + sl;
|
||||
|
||||
// create 4 faces.
|
||||
|
||||
newFace( newFaces, edge1, edge2, edge3 );
|
||||
newFace( newFaces, face.a, edge1, edge3 );
|
||||
newFace( newFaces, face.b, edge2, edge1 );
|
||||
newFace( newFaces, face.c, edge3, edge2 );
|
||||
|
||||
// create 4 new uv's
|
||||
|
||||
if ( hasUvs ) {
|
||||
|
||||
uv = oldUvs[ i ];
|
||||
|
||||
x0 = uv[ 0 ];
|
||||
x1 = uv[ 1 ];
|
||||
x2 = uv[ 2 ];
|
||||
|
||||
x3.set( midpoint( x0.x, x1.x ), midpoint( x0.y, x1.y ) );
|
||||
x4.set( midpoint( x1.x, x2.x ), midpoint( x1.y, x2.y ) );
|
||||
x5.set( midpoint( x0.x, x2.x ), midpoint( x0.y, x2.y ) );
|
||||
|
||||
newUv( newUVs, x3, x4, x5 );
|
||||
newUv( newUVs, x0, x3, x5 );
|
||||
|
||||
newUv( newUVs, x1, x4, x3 );
|
||||
newUv( newUVs, x2, x5, x4 );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Overwrite old arrays
|
||||
geometry.vertices = newVertices;
|
||||
geometry.faces = newFaces;
|
||||
if ( hasUvs ) geometry.faceVertexUvs[ 0 ] = newUVs;
|
||||
|
||||
// console.log('done');
|
||||
|
||||
};
|
||||
|
||||
} )();
|
||||
236
node_modules/three/examples/js/modifiers/TessellateModifier.js
generated
vendored
Normal file
236
node_modules/three/examples/js/modifiers/TessellateModifier.js
generated
vendored
Normal file
@@ -0,0 +1,236 @@
|
||||
/**
|
||||
* Break faces with edges longer than maxEdgeLength
|
||||
* - not recursive
|
||||
*
|
||||
* @author alteredq / http://alteredqualia.com/
|
||||
*/
|
||||
|
||||
THREE.TessellateModifier = function ( maxEdgeLength ) {
|
||||
|
||||
this.maxEdgeLength = maxEdgeLength;
|
||||
|
||||
};
|
||||
|
||||
THREE.TessellateModifier.prototype.modify = function ( geometry ) {
|
||||
|
||||
var edge;
|
||||
|
||||
var faces = [];
|
||||
var faceVertexUvs = [];
|
||||
var maxEdgeLengthSquared = this.maxEdgeLength * this.maxEdgeLength;
|
||||
|
||||
for ( var i = 0, il = geometry.faceVertexUvs.length; i < il; i ++ ) {
|
||||
|
||||
faceVertexUvs[ i ] = [];
|
||||
|
||||
}
|
||||
|
||||
for ( var i = 0, il = geometry.faces.length; i < il; i ++ ) {
|
||||
|
||||
var face = geometry.faces[ i ];
|
||||
|
||||
if ( face instanceof THREE.Face3 ) {
|
||||
|
||||
var a = face.a;
|
||||
var b = face.b;
|
||||
var c = face.c;
|
||||
|
||||
var va = geometry.vertices[ a ];
|
||||
var vb = geometry.vertices[ b ];
|
||||
var vc = geometry.vertices[ c ];
|
||||
|
||||
var dab = va.distanceToSquared( vb );
|
||||
var dbc = vb.distanceToSquared( vc );
|
||||
var dac = va.distanceToSquared( vc );
|
||||
|
||||
if ( dab > maxEdgeLengthSquared || dbc > maxEdgeLengthSquared || dac > maxEdgeLengthSquared ) {
|
||||
|
||||
var m = geometry.vertices.length;
|
||||
|
||||
var triA = face.clone();
|
||||
var triB = face.clone();
|
||||
|
||||
if ( dab >= dbc && dab >= dac ) {
|
||||
|
||||
var vm = va.clone();
|
||||
vm.lerp( vb, 0.5 );
|
||||
|
||||
triA.a = a;
|
||||
triA.b = m;
|
||||
triA.c = c;
|
||||
|
||||
triB.a = m;
|
||||
triB.b = b;
|
||||
triB.c = c;
|
||||
|
||||
if ( face.vertexNormals.length === 3 ) {
|
||||
|
||||
var vnm = face.vertexNormals[ 0 ].clone();
|
||||
vnm.lerp( face.vertexNormals[ 1 ], 0.5 );
|
||||
|
||||
triA.vertexNormals[ 1 ].copy( vnm );
|
||||
triB.vertexNormals[ 0 ].copy( vnm );
|
||||
|
||||
}
|
||||
|
||||
if ( face.vertexColors.length === 3 ) {
|
||||
|
||||
var vcm = face.vertexColors[ 0 ].clone();
|
||||
vcm.lerp( face.vertexColors[ 1 ], 0.5 );
|
||||
|
||||
triA.vertexColors[ 1 ].copy( vcm );
|
||||
triB.vertexColors[ 0 ].copy( vcm );
|
||||
|
||||
}
|
||||
|
||||
edge = 0;
|
||||
|
||||
} else if ( dbc >= dab && dbc >= dac ) {
|
||||
|
||||
var vm = vb.clone();
|
||||
vm.lerp( vc, 0.5 );
|
||||
|
||||
triA.a = a;
|
||||
triA.b = b;
|
||||
triA.c = m;
|
||||
|
||||
triB.a = m;
|
||||
triB.b = c;
|
||||
triB.c = a;
|
||||
|
||||
if ( face.vertexNormals.length === 3 ) {
|
||||
|
||||
var vnm = face.vertexNormals[ 1 ].clone();
|
||||
vnm.lerp( face.vertexNormals[ 2 ], 0.5 );
|
||||
|
||||
triA.vertexNormals[ 2 ].copy( vnm );
|
||||
|
||||
triB.vertexNormals[ 0 ].copy( vnm );
|
||||
triB.vertexNormals[ 1 ].copy( face.vertexNormals[ 2 ] );
|
||||
triB.vertexNormals[ 2 ].copy( face.vertexNormals[ 0 ] );
|
||||
|
||||
}
|
||||
|
||||
if ( face.vertexColors.length === 3 ) {
|
||||
|
||||
var vcm = face.vertexColors[ 1 ].clone();
|
||||
vcm.lerp( face.vertexColors[ 2 ], 0.5 );
|
||||
|
||||
triA.vertexColors[ 2 ].copy( vcm );
|
||||
|
||||
triB.vertexColors[ 0 ].copy( vcm );
|
||||
triB.vertexColors[ 1 ].copy( face.vertexColors[ 2 ] );
|
||||
triB.vertexColors[ 2 ].copy( face.vertexColors[ 0 ] );
|
||||
|
||||
}
|
||||
|
||||
edge = 1;
|
||||
|
||||
} else {
|
||||
|
||||
var vm = va.clone();
|
||||
vm.lerp( vc, 0.5 );
|
||||
|
||||
triA.a = a;
|
||||
triA.b = b;
|
||||
triA.c = m;
|
||||
|
||||
triB.a = m;
|
||||
triB.b = b;
|
||||
triB.c = c;
|
||||
|
||||
if ( face.vertexNormals.length === 3 ) {
|
||||
|
||||
var vnm = face.vertexNormals[ 0 ].clone();
|
||||
vnm.lerp( face.vertexNormals[ 2 ], 0.5 );
|
||||
|
||||
triA.vertexNormals[ 2 ].copy( vnm );
|
||||
triB.vertexNormals[ 0 ].copy( vnm );
|
||||
|
||||
}
|
||||
|
||||
if ( face.vertexColors.length === 3 ) {
|
||||
|
||||
var vcm = face.vertexColors[ 0 ].clone();
|
||||
vcm.lerp( face.vertexColors[ 2 ], 0.5 );
|
||||
|
||||
triA.vertexColors[ 2 ].copy( vcm );
|
||||
triB.vertexColors[ 0 ].copy( vcm );
|
||||
|
||||
}
|
||||
|
||||
edge = 2;
|
||||
|
||||
}
|
||||
|
||||
faces.push( triA, triB );
|
||||
geometry.vertices.push( vm );
|
||||
|
||||
for ( var j = 0, jl = geometry.faceVertexUvs.length; j < jl; j ++ ) {
|
||||
|
||||
if ( geometry.faceVertexUvs[ j ].length ) {
|
||||
|
||||
var uvs = geometry.faceVertexUvs[ j ][ i ];
|
||||
|
||||
var uvA = uvs[ 0 ];
|
||||
var uvB = uvs[ 1 ];
|
||||
var uvC = uvs[ 2 ];
|
||||
|
||||
// AB
|
||||
|
||||
if ( edge === 0 ) {
|
||||
|
||||
var uvM = uvA.clone();
|
||||
uvM.lerp( uvB, 0.5 );
|
||||
|
||||
var uvsTriA = [ uvA.clone(), uvM.clone(), uvC.clone() ];
|
||||
var uvsTriB = [ uvM.clone(), uvB.clone(), uvC.clone() ];
|
||||
|
||||
// BC
|
||||
|
||||
} else if ( edge === 1 ) {
|
||||
|
||||
var uvM = uvB.clone();
|
||||
uvM.lerp( uvC, 0.5 );
|
||||
|
||||
var uvsTriA = [ uvA.clone(), uvB.clone(), uvM.clone() ];
|
||||
var uvsTriB = [ uvM.clone(), uvC.clone(), uvA.clone() ];
|
||||
|
||||
// AC
|
||||
|
||||
} else {
|
||||
|
||||
var uvM = uvA.clone();
|
||||
uvM.lerp( uvC, 0.5 );
|
||||
|
||||
var uvsTriA = [ uvA.clone(), uvB.clone(), uvM.clone() ];
|
||||
var uvsTriB = [ uvM.clone(), uvB.clone(), uvC.clone() ];
|
||||
|
||||
}
|
||||
|
||||
faceVertexUvs[ j ].push( uvsTriA, uvsTriB );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
faces.push( face );
|
||||
|
||||
for ( var j = 0, jl = geometry.faceVertexUvs.length; j < jl; j ++ ) {
|
||||
|
||||
faceVertexUvs[ j ].push( geometry.faceVertexUvs[ j ][ i ] );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
geometry.faces = faces;
|
||||
geometry.faceVertexUvs = faceVertexUvs;
|
||||
|
||||
};
|
||||
Reference in New Issue
Block a user