1 | /**
|
---|
2 | * @author mrdoob / http://mrdoob.com/
|
---|
3 | * @author kile / http://kile.stravaganza.org/
|
---|
4 | * @author alteredq / http://alteredqualia.com/
|
---|
5 | * @author mikael emtinger / http://gomo.se/
|
---|
6 | * @author zz85 / http://www.lab4games.net/zz85/blog
|
---|
7 | * @author bhouston / http://exocortex.com
|
---|
8 | */
|
---|
9 |
|
---|
10 | THREE.Geometry = function () {
|
---|
11 |
|
---|
12 | this.id = THREE.GeometryIdCount ++;
|
---|
13 | this.uuid = THREE.Math.generateUUID();
|
---|
14 |
|
---|
15 | this.name = '';
|
---|
16 |
|
---|
17 | this.vertices = [];
|
---|
18 | this.colors = []; // one-to-one vertex colors, used in ParticleSystem and Line
|
---|
19 |
|
---|
20 | this.faces = [];
|
---|
21 |
|
---|
22 | this.faceVertexUvs = [[]];
|
---|
23 |
|
---|
24 | this.morphTargets = [];
|
---|
25 | this.morphColors = [];
|
---|
26 | this.morphNormals = [];
|
---|
27 |
|
---|
28 | this.skinWeights = [];
|
---|
29 | this.skinIndices = [];
|
---|
30 |
|
---|
31 | this.lineDistances = [];
|
---|
32 |
|
---|
33 | this.boundingBox = null;
|
---|
34 | this.boundingSphere = null;
|
---|
35 |
|
---|
36 | this.hasTangents = false;
|
---|
37 |
|
---|
38 | this.dynamic = true; // the intermediate typed arrays will be deleted when set to false
|
---|
39 |
|
---|
40 | // update flags
|
---|
41 |
|
---|
42 | this.verticesNeedUpdate = false;
|
---|
43 | this.elementsNeedUpdate = false;
|
---|
44 | this.uvsNeedUpdate = false;
|
---|
45 | this.normalsNeedUpdate = false;
|
---|
46 | this.tangentsNeedUpdate = false;
|
---|
47 | this.colorsNeedUpdate = false;
|
---|
48 | this.lineDistancesNeedUpdate = false;
|
---|
49 |
|
---|
50 | this.buffersNeedUpdate = false;
|
---|
51 |
|
---|
52 | };
|
---|
53 |
|
---|
54 | THREE.Geometry.prototype = {
|
---|
55 |
|
---|
56 | constructor: THREE.Geometry,
|
---|
57 |
|
---|
58 | applyMatrix: function ( matrix ) {
|
---|
59 |
|
---|
60 | var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
|
---|
61 |
|
---|
62 | for ( var i = 0, il = this.vertices.length; i < il; i ++ ) {
|
---|
63 |
|
---|
64 | var vertex = this.vertices[ i ];
|
---|
65 | vertex.applyMatrix4( matrix );
|
---|
66 |
|
---|
67 | }
|
---|
68 |
|
---|
69 | for ( var i = 0, il = this.faces.length; i < il; i ++ ) {
|
---|
70 |
|
---|
71 | var face = this.faces[ i ];
|
---|
72 | face.normal.applyMatrix3( normalMatrix ).normalize();
|
---|
73 |
|
---|
74 | for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {
|
---|
75 |
|
---|
76 | face.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize();
|
---|
77 |
|
---|
78 | }
|
---|
79 |
|
---|
80 | face.centroid.applyMatrix4( matrix );
|
---|
81 |
|
---|
82 | }
|
---|
83 |
|
---|
84 | if ( this.boundingBox instanceof THREE.Box3 ) {
|
---|
85 |
|
---|
86 | this.computeBoundingBox();
|
---|
87 |
|
---|
88 | }
|
---|
89 |
|
---|
90 | if ( this.boundingSphere instanceof THREE.Sphere ) {
|
---|
91 |
|
---|
92 | this.computeBoundingSphere();
|
---|
93 |
|
---|
94 | }
|
---|
95 |
|
---|
96 | },
|
---|
97 |
|
---|
98 | computeCentroids: function () {
|
---|
99 |
|
---|
100 | var f, fl, face;
|
---|
101 |
|
---|
102 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
103 |
|
---|
104 | face = this.faces[ f ];
|
---|
105 | face.centroid.set( 0, 0, 0 );
|
---|
106 |
|
---|
107 | face.centroid.add( this.vertices[ face.a ] );
|
---|
108 | face.centroid.add( this.vertices[ face.b ] );
|
---|
109 | face.centroid.add( this.vertices[ face.c ] );
|
---|
110 | face.centroid.divideScalar( 3 );
|
---|
111 |
|
---|
112 | }
|
---|
113 |
|
---|
114 | },
|
---|
115 |
|
---|
116 | computeFaceNormals: function () {
|
---|
117 |
|
---|
118 | var cb = new THREE.Vector3(), ab = new THREE.Vector3();
|
---|
119 |
|
---|
120 | for ( var f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
121 |
|
---|
122 | var face = this.faces[ f ];
|
---|
123 |
|
---|
124 | var vA = this.vertices[ face.a ];
|
---|
125 | var vB = this.vertices[ face.b ];
|
---|
126 | var vC = this.vertices[ face.c ];
|
---|
127 |
|
---|
128 | cb.subVectors( vC, vB );
|
---|
129 | ab.subVectors( vA, vB );
|
---|
130 | cb.cross( ab );
|
---|
131 |
|
---|
132 | cb.normalize();
|
---|
133 |
|
---|
134 | face.normal.copy( cb );
|
---|
135 |
|
---|
136 | }
|
---|
137 |
|
---|
138 | },
|
---|
139 |
|
---|
140 | computeVertexNormals: function ( areaWeighted ) {
|
---|
141 |
|
---|
142 | var v, vl, f, fl, face, vertices;
|
---|
143 |
|
---|
144 | vertices = new Array( this.vertices.length );
|
---|
145 |
|
---|
146 | for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
|
---|
147 |
|
---|
148 | vertices[ v ] = new THREE.Vector3();
|
---|
149 |
|
---|
150 | }
|
---|
151 |
|
---|
152 | if ( areaWeighted ) {
|
---|
153 |
|
---|
154 | // vertex normals weighted by triangle areas
|
---|
155 | // http://www.iquilezles.org/www/articles/normals/normals.htm
|
---|
156 |
|
---|
157 | var vA, vB, vC, vD;
|
---|
158 | var cb = new THREE.Vector3(), ab = new THREE.Vector3(),
|
---|
159 | db = new THREE.Vector3(), dc = new THREE.Vector3(), bc = new THREE.Vector3();
|
---|
160 |
|
---|
161 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
162 |
|
---|
163 | face = this.faces[ f ];
|
---|
164 |
|
---|
165 | vA = this.vertices[ face.a ];
|
---|
166 | vB = this.vertices[ face.b ];
|
---|
167 | vC = this.vertices[ face.c ];
|
---|
168 |
|
---|
169 | cb.subVectors( vC, vB );
|
---|
170 | ab.subVectors( vA, vB );
|
---|
171 | cb.cross( ab );
|
---|
172 |
|
---|
173 | vertices[ face.a ].add( cb );
|
---|
174 | vertices[ face.b ].add( cb );
|
---|
175 | vertices[ face.c ].add( cb );
|
---|
176 |
|
---|
177 | }
|
---|
178 |
|
---|
179 | } else {
|
---|
180 |
|
---|
181 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
182 |
|
---|
183 | face = this.faces[ f ];
|
---|
184 |
|
---|
185 | vertices[ face.a ].add( face.normal );
|
---|
186 | vertices[ face.b ].add( face.normal );
|
---|
187 | vertices[ face.c ].add( face.normal );
|
---|
188 |
|
---|
189 | }
|
---|
190 |
|
---|
191 | }
|
---|
192 |
|
---|
193 | for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
|
---|
194 |
|
---|
195 | vertices[ v ].normalize();
|
---|
196 |
|
---|
197 | }
|
---|
198 |
|
---|
199 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
200 |
|
---|
201 | face = this.faces[ f ];
|
---|
202 |
|
---|
203 | face.vertexNormals[ 0 ] = vertices[ face.a ].clone();
|
---|
204 | face.vertexNormals[ 1 ] = vertices[ face.b ].clone();
|
---|
205 | face.vertexNormals[ 2 ] = vertices[ face.c ].clone();
|
---|
206 |
|
---|
207 | }
|
---|
208 |
|
---|
209 | },
|
---|
210 |
|
---|
211 | computeMorphNormals: function () {
|
---|
212 |
|
---|
213 | var i, il, f, fl, face;
|
---|
214 |
|
---|
215 | // save original normals
|
---|
216 | // - create temp variables on first access
|
---|
217 | // otherwise just copy (for faster repeated calls)
|
---|
218 |
|
---|
219 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
220 |
|
---|
221 | face = this.faces[ f ];
|
---|
222 |
|
---|
223 | if ( ! face.__originalFaceNormal ) {
|
---|
224 |
|
---|
225 | face.__originalFaceNormal = face.normal.clone();
|
---|
226 |
|
---|
227 | } else {
|
---|
228 |
|
---|
229 | face.__originalFaceNormal.copy( face.normal );
|
---|
230 |
|
---|
231 | }
|
---|
232 |
|
---|
233 | if ( ! face.__originalVertexNormals ) face.__originalVertexNormals = [];
|
---|
234 |
|
---|
235 | for ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) {
|
---|
236 |
|
---|
237 | if ( ! face.__originalVertexNormals[ i ] ) {
|
---|
238 |
|
---|
239 | face.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone();
|
---|
240 |
|
---|
241 | } else {
|
---|
242 |
|
---|
243 | face.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] );
|
---|
244 |
|
---|
245 | }
|
---|
246 |
|
---|
247 | }
|
---|
248 |
|
---|
249 | }
|
---|
250 |
|
---|
251 | // use temp geometry to compute face and vertex normals for each morph
|
---|
252 |
|
---|
253 | var tmpGeo = new THREE.Geometry();
|
---|
254 | tmpGeo.faces = this.faces;
|
---|
255 |
|
---|
256 | for ( i = 0, il = this.morphTargets.length; i < il; i ++ ) {
|
---|
257 |
|
---|
258 | // create on first access
|
---|
259 |
|
---|
260 | if ( ! this.morphNormals[ i ] ) {
|
---|
261 |
|
---|
262 | this.morphNormals[ i ] = {};
|
---|
263 | this.morphNormals[ i ].faceNormals = [];
|
---|
264 | this.morphNormals[ i ].vertexNormals = [];
|
---|
265 |
|
---|
266 | var dstNormalsFace = this.morphNormals[ i ].faceNormals;
|
---|
267 | var dstNormalsVertex = this.morphNormals[ i ].vertexNormals;
|
---|
268 |
|
---|
269 | var faceNormal, vertexNormals;
|
---|
270 |
|
---|
271 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
272 |
|
---|
273 | face = this.faces[ f ];
|
---|
274 |
|
---|
275 | faceNormal = new THREE.Vector3();
|
---|
276 | vertexNormals = { a: new THREE.Vector3(), b: new THREE.Vector3(), c: new THREE.Vector3() };
|
---|
277 |
|
---|
278 | dstNormalsFace.push( faceNormal );
|
---|
279 | dstNormalsVertex.push( vertexNormals );
|
---|
280 |
|
---|
281 | }
|
---|
282 |
|
---|
283 | }
|
---|
284 |
|
---|
285 | var morphNormals = this.morphNormals[ i ];
|
---|
286 |
|
---|
287 | // set vertices to morph target
|
---|
288 |
|
---|
289 | tmpGeo.vertices = this.morphTargets[ i ].vertices;
|
---|
290 |
|
---|
291 | // compute morph normals
|
---|
292 |
|
---|
293 | tmpGeo.computeFaceNormals();
|
---|
294 | tmpGeo.computeVertexNormals();
|
---|
295 |
|
---|
296 | // store morph normals
|
---|
297 |
|
---|
298 | var faceNormal, vertexNormals;
|
---|
299 |
|
---|
300 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
301 |
|
---|
302 | face = this.faces[ f ];
|
---|
303 |
|
---|
304 | faceNormal = morphNormals.faceNormals[ f ];
|
---|
305 | vertexNormals = morphNormals.vertexNormals[ f ];
|
---|
306 |
|
---|
307 | faceNormal.copy( face.normal );
|
---|
308 |
|
---|
309 | vertexNormals.a.copy( face.vertexNormals[ 0 ] );
|
---|
310 | vertexNormals.b.copy( face.vertexNormals[ 1 ] );
|
---|
311 | vertexNormals.c.copy( face.vertexNormals[ 2 ] );
|
---|
312 |
|
---|
313 | }
|
---|
314 |
|
---|
315 | }
|
---|
316 |
|
---|
317 | // restore original normals
|
---|
318 |
|
---|
319 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
320 |
|
---|
321 | face = this.faces[ f ];
|
---|
322 |
|
---|
323 | face.normal = face.__originalFaceNormal;
|
---|
324 | face.vertexNormals = face.__originalVertexNormals;
|
---|
325 |
|
---|
326 | }
|
---|
327 |
|
---|
328 | },
|
---|
329 |
|
---|
330 | computeTangents: function () {
|
---|
331 |
|
---|
332 | // based on http://www.terathon.com/code/tangent.html
|
---|
333 | // tangents go to vertices
|
---|
334 |
|
---|
335 | var f, fl, v, vl, i, il, vertexIndex,
|
---|
336 | face, uv, vA, vB, vC, uvA, uvB, uvC,
|
---|
337 | x1, x2, y1, y2, z1, z2,
|
---|
338 | s1, s2, t1, t2, r, t, test,
|
---|
339 | tan1 = [], tan2 = [],
|
---|
340 | sdir = new THREE.Vector3(), tdir = new THREE.Vector3(),
|
---|
341 | tmp = new THREE.Vector3(), tmp2 = new THREE.Vector3(),
|
---|
342 | n = new THREE.Vector3(), w;
|
---|
343 |
|
---|
344 | for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
|
---|
345 |
|
---|
346 | tan1[ v ] = new THREE.Vector3();
|
---|
347 | tan2[ v ] = new THREE.Vector3();
|
---|
348 |
|
---|
349 | }
|
---|
350 |
|
---|
351 | function handleTriangle( context, a, b, c, ua, ub, uc ) {
|
---|
352 |
|
---|
353 | vA = context.vertices[ a ];
|
---|
354 | vB = context.vertices[ b ];
|
---|
355 | vC = context.vertices[ c ];
|
---|
356 |
|
---|
357 | uvA = uv[ ua ];
|
---|
358 | uvB = uv[ ub ];
|
---|
359 | uvC = uv[ uc ];
|
---|
360 |
|
---|
361 | x1 = vB.x - vA.x;
|
---|
362 | x2 = vC.x - vA.x;
|
---|
363 | y1 = vB.y - vA.y;
|
---|
364 | y2 = vC.y - vA.y;
|
---|
365 | z1 = vB.z - vA.z;
|
---|
366 | z2 = vC.z - vA.z;
|
---|
367 |
|
---|
368 | s1 = uvB.x - uvA.x;
|
---|
369 | s2 = uvC.x - uvA.x;
|
---|
370 | t1 = uvB.y - uvA.y;
|
---|
371 | t2 = uvC.y - uvA.y;
|
---|
372 |
|
---|
373 | r = 1.0 / ( s1 * t2 - s2 * t1 );
|
---|
374 | sdir.set( ( t2 * x1 - t1 * x2 ) * r,
|
---|
375 | ( t2 * y1 - t1 * y2 ) * r,
|
---|
376 | ( t2 * z1 - t1 * z2 ) * r );
|
---|
377 | tdir.set( ( s1 * x2 - s2 * x1 ) * r,
|
---|
378 | ( s1 * y2 - s2 * y1 ) * r,
|
---|
379 | ( s1 * z2 - s2 * z1 ) * r );
|
---|
380 |
|
---|
381 | tan1[ a ].add( sdir );
|
---|
382 | tan1[ b ].add( sdir );
|
---|
383 | tan1[ c ].add( sdir );
|
---|
384 |
|
---|
385 | tan2[ a ].add( tdir );
|
---|
386 | tan2[ b ].add( tdir );
|
---|
387 | tan2[ c ].add( tdir );
|
---|
388 |
|
---|
389 | }
|
---|
390 |
|
---|
391 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
392 |
|
---|
393 | face = this.faces[ f ];
|
---|
394 | uv = this.faceVertexUvs[ 0 ][ f ]; // use UV layer 0 for tangents
|
---|
395 |
|
---|
396 | handleTriangle( this, face.a, face.b, face.c, 0, 1, 2 );
|
---|
397 |
|
---|
398 | }
|
---|
399 |
|
---|
400 | var faceIndex = [ 'a', 'b', 'c', 'd' ];
|
---|
401 |
|
---|
402 | for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
|
---|
403 |
|
---|
404 | face = this.faces[ f ];
|
---|
405 |
|
---|
406 | for ( i = 0; i < Math.min( face.vertexNormals.length, 3 ); i++ ) {
|
---|
407 |
|
---|
408 | n.copy( face.vertexNormals[ i ] );
|
---|
409 |
|
---|
410 | vertexIndex = face[ faceIndex[ i ] ];
|
---|
411 |
|
---|
412 | t = tan1[ vertexIndex ];
|
---|
413 |
|
---|
414 | // Gram-Schmidt orthogonalize
|
---|
415 |
|
---|
416 | tmp.copy( t );
|
---|
417 | tmp.sub( n.multiplyScalar( n.dot( t ) ) ).normalize();
|
---|
418 |
|
---|
419 | // Calculate handedness
|
---|
420 |
|
---|
421 | tmp2.crossVectors( face.vertexNormals[ i ], t );
|
---|
422 | test = tmp2.dot( tan2[ vertexIndex ] );
|
---|
423 | w = (test < 0.0) ? -1.0 : 1.0;
|
---|
424 |
|
---|
425 | face.vertexTangents[ i ] = new THREE.Vector4( tmp.x, tmp.y, tmp.z, w );
|
---|
426 |
|
---|
427 | }
|
---|
428 |
|
---|
429 | }
|
---|
430 |
|
---|
431 | this.hasTangents = true;
|
---|
432 |
|
---|
433 | },
|
---|
434 |
|
---|
435 | computeLineDistances: function ( ) {
|
---|
436 |
|
---|
437 | var d = 0;
|
---|
438 | var vertices = this.vertices;
|
---|
439 |
|
---|
440 | for ( var i = 0, il = vertices.length; i < il; i ++ ) {
|
---|
441 |
|
---|
442 | if ( i > 0 ) {
|
---|
443 |
|
---|
444 | d += vertices[ i ].distanceTo( vertices[ i - 1 ] );
|
---|
445 |
|
---|
446 | }
|
---|
447 |
|
---|
448 | this.lineDistances[ i ] = d;
|
---|
449 |
|
---|
450 | }
|
---|
451 |
|
---|
452 | },
|
---|
453 |
|
---|
454 | computeBoundingBox: function () {
|
---|
455 |
|
---|
456 | if ( this.boundingBox === null ) {
|
---|
457 |
|
---|
458 | this.boundingBox = new THREE.Box3();
|
---|
459 |
|
---|
460 | }
|
---|
461 |
|
---|
462 | this.boundingBox.setFromPoints( this.vertices );
|
---|
463 |
|
---|
464 | },
|
---|
465 |
|
---|
466 | computeBoundingSphere: function () {
|
---|
467 |
|
---|
468 | if ( this.boundingSphere === null ) {
|
---|
469 |
|
---|
470 | this.boundingSphere = new THREE.Sphere();
|
---|
471 |
|
---|
472 | }
|
---|
473 |
|
---|
474 | this.boundingSphere.setFromPoints( this.vertices );
|
---|
475 |
|
---|
476 | },
|
---|
477 |
|
---|
478 | /*
|
---|
479 | * Checks for duplicate vertices with hashmap.
|
---|
480 | * Duplicated vertices are removed
|
---|
481 | * and faces' vertices are updated.
|
---|
482 | */
|
---|
483 |
|
---|
484 | mergeVertices: function () {
|
---|
485 |
|
---|
486 | var verticesMap = {}; // Hashmap for looking up vertice by position coordinates (and making sure they are unique)
|
---|
487 | var unique = [], changes = [];
|
---|
488 |
|
---|
489 | var v, key;
|
---|
490 | var precisionPoints = 4; // number of decimal points, eg. 4 for epsilon of 0.0001
|
---|
491 | var precision = Math.pow( 10, precisionPoints );
|
---|
492 | var i,il, face;
|
---|
493 | var indices, k, j, jl, u;
|
---|
494 |
|
---|
495 | for ( i = 0, il = this.vertices.length; i < il; i ++ ) {
|
---|
496 |
|
---|
497 | v = this.vertices[ i ];
|
---|
498 | key = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision );
|
---|
499 |
|
---|
500 | if ( verticesMap[ key ] === undefined ) {
|
---|
501 |
|
---|
502 | verticesMap[ key ] = i;
|
---|
503 | unique.push( this.vertices[ i ] );
|
---|
504 | changes[ i ] = unique.length - 1;
|
---|
505 |
|
---|
506 | } else {
|
---|
507 |
|
---|
508 | //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
|
---|
509 | changes[ i ] = changes[ verticesMap[ key ] ];
|
---|
510 |
|
---|
511 | }
|
---|
512 |
|
---|
513 | };
|
---|
514 |
|
---|
515 |
|
---|
516 | // if faces are completely degenerate after merging vertices, we
|
---|
517 | // have to remove them from the geometry.
|
---|
518 | var faceIndicesToRemove = [];
|
---|
519 |
|
---|
520 | for( i = 0, il = this.faces.length; i < il; i ++ ) {
|
---|
521 |
|
---|
522 | face = this.faces[ i ];
|
---|
523 |
|
---|
524 | face.a = changes[ face.a ];
|
---|
525 | face.b = changes[ face.b ];
|
---|
526 | face.c = changes[ face.c ];
|
---|
527 |
|
---|
528 | indices = [ face.a, face.b, face.c ];
|
---|
529 |
|
---|
530 | var dupIndex = -1;
|
---|
531 |
|
---|
532 | // if any duplicate vertices are found in a Face3
|
---|
533 | // we have to remove the face as nothing can be saved
|
---|
534 | for ( var n = 0; n < 3; n ++ ) {
|
---|
535 | if ( indices[ n ] == indices[ ( n + 1 ) % 3 ] ) {
|
---|
536 |
|
---|
537 | dupIndex = n;
|
---|
538 | faceIndicesToRemove.push( i );
|
---|
539 | break;
|
---|
540 |
|
---|
541 | }
|
---|
542 | }
|
---|
543 |
|
---|
544 | }
|
---|
545 |
|
---|
546 | for ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) {
|
---|
547 | var idx = faceIndicesToRemove[ i ];
|
---|
548 |
|
---|
549 | this.faces.splice( idx, 1 );
|
---|
550 |
|
---|
551 | for ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) {
|
---|
552 |
|
---|
553 | this.faceVertexUvs[ j ].splice( idx, 1 );
|
---|
554 |
|
---|
555 | }
|
---|
556 |
|
---|
557 | }
|
---|
558 |
|
---|
559 | // Use unique set of vertices
|
---|
560 |
|
---|
561 | var diff = this.vertices.length - unique.length;
|
---|
562 | this.vertices = unique;
|
---|
563 | return diff;
|
---|
564 |
|
---|
565 | },
|
---|
566 |
|
---|
567 | clone: function () {
|
---|
568 |
|
---|
569 | var geometry = new THREE.Geometry();
|
---|
570 |
|
---|
571 | var vertices = this.vertices;
|
---|
572 |
|
---|
573 | for ( var i = 0, il = vertices.length; i < il; i ++ ) {
|
---|
574 |
|
---|
575 | geometry.vertices.push( vertices[ i ].clone() );
|
---|
576 |
|
---|
577 | }
|
---|
578 |
|
---|
579 | var faces = this.faces;
|
---|
580 |
|
---|
581 | for ( var i = 0, il = faces.length; i < il; i ++ ) {
|
---|
582 |
|
---|
583 | geometry.faces.push( faces[ i ].clone() );
|
---|
584 |
|
---|
585 | }
|
---|
586 |
|
---|
587 | var uvs = this.faceVertexUvs[ 0 ];
|
---|
588 |
|
---|
589 | for ( var i = 0, il = uvs.length; i < il; i ++ ) {
|
---|
590 |
|
---|
591 | var uv = uvs[ i ], uvCopy = [];
|
---|
592 |
|
---|
593 | for ( var j = 0, jl = uv.length; j < jl; j ++ ) {
|
---|
594 |
|
---|
595 | uvCopy.push( new THREE.Vector2( uv[ j ].x, uv[ j ].y ) );
|
---|
596 |
|
---|
597 | }
|
---|
598 |
|
---|
599 | geometry.faceVertexUvs[ 0 ].push( uvCopy );
|
---|
600 |
|
---|
601 | }
|
---|
602 |
|
---|
603 | return geometry;
|
---|
604 |
|
---|
605 | },
|
---|
606 |
|
---|
607 | dispose: function () {
|
---|
608 |
|
---|
609 | this.dispatchEvent( { type: 'dispose' } );
|
---|
610 |
|
---|
611 | }
|
---|
612 |
|
---|
613 | };
|
---|
614 |
|
---|
615 | THREE.EventDispatcher.prototype.apply( THREE.Geometry.prototype );
|
---|
616 |
|
---|
617 | THREE.GeometryIdCount = 0;
|
---|