cyclone-physics 1.1.2 → 1.1.3

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.3",
   "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],
             });
@@ -637,20 +644,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 +679,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 +809,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 +887,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 +1699,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 +1716,7 @@ elation.require(['physics.common', 'utils.math'], function() {
             }
           }
         }
+        doubleSided = this.mesh.material.side == THREE.DoubleSide;
       }
       if (this.modeldata) {
         if (this.modeldata.index) {
@@ -1727,6 +1742,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 +1781,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 +1817,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];
         }

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;
       }
     }
   });