Merge remote-tracking branch 'bp/master'

2019-10-02 22:39:51 -07:00
parent b6e5609f90 3d87fb3b84
commit 9a6c6a3fb4
48 changed files with 7340 additions and 950 deletions
--- a/examples/DeformableDemo/ClothFriction.cpp
+++ b/examples/DeformableDemo/ClothFriction.cpp
@@ -0,0 +1,250 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#include "ClothFriction.h"
+///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
+#include "btBulletDynamicsCommon.h"
+#include "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h"
+#include "BulletSoftBody/btSoftBody.h"
+#include "BulletSoftBody/btSoftBodyHelpers.h"
+#include "BulletSoftBody/btDeformableBodySolver.h"
+#include "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include <stdio.h>  //printf debugging
+
+#include "../CommonInterfaces/CommonRigidBodyBase.h"
+#include "../Utils/b3ResourcePath.h"
+
+///The ClothFriction shows the use of deformable friction.
+class ClothFriction : public CommonRigidBodyBase
+{
+    btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
+public:
+    ClothFriction(struct GUIHelperInterface* helper)
+    : CommonRigidBodyBase(helper)
+    {
+    }
+    virtual ~ClothFriction()
+    {
+    }
+    void initPhysics();
+    
+    void exitPhysics();
+    
+    void resetCamera()
+    {
+        float dist = 12;
+        float pitch = -50;
+        float yaw = 120;
+        float targetPos[3] = {0, -3, 0};
+        m_guiHelper->resetCamera(dist, yaw, pitch, targetPos[0], targetPos[1], targetPos[2]);
+    }
+    
+    void stepSimulation(float deltaTime)
+    {
+        float internalTimeStep = 1. / 240.f;
+        m_dynamicsWorld->stepSimulation(deltaTime, 4, internalTimeStep);
+    }
+    
+    virtual const btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld() const
+    {
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld()
+    {
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual void renderScene()
+    {
+        CommonRigidBodyBase::renderScene();
+        btDeformableMultiBodyDynamicsWorld* deformableWorld = getDeformableDynamicsWorld();
+        
+        for (int i = 0; i < deformableWorld->getSoftBodyArray().size(); i++)
+        {
+            btSoftBody* psb = (btSoftBody*)deformableWorld->getSoftBodyArray()[i];
+            {
+                btSoftBodyHelpers::DrawFrame(psb, deformableWorld->getDebugDrawer());
+                btSoftBodyHelpers::Draw(psb, deformableWorld->getDebugDrawer(), deformableWorld->getDrawFlags());
+            }
+        }
+    }
+};
+
+void ClothFriction::initPhysics()
+{
+    m_guiHelper->setUpAxis(1);
+    
+    ///collision configuration contains default setup for memory, collision setup
+    m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration();
+    
+    ///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+    m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+    
+    m_broadphase = new btDbvtBroadphase();
+    btDeformableBodySolver* deformableBodySolver = new btDeformableBodySolver();
+    
+    ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+    btDeformableMultiBodyConstraintSolver* sol = new btDeformableMultiBodyConstraintSolver();
+    sol->setDeformableSolver(deformableBodySolver);
+    m_solver = sol;
+    
+    m_dynamicsWorld = new btDeformableMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, sol, m_collisionConfiguration, deformableBodySolver);
+    btVector3 gravity = btVector3(0, -10, 0);
+    m_dynamicsWorld->setGravity(gravity);
+    getDeformableDynamicsWorld()->getWorldInfo().m_gravity = gravity;
+    
+    m_guiHelper->createPhysicsDebugDrawer(m_dynamicsWorld);
+    
+    {
+        ///create a ground
+        btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(150), btScalar(25.), btScalar(150)));
+        
+        m_collisionShapes.push_back(groundShape);
+        
+        btTransform groundTransform;
+        groundTransform.setIdentity();
+        groundTransform.setOrigin(btVector3(0, -32, 0));
+        groundTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0.1));
+        //We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+        btScalar mass(0.);
+        
+        //rigidbody is dynamic if and only if mass is non zero, otherwise static
+        bool isDynamic = (mass != 0.f);
+        
+        btVector3 localInertia(0, 0, 0);
+        if (isDynamic)
+            groundShape->calculateLocalInertia(mass, localInertia);
+        
+        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass, myMotionState, groundShape, localInertia);
+        btRigidBody* body = new btRigidBody(rbInfo);
+        body->setFriction(3);
+        
+        //add the ground to the dynamics world
+        m_dynamicsWorld->addRigidBody(body);
+    }
+    
+    // create a piece of cloth
+    {
+        btScalar s = 4;
+        btScalar h = 0;
+        
+        btSoftBody* psb = btSoftBodyHelpers::CreatePatch(getDeformableDynamicsWorld()->getWorldInfo(), btVector3(-s, h, -s),
+                                                         btVector3(+s, h, -s),
+                                                         btVector3(-s, h, +s),
+                                                         btVector3(+s, h, +s),
+                                                         10,10,
+                                                         0, true);
+        
+        psb->getCollisionShape()->setMargin(0.05);
+        psb->generateBendingConstraints(2);
+        psb->setTotalMass(1);
+        psb->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb->m_cfg.kDF = 3;
+        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        getDeformableDynamicsWorld()->addSoftBody(psb);
+        
+        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(10,1, true);
+        getDeformableDynamicsWorld()->addForce(psb, mass_spring);
+        m_forces.push_back(mass_spring);
+        
+        btDeformableGravityForce* gravity_force =  new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
+        m_forces.push_back(gravity_force);
+        
+        
+        h = 2;
+        s = 2;
+        btSoftBody* psb2 = btSoftBodyHelpers::CreatePatch(getDeformableDynamicsWorld()->getWorldInfo(), btVector3(-s, h, -s),
+                                                          btVector3(+s, h, -s),
+                                                          btVector3(-s, h, +s),
+                                                          btVector3(+s, h, +s),
+                                                          5,5,
+                                                          0, true);
+        psb2->getCollisionShape()->setMargin(0.05);
+        psb2->generateBendingConstraints(2);
+        psb2->setTotalMass(1);
+        psb2->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb2->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb2->m_cfg.kDF = 20;
+        psb2->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb2->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        psb->translate(btVector3(0,0,0));
+        getDeformableDynamicsWorld()->addSoftBody(psb2);
+        
+        btDeformableMassSpringForce* mass_spring2 = new btDeformableMassSpringForce(10,1, true);
+        getDeformableDynamicsWorld()->addForce(psb2, mass_spring2);
+        m_forces.push_back(mass_spring2);
+        
+        btDeformableGravityForce* gravity_force2 =  new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb2, gravity_force2);
+        m_forces.push_back(gravity_force2);
+    }
+    getDeformableDynamicsWorld()->setImplicit(false);
+    m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
+}
+
+void ClothFriction::exitPhysics()
+{
+    //cleanup in the reverse order of creation/initialization
+    
+    //remove the rigidbodies from the dynamics world and delete them
+    int i;
+    for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+    {
+        btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+        btRigidBody* body = btRigidBody::upcast(obj);
+        if (body && body->getMotionState())
+        {
+            delete body->getMotionState();
+        }
+        m_dynamicsWorld->removeCollisionObject(obj);
+        delete obj;
+    }
+    // delete forces
+    for (int j = 0; j < m_forces.size(); j++)
+    {
+        btDeformableLagrangianForce* force = m_forces[j];
+        delete force;
+    }
+    m_forces.clear();
+    //delete collision shapes
+    for (int j = 0; j < m_collisionShapes.size(); j++)
+    {
+        btCollisionShape* shape = m_collisionShapes[j];
+        delete shape;
+    }
+    m_collisionShapes.clear();
+    
+    delete m_dynamicsWorld;
+    
+    delete m_solver;
+    
+    delete m_broadphase;
+    
+    delete m_dispatcher;
+    
+    delete m_collisionConfiguration;
+}
+
+class CommonExampleInterface* ClothFrictionCreateFunc(struct CommonExampleOptions& options)
+{
+    return new ClothFriction(options.m_guiHelper);
+}
+
+
--- a/examples/DeformableDemo/ClothFriction.h
+++ b/examples/DeformableDemo/ClothFriction.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef CLOTH_FRICTION_H
+#define CLOTH_FRICTION_H
+
+class CommonExampleInterface* ClothFrictionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //CLOTH_FRICTION_H
--- a/examples/DeformableDemo/DeformableContact.cpp
+++ b/examples/DeformableDemo/DeformableContact.cpp
@@ -0,0 +1,252 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#include "DeformableContact.h"
+///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
+#include "btBulletDynamicsCommon.h"
+#include "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h"
+#include "BulletSoftBody/btSoftBody.h"
+#include "BulletSoftBody/btSoftBodyHelpers.h"
+#include "BulletSoftBody/btDeformableBodySolver.h"
+#include "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include <stdio.h>  //printf debugging
+
+#include "../CommonInterfaces/CommonRigidBodyBase.h"
+#include "../Utils/b3ResourcePath.h"
+
+///The DeformableContact shows the contact between deformable objects
+
+class DeformableContact : public CommonRigidBodyBase
+{
+    btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
+public:
+    DeformableContact(struct GUIHelperInterface* helper)
+    : CommonRigidBodyBase(helper)
+    {
+    }
+    virtual ~DeformableContact()
+    {
+    }
+    void initPhysics();
+    
+    void exitPhysics();
+    
+    void resetCamera()
+    {
+        float dist = 12;
+        float pitch = -50;
+        float yaw = 120;
+        float targetPos[3] = {0, -3, 0};
+        m_guiHelper->resetCamera(dist, yaw, pitch, targetPos[0], targetPos[1], targetPos[2]);
+    }
+    
+    void stepSimulation(float deltaTime)
+    {
+        float internalTimeStep = 1. / 240.f;
+        m_dynamicsWorld->stepSimulation(deltaTime, 4, internalTimeStep);
+    }
+    
+    virtual const btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld() const
+    {
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld()
+    {
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual void renderScene()
+    {
+        CommonRigidBodyBase::renderScene();
+        btDeformableMultiBodyDynamicsWorld* deformableWorld = getDeformableDynamicsWorld();
+        
+        for (int i = 0; i < deformableWorld->getSoftBodyArray().size(); i++)
+        {
+            btSoftBody* psb = (btSoftBody*)deformableWorld->getSoftBodyArray()[i];
+            {
+                btSoftBodyHelpers::DrawFrame(psb, deformableWorld->getDebugDrawer());
+                btSoftBodyHelpers::Draw(psb, deformableWorld->getDebugDrawer(), deformableWorld->getDrawFlags());
+            }
+        }
+    }
+};
+
+void DeformableContact::initPhysics()
+{
+    m_guiHelper->setUpAxis(1);
+    
+    ///collision configuration contains default setup for memory, collision setup
+    m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration();
+    
+    ///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+    m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+    
+    m_broadphase = new btDbvtBroadphase();
+    btDeformableBodySolver* deformableBodySolver = new btDeformableBodySolver();
+    
+    ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+    btDeformableMultiBodyConstraintSolver* sol = new btDeformableMultiBodyConstraintSolver();
+    sol->setDeformableSolver(deformableBodySolver);
+    m_solver = sol;
+    
+    m_dynamicsWorld = new btDeformableMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, sol, m_collisionConfiguration, deformableBodySolver);
+    btVector3 gravity = btVector3(0, -10, 0);
+    m_dynamicsWorld->setGravity(gravity);
+    getDeformableDynamicsWorld()->getWorldInfo().m_gravity = gravity;
+    
+    m_guiHelper->createPhysicsDebugDrawer(m_dynamicsWorld);
+    
+    {
+        ///create a ground
+        btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(150), btScalar(25.), btScalar(150)));
+        
+        m_collisionShapes.push_back(groundShape);
+        
+        btTransform groundTransform;
+        groundTransform.setIdentity();
+        groundTransform.setOrigin(btVector3(0, -32, 0));
+        groundTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0.));
+        //We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+        btScalar mass(0.);
+        
+        //rigidbody is dynamic if and only if mass is non zero, otherwise static
+        bool isDynamic = (mass != 0.f);
+        
+        btVector3 localInertia(0, 0, 0);
+        if (isDynamic)
+            groundShape->calculateLocalInertia(mass, localInertia);
+        
+        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass, myMotionState, groundShape, localInertia);
+        btRigidBody* body = new btRigidBody(rbInfo);
+        body->setFriction(2);
+        
+        //add the ground to the dynamics world
+        m_dynamicsWorld->addRigidBody(body);
+    }
+    
+    // create a piece of cloth
+    {
+        btScalar s = 4;
+        btScalar h = 0;
+        
+        btSoftBody* psb = btSoftBodyHelpers::CreatePatch(getDeformableDynamicsWorld()->getWorldInfo(), btVector3(-s, h, -s),
+                                                         btVector3(+s, h, -s),
+                                                         btVector3(-s, h, +s),
+                                                         btVector3(+s, h, +s),
+                                                         20,20,
+                                                         1 + 2 + 4 + 8, true);
+        
+        psb->getCollisionShape()->setMargin(0.1);
+        psb->generateBendingConstraints(2);
+        psb->setTotalMass(1);
+        psb->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb->m_cfg.kDF = 0;
+        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        getDeformableDynamicsWorld()->addSoftBody(psb);
+        
+        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(10,1, true);
+        getDeformableDynamicsWorld()->addForce(psb, mass_spring);
+        m_forces.push_back(mass_spring);
+        
+        btDeformableGravityForce* gravity_force =  new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
+        m_forces.push_back(gravity_force);
+
+        
+        h = 2;
+        s = 2;
+        btSoftBody* psb2 = btSoftBodyHelpers::CreatePatch(getDeformableDynamicsWorld()->getWorldInfo(), btVector3(-s, h, -s),
+                                                          btVector3(+s, h, -s),
+                                                          btVector3(-s, h, +s),
+                                                          btVector3(+s, h, +s),
+                                                          10,10,
+                                                          0, true);
+        psb2->getCollisionShape()->setMargin(0.1);
+        psb2->generateBendingConstraints(2);
+        psb2->setTotalMass(1);
+        psb2->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb2->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb2->m_cfg.kDF = 0.1;
+        psb2->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb2->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        psb->translate(btVector3(3.5,0,0));
+        getDeformableDynamicsWorld()->addSoftBody(psb2);
+        
+        btDeformableMassSpringForce* mass_spring2 = new btDeformableMassSpringForce(10,1, true);
+        getDeformableDynamicsWorld()->addForce(psb2, mass_spring2);
+        m_forces.push_back(mass_spring2);
+        
+        btDeformableGravityForce* gravity_force2 =  new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb2, gravity_force2);
+        m_forces.push_back(gravity_force2);
+    }
+    getDeformableDynamicsWorld()->setImplicit(true);
+    getDeformableDynamicsWorld()->setLineSearch(false);
+    m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
+}
+
+void DeformableContact::exitPhysics()
+{
+    //cleanup in the reverse order of creation/initialization
+    
+    //remove the rigidbodies from the dynamics world and delete them
+    int i;
+    for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+    {
+        btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+        btRigidBody* body = btRigidBody::upcast(obj);
+        if (body && body->getMotionState())
+        {
+            delete body->getMotionState();
+        }
+        m_dynamicsWorld->removeCollisionObject(obj);
+        delete obj;
+    }
+    // delete forces
+    for (int j = 0; j < m_forces.size(); j++)
+    {
+        btDeformableLagrangianForce* force = m_forces[j];
+        delete force;
+    }
+    m_forces.clear();
+    //delete collision shapes
+    for (int j = 0; j < m_collisionShapes.size(); j++)
+    {
+        btCollisionShape* shape = m_collisionShapes[j];
+        delete shape;
+    }
+    m_collisionShapes.clear();
+    
+    delete m_dynamicsWorld;
+    
+    delete m_solver;
+    
+    delete m_broadphase;
+    
+    delete m_dispatcher;
+    
+    delete m_collisionConfiguration;
+}
+
+class CommonExampleInterface* DeformableContactCreateFunc(struct CommonExampleOptions& options)
+{
+    return new DeformableContact(options.m_guiHelper);
+}
+
+
--- a/examples/DeformableDemo/DeformableContact.h
+++ b/examples/DeformableDemo/DeformableContact.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef DEFORMABLE_CONTACT_H
+#define DEFORMABLE_CONTACT_H
+
+class CommonExampleInterface* DeformableContactCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_DEFORMABLE_CONTACT_H
--- a/examples/DeformableDemo/DeformableMultibody.cpp
+++ b/examples/DeformableDemo/DeformableMultibody.cpp
@@ -11,20 +11,6 @@
 3. This notice may not be removed or altered from any source distribution.
 */

-///create 125 (5x5x5) dynamic object
-#define ARRAY_SIZE_X 5
-#define ARRAY_SIZE_Y 5
-#define ARRAY_SIZE_Z 5
-
-//maximum number of objects (and allow user to shoot additional boxes)
-#define MAX_PROXIES (ARRAY_SIZE_X * ARRAY_SIZE_Y * ARRAY_SIZE_Z + 1024)
-
-///scaling of the objects (0.1 = 20 centimeter boxes )
-#define SCALING 1.
-#define START_POS_X -5
-#define START_POS_Y -5
-#define START_POS_Z -3
-
 #include "DeformableMultibody.h"
 ///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
 #include "btBulletDynamicsCommon.h"
@@ -235,7 +221,7 @@ void DeformableMultibody::initPhysics()
        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
        m_forces.push_back(gravity_force);
    }
-
+    getDeformableDynamicsWorld()->setImplicit(false);
 	m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
 }

@@ -360,26 +346,23 @@ void DeformableMultibody::addColliders_testMultiDof(btMultiBody* pMultiBody, btM
    local_origin[0] = pMultiBody->getBasePos();
    
    {
-        //    float pos[4]={local_origin[0].x(),local_origin[0].y(),local_origin[0].z(),1};
+
        btScalar quat[4] = {-world_to_local[0].x(), -world_to_local[0].y(), -world_to_local[0].z(), world_to_local[0].w()};
        
-        if (1)
-        {
-            btCollisionShape* box = new btBoxShape(baseHalfExtents);
-            btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(pMultiBody, -1);
-            col->setCollisionShape(box);
-            
-            btTransform tr;
-            tr.setIdentity();
-            tr.setOrigin(local_origin[0]);
-            tr.setRotation(btQuaternion(quat[0], quat[1], quat[2], quat[3]));
-            col->setWorldTransform(tr);
-            
-            pWorld->addCollisionObject(col, 2, 1 + 2);
-            
-            col->setFriction(friction);
-            pMultiBody->setBaseCollider(col);
-        }
+        btCollisionShape* box = new btBoxShape(baseHalfExtents);
+        btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(pMultiBody, -1);
+        col->setCollisionShape(box);
+        
+        btTransform tr;
+        tr.setIdentity();
+        tr.setOrigin(local_origin[0]);
+        tr.setRotation(btQuaternion(quat[0], quat[1], quat[2], quat[3]));
+        col->setWorldTransform(tr);
+        
+        pWorld->addCollisionObject(col, 2, 1 + 2);
+        
+        col->setFriction(friction);
+        pMultiBody->setBaseCollider(col);
    }
    
    for (int i = 0; i < pMultiBody->getNumLinks(); ++i)
@@ -392,7 +375,6 @@ void DeformableMultibody::addColliders_testMultiDof(btMultiBody* pMultiBody, btM
    for (int i = 0; i < pMultiBody->getNumLinks(); ++i)
    {
        btVector3 posr = local_origin[i + 1];
-        //    float pos[4]={posr.x(),posr.y(),posr.z(),1};
        
        btScalar quat[4] = {-world_to_local[i + 1].x(), -world_to_local[i + 1].y(), -world_to_local[i + 1].z(), world_to_local[i + 1].w()};
        
--- a/examples/DeformableDemo/DeformableRigid.cpp
+++ b/examples/DeformableDemo/DeformableRigid.cpp
@@ -10,21 +10,6 @@
 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
 3. This notice may not be removed or altered from any source distribution.
 */
-
-///create 125 (5x5x5) dynamic object
-#define ARRAY_SIZE_X 5
-#define ARRAY_SIZE_Y 5
-#define ARRAY_SIZE_Z 5
-
-//maximum number of objects (and allow user to shoot additional boxes)
-#define MAX_PROXIES (ARRAY_SIZE_X * ARRAY_SIZE_Y * ARRAY_SIZE_Z + 1024)
-
-///scaling of the objects (0.1 = 20 centimeter boxes )
-#define SCALING 1.
-#define START_POS_X -5
-#define START_POS_Y -5
-#define START_POS_Z -3
-
 #include "DeformableRigid.h"
 ///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
 #include "btBulletDynamicsCommon.h"
@@ -39,9 +24,7 @@
 #include "../CommonInterfaces/CommonRigidBodyBase.h"
 #include "../Utils/b3ResourcePath.h"

-///The DeformableRigid shows the use of rolling friction.
-///Spheres will come to a rest on a sloped plane using a constraint. Damping cannot achieve the same.
-///Generally it is best to leave the rolling friction coefficient zero (or close to zero).
+///The DeformableRigid shows contact between deformable objects and rigid objects.
 class DeformableRigid : public CommonRigidBodyBase
 {
    btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
@@ -238,7 +221,7 @@ void DeformableRigid::initPhysics()
        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
        getDeformableDynamicsWorld()->addSoftBody(psb);
        
-        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(2,0.1, true);
+        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(30,1, true);
        getDeformableDynamicsWorld()->addForce(psb, mass_spring);
        m_forces.push_back(mass_spring);
        
@@ -248,6 +231,8 @@ void DeformableRigid::initPhysics()
        // add a few rigid bodies
        Ctor_RbUpStack(1);
    }
+    getDeformableDynamicsWorld()->setImplicit(true);
+    getDeformableDynamicsWorld()->setLineSearch(false);
 	m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
 }

--- a/examples/DeformableDemo/DeformableSelfCollision.cpp
+++ b/examples/DeformableDemo/DeformableSelfCollision.cpp
@@ -0,0 +1,233 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+#include "DeformableSelfCollision.h"
+///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
+#include "btBulletDynamicsCommon.h"
+#include "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h"
+#include "BulletSoftBody/btSoftBody.h"
+#include "BulletSoftBody/btSoftBodyHelpers.h"
+#include "BulletSoftBody/btDeformableBodySolver.h"
+#include "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include <stdio.h>  //printf debugging
+
+#include "../CommonInterfaces/CommonRigidBodyBase.h"
+#include "../Utils/b3ResourcePath.h"
+
+///The DeformableSelfCollision shows deformable self collisions
+class DeformableSelfCollision : public CommonRigidBodyBase
+{
+    btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
+public:
+    DeformableSelfCollision(struct GUIHelperInterface* helper)
+    : CommonRigidBodyBase(helper)
+    {
+    }
+    virtual ~DeformableSelfCollision()
+    {
+    }
+    void initPhysics();
+    
+    void exitPhysics();
+    
+    void resetCamera()
+    {
+        float dist = 10;
+        float pitch = -8;
+        float yaw = 100;
+        float targetPos[3] = {0, -10, 0};
+        m_guiHelper->resetCamera(dist, yaw, pitch, targetPos[0], targetPos[1], targetPos[2]);
+    }
+    
+    void stepSimulation(float deltaTime)
+    {
+        float internalTimeStep = 1. / 240.f;
+        m_dynamicsWorld->stepSimulation(deltaTime, 4, internalTimeStep);
+    }
+    
+    virtual const btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld() const
+    {
+        ///just make it a btSoftRigidDynamicsWorld please
+        ///or we will add type checking
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld()
+    {
+        ///just make it a btSoftRigidDynamicsWorld please
+        ///or we will add type checking
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual void renderScene()
+    {
+        CommonRigidBodyBase::renderScene();
+        btDeformableMultiBodyDynamicsWorld* deformableWorld = getDeformableDynamicsWorld();
+        
+        for (int i = 0; i < deformableWorld->getSoftBodyArray().size(); i++)
+        {
+            btSoftBody* psb = (btSoftBody*)deformableWorld->getSoftBodyArray()[i];
+            {
+                btSoftBodyHelpers::DrawFrame(psb, deformableWorld->getDebugDrawer());
+                btSoftBodyHelpers::Draw(psb, deformableWorld->getDebugDrawer(), deformableWorld->getDrawFlags());
+            }
+        }
+    }
+};
+
+void DeformableSelfCollision::initPhysics()
+{
+    m_guiHelper->setUpAxis(1);
+    
+    ///collision configuration contains default setup for memory, collision setup
+    m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration();
+    
+    ///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+    m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+    
+    m_broadphase = new btDbvtBroadphase();
+    btDeformableBodySolver* deformableBodySolver = new btDeformableBodySolver();
+    
+    ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+    btDeformableMultiBodyConstraintSolver* sol = new btDeformableMultiBodyConstraintSolver();
+    sol->setDeformableSolver(deformableBodySolver);
+    m_solver = sol;
+    
+    m_dynamicsWorld = new btDeformableMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, sol, m_collisionConfiguration, deformableBodySolver);
+    //    deformableBodySolver->setWorld(getDeformableDynamicsWorld());
+    //    m_dynamicsWorld->getSolverInfo().m_singleAxisDeformableThreshold = 0.f;//faster but lower quality
+    btVector3 gravity = btVector3(0, -100, 0);
+    m_dynamicsWorld->setGravity(gravity);
+    getDeformableDynamicsWorld()->getWorldInfo().m_gravity = gravity;
+    
+    //    getDeformableDynamicsWorld()->before_solver_callbacks.push_back(dynamics);
+    m_guiHelper->createPhysicsDebugDrawer(m_dynamicsWorld);
+    
+    {
+        ///create a ground
+        btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(150.), btScalar(25.), btScalar(150.)));
+        
+        m_collisionShapes.push_back(groundShape);
+        
+        btTransform groundTransform;
+        groundTransform.setIdentity();
+        groundTransform.setOrigin(btVector3(0, -35, 0));
+        groundTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0));
+        //We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+        btScalar mass(0.);
+        
+        //rigidbody is dynamic if and only if mass is non zero, otherwise static
+        bool isDynamic = (mass != 0.f);
+        
+        btVector3 localInertia(0, 0, 0);
+        if (isDynamic)
+            groundShape->calculateLocalInertia(mass, localInertia);
+        
+        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass, myMotionState, groundShape, localInertia);
+        btRigidBody* body = new btRigidBody(rbInfo);
+        body->setFriction(40);
+        
+        //add the ground to the dynamics world
+        m_dynamicsWorld->addRigidBody(body);
+    }
+    
+    // create a piece of cloth
+    {
+        const btScalar s = 2;
+        const btScalar h = 0;
+        
+        btSoftBody* psb = btSoftBodyHelpers::CreatePatch(getDeformableDynamicsWorld()->getWorldInfo(), btVector3(-s, h, -4*s),
+                                                         btVector3(+s, h, -4*s),
+                                                         btVector3(-s, h, +4*s),
+                                                         btVector3(+s, h, +4*s),
+                                                         10,40,
+                                                         0, true, 0.01);
+
+        
+        psb->getCollisionShape()->setMargin(0.2);
+        psb->generateBendingConstraints(2);
+        psb->setTotalMass(1);
+        psb->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb->m_cfg.kDF = 0.2;
+        psb->rotate(btQuaternion(0,SIMD_PI / 2, 0));
+        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        getDeformableDynamicsWorld()->addSoftBody(psb);
+        
+        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(10,0.2, true);
+        getDeformableDynamicsWorld()->addForce(psb, mass_spring);
+        m_forces.push_back(mass_spring);
+        
+        btDeformableGravityForce* gravity_force =  new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
+        m_forces.push_back(gravity_force);
+    }
+    getDeformableDynamicsWorld()->setImplicit(true);
+    getDeformableDynamicsWorld()->setLineSearch(false);
+    m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
+}
+
+void DeformableSelfCollision::exitPhysics()
+{
+    //cleanup in the reverse order of creation/initialization
+    
+    //remove the rigidbodies from the dynamics world and delete them
+    int i;
+    for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+    {
+        btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+        btRigidBody* body = btRigidBody::upcast(obj);
+        if (body && body->getMotionState())
+        {
+            delete body->getMotionState();
+        }
+        m_dynamicsWorld->removeCollisionObject(obj);
+        delete obj;
+    }
+    // delete forces
+    for (int j = 0; j < m_forces.size(); j++)
+    {
+        btDeformableLagrangianForce* force = m_forces[j];
+        delete force;
+    }
+    m_forces.clear();
+    //delete collision shapes
+    for (int j = 0; j < m_collisionShapes.size(); j++)
+    {
+        btCollisionShape* shape = m_collisionShapes[j];
+        delete shape;
+    }
+    m_collisionShapes.clear();
+    
+    delete m_dynamicsWorld;
+    
+    delete m_solver;
+    
+    delete m_broadphase;
+    
+    delete m_dispatcher;
+    
+    delete m_collisionConfiguration;
+}
+
+
+
+class CommonExampleInterface* DeformableSelfCollisionCreateFunc(struct CommonExampleOptions& options)
+{
+    return new DeformableSelfCollision(options.m_guiHelper);
+}
+
+
--- a/examples/DeformableDemo/DeformableSelfCollision.h
+++ b/examples/DeformableDemo/DeformableSelfCollision.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef DEFORMABLE_SELF_COLLISION_H
+#define DEFORMABLE_SELF_COLLISION_H
+
+class CommonExampleInterface* DeformableSelfCollisionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_DEFORMABLE_SELF_COLLISION_H
--- a/examples/DeformableDemo/GraspDeformable.cpp
+++ b/examples/DeformableDemo/GraspDeformable.cpp
@@ -34,9 +34,7 @@
 #include "../CommonInterfaces/CommonFileIOInterface.h"
 #include "Bullet3Common/b3FileUtils.h"

-///The GraspDeformable shows the use of rolling friction.
-///Spheres will come to a rest on a sloped plane using a constraint. Damping cannot achieve the same.
-///Generally it is best to leave the rolling friction coefficient zero (or close to zero).
+///The GraspDeformable shows grasping a volumetric deformable objects with multibody gripper with moter constraints.
 static btScalar sGripperVerticalVelocity = 0.f;
 static btScalar sGripperClosingTargetVelocity = 0.f;
 static float friction = 1.;
@@ -103,11 +101,6 @@ public:
                    btMultiBodyJointMotor* motor = (btMultiBodyJointMotor*)mb->getLink(link).m_userPtr;
                    if (motor)
                    {
-//                        if (dofIndex == 10 || dofIndex == 11)
-//                        {
-//                            motor->setVelocityTarget(fingerTargetVelocities[1], 1);
-//                            motor->setMaxAppliedImpulse(1);
-//                        }
                        if (dofIndex == 6)
                        {
                            motor->setVelocityTarget(-fingerTargetVelocities[1], 1);
@@ -118,7 +111,6 @@ public:
                            motor->setVelocityTarget(fingerTargetVelocities[1], 1);
                            motor->setMaxAppliedImpulse(2);
                        }
-//                        motor->setRhsClamp(SIMD_INFINITY);
                        motor->setMaxAppliedImpulse(1);
                    }
                }
@@ -127,7 +119,7 @@ public:
        }
        
        //use a smaller internal timestep, there are stability issues
-        float internalTimeStep = 1. / 250.f;
+        float internalTimeStep = 1. / 240.f;
        m_dynamicsWorld->stepSimulation(deltaTime, 4, internalTimeStep);
    }
    
@@ -192,54 +184,11 @@ void GraspDeformable::initPhysics()
 	m_solver = sol;

 	m_dynamicsWorld = new btDeformableMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, sol, m_collisionConfiguration, deformableBodySolver);
-//    deformableBodySolver->setWorld(getDeformableDynamicsWorld());
    btVector3 gravity = btVector3(0, -9.81, 0);
 	m_dynamicsWorld->setGravity(gravity);
    getDeformableDynamicsWorld()->getWorldInfo().m_gravity = gravity;
 	m_guiHelper->createPhysicsDebugDrawer(m_dynamicsWorld);

-//    // load a gripper
-//    {
-//        btTransform rootTrans;
-//        rootTrans.setIdentity();
-//        BulletURDFImporter u2b(m_guiHelper,0,0,50,0);
-//        bool forceFixedBase = false;
-//        bool loadOk = u2b.loadSDF("gripper/wsg50_one_motor_gripper_new.sdf", forceFixedBase);
-//        if (loadOk)
-//        {
-//            for (int m = 0; m < u2b.getNumModels(); m++)
-//            {
-//                u2b.activateModel(m);
-//
-//                btMultiBody* mb = 0;
-//
-//                MyMultiBodyCreator creation(m_guiHelper);
-//
-//                u2b.getRootTransformInWorld(rootTrans);
-//                ConvertURDF2Bullet(u2b, creation, rootTrans, getDeformableDynamicsWorld(), true, u2b.getPathPrefix(), CUF_USE_SDF+CUF_RESERVED);
-//                mb = creation.getBulletMultiBody();
-//
-//                int numLinks = mb->getNumLinks();
-//                for (int i = 0; i < numLinks; i++)
-//                {
-//                    int mbLinkIndex = i;
-//                    float maxMotorImpulse = 1.f;
-//
-//                    if (supportsJointMotor(mb, mbLinkIndex))
-//                    {
-//                        int dof = 0;
-//                        btScalar desiredVelocity = 0.f;
-//                        btMultiBodyJointMotor* motor = new btMultiBodyJointMotor(mb, mbLinkIndex, dof, desiredVelocity, maxMotorImpulse);
-//                        motor->setPositionTarget(0, 0);
-//                        motor->setVelocityTarget(0, 1);
-//                        mb->getLink(mbLinkIndex).m_userPtr = motor;
-//                        getDeformableDynamicsWorld()->addMultiBodyConstraint(motor);
-//                        motor->finalizeMultiDof();
-//                    }
-//                }
-//            }
-//        }
-//    }
    // build a gripper
    {
        bool damping = true;
@@ -273,7 +222,6 @@ void GraspDeformable::initPhysics()
            }
        }
        
-        
        if (!damping)
        {
            mbC->setLinearDamping(0.0f);
@@ -287,10 +235,9 @@ void GraspDeformable::initPhysics()
        btScalar q0 = 0.f * SIMD_PI / 180.f;
        if (numLinks > 0)
            mbC->setJointPosMultiDof(0, &q0);
-        ///
        addColliders(mbC, getDeformableDynamicsWorld(), baseHalfExtents, linkHalfExtents);
-
    }
+    
    //create a ground
    {
        btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(150.), btScalar(25.), btScalar(150.)));
@@ -325,12 +272,13 @@ void GraspDeformable::initPhysics()
    {
        char relative_path[1024];
 //        b3FileUtils::findFile("banana.vtk", relative_path, 1024);
-        b3FileUtils::findFile("ball.vtk", relative_path, 1024);
+//        b3FileUtils::findFile("ball.vtk", relative_path, 1024);
+//        b3FileUtils::findFile("paper_collision.vtk", relative_path, 1024);
 //        b3FileUtils::findFile("single_tet.vtk", relative_path, 1024);
-//         b3FileUtils::findFile("tube.vtk", relative_path, 1024);
-//         b3FileUtils::findFile("torus.vtk", relative_path, 1024);
-//         b3FileUtils::findFile("paper_roll.vtk", relative_path, 1024);
-//         b3FileUtils::findFile("bread.vtk", relative_path, 1024);
+        b3FileUtils::findFile("tube.vtk", relative_path, 1024);
+//        b3FileUtils::findFile("torus.vtk", relative_path, 1024);
+//        b3FileUtils::findFile("paper_roll.vtk", relative_path, 1024);
+//        b3FileUtils::findFile("bread.vtk", relative_path, 1024);
 //        b3FileUtils::findFile("ditto.vtk", relative_path, 1024);
 //        b3FileUtils::findFile("boot.vtk", relative_path, 1024);
 //        btSoftBody* psb = btSoftBodyHelpers::CreateFromTetGenData(getDeformableDynamicsWorld()->getWorldInfo(),
@@ -341,27 +289,24 @@ void GraspDeformable::initPhysics()
        btSoftBody* psb = btSoftBodyHelpers::CreateFromVtkFile(getDeformableDynamicsWorld()->getWorldInfo(), relative_path);

 //        psb->scale(btVector3(30, 30, 30)); // for banana
-        psb->scale(btVector3(.25, .25, .25));
-//        psb->scale(btVector3(.3, .3, .3));  // for tube, torus, boot
-//        psb->scale(btVector3(1, 1, 1));  // for ditto
-        psb->translate(btVector3(.25, 0, 0.4)); 
-        psb->getCollisionShape()->setMargin(0.02);
-        psb->setTotalMass(.1);
+//        psb->scale(btVector3(.2, .2, .2));
+//        psb->scale(btVector3(2, 2, 2));
+        psb->scale(btVector3(.3, .3, .3));  // for tube, torus, boot
+//        psb->scale(btVector3(.1, .1, .1));  // for ditto
+//        psb->translate(btVector3(.25, 2, 0.4));
+        psb->getCollisionShape()->setMargin(0.01);
+        psb->setTotalMass(.01);
        psb->m_cfg.kKHR = 1; // collision hardness with kinematic objects
        psb->m_cfg.kCHR = 1; // collision hardness with rigid body
-        psb->m_cfg.kDF = 2;
+        psb->m_cfg.kDF = 20;
        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
        getDeformableDynamicsWorld()->addSoftBody(psb);
-        
-        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(.0,.04, true);
-        getDeformableDynamicsWorld()->addForce(psb, mass_spring);
-        m_forces.push_back(mass_spring);
-        
+
        btDeformableGravityForce* gravity_force =  new btDeformableGravityForce(gravity);
        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
        m_forces.push_back(gravity_force);
-        
-        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(5,10);
+
+        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(10,20, 0.01);
        getDeformableDynamicsWorld()->addForce(psb, neohookean);
        m_forces.push_back(neohookean);
    }
@@ -369,7 +314,7 @@ void GraspDeformable::initPhysics()
 //    // create a piece of cloth
 //    {
 //        bool onGround = false;
-//        const btScalar s = 4;
+//        const btScalar s = .4;
 //        btSoftBody* psb = btSoftBodyHelpers::CreatePatch(getDeformableDynamicsWorld()->getWorldInfo(), btVector3(-s, 0, -s),
 //                                                         btVector3(+s, 0, -s),
 //                                                         btVector3(-s, 0, +s),
@@ -386,17 +331,17 @@ void GraspDeformable::initPhysics()
 //                                                 2,2,
 //                                                 0, true);
 //
-//        psb->getCollisionShape()->setMargin(0.1);
+//        psb->getCollisionShape()->setMargin(0.02);
 //        psb->generateBendingConstraints(2);
-//        psb->setTotalMass(1);
-//        psb->setSpringStiffness(2);
-//        psb->setDampingCoefficient(0.03);
+//        psb->setTotalMass(.01);
+//        psb->setSpringStiffness(5);
+//        psb->setDampingCoefficient(0.05);
 //        psb->m_cfg.kKHR = 1; // collision hardness with kinematic objects
 //        psb->m_cfg.kCHR = 1; // collision hardness with rigid body
 //        psb->m_cfg.kDF = 1;
 //        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
 //        getDeformableDynamicsWorld()->addSoftBody(psb);
-//        getDeformableDynamicsWorld()->addForce(psb, new btDeformableMassSpringForce());
+//        getDeformableDynamicsWorld()->addForce(psb, new btDeformableMassSpringForce(.2,0.02, true));
 //        getDeformableDynamicsWorld()->addForce(psb, new btDeformableGravityForce(gravity));
 //    }
    
--- a/examples/DeformableDemo/Pinch.cpp
+++ b/examples/DeformableDemo/Pinch.cpp
@@ -11,20 +11,6 @@
 3. This notice may not be removed or altered from any source distribution.
 */

-///create 125 (5x5x5) dynamic object
-#define ARRAY_SIZE_X 5
-#define ARRAY_SIZE_Y 5
-#define ARRAY_SIZE_Z 5
-
-//maximum number of objects (and allow user to shoot additional boxes)
-#define MAX_PROXIES (ARRAY_SIZE_X * ARRAY_SIZE_Y * ARRAY_SIZE_Z + 1024)
-
-///scaling of the objects (0.1 = 20 centimeter boxes )
-#define SCALING 1.
-#define START_POS_X -5
-#define START_POS_Y -5
-#define START_POS_Z -3
-
 #include "Pinch.h"
 ///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
 #include "btBulletDynamicsCommon.h"
@@ -39,21 +25,13 @@
 #include "../CommonInterfaces/CommonRigidBodyBase.h"
 #include "../Utils/b3ResourcePath.h"

-///The Pinch shows the use of rolling friction.
-///Spheres will come to a rest on a sloped plane using a constraint. Damping cannot achieve the same.
-///Generally it is best to leave the rolling friction coefficient zero (or close to zero).
+///The Pinch shows the frictional contact between kinematic rigid objects with deformable objects

 struct TetraCube
 {
 #include "../SoftDemo/cube.inl"
 };

-struct TetraBunny
-{
-#include "../SoftDemo/bunny.inl"
-};
-
-
 class Pinch : public CommonRigidBodyBase
 {
    btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
@@ -351,6 +329,7 @@ void Pinch::initPhysics()
        // add a grippers
        createGrip();
    }
+    getDeformableDynamicsWorld()->setImplicit(false);
 	m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
 }

--- a/examples/DeformableDemo/PinchFriction.cpp
+++ b/examples/DeformableDemo/PinchFriction.cpp
@@ -0,0 +1,409 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+#include "PinchFriction.h"
+///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
+#include "btBulletDynamicsCommon.h"
+#include "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h"
+#include "BulletSoftBody/btSoftBody.h"
+#include "BulletSoftBody/btSoftBodyHelpers.h"
+#include "BulletSoftBody/btDeformableBodySolver.h"
+#include "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include <stdio.h>  //printf debugging
+
+#include "../CommonInterfaces/CommonRigidBodyBase.h"
+#include "../Utils/b3ResourcePath.h"
+
+///The PinchFriction shows the frictional contacts among volumetric deformable objects
+
+struct TetraCube
+{
+#include "../SoftDemo/cube.inl"
+};
+
+class PinchFriction : public CommonRigidBodyBase
+{
+    btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
+public:
+    PinchFriction(struct GUIHelperInterface* helper)
+    : CommonRigidBodyBase(helper)
+    {
+    }
+    virtual ~PinchFriction()
+    {
+    }
+    void initPhysics();
+    
+    void exitPhysics();
+    
+    void resetCamera()
+    {
+        float dist = 25;
+        float pitch = -30;
+        float yaw = 100;
+        float targetPos[3] = {0, -0, 0};
+        m_guiHelper->resetCamera(dist, yaw, pitch, targetPos[0], targetPos[1], targetPos[2]);
+    }
+    
+    void stepSimulation(float deltaTime)
+    {
+        //use a smaller internal timestep, there are stability issues
+        float internalTimeStep = 1. / 240.f;
+        m_dynamicsWorld->stepSimulation(deltaTime, 4, internalTimeStep);
+    }
+    
+    void createGrip()
+    {
+        int count = 2;
+        float mass = 1e6;
+        btCollisionShape* shape[] = {
+            new btBoxShape(btVector3(3, 3, 0.5)),
+        };
+        static const int nshapes = sizeof(shape) / sizeof(shape[0]);
+        for (int i = 0; i < count; ++i)
+        {
+            btTransform startTransform;
+            startTransform.setIdentity();
+            startTransform.setOrigin(btVector3(10, 0, 0));
+            startTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0.));
+            createRigidBody(mass, startTransform, shape[i % nshapes]);
+        }
+    }
+    
+    virtual const btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld() const
+    {
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld()
+    {
+        return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+    }
+    
+    virtual void renderScene()
+    {
+        CommonRigidBodyBase::renderScene();
+//        btDeformableMultiBodyDynamicsWorld* deformableWorld = getDeformableDynamicsWorld();
+//
+//        for (int i = 0; i < deformableWorld->getSoftBodyArray().size(); i++)
+//        {
+//            btSoftBody* psb = (btSoftBody*)deformableWorld->getSoftBodyArray()[i];
+//            {
+//                btSoftBodyHelpers::DrawFrame(psb, deformableWorld->getDebugDrawer());
+//                btSoftBodyHelpers::Draw(psb, deformableWorld->getDebugDrawer(), deformableWorld->getDrawFlags());
+//            }
+//        }
+    }
+};
+
+void dynamics2(btScalar time, btDeformableMultiBodyDynamicsWorld* world)
+{
+    btAlignedObjectArray<btRigidBody*>& rbs = world->getNonStaticRigidBodies();
+    if (rbs.size()<2)
+        return;
+    btRigidBody* rb0 = rbs[0];
+    btScalar pressTime = 0.9;
+    btScalar liftTime = 10;
+    btScalar shiftTime = 3.5;
+    btScalar holdTime = 4.5*1000;
+    btScalar dropTime = 5.3*1000;
+    btTransform rbTransform;
+    rbTransform.setIdentity();
+    btVector3 translation;
+    btVector3 velocity;
+    
+    btVector3 initialTranslationLeft = btVector3(0.5,3,4);
+    btVector3 initialTranslationRight = btVector3(0.5,3,-4);
+    btVector3 PinchFrictionVelocityLeft = btVector3(0,0,-1);
+    btVector3 PinchFrictionVelocityRight = btVector3(0,0,1);
+    btVector3 liftVelocity = btVector3(0,1,0);
+    btVector3 shiftVelocity = btVector3(0,0,0);
+    btVector3 holdVelocity = btVector3(0,0,0);
+    btVector3 openVelocityLeft = btVector3(0,0,4);
+    btVector3 openVelocityRight = btVector3(0,0,-4);
+    
+    if (time < pressTime)
+    {
+        velocity = PinchFrictionVelocityLeft;
+        translation = initialTranslationLeft + PinchFrictionVelocityLeft * time;
+    }
+    else if (time < liftTime)
+    {
+        velocity = liftVelocity;
+        translation = initialTranslationLeft + PinchFrictionVelocityLeft * pressTime + liftVelocity * (time - pressTime);
+        
+    }
+    else if (time < shiftTime)
+    {
+        velocity = shiftVelocity;
+        translation = initialTranslationLeft + PinchFrictionVelocityLeft * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (time - liftTime);
+    }
+    else if (time < holdTime)
+    {
+        velocity = btVector3(0,0,0);
+        translation = initialTranslationLeft + PinchFrictionVelocityLeft * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (shiftTime - liftTime) + holdVelocity * (time - shiftTime);
+    }
+    else if (time < dropTime)
+    {
+        velocity = openVelocityLeft;
+        translation = initialTranslationLeft + PinchFrictionVelocityLeft * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (shiftTime - liftTime) + holdVelocity * (holdTime - shiftTime)+ openVelocityLeft * (time - holdTime);
+    }
+    else
+    {
+        velocity = holdVelocity;
+        translation = initialTranslationLeft + PinchFrictionVelocityLeft * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (shiftTime - liftTime) + holdVelocity * (holdTime - shiftTime)+ openVelocityLeft * (dropTime - holdTime);
+    }
+    rbTransform.setOrigin(translation);
+    rbTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0));
+    rb0->setCenterOfMassTransform(rbTransform);
+    rb0->setAngularVelocity(btVector3(0,0,0));
+    rb0->setLinearVelocity(velocity);
+    
+    btRigidBody* rb1 = rbs[1];
+    if (time < pressTime)
+    {
+        velocity = PinchFrictionVelocityRight;
+        translation = initialTranslationRight + PinchFrictionVelocityRight * time;
+    }
+    else if (time < liftTime)
+    {
+        velocity = liftVelocity;
+        translation = initialTranslationRight + PinchFrictionVelocityRight * pressTime + liftVelocity * (time - pressTime);
+        
+    }
+    else if (time < shiftTime)
+    {
+        velocity = shiftVelocity;
+        translation = initialTranslationRight + PinchFrictionVelocityRight * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (time - liftTime);
+    }
+    else if (time < holdTime)
+    {
+        velocity = btVector3(0,0,0);
+        translation = initialTranslationRight + PinchFrictionVelocityRight * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (shiftTime - liftTime) + holdVelocity * (time - shiftTime);
+    }
+    else if (time < dropTime)
+    {
+        velocity = openVelocityRight;
+        translation = initialTranslationRight + PinchFrictionVelocityRight * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (shiftTime - liftTime) + holdVelocity * (holdTime - shiftTime)+ openVelocityRight * (time - holdTime);
+    }
+    else
+    {
+        velocity = holdVelocity;
+        translation = initialTranslationRight + PinchFrictionVelocityRight * pressTime + liftVelocity * (liftTime-pressTime) + shiftVelocity * (shiftTime - liftTime) + holdVelocity * (holdTime - shiftTime)+ openVelocityRight * (dropTime - holdTime);
+    }
+    rbTransform.setOrigin(translation);
+    rbTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0));
+    rb1->setCenterOfMassTransform(rbTransform);
+    rb1->setAngularVelocity(btVector3(0,0,0));
+    rb1->setLinearVelocity(velocity);
+    
+    rb0->setFriction(200);
+    rb1->setFriction(200);
+}
+
+void PinchFriction::initPhysics()
+{
+    m_guiHelper->setUpAxis(1);
+    
+    m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration();
+    
+    m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+    
+    m_broadphase = new btDbvtBroadphase();
+    btDeformableBodySolver* deformableBodySolver = new btDeformableBodySolver();
+    
+    btDeformableMultiBodyConstraintSolver* sol = new btDeformableMultiBodyConstraintSolver();
+    sol->setDeformableSolver(deformableBodySolver);
+    m_solver = sol;
+    
+    m_dynamicsWorld = new btDeformableMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, sol, m_collisionConfiguration, deformableBodySolver);
+    btVector3 gravity = btVector3(0, -10, 0);
+    m_dynamicsWorld->setGravity(gravity);
+    getDeformableDynamicsWorld()->getWorldInfo().m_gravity = gravity;
+    
+    getDeformableDynamicsWorld()->setSolverCallback(dynamics2);
+    m_guiHelper->createPhysicsDebugDrawer(m_dynamicsWorld);
+    
+    //create a ground
+    {
+        btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(150.), btScalar(25.), btScalar(150.)));
+        
+        m_collisionShapes.push_back(groundShape);
+        
+        btTransform groundTransform;
+        groundTransform.setIdentity();
+        groundTransform.setOrigin(btVector3(0, -25, 0));
+        groundTransform.setRotation(btQuaternion(btVector3(1, 0, 0), SIMD_PI * 0));
+        //We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+        btScalar mass(0.);
+        
+        //rigidbody is dynamic if and only if mass is non zero, otherwise static
+        bool isDynamic = (mass != 0.f);
+        
+        btVector3 localInertia(0, 0, 0);
+        if (isDynamic)
+            groundShape->calculateLocalInertia(mass, localInertia);
+        
+        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass, myMotionState, groundShape, localInertia);
+        btRigidBody* body = new btRigidBody(rbInfo);
+        body->setFriction(0);
+        
+        //add the ground to the dynamics world
+        m_dynamicsWorld->addRigidBody(body);
+    }
+    
+    // create a soft block
+    {
+        btSoftBody* psb = btSoftBodyHelpers::CreateFromTetGenData(getDeformableDynamicsWorld()->getWorldInfo(),
+                                                                  TetraCube::getElements(),
+                                                                  0,
+                                                                  TetraCube::getNodes(),
+                                                                  false, true, true);
+        
+        psb->scale(btVector3(2, 2, 1));
+        psb->translate(btVector3(0, 2.1, 2.2));
+        psb->getCollisionShape()->setMargin(0.1);
+        psb->setTotalMass(.6);
+        psb->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb->m_cfg.kDF = 20;
+        btSoftBodyHelpers::generateBoundaryFaces(psb);
+        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        getDeformableDynamicsWorld()->addSoftBody(psb);
+
+        btDeformableGravityForce* gravity_force = new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
+        m_forces.push_back(gravity_force);
+        
+        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(4,8,.1);
+        getDeformableDynamicsWorld()->addForce(psb, neohookean);
+        m_forces.push_back(neohookean);
+    }
+    
+    // create a second soft block
+    {
+        btSoftBody* psb2 = btSoftBodyHelpers::CreateFromTetGenData(getDeformableDynamicsWorld()->getWorldInfo(),
+                                                                  TetraCube::getElements(),
+                                                                  0,
+                                                                  TetraCube::getNodes(),
+                                                                  false, true, true);
+        
+        psb2->scale(btVector3(2, 2, 1));
+        psb2->translate(btVector3(0, 2.1, -2.2));
+        psb2->getCollisionShape()->setMargin(0.1);
+        psb2->setTotalMass(.6);
+        psb2->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb2->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb2->m_cfg.kDF = 20;
+        psb2->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb2->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        btSoftBodyHelpers::generateBoundaryFaces(psb2);
+        getDeformableDynamicsWorld()->addSoftBody(psb2);
+        
+        btDeformableGravityForce* gravity_force = new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb2, gravity_force);
+        m_forces.push_back(gravity_force);
+        
+        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(4,8,.1);
+        getDeformableDynamicsWorld()->addForce(psb2, neohookean);
+        m_forces.push_back(neohookean);
+    }
+    
+    // create a third soft block
+    {
+        btSoftBody* psb3 = btSoftBodyHelpers::CreateFromTetGenData(getDeformableDynamicsWorld()->getWorldInfo(),
+                                                                   TetraCube::getElements(),
+                                                                   0,
+                                                                   TetraCube::getNodes(),
+                                                                   false, true, true);
+        
+        psb3->scale(btVector3(2, 2, 1));
+        psb3->translate(btVector3(0, 2.1, 0));
+        psb3->getCollisionShape()->setMargin(0.1);
+        psb3->setTotalMass(.6);
+        psb3->m_cfg.kKHR = 1; // collision hardness with kinematic objects
+        psb3->m_cfg.kCHR = 1; // collision hardness with rigid body
+        psb3->m_cfg.kDF = 20;
+        psb3->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+        psb3->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+        btSoftBodyHelpers::generateBoundaryFaces(psb3);
+        getDeformableDynamicsWorld()->addSoftBody(psb3);
+        
+        btDeformableGravityForce* gravity_force = new btDeformableGravityForce(gravity);
+        getDeformableDynamicsWorld()->addForce(psb3, gravity_force);
+        m_forces.push_back(gravity_force);
+        
+        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(4,8,.1);
+        getDeformableDynamicsWorld()->addForce(psb3, neohookean);
+        m_forces.push_back(neohookean);
+    }
+    
+    // add a pair of grippers
+    createGrip();
+    m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
+}
+
+void PinchFriction::exitPhysics()
+{
+    //cleanup in the reverse order of creation/initialization
+    
+    //remove the rigidbodies from the dynamics world and delete them
+    int i;
+    for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+    {
+        btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+        btRigidBody* body = btRigidBody::upcast(obj);
+        if (body && body->getMotionState())
+        {
+            delete body->getMotionState();
+        }
+        m_dynamicsWorld->removeCollisionObject(obj);
+        delete obj;
+    }
+    // delete forces
+    for (int j = 0; j < m_forces.size(); j++)
+    {
+        btDeformableLagrangianForce* force = m_forces[j];
+        delete force;
+    }
+    m_forces.clear();
+    //delete collision shapes
+    for (int j = 0; j < m_collisionShapes.size(); j++)
+    {
+        btCollisionShape* shape = m_collisionShapes[j];
+        delete shape;
+    }
+    m_collisionShapes.clear();
+    
+    delete m_dynamicsWorld;
+    
+    delete m_solver;
+    
+    delete m_broadphase;
+    
+    delete m_dispatcher;
+    
+    delete m_collisionConfiguration;
+}
+
+
+
+class CommonExampleInterface* PinchFrictionCreateFunc(struct CommonExampleOptions& options)
+{
+    return new PinchFriction(options.m_guiHelper);
+}
+
+
--- a/examples/DeformableDemo/PinchFriction.h
+++ b/examples/DeformableDemo/PinchFriction.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _PINCH_FRICTION_H
+#define _PINCH_FRICTION_H
+
+class CommonExampleInterface* PinchFrictionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_PINCH_FRICTION_H
--- a/examples/DeformableDemo/VolumetricDeformable.cpp
+++ b/examples/DeformableDemo/VolumetricDeformable.cpp
@@ -11,20 +11,6 @@
 3. This notice may not be removed or altered from any source distribution.
 */

-///create 125 (5x5x5) dynamic object
-#define ARRAY_SIZE_X 5
-#define ARRAY_SIZE_Y 5
-#define ARRAY_SIZE_Z 5
-
-//maximum number of objects (and allow user to shoot additional boxes)
-#define MAX_PROXIES (ARRAY_SIZE_X * ARRAY_SIZE_Y * ARRAY_SIZE_Z + 1024)
-
-///scaling of the objects (0.1 = 20 centimeter boxes )
-#define SCALING 1.
-#define START_POS_X -5
-#define START_POS_Y -5
-#define START_POS_Z -3
-
 #include "VolumetricDeformable.h"
 ///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
 #include "btBulletDynamicsCommon.h"
@@ -39,10 +25,7 @@
 #include "../CommonInterfaces/CommonRigidBodyBase.h"
 #include "../Utils/b3ResourcePath.h"

-///The VolumetricDeformable shows the use of rolling friction.
-///Spheres will come to a rest on a sloped plane using a constraint. Damping cannot achieve the same.
-///Generally it is best to leave the rolling friction coefficient zero (or close to zero).
-
+///The VolumetricDeformable shows the contact between volumetric deformable objects and rigid objects.

 struct TetraCube
 {
@@ -108,7 +91,7 @@ public:
    
    void Ctor_RbUpStack(int count)
    {
-        float mass = 0.02;
+        float mass = 1;
        
        btCompoundShape* cylinderCompound = new btCompoundShape;
        btCollisionShape* cylinderShape = new btCylinderShapeX(btVector3(2, .5, .5));
@@ -183,7 +166,7 @@ void VolumetricDeformable::initPhysics()
 	m_solver = sol;

 	m_dynamicsWorld = new btDeformableMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, sol, m_collisionConfiguration, deformableBodySolver);
-    btVector3 gravity = btVector3(0, -10, 0);
+    btVector3 gravity = btVector3(0, -100, 0);
 	m_dynamicsWorld->setGravity(gravity);
    getDeformableDynamicsWorld()->getWorldInfo().m_gravity = gravity;
 	m_guiHelper->createPhysicsDebugDrawer(m_dynamicsWorld);
@@ -236,19 +219,17 @@ void VolumetricDeformable::initPhysics()
        psb->m_cfg.kDF = 0.5;
        psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
        
-        btDeformableMassSpringForce* mass_spring = new btDeformableMassSpringForce(0,0.03);
-        getDeformableDynamicsWorld()->addForce(psb, mass_spring);
-        m_forces.push_back(mass_spring);
-        
        btDeformableGravityForce* gravity_force =  new btDeformableGravityForce(gravity);
        getDeformableDynamicsWorld()->addForce(psb, gravity_force);
        m_forces.push_back(gravity_force);
        
-        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(.5,2.5);
+        btDeformableNeoHookeanForce* neohookean = new btDeformableNeoHookeanForce(30,100,0.02);
        getDeformableDynamicsWorld()->addForce(psb, neohookean);
        m_forces.push_back(neohookean);
        
    }
+    getDeformableDynamicsWorld()->setImplicit(true);
+    getDeformableDynamicsWorld()->setLineSearch(false);
    // add a few rigid bodies
    Ctor_RbUpStack(4); 
    
--- a/examples/ExampleBrowser/CMakeLists.txt
+++ b/examples/ExampleBrowser/CMakeLists.txt
@@ -353,10 +353,18 @@ SET(BulletExampleBrowser_SRCS
 ../MultiBody/MultiBodyConstraintFeedback.cpp
  ../SoftDemo/SoftDemo.cpp
  ../SoftDemo/SoftDemo.h
+  ../DeformableDemo/DeformableContact.cpp
+  ../DeformableDemo/DeformableContact.h
  ../DeformableDemo/GraspDeformable.cpp
  ../DeformableDemo/GraspDeformable.h
  ../DeformableDemo/Pinch.cpp
  ../DeformableDemo/Pinch.h
+  ../DeformableDemo/DeformableSelfCollision.cpp
+  ../DeformableDemo/DeformableSelfCollision.h
+  ../DeformableDemo/PinchFriction.cpp
+  ../DeformableDemo/PinchFriction.h
+  ../DeformableDemo/ClothFriction.cpp
+  ../DeformableDemo/ClothFriction.h
  ../DeformableDemo/DeformableMultibody.cpp
  ../DeformableDemo/DeformableMultibody.h
  ../DeformableDemo/DeformableRigid.cpp
--- a/examples/ExampleBrowser/ExampleEntries.cpp
+++ b/examples/ExampleBrowser/ExampleEntries.cpp
@@ -45,10 +45,14 @@
 #include "../DynamicControlDemo/MotorDemo.h"
 #include "../RollingFrictionDemo/RollingFrictionDemo.h"
 #include "../DeformableDemo/DeformableRigid.h"
+#include "../DeformableDemo/ClothFriction.h"
 #include "../DeformableDemo/Pinch.h"
+#include "../DeformableDemo/DeformableSelfCollision.h"
+#include "../DeformableDemo/PinchFriction.h"
 #include "../DeformableDemo/DeformableMultibody.h"
 #include "../DeformableDemo/VolumetricDeformable.h"
 #include "../DeformableDemo/GraspDeformable.h"
+#include "../DeformableDemo/DeformableContact.h"
 #include "../SharedMemory/PhysicsServerExampleBullet2.h"
 #include "../SharedMemory/PhysicsServerExample.h"
 #include "../SharedMemory/PhysicsClientExample.h"
@@ -186,6 +190,10 @@ static ExampleEntry gDefaultExamples[] =
 //ExampleEntry(1, "Spheres & Plane C-API (Bullet3)", "Collision C-API using Bullet 3.x backend", CollisionTutorialBullet2CreateFunc,TUT_SPHERE_PLANE_RTB3),

        ExampleEntry(0, "Deformabe Body"),
+        ExampleEntry(1, "Deformable Self Collision", "Deformable Self Collision", DeformableSelfCollisionCreateFunc),
+        ExampleEntry(1, "Deformable-Deformable Contact", "Deformable contact", DeformableContactCreateFunc),
+        ExampleEntry(1, "Cloth Friction", "Cloth friction contact", ClothFrictionCreateFunc),
+        ExampleEntry(1, "Deformable-Deformable Friction Contact", "Deformable friction contact", PinchFrictionCreateFunc),
        ExampleEntry(1, "Deformable-RigidBody Contact", "Deformable test", DeformableRigidCreateFunc),
        ExampleEntry(1, "Grasp Deformable Cube", "Grasping test", PinchCreateFunc),
        ExampleEntry(1, "Grasp Deformable with Motor", "Grasping test", GraspDeformableCreateFunc),
--- a/examples/SharedMemory/PhysicsClientC_API.cpp
+++ b/examples/SharedMemory/PhysicsClientC_API.cpp
@@ -376,7 +376,7 @@ B3_SHARED_API int b3LoadSoftBodyAddGravityForce(b3SharedMemoryCommandHandle comm
 	return 0;
 }

-B3_SHARED_API int b3LoadSoftBodySetCollsionHardness(b3SharedMemoryCommandHandle commandHandle, double collisionHardness)
+B3_SHARED_API int b3LoadSoftBodySetCollisionHardness(b3SharedMemoryCommandHandle commandHandle, double collisionHardness)
 {
 	struct SharedMemoryCommand* command = (struct SharedMemoryCommand*)commandHandle;
 	b3Assert(command->m_type == CMD_LOAD_SOFT_BODY);
--- a/examples/SharedMemory/PhysicsClientC_API.h
+++ b/examples/SharedMemory/PhysicsClientC_API.h
@@ -635,7 +635,7 @@ extern "C"
 	B3_SHARED_API int b3LoadSoftBodyAddNeoHookeanForce(b3SharedMemoryCommandHandle commandHandle, double NeoHookeanMu, double NeoHookeanLambda);
 	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 b3LoadSoftBodySetCollsionHardness(b3SharedMemoryCommandHandle commandHandle, double collisionHardness);
+	B3_SHARED_API int b3LoadSoftBodySetCollisionHardness(b3SharedMemoryCommandHandle commandHandle, double collisionHardness);
 	B3_SHARED_API int b3LoadSoftBodySetFrictionCoefficient(b3SharedMemoryCommandHandle commandHandle, double frictionCoefficient);
 	B3_SHARED_API int b3LoadSoftBodyUseBendingSprings(b3SharedMemoryCommandHandle commandHandle, int useBendingSprings);

--- a/examples/SharedMemory/PhysicsServerCommandProcessor.cpp
+++ b/examples/SharedMemory/PhysicsServerCommandProcessor.cpp
@@ -5055,15 +5055,24 @@ bool PhysicsServerCommandProcessor::processRequestMeshDataCommand(const struct S
 		{
 			btSoftBody* psb = bodyHandle->m_softBody;
 			int totalBytesPerVertex = sizeof(btVector3);
-			int numVertices = psb->m_nodes.size();
+            bool separateRenderMesh = (psb->m_renderNodes.size() != 0);
+            int numVertices = separateRenderMesh ? psb->m_renderNodes.size() : psb->m_nodes.size();
 			int maxNumVertices = bufferSizeInBytes / totalBytesPerVertex - 1;
 			int numVerticesRemaining = numVertices - clientCmd.m_requestMeshDataArgs.m_startingVertex;
 			int verticesCopied = btMin(maxNumVertices, numVerticesRemaining);
 			btVector3* verticesOut = (btVector3*)bufferServerToClient;
 			for (int i = 0; i < verticesCopied; ++i)
 			{
-				const btSoftBody::Node& n = psb->m_nodes[i + clientCmd.m_requestMeshDataArgs.m_startingVertex];
-				verticesOut[i] = n.m_x;
+                if (separateRenderMesh)
+                {
+                    const btSoftBody::Node& n = psb->m_renderNodes[i + clientCmd.m_requestMeshDataArgs.m_startingVertex];
+                    verticesOut[i] = n.m_x;
+                }
+                else
+                {
+                    const btSoftBody::Node& n = psb->m_nodes[i + clientCmd.m_requestMeshDataArgs.m_startingVertex];
+                    verticesOut[i] = n.m_x;
+                }
 			}

 			serverStatusOut.m_type = CMD_REQUEST_MESH_DATA_COMPLETED;
@@ -7989,200 +7998,230 @@ bool PhysicsServerCommandProcessor::processLoadSoftBodyCommand(const struct Shar
 	}

 	{
-		CommonFileIOInterface* fileIO(m_data->m_pluginManager.getFileIOInterface());
-		char relativeFileName[1024];
-		char pathPrefix[1024];
-		pathPrefix[0] = 0;
-		if (fileIO->findResourcePath(loadSoftBodyArgs.m_fileName, relativeFileName, 1024))
-		{
-			b3FileUtils::extractPath(relativeFileName, pathPrefix, 1024);
-		}
-		const std::string& error_message_prefix = "";
-		std::string out_found_filename;
-		int out_type=0;
+        btSoftBody* psb = NULL;
+        

-		bool foundFile = UrdfFindMeshFile(fileIO, pathPrefix, relativeFileName, error_message_prefix, &out_found_filename, &out_type);
-		btSoftBody* psb = NULL;
-		if (foundFile)
-		{
-		btScalar spring_elastic_stiffness, spring_damping_stiffness;
-		if (out_type == UrdfGeometry::FILE_OBJ)
-		{
-			std::vector<tinyobj::shape_t> shapes;
-			tinyobj::attrib_t attribute;
-			std::string err = tinyobj::LoadObj(attribute, shapes, out_found_filename.c_str(), "", fileIO);
-			if (!shapes.empty())
-			{
-				const tinyobj::shape_t& shape = shapes[0];
-				btAlignedObjectArray<btScalar> vertices;
-				btAlignedObjectArray<int> indices;
-				for (int i = 0; i < attribute.vertices.size(); i++)
-				{
-					vertices.push_back(attribute.vertices[i]);
-				}
-				for (int i = 0; i < shape.mesh.indices.size(); i++)
-				{
-					indices.push_back(shape.mesh.indices[i].vertex_index);
-				}
-				int numTris = shape.mesh.indices.size() / 3;
-				if (numTris > 0)
-				{
-					psb = btSoftBodyHelpers::CreateFromTriMesh(m_data->m_dynamicsWorld->getWorldInfo(), &vertices[0], &indices[0], numTris);
-				}
-			}
+	CommonFileIOInterface* fileIO(m_data->m_pluginManager.getFileIOInterface());
+	char relativeFileName[1024];
+	char pathPrefix[1024];
+	pathPrefix[0] = 0;
+	if (fileIO->findResourcePath(loadSoftBodyArgs.m_fileName, relativeFileName, 1024))
+	{
+		b3FileUtils::extractPath(relativeFileName, pathPrefix, 1024);
+	}
+
+        // add _sim.vtk postfix
+        char relativeSimFileName[1024];
+        char sim_file_ending[9] = "_sim.vtk";
+        strncpy(relativeSimFileName, relativeFileName, strlen(relativeFileName));
+        strncpy(relativeSimFileName + strlen(relativeFileName)-4, sim_file_ending, sizeof(sim_file_ending));
+
+	const std::string& error_message_prefix = "";
+	std::string out_found_filename;
+	std::string out_found_sim_filename;
+	int out_type, out_sim_type;
+
+        bool render_mesh_is_sim_mesh = true;
+
+	bool foundFile = UrdfFindMeshFile(fileIO, pathPrefix, relativeFileName, error_message_prefix, &out_found_filename, &out_type);
+        if (out_type == UrdfGeometry::FILE_OBJ)
+        {
+		    bool foundFile = UrdfFindMeshFile(fileIO, pathPrefix, relativeSimFileName, error_message_prefix, &out_found_sim_filename, &out_sim_type);
+            render_mesh_is_sim_mesh = !foundFile;
+        }
+
+        if (render_mesh_is_sim_mesh)
+        {
+            out_sim_type = out_type;
+            out_found_sim_filename = out_found_filename;
+        }
+        
+        if (out_sim_type == UrdfGeometry::FILE_OBJ)
+        {
+	    std::vector<tinyobj::shape_t> shapes;
+	    tinyobj::attrib_t attribute;
+	    std::string err = tinyobj::LoadObj(attribute, shapes, out_found_sim_filename.c_str(), "", fileIO);
+	    if (!shapes.empty())
+	    {
+            const tinyobj::shape_t& shape = shapes[0];
+            btAlignedObjectArray<btScalar> vertices;
+	    	btAlignedObjectArray<int> indices;
+	    	for (int i = 0; i < attribute.vertices.size(); i++)
+	    	{
+	    		vertices.push_back(attribute.vertices[i]);
+	    	}
+	    	for (int i = 0; i < shape.mesh.indices.size(); i++)
+	    	{
+	    		indices.push_back(shape.mesh.indices[i].vertex_index);
+	    	}
+	    	int numTris = shape.mesh.indices.size() / 3;
+	    	if (numTris > 0)
+            {
+                psb = btSoftBodyHelpers::CreateFromTriMesh(m_data->m_dynamicsWorld->getWorldInfo(), &vertices[0], &indices[0], numTris);
+            }
+        }
 #ifndef SKIP_DEFORMABLE_BODY
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_MASS_SPRING_FORCE)
-			{
-				spring_elastic_stiffness = clientCmd.m_loadSoftBodyArguments.m_springElasticStiffness;
-				spring_damping_stiffness = clientCmd.m_loadSoftBodyArguments.m_springDampingStiffness;
-				m_data->m_dynamicsWorld->addForce(psb, new btDeformableMassSpringForce(spring_elastic_stiffness, spring_damping_stiffness, false));
-			}
+        btScalar spring_elastic_stiffness, spring_damping_stiffness;
+	    if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_MASS_SPRING_FORCE)
+	    {
+            spring_elastic_stiffness = clientCmd.m_loadSoftBodyArguments.m_springElasticStiffness;
+            spring_damping_stiffness = clientCmd.m_loadSoftBodyArguments.m_springDampingStiffness;
+            m_data->m_dynamicsWorld->addForce(psb, new btDeformableMassSpringForce(spring_elastic_stiffness, spring_damping_stiffness, false));
+	    }
+#endif
+        }
+        else if (out_sim_type == UrdfGeometry::FILE_VTK)
+        {
+#ifndef SKIP_DEFORMABLE_BODY
+            psb = btSoftBodyHelpers::CreateFromVtkFile(m_data->m_dynamicsWorld->getWorldInfo(), out_found_sim_filename.c_str());
+            btScalar corotated_mu, corotated_lambda;
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_COROTATED_FORCE)
+            {
+                    corotated_mu = clientCmd.m_loadSoftBodyArguments.m_corotatedMu;
+                    corotated_lambda = clientCmd.m_loadSoftBodyArguments.m_corotatedLambda;
+                    m_data->m_dynamicsWorld->addForce(psb, new btDeformableCorotatedForce(corotated_mu, corotated_lambda));
+            }
+            btScalar neohookean_mu, neohookean_lambda;
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_NEOHOOKEAN_FORCE)
+            {
+                    neohookean_mu = clientCmd.m_loadSoftBodyArguments.m_NeoHookeanMu;
+                    neohookean_lambda = clientCmd.m_loadSoftBodyArguments.m_NeoHookeanLambda;
+                    m_data->m_dynamicsWorld->addForce(psb, new btDeformableNeoHookeanForce(neohookean_mu, neohookean_lambda));
+            }
+            btScalar spring_elastic_stiffness, spring_damping_stiffness;
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_MASS_SPRING_FORCE)
+            {
+                    spring_elastic_stiffness = clientCmd.m_loadSoftBodyArguments.m_springElasticStiffness;
+                    spring_damping_stiffness = clientCmd.m_loadSoftBodyArguments.m_springDampingStiffness;
+                    m_data->m_dynamicsWorld->addForce(psb, new btDeformableMassSpringForce(spring_elastic_stiffness, spring_damping_stiffness, true));
+            }
 #endif
 		}
-		else if (out_type == UrdfGeometry::FILE_VTK)
-		{
-#ifndef SKIP_DEFORMABLE_BODY
-			psb = btSoftBodyHelpers::CreateFromVtkFile(m_data->m_dynamicsWorld->getWorldInfo(), out_found_filename.c_str());
-			btScalar corotated_mu, corotated_lambda;
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_COROTATED_FORCE)
-			{
-				corotated_mu = clientCmd.m_loadSoftBodyArguments.m_corotatedMu;
-				corotated_lambda = clientCmd.m_loadSoftBodyArguments.m_corotatedLambda;
-				m_data->m_dynamicsWorld->addForce(psb, new btDeformableCorotatedForce(corotated_mu, corotated_lambda));
-			}
-			btScalar neohookean_mu, neohookean_lambda;
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_NEOHOOKEAN_FORCE)
-			{
-				neohookean_mu = clientCmd.m_loadSoftBodyArguments.m_NeoHookeanMu;
-				neohookean_lambda = clientCmd.m_loadSoftBodyArguments.m_NeoHookeanLambda;
-				m_data->m_dynamicsWorld->addForce(psb, new btDeformableNeoHookeanForce(neohookean_mu, neohookean_lambda));
-			}
-			btScalar spring_elastic_stiffness, spring_damping_stiffness;
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_MASS_SPRING_FORCE)
-			{
-				spring_elastic_stiffness = clientCmd.m_loadSoftBodyArguments.m_springElasticStiffness;
-				spring_damping_stiffness = clientCmd.m_loadSoftBodyArguments.m_springDampingStiffness;
-				m_data->m_dynamicsWorld->addForce(psb, new btDeformableMassSpringForce(spring_elastic_stiffness, spring_damping_stiffness, true));
-			}
-#endif
-		}
-		}
+		
 		if (psb != NULL)
 		{
 #ifndef SKIP_DEFORMABLE_BODY
-			btVector3 gravity = m_data->m_dynamicsWorld->getGravity();
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_GRAVITY_FORCE)
-			{
-				m_data->m_dynamicsWorld->addForce(psb, new btDeformableGravityForce(gravity));
-			}
-			btScalar collision_hardness = 1;
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_SET_COLLISION_HARDNESS)
-			{
-				collision_hardness = loadSoftBodyArgs.m_collisionHardness;
-			}
-			psb->m_cfg.kKHR = collision_hardness;
-			psb->m_cfg.kCHR = collision_hardness;
+            if (!render_mesh_is_sim_mesh)
+            {
+                // load render mesh
+                btSoftBodyHelpers::readRenderMeshFromObj(out_found_filename.c_str(), psb);
+                btSoftBodyHelpers::interpolateBarycentricWeights(psb);
+            }
+            else
+            {
+                psb->m_renderNodes.resize(0);
+            }
+            btVector3 gravity = m_data->m_dynamicsWorld->getGravity();
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_GRAVITY_FORCE)
+            {
+                    m_data->m_dynamicsWorld->addForce(psb, new btDeformableGravityForce(gravity));
+            }
+            btScalar collision_hardness = 1;
+            psb->m_cfg.kKHR = collision_hardness;
+            psb->m_cfg.kCHR = collision_hardness;

-			btScalar friction_coeff = 0;
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_SET_FRICTION_COEFFICIENT)
-			{
-				friction_coeff = loadSoftBodyArgs.m_frictionCoeff;
-			}
-			psb->m_cfg.kDF = friction_coeff;
+            btScalar friction_coeff = 0;
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_SET_FRICTION_COEFFICIENT)
+            {
+                    friction_coeff = loadSoftBodyArgs.m_frictionCoeff;
+            }
+            psb->m_cfg.kDF = friction_coeff;
+            
+            bool use_bending_spring = true;
+            if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_BENDING_SPRINGS)
+            {
+                    use_bending_spring = loadSoftBodyArgs.m_useBendingSprings;
+            }
+            btSoftBody::Material* pm = psb->appendMaterial();
+            pm->m_flags -= btSoftBody::fMaterial::DebugDraw;
+            if (use_bending_spring)
+            {
+                    psb->generateBendingConstraints(2,pm);
+            }

-			bool use_bending_spring = true;
-			if (clientCmd.m_updateFlags & LOAD_SOFT_BODY_ADD_BENDING_SPRINGS)
-			{
-				use_bending_spring = loadSoftBodyArgs.m_useBendingSprings;
-			}
-			btSoftBody::Material* pm = psb->appendMaterial();
-			pm->m_flags -= btSoftBody::fMaterial::DebugDraw;
-			if (use_bending_spring)
-			{
-				psb->generateBendingConstraints(2, pm);
-			}
-
-			// turn on the collision flag for deformable
-			// collision
-			psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
-			psb->setCollisionFlags(0);
-			psb->setTotalMass(mass);
+            // turn on the collision flag for deformable
+            // collision between deformable and rigid
+            psb->m_cfg.collisions = btSoftBody::fCollision::SDF_RD;
+            // collion between deformable and deformable and self-collision
+            psb->m_cfg.collisions |= btSoftBody::fCollision::VF_DD;
+            psb->setCollisionFlags(0);
+	    psb->setTotalMass(mass);
 #else
-			btSoftBody::Material* pm = psb->appendMaterial();
-			pm->m_kLST = 0.5;
-			pm->m_flags -= btSoftBody::fMaterial::DebugDraw;
-			psb->generateBendingConstraints(2, pm);
-			psb->m_cfg.piterations = 20;
-			psb->m_cfg.kDF = 0.5;
-			//turn on softbody vs softbody collision
-			psb->m_cfg.collisions |= btSoftBody::fCollision::VF_SS;
-			psb->randomizeConstraints();
-			psb->setTotalMass(mass, true);
+	    btSoftBody::Material* pm = psb->appendMaterial();
+	    pm->m_kLST = 0.5;
+	    pm->m_flags -= btSoftBody::fMaterial::DebugDraw;
+	    psb->generateBendingConstraints(2, pm);
+	    psb->m_cfg.piterations = 20;
+	    psb->m_cfg.kDF = 0.5;
+	    //turn on softbody vs softbody collision
+	    psb->m_cfg.collisions |= btSoftBody::fCollision::VF_SS;
+	    psb->randomizeConstraints();
+	    psb->setTotalMass(mass, true);
 #endif
-			psb->scale(btVector3(scale, scale, scale));
-			psb->rotate(initialOrn);
-			psb->translate(initialPos);
+	    psb->scale(btVector3(scale, scale, scale));
+	    psb->rotate(initialOrn);
+	    psb->translate(initialPos);

-			psb->getCollisionShape()->setMargin(collisionMargin);
-			psb->getCollisionShape()->setUserPointer(psb);
-			m_data->m_dynamicsWorld->addSoftBody(psb);
-			m_data->m_guiHelper->createCollisionShapeGraphicsObject(psb->getCollisionShape());
-			m_data->m_guiHelper->autogenerateGraphicsObjects(this->m_data->m_dynamicsWorld);
-			int bodyUniqueId = m_data->m_bodyHandles.allocHandle();
-			InternalBodyHandle* bodyHandle = m_data->m_bodyHandles.getHandle(bodyUniqueId);
-			bodyHandle->m_softBody = psb;
+	    psb->getCollisionShape()->setMargin(collisionMargin);
+	    psb->getCollisionShape()->setUserPointer(psb);
+	    m_data->m_dynamicsWorld->addSoftBody(psb);
+	    m_data->m_guiHelper->createCollisionShapeGraphicsObject(psb->getCollisionShape());
+	    m_data->m_guiHelper->autogenerateGraphicsObjects(this->m_data->m_dynamicsWorld);
+	    int bodyUniqueId = m_data->m_bodyHandles.allocHandle();
+	    InternalBodyHandle* bodyHandle = m_data->m_bodyHandles.getHandle(bodyUniqueId);
+	    bodyHandle->m_softBody = psb;

-			b3VisualShapeData visualShape;
+	    b3VisualShapeData visualShape;

-			visualShape.m_objectUniqueId = bodyUniqueId;
-			visualShape.m_linkIndex = -1;
-			visualShape.m_visualGeometryType = URDF_GEOM_MESH;
-			//dimensions just contains the scale
-			visualShape.m_dimensions[0] = scale;
-			visualShape.m_dimensions[1] = scale;
-			visualShape.m_dimensions[2] = scale;
-			//filename
-			strncpy(visualShape.m_meshAssetFileName, relativeFileName, VISUAL_SHAPE_MAX_PATH_LEN);
-			visualShape.m_meshAssetFileName[VISUAL_SHAPE_MAX_PATH_LEN - 1] = 0;
-			//position and orientation
-			visualShape.m_localVisualFrame[0] = initialPos[0];
-			visualShape.m_localVisualFrame[1] = initialPos[1];
-			visualShape.m_localVisualFrame[2] = initialPos[2];
-			visualShape.m_localVisualFrame[3] = initialOrn[0];
-			visualShape.m_localVisualFrame[4] = initialOrn[1];
-			visualShape.m_localVisualFrame[5] = initialOrn[2];
-			visualShape.m_localVisualFrame[6] = initialOrn[3];
-			//color and ids to be set by the renderer
-			visualShape.m_rgbaColor[0] = 0;
-			visualShape.m_rgbaColor[1] = 0;
-			visualShape.m_rgbaColor[2] = 0;
-			visualShape.m_rgbaColor[3] = 1;
-			visualShape.m_tinyRendererTextureId = -1;
-			visualShape.m_textureUniqueId = -1;
-			visualShape.m_openglTextureId = -1;
+	    visualShape.m_objectUniqueId = bodyUniqueId;
+	    visualShape.m_linkIndex = -1;
+	    visualShape.m_visualGeometryType = URDF_GEOM_MESH;
+	    //dimensions just contains the scale
+	    visualShape.m_dimensions[0] = scale;
+	    visualShape.m_dimensions[1] = scale;
+	    visualShape.m_dimensions[2] = scale;
+	    //filename
+	    strncpy(visualShape.m_meshAssetFileName, relativeFileName, VISUAL_SHAPE_MAX_PATH_LEN);
+	    visualShape.m_meshAssetFileName[VISUAL_SHAPE_MAX_PATH_LEN - 1] = 0;
+	    //position and orientation
+	    visualShape.m_localVisualFrame[0] = initialPos[0];
+	    visualShape.m_localVisualFrame[1] = initialPos[1];
+	    visualShape.m_localVisualFrame[2] = initialPos[2];
+	    visualShape.m_localVisualFrame[3] = initialOrn[0];
+	    visualShape.m_localVisualFrame[4] = initialOrn[1];
+	    visualShape.m_localVisualFrame[5] = initialOrn[2];
+	    visualShape.m_localVisualFrame[6] = initialOrn[3];
+	    //color and ids to be set by the renderer
+	    visualShape.m_rgbaColor[0] = 0;
+	    visualShape.m_rgbaColor[1] = 0;
+	    visualShape.m_rgbaColor[2] = 0;
+	    visualShape.m_rgbaColor[3] = 1;
+	    visualShape.m_tinyRendererTextureId = -1;
+	    visualShape.m_textureUniqueId  =-1;
+	    visualShape.m_openglTextureId = -1;

-			m_data->m_pluginManager.getRenderInterface()->addVisualShape(&visualShape, fileIO);
+	    m_data->m_pluginManager.getRenderInterface()->addVisualShape(&visualShape, fileIO);

-			serverStatusOut.m_loadSoftBodyResultArguments.m_objectUniqueId = bodyUniqueId;
-			serverStatusOut.m_type = CMD_LOAD_SOFT_BODY_COMPLETED;
+	    serverStatusOut.m_loadSoftBodyResultArguments.m_objectUniqueId = bodyUniqueId;
+	    serverStatusOut.m_type = CMD_LOAD_SOFT_BODY_COMPLETED;

-			int streamSizeInBytes = createBodyInfoStream(bodyUniqueId, bufferServerToClient, bufferSizeInBytes);
-			serverStatusOut.m_numDataStreamBytes = streamSizeInBytes;
+	    int streamSizeInBytes = createBodyInfoStream(bodyUniqueId, bufferServerToClient, bufferSizeInBytes);
+	    serverStatusOut.m_numDataStreamBytes = streamSizeInBytes;

 #ifdef ENABLE_LINK_MAPPER
-			if (m_data->m_urdfLinkNameMapper.size())
-			{
-				serverStatusOut.m_numDataStreamBytes = m_data->m_urdfLinkNameMapper.at(m_data->m_urdfLinkNameMapper.size() - 1)->m_memSerializer->getCurrentBufferSize();
-			}
+            if (m_data->m_urdfLinkNameMapper.size())
+            {
+              serverStatusOut.m_numDataStreamBytes = m_data->m_urdfLinkNameMapper.at(m_data->m_urdfLinkNameMapper.size() - 1)->m_memSerializer->getCurrentBufferSize();
+            }
 #endif
-			serverStatusOut.m_dataStreamArguments.m_bodyUniqueId = bodyUniqueId;
-			InternalBodyData* body = m_data->m_bodyHandles.getHandle(bodyUniqueId);
-			strcpy(serverStatusOut.m_dataStreamArguments.m_bodyName, body->m_bodyName.c_str());
+            serverStatusOut.m_dataStreamArguments.m_bodyUniqueId = bodyUniqueId;
+            InternalBodyData* body = m_data->m_bodyHandles.getHandle(bodyUniqueId);
+            strcpy(serverStatusOut.m_dataStreamArguments.m_bodyName, body->m_bodyName.c_str());

-			b3Notification notification;
-			notification.m_notificationType = BODY_ADDED;
-			notification.m_bodyArgs.m_bodyUniqueId = bodyUniqueId;
-			m_data->m_pluginManager.addNotification(notification);
+		    b3Notification notification;
+		    notification.m_notificationType = BODY_ADDED;
+		    notification.m_bodyArgs.m_bodyUniqueId = bodyUniqueId;
+		    m_data->m_pluginManager.addNotification(notification);
 		}
 	}
 #endif
@@ -8879,8 +8918,8 @@ bool PhysicsServerCommandProcessor::processGetDynamicsInfoCommand(const struct S
 	{
 		SharedMemoryStatus& serverCmd = serverStatusOut;
 		serverCmd.m_type = CMD_GET_DYNAMICS_INFO_COMPLETED;
-		serverCmd.m_dynamicsInfo.m_bodyType = BT_MULTI_BODY;
-
+                serverCmd.m_dynamicsInfo.m_bodyType = BT_MULTI_BODY;
+                
 		btMultiBody* mb = body->m_multiBody;
 		if (linkIndex == -1)
 		{
@@ -8994,7 +9033,7 @@ bool PhysicsServerCommandProcessor::processGetDynamicsInfoCommand(const struct S
 	{
 		SharedMemoryStatus& serverCmd = serverStatusOut;
 		serverCmd.m_type = CMD_GET_DYNAMICS_INFO_COMPLETED;
-		serverCmd.m_dynamicsInfo.m_bodyType = BT_RIGID_BODY;
+                serverCmd.m_dynamicsInfo.m_bodyType = BT_RIGID_BODY;

 		btRigidBody* rb = body->m_rigidBody;
 		serverCmd.m_dynamicsInfo.m_lateralFrictionCoeff = rb->getFriction();
@@ -9005,8 +9044,7 @@ bool PhysicsServerCommandProcessor::processGetDynamicsInfoCommand(const struct S
 		serverCmd.m_dynamicsInfo.m_mass = rb->getMass();
 	}
 #ifndef SKIP_SOFT_BODY_MULTI_BODY_DYNAMICS_WORLD
-	else if (body && body->m_softBody)
-	{
+	else if (body && body->m_softBody){
 		SharedMemoryStatus& serverCmd = serverStatusOut;
 		serverCmd.m_type = CMD_GET_DYNAMICS_INFO_COMPLETED;
 		serverCmd.m_dynamicsInfo.m_bodyType = BT_SOFT_BODY;
--- a/examples/pybullet/examples/load_soft_body.py
+++ b/examples/pybullet/examples/load_soft_body.py
@@ -5,6 +5,7 @@ physicsClient = p.connect(p.DIRECT)

 p.setGravity(0, 0, -10)
 planeId = p.loadURDF("plane.urdf")
+boxId = p.loadURDF("cube.urdf", useMaximalCoordinates = True)
 bunnyId = p.loadSoftBody("bunny.obj")
 #meshData = p.getMeshData(bunnyId)
 #print("meshData=",meshData)
@@ -14,6 +15,10 @@ useRealTimeSimulation = 1
 if (useRealTimeSimulation):
  p.setRealTimeSimulation(1)

+print(p.getDynamicsInfo(planeId, -1))
+print(p.getDynamicsInfo(bunnyId, 0))
+print(p.getDynamicsInfo(boxId, -1))
+
 while p.isConnected():
  p.setGravity(0, 0, -10)
  if (useRealTimeSimulation):