support disabling collisions btw adjacent joints

interface/src/avatar/SkeletonModel.cpp

@@ -594,10 +594,11 @@ void SkeletonModel::buildShapes() {
     // This method moves the shapes to their default positions in Model frame
     computeBoundingShape(geometry);
 
-    // while the shapes are in their default position we create the constraints
+    // while the shapes are in their default position...
+    disableSelfCollisions();
     buildRagdollConstraints();
 
-    // move shapes back to current joint positions
+    // ... then move shapes back to current joint positions
     moveShapesTowardJoints(1.0f);
 }
 
@@ -613,39 +614,6 @@ void SkeletonModel::moveShapesTowardJoints(float fraction) {
     }
 }
 
-/* TODO: Andrew to remove this when done with ragdoll work.
-void SkeletonModel::updateShapePositionsLegacy() {
-    if (_shapesAreDirty && _shapes.size() == _jointStates.size()) {
-        glm::vec3 rootPosition(0.0f);
-        _boundingRadius = 0.0f;
-        float uniformScale = extractUniformScale(_scale);
-        for (int i = 0; i < _jointStates.size(); i++) {
-            const JointState& state = _jointStates[i];
-            const FBXJoint& joint = state.getFBXJoint();
-            // shape position and rotation need to be in world-frame
-            glm::quat stateRotation = state.getRotation();
-            glm::vec3 shapeOffset = uniformScale * (stateRotation * joint.shapePosition);
-            glm::vec3 worldPosition = _translation + _rotation * (state.getPosition() + shapeOffset);
-            Shape* shape = _shapes[i];
-            if (shape) {
-                shape->setTranslation(worldPosition);
-                shape->setRotation(_rotation * stateRotation * joint.shapeRotation);
-                float distance = glm::distance(worldPosition, _translation) + shape->getBoundingRadius();
-                if (distance > _boundingRadius) {
-                    _boundingRadius = distance;
-                }
-            }
-            if (joint.parentIndex == -1) {
-                rootPosition = worldPosition;
-            }
-        }
-        _shapesAreDirty = false;
-        _boundingShape.setTranslation(rootPosition + _rotation * _boundingShapeLocalOffset);
-        _boundingShape.setRotation(_rotation);
-    }
-}
-*/
-
 void SkeletonModel::computeBoundingShape(const FBXGeometry& geometry) {
     // compute default joint transforms
     int numJoints = geometry.joints.size();

libraries/shared/src/PhysicsEntity.cpp

@@ -161,3 +161,69 @@ bool PhysicsEntity::findPlaneCollisions(const glm::vec4& plane, CollisionList& c
     }
     return collided;
 }
+
+// -----------------------------------------------------------
+// TODO: enforce this maximum when shapes are built.  The gotcha here is that
+// the Model class (derived from PhysicsEntity) expects numShapes == numJoints, 
+// so we have to modify that code to be safe.
+const int MAX_SHAPES_PER_ENTITY = 256;
+
+// the first 256 prime numbers
+const int primes[256] = {
+      2,    3,    5,    7,   11,   13,   17,   19,   23,   29,
+     31,   37,   41,   43,   47,   53,   59,   61,   67,   71,
+     73,   79,   83,   89,   97,  101,  103,  107,  109,  113,
+    127,  131,  137,  139,  149,  151,  157,  163,  167,  173,
+    179,  181,  191,  193,  197,  199,  211,  223,  227,  229,
+    233,  239,  241,  251,  257,  263,  269,  271,  277,  281,
+    283,  293,  307,  311,  313,  317,  331,  337,  347,  349,
+    353,  359,  367,  373,  379,  383,  389,  397,  401,  409,
+    419,  421,  431,  433,  439,  443,  449,  457,  461,  463,
+    467,  479,  487,  491,  499,  503,  509,  521,  523,  541,
+    547,  557,  563,  569,  571,  577,  587,  593,  599,  601,
+    607,  613,  617,  619,  631,  641,  643,  647,  653,  659,
+    661,  673,  677,  683,  691,  701,  709,  719,  727,  733,
+    739,  743,  751,  757,  761,  769,  773,  787,  797,  809,
+    811,  821,  823,  827,  829,  839,  853,  857,  859,  863,
+    877,  881,  883,  887,  907,  911,  919,  929,  937,  941,
+    947,  953,  967,  971,  977,  983,  991,  997, 1009, 1013,
+   1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
+   1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
+   1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
+   1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291,
+   1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373,
+   1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
+   1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
+   1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583,
+   1597, 1601, 1607, 1609, 1613, 1619 };
+
+void PhysicsEntity::disableCollisions(int shapeIndexA, int shapeIndexB) {
+    if (shapeIndexA < MAX_SHAPES_PER_ENTITY && shapeIndexB < MAX_SHAPES_PER_ENTITY) {
+        _disabledCollisions.insert(primes[shapeIndexA] * primes[shapeIndexB]);
+    }
+}
+
+bool PhysicsEntity::collisionsAreEnabled(int shapeIndexA, int shapeIndexB) const {
+    if (shapeIndexA < MAX_SHAPES_PER_ENTITY && shapeIndexB < MAX_SHAPES_PER_ENTITY) {
+        return !_disabledCollisions.contains(primes[shapeIndexA] * primes[shapeIndexB]);
+    }
+    return false;
+}
+
+void PhysicsEntity::disableSelfCollisions() {
+    CollisionList collisions(10);
+    int numShapes = _shapes.size();
+    for (int i = 0; i < numShapes; ++i) {
+        const Shape* shape = _shapes.at(i);
+        if (!shape) {
+            continue;
+        }
+        for (int j = i+1; j < numShapes; ++j) {
+            const Shape* otherShape = _shapes.at(j);
+            if (otherShape && ShapeCollider::collideShapes(shape, otherShape, collisions)) {
+                disableCollisions(i, j);
+                collisions.clear();
+            }
+        }
+    }
+}

libraries/shared/src/PhysicsEntity.h

@@ -13,6 +13,7 @@
 #define hifi_PhysicsEntity_h
 
 #include <QVector>
+#include <QSet>
 
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
@@ -54,6 +55,11 @@ public:
     bool findSphereCollisions(const glm::vec3& sphereCenter, float sphereRadius, CollisionList& collisions, int skipIndex);
     bool findPlaneCollisions(const glm::vec4& plane, CollisionList& collisions);
 
+    void disableCollisions(int shapeIndexA, int shapeIndexB);
+    bool collisionsAreEnabled(int shapeIndexA, int shapeIndexB) const;
+
+    void disableSelfCollisions();
+
 protected:
     glm::vec3 _translation;
     glm::quat _rotation;
@@ -61,6 +67,7 @@ protected:
     bool _shapesAreDirty;
     bool _enableShapes;
     QVector<Shape*> _shapes;
+    QSet<int> _disabledCollisions;
 
 private:
     // PhysicsSimulation is a friend so that it can set the protected _simulation backpointer

libraries/shared/src/PhysicsSimulation.cpp

@@ -135,7 +135,7 @@ void PhysicsSimulation::removeRagdoll(Ragdoll* doll) {
 // DONE (4) collisions move points (SpecialCapsuleShape would help solve this)
 // DONE (5) enforce constraints
 // DONE (6) make sure MyAvatar creates shapes, adds to simulation with ragdoll support
-// (7) support for pairwise collision bypass
+// DONE (7) support for pairwise collision bypass
 // (8) process collisions
 // (9) add and enforce angular contraints for joints
 void PhysicsSimulation::stepForward(float deltaTime, float minError, int maxIterations, quint64 maxUsec) {
@@ -162,7 +162,8 @@ void PhysicsSimulation::computeCollisions() {
     // TODO: keep track of QSet<PhysicsEntity*> collidedEntities;
     int numEntities = _entities.size();
     for (int i = 0; i < numEntities; ++i) {
-        const QVector<Shape*> shapes = _entities.at(i)->getShapes();
+        PhysicsEntity* entity = _entities.at(i);
+        const QVector<Shape*> shapes = entity->getShapes();
         int numShapes = shapes.size();
         // collide with self
         for (int j = 0; j < numShapes; ++j) {
@@ -170,10 +171,9 @@ void PhysicsSimulation::computeCollisions() {
             if (!shape) {
                 continue;
             }
-            // TODO: check for pairwise collision bypass here
             for (int k = j+1; k < numShapes; ++k) {
                 const Shape* otherShape = shapes.at(k);
-                if (otherShape) {
+                if (otherShape && entity->collisionsAreEnabled(j, k)) {
                     ShapeCollider::collideShapes(shape, otherShape, _collisionList);
                 }
             }