cleaup: remove some unused collision code

remove CollisionInfo::_type
remove unused Avatar collision response stuff
comment out some code that works but will probably be replaced

interface/src/avatar/Avatar.cpp

@@ -846,25 +846,6 @@ float Avatar::getHeadHeight() const {
     return DEFAULT_HEAD_HEIGHT;
 }
 
-bool Avatar::collisionWouldMoveAvatar(CollisionInfo& collision) const {
-    if (!collision._data || collision._type != COLLISION_TYPE_MODEL) {
-        return false;
-    }
-    Model* model = static_cast<Model*>(collision._data);
-    int jointIndex = collision._intData;
-
-    if (model == &(_skeletonModel) && jointIndex != -1) {
-        // collision response of skeleton is temporarily disabled
-        return false;
-        //return _skeletonModel.collisionHitsMoveableJoint(collision);
-    }
-    if (model == &(getHead()->getFaceModel())) {
-        // ATM we always handle COLLISION_TYPE_MODEL against the face.
-        return true;
-    }
-    return false;
-}
-
 float Avatar::getBoundingRadius() const {
     // TODO: also use head model when computing the avatar's bounding radius
     return _skeletonModel.getBoundingRadius();

interface/src/avatar/Avatar.h

@@ -132,9 +132,6 @@ public:
 
     static void renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2, float radius1, float radius2);
 
-    /// \return true if we expect the avatar would move as a result of the collision
-    bool collisionWouldMoveAvatar(CollisionInfo& collision) const;
-
     virtual void applyCollision(const glm::vec3& contactPoint, const glm::vec3& penetration) { }
 
     /// \return bounding radius of avatar

interface/src/avatar/MyAvatar.cpp

@@ -1461,17 +1461,10 @@ void MyAvatar::updateCollisionWithAvatars(float deltaTime) {
                 }
             }
 
-            // collide our hands against them
-            // TODO: make this work when we can figure out when the other avatar won't yeild
-            // (for example, we're colliding against their chest or leg)
-            //getHand()->collideAgainstAvatar(avatar, true);
-
             // collide their hands against us
             avatar->getHand()->collideAgainstAvatar(this, false);
         }
     }
-    // TODO: uncomment this when we handle collisions that won't affect other avatar
-    //getHand()->resolvePenetrations();
 }
 
 class SortedAvatar {

interface/src/renderer/Model.cpp

@@ -1049,7 +1049,6 @@ bool Model::findSphereCollisions(const glm::vec3& sphereCenter, float sphereRadi
         }
         if (ShapeCollider::collideShapes(&sphere, _jointShapes[i], collisions)) {
             CollisionInfo* collision = collisions.getLastCollision();
-            collision->_type = COLLISION_TYPE_MODEL;
             collision->_data = (void*)(this);
             collision->_intData = i;
             collided = true;
@@ -1065,7 +1064,6 @@ bool Model::findPlaneCollisions(const glm::vec4& plane, CollisionList& collision
     for (int i = 0; i < _jointShapes.size(); i++) {
         if (ShapeCollider::collideShapes(&planeShape, _jointShapes[i], collisions)) {
             CollisionInfo* collision = collisions.getLastCollision();
-            collision->_type = COLLISION_TYPE_MODEL;
             collision->_data = (void*)(this);
             collision->_intData = i;
             collided = true;
@@ -1446,55 +1444,6 @@ void Model::renderBoundingCollisionShapes(float alpha) {
     glPopMatrix();
 }
 
-bool Model::collisionHitsMoveableJoint(CollisionInfo& collision) const {
-    if (collision._type == COLLISION_TYPE_MODEL) {
-        // the joint is pokable by a collision if it exists and is free to move
-        const FBXJoint& joint = _geometry->getFBXGeometry().joints[collision._intData];
-        if (joint.parentIndex == -1 || _jointStates.isEmpty()) {
-            return false;
-        }
-        // an empty freeLineage means the joint can't move
-        const FBXGeometry& geometry = _geometry->getFBXGeometry();
-        int jointIndex = collision._intData;
-        const QVector<int>& freeLineage = geometry.joints.at(jointIndex).freeLineage;
-        return !freeLineage.isEmpty();
-    }
-    return false;
-}
-
-void Model::applyCollision(CollisionInfo& collision) {
-    if (collision._type != COLLISION_TYPE_MODEL) {
-        return;
-    }
-
-    glm::vec3 jointPosition(0.0f);
-    int jointIndex = collision._intData;
-    if (getJointPositionInWorldFrame(jointIndex, jointPosition)) {
-        const FBXJoint& joint = _geometry->getFBXGeometry().joints[jointIndex];
-        if (joint.parentIndex != -1) {
-            // compute the approximate distance (travel) that the joint needs to move
-            glm::vec3 start;
-            getJointPositionInWorldFrame(joint.parentIndex, start);
-            glm::vec3 contactPoint = collision._contactPoint - start;
-            glm::vec3 penetrationEnd = contactPoint + collision._penetration;
-            glm::vec3 axis = glm::cross(contactPoint, penetrationEnd);
-            float travel = glm::length(axis);
-            const float MIN_TRAVEL = 1.0e-8f;
-            if (travel > MIN_TRAVEL) {
-                // compute the new position of the joint
-                float angle = asinf(travel / (glm::length(contactPoint) * glm::length(penetrationEnd)));
-                axis = glm::normalize(axis);
-                glm::vec3 end;
-                getJointPositionInWorldFrame(jointIndex, end);
-                // transform into model-frame
-                glm::vec3 newEnd = glm::inverse(_rotation) * (start + glm::angleAxis(angle, axis) * (end - start) - _translation);
-                // try to move it
-                setJointPosition(jointIndex, newEnd, glm::quat(), false, -1, true);
-            }
-        }
-    }
-}
-
 void Model::setBlendedVertices(const QVector<glm::vec3>& vertices, const QVector<glm::vec3>& normals) {
     if (_blendedVertexBuffers.isEmpty()) {
         return;

interface/src/renderer/Model.h

@@ -156,14 +156,6 @@ public:
 
     bool findPlaneCollisions(const glm::vec4& plane, CollisionList& collisions);
     
-    /// \param collision details about the collisions
-    /// \return true if the collision is against a moveable joint
-    bool collisionHitsMoveableJoint(CollisionInfo& collision) const;
-
-    /// \param collision details about the collision
-    /// Use the collision to affect the model
-    void applyCollision(CollisionInfo& collision);
-
     float getBoundingRadius() const { return _boundingRadius; }
     float getBoundingShapeRadius() const { return _boundingShape.getRadius(); }
 

libraries/shared/src/CollisionInfo.cpp

@@ -43,7 +43,6 @@ void CollisionList::clear() {
     for (int i = 0; i < _size; ++i) {
         // we only clear the important stuff
         CollisionInfo& collision = _collisions[i];
-        collision._type = COLLISION_TYPE_UNKNOWN;
         //collision._data = NULL;
         //collision._intData = 0;
         //collision._floatDAta = 0.0f;

libraries/shared/src/CollisionInfo.h

@@ -17,16 +17,6 @@
 
 #include <QVector>
 
-enum CollisionType {
-    COLLISION_TYPE_UNKNOWN = 0,
-    COLLISION_TYPE_MODEL,
-        // _data = pointer to Model that owns joint
-        // _intData = joint index
-    COLLISION_TYPE_AACUBE,
-        // _floatData = cube side
-        // _vecData = cube center
-};
-
 const quint32 COLLISION_GROUP_ENVIRONMENT = 1U << 0;
 const quint32 COLLISION_GROUP_AVATARS     = 1U << 1;
 const quint32 COLLISION_GROUP_VOXELS      = 1U << 2;
@@ -41,8 +31,7 @@ const quint32 VALID_COLLISION_GROUPS = 0x0f;
 class CollisionInfo {
 public:
     CollisionInfo() 
-        : _type(0),
-        _data(NULL),
+        : _data(NULL),
         _intData(0),
         _damping(0.f),
         _elasticity(1.f),
@@ -52,8 +41,7 @@ public:
     }
 
     CollisionInfo(qint32 type)
-        : _type(type),
-        _data(NULL),
+        : _data(NULL),
         _intData(0),
         _damping(0.f),
         _elasticity(1.f),
@@ -64,8 +52,6 @@ public:
 
     ~CollisionInfo() {}
 
-    int _type;          // type of Collision
-
     // the value of the *Data fields depend on the type 
     void* _data;
     int _intData;       

libraries/shared/src/ShapeCollider.cpp

@@ -132,7 +132,6 @@ bool sphereSphere(const SphereShape* sphereA, const SphereShape* sphereB, Collis
         // penetration points from A into B
         CollisionInfo* collision = collisions.getNewCollision();
         if (collision) {
-            collision->_type = COLLISION_TYPE_UNKNOWN;
             collision->_penetration = BA * (totalRadius - distance);
             // contactPoint is on surface of A
             collision->_contactPoint = sphereA->getPosition() + sphereA->getRadius() * BA;
@@ -180,7 +179,6 @@ bool sphereCapsule(const SphereShape* sphereA, const CapsuleShape* capsuleB, Col
             collision->_penetration = (totalRadius - radialDistance) * radialAxis; // points from A into B
             // contactPoint is on surface of sphereA
             collision->_contactPoint = sphereA->getPosition() + sphereA->getRadius() * radialAxis;
-            collision->_type = COLLISION_TYPE_UNKNOWN;
         } else {
             // A is on B's axis, so the penetration is undefined... 
             if (absAxialDistance > capsuleB->getHalfHeight()) {
@@ -202,7 +200,6 @@ bool sphereCapsule(const SphereShape* sphereA, const CapsuleShape* capsuleB, Col
             collision->_penetration = (sign * (totalRadius + capsuleB->getHalfHeight() - absAxialDistance)) * capsuleAxis;
             // contactPoint is on surface of sphereA
             collision->_contactPoint = sphereA->getPosition() + (sign * sphereA->getRadius()) * capsuleAxis;
-            collision->_type = COLLISION_TYPE_UNKNOWN;
         }
         return true;
     }
@@ -218,7 +215,6 @@ bool spherePlane(const SphereShape* sphereA, const PlaneShape* planeB, Collision
         }
         collision->_penetration = penetration;
         collision->_contactPoint = sphereA->getPosition() + sphereA->getRadius() * glm::normalize(penetration);
-        collision->_type = COLLISION_TYPE_UNKNOWN;
         return true;
     }
     return false;
@@ -268,7 +264,6 @@ bool capsuleSphere(const CapsuleShape* capsuleA, const SphereShape* sphereB, Col
             collision->_penetration = (radialDistance - totalRadius) * radialAxis; // points from A into B
             // contactPoint is on surface of capsuleA
             collision->_contactPoint = closestApproach - capsuleA->getRadius() * radialAxis;
-            collision->_type = COLLISION_TYPE_UNKNOWN;
         } else {
             // A is on B's axis, so the penetration is undefined... 
             if (absAxialDistance > capsuleA->getHalfHeight()) {
@@ -289,7 +284,6 @@ bool capsuleSphere(const CapsuleShape* capsuleA, const SphereShape* sphereB, Col
                 collision->_penetration = (sign * (totalRadius + capsuleA->getHalfHeight() - absAxialDistance)) * capsuleAxis;
                 // contactPoint is on surface of sphereA
                 collision->_contactPoint = closestApproach + (sign * capsuleA->getRadius()) * capsuleAxis;
-                collision->_type = COLLISION_TYPE_UNKNOWN;
             }
         }
         return true;
@@ -361,7 +355,6 @@ bool capsuleCapsule(const CapsuleShape* capsuleA, const CapsuleShape* capsuleB,
             collision->_penetration = BA * (totalRadius - distance);
             // contactPoint is on surface of A
             collision->_contactPoint = centerA + distanceA * axisA + capsuleA->getRadius() * BA;
-            collision->_type = COLLISION_TYPE_UNKNOWN;
             return true;
         }
     } else {
@@ -427,7 +420,6 @@ bool capsuleCapsule(const CapsuleShape* capsuleA, const CapsuleShape* capsuleB,
             // average the internal pair, and then do the math from centerB
             collision->_contactPoint = centerB + (0.5f * (points[1] + points[2])) * axisB 
                 + (capsuleA->getRadius() - distance) * BA;
-            collision->_type = COLLISION_TYPE_UNKNOWN;
             return true;
         }
     }
@@ -447,7 +439,6 @@ bool capsulePlane(const CapsuleShape* capsuleA, const PlaneShape* planeB, Collis
         collision->_penetration = penetration;
         glm::vec3 deepestEnd = (glm::dot(start, glm::vec3(plane)) < glm::dot(end, glm::vec3(plane))) ? start : end;
         collision->_contactPoint = deepestEnd + capsuleA->getRadius() * glm::normalize(penetration);
-        collision->_type = COLLISION_TYPE_UNKNOWN;
         return true;
     }
     return false;
@@ -463,7 +454,6 @@ bool planeSphere(const PlaneShape* planeA, const SphereShape* sphereB, Collision
         collision->_penetration = -penetration;
         collision->_contactPoint = sphereB->getPosition() +
             (sphereB->getRadius() / glm::length(penetration) - 1.0f) * penetration;
-        collision->_type = COLLISION_TYPE_UNKNOWN;
         return true;
     }
     return false;
@@ -482,7 +472,6 @@ bool planeCapsule(const PlaneShape* planeA, const CapsuleShape* capsuleB, Collis
         collision->_penetration = -penetration;
         glm::vec3 deepestEnd = (glm::dot(start, glm::vec3(plane)) < glm::dot(end, glm::vec3(plane))) ? start : end;
         collision->_contactPoint = deepestEnd + (capsuleB->getRadius() / glm::length(penetration) - 1.0f) * penetration;
-        collision->_type = COLLISION_TYPE_UNKNOWN;
         return true;
     }
     return false;
@@ -668,13 +657,11 @@ bool sphereAACube(const glm::vec3& sphereCenter, float sphereRadius, const glm::
             direction /= lengthDirection;
 
             // compute collision details
-            collision->_type = COLLISION_TYPE_AACUBE;
             collision->_floatData = cubeSide;
             collision->_vecData = cubeCenter;
             collision->_penetration = (halfCubeSide * lengthDirection + sphereRadius - maxBA * glm::dot(BA, direction)) * direction;
             collision->_contactPoint = sphereCenter + sphereRadius * direction;
         }
-        collision->_type = COLLISION_TYPE_AACUBE;
         collision->_floatData = cubeSide;
         collision->_vecData = cubeCenter;
         return true;
@@ -688,7 +675,6 @@ bool sphereAACube(const glm::vec3& sphereCenter, float sphereRadius, const glm::
             // contactPoint is on surface of A
             collision->_contactPoint = sphereCenter + collision->_penetration;
 
-            collision->_type = COLLISION_TYPE_AACUBE;
             collision->_floatData = cubeSide;
             collision->_vecData = cubeCenter;
             return true;