three-stdlib 2.16.0 → 2.16.2

package/misc/ConvexObjectBreaker.js

@@ -1,45 +1,88 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const ConvexGeometry = require("../geometries/ConvexGeometry.js");
-var ConvexObjectBreaker = function(minSizeForBreak, smallDelta) {
+import { Line3, Plane, Vector3, Mesh } from 'three';
+import { ConvexGeometry } from '../geometries/ConvexGeometry.js';
+
+/**
+ * @fileoverview This class can be used to subdivide a convex Geometry object into pieces.
+ *
+ * Usage:
+ *
+ * Use the function prepareBreakableObject to prepare a Mesh object to be broken.
+ *
+ * Then, call the various functions to subdivide the object (subdivideByImpact, cutByPlane)
+ *
+ * Sub-objects that are product of subdivision don't need prepareBreakableObject to be called on them.
+ *
+ * Requisites for the object:
+ *
+ *  - Mesh object must have a BufferGeometry (not Geometry) and a Material
+ *
+ *  - Vertex normals must be planar (not smoothed)
+ *
+ *  - The geometry must be convex (this is not checked in the library). You can create convex
+ *  geometries with ConvexGeometry. The BoxGeometry, SphereGeometry and other convex primitives
+ *  can also be used.
+ *
+ * Note: This lib adds member variables to object's userData member (see prepareBreakableObject function)
+ * Use with caution and read the code when using with other libs.
+ *
+ * @param {double} minSizeForBreak Min size a debris can have to break.
+ * @param {double} smallDelta Max distance to consider that a point belongs to a plane.
+ *
+ */
+
+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.smallDelta = smallDelta || 0.0001;
+  this.tempLine1 = new Line3();
+  this.tempPlane1 = new Plane();
+  this.tempPlane2 = new Plane();
+  this.tempPlane_Cut = new Plane();
+  this.tempCM1 = new Vector3();
+  this.tempCM2 = new Vector3();
+  this.tempVector3 = new Vector3();
+  this.tempVector3_2 = new Vector3();
+  this.tempVector3_3 = new Vector3();
+  this.tempVector3_P0 = new Vector3();
+  this.tempVector3_P1 = new Vector3();
+  this.tempVector3_P2 = new Vector3();
+  this.tempVector3_N0 = new Vector3();
+  this.tempVector3_N1 = new Vector3();
+  this.tempVector3_AB = new Vector3();
+  this.tempVector3_CB = new Vector3();
+  this.tempResultObjects = {
+    object1: null,
+    object2: null
+  };
   this.segments = [];
   var n = 30 * 30;
-  for (let i = 0; i < n; i++)
-    this.segments[i] = false;
+
+  for (let i = 0; i < n; i++) this.segments[i] = false;
 };
+
 ConvexObjectBreaker.prototype = {
   constructor: ConvexObjectBreaker,
-  prepareBreakableObject: function(object, mass, velocity, angularVelocity, breakable) {
+  prepareBreakableObject: function (object, mass, velocity, angularVelocity, breakable) {
+    // object is a Object3d (normally a Mesh), must have a BufferGeometry, and it must be convex.
+    // Its material property is propagated to its children (sub-pieces)
+    // mass must be > 0
     if (!object.geometry.isBufferGeometry) {
-      console.error("THREE.ConvexObjectBreaker.prepareBreakableObject(): Parameter object must have a BufferGeometry.");
+      console.error('THREE.ConvexObjectBreaker.prepareBreakableObject(): Parameter object must have a BufferGeometry.');
     }
+
     var userData = object.userData;
     userData.mass = mass;
     userData.velocity = velocity.clone();
     userData.angularVelocity = angularVelocity.clone();
     userData.breakable = breakable;
   },
-  subdivideByImpact: function(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
+
+  /*
+   * @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;
@@ -47,76 +90,101 @@ ConvexObjectBreaker.prototype = {
     tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3);
     var maxTotalIterations = maxRandomIterations + maxRadialIterations;
     var scope = this;
+
     function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
       if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
         debris.push(subObject);
         return;
       }
+
       var angle = Math.PI;
+
       if (numIterations === 0) {
         tempPlane2.normal.copy(tempPlane1.normal);
         tempPlane2.constant = tempPlane1.constant;
       } else {
         if (numIterations <= maxRadialIterations) {
-          angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle;
+          angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle; // Rotate tempPlane2 at impact point around normal axis and the angle
+
           scope.tempVector3_2.copy(object.position).sub(pointOfImpact).applyAxisAngle(normal, angle).add(pointOfImpact);
           tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2);
         } else {
-          angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI;
+          angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI; // Rotate tempPlane2 at object position around normal axis and the angle
+
           scope.tempVector3_2.copy(pointOfImpact).sub(subObject.position).applyAxisAngle(normal, angle).add(subObject.position);
           scope.tempVector3_3.copy(normal).add(subObject.position);
           tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2);
         }
-      }
+      } // Perform the cut
+
+
       scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects);
       var obj1 = scope.tempResultObjects.object1;
       var obj2 = scope.tempResultObjects.object2;
+
       if (obj1) {
         subdivideRadial(obj1, startAngle, angle, numIterations + 1);
       }
+
       if (obj2) {
         subdivideRadial(obj2, angle, endAngle, numIterations + 1);
       }
     }
+
     subdivideRadial(object, 0, 2 * Math.PI, 0);
     return debris;
   },
-  cutByPlane: function(object, plane, output) {
+  cutByPlane: function (object, plane, output) {
+    // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
+    // object2 can be null if the plane doesn't cut the object.
+    // object1 can be null only in case of internal error
+    // Returned value is number of pieces, 0 for error.
     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();
+
     if (indices) {
       indices = indices.array;
       numFaces = indices.length / 3;
     }
+
     function getVertexIndex(faceIdx, vert) {
+      // vert = 0, 1 or 2.
       var idx = faceIdx * 3 + vert;
       return indices ? indices[idx] : idx;
     }
+
     var points1 = [];
     var points2 = [];
-    var delta = this.smallDelta;
+    var delta = this.smallDelta; // Reset segments mark
+
     var numPointPairs = numPoints * numPoints;
-    for (let i = 0; i < numPointPairs; i++)
-      this.segments[i] = false;
+
+    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;
+    var n1 = this.tempVector3_N1; // Iterate through the faces to mark edges shared by coplanar faces
+
     for (let i = 0; i < numFaces - 1; i++) {
       var a1 = getVertexIndex(i, 0);
       var b1 = getVertexIndex(i, 1);
-      var c1 = getVertexIndex(i, 2);
+      var c1 = getVertexIndex(i, 2); // Assuming all 3 vertices have the same normal
+
       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);
+        var c2 = getVertexIndex(j, 2); // Assuming all 3 vertices have the same normal
+
         n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2);
         var coplanar = 1 - n0.dot(n1) < delta;
+
         if (coplanar) {
           if (a1 === a2 || a1 === b2 || a1 === c2) {
             if (b1 === a2 || b1 === b2 || b1 === c2) {
@@ -132,26 +200,33 @@ ConvexObjectBreaker.prototype = {
           }
         }
       }
-    }
+    } // Transform the plane to object local space
+
+
     var localPlane = this.tempPlane_Cut;
     object.updateMatrix();
-    ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane);
+    ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane); // Iterate through the faces adding points to both pieces
+
     for (let i = 0; i < numFaces; i++) {
       var va = getVertexIndex(i, 0);
       var vb = getVertexIndex(i, 1);
       var 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];
-        if (segmentState)
-          continue;
+        if (segmentState) continue; // The segment already has been processed in another face
+        // Mark segment as processed (also inverted segment)
+
         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]);
+        p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2]); // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+
         var mark0 = 0;
         var d = localPlane.distanceToPoint(p0);
+
         if (d > delta) {
           mark0 = 2;
           points2.push(p0.clone());
@@ -162,9 +237,12 @@ ConvexObjectBreaker.prototype = {
           mark0 = 3;
           points1.push(p0.clone());
           points2.push(p0.clone());
-        }
+        } // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+
+
         var mark1 = 0;
         var d = localPlane.distanceToPoint(p1);
+
         if (d > delta) {
           mark1 = 2;
           points2.push(p1.clone());
@@ -176,117 +254,145 @@ ConvexObjectBreaker.prototype = {
           points1.push(p1.clone());
           points2.push(p1.clone());
         }
+
         if (mark0 === 1 && mark1 === 2 || mark0 === 2 && mark1 === 1) {
+          // Intersection of segment with the plane
           this.tempLine1.start.copy(p0);
           this.tempLine1.end.copy(p1);
-          var intersection = new THREE.Vector3();
+          var intersection = new Vector3();
           intersection = localPlane.intersectLine(this.tempLine1, intersection);
-          if (intersection === void 0) {
-            console.error("Internal error: segment does not intersect plane.");
+
+          if (intersection === undefined) {
+            // Shouldn't happen
+            console.error('Internal error: segment does not intersect plane.');
             output.segmentedObject1 = null;
             output.segmentedObject2 = null;
             return 0;
           }
+
           points1.push(intersection);
           points2.push(intersection.clone());
         }
       }
-    }
-    var newMass = object.userData.mass * 0.5;
+    } // Calculate debris mass (very fast and imprecise):
+
+
+    var newMass = object.userData.mass * 0.5; // Calculate debris Center of Mass (again fast and imprecise)
+
     this.tempCM1.set(0, 0, 0);
     var radius1 = 0;
     var numPoints1 = points1.length;
+
     if (numPoints1 > 0) {
-      for (let i = 0; i < numPoints1; i++)
-        this.tempCM1.add(points1[i]);
+      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];
         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;
+
     if (numPoints2 > 0) {
-      for (let i = 0; i < numPoints2; i++)
-        this.tempCM2.add(points2[i]);
+      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];
         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;
+
     if (numPoints1 > 4) {
-      object1 = new THREE.Mesh(new ConvexGeometry.ConvexGeometry(points1), object.material);
+      object1 = new Mesh(new ConvexGeometry(points1), object.material);
       object1.position.copy(this.tempCM1);
       object1.quaternion.copy(object.quaternion);
-      this.prepareBreakableObject(
-        object1,
-        newMass,
-        object.userData.velocity,
-        object.userData.angularVelocity,
-        2 * radius1 > this.minSizeForBreak
-      );
+      this.prepareBreakableObject(object1, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius1 > this.minSizeForBreak);
       numObjects++;
     }
+
     if (numPoints2 > 4) {
-      object2 = new THREE.Mesh(new ConvexGeometry.ConvexGeometry(points2), object.material);
+      object2 = new Mesh(new ConvexGeometry(points2), object.material);
       object2.position.copy(this.tempCM2);
       object2.quaternion.copy(object.quaternion);
-      this.prepareBreakableObject(
-        object2,
-        newMass,
-        object.userData.velocity,
-        object.userData.angularVelocity,
-        2 * radius2 > this.minSizeForBreak
-      );
+      this.prepareBreakableObject(object2, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius2 > this.minSizeForBreak);
       numObjects++;
     }
+
     output.object1 = object1;
     output.object2 = object2;
     return numObjects;
   }
 };
-ConvexObjectBreaker.transformFreeVector = function(v, m) {
-  var x = v.x, y = v.y, z = v.z;
+
+ConvexObjectBreaker.transformFreeVector = function (v, m) {
+  // input:
+  // vector interpreted as a free vector
+  // THREE.Matrix4 orthogonal matrix (matrix without scale)
+  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;
+
+ConvexObjectBreaker.transformFreeVectorInverse = function (v, m) {
+  // input:
+  // vector interpreted as a free vector
+  // THREE.Matrix4 orthogonal matrix (matrix without scale)
+  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;
+
+ConvexObjectBreaker.transformTiedVectorInverse = function (v, m) {
+  // input:
+  // vector interpreted as a tied (ordinary) vector
+  // THREE.Matrix4 orthogonal matrix (matrix without scale)
+  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();
+
+ConvexObjectBreaker.transformPlaneToLocalSpace = function () {
+  var v1 = new Vector3();
   return function transformPlaneToLocalSpace(plane, m, resultPlane) {
     resultPlane.normal.copy(plane.normal);
     resultPlane.constant = plane.constant;
     var referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(v1), m);
-    ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m);
+    ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m); // recalculate constant (like in setFromNormalAndCoplanarPoint)
+
     resultPlane.constant = -referencePoint.dot(resultPlane.normal);
   };
 }();
-exports.ConvexObjectBreaker = ConvexObjectBreaker;
+
+export { ConvexObjectBreaker };

package/misc/GPUComputationRenderer.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");exports.GPUComputationRenderer=function(r,t,n){this.variables=[],this.currentTextureIndex=0;var a=e.FloatType,i=new e.Scene,s=new e.Camera;s.position.z=1;var u={passThruTexture:{value:null}},l=h("uniform sampler2D passThruTexture;\n\nvoid main() {\n\n\tvec2 uv = gl_FragCoord.xy / resolution.xy;\n\n\tgl_FragColor = texture2D( passThruTexture, uv );\n\n}\n",u),d=new e.Mesh(new e.PlaneGeometry(2,2),l);function o(e){e.defines.resolution="vec2( "+r.toFixed(1)+", "+t.toFixed(1)+" )"}function h(r,t){t=t||{};var n=new e.ShaderMaterial({uniforms:t,vertexShader:"void main()\t{\n\n\tgl_Position = vec4( position, 1.0 );\n\n}\n",fragmentShader:r});return o(n),n}i.add(d),this.setDataType=function(e){return a=e,this},this.addVariable=function(r,t,n){var a={name:r,initialValueTexture:n,material:this.createShaderMaterial(t),dependencies:null,renderTargets:[],wrapS:null,wrapT:null,minFilter:e.NearestFilter,magFilter:e.NearestFilter};return this.variables.push(a),a},this.setVariableDependencies=function(e,r){e.dependencies=r},this.init=function(){if(!1===n.capabilities.isWebGL2&&!1===n.extensions.has("OES_texture_float"))return"No OES_texture_float support for float textures.";if(0===n.capabilities.maxVertexTextures)return"No support for vertex shader textures.";for(let n=0;n<this.variables.length;n++){var e=this.variables[n];e.renderTargets[0]=this.createRenderTarget(r,t,e.wrapS,e.wrapT,e.minFilter,e.magFilter),e.renderTargets[1]=this.createRenderTarget(r,t,e.wrapS,e.wrapT,e.minFilter,e.magFilter),this.renderTexture(e.initialValueTexture,e.renderTargets[0]),this.renderTexture(e.initialValueTexture,e.renderTargets[1]);var a=e.material,i=a.uniforms;if(null!==e.dependencies)for(let r=0;r<e.dependencies.length;r++){var s=e.dependencies[r];if(s.name!==e.name){var u=!1;for(let e=0;e<this.variables.length;e++)if(s.name===this.variables[e].name){u=!0;break}if(!u)return"Variable dependency not found. Variable="+e.name+", dependency="+s.name}i[s.name]={value:null},a.fragmentShader="\nuniform sampler2D "+s.name+";\n"+a.fragmentShader}}return this.currentTextureIndex=0,null},this.compute=function(){var e=this.currentTextureIndex,r=0===this.currentTextureIndex?1:0;for(let i=0,s=this.variables.length;i<s;i++){var t=this.variables[i];if(null!==t.dependencies){var n=t.material.uniforms;for(let r=0,i=t.dependencies.length;r<i;r++){var a=t.dependencies[r];n[a.name].value=a.renderTargets[e].texture}}this.doRenderTarget(t.material,t.renderTargets[r])}this.currentTextureIndex=r},this.getCurrentRenderTarget=function(e){return e.renderTargets[this.currentTextureIndex]},this.getAlternateRenderTarget=function(e){return e.renderTargets[0===this.currentTextureIndex?1:0]},this.addResolutionDefine=o,this.createShaderMaterial=h,this.createRenderTarget=function(n,i,s,u,l,d){return n=n||r,i=i||t,s=s||e.ClampToEdgeWrapping,u=u||e.ClampToEdgeWrapping,l=l||e.NearestFilter,d=d||e.NearestFilter,new e.WebGLRenderTarget(n,i,{wrapS:s,wrapT:u,minFilter:l,magFilter:d,format:e.RGBAFormat,type:a,depthBuffer:!1})},this.createTexture=function(){var n=new Float32Array(r*t*4);return new e.DataTexture(n,r,t,e.RGBAFormat,e.FloatType)},this.renderTexture=function(e,r){u.passThruTexture.value=e,this.doRenderTarget(l,r),u.passThruTexture.value=null},this.doRenderTarget=function(e,r){var t=n.getRenderTarget();d.material=e,n.setRenderTarget(r),n.render(i,s),d.material=l,n.setRenderTarget(t)}};