add option to turn self-collision on/off

examples/SharedMemory/PhysicsClientC_API.cpp

@@ -386,6 +386,15 @@ B3_SHARED_API int b3LoadSoftBodySetCollisionHardness(b3SharedMemoryCommandHandle
 	return 0;
 }
 
+B3_SHARED_API int b3LoadSoftBodySetSelfCollision(b3SharedMemoryCommandHandle commandHandle, bool useSelfCollision)
+{
+	struct SharedMemoryCommand* command = (struct SharedMemoryCommand*)commandHandle;
+	b3Assert(command->m_type == CMD_LOAD_SOFT_BODY);
+        command->m_loadSoftBodyArguments.m_useSelfCollision = useSelfCollision;
+	command->m_updateFlags |= LOAD_SOFT_BODY_SET_SELF_COLLISION;
+	return 0;
+}
+
 B3_SHARED_API int b3LoadSoftBodySetFrictionCoefficient(b3SharedMemoryCommandHandle commandHandle, double frictionCoefficient)
 {
 	struct SharedMemoryCommand* command = (struct SharedMemoryCommand*)commandHandle;

examples/SharedMemory/PhysicsClientC_API.h

@@ -636,6 +636,7 @@ extern "C"
 	B3_SHARED_API int b3LoadSoftBodyAddMassSpringForce(b3SharedMemoryCommandHandle commandHandle, double springElasticStiffness , double springDampingStiffness);
 	B3_SHARED_API int b3LoadSoftBodyAddGravityForce(b3SharedMemoryCommandHandle commandHandle, double gravityX, double gravityY, double gravityZ);
 	B3_SHARED_API int b3LoadSoftBodySetCollisionHardness(b3SharedMemoryCommandHandle commandHandle, double collisionHardness);
+	B3_SHARED_API int b3LoadSoftBodySetSelfCollision(b3SharedMemoryCommandHandle commandHandle, bool useSelfCollision);
 	B3_SHARED_API int b3LoadSoftBodySetFrictionCoefficient(b3SharedMemoryCommandHandle commandHandle, double frictionCoefficient);
 	B3_SHARED_API int b3LoadSoftBodyUseBendingSprings(b3SharedMemoryCommandHandle commandHandle, int useBendingSprings);
 

examples/SharedMemory/PhysicsServerCommandProcessor.cpp

@@ -8144,6 +8144,12 @@ bool PhysicsServerCommandProcessor::processLoadSoftBodyCommand(const struct Shar
             psb->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
             psb->setCollisionFlags(0);
 	    psb->setTotalMass(mass);
+            bool use_self_collision = false;
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_USE_SELF_COLLISION)
+            {
+                    use_self_collision = loadSoftBodyArgs.m_useSelfCollision;
+            }
+            psb->setSelfCollision(use_self_collision);
 #else
 	    btSoftBody::Material* pm = psb->appendMaterial();
 	    pm->m_kLST = 0.5;

examples/SharedMemory/SharedMemoryCommands.h

@@ -501,6 +501,7 @@ enum EnumLoadSoftBodyUpdateFlags
         LOAD_SOFT_BODY_SET_FRICTION_COEFFICIENT = 1<<10,
         LOAD_SOFT_BODY_ADD_BENDING_SPRINGS = 1<<11,
         LOAD_SOFT_BODY_ADD_NEOHOOKEAN_FORCE = 1<<12,
+        LOAD_SOFT_BODY_SET_SELF_COLLISION = 1<<13,
 };
 
 enum EnumSimParamInternalSimFlags
@@ -525,6 +526,7 @@ struct LoadSoftBodyArgs
         double m_corotatedLambda;
         bool m_useBendingSprings;
         double m_collisionHardness;
+        double m_useSelfCollision;
         double m_frictionCoeff;
         double m_NeoHookeanMu;
         double m_NeoHookeanLambda;

src/BulletSoftBody/btSoftBody.cpp

@@ -3378,6 +3378,16 @@ btSoftBody::vsolver_t btSoftBody::getSolver(eVSolver::_ solver)
 	return (0);
 }
 
+void btSoftBody::setSelfCollision(bool useSelfCollision)
+{
+    m_useSelfCollision = useSelfCollision;
+}
+
+bool btSoftBody::useSelfCollision()
+{
+   return m_useSelfCollision;
+}
+
 //
 void btSoftBody::defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap)
 {
@@ -3563,16 +3573,19 @@ void btSoftBody::defaultCollisionHandler(btSoftBody* psb)
             }
             else
             {
-                btSoftColliders::CollideFF_DD docollide;
+                if (psb->useSelfCollision())
-                docollide.mrg = getCollisionShape()->getMargin() +
+                {
-                psb->getCollisionShape()->getMargin();
+                  btSoftColliders::CollideFF_DD docollide;
-                docollide.psb[0] = this;
+                  docollide.mrg = getCollisionShape()->getMargin() +
-                docollide.psb[1] = psb;
+                  psb->getCollisionShape()->getMargin();
-                /* psb0 faces vs psb0 faces    */
+                  docollide.psb[0] = this;
-                btDbvntNode* root = copyToDbvnt(this->m_fdbvt.m_root);
+                  docollide.psb[1] = psb;
-                calculateNormalCone(root);
+                  /* psb0 faces vs psb0 faces    */
-                this->m_fdbvt.selfCollideT(root,docollide);
+                  btDbvntNode* root = copyToDbvnt(this->m_fdbvt.m_root);
-                delete root;
+                  calculateNormalCone(root);
+                  this->m_fdbvt.selfCollideT(root,docollide);
+                  delete root;
+                }
                 
 //                btSoftColliders::CollideFF_DD docollide;
 //                /* common                    */

src/BulletSoftBody/btSoftBody.h

@@ -790,6 +790,7 @@ public:
     
     btAlignedObjectArray<btVector4> m_renderNodesInterpolationWeights;
     btAlignedObjectArray<btAlignedObjectArray<const btSoftBody::Node*> > m_renderNodesParents;
+    bool m_useSelfCollision;
 
 	btAlignedObjectArray<bool> m_clusterConnectivity;  //cluster connectivity, for self-collision
 
@@ -1006,6 +1007,8 @@ public:
 	/* defaultCollisionHandlers												*/
 	void defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap);
 	void defaultCollisionHandler(btSoftBody* psb);
+        void setSelfCollision(bool useSelfCollision);
+        bool useSelfCollision();
 
 	//
 	// Functionality to deal with new accelerated solvers.