added penetration support to particle collisions JS callbacks

examples/collidingParticles.js

@@ -30,8 +30,9 @@ var gravity = {
 var damping = 0.1;
 
 var scriptA = " " +
-             " function collisionWithParticle(other) { " +
+             " function collisionWithParticle(other, penetration) { " +
              "   print('collisionWithParticle(other.getID()=' + other.getID() + ')...'); " +
+             "   Vec3.print('penetration=', penetration); " +
              "   print('myID=' + Particle.getID() + '\\n'); " +
              "   var colorBlack = { red: 0, green: 0, blue: 0 };" +
              "   var otherColor = other.getColor();" +
@@ -45,8 +46,9 @@ var scriptA = " " +
              " ";
 
 var scriptB = " " +
-             " function collisionWithParticle(other) { " +
+             " function collisionWithParticle(other, penetration) { " +
              "   print('collisionWithParticle(other.getID()=' + other.getID() + ')...'); " +
+             "   Vec3.print('penetration=', penetration); " +
              "   print('myID=' + Particle.getID() + '\\n'); " +
              "   Particle.setScript('Particle.setShouldDie(true);'); " +
              " } " +

examples/globalCollisionsExample.js

@@ -10,17 +10,23 @@
 //
 
 
-function particleCollisionWithVoxel(particle, voxel) {
+print("hello...");
+
+function particleCollisionWithVoxel(particle, voxel, penetration) {
     print("particleCollisionWithVoxel()..");
     print("   particle.getID()=" + particle.id);
     print("   voxel color...=" + voxel.red + ", " + voxel.green + ", " + voxel.blue);
+    Vec3.print('penetration=', penetration);
 }
 
-function particleCollisionWithParticle(particleA, particleB) {
+function particleCollisionWithParticle(particleA, particleB, penetration) {
     print("particleCollisionWithParticle()..");
     print("   particleA.getID()=" + particleA.id);
     print("   particleB.getID()=" + particleB.id);
+    Vec3.print('penetration=', penetration);
 }
 
 Particles.particleCollisionWithVoxel.connect(particleCollisionWithVoxel);
 Particles.particleCollisionWithParticle.connect(particleCollisionWithParticle);
+
+print("here... hello...");

examples/gun.js

@@ -61,7 +61,8 @@ function shootBullet(position, velocity) {
     Audio.playSound(fireSound, audioOptions);
 }
 
-function particleCollisionWithVoxel(particle, voxel) {
+function particleCollisionWithVoxel(particle, voxel, penetration) {
+    Vec3.print('particleCollisionWithVoxel() ... penetration=', penetration);
     var HOLE_SIZE = 0.125;
     var particleProperties = Particles.getParticleProperties(particle);
     var position = particleProperties.position; 

examples/paintGun.js

@@ -62,8 +62,9 @@ function checkController() {
 
                 // This is the script for the particles that this gun shoots.
                 var script = 
-                         " function collisionWithVoxel(voxel) { " +
+                         " function collisionWithVoxel(voxel, penetration) { " +
                          "   print('collisionWithVoxel(voxel)... '); " +
+                         "   Vec3.print('penetration=', penetration); " +
                          "   print('myID=' + Particle.getID() + '\\n'); " +
                          "   var voxelColor = { red: voxel.red, green: voxel.green, blue: voxel.blue };" +
                          "   var voxelAt = { x: voxel.x, y: voxel.y, z: voxel.z };" +

examples/spaceInvadersExample.js

@@ -392,8 +392,9 @@ function deleteIfInvader(possibleInvaderParticle) {
     }
 }
 
-function particleCollisionWithParticle(particleA, particleB) {
+function particleCollisionWithParticle(particleA, particleB, penetration) {
     print("particleCollisionWithParticle() a.id="+particleA.id + " b.id=" + particleB.id);
+    Vec3.print('particleCollisionWithParticle() penetration=', penetration);
     if (missileFired) {
         myMissile = Particles.identifyParticle(myMissile);
         if (myMissile.id == particleA.id) {

interface/src/Application.cpp

@@ -1560,14 +1560,14 @@ void Application::init() {
 
     // connect the _particleCollisionSystem to our script engine's ParticleScriptingInterface
     connect(&_particleCollisionSystem, 
-            SIGNAL(particleCollisionWithVoxel(const ParticleID&, const VoxelDetail&)),
+            SIGNAL(particleCollisionWithVoxel(const ParticleID&, const VoxelDetail&, const glm::vec3&)),
             ScriptEngine::getParticlesScriptingInterface(), 
-            SLOT(forwardParticleCollisionWithVoxel(const ParticleID&, const VoxelDetail&)));
+            SLOT(forwardParticleCollisionWithVoxel(const ParticleID&, const VoxelDetail&, const glm::vec3&)));
 
     connect(&_particleCollisionSystem, 
-            SIGNAL(particleCollisionWithParticle(const ParticleID&, const ParticleID&)),
+            SIGNAL(particleCollisionWithParticle(const ParticleID&, const ParticleID&, const glm::vec3&)),
             ScriptEngine::getParticlesScriptingInterface(), 
-            SLOT(forwardParticleCollisionWithParticle(const ParticleID&, const ParticleID&)));
+            SLOT(forwardParticleCollisionWithParticle(const ParticleID&, const ParticleID&, const glm::vec3&)));
 
     _pieMenu.init("./resources/images/hifi-interface-tools-v2-pie.svg",
                   _glWidget->width(),

libraries/particles/src/Particle.cpp

@@ -884,25 +884,25 @@ void Particle::executeUpdateScripts() {
     }
 }
 
-void Particle::collisionWithParticle(Particle* other) {
+void Particle::collisionWithParticle(Particle* other, const glm::vec3& penetration) {
     // Only run this particle script if there's a script attached directly to the particle.
     if (!_script.isEmpty()) {
         ScriptEngine engine(_script);
         ParticleScriptObject particleScriptable(this);
         startParticleScriptContext(engine, particleScriptable);
         ParticleScriptObject otherParticleScriptable(other);
-        particleScriptable.emitCollisionWithParticle(&otherParticleScriptable);
+        particleScriptable.emitCollisionWithParticle(&otherParticleScriptable, penetration);
         endParticleScriptContext(engine, particleScriptable);
     }
 }
 
-void Particle::collisionWithVoxel(VoxelDetail* voxelDetails) {
+void Particle::collisionWithVoxel(VoxelDetail* voxelDetails, const glm::vec3& penetration) {
     // Only run this particle script if there's a script attached directly to the particle.
     if (!_script.isEmpty()) {
         ScriptEngine engine(_script);
         ParticleScriptObject particleScriptable(this);
         startParticleScriptContext(engine, particleScriptable);
-        particleScriptable.emitCollisionWithVoxel(*voxelDetails);
+        particleScriptable.emitCollisionWithVoxel(*voxelDetails, penetration);
         endParticleScriptContext(engine, particleScriptable);
     }
 }

libraries/particles/src/Particle.h

@@ -295,8 +295,8 @@ public:
     void applyHardCollision(const CollisionInfo& collisionInfo);
 
     void update(const quint64& now);
-    void collisionWithParticle(Particle* other);
+    void collisionWithParticle(Particle* other, const glm::vec3& penetration);
-    void collisionWithVoxel(VoxelDetail* voxel);
+    void collisionWithVoxel(VoxelDetail* voxel, const glm::vec3& penetration);
 
     void debugDump() const;
 
@@ -371,8 +371,10 @@ public:
     //~ParticleScriptObject() { qDebug() << "~ParticleScriptObject() this=" << this; }
 
     void emitUpdate() { emit update(); }
-    void emitCollisionWithParticle(QObject* other) { emit collisionWithParticle(other); }
+    void emitCollisionWithParticle(QObject* other, const glm::vec3& penetration) 
-    void emitCollisionWithVoxel(const VoxelDetail& voxel) { emit collisionWithVoxel(voxel); }
+                { emit collisionWithParticle(other, penetration); }
+    void emitCollisionWithVoxel(const VoxelDetail& voxel, const glm::vec3& penetration) 
+                { emit collisionWithVoxel(voxel, penetration); }
 
 public slots:
     unsigned int getID() const { return _particle->getID(); }
@@ -417,8 +419,8 @@ public slots:
 
 signals:
     void update();
-    void collisionWithVoxel(const VoxelDetail& voxel);
+    void collisionWithVoxel(const VoxelDetail& voxel, const glm::vec3& penetration);
-    void collisionWithParticle(QObject* other);
+    void collisionWithParticle(QObject* other, const glm::vec3& penetration);
 
 private:
     Particle* _particle;

libraries/particles/src/ParticleCollisionSystem.cpp

@@ -71,15 +71,18 @@ void ParticleCollisionSystem::checkParticle(Particle* particle) {
     updateCollisionWithAvatars(particle);
 }
 
-void ParticleCollisionSystem::emitGlobalParticleCollisionWithVoxel(Particle* particle, VoxelDetail* voxelDetails) {
+void ParticleCollisionSystem::emitGlobalParticleCollisionWithVoxel(Particle* particle, 
+                                            VoxelDetail* voxelDetails, const glm::vec3& penetration) {
     ParticleID particleID = particle->getParticleID();
-    emit particleCollisionWithVoxel(particleID, *voxelDetails);
+    emit particleCollisionWithVoxel(particleID, *voxelDetails, penetration);
 }
 
-void ParticleCollisionSystem::emitGlobalParticleCollisionWithParticle(Particle* particleA, Particle* particleB) {
+void ParticleCollisionSystem::emitGlobalParticleCollisionWithParticle(Particle* particleA, 
+                                            Particle* particleB, const glm::vec3& penetration) {
+                                            
     ParticleID idA = particleA->getParticleID();
     ParticleID idB = particleB->getParticleID();
-    emit particleCollisionWithParticle(idA, idB);
+    emit particleCollisionWithParticle(idA, idB, penetration);
 }
 
 void ParticleCollisionSystem::updateCollisionWithVoxels(Particle* particle) {
@@ -95,10 +98,10 @@ void ParticleCollisionSystem::updateCollisionWithVoxels(Particle* particle) {
     if (_voxels->findSpherePenetration(center, radius, collisionInfo._penetration, (void**)&voxelDetails)) {
 
         // let the particles run their collision scripts if they have them
-        particle->collisionWithVoxel(voxelDetails);
+        particle->collisionWithVoxel(voxelDetails, collisionInfo._penetration);
 
         // let the global script run their collision scripts for particles if they have them
-        emitGlobalParticleCollisionWithVoxel(particle, voxelDetails);
+        emitGlobalParticleCollisionWithVoxel(particle, voxelDetails, collisionInfo._penetration);
 
         updateCollisionSound(particle, collisionInfo._penetration, COLLISION_FREQUENCY);
         collisionInfo._penetration /= (float)(TREE_SCALE);
@@ -125,9 +128,9 @@ void ParticleCollisionSystem::updateCollisionWithParticles(Particle* particleA)
         // we don't want to count this as a collision.
         glm::vec3 relativeVelocity = particleA->getVelocity() - particleB->getVelocity();
         if (glm::dot(relativeVelocity, penetration) > 0.0f) {
-            particleA->collisionWithParticle(particleB);
+            particleA->collisionWithParticle(particleB, penetration);
-            particleB->collisionWithParticle(particleA);
+            particleB->collisionWithParticle(particleA, penetration * -1.0f); // the penetration is reversed
-            emitGlobalParticleCollisionWithParticle(particleA, particleB);
+            emitGlobalParticleCollisionWithParticle(particleA, particleB, penetration);
 
             glm::vec3 axis = glm::normalize(penetration);
             glm::vec3 axialVelocity = glm::dot(relativeVelocity, axis) * axis;

libraries/particles/src/ParticleCollisionSystem.h

@@ -53,13 +53,13 @@ public:
     void updateCollisionSound(Particle* particle, const glm::vec3 &penetration, float frequency);
 
 signals:
-    void particleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel);
+    void particleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel, const glm::vec3& penetration);
-    void particleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB);
+    void particleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB, const glm::vec3& penetration);
 
 private:
     static bool updateOperation(OctreeElement* element, void* extraData);
-    void emitGlobalParticleCollisionWithVoxel(Particle* particle, VoxelDetail* voxelDetails);
+    void emitGlobalParticleCollisionWithVoxel(Particle* particle, VoxelDetail* voxelDetails, const glm::vec3& penetration);
-    void emitGlobalParticleCollisionWithParticle(Particle* particleA, Particle* particleB);
+    void emitGlobalParticleCollisionWithParticle(Particle* particleA, Particle* particleB, const glm::vec3& penetration);
 
     ParticleEditPacketSender* _packetSender;
     ParticleTree* _particles;

libraries/particles/src/ParticlesScriptingInterface.h

@@ -29,12 +29,13 @@ public:
     
 private slots:
     /// inbound slots for external collision systems
-    void forwardParticleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel) {
+    void forwardParticleCollisionWithVoxel(const ParticleID& particleID, 
-        emit particleCollisionWithVoxel(particleID, voxel);
+                            const VoxelDetail& voxel, const glm::vec3& penetration) {
+        emit particleCollisionWithVoxel(particleID, voxel, penetration);
     }
 
-    void forwardParticleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB) {
+    void forwardParticleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB, const glm::vec3& penetration) {
-        emit particleCollisionWithParticle(idA, idB);
+        emit particleCollisionWithParticle(idA, idB, penetration);
     }
     
 public slots:
@@ -65,8 +66,8 @@ public slots:
     QVector<ParticleID> findParticles(const glm::vec3& center, float radius) const;
 
 signals:
-    void particleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel);
+    void particleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel, const glm::vec3& penetration);
-    void particleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB);
+    void particleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB, const glm::vec3& penetration);
 
 private:
     void queueParticleMessage(PacketType packetType, ParticleID particleID, const ParticleProperties& properties);

libraries/script-engine/src/Vec3.cpp

@@ -9,6 +9,8 @@
 //
 //
 
+#include <QDebug>
+
 #include "Vec3.h"
 
 glm::vec3 Vec3::multiply(const glm::vec3& v1, const glm::vec3& v2) {
@@ -32,3 +34,11 @@ glm::vec3 Vec3::subtract(const glm::vec3& v1, const glm::vec3& v2) {
 float Vec3::length(const glm::vec3& v) {
     return glm::length(v);
 }
+
+glm::vec3 Vec3::normalize(const glm::vec3& v) {
+    return glm::normalize(v);
+}
+
+void Vec3::print(const QString& lable, const glm::vec3& v) {
+    qDebug() << qPrintable(lable) << v.x << "," << v.y << "," << v.z;
+}

libraries/script-engine/src/Vec3.h

@@ -27,6 +27,8 @@ public slots:
     glm::vec3 sum(const glm::vec3& v1, const glm::vec3& v2);
     glm::vec3 subtract(const glm::vec3& v1, const glm::vec3& v2);
     float length(const glm::vec3& v);
+    glm::vec3 normalize(const glm::vec3& v);
+    void print(const QString& lable, const glm::vec3& v);
 };