three-stdlib 2.22.9 → 2.23.0

package/dist/misc/ConvexObjectBreaker.js

@@ -2,63 +2,60 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
 const ConvexGeometry = require("../geometries/ConvexGeometry.js");
-var ConvexObjectBreaker = function(minSizeForBreak, smallDelta) {
-  this.minSizeForBreak = minSizeForBreak || 1.4;
-  this.smallDelta = smallDelta || 1e-4;
-  this.tempLine1 = new THREE.Line3();
-  this.tempPlane1 = new THREE.Plane();
-  this.tempPlane2 = new THREE.Plane();
-  this.tempPlane_Cut = new THREE.Plane();
-  this.tempCM1 = new THREE.Vector3();
-  this.tempCM2 = new THREE.Vector3();
-  this.tempVector3 = new THREE.Vector3();
-  this.tempVector3_2 = new THREE.Vector3();
-  this.tempVector3_3 = new THREE.Vector3();
-  this.tempVector3_P0 = new THREE.Vector3();
-  this.tempVector3_P1 = new THREE.Vector3();
-  this.tempVector3_P2 = new THREE.Vector3();
-  this.tempVector3_N0 = new THREE.Vector3();
-  this.tempVector3_N1 = new THREE.Vector3();
-  this.tempVector3_AB = new THREE.Vector3();
-  this.tempVector3_CB = new THREE.Vector3();
-  this.tempResultObjects = { object1: null, object2: null };
-  this.segments = [];
-  var n = 30 * 30;
-  for (let i = 0; i < n; i++)
-    this.segments[i] = false;
-};
-ConvexObjectBreaker.prototype = {
-  constructor: ConvexObjectBreaker,
-  prepareBreakableObject: function(object, mass, velocity, angularVelocity, breakable) {
-    if (!object.geometry.isBufferGeometry) {
-      console.error("THREE.ConvexObjectBreaker.prepareBreakableObject(): Parameter object must have a BufferGeometry.");
-    }
-    var userData = object.userData;
+const _v1 = /* @__PURE__ */ new THREE.Vector3();
+class ConvexObjectBreaker {
+  constructor(minSizeForBreak = 1.4, smallDelta = 1e-4) {
+    this.minSizeForBreak = minSizeForBreak;
+    this.smallDelta = smallDelta;
+    this.tempLine1 = new THREE.Line3();
+    this.tempPlane1 = new THREE.Plane();
+    this.tempPlane2 = new THREE.Plane();
+    this.tempPlane_Cut = new THREE.Plane();
+    this.tempCM1 = new THREE.Vector3();
+    this.tempCM2 = new THREE.Vector3();
+    this.tempVector3 = new THREE.Vector3();
+    this.tempVector3_2 = new THREE.Vector3();
+    this.tempVector3_3 = new THREE.Vector3();
+    this.tempVector3_P0 = new THREE.Vector3();
+    this.tempVector3_P1 = new THREE.Vector3();
+    this.tempVector3_P2 = new THREE.Vector3();
+    this.tempVector3_N0 = new THREE.Vector3();
+    this.tempVector3_N1 = new THREE.Vector3();
+    this.tempVector3_AB = new THREE.Vector3();
+    this.tempVector3_CB = new THREE.Vector3();
+    this.tempResultObjects = { object1: null, object2: null };
+    this.segments = [];
+    const n = 30 * 30;
+    for (let i = 0; i < n; i++)
+      this.segments[i] = false;
+  }
+  prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
+    const userData = object.userData;
     userData.mass = mass;
     userData.velocity = velocity.clone();
     userData.angularVelocity = angularVelocity.clone();
     userData.breakable = breakable;
-  },
+  }
   /*
    * @param {int} maxRadialIterations Iterations for radial cuts.
    * @param {int} maxRandomIterations Max random iterations for not-radial cuts
    *
    * Returns the array of pieces
    */
-  subdivideByImpact: function(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
-    var debris = [];
-    var tempPlane1 = this.tempPlane1;
-    var tempPlane2 = this.tempPlane2;
+  subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
+    const debris = [];
+    const tempPlane1 = this.tempPlane1;
+    const tempPlane2 = this.tempPlane2;
     this.tempVector3.addVectors(pointOfImpact, normal);
     tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3);
-    var maxTotalIterations = maxRandomIterations + maxRadialIterations;
-    var scope = this;
+    const maxTotalIterations = maxRandomIterations + maxRadialIterations;
+    const scope = this;
     function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
       if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
         debris.push(subObject);
         return;
       }
-      var angle = Math.PI;
+      let angle = Math.PI;
       if (numIterations === 0) {
         tempPlane2.normal.copy(tempPlane1.normal);
         tempPlane2.constant = tempPlane1.constant;
@@ -75,8 +72,8 @@ ConvexObjectBreaker.prototype = {
         }
       }
       scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects);
-      var obj1 = scope.tempResultObjects.object1;
-      var obj2 = scope.tempResultObjects.object2;
+      const obj1 = scope.tempResultObjects.object1;
+      const obj2 = scope.tempResultObjects.object2;
       if (obj1) {
         subdivideRadial(obj1, startAngle, angle, numIterations + 1);
       }
@@ -86,43 +83,43 @@ ConvexObjectBreaker.prototype = {
     }
     subdivideRadial(object, 0, 2 * Math.PI, 0);
     return debris;
-  },
-  cutByPlane: function(object, plane, output) {
-    var geometry = object.geometry;
-    var coords = geometry.attributes.position.array;
-    var normals = geometry.attributes.normal.array;
-    var numPoints = coords.length / 3;
-    var numFaces = numPoints / 3;
-    var indices = geometry.getIndex();
+  }
+  cutByPlane(object, plane, output) {
+    const geometry = object.geometry;
+    const coords = geometry.attributes.position.array;
+    const normals = geometry.attributes.normal.array;
+    const numPoints = coords.length / 3;
+    let numFaces = numPoints / 3;
+    let indices = geometry.getIndex();
     if (indices) {
       indices = indices.array;
       numFaces = indices.length / 3;
     }
     function getVertexIndex(faceIdx, vert) {
-      var idx = faceIdx * 3 + vert;
+      const idx = faceIdx * 3 + vert;
       return indices ? indices[idx] : idx;
     }
-    var points1 = [];
-    var points2 = [];
-    var delta = this.smallDelta;
-    var numPointPairs = numPoints * numPoints;
+    const points1 = [];
+    const points2 = [];
+    const delta = this.smallDelta;
+    const numPointPairs = numPoints * numPoints;
     for (let i = 0; i < numPointPairs; i++)
       this.segments[i] = false;
-    var p0 = this.tempVector3_P0;
-    var p1 = this.tempVector3_P1;
-    var n0 = this.tempVector3_N0;
-    var n1 = this.tempVector3_N1;
+    const p0 = this.tempVector3_P0;
+    const p1 = this.tempVector3_P1;
+    const n0 = this.tempVector3_N0;
+    const n1 = this.tempVector3_N1;
     for (let i = 0; i < numFaces - 1; i++) {
-      var a1 = getVertexIndex(i, 0);
-      var b1 = getVertexIndex(i, 1);
-      var c1 = getVertexIndex(i, 2);
+      const a1 = getVertexIndex(i, 0);
+      const b1 = getVertexIndex(i, 1);
+      const c1 = getVertexIndex(i, 2);
       n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2);
       for (let j = i + 1; j < numFaces; j++) {
-        var a2 = getVertexIndex(j, 0);
-        var b2 = getVertexIndex(j, 1);
-        var c2 = getVertexIndex(j, 2);
+        const a2 = getVertexIndex(j, 0);
+        const b2 = getVertexIndex(j, 1);
+        const c2 = getVertexIndex(j, 2);
         n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2);
-        var coplanar = 1 - n0.dot(n1) < delta;
+        const coplanar = 1 - n0.dot(n1) < delta;
         if (coplanar) {
           if (a1 === a2 || a1 === b2 || a1 === c2) {
             if (b1 === a2 || b1 === b2 || b1 === c2) {
@@ -139,25 +136,25 @@ ConvexObjectBreaker.prototype = {
         }
       }
     }
-    var localPlane = this.tempPlane_Cut;
+    const localPlane = this.tempPlane_Cut;
     object.updateMatrix();
     ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane);
     for (let i = 0; i < numFaces; i++) {
-      var va = getVertexIndex(i, 0);
-      var vb = getVertexIndex(i, 1);
-      var vc = getVertexIndex(i, 2);
+      const va = getVertexIndex(i, 0);
+      const vb = getVertexIndex(i, 1);
+      const vc = getVertexIndex(i, 2);
       for (let segment = 0; segment < 3; segment++) {
-        var i0 = segment === 0 ? va : segment === 1 ? vb : vc;
-        var i1 = segment === 0 ? vb : segment === 1 ? vc : va;
-        var segmentState = this.segments[i0 * numPoints + i1];
+        const i0 = segment === 0 ? va : segment === 1 ? vb : vc;
+        const i1 = segment === 0 ? vb : segment === 1 ? vc : va;
+        const segmentState = this.segments[i0 * numPoints + i1];
         if (segmentState)
           continue;
         this.segments[i0 * numPoints + i1] = true;
         this.segments[i1 * numPoints + i0] = true;
         p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2]);
         p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2]);
-        var mark0 = 0;
-        var d = localPlane.distanceToPoint(p0);
+        let mark0 = 0;
+        let d = localPlane.distanceToPoint(p0);
         if (d > delta) {
           mark0 = 2;
           points2.push(p0.clone());
@@ -169,8 +166,8 @@ ConvexObjectBreaker.prototype = {
           points1.push(p0.clone());
           points2.push(p0.clone());
         }
-        var mark1 = 0;
-        var d = localPlane.distanceToPoint(p1);
+        let mark1 = 0;
+        d = localPlane.distanceToPoint(p1);
         if (d > delta) {
           mark1 = 2;
           points2.push(p1.clone());
@@ -185,9 +182,9 @@ ConvexObjectBreaker.prototype = {
         if (mark0 === 1 && mark1 === 2 || mark0 === 2 && mark1 === 1) {
           this.tempLine1.start.copy(p0);
           this.tempLine1.end.copy(p1);
-          var intersection = new THREE.Vector3();
+          let intersection = new THREE.Vector3();
           intersection = localPlane.intersectLine(this.tempLine1, intersection);
-          if (intersection === void 0) {
+          if (intersection === null) {
             console.error("Internal error: segment does not intersect plane.");
             output.segmentedObject1 = null;
             output.segmentedObject2 = null;
@@ -198,38 +195,38 @@ ConvexObjectBreaker.prototype = {
         }
       }
     }
-    var newMass = object.userData.mass * 0.5;
+    const newMass = object.userData.mass * 0.5;
     this.tempCM1.set(0, 0, 0);
-    var radius1 = 0;
-    var numPoints1 = points1.length;
+    let radius1 = 0;
+    const numPoints1 = points1.length;
     if (numPoints1 > 0) {
       for (let i = 0; i < numPoints1; i++)
         this.tempCM1.add(points1[i]);
       this.tempCM1.divideScalar(numPoints1);
       for (let i = 0; i < numPoints1; i++) {
-        var p = points1[i];
+        const p = points1[i];
         p.sub(this.tempCM1);
         radius1 = Math.max(radius1, p.x, p.y, p.z);
       }
       this.tempCM1.add(object.position);
     }
     this.tempCM2.set(0, 0, 0);
-    var radius2 = 0;
-    var numPoints2 = points2.length;
+    let radius2 = 0;
+    const numPoints2 = points2.length;
     if (numPoints2 > 0) {
       for (let i = 0; i < numPoints2; i++)
         this.tempCM2.add(points2[i]);
       this.tempCM2.divideScalar(numPoints2);
       for (let i = 0; i < numPoints2; i++) {
-        var p = points2[i];
+        const p = points2[i];
         p.sub(this.tempCM2);
         radius2 = Math.max(radius2, p.x, p.y, p.z);
       }
       this.tempCM2.add(object.position);
     }
-    var object1 = null;
-    var object2 = null;
-    var numObjects = 0;
+    let object1 = null;
+    let object2 = null;
+    let numObjects = 0;
     if (numPoints1 > 4) {
       object1 = new THREE.Mesh(new ConvexGeometry.ConvexGeometry(points1), object.material);
       object1.position.copy(this.tempCM1);
@@ -260,39 +257,36 @@ ConvexObjectBreaker.prototype = {
     output.object2 = object2;
     return numObjects;
   }
-};
-ConvexObjectBreaker.transformFreeVector = function(v, m) {
-  var x = v.x, y = v.y, z = v.z;
-  var e = m.elements;
-  v.x = e[0] * x + e[4] * y + e[8] * z;
-  v.y = e[1] * x + e[5] * y + e[9] * z;
-  v.z = e[2] * x + e[6] * y + e[10] * z;
-  return v;
-};
-ConvexObjectBreaker.transformFreeVectorInverse = function(v, m) {
-  var x = v.x, y = v.y, z = v.z;
-  var e = m.elements;
-  v.x = e[0] * x + e[1] * y + e[2] * z;
-  v.y = e[4] * x + e[5] * y + e[6] * z;
-  v.z = e[8] * x + e[9] * y + e[10] * z;
-  return v;
-};
-ConvexObjectBreaker.transformTiedVectorInverse = function(v, m) {
-  var x = v.x, y = v.y, z = v.z;
-  var e = m.elements;
-  v.x = e[0] * x + e[1] * y + e[2] * z - e[12];
-  v.y = e[4] * x + e[5] * y + e[6] * z - e[13];
-  v.z = e[8] * x + e[9] * y + e[10] * z - e[14];
-  return v;
-};
-ConvexObjectBreaker.transformPlaneToLocalSpace = function() {
-  var v1 = new THREE.Vector3();
-  return function transformPlaneToLocalSpace(plane, m, resultPlane) {
+  static transformFreeVector(v, m) {
+    const x = v.x, y = v.y, z = v.z;
+    const e = m.elements;
+    v.x = e[0] * x + e[4] * y + e[8] * z;
+    v.y = e[1] * x + e[5] * y + e[9] * z;
+    v.z = e[2] * x + e[6] * y + e[10] * z;
+    return v;
+  }
+  static transformFreeVectorInverse(v, m) {
+    const x = v.x, y = v.y, z = v.z;
+    const e = m.elements;
+    v.x = e[0] * x + e[1] * y + e[2] * z;
+    v.y = e[4] * x + e[5] * y + e[6] * z;
+    v.z = e[8] * x + e[9] * y + e[10] * z;
+    return v;
+  }
+  static transformTiedVectorInverse(v, m) {
+    const x = v.x, y = v.y, z = v.z;
+    const e = m.elements;
+    v.x = e[0] * x + e[1] * y + e[2] * z - e[12];
+    v.y = e[4] * x + e[5] * y + e[6] * z - e[13];
+    v.z = e[8] * x + e[9] * y + e[10] * z - e[14];
+    return v;
+  }
+  static transformPlaneToLocalSpace(plane, m, resultPlane) {
     resultPlane.normal.copy(plane.normal);
     resultPlane.constant = plane.constant;
-    var referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(v1), m);
+    const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m);
     ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m);
     resultPlane.constant = -referencePoint.dot(resultPlane.normal);
-  };
-}();
+  }
+}
 exports.ConvexObjectBreaker = ConvexObjectBreaker;