BGE: Cleaning up the BGE's physics code and removing KX_IPhysicsController and KX_BulletPhysicsController. Instead, we just use PHY_IPhysicsController, which removes a lot of duplicate code.

This is a squashed commit of the following:
    BGE Physics Cleanup: Fix crashes with LibLoading and replication. Also fixing some memory leaks.
    BGE Physics Cleanup: Removing KX_IPhysicsController and KX_BulletPhysicsController.
    BGE Physics Cleanup: Moving the replication code outside of KX_BlenderBulletController and switching KX_ConvertPhysicsObjects to create a CcdPhysicsController instead of a KX_BlenderBulletController.
    BGE Physics Cleanup: Getting rid of an unsued KX_BulletPhysicsController.h include in KX_Scene.cpp.
    BGE Physics Cleanup: Removing unused KX_IPhysicsController and KX_BulletPhysicsController includes.
    BGE Physics Cleanup: Removing m_pPhysicsController1 and GetPhysicsController1() from KX_GameObject.
    BGE Physics Cleanup: Remove SetRigidBody() from KX_IPhysicsController and remove GetName() from CcdPhysicsController.
    BGE Physics Cleanup: Moving Add/RemoveCompoundChild() from KX_IPhysicsController to PHY_IPhysicsController.
    BGE Physics Cleanup: Removing GetLocalInertia() from KX_IPhysicsController.
    BGE Physics Cleanup: Making BlenderBulletCharacterController derive from PHY_ICharacter and removing CharacterWrapper from CcdPhysicsEnvironment.cpp. Also removing the character functions from KX_IPhysicsController.
    BGE Physics Cleanup: Removing GetOrientation(), SetOrientation(), SetPosition(), SetScaling(), and GetRadius() from KX_IPhysicsController.
    BGE Physics Cleanup: Removing GetReactionForce() since all implementations returned (0, 0, 0). The Python interface for KX_GameObject still has reaction force code, but it still also returns (0, 0, 0). This can probably be removed as well, but removing it can break scripts, so I'll leave it for now.
    BGE Physics Cleanup: Removing Get/SetLinVelocityMin() and Get/SetLinVelocityMax() from KX_IPhysicsController.
    BGE Physics Cleanup: Removing SetMargin(), RelativeTranslate(), and RelativeRotate() from KX_IPhysicsController.
    BGE Physics Cleanup: Using constant references for function arguments in PHY_IPhysicsController where appropriate.
    BGE Physics Cleanup: Removing ApplyImpulse() from KX_IPhysicsController.
    BGE Physics Cleanup: Removing ResolveCombinedVelocities() from KX_IPhysicsController.
    BGE Physics Cleanup: Accidently removed a return when cleaning up KX_GameObject::PyGetVelocity().
    BGE Physics Cleanup: Remove GetLinearVelocity(), GetAngularVelocity() and GetVelocity() from KX_IPhysicsController. The corresponding PHY_IPhysicsController functions now also take Moto types instead of scalars to match the KX_IPhysicsController interface.
    BGE Physics Cleanup: Moving SuspendDynamics, RestoreDynamics, SetMass, GetMass, and SetTransform from KX_IPhysicsController to PHY_IPhysicsController.
    BGE Physics Cleanup: PHY_IPhysicsEnvironment and derived classes now use the same naming scheme as PHY_IController.
    BGE Physics Cleanup: PHY_IMotionState and derived classes now use the same naming convention as PHY_IController.
    BGE Phsyics Cleanup: Making PHY_IController and its derived classes follow a consistent naming scheme for member functions. They now all start with capital letters (e.g., setWorldOrientation becomes SetWorldOrientation).
    BGE Physics Cleanup: Getting rid of KX_GameObject::SuspendDynamics() and KX_GameObject::RestoreDynamics(). Instead, use the functions from the physics controller.
    BGE: Some first steps in trying to cleanup the KX_IPhysicsController mess. KX_GameObject now has a GetPhysicsController() and a GetPhysicsController1(). The former returns a PHY_IPhysicsController* while the latter returns a KX_IPhysicsController. The goal is to get everything using GetPhysicsController() instead of GetPhysicsController1().

13 files changed, 702 insertions, 523 deletions

diff --git a/source/gameengine/Physics/Bullet/CcdGraphicController.cpp b/source/gameengine/Physics/Bullet/CcdGraphicController.cpp
index 3cb80e53e12..fdafc4e507d 100644
--- a/source/gameengine/Physics/Bullet/CcdGraphicController.cpp
+++ b/source/gameengine/Physics/Bullet/CcdGraphicController.cpp
@@ -35,48 +35,48 @@ CcdGraphicController::CcdGraphicController (CcdPhysicsEnvironment* phyEnv, PHY_I
 CcdGraphicController::~CcdGraphicController()
 {
 	if (m_phyEnv)
-		m_phyEnv->removeCcdGraphicController(this);
+		m_phyEnv->RemoveCcdGraphicController(this);
 
 	if (m_motionState)
 		delete m_motionState;
 }
 
-void CcdGraphicController::setLocalAabb(const btVector3& aabbMin,const btVector3& aabbMax)
+void CcdGraphicController::SetLocalAabb(const btVector3& aabbMin,const btVector3& aabbMax)
 {
 	m_localAabbMin = aabbMin;
 	m_localAabbMax = aabbMax;
 	SetGraphicTransform();
 }
 
-void CcdGraphicController::setLocalAabb(const MT_Point3& aabbMin,const MT_Point3& aabbMax)
+void CcdGraphicController::SetLocalAabb(const MT_Point3& aabbMin,const MT_Point3& aabbMax)
 {
 	m_localAabbMin.setValue(aabbMin[0],aabbMin[1],aabbMin[2]);
 	m_localAabbMax.setValue(aabbMax[0],aabbMax[1],aabbMax[2]);
 	SetGraphicTransform();
 }
 
-void CcdGraphicController::setLocalAabb(const MT_Vector3& aabbMin,const MT_Vector3& aabbMax)
+void CcdGraphicController::SetLocalAabb(const MT_Vector3& aabbMin,const MT_Vector3& aabbMax)
 {
 	m_localAabbMin.setValue(aabbMin[0],aabbMin[1],aabbMin[2]);
 	m_localAabbMax.setValue(aabbMax[0],aabbMax[1],aabbMax[2]);
 	SetGraphicTransform();
 }
 
-void CcdGraphicController::setLocalAabb(const float* aabbMin,const float* aabbMax)
+void CcdGraphicController::SetLocalAabb(const float* aabbMin,const float* aabbMax)
 {
 	m_localAabbMin.setValue(aabbMin[0],aabbMin[1],aabbMin[2]);
 	m_localAabbMax.setValue(aabbMax[0],aabbMax[1],aabbMax[2]);
 	SetGraphicTransform();
 }
 
-void CcdGraphicController::getAabb(btVector3& aabbMin, btVector3& aabbMax)
+void CcdGraphicController::GetAabb(btVector3& aabbMin, btVector3& aabbMax)
 {
 	btVector3 pos;
 	btVector3 scale;
 	float ori[12];
-	m_motionState->getWorldPosition(pos.m_floats[0],pos.m_floats[1],pos.m_floats[2]);
-	m_motionState->getWorldScaling(scale.m_floats[0],scale.m_floats[1],scale.m_floats[2]);
-	m_motionState->getWorldOrientation(ori);
+	m_motionState->GetWorldPosition(pos.m_floats[0],pos.m_floats[1],pos.m_floats[2]);
+	m_motionState->GetWorldScaling(scale.m_floats[0],scale.m_floats[1],scale.m_floats[2]);
+	m_motionState->GetWorldOrientation(ori);
 	btMatrix3x3 rot(ori[0], ori[4], ori[8],
 					ori[1], ori[5], ori[9],
 					ori[2], ori[6], ori[10]);
@@ -109,9 +109,9 @@ bool CcdGraphicController::SetGraphicTransform()
 		return false;
 	btVector3 aabbMin;
 	btVector3 aabbMax;
-	getAabb(aabbMin, aabbMax);
+	GetAabb(aabbMin, aabbMax);
 	// update Aabb in broadphase
-	m_phyEnv->getCullingTree()->setAabb(m_handle,aabbMin,aabbMax,NULL);
+	m_phyEnv->GetCullingTree()->setAabb(m_handle,aabbMin,aabbMax,NULL);
 	return true;
 }
 
@@ -131,7 +131,7 @@ void CcdGraphicController::SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*
 {
 	CcdPhysicsEnvironment* phyEnv = static_cast<CcdPhysicsEnvironment*>(env);
 	/* Updates the m_phyEnv's m_cullingTree & m_cullingCache */
-	if (getBroadphaseHandle()) {
+	if (GetBroadphaseHandle()) {
 		/* insert into the new physics scene */
 		Activate(false);
 		m_phyEnv= phyEnv;
@@ -145,8 +145,8 @@ void CcdGraphicController::SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*
 void CcdGraphicController::Activate(bool active)
 {
 	if (active)
-		m_phyEnv->addCcdGraphicController(this);
+		m_phyEnv->AddCcdGraphicController(this);
 	else
-		m_phyEnv->removeCcdGraphicController(this);
+		m_phyEnv->RemoveCcdGraphicController(this);
 
 }
diff --git a/source/gameengine/Physics/Bullet/CcdGraphicController.h b/source/gameengine/Physics/Bullet/CcdGraphicController.h
index 064f86040f6..e76ad86301e 100644
--- a/source/gameengine/Physics/Bullet/CcdGraphicController.h
+++ b/source/gameengine/Physics/Bullet/CcdGraphicController.h
@@ -40,16 +40,16 @@ public:
 
 	virtual ~CcdGraphicController();
 
-	void setLocalAabb(const btVector3& aabbMin,const btVector3& aabbMax);
-	void setLocalAabb(const MT_Point3& aabbMin,const MT_Point3& aabbMax);
-	virtual void setLocalAabb(const MT_Vector3& aabbMin,const MT_Vector3& aabbMax);
-	virtual void setLocalAabb(const float aabbMin[3],const float aabbMax[3]);
+	void SetLocalAabb(const btVector3& aabbMin,const btVector3& aabbMax);
+	void SetLocalAabb(const MT_Point3& aabbMin,const MT_Point3& aabbMax);
+	virtual void SetLocalAabb(const MT_Vector3& aabbMin,const MT_Vector3& aabbMax);
+	virtual void SetLocalAabb(const float aabbMin[3],const float aabbMax[3]);
 
 	PHY_IMotionState* GetMotionState() { return m_motionState; }
-	void getAabb(btVector3& aabbMin, btVector3& aabbMax);
+	void GetAabb(btVector3& aabbMin, btVector3& aabbMax);
 
-	virtual void setBroadphaseHandle(btBroadphaseProxy* handle) { m_handle = handle; }
-	virtual btBroadphaseProxy* getBroadphaseHandle() { return m_handle; }
+	virtual void SetBroadphaseHandle(btBroadphaseProxy* handle) { m_handle = handle; }
+	virtual btBroadphaseProxy* GetBroadphaseHandle() { return m_handle; }
 
 	virtual void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment* env);
 
@@ -67,8 +67,8 @@ public:
 	virtual void Activate(bool active);
 
 	// client info for culling
-	virtual	void* getNewClientInfo() { return m_newClientInfo; }
-	virtual	void setNewClientInfo(void* clientinfo) { m_newClientInfo = clientinfo; }
+	virtual	void* GetNewClientInfo() { return m_newClientInfo; }
+	virtual	void SetNewClientInfo(void* clientinfo) { m_newClientInfo = clientinfo; }
 	virtual PHY_IGraphicController*	GetReplica(class PHY_IMotionState* motionstate);
 		
 private:
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
index 8a3ad82d179..a3838a148e1 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
@@ -139,9 +139,14 @@ CcdPhysicsController::CcdPhysicsController (const CcdConstructionInfo& ci)
 	m_shapeInfo = ci.m_shapeInfo;
 	if (m_shapeInfo)
 		m_shapeInfo->AddRef();
+
+	m_bulletChildShape = NULL;
 	
 	m_bulletMotionState = 0;
 	m_characterController = 0;
+	m_savedCollisionFlags = 0;
+	m_savedMass = 0.0;
+	m_suspended = false;
 	
 	CreateRigidbody();
 }
@@ -150,11 +155,11 @@ btTransform&	CcdPhysicsController::GetTransformFromMotionState(PHY_IMotionState*
 {
 	static btTransform trans;
 	btVector3 tmp;
-	motionState->getWorldPosition(tmp.m_floats[0], tmp.m_floats[1], tmp.m_floats[2]);
+	motionState->GetWorldPosition(tmp.m_floats[0], tmp.m_floats[1], tmp.m_floats[2]);
 	trans.setOrigin(tmp);
 
 	float ori[12];
-	motionState->getWorldOrientation(ori);
+	motionState->GetWorldOrientation(ori);
 	trans.getBasis().setFromOpenGLSubMatrix(ori);
 	//btQuaternion orn;
 	//motionState->getWorldOrientation(orn[0],orn[1],orn[2],orn[3]);
@@ -180,18 +185,18 @@ public:
 		btVector3 pos;
 		float ori[12];
 
-		m_blenderMotionState->getWorldPosition(pos.m_floats[0],pos.m_floats[1],pos.m_floats[2]);
-		m_blenderMotionState->getWorldOrientation(ori);
+		m_blenderMotionState->GetWorldPosition(pos.m_floats[0],pos.m_floats[1],pos.m_floats[2]);
+		m_blenderMotionState->GetWorldOrientation(ori);
 		worldTrans.setOrigin(pos);
 		worldTrans.getBasis().setFromOpenGLSubMatrix(ori);
 	}
 
 	void	setWorldTransform(const btTransform& worldTrans)
 	{
-		m_blenderMotionState->setWorldPosition(worldTrans.getOrigin().getX(),worldTrans.getOrigin().getY(),worldTrans.getOrigin().getZ());
+		m_blenderMotionState->SetWorldPosition(worldTrans.getOrigin().getX(),worldTrans.getOrigin().getY(),worldTrans.getOrigin().getZ());
 		btQuaternion rotQuat = worldTrans.getRotation();
-		m_blenderMotionState->setWorldOrientation(rotQuat[0],rotQuat[1],rotQuat[2],rotQuat[3]);
-		m_blenderMotionState->calculateWorldTransformations();
+		m_blenderMotionState->SetWorldOrientation(rotQuat[0],rotQuat[1],rotQuat[2],rotQuat[3]);
+		m_blenderMotionState->CalculateWorldTransformations();
 	}
 
 };
@@ -238,7 +243,7 @@ bool CcdPhysicsController::CreateSoftbody()
 	btVector3 p(0,0,0);// = getOrigin();
 	//btSoftBody*	psb=btSoftBodyHelpers::CreateRope(worldInfo,	btVector3(-10,0,i*0.25),btVector3(10,0,i*0.25),	16,1+2);
 	btSoftBody* psb  = 0;
-	btSoftBodyWorldInfo& worldInfo = m_cci.m_physicsEnv->getDynamicsWorld()->getWorldInfo();
+	btSoftBodyWorldInfo& worldInfo = m_cci.m_physicsEnv->GetDynamicsWorld()->getWorldInfo();
 
 	if (m_cci.m_collisionShape->getShapeType() == CONVEX_HULL_SHAPE_PROXYTYPE) {
 		btConvexHullShape* convexHull = (btConvexHullShape* )m_cci.m_collisionShape;
@@ -456,8 +461,8 @@ bool CcdPhysicsController::CreateSoftbody()
 	btTransform startTrans;
 	rbci.m_motionState->getWorldTransform(startTrans);
 
-	m_MotionState->setWorldPosition(startTrans.getOrigin().getX(),startTrans.getOrigin().getY(),startTrans.getOrigin().getZ());
-	m_MotionState->setWorldOrientation(0,0,0,1);
+	m_MotionState->SetWorldPosition(startTrans.getOrigin().getX(),startTrans.getOrigin().getY(),startTrans.getOrigin().getZ());
+	m_MotionState->SetWorldOrientation(0,0,0,1);
 
 	if (!m_prototypeTransformInitialized)
 	{
@@ -609,7 +614,7 @@ bool CcdPhysicsController::ReplaceControllerShape(btCollisionShape *newShape)
 	
 	if (GetSoftBody()) {
 		// soft body must be recreated
-		m_cci.m_physicsEnv->removeCcdPhysicsController(this);
+		m_cci.m_physicsEnv->RemoveCcdPhysicsController(this);
 		delete m_object;
 		m_object = NULL;
 		// force complete reinitialization
@@ -619,14 +624,14 @@ bool CcdPhysicsController::ReplaceControllerShape(btCollisionShape *newShape)
 		CreateSoftbody();
 		assert(m_object);
 		// reinsert the new body
-		m_cci.m_physicsEnv->addCcdPhysicsController(this);
+		m_cci.m_physicsEnv->AddCcdPhysicsController(this);
 	}
 	
 	/* Copied from CcdPhysicsEnvironment::addCcdPhysicsController() */
 	
 	/* without this, an object can rest on the old physics mesh
 	 * and not move to account for the physics mesh, even with 'nosleep' */ 
-	btSoftRigidDynamicsWorld* dw= GetPhysicsEnvironment()->getDynamicsWorld();
+	btSoftRigidDynamicsWorld* dw= GetPhysicsEnvironment()->GetDynamicsWorld();
 	btCollisionObjectArray &obarr= dw->getCollisionObjectArray();
 	btCollisionObject *ob;
 	btBroadphaseProxy* proxy;
@@ -648,7 +653,7 @@ CcdPhysicsController::~CcdPhysicsController()
 {
 	//will be reference counted, due to sharing
 	if (m_cci.m_physicsEnv)
-		m_cci.m_physicsEnv->removeCcdPhysicsController(this);
+		m_cci.m_physicsEnv->RemoveCcdPhysicsController(this);
 
 	if (m_MotionState)
 		delete m_MotionState;
@@ -683,17 +688,17 @@ bool		CcdPhysicsController::SynchronizeMotionStates(float time)
 			btQuaternion worldquat;
 			btMatrix3x3	trs = sb->m_pose.m_rot*sb->m_pose.m_scl;
 			trs.getRotation(worldquat);
-			m_MotionState->setWorldPosition(worldPos[0],worldPos[1],worldPos[2]);
-			m_MotionState->setWorldOrientation(worldquat[0],worldquat[1],worldquat[2],worldquat[3]);
+			m_MotionState->SetWorldPosition(worldPos[0],worldPos[1],worldPos[2]);
+			m_MotionState->SetWorldOrientation(worldquat[0],worldquat[1],worldquat[2],worldquat[3]);
 		}
 		else 
 		{
 			btVector3 aabbMin,aabbMax;
 			sb->getAabb(aabbMin,aabbMax);
 			btVector3 worldPos  = (aabbMax+aabbMin)*0.5f;
-			m_MotionState->setWorldPosition(worldPos[0],worldPos[1],worldPos[2]);
+			m_MotionState->SetWorldPosition(worldPos[0],worldPos[1],worldPos[2]);
 		}
-		m_MotionState->calculateWorldTransformations();
+		m_MotionState->CalculateWorldTransformations();
 		return true;
 	}
 
@@ -719,12 +724,12 @@ bool		CcdPhysicsController::SynchronizeMotionStates(float time)
 		const btVector3& worldPos = xform.getOrigin();
 		float ori[12];
 		worldOri.getOpenGLSubMatrix(ori);
-		m_MotionState->setWorldOrientation(ori);
-		m_MotionState->setWorldPosition(worldPos[0],worldPos[1],worldPos[2]);
-		m_MotionState->calculateWorldTransformations();
+		m_MotionState->SetWorldOrientation(ori);
+		m_MotionState->SetWorldPosition(worldPos[0],worldPos[1],worldPos[2]);
+		m_MotionState->CalculateWorldTransformations();
 
 		float scale[3];
-		m_MotionState->getWorldScaling(scale[0],scale[1],scale[2]);
+		m_MotionState->GetWorldScaling(scale[0],scale[1],scale[2]);
 		btVector3 scaling(scale[0],scale[1],scale[2]);
 		GetCollisionShape()->setLocalScaling(scaling);
 	} else
@@ -743,7 +748,7 @@ bool		CcdPhysicsController::SynchronizeMotionStates(float time)
 		m_MotionState->calculateWorldTransformations();
 */
 		float scale[3];
-		m_MotionState->getWorldScaling(scale[0],scale[1],scale[2]);
+		m_MotionState->GetWorldScaling(scale[0],scale[1],scale[2]);
 		btVector3 scaling(scale[0],scale[1],scale[2]);
 		GetCollisionShape()->setLocalScaling(scaling);
 	}
@@ -767,7 +772,7 @@ void		CcdPhysicsController::WriteDynamicsToMotionState()
 		// controller replication
 void		CcdPhysicsController::PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl)
 {
-	
+	SetParentCtrl((CcdPhysicsController*)parentctrl);
 	m_softBodyTransformInitialized=false;
 	m_MotionState = motionstate;
 	m_registerCount = 0;
@@ -812,7 +817,7 @@ void		CcdPhysicsController::PostProcessReplica(class PHY_IMotionState* motionsta
 	}
 	// sensor object are added when needed
 	if (!m_cci.m_bSensor)
-		m_cci.m_physicsEnv->addCcdPhysicsController(this);
+		m_cci.m_physicsEnv->AddCcdPhysicsController(this);
 
 
 /*	SM_Object* dynaparent=0;
@@ -857,9 +862,9 @@ void	CcdPhysicsController::SetPhysicsEnvironment(class PHY_IPhysicsEnvironment *
 		// since the environment is changing, we must also move the controler to the
 		// new environment. Note that we don't handle sensor explicitly: this
 		// function can be called on sensor but only when they are not registered
-		if (m_cci.m_physicsEnv->removeCcdPhysicsController(this))
+		if (m_cci.m_physicsEnv->RemoveCcdPhysicsController(this))
 		{
-			physicsEnv->addCcdPhysicsController(this);
+			physicsEnv->AddCcdPhysicsController(this);
 
 			// Set the object to be active so it can at least by evaluated once.
 			// This fixes issues with static objects not having their physics meshes
@@ -904,7 +909,7 @@ void	CcdPhysicsController::SetCenterOfMassTransform(btTransform& xform)
 }
 
 		// kinematic methods
-void		CcdPhysicsController::RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local)
+void		CcdPhysicsController::RelativeTranslate(const MT_Vector3& dlocin,bool local)
 {
 	if (m_object)
 	{
@@ -917,7 +922,7 @@ void		CcdPhysicsController::RelativeTranslate(float dlocX,float dlocY,float dloc
 			return;
 		}
 
-		btVector3 dloc(dlocX,dlocY,dlocZ);
+		btVector3 dloc(dlocin.x(), dlocin.y(), dlocin.z());
 		btTransform xform = m_object->getWorldTransform();
 	
 		if (local)
@@ -929,22 +934,7 @@ void		CcdPhysicsController::RelativeTranslate(float dlocX,float dlocY,float dloc
 
 }
 
-void		CcdPhysicsController::SetWalkDirection(float dirX,float dirY,float dirZ,bool local)
-{
-
-	if (m_object && m_characterController)
-	{
-		btVector3 dir(dirX,dirY,dirZ);
-		btTransform xform = m_object->getWorldTransform();
-
-		if (local)
-			dir = xform.getBasis()*dir;
-
-		m_characterController->setWalkDirection(dir/GetPhysicsEnvironment()->getNumTimeSubSteps());
-	}
-}
-
-void		CcdPhysicsController::RelativeRotate(const float rotval[9],bool local)
+void		CcdPhysicsController::RelativeRotate(const MT_Matrix3x3& rotval,bool local)
 {
 	if (m_object)
 	{
@@ -957,9 +947,9 @@ void		CcdPhysicsController::RelativeRotate(const float rotval[9],bool local)
 			return;
 		}
 
-		btMatrix3x3 drotmat(rotval[0], rotval[3], rotval[6],
-		                    rotval[1], rotval[4], rotval[7],
-		                    rotval[2], rotval[5], rotval[8]);
+		btMatrix3x3 drotmat(rotval[0].x(), rotval[1].x(), rotval[2].x(),
+		        rotval[0].y(), rotval[1].y(), rotval[2].y(),
+		        rotval[0].z(), rotval[1].z(), rotval[2].z());
 
 
 		btMatrix3x3 currentOrn;
@@ -978,45 +968,23 @@ void		CcdPhysicsController::RelativeRotate(const float rotval[9],bool local)
 void CcdPhysicsController::GetWorldOrientation(btMatrix3x3& mat)
 {
 	float ori[12];
-	m_MotionState->getWorldOrientation(ori);
+	m_MotionState->GetWorldOrientation(ori);
 	mat.setFromOpenGLSubMatrix(ori);
 }
 
-void		CcdPhysicsController::getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal)
+MT_Matrix3x3 CcdPhysicsController::GetOrientation()
 {
-	btQuaternion q = m_object->getWorldTransform().getRotation();
-	quatImag0 = q[0];
-	quatImag1 = q[1];
-	quatImag2 = q[2];
-	quatReal = q[3];
+	btMatrix3x3 orn = m_object->getWorldTransform().getBasis();
+	return MT_Matrix3x3(orn[0][0], orn[0][1], orn[0][2], orn[1][0], orn[1][1], orn[1][2], orn[2][0], orn[2][1], orn[2][2]);
 }
-void		CcdPhysicsController::setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal)
-{
-	if (m_object)
-	{
-		m_object->activate(true);
-		if (m_object->isStaticObject())
-		{
-			if (!m_cci.m_bSensor)
-				m_object->setCollisionFlags(m_object->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
-			// kinematic object should not set the transform, it disturbs the velocity interpolation
-			return;
-		}
-		// not required
-		//m_MotionState->setWorldOrientation(quatImag0,quatImag1,quatImag2,quatReal);
-		btTransform xform  = m_object->getWorldTransform();
-		xform.setRotation(btQuaternion(quatImag0,quatImag1,quatImag2,quatReal));
-		SetCenterOfMassTransform(xform);
-		// not required
-		//m_bulletMotionState->setWorldTransform(xform);
-		
-		
-
-	}
 
+void		CcdPhysicsController::SetOrientation(const MT_Matrix3x3& orn)
+{
+	btMatrix3x3 btmat(orn[0][0], orn[0][1], orn[0][2], orn[1][0], orn[1][1], orn[1][2], orn[2][0], orn[2][1], orn[2][2]);
+	SetWorldOrientation(btmat);
 }
 
-void CcdPhysicsController::setWorldOrientation(const btMatrix3x3& orn)
+void CcdPhysicsController::SetWorldOrientation(const btMatrix3x3& orn)
 {
 	if (m_object)
 	{
@@ -1045,7 +1013,7 @@ void CcdPhysicsController::setWorldOrientation(const btMatrix3x3& orn)
 
 }
 
-void		CcdPhysicsController::setPosition(float posX,float posY,float posZ)
+void		CcdPhysicsController::SetPosition(const MT_Vector3& pos)
 {
 	if (m_object)
 	{
@@ -1060,7 +1028,7 @@ void		CcdPhysicsController::setPosition(float posX,float posY,float posZ)
 		// not required, this function is only used to update the physic controller
 		//m_MotionState->setWorldPosition(posX,posY,posZ);
 		btTransform xform  = m_object->getWorldTransform();
-		xform.setOrigin(btVector3(posX,posY,posZ));
+		xform.setOrigin(btVector3(pos.x(), pos.y(), pos.z()));
 		SetCenterOfMassTransform(xform);
 		if (!m_softBodyTransformInitialized)
 			m_softbodyStartTrans.setOrigin(xform.getOrigin());
@@ -1069,7 +1037,7 @@ void		CcdPhysicsController::setPosition(float posX,float posY,float posZ)
 	}
 }
 
-void CcdPhysicsController::forceWorldTransform(const btMatrix3x3& mat, const btVector3& pos)
+void CcdPhysicsController::ForceWorldTransform(const btMatrix3x3& mat, const btVector3& pos)
 {
 	if (m_object)
 	{
@@ -1080,11 +1048,44 @@ void CcdPhysicsController::forceWorldTransform(const btMatrix3x3& mat, const btV
 }
 
 
-void		CcdPhysicsController::resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ)
+void		CcdPhysicsController::ResolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ)
 {
 }
 
-void 		CcdPhysicsController::getPosition(MT_Vector3&	pos) const
+void	CcdPhysicsController::SuspendDynamics(bool ghost)
+{
+	btRigidBody *body = GetRigidBody();
+	if (body && !m_suspended && !GetConstructionInfo().m_bSensor)
+	{
+		m_savedCollisionFlags = body->getCollisionFlags();
+		m_savedMass = GetMass();
+		m_suspended = true;
+		GetPhysicsEnvironment()->UpdateCcdPhysicsController(this,
+			0.0,
+			btCollisionObject::CF_STATIC_OBJECT|((ghost)?btCollisionObject::CF_NO_CONTACT_RESPONSE:(m_savedCollisionFlags&btCollisionObject::CF_NO_CONTACT_RESPONSE)),
+			btBroadphaseProxy::StaticFilter,
+			btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
+	}
+}
+
+void	CcdPhysicsController::RestoreDynamics()
+{
+	btRigidBody *body = GetRigidBody();
+	if (body && m_suspended)
+	{
+		// before make sure any position change that was done in this logic frame are accounted for
+		SetTransform();
+		GetPhysicsEnvironment()->UpdateCcdPhysicsController(this,
+			m_savedMass,
+			m_savedCollisionFlags,
+			GetConstructionInfo().m_collisionFilterGroup,
+			GetConstructionInfo().m_collisionFilterMask);
+		body->activate();
+		m_suspended = false;
+	}
+}
+
+void 		CcdPhysicsController::GetPosition(MT_Vector3&	pos) const
 {
 	const btTransform& xform = m_object->getWorldTransform();
 	pos[0] = xform.getOrigin().x();
@@ -1092,13 +1093,13 @@ void 		CcdPhysicsController::getPosition(MT_Vector3&	pos) const
 	pos[2] = xform.getOrigin().z();
 }
 
-void		CcdPhysicsController::setScaling(float scaleX,float scaleY,float scaleZ)
+void		CcdPhysicsController::SetScaling(const MT_Vector3& scale)
 {
-	if (!btFuzzyZero(m_cci.m_scaling.x()-scaleX) ||
-		!btFuzzyZero(m_cci.m_scaling.y()-scaleY) ||
-		!btFuzzyZero(m_cci.m_scaling.z()-scaleZ))
+	if (!btFuzzyZero(m_cci.m_scaling.x()-scale.x()) ||
+	    !btFuzzyZero(m_cci.m_scaling.y()-scale.y()) ||
+	    !btFuzzyZero(m_cci.m_scaling.z()-scale.z()))
 	{
-		m_cci.m_scaling = btVector3(scaleX,scaleY,scaleZ);
+		m_cci.m_scaling = btVector3(scale.x(),scale.y(),scale.z());
 
 		if (m_object && m_object->getCollisionShape())
 		{
@@ -1116,11 +1117,64 @@ void		CcdPhysicsController::setScaling(float scaleX,float scaleY,float scaleZ)
 		}
 	}
 }
+
+void CcdPhysicsController::SetTransform()
+{
+	btVector3 pos;
+	btVector3 scale;
+	float ori[12];
+	m_MotionState->GetWorldPosition(pos.m_floats[0],pos.m_floats[1],pos.m_floats[2]);
+	m_MotionState->GetWorldScaling(scale.m_floats[0],scale.m_floats[1],scale.m_floats[2]);
+	m_MotionState->GetWorldOrientation(ori);
+	btMatrix3x3 rot(ori[0], ori[4], ori[8],
+					ori[1], ori[5], ori[9],
+					ori[2], ori[6], ori[10]);
+	ForceWorldTransform(rot, pos);
+
+	if (!IsDynamic() && !GetConstructionInfo().m_bSensor && !GetCharacterController())
+	{
+		btCollisionObject* object = GetRigidBody();
+		object->setActivationState(ACTIVE_TAG);
+		object->setCollisionFlags(object->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
+	}
+}
+
+MT_Scalar	CcdPhysicsController::GetMass()
+{
+	if (GetSoftBody())
+		return GetSoftBody()->getTotalMass();
+
+	MT_Scalar invmass = 0.f;
+	if (GetRigidBody())
+		invmass = GetRigidBody()->getInvMass();
+	if (invmass)
+		return 1.f/invmass;
+	return 0.f;
+
+}
+
+void CcdPhysicsController::SetMass(MT_Scalar newmass)
+{
+	btRigidBody *body = GetRigidBody();
+	if (body && !m_suspended && newmass>MT_EPSILON && GetMass()>MT_EPSILON)
+	{
+		btVector3 grav = body->getGravity();
+		btVector3 accel = grav / GetMass();
+
+		btBroadphaseProxy* handle = body->getBroadphaseHandle();
+		GetPhysicsEnvironment()->UpdateCcdPhysicsController(this,
+			newmass,
+			body->getCollisionFlags(),
+			handle->m_collisionFilterGroup,
+			handle->m_collisionFilterMask);
+		body->setGravity(accel);
+	}
+}
 		
 		// physics methods
-void		CcdPhysicsController::ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local)
+void		CcdPhysicsController::ApplyTorque(const MT_Vector3&  torquein,bool local)
 {
-	btVector3 torque(torqueX,torqueY,torqueZ);
+	btVector3 torque(torquein.x(),torquein.y(),torquein.z());
 	btTransform xform = m_object->getWorldTransform();
 	
 
@@ -1158,9 +1212,9 @@ void		CcdPhysicsController::ApplyTorque(float torqueX,float torqueY,float torque
 	}
 }
 
-void		CcdPhysicsController::ApplyForce(float forceX,float forceY,float forceZ,bool local)
+void		CcdPhysicsController::ApplyForce(const MT_Vector3& forcein,bool local)
 {
-	btVector3 force(forceX,forceY,forceZ);
+	btVector3 force(forcein.x(),forcein.y(),forcein.z());
 	
 
 	if (m_object && force.length2() > (SIMD_EPSILON*SIMD_EPSILON))
@@ -1191,9 +1245,9 @@ void		CcdPhysicsController::ApplyForce(float forceX,float forceY,float forceZ,bo
 		}
 	}
 }
-void		CcdPhysicsController::SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local)
+void		CcdPhysicsController::SetAngularVelocity(const MT_Vector3& ang_vel,bool local)
 {
-	btVector3 angvel(ang_velX,ang_velY,ang_velZ);
+	btVector3 angvel(ang_vel.x(),ang_vel.y(),ang_vel.z());
 	if (m_object && angvel.length2() > (SIMD_EPSILON*SIMD_EPSILON))
 	{
 		m_object->activate(true);
@@ -1214,10 +1268,10 @@ void		CcdPhysicsController::SetAngularVelocity(float ang_velX,float ang_velY,flo
 	}
 
 }
-void		CcdPhysicsController::SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local)
+void		CcdPhysicsController::SetLinearVelocity(const MT_Vector3& lin_vel,bool local)
 {
 
-	btVector3 linVel(lin_velX,lin_velY,lin_velZ);
+	btVector3 linVel(lin_vel.x(),lin_vel.y(),lin_vel.z());
 	if (m_object/* && linVel.length2() > (SIMD_EPSILON*SIMD_EPSILON)*/)
 	{
 		m_object->activate(true);
@@ -1249,9 +1303,9 @@ void		CcdPhysicsController::SetLinearVelocity(float lin_velX,float lin_velY,floa
 		}
 	}
 }
-void		CcdPhysicsController::applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ)
+void		CcdPhysicsController::ApplyImpulse(const MT_Point3& attach, const MT_Vector3& impulsein)
 {
-	btVector3 impulse(impulseX,impulseY,impulseZ);
+	btVector3 impulse(impulsein.x(), impulsein.y(), impulsein.z());
 
 	if (m_object && impulse.length2() > (SIMD_EPSILON*SIMD_EPSILON))
 	{
@@ -1263,7 +1317,7 @@ void		CcdPhysicsController::applyImpulse(float attachX,float attachY,float attac
 			return;
 		}
 		
-		btVector3 pos(attachX,attachY,attachZ);
+		btVector3 pos(attach.x(), attach.y(), attach.z());
 		btRigidBody* body = GetRigidBody();
 		if (body)
 			body->applyImpulse(impulse,pos);
@@ -1282,82 +1336,59 @@ void		CcdPhysicsController::SetActive(bool active)
 {
 }
 		// reading out information from physics
-void		CcdPhysicsController::GetLinearVelocity(float& linvX,float& linvY,float& linvZ)
+MT_Vector3		CcdPhysicsController::GetLinearVelocity()
 {
 	btRigidBody* body = GetRigidBody();
 	if (body)
 	{
 		const btVector3& linvel = body->getLinearVelocity();
-		linvX = linvel.x();
-		linvY = linvel.y();
-		linvZ = linvel.z();
-	} else
-	{
-		linvX = 0.f;
-		linvY = 0.f;
-		linvZ = 0.f;
+		return MT_Vector3(linvel.x(), linvel.y(), linvel.z());
 	}
 
+	return MT_Vector3(0.f, 0.f, 0.f);
 }
 
-void		CcdPhysicsController::GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ)
+MT_Vector3		CcdPhysicsController::GetAngularVelocity()
 {
 	btRigidBody* body = GetRigidBody();
 	if (body)
 	{
 		const btVector3& angvel= body->getAngularVelocity();
-		angVelX = angvel.x();
-		angVelY = angvel.y();
-		angVelZ = angvel.z();
-	} else
-	{
-		angVelX = 0.f;
-		angVelY = 0.f;
-		angVelZ = 0.f;
+		return MT_Vector3(angvel.x(), angvel.y(), angvel.z());
 	}
+
+	return MT_Vector3(0.f, 0.f, 0.f);
 }
 
-void		CcdPhysicsController::GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ)
+MT_Vector3		CcdPhysicsController::GetVelocity(const MT_Point3 &posin)
 {
-	btVector3 pos(posX,posY,posZ);
+	btVector3 pos(pos.x(), pos.y(), pos.z());
 	btRigidBody* body = GetRigidBody();
 	if (body)
 	{
 		btVector3 linvel = body->getVelocityInLocalPoint(pos);
-		linvX = linvel.x();
-		linvY = linvel.y();
-		linvZ = linvel.z();
-	} else
-	{
-		linvX = 0.f;
-		linvY = 0.f;
-		linvZ = 0.f;
+		return MT_Vector3(linvel.x(), linvel.y(), linvel.z());
 	}
-}
 
-void		CcdPhysicsController::GetWalkDirection(float& dirX,float& dirY,float& dirZ)
-{
-	if (m_object && m_characterController)
-	{
-		const btVector3 dir = m_characterController->getWalkDirection();
-		dirX = dir.x();
-		dirY = dir.y();
-		dirZ = dir.z();
-	}
-	else
-	{
-		dirX = 0.f;
-		dirY = 0.f;
-		dirZ = 0.f;
-	}
+	return MT_Vector3(0.f, 0.f, 0.f);
 }
 
-void		CcdPhysicsController::getReactionForce(float& forceX,float& forceY,float& forceZ)
+MT_Vector3 CcdPhysicsController::GetLocalInertia()
 {
+	MT_Vector3 inertia(0.f, 0.f, 0.f);
+	btVector3 inv_inertia;
+	if (GetRigidBody()) {
+		inv_inertia = GetRigidBody()->getInvInertiaDiagLocal();
+		if (!btFuzzyZero(inv_inertia.getX()) &&
+		        !btFuzzyZero(inv_inertia.getY()) &&
+		        !btFuzzyZero(inv_inertia.getZ()))
+			inertia = MT_Vector3(1.f/inv_inertia.getX(), 1.f/inv_inertia.getY(), 1.f/inv_inertia.getZ());
+	}
+	return inertia;
 }
 
 		// dyna's that are rigidbody are free in orientation, dyna's with non-rigidbody are restricted 
-void		CcdPhysicsController::setRigidBody(bool rigid)
+void		CcdPhysicsController::SetRigidBody(bool rigid)
 {
 	btRigidBody* body = GetRigidBody();
 	if (body)
@@ -1373,13 +1404,21 @@ void		CcdPhysicsController::setRigidBody(bool rigid)
 }
 
 		// clientinfo for raycasts for example
-void*		CcdPhysicsController::getNewClientInfo()
+void*		CcdPhysicsController::GetNewClientInfo()
 {
 	return m_newClientInfo;
 }
-void		CcdPhysicsController::setNewClientInfo(void* clientinfo)
+void		CcdPhysicsController::SetNewClientInfo(void* clientinfo)
 {
 	m_newClientInfo = clientinfo;
+
+	if (m_cci.m_bSensor)
+	{
+		// use a different callback function for sensor object,
+		// bullet will not synchronize, we must do it explicitly
+		SG_Callbacks& callbacks = KX_GameObject::GetClientObject((KX_ClientObjectInfo*)clientinfo)->GetSGNode()->GetCallBackFunctions();
+		callbacks.m_updatefunc = KX_GameObject::SynchronizeTransformFunc;
+	}
 }
 
 
@@ -1392,7 +1431,7 @@ void	CcdPhysicsController::UpdateDeactivation(float timeStep)
 	}
 }
 
-bool CcdPhysicsController::wantsSleeping()
+bool CcdPhysicsController::WantsSleeping()
 {
 	btRigidBody* body = GetRigidBody();
 	if (body)
@@ -1402,8 +1441,143 @@ bool CcdPhysicsController::wantsSleeping()
 	//check it out
 	return true;
 }
+/* This function dynamically adds the collision shape of another controller to
+ * the current controller shape provided it is a compound shape.
+ * The idea is that dynamic parenting on a compound object will dynamically extend the shape
+ */
+void    CcdPhysicsController::AddCompoundChild(PHY_IPhysicsController* child)
+{
+	if (child == NULL || !IsCompound())
+		return;
+	// other controller must be a bullet controller too
+	// verify that body and shape exist and match
+	CcdPhysicsController* childCtrl = dynamic_cast<CcdPhysicsController*>(child);
+	btRigidBody* rootBody = GetRigidBody();
+	btRigidBody* childBody = childCtrl->GetRigidBody();
+	if (!rootBody || !childBody)
+		return;
+	const btCollisionShape* rootShape = rootBody->getCollisionShape();
+	const btCollisionShape* childShape = childBody->getCollisionShape();
+	if (!rootShape ||
+		!childShape ||
+		rootShape->getShapeType() != COMPOUND_SHAPE_PROXYTYPE ||
+		childShape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE)
+		return;
+	btCompoundShape* compoundShape = (btCompoundShape*)rootShape;
+	// compute relative transformation between parent and child
+	btTransform rootTrans;
+	btTransform childTrans;
+	rootBody->getMotionState()->getWorldTransform(rootTrans);
+	childBody->getMotionState()->getWorldTransform(childTrans);
+	btVector3 rootScale = rootShape->getLocalScaling();
+	rootScale[0] = 1.0/rootScale[0];
+	rootScale[1] = 1.0/rootScale[1];
+	rootScale[2] = 1.0/rootScale[2];
+	// relative scale = child_scale/parent_scale
+	btVector3 relativeScale = childShape->getLocalScaling()*rootScale;
+	btMatrix3x3 rootRotInverse = rootTrans.getBasis().transpose();
+	// relative pos = parent_rot^-1 * ((parent_pos-child_pos)/parent_scale)
+	btVector3 relativePos = rootRotInverse*((childTrans.getOrigin()-rootTrans.getOrigin())*rootScale);
+	// relative rot = parent_rot^-1 * child_rot
+	btMatrix3x3 relativeRot = rootRotInverse*childTrans.getBasis();
+	// create a proxy shape info to store the transformation
+	CcdShapeConstructionInfo* proxyShapeInfo = new CcdShapeConstructionInfo();
+	// store the transformation to this object shapeinfo
+	proxyShapeInfo->m_childTrans.setOrigin(relativePos);
+	proxyShapeInfo->m_childTrans.setBasis(relativeRot);
+	proxyShapeInfo->m_childScale.setValue(relativeScale[0], relativeScale[1], relativeScale[2]);
+	// we will need this to make sure that we remove the right proxy later when unparenting
+	proxyShapeInfo->m_userData = childCtrl;
+	proxyShapeInfo->SetProxy(childCtrl->GetShapeInfo()->AddRef());
+	// add to parent compound shapeinfo (increments ref count)
+	GetShapeInfo()->AddShape(proxyShapeInfo);
+	// create new bullet collision shape from the object shapeinfo and set scaling
+	btCollisionShape* newChildShape = proxyShapeInfo->CreateBulletShape(childCtrl->GetMargin(), childCtrl->GetConstructionInfo().m_bGimpact, true);
+	newChildShape->setLocalScaling(relativeScale);
+	// add bullet collision shape to parent compound collision shape
+	compoundShape->addChildShape(proxyShapeInfo->m_childTrans,newChildShape);
+	// proxyShapeInfo is not needed anymore, release it
+	proxyShapeInfo->Release();
+	// remember we created this shape
+	childCtrl->m_bulletChildShape = newChildShape;
+	// recompute inertia of parent
+	if (!rootBody->isStaticOrKinematicObject())
+	{
+		btVector3 localInertia;
+		float mass = 1.f/rootBody->getInvMass();
+		compoundShape->calculateLocalInertia(mass,localInertia);
+		rootBody->setMassProps(mass,localInertia);
+	}
+	// must update the broadphase cache,
+	GetPhysicsEnvironment()->RefreshCcdPhysicsController(this);
+	// remove the children
+	GetPhysicsEnvironment()->DisableCcdPhysicsController(childCtrl);
+}
+
+/* Reverse function of the above, it will remove a shape from a compound shape
+ * provided that the former was added to the later using  AddCompoundChild()
+ */
+void    CcdPhysicsController::RemoveCompoundChild(PHY_IPhysicsController* child)
+{
+	if (child == NULL || !IsCompound())
+		return;
+	// other controller must be a bullet controller too
+	// verify that body and shape exist and match
+	CcdPhysicsController* childCtrl = dynamic_cast<CcdPhysicsController*>(child);
+	btRigidBody* rootBody = GetRigidBody();
+	btRigidBody* childBody = childCtrl->GetRigidBody();
+	if (!rootBody || !childBody)
+		return;
+	const btCollisionShape* rootShape = rootBody->getCollisionShape();
+	if (!rootShape ||
+		rootShape->getShapeType() != COMPOUND_SHAPE_PROXYTYPE)
+		return;
+	btCompoundShape* compoundShape = (btCompoundShape*)rootShape;
+	// retrieve the shapeInfo
+	CcdShapeConstructionInfo* childShapeInfo = childCtrl->GetShapeInfo();
+	CcdShapeConstructionInfo* rootShapeInfo = GetShapeInfo();
+	// and verify that the child is part of the parent
+	int i = rootShapeInfo->FindChildShape(childShapeInfo, childCtrl);
+	if (i < 0)
+		return;
+	rootShapeInfo->RemoveChildShape(i);
+	if (childCtrl->m_bulletChildShape)
+	{
+		int numChildren = compoundShape->getNumChildShapes();
+		for (i=0; i<numChildren; i++)
+		{
+			if (compoundShape->getChildShape(i) == childCtrl->m_bulletChildShape)
+			{
+				compoundShape->removeChildShapeByIndex(i);
+				compoundShape->recalculateLocalAabb();
+				break;
+			}
+		}
+		delete childCtrl->m_bulletChildShape;
+		childCtrl->m_bulletChildShape = NULL;
+	}
+	// recompute inertia of parent
+	if (!rootBody->isStaticOrKinematicObject())
+	{
+		btVector3 localInertia;
+		float mass = 1.f/rootBody->getInvMass();
+		compoundShape->calculateLocalInertia(mass,localInertia);
+		rootBody->setMassProps(mass,localInertia);
+	}
+	// must update the broadphase cache,
+	GetPhysicsEnvironment()->RefreshCcdPhysicsController(this);
+	// reactivate the children
+	GetPhysicsEnvironment()->EnableCcdPhysicsController(childCtrl);
+}
+
+PHY_IPhysicsController* CcdPhysicsController::GetReplica()
+{
+	CcdPhysicsController* replica = new CcdPhysicsController(*this);
+	return replica;
+}
 
-PHY_IPhysicsController*	CcdPhysicsController::GetReplica()
+// Keeping this separate for now, maybe we can combine it with GetReplica()...
+PHY_IPhysicsController*	CcdPhysicsController::GetReplicaForSensors()
 {
 	// This is used only to replicate Near and Radar sensor controllers
 	// The replication of object physics controller is done in KX_BulletPhysicsController::GetReplica()
@@ -1462,21 +1636,21 @@ DefaultMotionState::~DefaultMotionState()
 
 }
 
-void	DefaultMotionState::getWorldPosition(float& posX,float& posY,float& posZ)
+void	DefaultMotionState::GetWorldPosition(float& posX,float& posY,float& posZ)
 {
 	posX = m_worldTransform.getOrigin().x();
 	posY = m_worldTransform.getOrigin().y();
 	posZ = m_worldTransform.getOrigin().z();
 }
 
-void	DefaultMotionState::getWorldScaling(float& scaleX,float& scaleY,float& scaleZ)
+void	DefaultMotionState::GetWorldScaling(float& scaleX,float& scaleY,float& scaleZ)
 {
 	scaleX = m_localScaling.getX();
 	scaleY = m_localScaling.getY();
 	scaleZ = m_localScaling.getZ();
 }
 
-void	DefaultMotionState::getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal)
+void	DefaultMotionState::GetWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal)
 {
 	btQuaternion quat = m_worldTransform.getRotation();
 	quatIma0 = quat.x();
@@ -1485,28 +1659,28 @@ void	DefaultMotionState::getWorldOrientation(float& quatIma0,float& quatIma1,flo
 	quatReal = quat[3];
 }
 		
-void	DefaultMotionState::getWorldOrientation(float* ori)
+void	DefaultMotionState::GetWorldOrientation(float* ori)
 {
 	m_worldTransform.getBasis().getOpenGLSubMatrix(ori);
 }
 
-void	DefaultMotionState::setWorldOrientation(const float* ori)
+void	DefaultMotionState::SetWorldOrientation(const float* ori)
 {
 	m_worldTransform.getBasis().setFromOpenGLSubMatrix(ori);
 }
-void	DefaultMotionState::setWorldPosition(float posX,float posY,float posZ)
+void	DefaultMotionState::SetWorldPosition(float posX,float posY,float posZ)
 {
 	btVector3 pos(posX,posY,posZ);
 	m_worldTransform.setOrigin( pos );
 }
 
-void	DefaultMotionState::setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal)
+void	DefaultMotionState::SetWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal)
 {
 	btQuaternion orn(quatIma0,quatIma1,quatIma2,quatReal);
 	m_worldTransform.setRotation( orn );
 }
 		
-void	DefaultMotionState::calculateWorldTransformations()
+void	DefaultMotionState::CalculateWorldTransformations()
 {
 
 }
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.h b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
index f1f0ca31419..ecb894c1e8d 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
@@ -33,6 +33,7 @@ subject to the following restrictions:
 #include "LinearMath/btTransform.h"
 
 #include "PHY_IMotionState.h"
+#include "PHY_ICharacter.h"
 
 extern float gDeactivationTime;
 extern float gLinearSleepingTreshold;
@@ -266,6 +267,7 @@ struct CcdConstructionInfo
 		m_soft_kSHR(1.0f),
 		m_soft_kAHR(0.7f),
 		m_collisionFlags(0),
+	    m_bDyna(false),
 		m_bRigid(false),
 		m_bSoft(false),
 		m_bSensor(false),
@@ -349,6 +351,7 @@ struct CcdConstructionInfo
 
 
 	int			m_collisionFlags;
+	bool		m_bDyna;
 	bool		m_bRigid;
 	bool		m_bSoft;
 	bool		m_bSensor;
@@ -396,7 +399,7 @@ class btCollisionObject;
 class btSoftBody;
 class btPairCachingGhostObject;
 
-class BlenderBulletCharacterController : public btKinematicCharacterController
+class BlenderBulletCharacterController : public btKinematicCharacterController, public PHY_ICharacter
 {
 private:
 	btMotionState* m_motionState;
@@ -419,6 +422,25 @@ public:
 	virtual void jump();
 
 	const btVector3& getWalkDirection();
+
+	// PHY_ICharacter interface
+	virtual void Jump()	{ jump(); }
+	virtual bool OnGround(){ return onGround(); }
+	virtual float GetGravity() { return getGravity(); }
+	virtual void SetGravity(float gravity) { setGravity(gravity); }
+	virtual int GetMaxJumps() { return getMaxJumps(); }
+	virtual void SetMaxJumps(int maxJumps) { setMaxJumps(maxJumps); }
+	virtual int GetJumpCount() { return getJumpCount(); }
+	virtual void SetWalkDirection(const MT_Vector3& dir)
+	{
+		btVector3 vec = btVector3(dir[0], dir[1], dir[2]);
+		setWalkDirection(vec);
+	}
+	virtual MT_Vector3 GetWalkDirection()
+	{
+		btVector3 vec = getWalkDirection();
+		return MT_Vector3(vec[0], vec[1], vec[2]);
+	}
 };
 
 ///CcdPhysicsController is a physics object that supports continuous collision detection and time of impact based physics resolution.
@@ -433,6 +455,7 @@ protected:
 	btMotionState* 	m_bulletMotionState;
 	class btCollisionShape*	m_collisionShape;
 	class CcdShapeConstructionInfo* m_shapeInfo;
+	btCollisionShape* m_bulletChildShape;
 
 	friend class CcdPhysicsEnvironment;	// needed when updating the controller
 
@@ -449,6 +472,10 @@ protected:
 
 	CcdPhysicsController* m_parentCtrl;
 
+	int m_savedCollisionFlags;
+	MT_Scalar m_savedMass;
+	bool m_suspended;
+
 	void GetWorldOrientation(btMatrix3x3& mat);
 
 	void CreateRigidbody();
@@ -462,8 +489,8 @@ protected:
 		return (--m_registerCount == 0) ? true : false;
 	}
 
-	void setWorldOrientation(const btMatrix3x3& mat);
-	void forceWorldTransform(const btMatrix3x3& mat, const btVector3& pos);
+	void SetWorldOrientation(const btMatrix3x3& mat);
+	void ForceWorldTransform(const btMatrix3x3& mat, const btVector3& pos);
 
 	public:
 	
@@ -477,11 +504,11 @@ protected:
 
 		virtual ~CcdPhysicsController();
 
-		CcdConstructionInfo& getConstructionInfo()
+		CcdConstructionInfo& GetConstructionInfo()
 		{
 			return m_cci;
 		}
-		const CcdConstructionInfo& getConstructionInfo() const
+		const CcdConstructionInfo& GetConstructionInfo() const
 		{
 			return m_cci;
 		}
@@ -518,42 +545,51 @@ protected:
 		virtual void		SetPhysicsEnvironment(class PHY_IPhysicsEnvironment *env);
 
 		// kinematic methods
-		virtual void		RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local);
-		virtual void		SetWalkDirection(float dirX,float dirY,float dirZ,bool local);
-		virtual void		RelativeRotate(const float drot[9],bool local);
-		virtual	void		getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal);
-		virtual	void		setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal);
-		virtual	void		setPosition(float posX,float posY,float posZ);
-		virtual	void 		getPosition(MT_Vector3&	pos) const;
-
-		virtual	void		setScaling(float scaleX,float scaleY,float scaleZ);
+		virtual void		RelativeTranslate(const MT_Vector3& dloc,bool local);
+		virtual void		RelativeRotate(const MT_Matrix3x3&rotval, bool local);
+		virtual	MT_Matrix3x3	GetOrientation();
+		virtual	void		SetOrientation(const MT_Matrix3x3& orn);
+		virtual	void		SetPosition(const MT_Vector3& pos);
+		virtual	void 		GetPosition(MT_Vector3&	pos) const;
+		virtual	void		SetScaling(const MT_Vector3& scale);
+		virtual void		SetTransform();
+
+		virtual	MT_Scalar	GetMass();
+		virtual void	SetMass(MT_Scalar newmass);
 		
 		// physics methods
-		virtual void		ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local);
-		virtual void		ApplyForce(float forceX,float forceY,float forceZ,bool local);
-		virtual void		SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local);
-		virtual void		SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local);
-		virtual void		applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ);
+		virtual void		ApplyImpulse(const MT_Point3& attach, const MT_Vector3& impulsein);
+		virtual void		ApplyTorque(const MT_Vector3& torque,bool local);
+		virtual void		ApplyForce(const MT_Vector3& force,bool local);
+		virtual void		SetAngularVelocity(const MT_Vector3& ang_vel,bool local);
+		virtual void		SetLinearVelocity(const MT_Vector3& lin_vel,bool local);
 		virtual void		Jump();
 		virtual void		SetActive(bool active);
 
 		// reading out information from physics
-		virtual void		GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
-		virtual void		GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ);
-		virtual void		GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
-		virtual	void		getReactionForce(float& forceX,float& forceY,float& forceZ);
-		virtual void		GetWalkDirection(float& dirX,float& dirY,float& dirZ);
+		virtual MT_Vector3	GetLinearVelocity();
+		virtual MT_Vector3	GetAngularVelocity();
+		virtual MT_Vector3	GetVelocity(const MT_Point3& posin);
+		virtual	MT_Vector3	GetLocalInertia();
 
 		// dyna's that are rigidbody are free in orientation, dyna's with non-rigidbody are restricted 
-		virtual	void		setRigidBody(bool rigid);
+		virtual	void		SetRigidBody(bool rigid);
 
 		
-		virtual void		resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
+		virtual void		ResolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
+
+		virtual void		SuspendDynamics(bool ghost);
+		virtual void		RestoreDynamics();
+
+		// Shape control
+		virtual void    AddCompoundChild(PHY_IPhysicsController* child);
+		virtual void    RemoveCompoundChild(PHY_IPhysicsController* child);
 
 		// clientinfo for raycasts for example
-		virtual	void*				getNewClientInfo();
-		virtual	void				setNewClientInfo(void* clientinfo);
+		virtual	void*				GetNewClientInfo();
+		virtual	void				SetNewClientInfo(void* clientinfo);
 		virtual PHY_IPhysicsController*	GetReplica();
+		virtual PHY_IPhysicsController* GetReplicaForSensors();
 		
 		///There should be no 'SetCollisionFilterGroup' method, as changing this during run-time is will result in errors
 		short int	GetCollisionFilterGroup() const
@@ -566,7 +602,7 @@ protected:
 			return m_cci.m_collisionFilterMask;
 		}
 
-		virtual void calcXform() {}
+		virtual void CalcXform() {}
 		virtual void SetMargin(float margin) 
 		{
 			if (m_collisionShape)
@@ -609,7 +645,7 @@ protected:
 			return m_cci.m_clamp_vel_max;
 		}
 
-		bool	wantsSleeping();
+		bool	WantsSleeping();
 
 		void	UpdateDeactivation(float timeStep);
 
@@ -635,24 +671,29 @@ protected:
 			return m_cci.m_physicsEnv;
 		}
 
-		void	setParentCtrl(CcdPhysicsController* parentCtrl)
+		void	SetParentCtrl(CcdPhysicsController* parentCtrl)
 		{
 			m_parentCtrl = parentCtrl;
 		}
 
-		CcdPhysicsController*	getParentCtrl()
+		CcdPhysicsController*	GetParentCtrl()
 		{
 			return m_parentCtrl;
 		}
 
-		const CcdPhysicsController*	getParentCtrl() const
+		const CcdPhysicsController*	GetParentCtrl() const
 		{
 			return m_parentCtrl;
 		}
 
-		virtual const char* getName()
+		virtual bool IsDynamic()
+		{
+			return GetConstructionInfo().m_bDyna;
+		}
+
+		virtual bool IsCompound()
 		{
-			return 0;
+			return GetConstructionInfo().m_shapeInfo->m_shapeType == PHY_SHAPE_COMPOUND;
 		}
 
 #ifdef WITH_CXX_GUARDEDALLOC
@@ -672,16 +713,16 @@ class	DefaultMotionState : public PHY_IMotionState
 
 		virtual ~DefaultMotionState();
 
-		virtual void	getWorldPosition(float& posX,float& posY,float& posZ);
-		virtual void	getWorldScaling(float& scaleX,float& scaleY,float& scaleZ);
-		virtual void	getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal);
+		virtual void	GetWorldPosition(float& posX,float& posY,float& posZ);
+		virtual void	GetWorldScaling(float& scaleX,float& scaleY,float& scaleZ);
+		virtual void	GetWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal);
 		
-		virtual void	setWorldPosition(float posX,float posY,float posZ);
-		virtual	void	setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal);
-		virtual void	getWorldOrientation(float* ori);
-		virtual void	setWorldOrientation(const float* ori);
+		virtual void	SetWorldPosition(float posX,float posY,float posZ);
+		virtual	void	SetWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal);
+		virtual void	GetWorldOrientation(float* ori);
+		virtual void	SetWorldOrientation(const float* ori);
 		
-		virtual	void	calculateWorldTransformations();
+		virtual	void	CalculateWorldTransformations();
 		
 		btTransform	m_worldTransform;
 		btVector3		m_localScaling;
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
index e01530f2b11..10be1876e41 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
@@ -127,8 +127,8 @@ public:
 			btTransform trans = m_vehicle->getWheelInfo(i).m_worldTransform;
 			btQuaternion orn = trans.getRotation();
 			const btVector3& pos = trans.getOrigin();
-			motionState->setWorldOrientation(orn.x(),orn.y(),orn.z(),orn[3]);
-			motionState->setWorldPosition(pos.x(),pos.y(),pos.z());
+			motionState->SetWorldOrientation(orn.x(),orn.y(),orn.z(),orn[3]);
+			motionState->SetWorldPosition(pos.x(),pos.y(),pos.z());
 
 		}
 	}
@@ -265,63 +265,6 @@ public:
 };
 #endif //NEW_BULLET_VEHICLE_SUPPORT
 
-class CharacterWrapper : public PHY_ICharacter
-{
-private:
-	BlenderBulletCharacterController* m_controller;
-
-public:
-	CharacterWrapper(BlenderBulletCharacterController* cont)
-		: m_controller(cont)
-	{}
-
-	virtual void Jump()
-	{
-		m_controller->jump();
-	}
-
-	virtual bool OnGround()
-	{
-		return m_controller->onGround();
-	}
-
-	virtual float GetGravity()
-	{
-		return m_controller->getGravity();
-	}
-	virtual void SetGravity(float gravity)
-	{
-		m_controller->setGravity(gravity);
-	}
-
-	virtual int GetMaxJumps()
-	{
-		return m_controller->getMaxJumps();
-	}
-
-	virtual void SetMaxJumps(int maxJumps)
-	{
-		m_controller->setMaxJumps(maxJumps);
-	}
-
-	virtual int GetJumpCount()
-	{
-		return m_controller->getJumpCount();
-	}
-
-	virtual void SetWalkDirection(const MT_Vector3& dir)
-	{
-		btVector3 vec = btVector3(dir[0], dir[1], dir[2]);
-		m_controller->setWalkDirection(vec);
-	}
-
-	virtual MT_Vector3 GetWalkDirection()
-	{
-		btVector3 vec = m_controller->getWalkDirection();
-		return MT_Vector3(vec[0], vec[1], vec[2]);
-	}
-};
-
 class CcdOverlapFilterCallBack : public btOverlapFilterCallback
 {
 private:
@@ -339,7 +282,7 @@ public:
 };
 
 
-void CcdPhysicsEnvironment::setDebugDrawer(btIDebugDraw* debugDrawer)
+void CcdPhysicsEnvironment::SetDebugDrawer(btIDebugDraw* debugDrawer)
 {
 	if (debugDrawer && m_dynamicsWorld)
 		m_dynamicsWorld->setDebugDrawer(debugDrawer);
@@ -429,17 +372,17 @@ m_scalingPropagated(false)
 	m_broadphase->getOverlappingPairCache()->setOverlapFilterCallback(m_filterCallback);
 	m_broadphase->getOverlappingPairCache()->setInternalGhostPairCallback(m_ghostPairCallback);
 
-	setSolverType(1);//issues with quickstep and memory allocations
+	SetSolverType(1);//issues with quickstep and memory allocations
 //	m_dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
 	m_dynamicsWorld = new btSoftRigidDynamicsWorld(dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
 	//m_dynamicsWorld->getSolverInfo().m_linearSlop = 0.01f;
 	//m_dynamicsWorld->getSolverInfo().m_solverMode=	SOLVER_USE_WARMSTARTING +	SOLVER_USE_2_FRICTION_DIRECTIONS +	SOLVER_RANDMIZE_ORDER +	SOLVER_USE_FRICTION_WARMSTARTING;
 
 	m_debugDrawer = 0;
-	setGravity(0.f,0.f,-9.81f);
+	SetGravity(0.f,0.f,-9.81f);
 }
 
-void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
+void	CcdPhysicsEnvironment::AddCcdPhysicsController(CcdPhysicsController* ctrl)
 {
 	btRigidBody* body = ctrl->GetRigidBody();
 	btCollisionObject* obj = ctrl->GetCollisionObject();
@@ -483,7 +426,7 @@ void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
 
 		
 
-bool	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctrl)
+bool	CcdPhysicsEnvironment::RemoveCcdPhysicsController(CcdPhysicsController* ctrl)
 {
 	//also remove constraint
 	btRigidBody* body = ctrl->GetRigidBody();
@@ -522,7 +465,7 @@ bool	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 	return (m_controllers.erase(ctrl) != 0);
 }
 
-void	CcdPhysicsEnvironment::updateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask)
+void	CcdPhysicsEnvironment::UpdateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask)
 {
 	// this function is used when the collisionning group of a controller is changed
 	// remove and add the collistioning object
@@ -551,7 +494,7 @@ void	CcdPhysicsEnvironment::updateCcdPhysicsController(CcdPhysicsController* ctr
 	ctrl->m_cci.m_collisionFlags = newCollisionFlags;
 }
 
-void CcdPhysicsEnvironment::enableCcdPhysicsController(CcdPhysicsController* ctrl)
+void CcdPhysicsEnvironment::EnableCcdPhysicsController(CcdPhysicsController* ctrl)
 {
 	if (m_controllers.insert(ctrl).second)
 	{
@@ -568,7 +511,7 @@ void CcdPhysicsEnvironment::enableCcdPhysicsController(CcdPhysicsController* ctr
 	}
 }
 
-void CcdPhysicsEnvironment::disableCcdPhysicsController(CcdPhysicsController* ctrl)
+void CcdPhysicsEnvironment::DisableCcdPhysicsController(CcdPhysicsController* ctrl)
 {
 	if (m_controllers.erase(ctrl))
 	{
@@ -588,7 +531,7 @@ void CcdPhysicsEnvironment::disableCcdPhysicsController(CcdPhysicsController* ct
 	}
 }
 
-void CcdPhysicsEnvironment::refreshCcdPhysicsController(CcdPhysicsController* ctrl)
+void CcdPhysicsEnvironment::RefreshCcdPhysicsController(CcdPhysicsController* ctrl)
 {
 	btCollisionObject* obj = ctrl->GetCollisionObject();
 	if (obj)
@@ -601,15 +544,15 @@ void CcdPhysicsEnvironment::refreshCcdPhysicsController(CcdPhysicsController* ct
 	}
 }
 
-void CcdPhysicsEnvironment::addCcdGraphicController(CcdGraphicController* ctrl)
+void CcdPhysicsEnvironment::AddCcdGraphicController(CcdGraphicController* ctrl)
 {
-	if (m_cullingTree && !ctrl->getBroadphaseHandle())
+	if (m_cullingTree && !ctrl->GetBroadphaseHandle())
 	{
 		btVector3	minAabb;
 		btVector3	maxAabb;
-		ctrl->getAabb(minAabb, maxAabb);
+		ctrl->GetAabb(minAabb, maxAabb);
 
-		ctrl->setBroadphaseHandle(m_cullingTree->createProxy(
+		ctrl->SetBroadphaseHandle(m_cullingTree->createProxy(
 				minAabb,
 				maxAabb,
 				INVALID_SHAPE_PROXYTYPE,	// this parameter is not used
@@ -619,35 +562,35 @@ void CcdPhysicsEnvironment::addCcdGraphicController(CcdGraphicController* ctrl)
 				NULL,						// dispatcher => this parameter is not used
 				0));
 
-		assert(ctrl->getBroadphaseHandle());
+		assert(ctrl->GetBroadphaseHandle());
 	}
 }
 
-void CcdPhysicsEnvironment::removeCcdGraphicController(CcdGraphicController* ctrl)
+void CcdPhysicsEnvironment::RemoveCcdGraphicController(CcdGraphicController* ctrl)
 {
 	if (m_cullingTree)
 	{
-		btBroadphaseProxy* bp = ctrl->getBroadphaseHandle();
+		btBroadphaseProxy* bp = ctrl->GetBroadphaseHandle();
 		if (bp)
 		{
 			m_cullingTree->destroyProxy(bp,NULL);
-			ctrl->setBroadphaseHandle(0);
+			ctrl->SetBroadphaseHandle(0);
 		}
 	}
 }
 
-void	CcdPhysicsEnvironment::beginFrame()
+void	CcdPhysicsEnvironment::BeginFrame()
 {
 
 }
 
-void CcdPhysicsEnvironment::debugDrawWorld()
+void CcdPhysicsEnvironment::DebugDrawWorld()
 {
 	if (m_dynamicsWorld->getDebugDrawer() &&  m_dynamicsWorld->getDebugDrawer()->getDebugMode() >0)
 			m_dynamicsWorld->debugDrawWorld();
 }
 
-bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep,float interval)
+bool	CcdPhysicsEnvironment::ProceedDeltaTime(double curTime,float timeStep,float interval)
 {
 	std::set<CcdPhysicsController*>::iterator it;
 	int i;
@@ -662,7 +605,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep,float
 //uncomment next line to see where Bullet spend its time (printf in console)
 //CProfileManager::dumpAll();
 
-	processFhSprings(curTime,i*subStep);
+	ProcessFhSprings(curTime,i*subStep);
 
 	for (it=m_controllers.begin(); it!=m_controllers.end(); it++)
 	{
@@ -714,7 +657,7 @@ public:
 
 };
 
-void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
+void	CcdPhysicsEnvironment::ProcessFhSprings(double curTime,float interval)
 {
 	std::set<CcdPhysicsController*>::iterator it;
 	// dynamic of Fh spring is based on a timestep of 1/60
@@ -725,12 +668,12 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 		CcdPhysicsController* ctrl = (*it);
 		btRigidBody* body = ctrl->GetRigidBody();
 
-		if (body && (ctrl->getConstructionInfo().m_do_fh || ctrl->getConstructionInfo().m_do_rot_fh))
+		if (body && (ctrl->GetConstructionInfo().m_do_fh || ctrl->GetConstructionInfo().m_do_rot_fh))
 		{
 			//printf("has Fh or RotFh\n");
 			//re-implement SM_FhObject.cpp using btCollisionWorld::rayTest and info from ctrl->getConstructionInfo()
 			//send a ray from {0.0, 0.0, 0.0} towards {0.0, 0.0, -10.0}, in local coordinates
-			CcdPhysicsController* parentCtrl = ctrl->getParentCtrl();
+			CcdPhysicsController* parentCtrl = ctrl->GetParentCtrl();
 			btRigidBody* parentBody = parentCtrl?parentCtrl->GetRigidBody() : 0;
 			btRigidBody* cl_object = parentBody ? parentBody : body;
 
@@ -756,16 +699,16 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 
 				if (controller)
 				{
-					if (controller->getConstructionInfo().m_fh_distance < SIMD_EPSILON)
+					if (controller->GetConstructionInfo().m_fh_distance < SIMD_EPSILON)
 						continue;
 
 					btRigidBody* hit_object = controller->GetRigidBody();
 					if (!hit_object)
 						continue;
 
-					CcdConstructionInfo& hitObjShapeProps = controller->getConstructionInfo();
+					CcdConstructionInfo& hitObjShapeProps = controller->GetConstructionInfo();
 
-					float distance = resultCallback.m_closestHitFraction*rayDirLocal.length()-ctrl->getConstructionInfo().m_radius;
+					float distance = resultCallback.m_closestHitFraction*rayDirLocal.length()-ctrl->GetConstructionInfo().m_radius;
 					if (distance >= hitObjShapeProps.m_fh_distance)
 						continue;
 					
@@ -778,7 +721,7 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 
 					for (int i=0; i<numIter; i++)
 					{
-						if (ctrl->getConstructionInfo().m_do_fh) 
+						if (ctrl->GetConstructionInfo().m_do_fh)
 						{
 							btVector3 lspot = cl_object->getCenterOfMassPosition() +
 							        rayDirLocal * resultCallback.m_closestHitFraction;
@@ -790,7 +733,7 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 							btVector3 rel_vel = cl_object->getLinearVelocity() - hit_object->getVelocityInLocalPoint(lspot);
 							btScalar rel_vel_ray = ray_dir.dot(rel_vel);
 							btScalar spring_extent = 1.0 - distance / hitObjShapeProps.m_fh_distance; 
-							
+
 							btScalar i_spring = spring_extent * hitObjShapeProps.m_fh_spring;
 							btScalar i_damp =   rel_vel_ray * hitObjShapeProps.m_fh_damping;
 							
@@ -803,7 +746,7 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 							btVector3 lateral = rel_vel - rel_vel_ray * ray_dir;
 							
 							
-							if (ctrl->getConstructionInfo().m_do_anisotropic) {
+							if (ctrl->GetConstructionInfo().m_do_anisotropic) {
 								//Bullet basis contains no scaling/shear etc.
 								const btMatrix3x3& lcs = cl_object->getCenterOfMassTransform().getBasis();
 								btVector3 loc_lateral = lateral * lcs;
@@ -830,7 +773,7 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 						}
 
 						
-						if (ctrl->getConstructionInfo().m_do_rot_fh) {
+						if (ctrl->GetConstructionInfo().m_do_rot_fh) {
 							btVector3 up2 = cl_object->getWorldTransform().getBasis().getColumn(2);
 
 							btVector3 t_spring = up2.cross(normal) * hitObjShapeProps.m_fh_spring;
@@ -850,69 +793,69 @@ void	CcdPhysicsEnvironment::processFhSprings(double curTime,float interval)
 	}
 }
 
-void		CcdPhysicsEnvironment::setDebugMode(int debugMode)
+void		CcdPhysicsEnvironment::SetDebugMode(int debugMode)
 {
 	if (m_debugDrawer) {
 		m_debugDrawer->setDebugMode(debugMode);
 	}
 }
 
-void		CcdPhysicsEnvironment::setNumIterations(int numIter)
+void		CcdPhysicsEnvironment::SetNumIterations(int numIter)
 {
 	m_numIterations = numIter;
 }
-void		CcdPhysicsEnvironment::setDeactivationTime(float dTime)
+void		CcdPhysicsEnvironment::SetDeactivationTime(float dTime)
 {
 	gDeactivationTime = dTime;
 }
-void		CcdPhysicsEnvironment::setDeactivationLinearTreshold(float linTresh)
+void		CcdPhysicsEnvironment::SetDeactivationLinearTreshold(float linTresh)
 {
 	gLinearSleepingTreshold = linTresh;
 }
-void		CcdPhysicsEnvironment::setDeactivationAngularTreshold(float angTresh) 
+void		CcdPhysicsEnvironment::SetDeactivationAngularTreshold(float angTresh)
 {
 	gAngularSleepingTreshold = angTresh;
 }
 
-void		CcdPhysicsEnvironment::setContactBreakingTreshold(float contactBreakingTreshold)
+void		CcdPhysicsEnvironment::SetContactBreakingTreshold(float contactBreakingTreshold)
 {
 	gContactBreakingThreshold = contactBreakingTreshold;
 
 }
 
 
-void		CcdPhysicsEnvironment::setCcdMode(int ccdMode)
+void		CcdPhysicsEnvironment::SetCcdMode(int ccdMode)
 {
 	m_ccdMode = ccdMode;
 }
 
 
-void		CcdPhysicsEnvironment::setSolverSorConstant(float sor)
+void		CcdPhysicsEnvironment::SetSolverSorConstant(float sor)
 {
 	m_dynamicsWorld->getSolverInfo().m_sor = sor;
 }
 
-void		CcdPhysicsEnvironment::setSolverTau(float tau)
+void		CcdPhysicsEnvironment::SetSolverTau(float tau)
 {
 	m_dynamicsWorld->getSolverInfo().m_tau = tau;
 }
-void		CcdPhysicsEnvironment::setSolverDamping(float damping)
+void		CcdPhysicsEnvironment::SetSolverDamping(float damping)
 {
 	m_dynamicsWorld->getSolverInfo().m_damping = damping;
 }
 
 
-void		CcdPhysicsEnvironment::setLinearAirDamping(float damping)
+void		CcdPhysicsEnvironment::SetLinearAirDamping(float damping)
 {
 	//gLinearAirDamping = damping;
 }
 
-void		CcdPhysicsEnvironment::setUseEpa(bool epa)
+void		CcdPhysicsEnvironment::SetUseEpa(bool epa)
 {
 	//gUseEpa = epa;
 }
 
-void		CcdPhysicsEnvironment::setSolverType(int solverType)
+void		CcdPhysicsEnvironment::SetSolverType(int solverType)
 {
 
 	switch (solverType)
@@ -945,7 +888,7 @@ void		CcdPhysicsEnvironment::setSolverType(int solverType)
 
 
 
-void		CcdPhysicsEnvironment::getGravity(MT_Vector3& grav)
+void		CcdPhysicsEnvironment::GetGravity(MT_Vector3& grav)
 {
 		const btVector3& gravity = m_dynamicsWorld->getGravity();
 		grav[0] = gravity.getX();
@@ -954,7 +897,7 @@ void		CcdPhysicsEnvironment::getGravity(MT_Vector3& grav)
 }
 
 
-void		CcdPhysicsEnvironment::setGravity(float x,float y,float z)
+void		CcdPhysicsEnvironment::SetGravity(float x,float y,float z)
 {
 	m_gravity = btVector3(x,y,z);
 	m_dynamicsWorld->setGravity(m_gravity);
@@ -967,7 +910,7 @@ void		CcdPhysicsEnvironment::setGravity(float x,float y,float z)
 static int gConstraintUid = 1;
 
 //Following the COLLADA physics specification for constraints
-int			CcdPhysicsEnvironment::createUniversalD6Constraint(
+int			CcdPhysicsEnvironment::CreateUniversalD6Constraint(
 						class PHY_IPhysicsController* ctrlRef,class PHY_IPhysicsController* ctrlOther,
 						btTransform& frameInA,
 						btTransform& frameInB,
@@ -1025,7 +968,7 @@ int			CcdPhysicsEnvironment::createUniversalD6Constraint(
 
 
 
-void		CcdPhysicsEnvironment::removeConstraint(int	constraintId)
+void		CcdPhysicsEnvironment::RemoveConstraint(int	constraintId)
 {
 	
 	int i;
@@ -1144,7 +1087,7 @@ static bool GetHitTriangle(btCollisionShape* shape, CcdShapeConstructionInfo* sh
 	return true;
 }
 
-PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ)
+PHY_IPhysicsController* CcdPhysicsEnvironment::RayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ)
 {
 	btVector3 rayFrom(fromX,fromY,fromZ);
 	btVector3 rayTo(toX,toY,toZ);
@@ -1798,7 +1741,7 @@ struct	DbvtCullingCallback : btDbvt::ICollide
 		btBroadphaseProxy*	proxy=(btBroadphaseProxy*)leaf->data;
 		// the client object is a graphic controller
 		CcdGraphicController* ctrl = static_cast<CcdGraphicController*>(proxy->m_clientObject);
-		KX_ClientObjectInfo *info = (KX_ClientObjectInfo*)ctrl->getNewClientInfo();
+		KX_ClientObjectInfo *info = (KX_ClientObjectInfo*)ctrl->GetNewClientInfo();
 		if (m_ocb)
 		{
 			// means we are doing occlusion culling. Check if this object is an occluders
@@ -1846,7 +1789,7 @@ struct	DbvtCullingCallback : btDbvt::ICollide
 };
 
 static OcclusionBuffer gOcb;
-bool CcdPhysicsEnvironment::cullingTest(PHY_CullingCallback callback, void* userData, MT_Vector4 *planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16])
+bool CcdPhysicsEnvironment::CullingTest(PHY_CullingCallback callback, void* userData, MT_Vector4 *planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16])
 {
 	if (!m_cullingTree)
 		return false;
@@ -1876,12 +1819,12 @@ bool CcdPhysicsEnvironment::cullingTest(PHY_CullingCallback callback, void* user
 	return true;
 }
 
-int	CcdPhysicsEnvironment::getNumContactPoints()
+int	CcdPhysicsEnvironment::GetNumContactPoints()
 {
 	return 0;
 }
 
-void CcdPhysicsEnvironment::getContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ)
+void CcdPhysicsEnvironment::GetContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ)
 {
 
 }
@@ -1889,12 +1832,12 @@ void CcdPhysicsEnvironment::getContactPoint(int i,float& hitX,float& hitY,float&
 
 
 
-btBroadphaseInterface*	CcdPhysicsEnvironment::getBroadphase()
+btBroadphaseInterface*	CcdPhysicsEnvironment::GetBroadphase()
 { 
 	return m_dynamicsWorld->getBroadphase(); 
 }
 
-btDispatcher*	CcdPhysicsEnvironment::getDispatcher()
+btDispatcher*	CcdPhysicsEnvironment::GetDispatcher()
 { 
 	return m_dynamicsWorld->getDispatcher();
 }
@@ -1908,8 +1851,8 @@ void CcdPhysicsEnvironment::MergeEnvironment(CcdPhysicsEnvironment *other)
 		it= other->m_controllers.begin();
 		CcdPhysicsController* ctrl= (*it);
 
-		other->removeCcdPhysicsController(ctrl);
-		this->addCcdPhysicsController(ctrl);
+		other->RemoveCcdPhysicsController(ctrl);
+		this->AddCcdPhysicsController(ctrl);
 	}
 }
 
@@ -1961,9 +1904,9 @@ CcdPhysicsEnvironment::~CcdPhysicsEnvironment()
 }
 
 
-float	CcdPhysicsEnvironment::getConstraintParam(int constraintId,int param)
+float	CcdPhysicsEnvironment::GetConstraintParam(int constraintId,int param)
 {
-	btTypedConstraint* typedConstraint = getConstraintById(constraintId);
+	btTypedConstraint* typedConstraint = GetConstraintById(constraintId);
 	switch (typedConstraint->getUserConstraintType())
 	{
 	case PHY_GENERIC_6DOF_CONSTRAINT:
@@ -2000,9 +1943,9 @@ float	CcdPhysicsEnvironment::getConstraintParam(int constraintId,int param)
 	return 0.f;
 }
 
-void	CcdPhysicsEnvironment::setConstraintParam(int constraintId,int param,float value0,float value1)
+void	CcdPhysicsEnvironment::SetConstraintParam(int constraintId,int param,float value0,float value1)
 {
-	btTypedConstraint* typedConstraint = getConstraintById(constraintId);
+	btTypedConstraint* typedConstraint = GetConstraintById(constraintId);
 	switch (typedConstraint->getUserConstraintType())
 	{
 	case PHY_GENERIC_6DOF_CONSTRAINT:
@@ -2110,7 +2053,7 @@ void	CcdPhysicsEnvironment::setConstraintParam(int constraintId,int param,float
 	};
 }
 
-btTypedConstraint*	CcdPhysicsEnvironment::getConstraintById(int constraintId)
+btTypedConstraint*	CcdPhysicsEnvironment::GetConstraintById(int constraintId)
 {
 
 	int numConstraints = m_dynamicsWorld->getNumConstraints();
@@ -2127,7 +2070,7 @@ btTypedConstraint*	CcdPhysicsEnvironment::getConstraintById(int constraintId)
 }
 
 
-void CcdPhysicsEnvironment::addSensor(PHY_IPhysicsController* ctrl)
+void CcdPhysicsEnvironment::AddSensor(PHY_IPhysicsController* ctrl)
 {
 
 	CcdPhysicsController* ctrl1 = (CcdPhysicsController* )ctrl;
@@ -2137,10 +2080,10 @@ void CcdPhysicsEnvironment::addSensor(PHY_IPhysicsController* ctrl)
 	//{
 	//	addCcdPhysicsController(ctrl1);
 	//}
-	enableCcdPhysicsController(ctrl1);
+	EnableCcdPhysicsController(ctrl1);
 }
 
-bool CcdPhysicsEnvironment::removeCollisionCallback(PHY_IPhysicsController* ctrl)
+bool CcdPhysicsEnvironment::RemoveCollisionCallback(PHY_IPhysicsController* ctrl)
 {
 	CcdPhysicsController* ccdCtrl = (CcdPhysicsController*)ctrl;
 	if (!ccdCtrl->Unregister())
@@ -2150,12 +2093,12 @@ bool CcdPhysicsEnvironment::removeCollisionCallback(PHY_IPhysicsController* ctrl
 }
 
 
-void CcdPhysicsEnvironment::removeSensor(PHY_IPhysicsController* ctrl)
+void CcdPhysicsEnvironment::RemoveSensor(PHY_IPhysicsController* ctrl)
 {
-	disableCcdPhysicsController((CcdPhysicsController*)ctrl);
+	DisableCcdPhysicsController((CcdPhysicsController*)ctrl);
 }
 
-void CcdPhysicsEnvironment::addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)
+void CcdPhysicsEnvironment::AddTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)
 {
 	/*	printf("addTouchCallback\n(response class = %i)\n",response_class);
 
@@ -2187,7 +2130,7 @@ void CcdPhysicsEnvironment::addTouchCallback(int response_class, PHY_ResponseCal
 	m_triggerCallbacksUserPtrs[response_class] = user;
 
 }
-bool CcdPhysicsEnvironment::requestCollisionCallback(PHY_IPhysicsController* ctrl)
+bool CcdPhysicsEnvironment::RequestCollisionCallback(PHY_IPhysicsController* ctrl)
 {
 	CcdPhysicsController* ccdCtrl = static_cast<CcdPhysicsController*>(ctrl);
 
@@ -2270,12 +2213,12 @@ bool CcdOverlapFilterCallBack::needBroadphaseCollision(btBroadphaseProxy* proxy0
 			(KX_ClientObjectInfo*)
 			((CcdPhysicsController*)
 					(((btCollisionObject*)proxy0->m_clientObject)->getUserPointer()))
-			->getNewClientInfo());
+			->GetNewClientInfo());
 	KX_GameObject *kxObj1 = KX_GameObject::GetClientObject(
 			(KX_ClientObjectInfo*)
 			((CcdPhysicsController*)
 					(((btCollisionObject*)proxy1->m_clientObject)->getUserPointer()))
-			->getNewClientInfo());
+			->GetNewClientInfo());
 
 	// First check the filters. Note that this is called during scene
 	// conversion, so we can't assume the KX_GameObject instances exist. This
@@ -2324,7 +2267,7 @@ bool CcdOverlapFilterCallBack::needBroadphaseCollision(btBroadphaseProxy* proxy0
 #ifdef NEW_BULLET_VEHICLE_SUPPORT
 
 //complex constraint for vehicles
-PHY_IVehicle*	CcdPhysicsEnvironment::getVehicleConstraint(int constraintId)
+PHY_IVehicle*	CcdPhysicsEnvironment::GetVehicleConstraint(int constraintId)
 {
 	int i;
 
@@ -2342,13 +2285,10 @@ PHY_IVehicle*	CcdPhysicsEnvironment::getVehicleConstraint(int constraintId)
 #endif //NEW_BULLET_VEHICLE_SUPPORT
 
 
-PHY_ICharacter* CcdPhysicsEnvironment::getCharacterController(KX_GameObject *ob)
+PHY_ICharacter* CcdPhysicsEnvironment::GetCharacterController(KX_GameObject *ob)
 {
-	CcdPhysicsController* controller = (CcdPhysicsController*)ob->GetPhysicsController()->GetUserData();
-	if (controller->GetCharacterController())
-		return new CharacterWrapper((BlenderBulletCharacterController*)controller->GetCharacterController());
-
-	return NULL;
+	CcdPhysicsController* controller = (CcdPhysicsController*)ob->GetPhysicsController();
+	return dynamic_cast<BlenderBulletCharacterController*>(controller->GetCharacterController());
 }
 
 
@@ -2398,7 +2338,7 @@ int findClosestNode(btSoftBody* sb,const btVector3& worldPoint)
 	return node;
 }
 
-int			CcdPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl0,class PHY_IPhysicsController* ctrl1,PHY_ConstraintType type,
+int			CcdPhysicsEnvironment::CreateConstraint(class PHY_IPhysicsController* ctrl0,class PHY_IPhysicsController* ctrl1,PHY_ConstraintType type,
 													float pivotX,float pivotY,float pivotZ,
 													float axisX,float axisY,float axisZ,
 													float axis1X,float axis1Y,float axis1Z,
@@ -2891,7 +2831,7 @@ float		CcdPhysicsEnvironment::getAppliedImpulse(int	constraintid)
 	return 0.f;
 }
 
-void	CcdPhysicsEnvironment::exportFile(const char* filename)
+void	CcdPhysicsEnvironment::ExportFile(const char* filename)
 {
 	btDefaultSerializer*	serializer = new btDefaultSerializer();
 	
@@ -2904,7 +2844,7 @@ void	CcdPhysicsEnvironment::exportFile(const char* filename)
 		CcdPhysicsController* controller = static_cast<CcdPhysicsController*>(colObj->getUserPointer());
 		if (controller)
 		{
-			const char* name = controller->getName();
+			const char* name = KX_GameObject::GetClientObject((KX_ClientObjectInfo*)controller->GetNewClientInfo())->GetName();
 			if (name)
 			{
 				serializer->registerNameForPointer(colObj,name);
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
index 8cf88526969..0e8ac9417f0 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
@@ -24,6 +24,7 @@ subject to the following restrictions:
 #include "PHY_IPhysicsEnvironment.h"
 #include <vector>
 #include <set>
+#include <map>
 class CcdPhysicsController;
 class CcdGraphicController;
 #include "LinearMath/btVector3.h"
@@ -83,7 +84,7 @@ protected:
 	int	m_profileTimings;
 	bool m_enableSatCollisionDetection;
 
-	void	processFhSprings(double curTime,float timeStep);
+	void	ProcessFhSprings(double curTime,float timeStep);
 
 	public:
 		CcdPhysicsEnvironment(bool useDbvtCulling, btDispatcher* dispatcher=0, btOverlappingPairCache* pairCache=0);
@@ -96,54 +97,54 @@ protected:
 
 		/// Perform an integration step of duration 'timeStep'.
 
-		virtual void setDebugDrawer(btIDebugDraw* debugDrawer);
+		virtual void SetDebugDrawer(btIDebugDraw* debugDrawer);
 
-		virtual void		setNumIterations(int numIter);
-		virtual void		setNumTimeSubSteps(int numTimeSubSteps)
+		virtual void		SetNumIterations(int numIter);
+		virtual void		SetNumTimeSubSteps(int numTimeSubSteps)
 		{
 			m_numTimeSubSteps = numTimeSubSteps;
 		}
-		virtual void		setDeactivationTime(float dTime);
-		virtual	void		setDeactivationLinearTreshold(float linTresh);
-		virtual	void		setDeactivationAngularTreshold(float angTresh);
-		virtual void		setContactBreakingTreshold(float contactBreakingTreshold);
-		virtual void		setCcdMode(int ccdMode);
-		virtual void		setSolverType(int solverType);
-		virtual void		setSolverSorConstant(float sor);
-		virtual void		setSolverTau(float tau);
-		virtual void		setSolverDamping(float damping);
-		virtual void		setLinearAirDamping(float damping);
-		virtual void		setUseEpa(bool epa);
-
-		int					getNumTimeSubSteps()
+		virtual void		SetDeactivationTime(float dTime);
+		virtual	void		SetDeactivationLinearTreshold(float linTresh);
+		virtual	void		SetDeactivationAngularTreshold(float angTresh);
+		virtual void		SetContactBreakingTreshold(float contactBreakingTreshold);
+		virtual void		SetCcdMode(int ccdMode);
+		virtual void		SetSolverType(int solverType);
+		virtual void		SetSolverSorConstant(float sor);
+		virtual void		SetSolverTau(float tau);
+		virtual void		SetSolverDamping(float damping);
+		virtual void		SetLinearAirDamping(float damping);
+		virtual void		SetUseEpa(bool epa);
+
+		virtual int			GetNumTimeSubSteps()
 		{
 			return m_numTimeSubSteps;
 		}
 
-		virtual	void		beginFrame();
-		virtual void		endFrame() {}
+		virtual	void		BeginFrame();
+		virtual void		EndFrame() {}
 		/// Perform an integration step of duration 'timeStep'.
-		virtual	bool		proceedDeltaTime(double curTime,float timeStep,float interval);
-		
-		virtual void		debugDrawWorld();
+		virtual	bool		ProceedDeltaTime(double curTime,float timeStep,float interval);
+
+		virtual void		DebugDrawWorld();
 //		virtual bool		proceedDeltaTimeOneStep(float timeStep);
 
-		virtual	void		setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)
+		virtual	void		SetFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)
 		{
 			//based on DEFAULT_PHYSICS_TIC_RATE of 60 hertz
-			setNumTimeSubSteps((int)(fixedTimeStep / 60.f));
+			SetNumTimeSubSteps((int)(fixedTimeStep / 60.f));
 		}
 		//returns 0.f if no fixed timestep is used
 
-		virtual	float		getFixedTimeStep() { return 0.f; }
+		virtual	float		GetFixedTimeStep() { return 0.f; }
 
-		virtual void		setDebugMode(int debugMode);
+		virtual void		SetDebugMode(int debugMode);
 
-		virtual	void		setGravity(float x,float y,float z);
-		virtual	void		getGravity(MT_Vector3& grav);
+		virtual	void		SetGravity(float x,float y,float z);
+		virtual	void		GetGravity(MT_Vector3& grav);
 
 
-		virtual int			createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
+		virtual int			CreateConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
 			float pivotX,float pivotY,float pivotZ,
 			float axisX,float axisY,float axisZ,
 			float axis1X=0,float axis1Y=0,float axis1Z=0,
@@ -152,7 +153,7 @@ protected:
 
 
 		//Following the COLLADA physics specification for constraints
-		virtual int			createUniversalD6Constraint(
+		virtual int			CreateUniversalD6Constraint(
 		class PHY_IPhysicsController* ctrlRef,class PHY_IPhysicsController* ctrlOther,
 			btTransform& localAttachmentFrameRef,
 			btTransform& localAttachmentOther,
@@ -163,11 +164,11 @@ protected:
 			);
 
 		
-		virtual void	setConstraintParam(int constraintId,int param,float value,float value1);
+		virtual void	SetConstraintParam(int constraintId,int param,float value,float value1);
 		
-		virtual float	getConstraintParam(int constraintId,int param);
+		virtual float	GetConstraintParam(int constraintId,int param);
 
-		virtual void		removeConstraint(int	constraintid);
+		virtual void		RemoveConstraint(int	constraintid);
 
 		virtual float		getAppliedImpulse(int	constraintid);
 
@@ -177,61 +178,61 @@ protected:
 
 #ifdef NEW_BULLET_VEHICLE_SUPPORT
 		//complex constraint for vehicles
-		virtual PHY_IVehicle*	getVehicleConstraint(int constraintId);
+		virtual PHY_IVehicle*	GetVehicleConstraint(int constraintId);
 #else
-		virtual class PHY_IVehicle*	getVehicleConstraint(int constraintId)
+		virtual class PHY_IVehicle*	GetVehicleConstraint(int constraintId)
 		{
 			return 0;
 		}
 #endif  /* NEW_BULLET_VEHICLE_SUPPORT */
 		// Character physics wrapper
-		virtual PHY_ICharacter*	getCharacterController(class KX_GameObject* ob);
+		virtual PHY_ICharacter*	GetCharacterController(class KX_GameObject* ob);
 
-		btTypedConstraint*	getConstraintById(int constraintId);
+		btTypedConstraint*	GetConstraintById(int constraintId);
 
-		virtual PHY_IPhysicsController* rayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
-		virtual bool cullingTest(PHY_CullingCallback callback, void* userData, MT_Vector4* planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16]);
+		virtual PHY_IPhysicsController* RayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
+		virtual bool CullingTest(PHY_CullingCallback callback, void* userData, MT_Vector4* planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16]);
 
 
 		//Methods for gamelogic collision/physics callbacks
-		virtual void addSensor(PHY_IPhysicsController* ctrl);
-		virtual void removeSensor(PHY_IPhysicsController* ctrl);
-		virtual void addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user);
-		virtual bool requestCollisionCallback(PHY_IPhysicsController* ctrl);
-		virtual bool removeCollisionCallback(PHY_IPhysicsController* ctrl);
+		virtual void AddSensor(PHY_IPhysicsController* ctrl);
+		virtual void RemoveSensor(PHY_IPhysicsController* ctrl);
+		virtual void AddTouchCallback(int response_class, PHY_ResponseCallback callback, void *user);
+		virtual bool RequestCollisionCallback(PHY_IPhysicsController* ctrl);
+		virtual bool RemoveCollisionCallback(PHY_IPhysicsController* ctrl);
 		//These two methods are used *solely* to create controllers for Near/Radar sensor! Don't use for anything else
 		virtual PHY_IPhysicsController*	CreateSphereController(float radius,const MT_Vector3& position);
 		virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight);
 	
 
-		virtual int	getNumContactPoints();
+		virtual int	GetNumContactPoints();
 
-		virtual void getContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ);
+		virtual void GetContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ);
 
 		//////////////////////
 		//CcdPhysicsEnvironment interface
 		////////////////////////
 	
-		void	addCcdPhysicsController(CcdPhysicsController* ctrl);
+		void	AddCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		bool	removeCcdPhysicsController(CcdPhysicsController* ctrl);
+		bool	RemoveCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		void	updateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask);
+		void	UpdateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask);
 
-		void	disableCcdPhysicsController(CcdPhysicsController* ctrl);
+		void	DisableCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		void	enableCcdPhysicsController(CcdPhysicsController* ctrl);
+		void	EnableCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		void	refreshCcdPhysicsController(CcdPhysicsController* ctrl);
+		void	RefreshCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		void	addCcdGraphicController(CcdGraphicController* ctrl);
+		void	AddCcdGraphicController(CcdGraphicController* ctrl);
 
-		void	removeCcdGraphicController(CcdGraphicController* ctrl);
+		void	RemoveCcdGraphicController(CcdGraphicController* ctrl);
 
-		btBroadphaseInterface*	getBroadphase();
-		btDbvtBroadphase*	getCullingTree() { return m_cullingTree; }
+		btBroadphaseInterface*	GetBroadphase();
+		btDbvtBroadphase*	GetCullingTree() { return m_cullingTree; }
 
-		btDispatcher*	getDispatcher();
+		btDispatcher*	GetDispatcher();
 		
 
 		bool	IsSatCollisionDetectionEnabled() const
@@ -250,7 +251,7 @@ protected:
 	
 		void	SyncMotionStates(float timeStep);
 
-		class	btSoftRigidDynamicsWorld*	getDynamicsWorld()
+		class	btSoftRigidDynamicsWorld*	GetDynamicsWorld()
 		{
 			return m_dynamicsWorld;
 		}
@@ -291,7 +292,7 @@ protected:
 
 		bool	m_scalingPropagated;
 
-		virtual void	exportFile(const char* filename);
+		virtual void	ExportFile(const char* filename);
 
 		
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.cpp b/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.cpp
index 72450e4307c..1bb5431c749 100644
--- a/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.cpp
@@ -47,19 +47,19 @@ DummyPhysicsEnvironment::~DummyPhysicsEnvironment()
 	//destroy physicsengine data
 }
 
-void DummyPhysicsEnvironment::beginFrame()
+void DummyPhysicsEnvironment::BeginFrame()
 {
 	// beginning of logic frame: apply forces
 }
 
-void DummyPhysicsEnvironment::endFrame()
+void DummyPhysicsEnvironment::EndFrame()
 {
 	// end of logic frame: clear forces
 }
 
 
 
-bool		DummyPhysicsEnvironment::proceedDeltaTime(double  curTime,float timeStep,float interval)
+bool		DummyPhysicsEnvironment::ProceedDeltaTime(double  curTime,float timeStep,float interval)
 {
 	//step physics simulation, typically perform
 	
@@ -69,11 +69,11 @@ bool		DummyPhysicsEnvironment::proceedDeltaTime(double  curTime,float timeStep,f
 	// return true if an update was done.
 	return true;
 }
-void		DummyPhysicsEnvironment::setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)
+void		DummyPhysicsEnvironment::SetFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)
 {
 }
  
-float		DummyPhysicsEnvironment::getFixedTimeStep()
+float		DummyPhysicsEnvironment::GetFixedTimeStep()
 {
 	return 0.f;
 }
@@ -81,18 +81,18 @@ float		DummyPhysicsEnvironment::getFixedTimeStep()
 
 
 
-void DummyPhysicsEnvironment::setGravity(float x,float y,float z)
+void DummyPhysicsEnvironment::SetGravity(float x,float y,float z)
 {
 }
 
-void DummyPhysicsEnvironment::getGravity(class MT_Vector3& grav)
+void DummyPhysicsEnvironment::GetGravity(class MT_Vector3& grav)
 {
 }
 
 
 
 
-int			DummyPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
+int			DummyPhysicsEnvironment::CreateConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
 		float pivotX,float pivotY,float pivotZ,float axisX,float axisY,float axisZ,
 			float axis1X,float axis1Y,float axis1Z,
 			float axis2X,float axis2Y,float axis2Z,int flag
@@ -104,14 +104,14 @@ int			DummyPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ct
 
 }
 
-void		DummyPhysicsEnvironment::removeConstraint(int	constraintid)
+void		DummyPhysicsEnvironment::RemoveConstraint(int	constraintid)
 {
 	if (constraintid)
 	{
 	}
 }
 
-PHY_IPhysicsController* DummyPhysicsEnvironment::rayTest(PHY_IRayCastFilterCallback &filterCallback,float fromX,float fromY,float fromZ, float toX,float toY,float toZ)
+PHY_IPhysicsController* DummyPhysicsEnvironment::RayTest(PHY_IRayCastFilterCallback &filterCallback,float fromX,float fromY,float fromZ, float toX,float toY,float toZ)
 {
 	//collision detection / raytesting
 	return NULL;
diff --git a/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.h b/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.h
index 9f6bc85fced..41462f91840 100644
--- a/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.h
+++ b/source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.h
@@ -48,57 +48,57 @@ class DummyPhysicsEnvironment  : public PHY_IPhysicsEnvironment
 public:
 	DummyPhysicsEnvironment ();
 	virtual		~DummyPhysicsEnvironment ();
-	virtual void		beginFrame();
-	virtual void		endFrame();
+	virtual void		BeginFrame();
+	virtual void		EndFrame();
 // Perform an integration step of duration 'timeStep'.
-	virtual	bool		proceedDeltaTime(double  curTime,float timeStep,float interval);
-	virtual	void		setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep);
-	virtual	float		getFixedTimeStep();
+	virtual	bool		ProceedDeltaTime(double  curTime,float timeStep,float interval);
+	virtual	void		SetFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep);
+	virtual	float		GetFixedTimeStep();
 
-	virtual	void		setGravity(float x,float y,float z);
-	virtual	void		getGravity(class MT_Vector3& grav);
+	virtual	void		SetGravity(float x,float y,float z);
+	virtual	void		GetGravity(class MT_Vector3& grav);
 
-	virtual int			createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
+	virtual int			CreateConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
 			float pivotX,float pivotY,float pivotZ,
 			float axisX,float axisY,float axisZ,
 			float axis1X=0,float axis1Y=0,float axis1Z=0,
 			float axis2X=0,float axis2Y=0,float axis2Z=0,int flag=0
 			);
 
-	virtual void		removeConstraint(int	constraintid);
+	virtual void		RemoveConstraint(int	constraintid);
 
 		//complex constraint for vehicles
-	virtual PHY_IVehicle*	getVehicleConstraint(int constraintId)
+	virtual PHY_IVehicle*	GetVehicleConstraint(int constraintId)
 	{
 		return 0;
 	}
 
 		// Character physics wrapper
-	virtual PHY_ICharacter*	getCharacterController(class KX_GameObject* ob)
+	virtual PHY_ICharacter*	GetCharacterController(class KX_GameObject* ob)
 	{
 		return 0;
 	}
 
-	virtual PHY_IPhysicsController* rayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
-	virtual bool cullingTest(PHY_CullingCallback callback, void* userData, class MT_Vector4* planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16]) { return false; }
+	virtual PHY_IPhysicsController* RayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
+	virtual bool CullingTest(PHY_CullingCallback callback, void* userData, class MT_Vector4* planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16]) { return false; }
 
 
 	//gamelogic callbacks
-		virtual void addSensor(PHY_IPhysicsController* ctrl) {}
-		virtual void removeSensor(PHY_IPhysicsController* ctrl) {}
-		virtual void addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)
+		virtual void AddSensor(PHY_IPhysicsController* ctrl) {}
+		virtual void RemoveSensor(PHY_IPhysicsController* ctrl) {}
+		virtual void AddTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)
 		{
 		}
-		virtual bool requestCollisionCallback(PHY_IPhysicsController* ctrl) { return false; }
-		virtual bool removeCollisionCallback(PHY_IPhysicsController* ctrl) { return false;}
+		virtual bool RequestCollisionCallback(PHY_IPhysicsController* ctrl) { return false; }
+		virtual bool RemoveCollisionCallback(PHY_IPhysicsController* ctrl) { return false;}
 		virtual PHY_IPhysicsController*	CreateSphereController(float radius,const class MT_Vector3& position) {return 0;}
 		virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight) { return 0;}
 
-		virtual void	setConstraintParam(int constraintId,int param,float value,float value1)
+		virtual void	SetConstraintParam(int constraintId,int param,float value,float value1)
 		{
 		}
 
-		virtual float	getConstraintParam(int constraintId,int param)
+		virtual float	GetConstraintParam(int constraintId,int param)
 		{
 			return 0.f;
 		}
diff --git a/source/gameengine/Physics/common/PHY_IController.h b/source/gameengine/Physics/common/PHY_IController.h
index ae1b2d9ad53..284d77ca221 100644
--- a/source/gameengine/Physics/common/PHY_IController.h
+++ b/source/gameengine/Physics/common/PHY_IController.h
@@ -50,8 +50,8 @@ class PHY_IController
 	public:
 		virtual ~PHY_IController(){};
 		// clientinfo for raycasts for example
-		virtual	void*	getNewClientInfo()=0;
-		virtual	void	setNewClientInfo(void* clientinfo)=0;
+		virtual	void*	GetNewClientInfo()=0;
+		virtual	void	SetNewClientInfo(void* clientinfo)=0;
 		virtual void	SetPhysicsEnvironment(class PHY_IPhysicsEnvironment *env)=0;
 
 	
diff --git a/source/gameengine/Physics/common/PHY_IGraphicController.h b/source/gameengine/Physics/common/PHY_IGraphicController.h
index 5f64e7ccc80..b047edd93eb 100644
--- a/source/gameengine/Physics/common/PHY_IGraphicController.h
+++ b/source/gameengine/Physics/common/PHY_IGraphicController.h
@@ -47,8 +47,8 @@ class PHY_IGraphicController : public PHY_IController
 		 */
 		virtual bool SetGraphicTransform()=0;
 		virtual void Activate(bool active=true)=0;
-		virtual void setLocalAabb(const class MT_Vector3& aabbMin,const class MT_Vector3& aabbMax)=0;
-		virtual void setLocalAabb(const float* aabbMin,const float* aabbMax)=0;
+		virtual void SetLocalAabb(const class MT_Vector3& aabbMin,const class MT_Vector3& aabbMax)=0;
+		virtual void SetLocalAabb(const float* aabbMin,const float* aabbMax)=0;
 
 		virtual PHY_IGraphicController*	GetReplica(class PHY_IMotionState* motionstate) {return 0;}
 
diff --git a/source/gameengine/Physics/common/PHY_IMotionState.h b/source/gameengine/Physics/common/PHY_IMotionState.h
index be5b2b54907..d40b8da9451 100644
--- a/source/gameengine/Physics/common/PHY_IMotionState.h
+++ b/source/gameengine/Physics/common/PHY_IMotionState.h
@@ -46,18 +46,18 @@ class	PHY_IMotionState
 	public:
 		virtual ~PHY_IMotionState(){};
 
-		virtual void	getWorldPosition(float& posX,float& posY,float& posZ)=0;
-		virtual void	getWorldScaling(float& scaleX,float& scaleY,float& scaleZ)=0;
-		virtual void	getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal)=0;
+		virtual void	GetWorldPosition(float& posX,float& posY,float& posZ)=0;
+		virtual void	GetWorldScaling(float& scaleX,float& scaleY,float& scaleZ)=0;
+		virtual void	GetWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal)=0;
 		// ori = array 12 floats, [0..3] = first column + 0, [4..7] = second column, [8..11] = third column
-		virtual void	getWorldOrientation(float* ori)=0;
-		virtual	void	setWorldOrientation(const float* ori)=0;
+		virtual void	GetWorldOrientation(float* ori)=0;
+		virtual	void	SetWorldOrientation(const float* ori)=0;
 		
-		virtual void	setWorldPosition(float posX,float posY,float posZ)=0;
-		virtual	void	setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal)=0;
+		virtual void	SetWorldPosition(float posX,float posY,float posZ)=0;
+		virtual	void	SetWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal)=0;
 
 
-		virtual	void	calculateWorldTransformations()=0;
+		virtual	void	CalculateWorldTransformations()=0;
 	
 	
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Physics/common/PHY_IPhysicsController.h b/source/gameengine/Physics/common/PHY_IPhysicsController.h
index 18af42adc15..a1d0972a950 100644
--- a/source/gameengine/Physics/common/PHY_IPhysicsController.h
+++ b/source/gameengine/Physics/common/PHY_IPhysicsController.h
@@ -37,6 +37,10 @@
 class PHY_IMotionState;
 class PHY_IPhysicsEnvironment;
 
+class MT_Vector3;
+class MT_Point3;
+class MT_Matrix3x3;
+
 /**
  * PHY_IPhysicsController is the abstract simplified Interface to a physical object.
  * It contains the IMotionState and IDeformableMesh Interfaces.
@@ -59,37 +63,47 @@ class PHY_IPhysicsController : public PHY_IController
 		virtual class PHY_IMotionState* GetMotionState() = 0;
 		// controller replication
 		virtual	void		PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl)=0;
+		virtual void		SetPhysicsEnvironment(class PHY_IPhysicsEnvironment *env)=0;
 
 		// kinematic methods
-		virtual void		RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local)=0;
-		virtual void		RelativeRotate(const float drot[12],bool local)=0;
-		virtual	void		getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal)=0;
-		virtual	void		setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal)=0;
-		virtual	void		setPosition(float posX,float posY,float posZ)=0;
-		virtual	void 		getPosition(class MT_Vector3&	pos) const=0;
-		virtual	void		setScaling(float scaleX,float scaleY,float scaleZ)=0;
-		
+		virtual void		RelativeTranslate(const MT_Vector3& dloc,bool local)=0;
+		virtual void		RelativeRotate(const MT_Matrix3x3&,bool local)=0;
+		virtual	MT_Matrix3x3	GetOrientation()=0;
+		virtual	void		SetOrientation(const MT_Matrix3x3& orn)=0;
+		virtual	void		SetPosition(const MT_Vector3& pos)=0;
+		virtual	void 		GetPosition(MT_Vector3&	pos) const=0;
+		virtual	void		SetScaling(const MT_Vector3& scale)=0;
+		virtual void		SetTransform()=0;
+
+		virtual	MT_Scalar	GetMass()=0;
+		virtual void		SetMass(MT_Scalar newmass)=0;
+
 		// physics methods
-		virtual void		ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local)=0;
-		virtual void		ApplyForce(float forceX,float forceY,float forceZ,bool local)=0;
-		virtual void		SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local)=0;
-		virtual void		SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local)=0;
-		virtual void		resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ) = 0;
+		virtual void		ApplyImpulse(const MT_Point3& attach, const MT_Vector3& impulse)=0;
+		virtual void		ApplyTorque(const MT_Vector3& torque,bool local)=0;
+		virtual void		ApplyForce(const MT_Vector3& force,bool local)=0;
+		virtual void		SetAngularVelocity(const MT_Vector3& ang_vel,bool local)=0;
+		virtual void		SetLinearVelocity(const MT_Vector3& lin_vel,bool local)=0;
+		virtual void		ResolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ) = 0;
+
+		virtual void		SuspendDynamics(bool ghost=false)=0;
+		virtual void		RestoreDynamics()=0;
 
-		virtual void		applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ)=0;
 		virtual void		SetActive(bool active)=0;
 
 		// reading out information from physics
-		virtual void		GetLinearVelocity(float& linvX,float& linvY,float& linvZ)=0;
-		virtual void		GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ)=0; 
-		virtual	void		getReactionForce(float& forceX,float& forceY,float& forceZ)=0;
+		virtual MT_Vector3	GetLinearVelocity()=0;
+		virtual MT_Vector3	GetAngularVelocity()=0;
+		virtual MT_Vector3	GetVelocity(const MT_Point3& pos)=0;
+		virtual	MT_Vector3	GetLocalInertia()=0;
 
 		// dyna's that are rigidbody are free in orientation, dyna's with non-rigidbody are restricted 
-		virtual	void		setRigidBody(bool rigid)=0;
+		virtual	void		SetRigidBody(bool rigid)=0;
 
 		virtual PHY_IPhysicsController*	GetReplica() {return 0;}
+		virtual PHY_IPhysicsController* GetReplicaForSensors() {return 0;}
 
-		virtual void	calcXform() =0;
+		virtual void	CalcXform() =0;
 		virtual void SetMargin(float margin) =0;
 		virtual float GetMargin() const=0;
 		virtual float GetRadius() const=0;
@@ -100,7 +114,15 @@ class PHY_IPhysicsController : public PHY_IController
 		virtual float GetLinVelocityMax() const=0;
 		virtual void  SetLinVelocityMax(float val) = 0;
 		
-		class MT_Vector3	GetWorldPosition(class MT_Vector3& localpos);
+		MT_Vector3	GetWorldPosition(MT_Vector3& localpos);
+
+		// Shape control
+		virtual void    AddCompoundChild(PHY_IPhysicsController* child) = 0;
+		virtual void    RemoveCompoundChild(PHY_IPhysicsController* child) = 0;
+
+
+		virtual bool IsDynamic() = 0;
+		virtual bool IsCompound() = 0;
 
 
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Physics/common/PHY_IPhysicsEnvironment.h b/source/gameengine/Physics/common/PHY_IPhysicsEnvironment.h
index 14904a70553..b1a0480ab14 100644
--- a/source/gameengine/Physics/common/PHY_IPhysicsEnvironment.h
+++ b/source/gameengine/Physics/common/PHY_IPhysicsEnvironment.h
@@ -105,87 +105,88 @@ public:
 class PHY_IPhysicsEnvironment
 {
 	public:
-		virtual		~PHY_IPhysicsEnvironment(){};
-		virtual	void		beginFrame() = 0;
-		virtual void		endFrame() = 0;
+		virtual		~PHY_IPhysicsEnvironment(){}
+		virtual	void		BeginFrame() = 0;
+		virtual void		EndFrame() = 0;
 		/// Perform an integration step of duration 'timeStep'.
-		virtual	bool		proceedDeltaTime(double curTime,float timeStep,float interval)=0;
+		virtual	bool		ProceedDeltaTime(double curTime,float timeStep,float interval)=0;
 		///draw debug lines (make sure to call this during the render phase, otherwise lines are not drawn properly)
-		virtual void		debugDrawWorld() {}
-		virtual	void		setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)=0;
+		virtual void		DebugDrawWorld() {}
+		virtual	void		SetFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)=0;
 		//returns 0.f if no fixed timestep is used
-		virtual	float		getFixedTimeStep()=0;
+		virtual	float		GetFixedTimeStep()=0;
 
 		///setDebugMode is used to support several ways of debug lines, contact point visualization
-		virtual void		setDebugMode(int debugMode) {}
+		virtual void		SetDebugMode(int debugMode) {}
 		///setNumIterations set the number of iterations for iterative solvers
-		virtual void		setNumIterations(int numIter) {}
+		virtual void		SetNumIterations(int numIter) {}
 		///setNumTimeSubSteps set the number of divisions of the timestep. Tradeoff quality versus performance.
-		virtual void		setNumTimeSubSteps(int numTimeSubSteps) {}
+		virtual void		SetNumTimeSubSteps(int numTimeSubSteps) {}
+		virtual int			GetNumTimeSubSteps() {return 0; }
 		///setDeactivationTime sets the minimum time that an objects has to stay within the velocity tresholds until it gets fully deactivated
-		virtual void		setDeactivationTime(float dTime) {}
+		virtual void		SetDeactivationTime(float dTime) {}
 		///setDeactivationLinearTreshold sets the linear velocity treshold, see setDeactivationTime
-		virtual	void		setDeactivationLinearTreshold(float linTresh) {}
+		virtual	void		SetDeactivationLinearTreshold(float linTresh) {}
 		///setDeactivationAngularTreshold sets the angular velocity treshold, see setDeactivationTime
-		virtual	void		setDeactivationAngularTreshold(float angTresh) {}
+		virtual	void		SetDeactivationAngularTreshold(float angTresh) {}
 		///setContactBreakingTreshold sets tresholds to do with contact point management
-		virtual void		setContactBreakingTreshold(float contactBreakingTreshold) {}
+		virtual void		SetContactBreakingTreshold(float contactBreakingTreshold) {}
 		///continuous collision detection mode, very experimental for Bullet
-		virtual void		setCcdMode(int ccdMode) {}
+		virtual void		SetCcdMode(int ccdMode) {}
 		///successive overrelaxation constant, in case PSOR is used, values in between 1 and 2 guarantee converging behavior
-		virtual void		setSolverSorConstant(float sor) {}
+		virtual void		SetSolverSorConstant(float sor) {}
 		///setSolverType, internal setting, chooses solvertype, PSOR, Dantzig, impulse based, penalty based
-		virtual void		setSolverType(int solverType) {}
+		virtual void		SetSolverType(int solverType) {}
 		///setTau sets the spring constant of a penalty based solver
-		virtual void		setSolverTau(float tau) {}
+		virtual void		SetSolverTau(float tau) {}
 		///setDamping sets the damper constant of a penalty based solver
-		virtual void		setSolverDamping(float damping) {}
+		virtual void		SetSolverDamping(float damping) {}
 		///linear air damping for rigidbodies
-		virtual void		setLinearAirDamping(float damping) {}
+		virtual void		SetLinearAirDamping(float damping) {}
 		/// penetrationdepth setting
-		virtual void		setUseEpa(bool epa) {}
+		virtual void		SetUseEpa(bool epa) {}
 
-		virtual	void		setGravity(float x,float y,float z)=0;
-		virtual	void		getGravity(MT_Vector3& grav) = 0;
+		virtual	void		SetGravity(float x,float y,float z)=0;
+		virtual	void		GetGravity(MT_Vector3& grav) = 0;
 
-		virtual int			createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
+		virtual int			CreateConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
 			float pivotX,float pivotY,float pivotZ,
 			float axis0X,float axis0Y,float axis0Z,
 			float axis1X=0,float axis1Y=0,float axis1Z=0,
 			float axis2X=0,float axis2Y=0,float axis2Z=0,int flag=0
 		)=0;
-		virtual void		removeConstraint(int	constraintid)=0;
-		virtual float		getAppliedImpulse(int	constraintid) { return 0.0f; }
+		virtual void		RemoveConstraint(int	constraintid)=0;
+		virtual float		GetAppliedImpulse(int	constraintid) { return 0.0f; }
 
 
 		//complex constraint for vehicles
-		virtual PHY_IVehicle*	getVehicleConstraint(int constraintId) =0;
+		virtual PHY_IVehicle*	GetVehicleConstraint(int constraintId) =0;
 
 		// Character physics wrapper
-		virtual PHY_ICharacter*	getCharacterController(class KX_GameObject* ob) =0;
+		virtual PHY_ICharacter*	GetCharacterController(class KX_GameObject* ob) =0;
 
-		virtual PHY_IPhysicsController* rayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ)=0;
+		virtual PHY_IPhysicsController* RayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ)=0;
 
 		//culling based on physical broad phase
 		// the plane number must be set as follow: near, far, left, right, top, botton
 		// the near plane must be the first one and must always be present, it is used to get the direction of the view
-		virtual bool cullingTest(PHY_CullingCallback callback, void *userData, MT_Vector4* planeNormals, int planeNumber, int occlusionRes, const int *viewport, double modelview[16], double projection[16]) = 0;
+		virtual bool CullingTest(PHY_CullingCallback callback, void *userData, MT_Vector4* planeNormals, int planeNumber, int occlusionRes, const int *viewport, double modelview[16], double projection[16]) = 0;
 
 		//Methods for gamelogic collision/physics callbacks
 		//todo:
-		virtual void addSensor(PHY_IPhysicsController* ctrl)=0;
-		virtual void removeSensor(PHY_IPhysicsController* ctrl)=0;
-		virtual void addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)=0;
-		virtual bool requestCollisionCallback(PHY_IPhysicsController* ctrl)=0;
-		virtual bool removeCollisionCallback(PHY_IPhysicsController* ctrl)=0;
+		virtual void AddSensor(PHY_IPhysicsController* ctrl)=0;
+		virtual void RemoveSensor(PHY_IPhysicsController* ctrl)=0;
+		virtual void AddTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)=0;
+		virtual bool RequestCollisionCallback(PHY_IPhysicsController* ctrl)=0;
+		virtual bool RemoveCollisionCallback(PHY_IPhysicsController* ctrl)=0;
 		//These two methods are *solely* used to create controllers for sensor! Don't use for anything else
 		virtual PHY_IPhysicsController*	CreateSphereController(float radius,const MT_Vector3& position) =0;
 		virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight)=0;
 		
-		virtual void	setConstraintParam(int constraintId,int param,float value,float value1) = 0;
-		virtual float	getConstraintParam(int constraintId,int param) = 0;
+		virtual void	SetConstraintParam(int constraintId,int param,float value,float value1) = 0;
+		virtual float	GetConstraintParam(int constraintId,int param) = 0;
 		
-		virtual void	exportFile(const char* filename) {};
+		virtual void	ExportFile(const char* filename) {};
 
 
 #ifdef WITH_CXX_GUARDEDALLOC