cyclone-physics 1.1.2 → 1.1.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cyclone-physics",
   "description": "Pure Javascript physics engine based on http://procyclone.com/",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "main": "",
   "author": "James Baicoianu",
   "license": "MIT",

package/scripts/collisions.js

@@ -9,6 +9,8 @@ elation.require(['physics.common', 'utils.math'], function() {
       // closure scratch variables
       var thispos = new THREE.Vector3(),
           otherpos = new THREE.Vector3(),
+          thisvel = new THREE.Vector3(),
+          othervel = new THREE.Vector3(),
           midline = new THREE.Vector3(),
           scaledVelocity = new THREE.Vector3(),
           intersectionPoint = new THREE.Vector3();
@@ -20,9 +22,6 @@ elation.require(['physics.common', 'utils.math'], function() {
         obj1.body.localToWorldPos(thispos.set(0,0,0));
         obj2.body.localToWorldPos(otherpos.set(0,0,0));
 
-        let scaledRadius1 = obj1.radius * Math.max(obj1.body.scaleWorld.x, obj1.body.scaleWorld.y, obj1.body.scaleWorld.z),
-            scaledRadius2 = obj2.radius * Math.max(obj2.body.scaleWorld.x, obj2.body.scaleWorld.y, obj2.body.scaleWorld.z);
-
         let dynamic = true; // TODO - this should either be a flag on rigid bodies, or a configurable threshold based on velocity
         if (!dynamic) {
           midline.subVectors(otherpos, thispos),
@@ -45,9 +44,17 @@ elation.require(['physics.common', 'utils.math'], function() {
             //console.log('crash a sphere-sphere', contact);
           }
         } else {
-          let r = scaledRadius1 + scaledRadius2;
+          let r = obj1.radius + obj2.radius;
           // FIXME - probably need to transform velocity into world coordinates as well
-          let v = scaledVelocity.copy(obj1.body.velocity).sub(obj2.body.velocity).multiplyScalar(dt);
+          obj1.body.localToWorldDir(thisvel.copy(obj1.body.velocity));
+          obj2.body.localToWorldDir(othervel.copy(obj2.body.velocity));
+
+
+          let v = scaledVelocity.copy(thisvel).sub(othervel).multiplyScalar(dt);
+
+          midline.copy(thispos).sub(otherpos).normalize();
+
+          //if (midline.dot(scaledVelocity) > 0) return; // moving away, can't collide
 
           let endpos = midline.copy(thispos).add(v);
 
@@ -61,7 +68,7 @@ elation.require(['physics.common', 'utils.math'], function() {
 
             var contact = new elation.physics.contact_dynamic({
               normal: normal,
-              point: normal.clone().multiplyScalar(scaledRadius1).add(thispos), // allocate point
+              point: normal.clone().multiplyScalar(obj1.radius).add(thispos), // allocate point
               penetrationTime: intersection.t,
               bodies: [obj1.body, obj2.body],
             });
@@ -315,7 +322,7 @@ elation.require(['physics.common', 'utils.math'], function() {
       }
     })();
 
-    this.box_box = function() {
+    this.box_box_old = function() {
       // closure scratch variables
       var diff = new THREE.Vector3(),
           thispos = new THREE.Vector3(),
@@ -477,6 +484,234 @@ elation.require(['physics.common', 'utils.math'], function() {
       }
     }();
 
+    this.box_box = (function() {
+      // closure scratch variables
+      const scratch = {
+        axes: Array(15).fill(null).map(() => new THREE.Vector3()),
+        box1Corners: Array(8).fill(null).map(() => new THREE.Vector3()),
+        box2Corners: Array(8).fill(null).map(() => new THREE.Vector3()),
+        box1Projection: { min: 0, max: 0 },
+        box2Projection: { min: 0, max: 0 },
+        tmpVec: new THREE.Vector3(),
+        tmpQuat: new THREE.Quaternion(),
+        contactAxis: new THREE.Vector3(),
+      };
+
+      function getAxesToTest(box1, box2, scratchAxes) {
+        const axes = scratchAxes;
+
+        // Get the three local axes of both boxes in world coordinates
+        const box1Axes = getWorldAxes(box1, axes.slice(0, 3));
+        const box2Axes = getWorldAxes(box2, axes.slice(3, 6));
+
+        // Add cross products of edges (9 cross-product axes)
+        let axesIndex = 6;
+        for (let i = 0; i < 3; i++) {
+          for (let j = 0; j < 3; j++) {
+            const cross = axes[axesIndex].crossVectors(box1Axes[i], box2Axes[j]);
+            if (cross.lengthSq() > 1e-6) {  // Avoid zero vectors
+              cross.normalize();
+            }
+            axesIndex++;
+          }
+        }
+
+        return axes;
+      }
+
+      function getWorldAxes(box, axes) {
+        // The orientationWorld is already in world space
+        axes[0].set(1, 0, 0).applyQuaternion(box.body.orientationWorld);
+        axes[1].set(0, 1, 0).applyQuaternion(box.body.orientationWorld);
+        axes[2].set(0, 0, 1).applyQuaternion(box.body.orientationWorld);
+        return axes;
+      }
+      function getPenetrationOnAxis(box1, box2, axis) {
+        // Project both boxes onto the axis
+        const box1Projection = projectBoxOntoAxis(box1, axis, scratch.box1Corners, scratch.box1Projection);
+        const box2Projection = projectBoxOntoAxis(box2, axis, scratch.box2Corners, scratch.box2Projection);
+
+        // Check if projections overlap
+        const overlap = Math.min(box1Projection.max - box2Projection.min, box2Projection.max - box1Projection.min);
+        if (box1Projection.max < box2Projection.min || box2Projection.max < box1Projection.min) {
+          return false; // Separating axis found
+        }
+
+        return overlap; // Return penetration depth on this axis
+      }
+      function projectBoxOntoAxis(box, axis, corners, projection) {
+        getBoxCorners(box, corners);
+
+        projection.min = Infinity;
+        projection.max = -Infinity;
+
+        for (let corner of corners) {
+          const proj = corner.dot(axis);
+          projection.min = Math.min(projection.min, proj);
+          projection.max = Math.max(projection.max, proj);
+        }
+
+        return projection;
+      }
+      function getBoxCorners(box, corners) {
+        const halfSize = box.halfsize;
+        const offset = box.offset;
+
+        const scale = box.body.localToWorldScale(scratch.tmpVec.set(1,1,1));
+
+        // Define the eight corners of the box in local space
+        corners[0].set(halfSize.x, halfSize.y, halfSize.z).add(offset).divide(scale);
+        corners[1].set(halfSize.x, halfSize.y, -halfSize.z).add(offset).divide(scale);
+        corners[2].set(halfSize.x, -halfSize.y, halfSize.z).add(offset).divide(scale);
+        corners[3].set(halfSize.x, -halfSize.y, -halfSize.z).add(offset).divide(scale);
+        corners[4].set(-halfSize.x, halfSize.y, halfSize.z).add(offset).divide(scale);
+        corners[5].set(-halfSize.x, halfSize.y, -halfSize.z).add(offset).divide(scale);
+        corners[6].set(-halfSize.x, -halfSize.y, halfSize.z).add(offset).divide(scale);
+        corners[7].set(-halfSize.x, -halfSize.y, -halfSize.z).add(offset).divide(scale);
+
+        // Convert local corners to world space using localToWorld
+        for (let i = 0; i < 8; i++) {
+          box.body.localToWorldPos(corners[i]);
+        }
+
+        return corners;
+      }
+      function generateContacts(box1, box2, minPenetration, contactAxis, contacts) {
+        // The contact normal is the axis of minimum penetration
+        const contactNormal = contactAxis.clone().normalize();
+
+        // Find the closest points on the surface of both boxes
+        const box1Corners = getBoxCorners(box1, scratch.box1Corners);
+        const box2Corners = getBoxCorners(box2, scratch.box2Corners);
+
+        //const box1Closest = findClosestPointOnBox(box1Corners, contactNormal);
+        //const box2Closest = findClosestPointOnBox(box2Corners, contactNormal.clone().negate());
+        const box1Closest = findClosestPointOnFace(box1Corners, box2, contactNormal);
+        const box2Closest = findClosestPointOnFace(box2Corners, box1, contactNormal);
+
+        // Contact point is the midpoint between closest points on both boxes
+        const contactPoint = box1Closest.clone().add(box2Closest).multiplyScalar(0.5);
+
+        // Create the contact
+        const contact = new elation.physics.contact({
+          normal: contactNormal,
+          point: contactPoint.clone(),
+          penetration: 0, //-minPenetration, // negative value as it's penetration
+          //penetration: box1Closest.distanceTo(box2Closest),
+          bodies: [box1.body, box2.body]
+        });
+
+        contacts.push(contact);
+        return contacts;
+      }
+      function findClosestPointOnBox(corners, normal) {
+        let closestPoint = corners[0];
+        let minDistance = closestPoint.dot(normal);
+
+        for (let i = 1; i < corners.length; i++) {
+          const dist = corners[i].dot(normal);
+          if (dist < minDistance) {
+            closestPoint = corners[i];
+            minDistance = dist;
+          }
+        }
+        return closestPoint;
+      }
+      function findClosestPointOnFace(corners, otherBox, normal) {
+        let closestPoint = null;
+        let minDistance = Infinity;
+
+        // Check the projection of each corner onto the face of the other box
+        for (let i = 0; i < corners.length; i++) {
+          const corner = corners[i];
+          const projectedPoint = projectPointOntoFace(corner, otherBox, normal);
+
+          const distance = corner.distanceTo(projectedPoint);
+          if (distance < minDistance) {
+            closestPoint = projectedPoint;
+            minDistance = distance;
+          }
+        }
+
+        return closestPoint;
+      }
+
+      function projectPointOntoFace(point, box, normal) {
+        // First, find the center of the box in world space
+        const boxCenter = new THREE.Vector3();
+        box.body.localToWorldPos(boxCenter.set(0, 0, 0));
+
+        // Determine the plane of the face by using the box's normal and a point on the plane
+        // (the center of the face, which is aligned with one of the box's axes)
+        const halfSize = box.halfsize;
+        const offset = new THREE.Vector3().addVectors(box.min, box.max).multiplyScalar(.5);
+        const planePoint = new THREE.Vector3();
+        const planeNormal = normal.clone().normalize(); // Normal of the face (aligned with one of the box's axes)
+
+        // We need to determine which face we're projecting onto, so find the direction along the normal
+        // Set the point on the plane (face center) by adding/subtracting half the box size along the normal
+        for (let i = 0; i < 3; i++) {
+            const axisValue = planeNormal.getComponent(i);
+            if (axisValue !== 0) {
+                planePoint.setComponent(i, boxCenter.getComponent(i) + (axisValue * halfSize.getComponent(i)));
+            }
+        }
+
+        // Now, we project the point onto the plane
+        // To do that, find the vector from the point to the plane point
+        const pointToPlane = point.clone().sub(planePoint);
+
+        // Project this vector onto the normal to find how far away the point is from the plane
+        const distance = pointToPlane.dot(planeNormal);
+
+        // Move the point onto the plane by subtracting the distance along the normal
+        const projectedPoint = point.clone().sub(planeNormal.multiplyScalar(distance));
+
+        // Now we need to clamp the projected point to the bounds of the box face
+        // For each axis, clamp the value within the bounds of the face
+        for (let i = 0; i < 3; i++) {
+            const axisValue = planeNormal.getComponent(i);
+            if (axisValue === 0) {
+                // Clamp the coordinate to be within the face bounds (which are defined by the box size)
+                const minVal = boxCenter.getComponent(i) - halfSize.getComponent(i);
+                const maxVal = boxCenter.getComponent(i) + halfSize.getComponent(i);
+                const value = projectedPoint.getComponent(i);
+                projectedPoint.setComponent(i, Math.max(minVal, Math.min(value, maxVal)));
+            }
+        }
+
+        return projectedPoint.add(offset);
+
+      }
+
+
+
+      return function(box1, box2, contacts, dt) {
+        const axes = getAxesToTest(box1, box2, scratch.axes);
+        let hasCollision = true;
+        let minPenetration = Infinity;
+
+        // Check for overlap along each axis
+        for (let axis of axes) {
+          const overlap = getPenetrationOnAxis(box1, box2, axis);
+          if (overlap === false) {
+            hasCollision = false; // Separating axis found, no collision
+            break;
+          } else if (overlap < minPenetration) {
+            minPenetration = overlap; // Track the minimum penetration
+            scratch.contactAxis.copy(axis);  // Store the axis with minimum penetration
+          }
+        }
+
+        if (!hasCollision) {
+          return false;
+        }
+
+        // If colliding, generate contact points and return them
+        return generateContacts(box1, box2, minPenetration, scratch.contactAxis, contacts);
+      }
+    })();
+
     /* cylinder helpers */
     this.cylinder_sphere = function() {
       // closure scratch variables
@@ -637,20 +872,23 @@ elation.require(['physics.common', 'utils.math'], function() {
             closest = new THREE.Vector3();
 
       return function(capsule, sphere, contacts, dt) {
-        const radius = capsule.radius + sphere.radius;
-        const capsuleDims = capsule.getDimensions();
+        const capsuleScaledRadius = capsule.radius * Math.max(capsule.body.scale.x, capsule.body.scale.z),
+              combinedRadius = capsuleScaledRadius + sphere.radius,
+              capsuleDims = capsule.getDimensions();
         sphere.body.localToWorldPos(point.set(0,0,0));
 
+
         elation.physics.colliders.helperfuncs.closest_point_on_line(capsuleDims.start, capsuleDims.end, point, closest);
+
         normal.subVectors(closest, point);
         const distance = normal.length();
-  //console.log(distance, radius, capsule.radius, sphere.radius);
-        if (distance <= radius) {
+
+        if (distance <= combinedRadius) {
           normal.divideScalar(distance);
           let contact = new elation.physics.contact({
             normal: normal.clone(), // allocate normal
-            point: closest.clone().add(normal.multiplyScalar(capsule.radius)), // allocate point
-            penetration: radius - distance,
+            point: closest.clone().add(normal.multiplyScalar(capsuleScaledRadius)), // allocate point
+            penetration: combinedRadius - distance,
             bodies: [capsule.body, sphere.body]
           });
           contacts.push(contact);
@@ -669,20 +907,23 @@ elation.require(['physics.common', 'utils.math'], function() {
 
         let distSquared = elation.physics.colliders.helperfuncs.distancesquared_between_lines(capsule1Dims.start, capsule1Dims.end, capsule2Dims.start, capsule2Dims.end, p1, p2);
 
-        if (distSquared <= Math.pow(capsule1.radius + capsule2.radius, 2)) {
+        const capsule1ScaledRadius = capsule1.radius * Math.max(capsule1.body.scale.x, capsule1.body.scale.z),
+              capsule2ScaledRadius = capsule2.radius * Math.max(capsule2.body.scale.x, capsule2.body.scale.z);
+
+        if (distSquared <= Math.pow(capsule1ScaledRadius + capsule2ScaledRadius, 2)) {
           console.log('CAPSULE COLLIDE', capsule1, capsule2);
           let normal = new THREE.Vector3().subVectors(p2, p1),
               point = p1.clone();
               dist = Math.sqrt(distSquared);
           normal.divideScalar(dist);
-          point.x += normal.x * capsule1.radius;
-          point.y += normal.y * capsule1.radius;
-          point.z += normal.z * capsule1.radius;
+          point.x += normal.x * capsule1ScaledRadius;
+          point.y += normal.y * capsule1ScaledRadius;
+          point.z += normal.z * capsule1ScaledRadius;
 
           let contact = new elation.physics.contact({
             normal: normal,
             point: point,
-            penetration: dist - (capsule1.radius + capsule2.radius),
+            penetration: dist - (capsule1ScaledRadius + capsule2ScaledRadius),
             bodies: [capsule1.body, capsule2.body]
           });
           contacts.push(contact);
@@ -796,13 +1037,12 @@ elation.require(['physics.common', 'utils.math'], function() {
               p3 = worldpoints.p3,
               normal = worldpoints.normal;
 
-        //if (spherevel.dot(normal) > 0) return; // moving away, can't collide
-
+        let velNormal = spherevel.dot(normal);
 
         // Check if we're already in contact
         elation.physics.colliders.helperfuncs.closest_point_on_triangle(spherepos, p1, p2, p3, triangleClosestPoint);
         let triangleDistSquared = triangleClosestPoint.distanceToSquared(spherepos)
-        if (triangleDistSquared < sphere.radius * sphere.radius) {
+        if (triangleDistSquared < sphere.radius * sphere.radius && velNormal <= 0) {
           let contact = new elation.physics.contact({
             normal: normal.clone(), // allocate normal
             point: triangleClosestPoint.clone(), // allocate point
@@ -875,7 +1115,7 @@ elation.require(['physics.common', 'utils.math'], function() {
             intersectionPoint.y - triangleClosestPoint.y,
             intersectionPoint.z - triangleClosestPoint.z
           );
-          normal.normalize();
+          collisionNormal.normalize();
 
           intersectionPoint.x += collisionNormal.x * -sphere.radius;
           intersectionPoint.y += collisionNormal.y * -sphere.radius;
@@ -1687,6 +1927,8 @@ elation.require(['physics.common', 'utils.math'], function() {
       let triangles = [];
       let radiusSq = 0;
 
+      this.body.updateState(); // ensure scaleWorld is up to date before processing triangles
+      let doubleSided = false;
       if (!this.modeldata && this.mesh && this.mesh.geometry) {
         if (this.mesh.geometry instanceof THREE.BufferGeometry) {
           this.modeldata = {
@@ -1702,6 +1944,7 @@ elation.require(['physics.common', 'utils.math'], function() {
             }
           }
         }
+        doubleSided = this.mesh.material.side == THREE.DoubleSide;
       }
       if (this.modeldata) {
         if (this.modeldata.index) {
@@ -1727,6 +1970,11 @@ elation.require(['physics.common', 'utils.math'], function() {
             if (!triangle.isDegenerate()) {
               triangles.push(triangle);
 
+              if (doubleSided) {
+                let triangle2 = new elation.physics.colliders.triangle(this.body, [p3, p2, p1]);
+                triangles.push(triangle2);
+              }
+
               let l1 = p1.lengthSq(),
                   l2 = p2.lengthSq(),
                   l3 = p3.lengthSq();
@@ -1761,7 +2009,7 @@ elation.require(['physics.common', 'utils.math'], function() {
           }
         }
       }
-      this.radius = Math.sqrt(radiusSq);
+      this.radius = Math.sqrt(radiusSq) * Math.max(this.body.scaleWorld.x, this.body.scaleWorld.y, this.body.scaleWorld.z);
       this.boundingSphere.radius = this.radius;
       return triangles;
     }
@@ -1797,11 +2045,11 @@ elation.require(['physics.common', 'utils.math'], function() {
             bodies[obj.uuid].scale.copy(obj.scale);
             bodies[obj.uuid].orientation.copy(obj.quaternion);
             bodies[obj.uuid].object = this.body.object;
+            parent.add(bodies[obj.uuid]);
             if (obj instanceof THREE.Mesh) {
               bodies[obj.uuid].setCollider('mesh', {mesh: obj, isroot: false });
               //elation.events.add(bodies[obj.uuid], 'physics_collide', (ev) => elation.events.fire({type: 'physics_collide', element: this.body, event: ev}));
             }
-            parent.add(bodies[obj.uuid]);
           }
           parent = bodies[obj.uuid];
         }
@@ -2143,21 +2391,20 @@ elation.require(['physics.common', 'utils.math'], function() {
       var lastaccel = new THREE.Vector3();
 
       if (this.bodies[0] && !this.bodies[0].state.sleeping) {
-        velocityFromAccel -= .5 * lastaccel.copy(this.bodies[0].lastacceleration).multiplyScalar(duration).dot(this.normal);
+        velocityFromAccel -= lastaccel.copy(this.bodies[0].lastacceleration).multiplyScalar(duration).dot(this.normal);
       }
       if (this.bodies[1] && !this.bodies[1].state.sleeping) {
-        velocityFromAccel += .5 * lastaccel.copy(this.bodies[1].lastacceleration).multiplyScalar(duration).dot(this.normal);
+        velocityFromAccel += lastaccel.copy(this.bodies[1].lastacceleration).multiplyScalar(duration).dot(this.normal);
       }
 
       var restitution = this.restitution;
-/*
-      if (Math.abs(this.velocity.y) < 0.25) { // FIXME - velocity threshold should be configurable
+
+      if (Math.abs(this.velocity.y) < 0.01) { // FIXME - velocity threshold should be configurable
         restitution = 0;
       }
-*/
+
       this.desiredDeltaVelocity = -this.velocity.y - restitution * (this.velocity.y - velocityFromAccel);
       //if (this.desiredDeltaVelocity > 0) this.desiredDeltaVelocity *= -1;
-      //console.log('desiredDeltaV: ' + this.desiredDeltaVelocity);
     }
     this.calculateInternals = function(duration) {
       this.calculateContactMatrix();

package/scripts/common.js

@@ -15,6 +15,9 @@ elation.require(['engine.external.three.three'], function() {
     toJSON() {
       return {x: this._x, y: this._y, z: this._z};
     }
+    clone() {
+      return super.clone();
+    }
   }
   // FIXME - orientation doesn't currently work properly because THREE.Quaternion already uses getters and setters internally
   class CycloneQuaternion extends THREE.Quaternion {
@@ -34,6 +37,9 @@ elation.require(['engine.external.three.three'], function() {
       this.changed = true;
       return super.copy(quat);
     }
+    clone() {
+      return super.clone();
+    }
     set(x, y, z, w) {
       this.changed = true;
       return super.set(x, y, z, w);

package/scripts/cyclone.js

@@ -7,7 +7,7 @@ elation.require(["physics.common", "physics.processors", "physics.processors.wor
     this.position = this.positionWorld = new THREE.Vector3();
     this.orientation = this.orientationWorld = new THREE.Quaternion();
     this.scale = this.scaleWorld = new THREE.Vector3(1, 1, 1);
-    this.substep = elation.utils.any(this.args.substep, true);
+    this.substep = false; //elation.utils.any(this.args.substep, true);
     this.substepMaxDelta = elation.utils.any(this.args.substepMaxDelta, 20/1000);
     this.substepMaxSteps = elation.utils.any(this.args.substepMaxSteps, 4);
     this.processortype = elation.utils.any(this.args.processortype, 'cpu');
@@ -39,7 +39,7 @@ elation.require(["physics.common", "physics.processors", "physics.processors.wor
         steps = Math.min(Math.round(t / this.substepMaxDelta), this.substepMaxSteps);
       }
       
-      var step = 0;
+      var step = 1;
       while (t > 0) {
         var steptime = (step < steps ? Math.min(t, this.substepMaxDelta) : t);
 

package/scripts/forces.js

@@ -415,6 +415,8 @@ elation.require(['physics.common'], function() {
     var _tmpvec2 = new THREE.Vector3();
 
     this.apply = function() {
+      if (this.disabled) return;
+
       var lws = this.body.localToWorldPos(_tmpvec1.copy(this.connectionpoint));
       var ows = (this.other ? this.other.localToWorldPos(_tmpvec2.copy(this.otherconnectionpoint)) : this.anchor);
 

package/scripts/processors.js

@@ -53,6 +53,7 @@ elation.require(["physics.common"], function() {
           var obj1 = potentialpair[0], obj2 = potentialpair[1];
           // Get list of all contact points between the two objects
           var contacts = obj1.getContacts(obj2, [], t);
+/*
           if (contacts && contacts.length > 0) {
             // Resolve the deepest contact first
             var deepest = this.getDeepestContact(contacts);
@@ -60,6 +61,14 @@ elation.require(["physics.common"], function() {
             obj1.state.colliding = true;
             obj2.state.colliding = true;
           }
+*/
+          if (contacts && contacts.length > 0) {
+            for (let i = 0; i < contacts.length; i++) {
+              collisions.push(contacts[i]);
+              obj1.state.colliding = true;
+              obj2.state.colliding = true;
+            }
+          }
         }
         //console.log(potentials.length + ' potential crashes:', potentials, collisions);
       }
@@ -103,7 +112,7 @@ elation.require(["physics.common"], function() {
         let contact = contacts.shift();
         contact.resolve(t, linearChange, angularChange, contacts);
         // console.log('blah', contacts.length, linearChange[1].toArray().map(x => +x.toFixed(4)), contact.bodies)
-        break;
+        //break;
       }
     }
   });