three-stdlib 2.22.7 → 2.22.8

package/dist/modifiers/CurveModifier.js

@@ -0,0 +1,232 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const CHANNELS = 4;
+const TEXTURE_WIDTH = 1024;
+const TEXTURE_HEIGHT = 4;
+const initSplineTexture = (numberOfCurves = 1) => {
+  const dataArray = new Float32Array(TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS);
+  const dataTexture = new THREE.DataTexture(dataArray, TEXTURE_WIDTH, TEXTURE_HEIGHT * numberOfCurves, THREE.RGBAFormat, THREE.FloatType);
+  dataTexture.wrapS = THREE.RepeatWrapping;
+  dataTexture.wrapT = THREE.RepeatWrapping;
+  dataTexture.magFilter = THREE.NearestFilter;
+  dataTexture.needsUpdate = true;
+  return dataTexture;
+};
+const updateSplineTexture = (texture, splineCurve, offset = 0) => {
+  const numberOfPoints = Math.floor(TEXTURE_WIDTH * (TEXTURE_HEIGHT / 4));
+  splineCurve.arcLengthDivisions = numberOfPoints / 2;
+  splineCurve.updateArcLengths();
+  const points = splineCurve.getSpacedPoints(numberOfPoints);
+  const frenetFrames = splineCurve.computeFrenetFrames(numberOfPoints, true);
+  for (let i = 0; i < numberOfPoints; i++) {
+    const rowOffset = Math.floor(i / TEXTURE_WIDTH);
+    const rowIndex = i % TEXTURE_WIDTH;
+    let pt = points[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 0 + rowOffset + TEXTURE_HEIGHT * offset);
+    pt = frenetFrames.tangents[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 1 + rowOffset + TEXTURE_HEIGHT * offset);
+    pt = frenetFrames.normals[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 2 + rowOffset + TEXTURE_HEIGHT * offset);
+    pt = frenetFrames.binormals[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 3 + rowOffset + TEXTURE_HEIGHT * offset);
+  }
+  texture.needsUpdate = true;
+};
+const setTextureValue = (texture, index, x, y, z, o) => {
+  const image = texture.image;
+  const { data } = image;
+  const i = CHANNELS * TEXTURE_WIDTH * o;
+  data[index * CHANNELS + i + 0] = x;
+  data[index * CHANNELS + i + 1] = y;
+  data[index * CHANNELS + i + 2] = z;
+  data[index * CHANNELS + i + 3] = 1;
+};
+const getUniforms = (splineTexture) => ({
+  spineTexture: { value: splineTexture },
+  pathOffset: { type: "f", value: 0 },
+  // time of path curve
+  pathSegment: { type: "f", value: 1 },
+  // fractional length of path
+  spineOffset: { type: "f", value: 161 },
+  spineLength: { type: "f", value: 400 },
+  flow: { type: "i", value: 1 }
+});
+function modifyShader(material, uniforms, numberOfCurves = 1) {
+  if (material.__ok)
+    return;
+  material.__ok = true;
+  material.onBeforeCompile = (shader) => {
+    if (shader.__modified)
+      return;
+    shader.__modified = true;
+    Object.assign(shader.uniforms, uniforms);
+    const vertexShader = (
+      /* glsl */
+      `
+		uniform sampler2D spineTexture;
+		uniform float pathOffset;
+		uniform float pathSegment;
+		uniform float spineOffset;
+		uniform float spineLength;
+		uniform int flow;
+
+		float textureLayers = ${TEXTURE_HEIGHT * numberOfCurves}.;
+		float textureStacks = ${TEXTURE_HEIGHT / 4}.;
+
+		${shader.vertexShader}
+		`.replace("#include <beginnormal_vertex>", "").replace("#include <defaultnormal_vertex>", "").replace("#include <begin_vertex>", "").replace(
+        /void\s*main\s*\(\)\s*\{/,
+        /* glsl */
+        `
+        void main() {
+        #include <beginnormal_vertex>
+
+        vec4 worldPos = modelMatrix * vec4(position, 1.);
+
+        bool bend = flow > 0;
+        float xWeight = bend ? 0. : 1.;
+
+        #ifdef USE_INSTANCING
+        float pathOffsetFromInstanceMatrix = instanceMatrix[3][2];
+        float spineLengthFromInstanceMatrix = instanceMatrix[3][0];
+        float spinePortion = bend ? (worldPos.x + spineOffset) / spineLengthFromInstanceMatrix : 0.;
+        float mt = (spinePortion * pathSegment + pathOffset + pathOffsetFromInstanceMatrix)*textureStacks;
+        #else
+        float spinePortion = bend ? (worldPos.x + spineOffset) / spineLength : 0.;
+        float mt = (spinePortion * pathSegment + pathOffset)*textureStacks;
+        #endif
+
+        mt = mod(mt, textureStacks);
+        float rowOffset = floor(mt);
+
+        #ifdef USE_INSTANCING
+        rowOffset += instanceMatrix[3][1] * ${TEXTURE_HEIGHT}.;
+        #endif
+
+        vec3 spinePos = texture2D(spineTexture, vec2(mt, (0. + rowOffset + 0.5) / textureLayers)).xyz;
+        vec3 a =        texture2D(spineTexture, vec2(mt, (1. + rowOffset + 0.5) / textureLayers)).xyz;
+        vec3 b =        texture2D(spineTexture, vec2(mt, (2. + rowOffset + 0.5) / textureLayers)).xyz;
+        vec3 c =        texture2D(spineTexture, vec2(mt, (3. + rowOffset + 0.5) / textureLayers)).xyz;
+        mat3 basis = mat3(a, b, c);
+
+        vec3 transformed = basis
+          * vec3(worldPos.x * xWeight, worldPos.y * 1., worldPos.z * 1.)
+          + spinePos;
+
+        vec3 transformedNormal = normalMatrix * (basis * objectNormal);
+			`
+      ).replace(
+        "#include <project_vertex>",
+        /* glsl */
+        `vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
+				gl_Position = projectionMatrix * mvPosition;`
+      )
+    );
+    shader.vertexShader = vertexShader;
+  };
+}
+class Flow {
+  /**
+   * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+   * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+   */
+  constructor(mesh, numberOfCurves = 1) {
+    __publicField(this, "curveArray");
+    __publicField(this, "curveLengthArray");
+    __publicField(this, "object3D");
+    __publicField(this, "splineTexure");
+    __publicField(this, "uniforms");
+    const obj3D = mesh.clone();
+    const splineTexure = initSplineTexture(numberOfCurves);
+    const uniforms = getUniforms(splineTexure);
+    obj3D.traverse((child) => {
+      if (child instanceof THREE.Mesh || child instanceof THREE.InstancedMesh) {
+        child.material = child.material.clone();
+        modifyShader(child.material, uniforms, numberOfCurves);
+      }
+    });
+    this.curveArray = new Array(numberOfCurves);
+    this.curveLengthArray = new Array(numberOfCurves);
+    this.object3D = obj3D;
+    this.splineTexure = splineTexure;
+    this.uniforms = uniforms;
+  }
+  updateCurve(index, curve) {
+    if (index >= this.curveArray.length)
+      throw Error("Index out of range for Flow");
+    const curveLength = curve.getLength();
+    this.uniforms.spineLength.value = curveLength;
+    this.curveLengthArray[index] = curveLength;
+    this.curveArray[index] = curve;
+    updateSplineTexture(this.splineTexure, curve, index);
+  }
+  moveAlongCurve(amount) {
+    this.uniforms.pathOffset.value += amount;
+  }
+}
+const matrix = new THREE.Matrix4();
+class InstancedFlow extends Flow {
+  /**
+   *
+   * @param {number} count The number of instanced elements
+   * @param {number} curveCount The number of curves to preallocate for
+   * @param {Geometry} geometry The geometry to use for the instanced mesh
+   * @param {Material} material The material to use for the instanced mesh
+   */
+  constructor(count, curveCount, geometry, material) {
+    const mesh = new THREE.InstancedMesh(geometry, material, count);
+    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh.frustumCulled = false;
+    super(mesh, curveCount);
+    __publicField(this, "offsets");
+    __publicField(this, "whichCurve");
+    this.offsets = new Array(count).fill(0);
+    this.whichCurve = new Array(count).fill(0);
+  }
+  /**
+   * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+   * This writes that information to the matrix and marks it as needing update.
+   *
+   * @param {number} index of the instanced element to update
+   */
+  writeChanges(index) {
+    matrix.makeTranslation(this.curveLengthArray[this.whichCurve[index]], this.whichCurve[index], this.offsets[index]);
+    this.object3D.setMatrixAt(index, matrix);
+    this.object3D.instanceMatrix.needsUpdate = true;
+  }
+  /**
+   * Move an individual element along the curve by a specific amount
+   *
+   * @param {number} index Which element to update
+   * @param {number} offset Move by how much
+   */
+  moveIndividualAlongCurve(index, offset) {
+    this.offsets[index] += offset;
+    this.writeChanges(index);
+  }
+  /**
+   * Select which curve to use for an element
+   *
+   * @param {number} index the index of the instanced element to update
+   * @param {number} curveNo the index of the curve it should use
+   */
+  setCurve(index, curveNo) {
+    if (isNaN(curveNo))
+      throw Error("curve index being set is Not a Number (NaN)");
+    this.whichCurve[index] = curveNo;
+    this.writeChanges(index);
+  }
+}
+exports.Flow = Flow;
+exports.InstancedFlow = InstancedFlow;
+exports.getUniforms = getUniforms;
+exports.initSplineTexture = initSplineTexture;
+exports.modifyShader = modifyShader;
+exports.updateSplineTexture = updateSplineTexture;

package/dist/modifiers/CurveModifier.mjs

@@ -0,0 +1,232 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { DataTexture, RGBAFormat, FloatType, RepeatWrapping, NearestFilter, Mesh, InstancedMesh, Matrix4, DynamicDrawUsage } from "three";
+const CHANNELS = 4;
+const TEXTURE_WIDTH = 1024;
+const TEXTURE_HEIGHT = 4;
+const initSplineTexture = (numberOfCurves = 1) => {
+  const dataArray = new Float32Array(TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS);
+  const dataTexture = new DataTexture(dataArray, TEXTURE_WIDTH, TEXTURE_HEIGHT * numberOfCurves, RGBAFormat, FloatType);
+  dataTexture.wrapS = RepeatWrapping;
+  dataTexture.wrapT = RepeatWrapping;
+  dataTexture.magFilter = NearestFilter;
+  dataTexture.needsUpdate = true;
+  return dataTexture;
+};
+const updateSplineTexture = (texture, splineCurve, offset = 0) => {
+  const numberOfPoints = Math.floor(TEXTURE_WIDTH * (TEXTURE_HEIGHT / 4));
+  splineCurve.arcLengthDivisions = numberOfPoints / 2;
+  splineCurve.updateArcLengths();
+  const points = splineCurve.getSpacedPoints(numberOfPoints);
+  const frenetFrames = splineCurve.computeFrenetFrames(numberOfPoints, true);
+  for (let i = 0; i < numberOfPoints; i++) {
+    const rowOffset = Math.floor(i / TEXTURE_WIDTH);
+    const rowIndex = i % TEXTURE_WIDTH;
+    let pt = points[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 0 + rowOffset + TEXTURE_HEIGHT * offset);
+    pt = frenetFrames.tangents[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 1 + rowOffset + TEXTURE_HEIGHT * offset);
+    pt = frenetFrames.normals[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 2 + rowOffset + TEXTURE_HEIGHT * offset);
+    pt = frenetFrames.binormals[i];
+    setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 3 + rowOffset + TEXTURE_HEIGHT * offset);
+  }
+  texture.needsUpdate = true;
+};
+const setTextureValue = (texture, index, x, y, z, o) => {
+  const image = texture.image;
+  const { data } = image;
+  const i = CHANNELS * TEXTURE_WIDTH * o;
+  data[index * CHANNELS + i + 0] = x;
+  data[index * CHANNELS + i + 1] = y;
+  data[index * CHANNELS + i + 2] = z;
+  data[index * CHANNELS + i + 3] = 1;
+};
+const getUniforms = (splineTexture) => ({
+  spineTexture: { value: splineTexture },
+  pathOffset: { type: "f", value: 0 },
+  // time of path curve
+  pathSegment: { type: "f", value: 1 },
+  // fractional length of path
+  spineOffset: { type: "f", value: 161 },
+  spineLength: { type: "f", value: 400 },
+  flow: { type: "i", value: 1 }
+});
+function modifyShader(material, uniforms, numberOfCurves = 1) {
+  if (material.__ok)
+    return;
+  material.__ok = true;
+  material.onBeforeCompile = (shader) => {
+    if (shader.__modified)
+      return;
+    shader.__modified = true;
+    Object.assign(shader.uniforms, uniforms);
+    const vertexShader = (
+      /* glsl */
+      `
+		uniform sampler2D spineTexture;
+		uniform float pathOffset;
+		uniform float pathSegment;
+		uniform float spineOffset;
+		uniform float spineLength;
+		uniform int flow;
+
+		float textureLayers = ${TEXTURE_HEIGHT * numberOfCurves}.;
+		float textureStacks = ${TEXTURE_HEIGHT / 4}.;
+
+		${shader.vertexShader}
+		`.replace("#include <beginnormal_vertex>", "").replace("#include <defaultnormal_vertex>", "").replace("#include <begin_vertex>", "").replace(
+        /void\s*main\s*\(\)\s*\{/,
+        /* glsl */
+        `
+        void main() {
+        #include <beginnormal_vertex>
+
+        vec4 worldPos = modelMatrix * vec4(position, 1.);
+
+        bool bend = flow > 0;
+        float xWeight = bend ? 0. : 1.;
+
+        #ifdef USE_INSTANCING
+        float pathOffsetFromInstanceMatrix = instanceMatrix[3][2];
+        float spineLengthFromInstanceMatrix = instanceMatrix[3][0];
+        float spinePortion = bend ? (worldPos.x + spineOffset) / spineLengthFromInstanceMatrix : 0.;
+        float mt = (spinePortion * pathSegment + pathOffset + pathOffsetFromInstanceMatrix)*textureStacks;
+        #else
+        float spinePortion = bend ? (worldPos.x + spineOffset) / spineLength : 0.;
+        float mt = (spinePortion * pathSegment + pathOffset)*textureStacks;
+        #endif
+
+        mt = mod(mt, textureStacks);
+        float rowOffset = floor(mt);
+
+        #ifdef USE_INSTANCING
+        rowOffset += instanceMatrix[3][1] * ${TEXTURE_HEIGHT}.;
+        #endif
+
+        vec3 spinePos = texture2D(spineTexture, vec2(mt, (0. + rowOffset + 0.5) / textureLayers)).xyz;
+        vec3 a =        texture2D(spineTexture, vec2(mt, (1. + rowOffset + 0.5) / textureLayers)).xyz;
+        vec3 b =        texture2D(spineTexture, vec2(mt, (2. + rowOffset + 0.5) / textureLayers)).xyz;
+        vec3 c =        texture2D(spineTexture, vec2(mt, (3. + rowOffset + 0.5) / textureLayers)).xyz;
+        mat3 basis = mat3(a, b, c);
+
+        vec3 transformed = basis
+          * vec3(worldPos.x * xWeight, worldPos.y * 1., worldPos.z * 1.)
+          + spinePos;
+
+        vec3 transformedNormal = normalMatrix * (basis * objectNormal);
+			`
+      ).replace(
+        "#include <project_vertex>",
+        /* glsl */
+        `vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
+				gl_Position = projectionMatrix * mvPosition;`
+      )
+    );
+    shader.vertexShader = vertexShader;
+  };
+}
+class Flow {
+  /**
+   * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+   * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+   */
+  constructor(mesh, numberOfCurves = 1) {
+    __publicField(this, "curveArray");
+    __publicField(this, "curveLengthArray");
+    __publicField(this, "object3D");
+    __publicField(this, "splineTexure");
+    __publicField(this, "uniforms");
+    const obj3D = mesh.clone();
+    const splineTexure = initSplineTexture(numberOfCurves);
+    const uniforms = getUniforms(splineTexure);
+    obj3D.traverse((child) => {
+      if (child instanceof Mesh || child instanceof InstancedMesh) {
+        child.material = child.material.clone();
+        modifyShader(child.material, uniforms, numberOfCurves);
+      }
+    });
+    this.curveArray = new Array(numberOfCurves);
+    this.curveLengthArray = new Array(numberOfCurves);
+    this.object3D = obj3D;
+    this.splineTexure = splineTexure;
+    this.uniforms = uniforms;
+  }
+  updateCurve(index, curve) {
+    if (index >= this.curveArray.length)
+      throw Error("Index out of range for Flow");
+    const curveLength = curve.getLength();
+    this.uniforms.spineLength.value = curveLength;
+    this.curveLengthArray[index] = curveLength;
+    this.curveArray[index] = curve;
+    updateSplineTexture(this.splineTexure, curve, index);
+  }
+  moveAlongCurve(amount) {
+    this.uniforms.pathOffset.value += amount;
+  }
+}
+const matrix = new Matrix4();
+class InstancedFlow extends Flow {
+  /**
+   *
+   * @param {number} count The number of instanced elements
+   * @param {number} curveCount The number of curves to preallocate for
+   * @param {Geometry} geometry The geometry to use for the instanced mesh
+   * @param {Material} material The material to use for the instanced mesh
+   */
+  constructor(count, curveCount, geometry, material) {
+    const mesh = new InstancedMesh(geometry, material, count);
+    mesh.instanceMatrix.setUsage(DynamicDrawUsage);
+    mesh.frustumCulled = false;
+    super(mesh, curveCount);
+    __publicField(this, "offsets");
+    __publicField(this, "whichCurve");
+    this.offsets = new Array(count).fill(0);
+    this.whichCurve = new Array(count).fill(0);
+  }
+  /**
+   * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+   * This writes that information to the matrix and marks it as needing update.
+   *
+   * @param {number} index of the instanced element to update
+   */
+  writeChanges(index) {
+    matrix.makeTranslation(this.curveLengthArray[this.whichCurve[index]], this.whichCurve[index], this.offsets[index]);
+    this.object3D.setMatrixAt(index, matrix);
+    this.object3D.instanceMatrix.needsUpdate = true;
+  }
+  /**
+   * Move an individual element along the curve by a specific amount
+   *
+   * @param {number} index Which element to update
+   * @param {number} offset Move by how much
+   */
+  moveIndividualAlongCurve(index, offset) {
+    this.offsets[index] += offset;
+    this.writeChanges(index);
+  }
+  /**
+   * Select which curve to use for an element
+   *
+   * @param {number} index the index of the instanced element to update
+   * @param {number} curveNo the index of the curve it should use
+   */
+  setCurve(index, curveNo) {
+    if (isNaN(curveNo))
+      throw Error("curve index being set is Not a Number (NaN)");
+    this.whichCurve[index] = curveNo;
+    this.writeChanges(index);
+  }
+}
+export {
+  Flow,
+  InstancedFlow,
+  getUniforms,
+  initSplineTexture,
+  modifyShader,
+  updateSplineTexture
+};

package/dist/modifiers/EdgeSplitModifier.d.ts

@@ -0,0 +1,19 @@
+import { BufferGeometry } from 'three';
+declare class EdgeSplitModifier {
+    private A;
+    private B;
+    private C;
+    private positions;
+    private normals;
+    private indexes;
+    private pointToIndexMap;
+    private splitIndexes;
+    private oldNormals;
+    constructor();
+    private computeNormals;
+    private mapPositionsToIndexes;
+    private edgeSplitToGroups;
+    private edgeSplit;
+    modify: (geometry: BufferGeometry, cutOffAngle: number, tryKeepNormals?: boolean) => BufferGeometry;
+}
+export { EdgeSplitModifier };

package/dist/modifiers/EdgeSplitModifier.js

@@ -0,0 +1,167 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const BufferGeometryUtils = require("../utils/BufferGeometryUtils.js");
+class EdgeSplitModifier {
+  constructor() {
+    __publicField(this, "A", new THREE.Vector3());
+    __publicField(this, "B", new THREE.Vector3());
+    __publicField(this, "C", new THREE.Vector3());
+    __publicField(this, "positions", []);
+    __publicField(this, "normals", new Float32Array());
+    __publicField(this, "indexes", []);
+    __publicField(this, "pointToIndexMap", []);
+    __publicField(this, "splitIndexes", []);
+    __publicField(this, "oldNormals", []);
+    __publicField(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;
+        }
+      }
+    });
+    __publicField(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);
+      }
+    });
+    __publicField(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;
+    });
+    __publicField(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]);
+      }
+    });
+    __publicField(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 = BufferGeometryUtils.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 THREE.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 THREE.BufferGeometry();
+      geometry.setIndex(new THREE.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;
+    });
+  }
+}
+exports.EdgeSplitModifier = EdgeSplitModifier;