three-stdlib 2.16.0 → 2.16.1

package/modifiers/SimplifyModifier.js

@@ -1,48 +1,88 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const BufferGeometryUtils = require("../utils/BufferGeometryUtils.js");
-const cb = new THREE.Vector3(), ab = new THREE.Vector3();
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { Vector3, BufferGeometry, Float32BufferAttribute } from 'three';
+import { mergeVertices } from '../utils/BufferGeometryUtils.js';
+
+const cb = new Vector3(),
+      ab = new Vector3();
+
 function pushIfUnique(array, object) {
-  if (array.indexOf(object) === -1)
-    array.push(object);
+  if (array.indexOf(object) === -1) array.push(object);
 }
+
 function removeFromArray(array, object) {
   const k = array.indexOf(object);
-  if (k > -1)
-    array.splice(k, 1);
+  if (k > -1) array.splice(k, 1);
 }
+
 class Vertex {
   constructor(v, id) {
-    this.minCost = 0;
-    this.totalCost = 0;
-    this.costCount = 0;
+    _defineProperty(this, "position", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "faces", void 0);
+
+    _defineProperty(this, "neighbors", void 0);
+
+    _defineProperty(this, "collapseCost", void 0);
+
+    _defineProperty(this, "collapseNeighbor", void 0);
+
+    _defineProperty(this, "minCost", 0);
+
+    _defineProperty(this, "totalCost", 0);
+
+    _defineProperty(this, "costCount", 0);
+
     this.position = v;
-    this.id = id;
-    this.faces = [];
-    this.neighbors = [];
-    this.collapseCost = 0;
-    this.collapseNeighbor = null;
+    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
   }
+
   addUniqueNeighbor(vertex) {
     pushIfUnique(this.neighbors, vertex);
   }
+
   removeIfNonNeighbor(n) {
     const neighbors = this.neighbors;
     const faces = this.faces;
     const offset = neighbors.indexOf(n);
-    if (offset === -1)
-      return;
+    if (offset === -1) return;
+
     for (let i = 0; i < faces.length; i++) {
-      if (faces[i].hasVertex(n))
-        return;
+      if (faces[i].hasVertex(n)) return;
     }
+
     neighbors.splice(offset, 1);
   }
-}
+
+} // we use a triangle class to represent structure of face slightly differently
+
+
 class Triangle {
   constructor(v1, v2, v3, a, b, c) {
-    this.normal = new THREE.Vector3();
+    _defineProperty(this, "a", void 0);
+
+    _defineProperty(this, "b", void 0);
+
+    _defineProperty(this, "c", void 0);
+
+    _defineProperty(this, "v1", void 0);
+
+    _defineProperty(this, "v2", void 0);
+
+    _defineProperty(this, "v3", void 0);
+
+    _defineProperty(this, "normal", new Vector3());
+
     this.a = a;
     this.b = b;
     this.c = c;
@@ -60,6 +100,7 @@ class Triangle {
     v3.addUniqueNeighbor(v1);
     v3.addUniqueNeighbor(v2);
   }
+
   computeNormal() {
     const vA = this.v1.position;
     const vB = this.v2.position;
@@ -69,16 +110,13 @@ class Triangle {
     cb.cross(ab).normalize();
     this.normal.copy(cb);
   }
+
   hasVertex(v) {
     return v === this.v1 || v === this.v2 || v === this.v3;
   }
+
   replaceVertex(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;
+    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);
@@ -95,47 +133,88 @@ class Triangle {
     this.v3.addUniqueNeighbor(this.v2);
     this.computeNormal();
   }
+
 }
+/**
+ *	Simplification Geometry Modifier
+ *    - based on code and technique
+ *	  - by Stan Melax in 1998
+ *	  - Progressive Mesh type Polygon Reduction Algorithm
+ *    - http://www.melax.com/polychop/
+ */
+
+
 class SimplifyModifier {
   constructor() {
-    this.computeEdgeCollapseCost = (u, v) => {
+    _defineProperty(this, "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".
       const edgelength = v.position.distanceTo(u.position);
       let curvature = 0;
       const sideFaces = [];
-      let i, il = u.faces.length, face, sideFace;
+      let i,
+          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++) {
         let minCurvature = 1;
         face = u.faces[i];
+
         for (let j = 0; j < sideFaces.length; j++) {
-          sideFace = sideFaces[j];
+          sideFace = sideFaces[j]; // use dot product of face normals.
+
           const 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
+
+
       const borders = 0;
+
       if (sideFaces.length < 2) {
+        // we add some arbitrary cost for borders,
+        // borders += 10;
         curvature = 1;
       }
+
       const amt = edgelength * curvature + borders;
       return amt;
-    };
-    this.computeEdgeCostAtVertex = (v) => {
+    });
+
+    _defineProperty(this, "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 = 1e5;
-      v.collapseNeighbor = null;
+
+      v.collapseCost = 100000;
+      v.collapseNeighbor = null; // search all neighboring edges for "least cost" edge
+
       for (let i = 0; i < v.neighbors.length; i++) {
         const collapseCost = this.computeEdgeCollapseCost(v, v.neighbors[i]);
+
         if (!v.collapseNeighbor) {
           v.collapseNeighbor = v.neighbors[i];
           v.collapseCost = collapseCost;
@@ -143,83 +222,112 @@ class SimplifyModifier {
           v.totalCost = 0;
           v.costCount = 0;
         }
+
         v.costCount++;
         v.totalCost += collapseCost;
+
         if (collapseCost < v.minCost) {
           v.collapseNeighbor = v.neighbors[i];
           v.minCost = collapseCost;
         }
-      }
-      v.collapseCost = v.totalCost / v.costCount;
-    };
-    this.removeFace = (f, faces) => {
+      } // we average the cost of collapsing at this vertex
+
+
+      v.collapseCost = v.totalCost / v.costCount; // v.collapseCost = v.minCost;
+    });
+
+    _defineProperty(this, "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);
+      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!
+
       const vs = [f.v1, f.v2, f.v3];
       let v1, v2;
+
       for (let i = 0; i < 3; i++) {
         v1 = vs[i];
         v2 = vs[(i + 1) % 3];
-        if (!v1 || !v2)
-          continue;
+        if (!v1 || !v2) continue;
         v1.removeIfNonNeighbor(v2);
         v2.removeIfNonNeighbor(v1);
       }
-    };
-    this.collapse = (vertices, faces, u, v) => {
+    });
+
+    _defineProperty(this, "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..
         this.removeVertex(u, vertices);
         return;
       }
+
       let i;
       const 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)) {
           this.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);
       }
-      this.removeVertex(u, vertices);
+
+      this.removeVertex(u, vertices); // recompute the edge collapse costs in neighborhood
+
       for (i = 0; i < tmpVertices.length; i++) {
         this.computeEdgeCostAtVertex(tmpVertices[i]);
       }
-    };
-    this.minimumCostEdge = (vertices) => {
+    });
+
+    _defineProperty(this, "minimumCostEdge", vertices => {
+      // O(n * n) approach. TODO optimize this
       let least = vertices[0];
+
       for (let i = 0; i < vertices.length; i++) {
         if (vertices[i].collapseCost < least.collapseCost) {
           least = vertices[i];
         }
       }
+
       return least;
-    };
-    this.modify = (geometry, count) => {
+    });
+
+    _defineProperty(this, "modify", (geometry, count) => {
       geometry = geometry.clone();
-      const attributes = geometry.attributes;
+      const attributes = geometry.attributes; // this modifier can only process indexed and non-indexed geomtries with a position attribute
+
       for (let name in attributes) {
-        if (name !== "position")
-          geometry.deleteAttribute(name);
+        if (name !== 'position') geometry.deleteAttribute(name);
       }
-      geometry = BufferGeometryUtils.mergeVertices(geometry);
+
+      geometry = mergeVertices(geometry); //
+      // put data of original geometry in different data structures
+      //
+
       const vertices = [];
-      const faces = [];
-      const positionAttribute = geometry.getAttribute("position");
+      const faces = []; // add vertices
+
+      const positionAttribute = geometry.getAttribute('position');
+
       for (let i = 0; i < positionAttribute.count; i++) {
-        const v = new THREE.Vector3().fromBufferAttribute(positionAttribute, i);
+        const v = new Vector3().fromBufferAttribute(positionAttribute, i);
         const vertex = new Vertex(v, i);
         vertices.push(vertex);
-      }
+      } // add faces
+
+
       const geomIndex = geometry.getIndex();
+
       if (geomIndex !== null) {
         for (let i = 0; i < geomIndex.count; i += 3) {
           const a = geomIndex.getX(i);
@@ -236,47 +344,64 @@ class SimplifyModifier {
           const triangle = new Triangle(vertices[a], vertices[b], vertices[c], a, b, c);
           faces.push(triangle);
         }
-      }
+      } // compute all edge collapse costs
+
+
       for (let i = 0, il = vertices.length; i < il; i++) {
         this.computeEdgeCostAtVertex(vertices[i]);
       }
+
       let nextVertex;
       let z = count;
+
       while (z--) {
         nextVertex = this.minimumCostEdge(vertices);
+
         if (!nextVertex) {
-          console.log("THREE.SimplifyModifier: No next vertex");
+          console.log('THREE.SimplifyModifier: No next vertex');
           break;
         } else {
           this.collapse(vertices, faces, nextVertex, nextVertex.collapseNeighbor);
         }
-      }
-      const simplifiedGeometry = new THREE.BufferGeometry();
+      } //
+
+
+      const simplifiedGeometry = new BufferGeometry();
       const position = [];
-      let index = [];
+      let index = []; //
+
       for (let i = 0; i < vertices.length; i++) {
         const vertex = vertices[i].position;
         position.push(vertex.x, vertex.y, vertex.z);
-      }
+      } //
+
+
       for (let i = 0; i < faces.length; i++) {
         const face = faces[i];
         const a = vertices.indexOf(face.v1);
         const b = vertices.indexOf(face.v2);
         const c = vertices.indexOf(face.v3);
         index.push(a, b, c);
-      }
-      simplifiedGeometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+      } //
+
+
+      simplifiedGeometry.setAttribute('position', new Float32BufferAttribute(position, 3));
       simplifiedGeometry.setIndex(index);
       return simplifiedGeometry;
-    };
+    });
   }
+
   removeVertex(v, vertices) {
     console.assert(v.faces.length === 0);
+
     while (v.neighbors.length) {
       const n = v.neighbors.pop();
       removeFromArray(n.neighbors, v);
     }
+
     removeFromArray(vertices, v);
   }
+
 }
-exports.SimplifyModifier = SimplifyModifier;
+
+export { SimplifyModifier };

package/modifiers/TessellateModifier.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@babel/runtime/helpers/defineProperty"),e=require("three");function t(r){return r&&"object"==typeof r&&"default"in r?r:{default:r}}var o=t(r);exports.TessellateModifier=class{constructor(r=.1,t=6){o.default(this,"maxEdgeLength",void 0),o.default(this,"maxIterations",void 0),o.default(this,"modify",(r=>{null!==r.index&&(r=r.toNonIndexed());const t=this.maxIterations,o=this.maxEdgeLength*this.maxEdgeLength,s=new e.Vector3,n=new e.Vector3,u=new e.Vector3,a=new e.Vector3,l=[s,n,u,a],i=new e.Vector3,c=new e.Vector3,f=new e.Vector3,p=new e.Vector3,y=[i,c,f,p],h=new e.Color,d=new e.Color,m=new e.Color,V=new e.Color,w=[h,d,m,V],A=new e.Vector2,x=new e.Vector2,b=new e.Vector2,v=new e.Vector2,g=[A,x,b,v],C=new e.Vector2,z=new e.Vector2,B=new e.Vector2,q=new e.Vector2,F=[C,z,B,q],E=r.attributes,I=void 0!==E.normal,L=void 0!==E.color,T=void 0!==E.uv,S=void 0!==E.uv2;let j=E.position.array,M=I?E.normal.array:null,P=L?E.color.array:null,_=T?E.uv.array:null,G=S?E.uv2.array:null,N=j,O=M,k=P,D=_,H=G,J=0,K=!0;function Q(r,e,t){const o=l[r],s=l[e],n=l[t];if(N.push(o.x,o.y,o.z),N.push(s.x,s.y,s.z),N.push(n.x,n.y,n.z),I){const o=y[r],s=y[e],n=y[t];O.push(o.x,o.y,o.z),O.push(s.x,s.y,s.z),O.push(n.x,n.y,n.z)}if(L){const o=w[r],s=w[e],n=w[t];k.push(o.r,o.g,o.b),k.push(s.r,s.g,s.b),k.push(n.r,n.g,n.b)}if(T){const o=g[r],s=g[e],n=g[t];D.push(o.x,o.y),D.push(s.x,s.y),D.push(n.x,n.y)}if(S){const o=F[r],s=F[e],n=F[t];H.push(o.x,o.y),H.push(s.x,s.y),H.push(n.x,n.y)}}for(;K&&J<t;){J++,K=!1,j=N,N=[],I&&(M=O,O=[]),L&&(P=k,k=[]),T&&(_=D,D=[]),S&&(G=H,H=[]);for(let r=0,e=0,t=j.length;r<t;r+=9,e+=6){s.fromArray(j,r+0),n.fromArray(j,r+3),u.fromArray(j,r+6),I&&M&&(i.fromArray(M,r+0),c.fromArray(M,r+3),f.fromArray(M,r+6)),L&&P&&(h.fromArray(P,r+0),d.fromArray(P,r+3),m.fromArray(P,r+6)),T&&_&&(A.fromArray(_,e+0),x.fromArray(_,e+2),b.fromArray(_,e+4)),S&&G&&(C.fromArray(G,e+0),z.fromArray(G,e+2),B.fromArray(G,e+4));const t=s.distanceToSquared(n),l=n.distanceToSquared(u),y=s.distanceToSquared(u);t>o||l>o||y>o?(K=!0,t>=l&&t>=y?(a.lerpVectors(s,n,.5),I&&p.lerpVectors(i,c,.5),L&&V.lerpColors(h,d,.5),T&&v.lerpVectors(A,x,.5),S&&q.lerpVectors(C,z,.5),Q(0,3,2),Q(3,1,2)):l>=t&&l>=y?(a.lerpVectors(n,u,.5),I&&p.lerpVectors(c,f,.5),L&&V.lerpColors(d,m,.5),T&&v.lerpVectors(x,b,.5),S&&q.lerpVectors(z,B,.5),Q(0,1,3),Q(3,2,0)):(a.lerpVectors(s,u,.5),I&&p.lerpVectors(i,f,.5),L&&V.lerpColors(h,m,.5),T&&v.lerpVectors(A,b,.5),S&&q.lerpVectors(C,B,.5),Q(0,1,3),Q(3,1,2))):Q(0,1,2)}}const R=new e.BufferGeometry;return R.setAttribute("position",new e.Float32BufferAttribute(N,3)),I&&R.setAttribute("normal",new e.Float32BufferAttribute(O,3)),L&&R.setAttribute("color",new e.Float32BufferAttribute(k,3)),T&&R.setAttribute("uv",new e.Float32BufferAttribute(D,2)),S&&R.setAttribute("uv2",new e.Float32BufferAttribute(H,2)),R})),this.maxEdgeLength=r,this.maxIterations=t}};