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().

5 files changed, 93 insertions, 70 deletions

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