three-stdlib 2.16.0 → 2.16.1

package/modifiers/EdgeSplitModifier.mjs

@@ -1,162 +0,0 @@
-import { Vector3, BufferAttribute, BufferGeometry } from "three";
-import * as BufferGeometryUtils from "../utils/BufferGeometryUtils.mjs";
-import { mergeVertices } from "../utils/BufferGeometryUtils.mjs";
-class EdgeSplitModifier {
-  constructor() {
-    this.A = new Vector3();
-    this.B = new Vector3();
-    this.C = new Vector3();
-    this.positions = [];
-    this.normals = new Float32Array();
-    this.indexes = [];
-    this.pointToIndexMap = [];
-    this.splitIndexes = [];
-    this.oldNormals = [];
-    this.computeNormals = () => {
-      this.normals = new Float32Array(this.indexes.length * 3);
-      for (let i = 0; i < this.indexes.length; i += 3) {
-        let index = this.indexes[i];
-        this.A.set(this.positions[3 * index], this.positions[3 * index + 1], this.positions[3 * index + 2]);
-        index = this.indexes[i + 1];
-        this.B.set(this.positions[3 * index], this.positions[3 * index + 1], this.positions[3 * index + 2]);
-        index = this.indexes[i + 2];
-        this.C.set(this.positions[3 * index], this.positions[3 * index + 1], this.positions[3 * index + 2]);
-        this.C.sub(this.B);
-        this.A.sub(this.B);
-        const normal = this.C.cross(this.A).normalize();
-        for (let j = 0; j < 3; j++) {
-          this.normals[3 * (i + j)] = normal.x;
-          this.normals[3 * (i + j) + 1] = normal.y;
-          this.normals[3 * (i + j) + 2] = normal.z;
-        }
-      }
-    };
-    this.mapPositionsToIndexes = () => {
-      this.pointToIndexMap = Array(this.positions.length / 3);
-      for (let i = 0; i < this.indexes.length; i++) {
-        const index = this.indexes[i];
-        if (this.pointToIndexMap[index] == null) {
-          this.pointToIndexMap[index] = [];
-        }
-        this.pointToIndexMap[index].push(i);
-      }
-    };
-    this.edgeSplitToGroups = (indexes, cutOff, firstIndex) => {
-      this.A.set(
-        this.normals[3 * firstIndex],
-        this.normals[3 * firstIndex + 1],
-        this.normals[3 * firstIndex + 2]
-      ).normalize();
-      const result = {
-        splitGroup: [],
-        currentGroup: [firstIndex]
-      };
-      for (let j of indexes) {
-        if (j !== firstIndex) {
-          this.B.set(this.normals[3 * j], this.normals[3 * j + 1], this.normals[3 * j + 2]).normalize();
-          if (this.B.dot(this.A) < cutOff) {
-            result.splitGroup.push(j);
-          } else {
-            result.currentGroup.push(j);
-          }
-        }
-      }
-      return result;
-    };
-    this.edgeSplit = (indexes, cutOff, original = null) => {
-      if (indexes.length === 0)
-        return;
-      const groupResults = [];
-      for (let index of indexes) {
-        groupResults.push(this.edgeSplitToGroups(indexes, cutOff, index));
-      }
-      let result = groupResults[0];
-      for (let groupResult of groupResults) {
-        if (groupResult.currentGroup.length > result.currentGroup.length) {
-          result = groupResult;
-        }
-      }
-      if (original != null) {
-        this.splitIndexes.push({
-          original,
-          indexes: result.currentGroup
-        });
-      }
-      if (result.splitGroup.length) {
-        this.edgeSplit(result.splitGroup, cutOff, original || result.currentGroup[0]);
-      }
-    };
-    this.modify = (geometry, cutOffAngle, tryKeepNormals = true) => {
-      let hadNormals = false;
-      if (geometry.attributes.normal) {
-        hadNormals = true;
-        geometry = geometry.clone();
-        if (tryKeepNormals === true && geometry.index !== null) {
-          this.oldNormals = geometry.attributes.normal.array;
-        }
-        geometry.deleteAttribute("normal");
-      }
-      if (geometry.index == null) {
-        if (BufferGeometryUtils === void 0) {
-          throw "THREE.EdgeSplitModifier relies on BufferGeometryUtils";
-        }
-        geometry = mergeVertices(geometry);
-      }
-      this.indexes = geometry.index.array;
-      this.positions = geometry.getAttribute("position").array;
-      this.computeNormals();
-      this.mapPositionsToIndexes();
-      this.splitIndexes = [];
-      for (let vertexIndexes of this.pointToIndexMap) {
-        this.edgeSplit(vertexIndexes, Math.cos(cutOffAngle) - 1e-3);
-      }
-      const newAttributes = {};
-      for (let name of Object.keys(geometry.attributes)) {
-        const oldAttribute = geometry.attributes[name];
-        const newArray = new oldAttribute.array.constructor(
-          (this.indexes.length + this.splitIndexes.length) * oldAttribute.itemSize
-        );
-        newArray.set(oldAttribute.array);
-        newAttributes[name] = new BufferAttribute(newArray, oldAttribute.itemSize, oldAttribute.normalized);
-      }
-      const newIndexes = new Uint32Array(this.indexes.length);
-      newIndexes.set(this.indexes);
-      for (let i = 0; i < this.splitIndexes.length; i++) {
-        const split = this.splitIndexes[i];
-        const index = this.indexes[split.original];
-        for (let attribute of Object.values(newAttributes)) {
-          for (let j = 0; j < attribute.itemSize; j++) {
-            attribute.array[(this.indexes.length + i) * attribute.itemSize + j] = attribute.array[index * attribute.itemSize + j];
-          }
-        }
-        for (let j of split.indexes) {
-          newIndexes[j] = this.indexes.length + i;
-        }
-      }
-      geometry = new BufferGeometry();
-      geometry.setIndex(new BufferAttribute(newIndexes, 1));
-      for (let name of Object.keys(newAttributes)) {
-        geometry.setAttribute(name, newAttributes[name]);
-      }
-      if (hadNormals) {
-        geometry.computeVertexNormals();
-        if (this.oldNormals !== null) {
-          const changedNormals = new Array(this.oldNormals.length / 3).fill(false);
-          for (let splitData of this.splitIndexes)
-            changedNormals[splitData.original] = true;
-          for (let i = 0; i < changedNormals.length; i++) {
-            if (changedNormals[i] === false) {
-              for (let j = 0; j < 3; j++) {
-                geometry.attributes.normal.array[3 * i + j] = this.oldNormals[3 * i + j];
-              }
-            }
-          }
-        }
-      }
-      return geometry;
-    };
-  }
-}
-export {
-  EdgeSplitModifier
-};

package/modifiers/SimplifyModifier.mjs

@@ -1,282 +0,0 @@
-import { Vector3, BufferGeometry, Float32BufferAttribute } from "three";
-import { mergeVertices } from "../utils/BufferGeometryUtils.mjs";
-const cb = new Vector3(), ab = new Vector3();
-function pushIfUnique(array, 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);
-}
-class Vertex {
-  constructor(v, id) {
-    this.minCost = 0;
-    this.totalCost = 0;
-    this.costCount = 0;
-    this.position = v;
-    this.id = id;
-    this.faces = [];
-    this.neighbors = [];
-    this.collapseCost = 0;
-    this.collapseNeighbor = null;
-  }
-  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;
-    for (let i = 0; i < faces.length; i++) {
-      if (faces[i].hasVertex(n))
-        return;
-    }
-    neighbors.splice(offset, 1);
-  }
-}
-class Triangle {
-  constructor(v1, v2, v3, a, b, c) {
-    this.normal = new Vector3();
-    this.a = a;
-    this.b = b;
-    this.c = c;
-    this.v1 = v1;
-    this.v2 = v2;
-    this.v3 = v3;
-    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);
-  }
-  computeNormal() {
-    const vA = this.v1.position;
-    const vB = this.v2.position;
-    const vC = this.v3.position;
-    cb.subVectors(vC, vB);
-    ab.subVectors(vA, vB);
-    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;
-    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();
-  }
-}
-class SimplifyModifier {
-  constructor() {
-    this.computeEdgeCollapseCost = (u, v) => {
-      const edgelength = v.position.distanceTo(u.position);
-      let curvature = 0;
-      const sideFaces = [];
-      let i, il = u.faces.length, face, sideFace;
-      for (i = 0; i < il; i++) {
-        face = u.faces[i];
-        if (face.hasVertex(v)) {
-          sideFaces.push(face);
-        }
-      }
-      for (i = 0; i < il; i++) {
-        let minCurvature = 1;
-        face = u.faces[i];
-        for (let j = 0; j < sideFaces.length; j++) {
-          sideFace = sideFaces[j];
-          const dotProd = face.normal.dot(sideFace.normal);
-          minCurvature = Math.min(minCurvature, (1.001 - dotProd) / 2);
-        }
-        curvature = Math.max(curvature, minCurvature);
-      }
-      const borders = 0;
-      if (sideFaces.length < 2) {
-        curvature = 1;
-      }
-      const amt = edgelength * curvature + borders;
-      return amt;
-    };
-    this.computeEdgeCostAtVertex = (v) => {
-      if (v.neighbors.length === 0) {
-        v.collapseNeighbor = null;
-        v.collapseCost = -0.01;
-        return;
-      }
-      v.collapseCost = 1e5;
-      v.collapseNeighbor = null;
-      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;
-          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;
-        }
-      }
-      v.collapseCost = v.totalCost / v.costCount;
-    };
-    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);
-      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;
-        v1.removeIfNonNeighbor(v2);
-        v2.removeIfNonNeighbor(v1);
-      }
-    };
-    this.collapse = (vertices, faces, u, v) => {
-      if (!v) {
-        this.removeVertex(u, vertices);
-        return;
-      }
-      let i;
-      const tmpVertices = [];
-      for (i = 0; i < u.neighbors.length; i++) {
-        tmpVertices.push(u.neighbors[i]);
-      }
-      for (i = u.faces.length - 1; i >= 0; i--) {
-        if (u.faces[i].hasVertex(v)) {
-          this.removeFace(u.faces[i], faces);
-        }
-      }
-      for (i = u.faces.length - 1; i >= 0; i--) {
-        u.faces[i].replaceVertex(u, v);
-      }
-      this.removeVertex(u, vertices);
-      for (i = 0; i < tmpVertices.length; i++) {
-        this.computeEdgeCostAtVertex(tmpVertices[i]);
-      }
-    };
-    this.minimumCostEdge = (vertices) => {
-      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) => {
-      geometry = geometry.clone();
-      const attributes = geometry.attributes;
-      for (let name in attributes) {
-        if (name !== "position")
-          geometry.deleteAttribute(name);
-      }
-      geometry = mergeVertices(geometry);
-      const vertices = [];
-      const faces = [];
-      const positionAttribute = geometry.getAttribute("position");
-      for (let i = 0; i < positionAttribute.count; i++) {
-        const v = new Vector3().fromBufferAttribute(positionAttribute, i);
-        const vertex = new Vertex(v, i);
-        vertices.push(vertex);
-      }
-      const geomIndex = geometry.getIndex();
-      if (geomIndex !== null) {
-        for (let i = 0; i < geomIndex.count; i += 3) {
-          const a = geomIndex.getX(i);
-          const b = geomIndex.getX(i + 1);
-          const c = geomIndex.getX(i + 2);
-          const triangle = new Triangle(vertices[a], vertices[b], vertices[c], a, b, c);
-          faces.push(triangle);
-        }
-      } else {
-        for (let i = 0; i < positionAttribute.count; i += 3) {
-          const a = i;
-          const b = i + 1;
-          const c = i + 2;
-          const triangle = new Triangle(vertices[a], vertices[b], vertices[c], a, b, c);
-          faces.push(triangle);
-        }
-      }
-      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");
-          break;
-        } else {
-          this.collapse(vertices, faces, nextVertex, nextVertex.collapseNeighbor);
-        }
-      }
-      const simplifiedGeometry = new BufferGeometry();
-      const position = [];
-      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 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);
-  }
-}
-export {
-  SimplifyModifier
-};

package/modifiers/TessellateModifier.mjs

@@ -1,206 +0,0 @@
-import { Vector3, Color, Vector2, BufferGeometry, Float32BufferAttribute } from "three";
-class TessellateModifier {
-  constructor(maxEdgeLength = 0.1, maxIterations = 6) {
-    this.modify = (geometry) => {
-      if (geometry.index !== null) {
-        geometry = geometry.toNonIndexed();
-      }
-      const maxIterations2 = this.maxIterations;
-      const maxEdgeLengthSquared = this.maxEdgeLength * this.maxEdgeLength;
-      const va = new Vector3();
-      const vb = new Vector3();
-      const vc = new Vector3();
-      const vm = new Vector3();
-      const vs = [va, vb, vc, vm];
-      const na = new Vector3();
-      const nb = new Vector3();
-      const nc = new Vector3();
-      const nm = new Vector3();
-      const ns = [na, nb, nc, nm];
-      const ca = new Color();
-      const cb = new Color();
-      const cc = new Color();
-      const cm = new Color();
-      const cs = [ca, cb, cc, cm];
-      const ua = new Vector2();
-      const ub = new Vector2();
-      const uc = new Vector2();
-      const um = new Vector2();
-      const us = [ua, ub, uc, um];
-      const u2a = new Vector2();
-      const u2b = new Vector2();
-      const u2c = new Vector2();
-      const u2m = new Vector2();
-      const u2s = [u2a, u2b, u2c, u2m];
-      const attributes = geometry.attributes;
-      const hasNormals = attributes.normal !== void 0;
-      const hasColors = attributes.color !== void 0;
-      const hasUVs = attributes.uv !== void 0;
-      const hasUV2s = attributes.uv2 !== void 0;
-      let positions = attributes.position.array;
-      let normals = hasNormals ? attributes.normal.array : null;
-      let colors = hasColors ? attributes.color.array : null;
-      let uvs = hasUVs ? attributes.uv.array : null;
-      let uv2s = hasUV2s ? attributes.uv2.array : null;
-      let positions2 = positions;
-      let normals2 = normals;
-      let colors2 = colors;
-      let uvs2 = uvs;
-      let uv2s2 = uv2s;
-      let iteration = 0;
-      let tessellating = true;
-      function addTriangle(a, b, c) {
-        const v1 = vs[a];
-        const v2 = vs[b];
-        const v3 = vs[c];
-        positions2.push(v1.x, v1.y, v1.z);
-        positions2.push(v2.x, v2.y, v2.z);
-        positions2.push(v3.x, v3.y, v3.z);
-        if (hasNormals) {
-          const n1 = ns[a];
-          const n2 = ns[b];
-          const n3 = ns[c];
-          normals2.push(n1.x, n1.y, n1.z);
-          normals2.push(n2.x, n2.y, n2.z);
-          normals2.push(n3.x, n3.y, n3.z);
-        }
-        if (hasColors) {
-          const c1 = cs[a];
-          const c2 = cs[b];
-          const c3 = cs[c];
-          colors2.push(c1.r, c1.g, c1.b);
-          colors2.push(c2.r, c2.g, c2.b);
-          colors2.push(c3.r, c3.g, c3.b);
-        }
-        if (hasUVs) {
-          const u1 = us[a];
-          const u2 = us[b];
-          const u3 = us[c];
-          uvs2.push(u1.x, u1.y);
-          uvs2.push(u2.x, u2.y);
-          uvs2.push(u3.x, u3.y);
-        }
-        if (hasUV2s) {
-          const u21 = u2s[a];
-          const u22 = u2s[b];
-          const u23 = u2s[c];
-          uv2s2.push(u21.x, u21.y);
-          uv2s2.push(u22.x, u22.y);
-          uv2s2.push(u23.x, u23.y);
-        }
-      }
-      while (tessellating && iteration < maxIterations2) {
-        iteration++;
-        tessellating = false;
-        positions = positions2;
-        positions2 = [];
-        if (hasNormals) {
-          normals = normals2;
-          normals2 = [];
-        }
-        if (hasColors) {
-          colors = colors2;
-          colors2 = [];
-        }
-        if (hasUVs) {
-          uvs = uvs2;
-          uvs2 = [];
-        }
-        if (hasUV2s) {
-          uv2s = uv2s2;
-          uv2s2 = [];
-        }
-        for (let i = 0, i2 = 0, il = positions.length; i < il; i += 9, i2 += 6) {
-          va.fromArray(positions, i + 0);
-          vb.fromArray(positions, i + 3);
-          vc.fromArray(positions, i + 6);
-          if (hasNormals && normals) {
-            na.fromArray(normals, i + 0);
-            nb.fromArray(normals, i + 3);
-            nc.fromArray(normals, i + 6);
-          }
-          if (hasColors && colors) {
-            ca.fromArray(colors, i + 0);
-            cb.fromArray(colors, i + 3);
-            cc.fromArray(colors, i + 6);
-          }
-          if (hasUVs && uvs) {
-            ua.fromArray(uvs, i2 + 0);
-            ub.fromArray(uvs, i2 + 2);
-            uc.fromArray(uvs, i2 + 4);
-          }
-          if (hasUV2s && uv2s) {
-            u2a.fromArray(uv2s, i2 + 0);
-            u2b.fromArray(uv2s, i2 + 2);
-            u2c.fromArray(uv2s, i2 + 4);
-          }
-          const dab = va.distanceToSquared(vb);
-          const dbc = vb.distanceToSquared(vc);
-          const dac = va.distanceToSquared(vc);
-          if (dab > maxEdgeLengthSquared || dbc > maxEdgeLengthSquared || dac > maxEdgeLengthSquared) {
-            tessellating = true;
-            if (dab >= dbc && dab >= dac) {
-              vm.lerpVectors(va, vb, 0.5);
-              if (hasNormals)
-                nm.lerpVectors(na, nb, 0.5);
-              if (hasColors)
-                cm.lerpColors(ca, cb, 0.5);
-              if (hasUVs)
-                um.lerpVectors(ua, ub, 0.5);
-              if (hasUV2s)
-                u2m.lerpVectors(u2a, u2b, 0.5);
-              addTriangle(0, 3, 2);
-              addTriangle(3, 1, 2);
-            } else if (dbc >= dab && dbc >= dac) {
-              vm.lerpVectors(vb, vc, 0.5);
-              if (hasNormals)
-                nm.lerpVectors(nb, nc, 0.5);
-              if (hasColors)
-                cm.lerpColors(cb, cc, 0.5);
-              if (hasUVs)
-                um.lerpVectors(ub, uc, 0.5);
-              if (hasUV2s)
-                u2m.lerpVectors(u2b, u2c, 0.5);
-              addTriangle(0, 1, 3);
-              addTriangle(3, 2, 0);
-            } else {
-              vm.lerpVectors(va, vc, 0.5);
-              if (hasNormals)
-                nm.lerpVectors(na, nc, 0.5);
-              if (hasColors)
-                cm.lerpColors(ca, cc, 0.5);
-              if (hasUVs)
-                um.lerpVectors(ua, uc, 0.5);
-              if (hasUV2s)
-                u2m.lerpVectors(u2a, u2c, 0.5);
-              addTriangle(0, 1, 3);
-              addTriangle(3, 1, 2);
-            }
-          } else {
-            addTriangle(0, 1, 2);
-          }
-        }
-      }
-      const geometry2 = new BufferGeometry();
-      geometry2.setAttribute("position", new Float32BufferAttribute(positions2, 3));
-      if (hasNormals) {
-        geometry2.setAttribute("normal", new Float32BufferAttribute(normals2, 3));
-      }
-      if (hasColors) {
-        geometry2.setAttribute("color", new Float32BufferAttribute(colors2, 3));
-      }
-      if (hasUVs) {
-        geometry2.setAttribute("uv", new Float32BufferAttribute(uvs2, 2));
-      }
-      if (hasUV2s) {
-        geometry2.setAttribute("uv2", new Float32BufferAttribute(uv2s2, 2));
-      }
-      return geometry2;
-    };
-    this.maxEdgeLength = maxEdgeLength;
-    this.maxIterations = maxIterations;
-  }
-}
-export {
-  TessellateModifier
-};