enable -noaudio option, so it actually works (and doesn't get overwritten by a game flag). audio initialization delays startup of game engine 2 seconds

add -nojoystick commandline option: it takes 5 seconds everytime to start the game engine, while there IS no joystick.

In other words: blender -noaudio -nojoystick improves workflow turnaround times for P - ESC from 7 seconds to 1 second!

Improved Bullet soft body advanced options, still work-in-progress. Make sure to create game Bullet soft bodies from scratch, it is not compatible with last weeks builds.

8 files changed, 290 insertions, 68 deletions

diff --git a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
index cc141249561..0d58810e156 100644
--- a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
+++ b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
@@ -170,6 +170,13 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
 		NG_NetworkDeviceInterface* networkdevice = new
 			NG_LoopBackNetworkDeviceInterface();
 		
+		//
+		SYS_SystemHandle hSystem = SYS_GetSystem();
+		bool noaudio = SYS_GetCommandLineInt(hSystem,"noaudio",0);
+
+		if (noaudio)/*(noaudio) intrr: disable game engine audio (openal) */
+			SND_DeviceManager::SetDeviceType(snd_e_dummydevice);
+
 		// get an audiodevice
 		SND_DeviceManager::Subscribe();
 		SND_IAudioDevice* audiodevice = SND_DeviceManager::Instance();
diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
index 784a103f3e3..66eed4201ee 100644
--- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp
+++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
@@ -1323,20 +1323,86 @@ void BL_CreatePhysicsObjectNew(KX_GameObject* gameobj,
 	objprop.m_softbody = (blenderobject->gameflag & OB_SOFT_BODY) != 0;
 	objprop.m_angular_rigidbody = (blenderobject->gameflag & OB_RIGID_BODY) != 0;
 	
-	///for game soft bodies
-	if (blenderobject->bsoft)
+	if (objprop.m_softbody)
 	{
-		objprop.m_linearStiffness = blenderobject->bsoft->linStiff;
-		objprop.m_angularStiffness = blenderobject->bsoft->angStiff;
-		objprop.m_volumePreservation = blenderobject->bsoft->volume;
-		objprop.m_gamesoftFlag = blenderobject->bsoft->flag;
+		///for game soft bodies
+		if (blenderobject->bsoft)
+		{
+			objprop.m_gamesoftFlag = blenderobject->bsoft->flag;
+					///////////////////
+			objprop.m_soft_linStiff = blenderobject->bsoft->linStiff;
+			objprop.m_soft_angStiff = blenderobject->bsoft->angStiff;		/* angular stiffness 0..1 */
+			objprop.m_soft_volume= blenderobject->bsoft->volume;			/* volume preservation 0..1 */
+
+			objprop.m_soft_viterations= blenderobject->bsoft->viterations;		/* Velocities solver iterations */
+			objprop.m_soft_piterations= blenderobject->bsoft->piterations;		/* Positions solver iterations */
+			objprop.m_soft_diterations= blenderobject->bsoft->diterations;		/* Drift solver iterations */
+			objprop.m_soft_citerations= blenderobject->bsoft->citerations;		/* Cluster solver iterations */
+
+			objprop.m_soft_kSRHR_CL= blenderobject->bsoft->kSRHR_CL;		/* Soft vs rigid hardness [0,1] (cluster only) */
+			objprop.m_soft_kSKHR_CL= blenderobject->bsoft->kSKHR_CL;		/* Soft vs kinetic hardness [0,1] (cluster only) */
+			objprop.m_soft_kSSHR_CL= blenderobject->bsoft->kSSHR_CL;		/* Soft vs soft hardness [0,1] (cluster only) */
+			objprop.m_soft_kSR_SPLT_CL= blenderobject->bsoft->kSR_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+
+			objprop.m_soft_kSK_SPLT_CL= blenderobject->bsoft->kSK_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+			objprop.m_soft_kSS_SPLT_CL= blenderobject->bsoft->kSS_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+			objprop.m_soft_kVCF= blenderobject->bsoft->kVCF;			/* Velocities correction factor (Baumgarte) */
+			objprop.m_soft_kDP= blenderobject->bsoft->kDP;			/* Damping coefficient [0,1] */
+
+			objprop.m_soft_kDG= blenderobject->bsoft->kDG;			/* Drag coefficient [0,+inf] */
+			objprop.m_soft_kLF= blenderobject->bsoft->kLF;			/* Lift coefficient [0,+inf] */
+			objprop.m_soft_kPR= blenderobject->bsoft->kPR;			/* Pressure coefficient [-inf,+inf] */
+			objprop.m_soft_kVC= blenderobject->bsoft->kVC;			/* Volume conversation coefficient [0,+inf] */
+
+			objprop.m_soft_kDF= blenderobject->bsoft->kDF;			/* Dynamic friction coefficient [0,1] */
+			objprop.m_soft_kMT= blenderobject->bsoft->kMT;			/* Pose matching coefficient [0,1] */
+			objprop.m_soft_kCHR= blenderobject->bsoft->kCHR;			/* Rigid contacts hardness [0,1] */
+			objprop.m_soft_kKHR= blenderobject->bsoft->kKHR;			/* Kinetic contacts hardness [0,1] */
+
+			objprop.m_soft_kSHR= blenderobject->bsoft->kSHR;			/* Soft contacts hardness [0,1] */
+			objprop.m_soft_kAHR= blenderobject->bsoft->kAHR;			/* Anchors hardness [0,1] */
+			objprop.m_soft_collisionflags= blenderobject->bsoft->collisionflags;	/* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
+			objprop.m_soft_numclusteriterations= blenderobject->bsoft->numclusteriterations;	/* number of iterations to refine collision clusters*/
 		
-	} else
-	{
-		objprop.m_linearStiffness = 0.5;//blenderobject->bsoft->linStiff;
-		objprop.m_angularStiffness = 1.f;//blenderobject->bsoft->angStiff;
-		objprop.m_volumePreservation = 1.f;//blenderobject->bsoft->volume;
-		objprop.m_gamesoftFlag = 1;//blenderobject->bsoft->flag;
+		} else
+		{
+			objprop.m_gamesoftFlag = OB_BSB_BENDING_CONSTRAINTS | OB_BSB_SHAPE_MATCHING | OB_BSB_AERO_VPOINT;
+			
+			objprop.m_soft_linStiff = 0.5;;
+			objprop.m_soft_angStiff = 1.f;		/* angular stiffness 0..1 */
+			objprop.m_soft_volume= 1.f;			/* volume preservation 0..1 */
+
+
+			objprop.m_soft_viterations= 0;
+			objprop.m_soft_piterations= 1;
+			objprop.m_soft_diterations= 0;
+			objprop.m_soft_citerations= 4;
+
+			objprop.m_soft_kSRHR_CL= 0.1f;
+			objprop.m_soft_kSKHR_CL= 1.f;
+			objprop.m_soft_kSSHR_CL= 0.5;
+			objprop.m_soft_kSR_SPLT_CL= 0.5f;
+
+			objprop.m_soft_kSK_SPLT_CL= 0.5f;
+			objprop.m_soft_kSS_SPLT_CL= 0.5f;
+			objprop.m_soft_kVCF=  1;
+			objprop.m_soft_kDP= 0;
+
+			objprop.m_soft_kDG= 0;
+			objprop.m_soft_kLF= 0;
+			objprop.m_soft_kPR= 0;
+			objprop.m_soft_kVC= 0;
+
+			objprop.m_soft_kDF= 0.2f;
+			objprop.m_soft_kMT= 0.f;
+			objprop.m_soft_kCHR= 1.0f;
+			objprop.m_soft_kKHR= 0.1f;
+
+			objprop.m_soft_kSHR= 1.f;
+			objprop.m_soft_kAHR= 0.7f;
+			objprop.m_soft_collisionflags= OB_BSB_COL_SDF_RS + OB_BSB_COL_VF_SS;
+			objprop.m_soft_numclusteriterations= 16;
+		}
 	}
 
 	objprop.m_ghost = (blenderobject->gameflag & OB_GHOST) != 0;
diff --git a/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h b/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h
index 6325c9365fd..53486cecf73 100644
--- a/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h
+++ b/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h
@@ -88,10 +88,44 @@ struct KX_ObjectProperties
 	bool	m_hasCompoundChildren;
 	bool	m_isCompoundChild;
 
-	float	m_linearStiffness;
-	float m_angularStiffness;
-	float	m_volumePreservation;
+	/////////////////////////
+
 	int		m_gamesoftFlag;
+	float	m_soft_linStiff;			/* linear stiffness 0..1 */
+	float	m_soft_angStiff;		/* angular stiffness 0..1 */
+	float	m_soft_volume;			/* volume preservation 0..1 */
+
+	int		m_soft_viterations;		/* Velocities solver iterations */
+	int		m_soft_piterations;		/* Positions solver iterations */
+	int		m_soft_diterations;		/* Drift solver iterations */
+	int		m_soft_citerations;		/* Cluster solver iterations */
+
+	float	m_soft_kSRHR_CL;		/* Soft vs rigid hardness [0,1] (cluster only) */
+	float	m_soft_kSKHR_CL;		/* Soft vs kinetic hardness [0,1] (cluster only) */
+	float	m_soft_kSSHR_CL;		/* Soft vs soft hardness [0,1] (cluster only) */
+	float	m_soft_kSR_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+
+	float	m_soft_kSK_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+	float	m_soft_kSS_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+	float	m_soft_kVCF;			/* Velocities correction factor (Baumgarte) */
+	float	m_soft_kDP;			/* Damping coefficient [0,1] */
+
+	float	m_soft_kDG;			/* Drag coefficient [0,+inf] */
+	float	m_soft_kLF;			/* Lift coefficient [0,+inf] */
+	float	m_soft_kPR;			/* Pressure coefficient [-inf,+inf] */
+	float	m_soft_kVC;			/* Volume conversation coefficient [0,+inf] */
+
+	float	m_soft_kDF;			/* Dynamic friction coefficient [0,1] */
+	float	m_soft_kMT;			/* Pose matching coefficient [0,1] */
+	float	m_soft_kCHR;			/* Rigid contacts hardness [0,1] */
+	float	m_soft_kKHR;			/* Kinetic contacts hardness [0,1] */
+
+	float	m_soft_kSHR;			/* Soft contacts hardness [0,1] */
+	float	m_soft_kAHR;			/* Anchors hardness [0,1] */
+	int		m_soft_collisionflags;	/* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
+	int		m_soft_numclusteriterations;	/* number of iterations to refine collision clusters*/
+
+	/////////////////////////
 	
 	double  m_margin;
 	KX_BoundBoxClass	m_boundclass;
diff --git a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
index c5dbabe24fc..e4c7e7f9317 100644
--- a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
+++ b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
@@ -1024,10 +1024,45 @@ void	KX_ConvertBulletObject(	class	KX_GameObject* gameobj,
 	ci.m_angularDamping = 1.f - shapeprops->m_ang_drag;
 	//need a bit of damping, else system doesn't behave well
 	ci.m_inertiaFactor = shapeprops->m_inertia/0.4f;//defaults to 0.4, don't want to change behaviour
-	ci.m_linearStiffness = objprop->m_linearStiffness;
-	ci.m_angularStiffness= objprop->m_angularStiffness;
-	ci.m_volumePreservation= objprop->m_volumePreservation;
+	
+	
+	///////////////////
 	ci.m_gamesoftFlag = objprop->m_gamesoftFlag;
+	ci.m_soft_linStiff = objprop->m_soft_linStiff;
+	ci.m_soft_angStiff = objprop->m_soft_angStiff;		/* angular stiffness 0..1 */
+	ci.m_soft_volume= objprop->m_soft_volume;			/* volume preservation 0..1 */
+
+	ci.m_soft_viterations= objprop->m_soft_viterations;		/* Velocities solver iterations */
+	ci.m_soft_piterations= objprop->m_soft_piterations;		/* Positions solver iterations */
+	ci.m_soft_diterations= objprop->m_soft_diterations;		/* Drift solver iterations */
+	ci.m_soft_citerations= objprop->m_soft_citerations;		/* Cluster solver iterations */
+
+	ci.m_soft_kSRHR_CL= objprop->m_soft_kSRHR_CL;		/* Soft vs rigid hardness [0,1] (cluster only) */
+	ci.m_soft_kSKHR_CL= objprop->m_soft_kSKHR_CL;		/* Soft vs kinetic hardness [0,1] (cluster only) */
+	ci.m_soft_kSSHR_CL= objprop->m_soft_kSSHR_CL;		/* Soft vs soft hardness [0,1] (cluster only) */
+	ci.m_soft_kSR_SPLT_CL= objprop->m_soft_kSR_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+
+	ci.m_soft_kSK_SPLT_CL= objprop->m_soft_kSK_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+	ci.m_soft_kSS_SPLT_CL= objprop->m_soft_kSS_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+	ci.m_soft_kVCF= objprop->m_soft_kVCF;			/* Velocities correction factor (Baumgarte) */
+	ci.m_soft_kDP= objprop->m_soft_kDP;			/* Damping coefficient [0,1] */
+
+	ci.m_soft_kDG= objprop->m_soft_kDG;			/* Drag coefficient [0,+inf] */
+	ci.m_soft_kLF= objprop->m_soft_kLF;			/* Lift coefficient [0,+inf] */
+	ci.m_soft_kPR= objprop->m_soft_kPR;			/* Pressure coefficient [-inf,+inf] */
+	ci.m_soft_kVC= objprop->m_soft_kVC;			/* Volume conversation coefficient [0,+inf] */
+
+	ci.m_soft_kDF= objprop->m_soft_kDF;			/* Dynamic friction coefficient [0,1] */
+	ci.m_soft_kMT= objprop->m_soft_kMT;			/* Pose matching coefficient [0,1] */
+	ci.m_soft_kCHR= objprop->m_soft_kCHR;			/* Rigid contacts hardness [0,1] */
+	ci.m_soft_kKHR= objprop->m_soft_kKHR;			/* Kinetic contacts hardness [0,1] */
+
+	ci.m_soft_kSHR= objprop->m_soft_kSHR;			/* Soft contacts hardness [0,1] */
+	ci.m_soft_kAHR= objprop->m_soft_kAHR;			/* Anchors hardness [0,1] */
+	ci.m_soft_collisionflags= objprop->m_soft_collisionflags;	/* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
+	ci.m_soft_numclusteriterations= objprop->m_soft_numclusteriterations;	/* number of iterations to refine collision clusters*/
+
+	////////////////////
 
 	ci.m_collisionFilterGroup = (isbulletdyna) ? short(CcdConstructionInfo::DefaultFilter) : short(CcdConstructionInfo::StaticFilter);
 	ci.m_collisionFilterMask = (isbulletdyna) ? short(CcdConstructionInfo::AllFilter) : short(CcdConstructionInfo::AllFilter ^ CcdConstructionInfo::StaticFilter);
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index 6eeb732c1e3..f5d6d7e8e0a 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -159,7 +159,7 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice,
 
 	KX_NetworkEventManager* netmgr = new KX_NetworkEventManager(m_logicmgr, ndi);
 	
-	SCA_JoystickManager *joymgr	= new SCA_JoystickManager(m_logicmgr);
+	
 
 	m_logicmgr->RegisterEventManager(alwaysmgr);
 	m_logicmgr->RegisterEventManager(propmgr);
@@ -170,7 +170,15 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice,
 	m_logicmgr->RegisterEventManager(rndmgr);
 	m_logicmgr->RegisterEventManager(raymgr);
 	m_logicmgr->RegisterEventManager(netmgr);
-	m_logicmgr->RegisterEventManager(joymgr);
+
+
+	SYS_SystemHandle hSystem = SYS_GetSystem();
+	bool nojoystick= SYS_GetCommandLineInt(hSystem,"nojoystick",0);
+	if (!nojoystick)
+	{
+		SCA_JoystickManager *joymgr	= new SCA_JoystickManager(m_logicmgr);
+		m_logicmgr->RegisterEventManager(joymgr);
+	}
 
 	m_soundScene = new SND_Scene(adi);
 	MT_assert (m_networkDeviceInterface != NULL);
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
index f17cfb79e92..166731459e7 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
@@ -288,26 +288,69 @@ void CcdPhysicsController::CreateRigidbody()
 		m_object = psb;
 
 		//psb->m_cfg.collisions	=	btSoftBody::fCollision::SDF_RS;//btSoftBody::fCollision::CL_SS+	btSoftBody::fCollision::CL_RS;
-		psb->m_cfg.collisions	=	btSoftBody::fCollision::SDF_RS + btSoftBody::fCollision::VF_SS;//CL_SS;
-		//psb->m_cfg.collisions	=	btSoftBody::fCollision::CL_SS + btSoftBody::fCollision::CL_RS;
 		
-		//btSoftBody::Material*	pm=psb->appendMaterial();
-		btSoftBody::Material*	pm=psb->m_materials[0];
+		//psb->m_cfg.collisions	=	btSoftBody::fCollision::SDF_RS + btSoftBody::fCollision::VF_SS;//CL_SS;
 		
-		pm->m_kLST				=	m_cci.m_linearStiffness;
-		pm->m_kAST				=	m_cci.m_angularStiffness;
-		pm->m_kVST				=	m_cci.m_volumePreservation;
 		
+		//btSoftBody::Material*	pm=psb->appendMaterial();
+		btSoftBody::Material*	pm=psb->m_materials[0];
+		pm->m_kLST				=	m_cci.m_soft_linStiff;
+		pm->m_kAST				=	m_cci.m_soft_angStiff;
+		pm->m_kVST				=	m_cci.m_soft_volume;
+		psb->m_cfg.collisions = 0;
 
-		
-		//pm->m_kAST = 0.01f;
-		//pm->m_kVST = 0.001f;
-		psb->generateBendingConstraints(2,pm);
-		psb->m_cfg.piterations = 4;
-		psb->m_cfg.viterations = 4;
-		psb->m_cfg.diterations = 4;
-		psb->m_cfg.citerations = 4;
-		if (m_cci.m_gamesoftFlag & 2)//OB_SB_GOAL)
+		if (m_cci.m_soft_collisionflags & CCD_BSB_COL_CL_RS)
+		{
+			psb->m_cfg.collisions	+=	btSoftBody::fCollision::CL_RS;
+		} else
+		{
+			psb->m_cfg.collisions	+=	btSoftBody::fCollision::SDF_RS;
+		}
+		if (m_cci.m_soft_collisionflags & CCD_BSB_COL_CL_SS)
+		{
+			psb->m_cfg.collisions += btSoftBody::fCollision::CL_SS;
+		} else
+		{
+			psb->m_cfg.collisions += btSoftBody::fCollision::VF_SS;
+		}
+
+
+		psb->m_cfg.kSRHR_CL = m_cci.m_soft_kSRHR_CL;		/* Soft vs rigid hardness [0,1] (cluster only) */
+		psb->m_cfg.kSKHR_CL = m_cci.m_soft_kSKHR_CL;		/* Soft vs kinetic hardness [0,1] (cluster only) */
+		psb->m_cfg.kSSHR_CL = m_cci.m_soft_kSSHR_CL;		/* Soft vs soft hardness [0,1] (cluster only) */
+		psb->m_cfg.kSR_SPLT_CL = m_cci.m_soft_kSR_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+
+		psb->m_cfg.kSK_SPLT_CL = m_cci.m_soft_kSK_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+		psb->m_cfg.kSS_SPLT_CL = m_cci.m_soft_kSS_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+		psb->m_cfg.kVCF = m_cci.m_soft_kVCF;			/* Velocities correction factor (Baumgarte) */
+		psb->m_cfg.kDP = m_cci.m_soft_kDP;			/* Damping coefficient [0,1] */
+
+		psb->m_cfg.kDG = m_cci.m_soft_kDG;			/* Drag coefficient [0,+inf] */
+		psb->m_cfg.kLF = m_cci.m_soft_kLF;			/* Lift coefficient [0,+inf] */
+		psb->m_cfg.kPR = m_cci.m_soft_kPR;			/* Pressure coefficient [-inf,+inf] */
+		psb->m_cfg.kVC = m_cci.m_soft_kVC;			/* Volume conversation coefficient [0,+inf] */
+
+		psb->m_cfg.kDF = m_cci.m_soft_kDF;			/* Dynamic friction coefficient [0,1] */
+		psb->m_cfg.kMT = m_cci.m_soft_kMT;			/* Pose matching coefficient [0,1] */
+		psb->m_cfg.kCHR = m_cci.m_soft_kCHR;			/* Rigid contacts hardness [0,1] */
+		psb->m_cfg.kKHR = m_cci.m_soft_kKHR;			/* Kinetic contacts hardness [0,1] */
+
+		psb->m_cfg.kSHR = m_cci.m_soft_kSHR;			/* Soft contacts hardness [0,1] */
+		psb->m_cfg.kAHR = m_cci.m_soft_kAHR;			/* Anchors hardness [0,1] */
+
+
+
+		if (m_cci.m_gamesoftFlag & CCD_BSB_BENDING_CONSTRAINTS)//OB_SB_GOAL)
+		{
+			psb->generateBendingConstraints(2,pm);
+		}
+
+		psb->m_cfg.piterations = m_cci.m_soft_piterations;
+		psb->m_cfg.viterations = m_cci.m_soft_viterations;
+		psb->m_cfg.diterations = m_cci.m_soft_diterations;
+		psb->m_cfg.citerations = m_cci.m_soft_citerations;
+
+		if (m_cci.m_gamesoftFlag & CCD_BSB_SHAPE_MATCHING)//OB_SB_GOAL)
 		{
 			psb->setPose(false,true);//
 		} else
@@ -315,27 +358,14 @@ void CcdPhysicsController::CreateRigidbody()
 			psb->setPose(true,false);
 		}
 
-		psb->m_cfg.kDF				=	0.5;
-		//psb->m_cfg.kMT				=	0.05;
-		psb->m_cfg.piterations		=	5;
-		
-		psb->m_cfg.piterations		=	5;
-		//psb->m_cfg.kVC				=	20;
 
+		
 		psb->randomizeConstraints();
 
-/*
-		psb->m_cfg.kDF = 0.1f;//1.f;
-		psb->m_cfg.kDP		=	0.0001;
-		//psb->m_cfg.kDP		=	0.005;
-		psb->m_cfg.kCHR		=	0.1;
-		//psb->m_cfg.kVCF = 0.1f;
-		psb->m_cfg.kVCF = 0.0001f;
-		//psb->m_cfg.kAHR = 0.1f;
-		psb->m_cfg.kAHR = 0.0001f;
-		psb->m_cfg.kMT = 0.1f;
-		//psb->m_cfg.kDF=1;
-		*/
+		if (m_cci.m_soft_collisionflags & (CCD_BSB_COL_CL_RS+CCD_BSB_COL_CL_SS))
+		{
+			psb->generateClusters(m_cci.m_soft_numclusteriterations);
+		}
 
 //		psb->activate();
 //		psb->setActivationState(1);
@@ -343,14 +373,10 @@ void CcdPhysicsController::CreateRigidbody()
 		
 		//psb->m_materials[0]->m_kLST	=	0.1+(i/(btScalar)(n-1))*0.9;
 		psb->setTotalMass(m_cci.m_mass);
-		psb->generateClusters(64);		
+		
 		psb->setCollisionFlags(0);
 
-
-
-
-
-			///create a mapping between graphics mesh vertices and soft body vertices
+		///create a mapping between graphics mesh vertices and soft body vertices
 		{
 			RAS_MeshObject* rasMesh= GetShapeInfo()->GetMesh();
 
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.h b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
index 60c734838f3..1366764eb63 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
@@ -38,6 +38,20 @@ class btMotionState;
 class RAS_MeshObject;
 class btCollisionShape;
 
+
+#define CCD_BSB_SHAPE_MATCHING	2
+#define CCD_BSB_BENDING_CONSTRAINTS 8
+#define CCD_BSB_AERO_VPOINT 16 /* aero model, Vertex normals are oriented toward velocity*/
+#define CCD_BSB_AERO_VTWOSIDE 32 /* aero model, Vertex normals are flipped to match velocity */
+
+/* BulletSoftBody.collisionflags */
+#define CCD_BSB_COL_SDF_RS	2 /* SDF based rigid vs soft */
+#define CCD_BSB_COL_CL_RS	4 /* Cluster based rigid vs soft */
+#define CCD_BSB_COL_CL_SS	8 /* Cluster based soft vs soft */
+#define CCD_BSB_COL_VF_SS	16 /* Vertex/Face based soft vs soft */
+
+
+
 // Shape contructor
 // It contains all the information needed to create a simple bullet shape at runtime
 class CcdShapeConstructionInfo
@@ -162,9 +176,6 @@ struct CcdConstructionInfo
 		m_linearDamping(0.1f),
 		m_angularDamping(0.1f),
 		m_margin(0.06f),
-		m_linearStiffness(1.f),
-		m_angularStiffness(1.f),
-		m_volumePreservation(1.f),
 		m_gamesoftFlag(0),
 		m_collisionFlags(0),
 		m_bRigid(false),
@@ -189,10 +200,44 @@ struct CcdConstructionInfo
 	btScalar	m_angularDamping;
 	btScalar	m_margin;
 
-	btScalar	m_linearStiffness;
-	btScalar	m_angularStiffness;
-	btScalar	m_volumePreservation;
-	int			m_gamesoftFlag;
+	////////////////////
+	int		m_gamesoftFlag;
+	float	m_soft_linStiff;			/* linear stiffness 0..1 */
+	float	m_soft_angStiff;		/* angular stiffness 0..1 */
+	float	m_soft_volume;			/* volume preservation 0..1 */
+
+	int		m_soft_viterations;		/* Velocities solver iterations */
+	int		m_soft_piterations;		/* Positions solver iterations */
+	int		m_soft_diterations;		/* Drift solver iterations */
+	int		m_soft_citerations;		/* Cluster solver iterations */
+
+	float	m_soft_kSRHR_CL;		/* Soft vs rigid hardness [0,1] (cluster only) */
+	float	m_soft_kSKHR_CL;		/* Soft vs kinetic hardness [0,1] (cluster only) */
+	float	m_soft_kSSHR_CL;		/* Soft vs soft hardness [0,1] (cluster only) */
+	float	m_soft_kSR_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+
+	float	m_soft_kSK_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+	float	m_soft_kSS_SPLT_CL;	/* Soft vs rigid impulse split [0,1] (cluster only) */
+	float	m_soft_kVCF;			/* Velocities correction factor (Baumgarte) */
+	float	m_soft_kDP;			/* Damping coefficient [0,1] */
+
+	float	m_soft_kDG;			/* Drag coefficient [0,+inf] */
+	float	m_soft_kLF;			/* Lift coefficient [0,+inf] */
+	float	m_soft_kPR;			/* Pressure coefficient [-inf,+inf] */
+	float	m_soft_kVC;			/* Volume conversation coefficient [0,+inf] */
+
+	float	m_soft_kDF;			/* Dynamic friction coefficient [0,1] */
+	float	m_soft_kMT;			/* Pose matching coefficient [0,1] */
+	float	m_soft_kCHR;			/* Rigid contacts hardness [0,1] */
+	float	m_soft_kKHR;			/* Kinetic contacts hardness [0,1] */
+
+	float	m_soft_kSHR;			/* Soft contacts hardness [0,1] */
+	float	m_soft_kAHR;			/* Anchors hardness [0,1] */
+	int		m_soft_collisionflags;	/* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
+	int		m_soft_numclusteriterations;	/* number of iterations to refine collision clusters*/
+///////////////////
+
+
 
 	int			m_collisionFlags;
 	bool		m_bRigid;
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
index 3593aecf3d5..763fc148a04 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
@@ -576,7 +576,8 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 		veh->SyncWheels();
 	}
 
-	m_dynamicsWorld->debugDrawWorld();
+	if (m_dynamicsWorld->getDebugDrawer() &&  m_dynamicsWorld->getDebugDrawer()->getDebugMode() >0)
+		m_dynamicsWorld->debugDrawWorld();
 
 
 	CallbackTriggers();