btDeformableRigidWorld now inherits from btMultiBodyDynamicsWorld instead of btSoftRigidDynamicsWorld

src/BulletDynamics/Dynamics/btDynamicsWorld.h

@@ -35,7 +35,7 @@ enum btDynamicsWorldType
 	BT_SOFT_RIGID_DYNAMICS_WORLD = 4,
 	BT_GPU_DYNAMICS_WORLD = 5,
 	BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6,
-    BT_DEFORMABLE_RIGID_DYNAMICS_WORLD = 7
+    BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7
 };
 
 ///The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc.

src/BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h

@@ -47,7 +47,7 @@ protected:
 
 	virtual void calculateSimulationIslands();
 	virtual void updateActivationState(btScalar timeStep);
-	virtual void solveConstraints(btContactSolverInfo& solverInfo);
+	
 
 	virtual void serializeMultiBodies(btSerializer* serializer);
 
@@ -55,7 +55,8 @@ public:
 	btMultiBodyDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration);
 
 	virtual ~btMultiBodyDynamicsWorld();
-
+    
+    virtual void solveConstraints(btContactSolverInfo& solverInfo);
 	virtual void addMultiBody(btMultiBody* body, int group = btBroadphaseProxy::DefaultFilter, int mask = btBroadphaseProxy::AllFilter);
 
 	virtual void removeMultiBody(btMultiBody* body);

src/BulletSoftBody/btContactProjection.cpp

@@ -10,7 +10,7 @@
 void btContactProjection::update(const TVStack& dv, const TVStack& backupVelocity)
 {
     ///solve rigid body constraints
-    m_world->btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::solveConstraints(m_world->getSolverInfo());
+    m_world->btMultiBodyDynamicsWorld::solveConstraints(m_world->getSolverInfo());
 
     // loop through contacts to create contact constraints
     for (int i = 0; i < m_softBodies.size(); ++i)

src/BulletSoftBody/btDeformableBodySolver.cpp

@@ -8,6 +8,20 @@
 #include <stdio.h>
 #include "btDeformableBodySolver.h"
 
+btDeformableBodySolver::btDeformableBodySolver()
+: m_numNodes(0)
+, m_solveIterations(1)
+, m_impulseIterations(1)
+, m_world(nullptr)
+{
+    m_objective = new btBackwardEulerObjective(m_softBodySet, m_backupVelocity);
+}
+
+btDeformableBodySolver::~btDeformableBodySolver()
+{
+    delete m_objective;
+}
+
 void btDeformableBodySolver::postStabilize()
 {
     for (int i = 0; i < m_softBodySet.size(); ++i)

src/BulletSoftBody/btDeformableRigidDynamicsWorld.cpp

@@ -9,24 +9,11 @@
 #include "btDeformableRigidDynamicsWorld.h"
 #include "btDeformableBodySolver.h"
 
-btDeformableBodySolver::btDeformableBodySolver()
-: m_numNodes(0)
-, m_solveIterations(1)
-, m_impulseIterations(1)
-, m_world(nullptr)
-{
-    m_objective = new btBackwardEulerObjective(m_softBodySet, m_backupVelocity);
-}
-
-btDeformableBodySolver::~btDeformableBodySolver()
-{
-    delete m_objective;
-}
 
 void btDeformableRigidDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
 {
     // Let the solver grab the soft bodies and if necessary optimize for it
-    m_deformableBodySolver->optimize(getSoftDynamicsWorld()->getSoftBodyArray());
+    m_deformableBodySolver->optimize(m_softBodies);
     
     if (!m_deformableBodySolver->checkInitialized())
     {
@@ -42,22 +29,21 @@ void btDeformableRigidDynamicsWorld::internalSingleStepSimulation(btScalar timeS
     ///apply gravity, predict motion
     predictUnconstraintMotion(timeStep);
     
-    
+    btDispatcherInfo& dispatchInfo = btMultiBodyDynamicsWorld::getDispatchInfo();
-    btDispatcherInfo& dispatchInfo = btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::getDispatchInfo();
     
     dispatchInfo.m_timeStep = timeStep;
     dispatchInfo.m_stepCount = 0;
-    dispatchInfo.m_debugDraw = btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::getDebugDrawer();
+    dispatchInfo.m_debugDraw = btMultiBodyDynamicsWorld::getDebugDrawer();
     
     // only used in CCD
 //    createPredictiveContacts(timeStep);
     
     ///perform collision detection
-    btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::performDiscreteCollisionDetection();
+    btMultiBodyDynamicsWorld::performDiscreteCollisionDetection();
     
-    btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::calculateSimulationIslands();
+    btMultiBodyDynamicsWorld::calculateSimulationIslands();
     
-    btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::getSolverInfo().m_timeStep = timeStep;
+    btMultiBodyDynamicsWorld::getSolverInfo().m_timeStep = timeStep;
 
     if (0 != m_internalTickCallback)
     {
@@ -76,12 +62,12 @@ void btDeformableRigidDynamicsWorld::internalSingleStepSimulation(btScalar timeS
     solveDeformableBodiesConstraints(timeStep);
 
     //integrate transforms
-    btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::integrateTransforms(timeStep);
+    btMultiBodyDynamicsWorld::integrateTransforms(timeStep);
     
     ///update vehicle simulation
-    btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::updateActions(timeStep);
+    btMultiBodyDynamicsWorld::updateActions(timeStep);
     
-    btSoftRigidDynamicsWorld::btDiscreteDynamicsWorld::updateActivationState(timeStep);
+    btMultiBodyDynamicsWorld::updateActivationState(timeStep);
     
     ///update soft bodies
     m_deformableBodySolver->updateSoftBodies();
@@ -98,7 +84,7 @@ void btDeformableRigidDynamicsWorld::solveDeformableBodiesConstraints(btScalar t
 
 void btDeformableRigidDynamicsWorld::addSoftBody(btSoftBody* body, int collisionFilterGroup, int collisionFilterMask)
 {
-    getSoftDynamicsWorld()->getSoftBodyArray().push_back(body);
+    m_softBodies.push_back(body);
     
     // Set the soft body solver that will deal with this body
     // to be the world's solver

src/BulletSoftBody/btDeformableRigidDynamicsWorld.h

@@ -16,50 +16,76 @@
 #ifndef BT_DEFORMABLE_RIGID_DYNAMICS_WORLD_H
 #define BT_DEFORMABLE_RIGID_DYNAMICS_WORLD_H
 
-#include "btSoftRigidDynamicsWorld.h"
+#include "btSoftMultiBodyDynamicsWorld.h"
 #include "btLagrangianForce.h"
 #include "btMassSpring.h"
 #include "btDeformableBodySolver.h"
+#include "btSoftBodyHelpers.h"
+
 typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
 
 class btDeformableBodySolver;
 class btLagrangianForce;
+typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
 
-class btDeformableRigidDynamicsWorld : public btSoftRigidDynamicsWorld
+class btDeformableRigidDynamicsWorld : public btMultiBodyDynamicsWorld
 {
     using TVStack = btAlignedObjectArray<btVector3>;
     ///Solver classes that encapsulate multiple deformable bodies for solving
     btDeformableBodySolver* m_deformableBodySolver;
-
+    btSoftBodyArray m_softBodies;
+    int m_drawFlags;
+    bool m_drawNodeTree;
+    bool m_drawFaceTree;
+    bool m_drawClusterTree;
+    btSoftBodyWorldInfo m_sbi;
+    bool m_ownsSolver;
+    
 protected:
     virtual void internalSingleStepSimulation(btScalar timeStep);
     
     void solveDeformableBodiesConstraints(btScalar timeStep);
     
 public:
-    btDeformableRigidDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btDeformableBodySolver* deformableBodySolver = 0)
+    btDeformableRigidDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btDeformableBodySolver* deformableBodySolver = 0)
-    : btSoftRigidDynamicsWorld(dispatcher, pairCache, constraintSolver, collisionConfiguration, 0),
+    : btMultiBodyDynamicsWorld(dispatcher, pairCache, constraintSolver, collisionConfiguration),
     m_deformableBodySolver(deformableBodySolver)
     {
+        m_drawFlags = fDrawFlags::Std;
+        m_drawNodeTree = true;
+        m_drawFaceTree = false;
+        m_drawClusterTree = false;
+        m_sbi.m_broadphase = pairCache;
+        m_sbi.m_dispatcher = dispatcher;
+        m_sbi.m_sparsesdf.Initialize();
+        m_sbi.m_sparsesdf.Reset();
+        
+        m_sbi.air_density = (btScalar)1.2;
+        m_sbi.water_density = 0;
+        m_sbi.water_offset = 0;
+        m_sbi.water_normal = btVector3(0, 0, 0);
+        m_sbi.m_gravity.setValue(0, -10, 0);
+        
+        m_sbi.m_sparsesdf.Initialize();
     }
     
     virtual ~btDeformableRigidDynamicsWorld()
     {
     }
     
-    virtual btSoftRigidDynamicsWorld* getSoftDynamicsWorld()
+    virtual btMultiBodyDynamicsWorld* getMultiBodyDynamicsWorld()
     {
-        return (btSoftRigidDynamicsWorld*)(this);
+        return (btMultiBodyDynamicsWorld*)(this);
     }
     
-    virtual const btSoftRigidDynamicsWorld* getSoftDynamicsWorld() const
+    virtual const btMultiBodyDynamicsWorld* getMultiBodyDynamicsWorld() const
     {
-        return (const btSoftRigidDynamicsWorld*)(this);
+        return (const btMultiBodyDynamicsWorld*)(this);
     }
     
     virtual btDynamicsWorldType getWorldType() const
     {
-        return BT_DEFORMABLE_RIGID_DYNAMICS_WORLD;
+        return BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD;
     }
     
     virtual void predictUnconstraintMotion(btScalar timeStep);
@@ -68,6 +94,27 @@ public:
     // virtual void solveDeformableBodiesConstraints(btScalar timeStep);
     
     virtual void addSoftBody(btSoftBody* body, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
+    
+    btSoftBodyArray& getSoftBodyArray()
+    {
+        return m_softBodies;
+    }
+    
+    const btSoftBodyArray& getSoftBodyArray() const
+    {
+        return m_softBodies;
+    }
+    
+    btSoftBodyWorldInfo& getWorldInfo()
+    {
+        return m_sbi;
+    }
+    const btSoftBodyWorldInfo& getWorldInfo() const
+    {
+        return m_sbi;
+    }
+    int getDrawFlags() const { return (m_drawFlags); }
+    void setDrawFlags(int f) { m_drawFlags = f; }
 };
 
 #endif  //BT_DEFORMABLE_RIGID_DYNAMICS_WORLD_H