-added basic support for GameActuator 'load game', relative paths were broken, just load file into memory and load blend from memory.

-near sensor support
- python binding for PhysicsConstraints.setNumTimeSubSteps (dividing the physics timestep to tradeoff quality for performance)

6 files changed, 250 insertions, 40 deletions

diff --git a/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.cpp b/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.cpp
index c3ca2ef6be9..9c20f28d1ec 100644
--- a/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.cpp
+++ b/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.cpp
@@ -307,26 +307,14 @@ void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy
 	
 	GjkPairDetector::ClosestPointInput input;
 
-	SphereShape	sphere(0.2f);
-	MinkowskiSumShape	expanded0(min0,&sphere);
-	MinkowskiSumShape	expanded1(min1,&sphere);
 
-	if (dispatchInfo.m_useContinuous)
-	{
-		m_gjkPairDetector.SetMinkowskiA(&expanded0);
-		m_gjkPairDetector.SetMinkowskiB(&expanded1);
-		input.m_maximumDistanceSquared = expanded0.GetMargin()+expanded1.GetMargin();
-		input.m_maximumDistanceSquared *= input.m_maximumDistanceSquared;
-	}
-	else
-	{
-		m_gjkPairDetector.SetMinkowskiA(min0);
-		m_gjkPairDetector.SetMinkowskiB(min1);
-		input.m_maximumDistanceSquared = min0->GetMargin() + min1->GetMargin() + m_manifoldPtr->GetContactBreakingTreshold();
-		input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
-	}
-
-	input.m_maximumDistanceSquared = 1e30f;//
+	//TODO: if (dispatchInfo.m_useContinuous)
+	m_gjkPairDetector.SetMinkowskiA(min0);
+	m_gjkPairDetector.SetMinkowskiB(min1);
+	input.m_maximumDistanceSquared = min0->GetMargin() + min1->GetMargin() + m_manifoldPtr->GetContactBreakingTreshold();
+	input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
+	
+	//input.m_maximumDistanceSquared = 1e30f;//
 	
 	input.m_transformA = col0->m_worldTransform;
 	input.m_transformB = col1->m_worldTransform;
diff --git a/extern/bullet/BulletDynamics/ConstraintSolver/SimpleConstraintSolver.cpp b/extern/bullet/BulletDynamics/ConstraintSolver/SimpleConstraintSolver.cpp
index 9f7d360f7eb..fe59a40683a 100644
--- a/extern/bullet/BulletDynamics/ConstraintSolver/SimpleConstraintSolver.cpp
+++ b/extern/bullet/BulletDynamics/ConstraintSolver/SimpleConstraintSolver.cpp
@@ -112,6 +112,7 @@ SimdScalar restitutionCurve(SimdScalar rel_vel, SimdScalar restitution)
 
 
 
+
 float SimpleConstraintSolver::Solve(PersistentManifold* manifoldPtr, const ContactSolverInfo& info,int iter,IDebugDraw* debugDrawer)
 {
 
@@ -125,7 +126,7 @@ float SimpleConstraintSolver::Solve(PersistentManifold* manifoldPtr, const Conta
 	{
 		manifoldPtr->RefreshContactPoints(body0->getCenterOfMassTransform(),body1->getCenterOfMassTransform());
 		
-		const int numpoints = manifoldPtr->GetNumContacts();
+		int numpoints = manifoldPtr->GetNumContacts();
 
 		SimdVector3 color(0,1,0);
 		for (int i=0;i<numpoints ;i++)
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp
index 043d5be802e..cddc780aff4 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp
@@ -23,6 +23,9 @@ subject to the following restrictions:
 #include "CcdPhysicsEnvironment.h"
 #include "SimdTransformUtil.h"
 
+#include "CollisionShapes/SphereShape.h"
+#include "CollisionShapes/ConeShape.h"
+
 class BP_Proxy;
 
 ///todo: fill all the empty CcdPhysicsController methods, hook them up to the RigidBody class
@@ -31,7 +34,7 @@ class BP_Proxy;
 float	gDeactivationTime = 2.f;
 bool	gDisableDeactivation = false;
 
-float gLinearSleepingTreshold = 0.8f;
+float gLinearSleepingTreshold = 0.4f;
 float gAngularSleepingTreshold = 1.0f;
 
 #include "Dynamics/MassProps.h"
@@ -486,3 +489,96 @@ bool CcdPhysicsController::wantsSleeping()
 	return false;
 }
 
+PHY_IPhysicsController*	CcdPhysicsController::GetReplica()
+{
+	//very experimental, shape sharing is not implemented yet.
+	//just support SphereShape/ConeShape for now
+
+	CcdConstructionInfo cinfo = m_cci;
+	if (cinfo.m_collisionShape)
+	{
+		switch (cinfo.m_collisionShape->GetShapeType())
+		{
+		case SPHERE_SHAPE_PROXYTYPE:
+			{
+				SphereShape* orgShape = (SphereShape*)cinfo.m_collisionShape;
+				cinfo.m_collisionShape = new SphereShape(*orgShape);
+				break;
+			}
+
+			case CONE_SHAPE_PROXYTYPE:
+			{
+				ConeShape* orgShape = (ConeShape*)cinfo.m_collisionShape;
+				cinfo.m_collisionShape = new ConeShape(*orgShape);
+				break;
+			}
+
+
+		default:
+			{
+				return 0;
+			}
+		}
+	}
+
+	cinfo.m_MotionState = new DefaultMotionState();
+
+	CcdPhysicsController* replica = new CcdPhysicsController(cinfo);
+	return replica;
+}
+
+///////////////////////////////////////////////////////////
+///A small utility class, DefaultMotionState
+///
+///////////////////////////////////////////////////////////
+
+DefaultMotionState::DefaultMotionState()
+{
+	m_worldTransform.setIdentity();
+}
+
+
+DefaultMotionState::~DefaultMotionState()
+{
+
+}
+
+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)
+{
+	scaleX = 1.;
+	scaleY = 1.;
+	scaleZ = 1.;
+}
+
+void	DefaultMotionState::getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal)
+{
+	quatIma0 = m_worldTransform.getRotation().x();
+	quatIma1 = m_worldTransform.getRotation().y();
+	quatIma2 = m_worldTransform.getRotation().z();
+	quatReal = m_worldTransform.getRotation()[3];
+}
+		
+void	DefaultMotionState::setWorldPosition(float posX,float posY,float posZ)
+{
+	SimdPoint3 pos(posX,posY,posZ);
+	m_worldTransform.setOrigin( pos );
+}
+
+void	DefaultMotionState::setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal)
+{
+	SimdQuaternion orn(quatIma0,quatIma1,quatIma2,quatReal);
+	m_worldTransform.setRotation( orn );
+}
+		
+void	DefaultMotionState::calculateWorldTransformations()
+{
+
+}
+
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h
index 646b21f285e..056feba652c 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h
@@ -27,6 +27,7 @@ subject to the following restrictions:
 #include "SimdTransform.h"
 #include "Dynamics/RigidBody.h"
 
+#include "PHY_IMotionState.h"
 
 #include "BroadphaseCollision/BroadphaseProxy.h" //for CollisionShape access
 class CollisionShape;
@@ -155,7 +156,8 @@ class CcdPhysicsController : public PHY_IPhysicsController
 		// clientinfo for raycasts for example
 		virtual	void*				getNewClientInfo();
 		virtual	void				setNewClientInfo(void* clientinfo);
-		virtual PHY_IPhysicsController*	GetReplica() {return 0;}
+		virtual PHY_IPhysicsController*	GetReplica();
+		
 
 		virtual void	calcXform() {} ;
 		virtual void SetMargin(float margin) {};
@@ -184,4 +186,30 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 };
 
+
+
+
+///DefaultMotionState implements standard motionstate, using SimdTransform
+class	DefaultMotionState : public PHY_IMotionState
+
+{
+	public:
+		DefaultMotionState();
+
+		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	setWorldPosition(float posX,float posY,float posZ);
+		virtual	void	setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal);
+		
+		virtual	void	calculateWorldTransformations();
+		
+		SimdTransform	m_worldTransform;
+
+};
+
+
 #endif //BULLET2_PHYSICSCONTROLLER_H
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp
index cb4adc77d76..4b4d3f15dae 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp
@@ -29,6 +29,10 @@ subject to the following restrictions:
 #include "CollisionDispatch/CollisionWorld.h"
 
 #include "CollisionShapes/ConvexShape.h"
+#include "CollisionShapes/ConeShape.h"
+
+
+
 #include "BroadphaseCollision/Dispatcher.h"
 #include "NarrowPhaseCollision/PersistentManifold.h"
 #include "CollisionShapes/TriangleMeshShape.h"
@@ -321,6 +325,7 @@ static void DrawAabb(IDebugDraw* debugDrawer,const SimdVector3& from,const SimdV
 CcdPhysicsEnvironment::CcdPhysicsEnvironment(CollisionDispatcher* dispatcher,BroadphaseInterface* broadphase)
 :m_scalingPropagated(false),
 m_numIterations(10),
+m_numTimeSubSteps(1),
 m_ccdMode(0),
 m_solverType(-1),
 m_profileTimings(0),
@@ -342,9 +347,9 @@ m_enableSatCollisionDetection(false)
 		SimdVector3 worldMin(-10000,-10000,-10000);
 		SimdVector3 worldMax(10000,10000,10000);
 
-		//broadphase = new AxisSweep3(worldMin,worldMax);
+		broadphase = new AxisSweep3(worldMin,worldMax);
 
-		broadphase = new SimpleBroadphase();
+		//broadphase = new SimpleBroadphase();
 	}
 
 
@@ -498,6 +503,8 @@ void	CcdPhysicsEnvironment::beginFrame()
 
 bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 {
+	//printf("proceedDeltaTime\n");
+	
 
 #ifdef USE_QUICKPROF
 	//toggle Profiler
@@ -528,16 +535,38 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 
 	if (!SimdFuzzyZero(timeStep))
 	{
+		
+		{
+			//do the kinematic calculation here, over the full timestep
+			std::vector<CcdPhysicsController*>::iterator i;
+			for (i=m_controllers.begin();
+						!(i==m_controllers.end()); i++)
+			{
 
-		// define this in blender, the stepsize is 30 hertz, 60 hertz works much better 
-//#define SPLIT_TIMESTEP 1
+						CcdPhysicsController* ctrl = *i;
 
-#ifdef SPLIT_TIMESTEP
-		proceedDeltaTimeOneStep(0.5f*timeStep);
-		proceedDeltaTimeOneStep(0.5f*timeStep);
-#else		
-		proceedDeltaTimeOneStep(timeStep);
-#endif
+						SimdTransform predictedTrans;
+						RigidBody* body = ctrl->GetRigidBody();
+						if (body->GetActivationState() != ISLAND_SLEEPING)
+						{
+
+							if (body->IsStatic())
+							{
+								//to calculate velocities next frame
+								body->saveKinematicState(timeStep);
+							}
+						}
+			}
+		}
+
+
+		int i;
+		float subTimeStep = timeStep / float(m_numTimeSubSteps);
+
+		for (i=0;i<this->m_numTimeSubSteps;i++)
+		{
+			proceedDeltaTimeOneStep(subTimeStep);
+		}
 	} else
 	{
 		//todo: interpolate
@@ -563,7 +592,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 {
 
 
-	//	printf("CcdPhysicsEnvironment::proceedDeltaTime\n");
+	//printf("CcdPhysicsEnvironment::proceedDeltaTime\n");
 
 	if (SimdFuzzyZero(timeStep))
 		return true;
@@ -811,11 +840,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 					if (body->GetActivationState() != ISLAND_SLEEPING)
 					{
 
-						if (body->IsStatic())
-						{
-							//to calculate velocities next frame
-							body->saveKinematicState(timeStep);
-						} else
+						if (!body->IsStatic())
 						{
 							body->predictIntegratedTransform(timeStep*	toi, predictedTrans);
 							body->proceedToTransform( predictedTrans);
@@ -1392,10 +1417,34 @@ TypedConstraint*	CcdPhysicsEnvironment::getConstraintById(int constraintId)
 
 void CcdPhysicsEnvironment::addSensor(PHY_IPhysicsController* ctrl)
 {
+
+	CcdPhysicsController* ctrl1 = (CcdPhysicsController* )ctrl;
+	std::vector<CcdPhysicsController*>::iterator i =
+		std::find(m_controllers.begin(), m_controllers.end(), ctrl);
+	if ((i == m_controllers.end()))
+	{
+		addCcdPhysicsController(ctrl1);
+	}
+
+	requestCollisionCallback(ctrl);
 	//printf("addSensor\n");
 }
+
+void CcdPhysicsEnvironment::removeCollisionCallback(PHY_IPhysicsController* ctrl)
+{
+	std::vector<CcdPhysicsController*>::iterator i =
+		std::find(m_triggerControllers.begin(), m_triggerControllers.end(), ctrl);
+	if (!(i == m_triggerControllers.end()))
+	{
+		std::swap(*i, m_triggerControllers.back());
+		m_triggerControllers.pop_back();
+	}
+}
+
+
 void CcdPhysicsEnvironment::removeSensor(PHY_IPhysicsController* ctrl)
 {
+	removeCollisionCallback(ctrl);
 	//printf("removeSensor\n");
 }
 void CcdPhysicsEnvironment::addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)
@@ -1584,3 +1633,41 @@ void	CcdPhysicsEnvironment::UpdateAabbs(float	timeStep)
 				}
 			}
 }
+
+PHY_IPhysicsController*	CcdPhysicsEnvironment::CreateSphereController(float radius,const PHY__Vector3& position)
+{
+	
+	CcdConstructionInfo	cinfo;
+	cinfo.m_collisionShape = new SphereShape(radius);
+	cinfo.m_MotionState = 0;
+	cinfo.m_physicsEnv = this;
+	cinfo.m_collisionFlags |= CollisionObject::noContactResponse;
+	DefaultMotionState* motionState = new DefaultMotionState();
+	cinfo.m_MotionState = motionState;
+	motionState->m_worldTransform.setIdentity();
+	motionState->m_worldTransform.setOrigin(SimdVector3(position[0],position[1],position[2]));
+
+	CcdPhysicsController* sphereController = new CcdPhysicsController(cinfo);
+	
+
+	return sphereController;
+}
+
+
+PHY_IPhysicsController* CcdPhysicsEnvironment::CreateConeController(float coneradius,float coneheight)
+{
+	CcdConstructionInfo	cinfo;
+	cinfo.m_collisionShape = new ConeShape(coneradius,coneheight);
+	cinfo.m_MotionState = 0;
+	cinfo.m_physicsEnv = this;
+	DefaultMotionState* motionState = new DefaultMotionState();
+	cinfo.m_MotionState = motionState;
+	motionState->m_worldTransform.setIdentity();
+//	motionState->m_worldTransform.setOrigin(SimdVector3(position[0],position[1],position[2]));
+
+	CcdPhysicsController* sphereController = new CcdPhysicsController(cinfo);
+
+
+	return sphereController;
+}
+	
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h
index 08dff62e236..9de7053d271 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h
@@ -48,7 +48,11 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 	SimdVector3 m_gravity;
 	
 	IDebugDraw*	m_debugDrawer;
+	//solver iterations
 	int	m_numIterations;
+	
+	//timestep subdivisions
+	int	m_numTimeSubSteps;
 	int	m_ccdMode;
 	int	m_solverType;
 	int	m_profileTimings;
@@ -74,6 +78,10 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 		}
 
 		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) ;
@@ -131,8 +139,10 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 		virtual void removeSensor(PHY_IPhysicsController* ctrl);
 		virtual void addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user);
 		virtual void requestCollisionCallback(PHY_IPhysicsController* ctrl);
-		virtual PHY_IPhysicsController*	CreateSphereController(float radius,const PHY__Vector3& position) {return 0;};
-		virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight){ return 0;};
+		virtual void removeCollisionCallback(PHY_IPhysicsController* ctrl);
+
+		virtual PHY_IPhysicsController*	CreateSphereController(float radius,const PHY__Vector3& position);
+		virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight);
 	
 
 		virtual int	getNumContactPoints();