three-stdlib 2.22.9 → 2.23.0

package/dist/math/MeshSurfaceSampler.mjs

@@ -1,12 +1,9 @@
 import { Triangle, Vector3 } from "three";
-var MeshSurfaceSampler = function() {
-  var _face = new Triangle();
-  var _color = new Vector3();
-  function MeshSurfaceSampler2(mesh) {
-    var geometry = mesh.geometry;
-    if (!geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3) {
-      throw new Error("THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.");
-    }
+const _face = /* @__PURE__ */ new Triangle();
+const _color = /* @__PURE__ */ new Vector3();
+class MeshSurfaceSampler {
+  constructor(mesh) {
+    let geometry = mesh.geometry;
     if (geometry.index) {
       console.warn("THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.");
       geometry = geometry.toNonIndexed();
@@ -18,90 +15,89 @@ var MeshSurfaceSampler = function() {
     this.weightAttribute = null;
     this.distribution = null;
   }
-  MeshSurfaceSampler2.prototype = {
-    constructor: MeshSurfaceSampler2,
-    setWeightAttribute: function(name) {
-      this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
-      return this;
-    },
-    build: function() {
-      var positionAttribute = this.positionAttribute;
-      var weightAttribute = this.weightAttribute;
-      var faceWeights = new Float32Array(positionAttribute.count / 3);
-      for (let i = 0; i < positionAttribute.count; i += 3) {
-        var faceWeight = 1;
-        if (weightAttribute) {
-          faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
-        }
-        _face.a.fromBufferAttribute(positionAttribute, i);
-        _face.b.fromBufferAttribute(positionAttribute, i + 1);
-        _face.c.fromBufferAttribute(positionAttribute, i + 2);
-        faceWeight *= _face.getArea();
-        faceWeights[i / 3] = faceWeight;
-      }
-      this.distribution = new Float32Array(positionAttribute.count / 3);
-      var cumulativeTotal = 0;
-      for (let i = 0; i < faceWeights.length; i++) {
-        cumulativeTotal += faceWeights[i];
-        this.distribution[i] = cumulativeTotal;
-      }
-      return this;
-    },
-    setRandomGenerator: function(randomFunction) {
-      this.randomFunction = randomFunction;
-      return this;
-    },
-    sample: function(targetPosition, targetNormal, targetColor) {
-      var cumulativeTotal = this.distribution[this.distribution.length - 1];
-      var faceIndex = this.binarySearch(this.randomFunction() * cumulativeTotal);
-      return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
-    },
-    binarySearch: function(x) {
-      var dist = this.distribution;
-      var start = 0;
-      var end = dist.length - 1;
-      var index = -1;
-      while (start <= end) {
-        var mid = Math.ceil((start + end) / 2);
-        if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
-          index = mid;
-          break;
-        } else if (x < dist[mid]) {
-          end = mid - 1;
-        } else {
-          start = mid + 1;
-        }
-      }
-      return index;
-    },
-    sampleFace: function(faceIndex, targetPosition, targetNormal, targetColor) {
-      var u = this.randomFunction();
-      var v = this.randomFunction();
-      if (u + v > 1) {
-        u = 1 - u;
-        v = 1 - v;
-      }
-      _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
-      _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
-      _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
-      targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
-      if (targetNormal !== void 0) {
-        _face.getNormal(targetNormal);
+  setWeightAttribute(name) {
+    this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+    return this;
+  }
+  build() {
+    const positionAttribute = this.positionAttribute;
+    const weightAttribute = this.weightAttribute;
+    const faceWeights = new Float32Array(positionAttribute.count / 3);
+    for (let i = 0; i < positionAttribute.count; i += 3) {
+      let faceWeight = 1;
+      if (weightAttribute) {
+        faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
       }
-      if (targetColor !== void 0 && this.colorAttribute !== void 0) {
-        _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
-        _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
-        _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
-        _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
-        targetColor.r = _color.x;
-        targetColor.g = _color.y;
-        targetColor.b = _color.z;
+      _face.a.fromBufferAttribute(positionAttribute, i);
+      _face.b.fromBufferAttribute(positionAttribute, i + 1);
+      _face.c.fromBufferAttribute(positionAttribute, i + 2);
+      faceWeight *= _face.getArea();
+      faceWeights[i / 3] = faceWeight;
+    }
+    this.distribution = new Float32Array(positionAttribute.count / 3);
+    let cumulativeTotal = 0;
+    for (let i = 0; i < faceWeights.length; i++) {
+      cumulativeTotal += faceWeights[i];
+      this.distribution[i] = cumulativeTotal;
+    }
+    return this;
+  }
+  setRandomGenerator(randomFunction) {
+    this.randomFunction = randomFunction;
+    return this;
+  }
+  sample(targetPosition, targetNormal, targetColor) {
+    const faceIndex = this.sampleFaceIndex();
+    return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
+  }
+  sampleFaceIndex() {
+    const cumulativeTotal = this.distribution[this.distribution.length - 1];
+    return this.binarySearch(this.randomFunction() * cumulativeTotal);
+  }
+  binarySearch(x) {
+    const dist = this.distribution;
+    let start = 0;
+    let end = dist.length - 1;
+    let index = -1;
+    while (start <= end) {
+      const mid = Math.ceil((start + end) / 2);
+      if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
+        index = mid;
+        break;
+      } else if (x < dist[mid]) {
+        end = mid - 1;
+      } else {
+        start = mid + 1;
       }
-      return this;
     }
-  };
-  return MeshSurfaceSampler2;
-}();
+    return index;
+  }
+  sampleFace(faceIndex, targetPosition, targetNormal, targetColor) {
+    let u = this.randomFunction();
+    let v = this.randomFunction();
+    if (u + v > 1) {
+      u = 1 - u;
+      v = 1 - v;
+    }
+    _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
+    _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
+    _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
+    targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+    if (targetNormal !== void 0) {
+      _face.getNormal(targetNormal);
+    }
+    if (targetColor !== void 0 && this.colorAttribute !== void 0) {
+      _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
+      _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
+      _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
+      _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+      targetColor.r = _color.x;
+      targetColor.g = _color.y;
+      targetColor.b = _color.z;
+    }
+    return this;
+  }
+}
 export {
   MeshSurfaceSampler
 };

package/dist/math/OBB.js

@@ -1,95 +1,95 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-var a = {
+const a = {
   c: null,
   // center
-  u: [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()],
+  u: [/* @__PURE__ */ new THREE.Vector3(), /* @__PURE__ */ new THREE.Vector3(), /* @__PURE__ */ new THREE.Vector3()],
   // basis vectors
   e: []
   // half width
 };
-var b = {
+const b = {
   c: null,
   // center
-  u: [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()],
+  u: [/* @__PURE__ */ new THREE.Vector3(), /* @__PURE__ */ new THREE.Vector3(), /* @__PURE__ */ new THREE.Vector3()],
   // basis vectors
   e: []
   // half width
 };
-var R = [[], [], []];
-var AbsR = [[], [], []];
-var t = [];
-var xAxis = new THREE.Vector3();
-var yAxis = new THREE.Vector3();
-var zAxis = new THREE.Vector3();
-var v1 = new THREE.Vector3();
-var size = new THREE.Vector3();
-var closestPoint = new THREE.Vector3();
-var rotationMatrix = new THREE.Matrix3();
-var aabb = new THREE.Box3();
-var matrix = new THREE.Matrix4();
-var inverse = new THREE.Matrix4();
-var localRay = new THREE.Ray();
-function OBB(center = new THREE.Vector3(), halfSize = new THREE.Vector3(), rotation = new THREE.Matrix3()) {
-  this.center = center;
-  this.halfSize = halfSize;
-  this.rotation = rotation;
-}
-Object.assign(OBB.prototype, {
-  set: function(center, halfSize, rotation) {
+const R = [[], [], []];
+const AbsR = [[], [], []];
+const t = [];
+const xAxis = /* @__PURE__ */ new THREE.Vector3();
+const yAxis = /* @__PURE__ */ new THREE.Vector3();
+const zAxis = /* @__PURE__ */ new THREE.Vector3();
+const v1 = /* @__PURE__ */ new THREE.Vector3();
+const size = /* @__PURE__ */ new THREE.Vector3();
+const closestPoint = /* @__PURE__ */ new THREE.Vector3();
+const rotationMatrix = /* @__PURE__ */ new THREE.Matrix3();
+const aabb = /* @__PURE__ */ new THREE.Box3();
+const matrix = /* @__PURE__ */ new THREE.Matrix4();
+const inverse = /* @__PURE__ */ new THREE.Matrix4();
+const localRay = /* @__PURE__ */ new THREE.Ray();
+class OBB {
+  constructor(center = new THREE.Vector3(), halfSize = new THREE.Vector3(), rotation = new THREE.Matrix3()) {
+    this.center = center;
+    this.halfSize = halfSize;
+    this.rotation = rotation;
+  }
+  set(center, halfSize, rotation) {
     this.center = center;
     this.halfSize = halfSize;
     this.rotation = rotation;
     return this;
-  },
-  copy: function(obb2) {
+  }
+  copy(obb2) {
     this.center.copy(obb2.center);
     this.halfSize.copy(obb2.halfSize);
     this.rotation.copy(obb2.rotation);
     return this;
-  },
-  clone: function() {
+  }
+  clone() {
     return new this.constructor().copy(this);
-  },
-  getSize: function(result) {
+  }
+  getSize(result) {
     return result.copy(this.halfSize).multiplyScalar(2);
-  },
+  }
   /**
    * Reference: Closest Point on OBB to Point in Real-Time Collision Detection
    * by Christer Ericson (chapter 5.1.4)
    */
-  clampPoint: function(point, result) {
-    var halfSize = this.halfSize;
+  clampPoint(point, result) {
+    const halfSize = this.halfSize;
     v1.subVectors(point, this.center);
     this.rotation.extractBasis(xAxis, yAxis, zAxis);
     result.copy(this.center);
-    var x = THREE.MathUtils.clamp(v1.dot(xAxis), -halfSize.x, halfSize.x);
+    const x = THREE.MathUtils.clamp(v1.dot(xAxis), -halfSize.x, halfSize.x);
     result.add(xAxis.multiplyScalar(x));
-    var y = THREE.MathUtils.clamp(v1.dot(yAxis), -halfSize.y, halfSize.y);
+    const y = THREE.MathUtils.clamp(v1.dot(yAxis), -halfSize.y, halfSize.y);
     result.add(yAxis.multiplyScalar(y));
-    var z = THREE.MathUtils.clamp(v1.dot(zAxis), -halfSize.z, halfSize.z);
+    const z = THREE.MathUtils.clamp(v1.dot(zAxis), -halfSize.z, halfSize.z);
     result.add(zAxis.multiplyScalar(z));
     return result;
-  },
-  containsPoint: function(point) {
+  }
+  containsPoint(point) {
     v1.subVectors(point, this.center);
     this.rotation.extractBasis(xAxis, yAxis, zAxis);
     return Math.abs(v1.dot(xAxis)) <= this.halfSize.x && Math.abs(v1.dot(yAxis)) <= this.halfSize.y && Math.abs(v1.dot(zAxis)) <= this.halfSize.z;
-  },
-  intersectsBox3: function(box3) {
+  }
+  intersectsBox3(box3) {
     return this.intersectsOBB(obb.fromBox3(box3));
-  },
-  intersectsSphere: function(sphere) {
+  }
+  intersectsSphere(sphere) {
     this.clampPoint(sphere.center, closestPoint);
     return closestPoint.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius;
-  },
+  }
   /**
    * Reference: OBB-OBB Intersection in Real-Time Collision Detection
    * by Christer Ericson (chapter 4.4.1)
    *
    */
-  intersectsOBB: function(obb2, epsilon = Number.EPSILON) {
+  intersectsOBB(obb2, epsilon = Number.EPSILON) {
     a.c = this.center;
     a.e[0] = this.halfSize.x;
     a.e[1] = this.halfSize.y;
@@ -114,7 +114,7 @@ Object.assign(OBB.prototype, {
         AbsR[i][j] = Math.abs(R[i][j]) + epsilon;
       }
     }
-    var ra, rb;
+    let ra, rb;
     for (let i = 0; i < 3; i++) {
       ra = a.e[i];
       rb = b.e[0] * AbsR[i][0] + b.e[1] * AbsR[i][1] + b.e[2] * AbsR[i][2];
@@ -164,25 +164,25 @@ Object.assign(OBB.prototype, {
     if (Math.abs(t[1] * R[0][2] - t[0] * R[1][2]) > ra + rb)
       return false;
     return true;
-  },
+  }
   /**
    * Reference: Testing Box Against Plane in Real-Time Collision Detection
    * by Christer Ericson (chapter 5.2.3)
    */
-  intersectsPlane: function(plane) {
+  intersectsPlane(plane) {
     this.rotation.extractBasis(xAxis, yAxis, zAxis);
     const r = this.halfSize.x * Math.abs(plane.normal.dot(xAxis)) + this.halfSize.y * Math.abs(plane.normal.dot(yAxis)) + this.halfSize.z * Math.abs(plane.normal.dot(zAxis));
     const d = plane.normal.dot(this.center) - plane.constant;
     return Math.abs(d) <= r;
-  },
+  }
   /**
    * Performs a ray/OBB intersection test and stores the intersection point
    * to the given 3D vector. If no intersection is detected, *null* is returned.
    */
-  intersectRay: function(ray, result) {
+  intersectRay(ray, result) {
     this.getSize(size);
     aabb.setFromCenterAndSize(v1.set(0, 0, 0), size);
-    matrix4FromRotationMatrix(matrix, this.rotation);
+    matrix.setFromMatrix3(this.rotation);
     matrix.setPosition(this.center);
     inverse.copy(matrix).invert();
     localRay.copy(ray).applyMatrix4(inverse);
@@ -191,35 +191,35 @@ Object.assign(OBB.prototype, {
     } else {
       return null;
     }
-  },
+  }
   /**
    * Performs a ray/OBB intersection test. Returns either true or false if
    * there is a intersection or not.
    */
-  intersectsRay: function(ray) {
+  intersectsRay(ray) {
     return this.intersectRay(ray, v1) !== null;
-  },
-  fromBox3: function(box3) {
+  }
+  fromBox3(box3) {
     box3.getCenter(this.center);
     box3.getSize(this.halfSize).multiplyScalar(0.5);
     this.rotation.identity();
     return this;
-  },
-  equals: function(obb2) {
+  }
+  equals(obb2) {
     return obb2.center.equals(this.center) && obb2.halfSize.equals(this.halfSize) && obb2.rotation.equals(this.rotation);
-  },
-  applyMatrix4: function(matrix2) {
-    var e = matrix2.elements;
-    var sx = v1.set(e[0], e[1], e[2]).length();
-    var sy = v1.set(e[4], e[5], e[6]).length();
-    var sz = v1.set(e[8], e[9], e[10]).length();
-    var det = matrix2.determinant();
+  }
+  applyMatrix4(matrix2) {
+    const e = matrix2.elements;
+    let sx = v1.set(e[0], e[1], e[2]).length();
+    const sy = v1.set(e[4], e[5], e[6]).length();
+    const sz = v1.set(e[8], e[9], e[10]).length();
+    const det = matrix2.determinant();
     if (det < 0)
       sx = -sx;
     rotationMatrix.setFromMatrix4(matrix2);
-    var invSX = 1 / sx;
-    var invSY = 1 / sy;
-    var invSZ = 1 / sz;
+    const invSX = 1 / sx;
+    const invSY = 1 / sy;
+    const invSZ = 1 / sz;
     rotationMatrix.elements[0] *= invSX;
     rotationMatrix.elements[1] *= invSX;
     rotationMatrix.elements[2] *= invSX;
@@ -237,26 +237,6 @@ Object.assign(OBB.prototype, {
     this.center.add(v1);
     return this;
   }
-});
-function matrix4FromRotationMatrix(matrix4, matrix3) {
-  var e = matrix4.elements;
-  var me = matrix3.elements;
-  e[0] = me[0];
-  e[1] = me[1];
-  e[2] = me[2];
-  e[3] = 0;
-  e[4] = me[3];
-  e[5] = me[4];
-  e[6] = me[5];
-  e[7] = 0;
-  e[8] = me[6];
-  e[9] = me[7];
-  e[10] = me[8];
-  e[11] = 0;
-  e[12] = 0;
-  e[13] = 0;
-  e[14] = 0;
-  e[15] = 1;
 }
-var obb = new OBB();
+const obb = /* @__PURE__ */ new OBB();
 exports.OBB = OBB;