Actually commit the changes this time!

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -1131,10 +1131,15 @@ void EntityTreeRenderer::playEntityCollisionSound(const QUuid& myNodeID, EntityT
     }
     const float mass = entity->computeMass();
     const float COLLISION_PENTRATION_TO_VELOCITY = 50; // as a subsitute for RELATIVE entity->getVelocity()
-    const float linearVelocity = glm::length(collision.penetration) * COLLISION_PENTRATION_TO_VELOCITY;
+    // The collision.penetration is a pretty good indicator of changed velocity AFTER the initial contact,
+    // but that first contact depends on exactly where we hit in the physics step.
+    // We can get a more consistent initial-contact energy reading by using the changed velocity.
+    const float linearVelocity = (collision.type == CONTACT_EVENT_TYPE_START) ?
+        glm::length(collision.velocityChange) :
+        glm::length(collision.penetration) * COLLISION_PENTRATION_TO_VELOCITY;
     const float energy = mass * linearVelocity * linearVelocity / 2.0f;
     const glm::vec3 position = collision.contactPoint;
-    const float COLLISION_ENERGY_AT_FULL_VOLUME = 0.5f;
+    const float COLLISION_ENERGY_AT_FULL_VOLUME = (collision.type == CONTACT_EVENT_TYPE_START) ? 10.0f : 0.5f;
     const float COLLISION_MINIMUM_VOLUME = 0.005f;
     const float energyFactorOfFull = fmin(1.0f, energy / COLLISION_ENERGY_AT_FULL_VOLUME);
     if (energyFactorOfFull < COLLISION_MINIMUM_VOLUME) {

libraries/physics/src/EntityMotionState.cpp

@@ -494,6 +494,7 @@ void EntityMotionState::measureBodyAcceleration() {
         float dt = ((float)numSubsteps * PHYSICS_ENGINE_FIXED_SUBSTEP);
         float invDt = 1.0f / dt;
         _lastMeasureStep = thisStep;
+        _measuredDeltaTime = dt;
 
         // Note: the integration equation for velocity uses damping:   v1 = (v0 + a * dt) * (1 - D)^dt
         // hence the equation for acceleration is: a = (v1 / (1 - D)^dt - v0) / dt
@@ -502,6 +503,12 @@ void EntityMotionState::measureBodyAcceleration() {
         _lastVelocity = velocity;
     }
 }
+glm::vec3 EntityMotionState::getObjectLinearVelocityChange() const {
+    // This is the dampened change in linear velocity, as calculated in measureBodyAcceleration: dv = a * dt
+    // It is generally only meaningful during the lifespan of collision. In particular, it is not meaningful
+    // when the entity first starts moving via direct user action.
+    return _measuredAcceleration * _measuredDeltaTime;
+}
 
 // virtual 
 void EntityMotionState::setMotionType(MotionType motionType) {

libraries/physics/src/EntityMotionState.h

@@ -64,6 +64,7 @@ public:
     virtual glm::vec3 getObjectLinearVelocity() const { return _entity->getVelocity(); }
     virtual glm::vec3 getObjectAngularVelocity() const { return _entity->getAngularVelocity(); }
     virtual glm::vec3 getObjectGravity() const { return _entity->getGravity(); }
+    virtual glm::vec3 getObjectLinearVelocityChange() const;
 
     virtual const QUuid& getObjectID() const { return _entity->getID(); }
 
@@ -101,6 +102,7 @@ protected:
     uint32_t _lastMeasureStep;
     glm::vec3 _lastVelocity;
     glm::vec3 _measuredAcceleration;
+    float _measuredDeltaTime;
 
     quint8 _accelerationNearlyGravityCount;
     bool _candidateForOwnership;

libraries/physics/src/ObjectMotionState.cpp

@@ -82,6 +82,9 @@ void ObjectMotionState::setBodyGravity(const glm::vec3& gravity) const {
 glm::vec3 ObjectMotionState::getBodyLinearVelocity() const {
     return bulletToGLM(_body->getLinearVelocity());
 }
+glm::vec3 ObjectMotionState::getObjectLinearVelocityChange() const {
+    return glm::vec3();  // Subclasses override where meaningful.
+}
 
 glm::vec3 ObjectMotionState::getBodyAngularVelocity() const {
     return bulletToGLM(_body->getAngularVelocity());

libraries/physics/src/ObjectMotionState.h

@@ -90,6 +90,7 @@ public:
 
     glm::vec3 getBodyLinearVelocity() const;
     glm::vec3 getBodyAngularVelocity() const;
+    virtual glm::vec3 getObjectLinearVelocityChange() const;
 
     virtual uint32_t getAndClearIncomingDirtyFlags() = 0;
 

libraries/physics/src/PhysicsEngine.cpp

@@ -317,6 +317,8 @@ CollisionEvents& PhysicsEngine::getCollisionEvents() {
         if(type != CONTACT_EVENT_TYPE_CONTINUE || _numSubsteps % CONTINUE_EVENT_FILTER_FREQUENCY == 0) {
             ObjectMotionState* A = static_cast<ObjectMotionState*>(contactItr->first._a);
             ObjectMotionState* B = static_cast<ObjectMotionState*>(contactItr->first._b);
+            glm::vec3 velocityChange = (A ? A->getObjectLinearVelocityChange() : glm::vec3(0.0f)) +
+                (B ? B->getObjectLinearVelocityChange() : glm::vec3(0.0f));
 
             if (A && A->getType() == MOTIONSTATE_TYPE_ENTITY) {
                 QUuid idA = A->getObjectID();
@@ -326,14 +328,14 @@ CollisionEvents& PhysicsEngine::getCollisionEvents() {
                 }
                 glm::vec3 position = bulletToGLM(contact.getPositionWorldOnB()) + _originOffset;
                 glm::vec3 penetration = bulletToGLM(contact.distance * contact.normalWorldOnB);
-                _collisionEvents.push_back(Collision(type, idA, idB, position, penetration));
+                _collisionEvents.push_back(Collision(type, idA, idB, position, penetration, velocityChange));
             } else if (B && B->getType() == MOTIONSTATE_TYPE_ENTITY) {
                 QUuid idB = B->getObjectID();
                 glm::vec3 position = bulletToGLM(contact.getPositionWorldOnA()) + _originOffset;
                 // NOTE: we're flipping the order of A and B (so that the first objectID is never NULL) 
                 // hence we must negate the penetration.
                 glm::vec3 penetration = - bulletToGLM(contact.distance * contact.normalWorldOnB);
-                _collisionEvents.push_back(Collision(type, idB, QUuid(), position, penetration));
+                _collisionEvents.push_back(Collision(type, idB, QUuid(), position, penetration, velocityChange));
             }
         }
 

libraries/shared/src/RegisteredMetaTypes.h

@@ -78,15 +78,17 @@ enum ContactEventType {
 
 class Collision {
 public:
-    Collision() : type(CONTACT_EVENT_TYPE_START), idA(), idB(), contactPoint(0.0f), penetration(0.0f) { }
-    Collision(ContactEventType cType, const QUuid& cIdA, const QUuid& cIdB, const glm::vec3& cPoint, const glm::vec3& cPenetration)
-        :   type(cType), idA(cIdA), idB(cIdB), contactPoint(cPoint), penetration(cPenetration) { }
+    Collision() : type(CONTACT_EVENT_TYPE_START), idA(), idB(), contactPoint(0.0f), penetration(0.0f), velocityChange(0.0f) { }
+    Collision(ContactEventType cType, const QUuid& cIdA, const QUuid& cIdB, const glm::vec3& cPoint,
+              const glm::vec3& cPenetration, const glm::vec3& velocityChange)
+    :   type(cType), idA(cIdA), idB(cIdB), contactPoint(cPoint), penetration(cPenetration), velocityChange(velocityChange) { }
 
     ContactEventType type;
     QUuid idA;
     QUuid idB;
     glm::vec3 contactPoint;
     glm::vec3 penetration;
+    glm::vec3 velocityChange;
 };
 Q_DECLARE_METATYPE(Collision)
 QScriptValue collisionToScriptValue(QScriptEngine* engine, const Collision& collision);