/* * @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? * * * EX: new TypedArrayHelper(initial_size_in_elements, 3, THREE.Vector3, Float32Array, 3, ['x', 'y', 'z']); (the x,y,z comes from THREE.Vector3. It would be abc if it were a face3. etc etc) * */ 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 ("Nope nope nope, not enough registers!"); } if (index > this.length) { throw ("Nope nope nope, index is out of range"); } 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 { if (this.buffer.length < new_size * this.unit_size) { var nBuffer = new this.array_type(new_size * this.unit_size); nBuffer.set(this.buffer); this.buffer = nBuffer; this.real_length = new_size; } else { var 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.resize(oldArray.length); this.buffer.set(oldArray);//.slice(0, oldArray.length)); 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); }, each: function (function_pointer, xtra) { if (typeof this.loop_register == 'undefined') this.loop_register = new this.register_type(); for (var i = 0; i < this.length; i++) { for (var j = 0; j < this.unit_size; j++) this.loop_register[this.accessors[j]] = this.buffer[i * this.unit_size + j]; function_pointer(this.loop_register, i, xtra); } }, push_array: 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[i]; } 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 addNormal(old, newn) { // old.x += newn.x; // old.y += newn.y; // old.z += newn.z; ///* if (old.x == 0) old.x = newn.x; else old.x = (old.x + newn.x) / 2; if (old.y == 0) old.y = newn.y; else old.y = (old.y + newn.y) / 2; if (old.z == 0) old.z = newn.z; else old.z = (old.z + newn.z) / 2; // */ } function findArea(a, b, c) { return Math.abs(((a.x * (b.y - c.y)) + (b.x * (c.y - a.y)) + (c.x * (a.y - b.y))) / 2.0); } function find_angle3d(A, B, C) { var AB = Math.sqrt(Math.pow(B.x - A.x, 2) + Math.pow(B.y - A.y, 2)); var BC = Math.sqrt(Math.pow(B.x - C.x, 2) + Math.pow(B.y - C.y, 2)); var AC = Math.sqrt(Math.pow(C.x - A.x, 2) + Math.pow(C.y - A.y, 2)); return Math.acos((BC * BC + AB * AB - AC * AC) / (2 * BC * AB)); } function find_angle2d(p1,p2) { return Math.atan2(p2.y - p1.y, p2.x - p1.x); } 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; var a, b, c; oldFaces.from_existing(geometry.index.array); var j, jl; var k,l; var my_weight; var full_weights = [0.0,0.0,0.0]; 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); 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()); //my_weight = findArea(oldVertices.register[0], oldVertices.register[1], oldVertices.register[2]); 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; var tmpy; var tmpz; var t_len; 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); newNormals.register[0].subVectors(oldVertices.register[1], oldVertices.register[0]); newNormals.register[1].subVectors(oldVertices.register[2], oldVertices.register[0]); /* // newNormals.register[0].cross(newNormals.register[1]); newNormals.register[3].copy(newNormals.register[0]);//(a, b, c); t_len = (newNormals.register[3].x + newNormals.register[3].y + newNormals.register[3].z); newNormals.register[3].x = newNormals.register[3].x / t_len; newNormals.register[3].y = newNormals.register[3].y / t_len; newNormals.register[3].z = newNormals.register[3].z / t_len; */ 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() ); // oldVertices.register[3].subVectors(oldVertices.register[2],oldVertices.register[0]); // oldVertices.register[4].subVectors(oldVertices.register[2],oldVertices.register[1]); // var angle = find_angle2d(oldVertices.register[3],oldVertices.register[4]); 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 ] += 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 ] += 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 ] += 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.index_to_register(oldFaces.register[0].a, 0); newNormals.index_to_register(oldFaces.register[0].b, 1); newNormals.index_to_register(oldFaces.register[0].c, 2); addNormal(newNormals.register[3], newNormals.register[0]); addNormal(newNormals.register[3], newNormals.register[1]); addNormal(newNormals.register[3], newNormals.register[2]); newNormals.buffer[oldFaces.register[0].a * 3] = newNormals.register[3].x; newNormals.buffer[(oldFaces.register[0].a * 3)+1] = newNormals.register[3].y; newNormals.buffer[(oldFaces.register[0].a * 3) + 2] = newNormals.register[3].z; newNormals.buffer[oldFaces.register[0].b * 3] = newNormals.register[3].x; newNormals.buffer[(oldFaces.register[0].b * 3) + 1] = newNormals.register[3].y; newNormals.buffer[(oldFaces.register[0].b * 3) + 2] = newNormals.register[3].z; newNormals.buffer[oldFaces.register[0].c * 3] = newNormals.register[3].x; newNormals.buffer[(oldFaces.register[0].c * 3) + 1] = newNormals.register[3].y; newNormals.buffer[(oldFaces.register[0].c * 3) + 2] = newNormals.register[3].z; */ // newNormalFaces[oldFaces.register[0].a] += 1; // newNormalFaces[oldFaces.register[0].b] += 1; // newNormalFaces[oldFaces.register[0].c] += 1; } // for (var i = 0, il = newNormalFaces.length; i < i; i++) { // newNormals.buffer[(i * 3)] = newNormals.buffer[(i * 3)] / newNormalFaces.buffer[i]; // newNormals.buffer[(i * 3)+1] = newNormals.buffer[(i * 3)+1] / newNormalFaces.buffer[i]; // newNormals.buffer[(i * 3)+2] = newNormals.buffer[(i * 3)+2] / newNormalFaces.buffer[i]; // } 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); // geometry.computeFaceNormals(); // geometry.computeVertexNormals(); 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]); /* 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]); v = newNormals.register[0]; w = newNormals.register[1]; newNormals.register[2].x = (v.y * w.z) - (v.z * w.y); newNormals.register[2].y = (v.z * w.x) - (v.x * w.z) newNormals.register[2].z = (v.x * w.y) - (v.y * w.x) newNormals.push_element(newNormals.register[2]); newNormals.push_element(newNormals.register[2]); newNormals.push_element(newNormals.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)); // geometry.computeVertexNormals(); return geometry; } THREE.BufferSubdivisionModifier = function (subdivisions) { this.subdivisions = (subdivisions === undefined) ? 1 : subdivisions; //this.subdivisions = 3; }; // Applies the "modify" pattern THREE.BufferSubdivisionModifier.prototype.modify = function (geometry) { if (geometry instanceof THREE.Geometry) { geometry.mergeVertices(); if (typeof (geometry.normals) == 'undefined') geometry.normals = []; var BGEom = convertGeometryToIndexedBuffer(geometry); geometry = BGEom; } else if( !(geometry instanceof THREE.BufferGeometry) ) console.log("Geometry is not an instance of THREE.BufferGeometry or THREE.Geometry"); var repeats = this.subdivisions; while (repeats-- > 0) { this.smooth(geometry); } return unIndexIndexedGeometry(geometry); // it doesn't change what geometry points to in the function that calls this.. >_<. how annoying. }; var edge_type = function (a, b) { this.a = a; this.b = b; this.faces = []; this.newEdge = null; }; (function () { // Some constants var WARNINGS = ! true; // Set to true for development 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 { // var vertexA = vertices[vertexIndexA]; // var vertexB = vertices[vertexIndexB]; 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; // new stuff. var 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; if (connectedFaces != 1) { if (WARNINGS) console.warn('Subdivision Modifier: Number of connected faces != 2, is: ', connectedFaces, currentEdge); } } 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); // console.log(currentEdge, 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 // 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.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 vertecies * 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];//oldFaces[i]; // 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); // create 4 new uv's /* 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) { oldUvs.index_to_register(i * 3, 0); oldUvs.index_to_register((i * 3)+1, 1); oldUvs.index_to_register((i * 3)+2, 2); // uv = oldUvs[i]; 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 //geometry.addAttribute('position', THREE.BufferAttribute(newVertices, 3).copy) newVertices.trim_size(); newFaces.trim_size(); newUVs.trim_size(); geometry.addAttribute('position', new THREE.BufferAttribute(newVertices.buffer,3)); geometry.setIndex(new THREE.BufferAttribute(newFaces.buffer,3)); geometry.addAttribute('uv', new THREE.BufferAttribute(newUVs.buffer,2)); /* geometry.vertices = newVertices; geometry.faces = newFaces; geometry.faceVertexUvs[0] = newUVs; */ // console.log('done'); }; })();