three-stdlib 2.22.7 → 2.22.9

package/dist/curves/NURBSUtils.mjs

@@ -0,0 +1,226 @@
+import { Vector4, Vector3 } from "three";
+function findSpan(p, u, U) {
+  const n = U.length - p - 1;
+  if (u >= U[n]) {
+    return n - 1;
+  }
+  if (u <= U[p]) {
+    return p;
+  }
+  let low = p;
+  let high = n;
+  let mid = Math.floor((low + high) / 2);
+  while (u < U[mid] || u >= U[mid + 1]) {
+    if (u < U[mid]) {
+      high = mid;
+    } else {
+      low = mid;
+    }
+    mid = Math.floor((low + high) / 2);
+  }
+  return mid;
+}
+function calcBasisFunctions(span, u, p, U) {
+  const N = [];
+  const left = [];
+  const right = [];
+  N[0] = 1;
+  for (let j = 1; j <= p; ++j) {
+    left[j] = u - U[span + 1 - j];
+    right[j] = U[span + j] - u;
+    let saved = 0;
+    for (let r = 0; r < j; ++r) {
+      const rv = right[r + 1];
+      const lv = left[j - r];
+      const temp = N[r] / (rv + lv);
+      N[r] = saved + rv * temp;
+      saved = lv * temp;
+    }
+    N[j] = saved;
+  }
+  return N;
+}
+function calcBSplinePoint(p, U, P, u) {
+  const span = findSpan(p, u, U);
+  const N = calcBasisFunctions(span, u, p, U);
+  const C = new Vector4(0, 0, 0, 0);
+  for (let j = 0; j <= p; ++j) {
+    const point = P[span - p + j];
+    const Nj = N[j];
+    const wNj = point.w * Nj;
+    C.x += point.x * wNj;
+    C.y += point.y * wNj;
+    C.z += point.z * wNj;
+    C.w += point.w * Nj;
+  }
+  return C;
+}
+function calcBasisFunctionDerivatives(span, u, p, n, U) {
+  const zeroArr = [];
+  for (let i = 0; i <= p; ++i)
+    zeroArr[i] = 0;
+  const ders = [];
+  for (let i = 0; i <= n; ++i)
+    ders[i] = zeroArr.slice(0);
+  const ndu = [];
+  for (let i = 0; i <= p; ++i)
+    ndu[i] = zeroArr.slice(0);
+  ndu[0][0] = 1;
+  const left = zeroArr.slice(0);
+  const right = zeroArr.slice(0);
+  for (let j2 = 1; j2 <= p; ++j2) {
+    left[j2] = u - U[span + 1 - j2];
+    right[j2] = U[span + j2] - u;
+    let saved = 0;
+    for (let r2 = 0; r2 < j2; ++r2) {
+      const rv = right[r2 + 1];
+      const lv = left[j2 - r2];
+      ndu[j2][r2] = rv + lv;
+      const temp = ndu[r2][j2 - 1] / ndu[j2][r2];
+      ndu[r2][j2] = saved + rv * temp;
+      saved = lv * temp;
+    }
+    ndu[j2][j2] = saved;
+  }
+  for (let j2 = 0; j2 <= p; ++j2) {
+    ders[0][j2] = ndu[j2][p];
+  }
+  for (let r2 = 0; r2 <= p; ++r2) {
+    let s1 = 0;
+    let s2 = 1;
+    const a = [];
+    for (let i = 0; i <= p; ++i) {
+      a[i] = zeroArr.slice(0);
+    }
+    a[0][0] = 1;
+    for (let k = 1; k <= n; ++k) {
+      let d = 0;
+      const rk = r2 - k;
+      const pk = p - k;
+      if (r2 >= k) {
+        a[s2][0] = a[s1][0] / ndu[pk + 1][rk];
+        d = a[s2][0] * ndu[rk][pk];
+      }
+      const j1 = rk >= -1 ? 1 : -rk;
+      const j2 = r2 - 1 <= pk ? k - 1 : p - r2;
+      for (let j3 = j1; j3 <= j2; ++j3) {
+        a[s2][j3] = (a[s1][j3] - a[s1][j3 - 1]) / ndu[pk + 1][rk + j3];
+        d += a[s2][j3] * ndu[rk + j3][pk];
+      }
+      if (r2 <= pk) {
+        a[s2][k] = -a[s1][k - 1] / ndu[pk + 1][r2];
+        d += a[s2][k] * ndu[r2][pk];
+      }
+      ders[k][r2] = d;
+      var j = s1;
+      s1 = s2;
+      s2 = j;
+    }
+  }
+  var r = p;
+  for (let k = 1; k <= n; ++k) {
+    for (let j2 = 0; j2 <= p; ++j2) {
+      ders[k][j2] *= r;
+    }
+    r *= p - k;
+  }
+  return ders;
+}
+function calcBSplineDerivatives(p, U, P, u, nd) {
+  const du = nd < p ? nd : p;
+  const CK = [];
+  const span = findSpan(p, u, U);
+  const nders = calcBasisFunctionDerivatives(span, u, p, du, U);
+  const Pw = [];
+  for (let i = 0; i < P.length; ++i) {
+    var point = P[i].clone();
+    const w = point.w;
+    point.x *= w;
+    point.y *= w;
+    point.z *= w;
+    Pw[i] = point;
+  }
+  for (let k = 0; k <= du; ++k) {
+    var point = Pw[span - p].clone().multiplyScalar(nders[k][0]);
+    for (let j = 1; j <= p; ++j) {
+      point.add(Pw[span - p + j].clone().multiplyScalar(nders[k][j]));
+    }
+    CK[k] = point;
+  }
+  for (let k = du + 1; k <= nd + 1; ++k) {
+    CK[k] = new Vector4(0, 0, 0);
+  }
+  return CK;
+}
+function calcKoverI(k, i) {
+  let nom = 1;
+  for (let j = 2; j <= k; ++j) {
+    nom *= j;
+  }
+  let denom = 1;
+  for (let j = 2; j <= i; ++j) {
+    denom *= j;
+  }
+  for (let j = 2; j <= k - i; ++j) {
+    denom *= j;
+  }
+  return nom / denom;
+}
+function calcRationalCurveDerivatives(Pders) {
+  const nd = Pders.length;
+  const Aders = [];
+  const wders = [];
+  for (let i = 0; i < nd; ++i) {
+    const point = Pders[i];
+    Aders[i] = new Vector3(point.x, point.y, point.z);
+    wders[i] = point.w;
+  }
+  const CK = [];
+  for (let k = 0; k < nd; ++k) {
+    const v = Aders[k].clone();
+    for (let i = 1; i <= k; ++i) {
+      v.sub(CK[k - i].clone().multiplyScalar(calcKoverI(k, i) * wders[i]));
+    }
+    CK[k] = v.divideScalar(wders[0]);
+  }
+  return CK;
+}
+function calcNURBSDerivatives(p, U, P, u, nd) {
+  const Pders = calcBSplineDerivatives(p, U, P, u, nd);
+  return calcRationalCurveDerivatives(Pders);
+}
+function calcSurfacePoint(p, q, U, V, P, u, v, target) {
+  const uspan = findSpan(p, u, U);
+  const vspan = findSpan(q, v, V);
+  const Nu = calcBasisFunctions(uspan, u, p, U);
+  const Nv = calcBasisFunctions(vspan, v, q, V);
+  const temp = [];
+  for (let l = 0; l <= q; ++l) {
+    temp[l] = new Vector4(0, 0, 0, 0);
+    for (let k = 0; k <= p; ++k) {
+      const point = P[uspan - p + k][vspan - q + l].clone();
+      const w = point.w;
+      point.x *= w;
+      point.y *= w;
+      point.z *= w;
+      temp[l].add(point.multiplyScalar(Nu[k]));
+    }
+  }
+  const Sw = new Vector4(0, 0, 0, 0);
+  for (let l = 0; l <= q; ++l) {
+    Sw.add(temp[l].multiplyScalar(Nv[l]));
+  }
+  Sw.divideScalar(Sw.w);
+  target.set(Sw.x, Sw.y, Sw.z);
+}
+export {
+  calcBSplineDerivatives,
+  calcBSplinePoint,
+  calcBasisFunctionDerivatives,
+  calcBasisFunctions,
+  calcKoverI,
+  calcNURBSDerivatives,
+  calcRationalCurveDerivatives,
+  calcSurfacePoint,
+  findSpan
+};

package/dist/custom.d.ts

@@ -0,0 +1,5 @@
+declare module 'mmd-parser' {
+  export class CharsetEncoder {
+    public s2uTable: { [key: string]: number }
+  }
+}

package/dist/deprecated/Geometry.d.ts

@@ -0,0 +1,342 @@
+import {
+  Vector3,
+  Color,
+  Vector2,
+  Vector4,
+  Box3,
+  Sphere,
+  Matrix4,
+  BufferGeometry,
+  Matrix,
+  Mesh,
+  Bone,
+  AnimationClip,
+  EventDispatcher,
+  Object3D,
+} from 'three'
+
+/**
+ * @deprecated Use Face3 instead.
+ */
+
+export interface MorphTarget {
+  name: string
+  vertices: Vector3[]
+}
+
+export interface MorphColor {
+  name: string
+  colors: Color[]
+}
+
+export interface MorphNormals {
+  name: string
+  normals: Vector3[]
+}
+
+/**
+ * Base class for geometries
+ */
+export class Geometry extends EventDispatcher {
+  constructor()
+
+  /**
+   * Unique number of this geometry instance
+   */
+  id: number
+
+  uuid: string
+
+  readonly isGeometry: true
+
+  /**
+   * Name for this geometry. Default is an empty string.
+   * @default ''
+   */
+  name: string
+
+  /**
+   * @default 'Geometry'
+   */
+  type: string
+
+  /**
+   * The array of vertices hold every position of points of the model.
+   * To signal an update in this array, Geometry.verticesNeedUpdate needs to be set to true.
+   * @default []
+   */
+  vertices: Vector3[]
+
+  /**
+   * Array of vertex colors, matching number and order of vertices.
+   * Used in ParticleSystem, Line and Ribbon.
+   * Meshes use per-face-use-of-vertex colors embedded directly in faces.
+   * To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.
+   * @default []
+   */
+  colors: Color[]
+
+  /**
+   * Array of triangles or/and quads.
+   * The array of faces describe how each vertex in the model is connected with each other.
+   * To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.
+   * @default []
+   */
+  faces: Face3[]
+
+  /**
+   * Array of face UV layers.
+   * Each UV layer is an array of UV matching order and number of vertices in faces.
+   * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.
+   * @default [[]]
+   */
+  faceVertexUvs: Vector2[][][]
+
+  /**
+   * Array of morph targets. Each morph target is a Javascript object:
+   *
+   * { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
+   *
+   * Morph vertices match number and order of primary vertices.
+   * @default []
+   */
+  morphTargets: MorphTarget[]
+
+  /**
+   * Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object:
+   *
+   * morphNormal = { name: "NormalName", normals: [ new THREE.Vector3(), ... ] }
+   * @default []
+   */
+  morphNormals: MorphNormals[]
+
+  /**
+   * Array of skinning weights, matching number and order of vertices.
+   * @default []
+   */
+  skinWeights: Vector4[]
+
+  /**
+   * Array of skinning indices, matching number and order of vertices.
+   * @default []
+   */
+  skinIndices: Vector4[]
+
+  /**
+   * @default []
+   */
+  lineDistances: number[]
+
+  /**
+   * Bounding box.
+   * @default null
+   */
+  boundingBox: Box3 | null
+
+  /**
+   * Bounding sphere.
+   * @default null
+   */
+  boundingSphere: Sphere | null
+
+  /**
+   * Set to true if the vertices array has been updated.
+   * @default false
+   */
+  verticesNeedUpdate: boolean
+
+  /**
+   * Set to true if the faces array has been updated.
+   * @default false
+   */
+  elementsNeedUpdate: boolean
+
+  /**
+   * Set to true if the uvs array has been updated.
+   * @default false
+   */
+  uvsNeedUpdate: boolean
+
+  /**
+   * Set to true if the normals array has been updated.
+   * @default false
+   */
+  normalsNeedUpdate: boolean
+
+  /**
+   * Set to true if the colors array has been updated.
+   * @default false
+   */
+  colorsNeedUpdate: boolean
+
+  /**
+   * Set to true if the linedistances array has been updated.
+   * @default false
+   */
+  lineDistancesNeedUpdate: boolean
+
+  /**
+   *
+   * @default false
+   */
+  groupsNeedUpdate: boolean
+
+  /**
+   * Bakes matrix transform directly into vertex coordinates.
+   */
+  applyMatrix4(matrix: Matrix4): Geometry
+
+  rotateX(angle: number): Geometry
+  rotateY(angle: number): Geometry
+  rotateZ(angle: number): Geometry
+
+  translate(x: number, y: number, z: number): Geometry
+  scale(x: number, y: number, z: number): Geometry
+  lookAt(vector: Vector3): void
+
+  fromBufferGeometry(geometry: BufferGeometry): Geometry
+
+  center(): Geometry
+
+  normalize(): Geometry
+
+  /**
+   * Computes face normals.
+   */
+  computeFaceNormals(): void
+
+  /**
+   * Computes vertex normals by averaging face normals.
+   * Face normals must be existing / computed beforehand.
+   */
+  computeVertexNormals(areaWeighted?: boolean): void
+
+  /**
+   * Compute vertex normals, but duplicating face normals.
+   */
+  computeFlatVertexNormals(): void
+
+  /**
+   * Computes morph normals.
+   */
+  computeMorphNormals(): void
+
+  /**
+   * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute.
+   */
+  computeBoundingBox(): void
+
+  /**
+   * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
+   * Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null.
+   */
+  computeBoundingSphere(): void
+
+  merge(geometry: Geometry, matrix?: Matrix, materialIndexOffset?: number): void
+
+  mergeMesh(mesh: Mesh): void
+
+  /**
+   * Checks for duplicate vertices using hashmap for specified number of decimal points, e.g. 4 for epsilon of 0.0001
+   * Duplicated vertices are removed and faces' vertices are updated.
+   */
+  mergeVertices(precisionPoints?: number): number
+
+  setFromPoints(points: Vector2[] | Vector3[]): this
+
+  sortFacesByMaterialIndex(): void
+
+  toBufferGeometry(): BufferGeometry
+
+  static createBufferGeometryFromObject(object: Object3D): BufferGeometry
+
+  toJSON(): any
+
+  /**
+   * Creates a new clone of the Geometry.
+   */
+  clone(): Geometry
+
+  copy(source: Geometry): this
+
+  /**
+   * Removes The object from memory.
+   * Don't forget to call this method when you remove an geometry because it can cuase meomory leaks.
+   */
+  dispose(): void
+
+  // These properties do not exist in a normal Geometry class, but if you use the instance that was passed by JSONLoader, it will be added.
+  bones: Bone[]
+  animation: AnimationClip
+  animations: AnimationClip[]
+}
+
+/**
+ * Triangle face.
+ */
+export class Face3 {
+  /**
+   * @param a Vertex A index.
+   * @param b Vertex B index.
+   * @param c Vertex C index.
+   * @param normal Face normal or array of vertex normals.
+   * @param color Face color or array of vertex colors.
+   * @param materialIndex Material index.
+   */
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    normal?: Vector3 | Vector3[],
+    color?: Color | Color[],
+    materialIndex?: number,
+  )
+
+  /**
+   * Vertex A index.
+   */
+  a: number
+
+  /**
+   * Vertex B index.
+   */
+  b: number
+
+  /**
+   * Vertex C index.
+   */
+  c: number
+
+  /**
+   * Face normal.
+   * @default new THREE.Vector3()
+   */
+  normal: Vector3
+
+  /**
+   * Array of 3 vertex normals.
+   * @default []
+   */
+  vertexNormals: Vector3[]
+
+  /**
+   * Face color.
+   * @default new THREE.Color()
+   */
+  color: Color
+
+  /**
+   * Array of 3 vertex colors.
+   * @default []
+   */
+  vertexColors: Color[]
+
+  /**
+   * Material index (points to {@link Mesh.material}).
+   * @default 0
+   */
+  materialIndex: number
+
+  clone(): this
+  copy(source: Face3): this
+}