three-stdlib 2.25.0 → 2.26.0

package/modifiers/CurveModifier.js

@@ -1,232 +0,0 @@
-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 = /* @__PURE__ */ 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/modifiers/EdgeSplitModifier.cjs

@@ -1,167 +0,0 @@
-"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.cjs");
-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;

package/modifiers/EdgeSplitModifier.js

@@ -1,168 +0,0 @@
-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 { Vector3, BufferAttribute, BufferGeometry } from "three";
-import * as BufferGeometryUtils from "../utils/BufferGeometryUtils.js";
-import { mergeVertices } from "../utils/BufferGeometryUtils.js";
-class EdgeSplitModifier {
-  constructor() {
-    __publicField(this, "A", new Vector3());
-    __publicField(this, "B", new Vector3());
-    __publicField(this, "C", new 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 = 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
-};