Merge pull request #24740 from OBKF/update-bullet-physics

Update Bullet physics to commit 126b676

1 files changed, 163 insertions, 181 deletions

diff --git a/thirdparty/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h b/thirdparty/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h
index 886476e8ad..fd0e5b9bbd 100644
--- a/thirdparty/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h
+++ b/thirdparty/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h
@@ -13,7 +13,6 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
-
 /**
  * @mainpage Bullet Documentation
  *
@@ -66,8 +65,6 @@ subject to the following restrictions:
  * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf
  * 
  */
- 
- 
 
 #ifndef BT_COLLISION_WORLD_H
 #define BT_COLLISION_WORLD_H
@@ -87,147 +84,138 @@ class btSerializer;
 ///CollisionWorld is interface and container for the collision detection
 class btCollisionWorld
 {
-
-	
 protected:
+	btAlignedObjectArray<btCollisionObject*> m_collisionObjects;
 
-	btAlignedObjectArray<btCollisionObject*>	m_collisionObjects;
-	
-	btDispatcher*	m_dispatcher1;
+	btDispatcher* m_dispatcher1;
 
-	btDispatcherInfo	m_dispatchInfo;
+	btDispatcherInfo m_dispatchInfo;
 
-	btBroadphaseInterface*	m_broadphasePairCache;
+	btBroadphaseInterface* m_broadphasePairCache;
 
-	btIDebugDraw*	m_debugDrawer;
+	btIDebugDraw* m_debugDrawer;
 
 	///m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs
 	///it is true by default, because it is error-prone (setting the position of static objects wouldn't update their AABB)
 	bool m_forceUpdateAllAabbs;
 
-	void	serializeCollisionObjects(btSerializer* serializer);
+	void serializeCollisionObjects(btSerializer* serializer);
 
 	void serializeContactManifolds(btSerializer* serializer);
 
-
 public:
-
 	//this constructor doesn't own the dispatcher and paircache/broadphase
-	btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
+	btCollisionWorld(btDispatcher* dispatcher, btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
 
 	virtual ~btCollisionWorld();
 
-	void	setBroadphase(btBroadphaseInterface*	pairCache)
+	void setBroadphase(btBroadphaseInterface* pairCache)
 	{
 		m_broadphasePairCache = pairCache;
 	}
 
-	const btBroadphaseInterface*	getBroadphase() const
+	const btBroadphaseInterface* getBroadphase() const
 	{
 		return m_broadphasePairCache;
 	}
 
-	btBroadphaseInterface*	getBroadphase()
+	btBroadphaseInterface* getBroadphase()
 	{
 		return m_broadphasePairCache;
 	}
 
-	btOverlappingPairCache*	getPairCache()
+	btOverlappingPairCache* getPairCache()
 	{
 		return m_broadphasePairCache->getOverlappingPairCache();
 	}
 
-
-	btDispatcher*	getDispatcher()
+	btDispatcher* getDispatcher()
 	{
 		return m_dispatcher1;
 	}
 
-	const btDispatcher*	getDispatcher() const
+	const btDispatcher* getDispatcher() const
 	{
 		return m_dispatcher1;
 	}
 
-	void	updateSingleAabb(btCollisionObject* colObj);
+	void updateSingleAabb(btCollisionObject* colObj);
 
-	virtual void	updateAabbs();
+	virtual void updateAabbs();
 
 	///the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSimulation)
 	///it can be useful to use if you perform ray tests without collision detection/simulation
-	virtual void	computeOverlappingPairs();
+	virtual void computeOverlappingPairs();
 
-	
-	virtual void	setDebugDrawer(btIDebugDraw*	debugDrawer)
+	virtual void setDebugDrawer(btIDebugDraw* debugDrawer)
 	{
-			m_debugDrawer = debugDrawer;
+		m_debugDrawer = debugDrawer;
 	}
 
-	virtual btIDebugDraw*	getDebugDrawer()
+	virtual btIDebugDraw* getDebugDrawer()
 	{
 		return m_debugDrawer;
 	}
 
-	virtual void	debugDrawWorld();
+	virtual void debugDrawWorld();
 
 	virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
 
-
 	///LocalShapeInfo gives extra information for complex shapes
 	///Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart
-	struct	LocalShapeInfo
+	struct LocalShapeInfo
 	{
-		int	m_shapePart;
-		int	m_triangleIndex;
-		
+		int m_shapePart;
+		int m_triangleIndex;
+
 		//const btCollisionShape*	m_shapeTemp;
 		//const btTransform*	m_shapeLocalTransform;
 	};
 
-	struct	LocalRayResult
+	struct LocalRayResult
 	{
-		LocalRayResult(const btCollisionObject*	collisionObject, 
-			LocalShapeInfo*	localShapeInfo,
-			const btVector3&		hitNormalLocal,
-			btScalar hitFraction)
-		:m_collisionObject(collisionObject),
-		m_localShapeInfo(localShapeInfo),
-		m_hitNormalLocal(hitNormalLocal),
-		m_hitFraction(hitFraction)
+		LocalRayResult(const btCollisionObject* collisionObject,
+					   LocalShapeInfo* localShapeInfo,
+					   const btVector3& hitNormalLocal,
+					   btScalar hitFraction)
+			: m_collisionObject(collisionObject),
+			  m_localShapeInfo(localShapeInfo),
+			  m_hitNormalLocal(hitNormalLocal),
+			  m_hitFraction(hitFraction)
 		{
 		}
 
-		const btCollisionObject*		m_collisionObject;
-		LocalShapeInfo*			m_localShapeInfo;
-		btVector3				m_hitNormalLocal;
-		btScalar				m_hitFraction;
-
+		const btCollisionObject* m_collisionObject;
+		LocalShapeInfo* m_localShapeInfo;
+		btVector3 m_hitNormalLocal;
+		btScalar m_hitFraction;
 	};
 
 	///RayResultCallback is used to report new raycast results
-	struct	RayResultCallback
+	struct RayResultCallback
 	{
-		btScalar	m_closestHitFraction;
-		const btCollisionObject*		m_collisionObject;
-		int	m_collisionFilterGroup;
-		int	m_collisionFilterMask;
+		btScalar m_closestHitFraction;
+		const btCollisionObject* m_collisionObject;
+		int m_collisionFilterGroup;
+		int m_collisionFilterMask;
 		//@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke.
 		unsigned int m_flags;
 
 		virtual ~RayResultCallback()
 		{
 		}
-		bool	hasHit() const
+		bool hasHit() const
 		{
 			return (m_collisionObject != 0);
 		}
 
 		RayResultCallback()
-			:m_closestHitFraction(btScalar(1.)),
-			m_collisionObject(0),
-			m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
-			m_collisionFilterMask(btBroadphaseProxy::AllFilter),
-			//@BP Mod
-			m_flags(0)
+			: m_closestHitFraction(btScalar(1.)),
+			  m_collisionObject(0),
+			  m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+			  m_collisionFilterMask(btBroadphaseProxy::AllFilter),
+			  //@BP Mod
+			  m_flags(0)
 		{
 		}
 
@@ -238,62 +226,62 @@ public:
 			return collides;
 		}
 
-
-		virtual	btScalar	addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
+		virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace) = 0;
 	};
 
-	struct	ClosestRayResultCallback : public RayResultCallback
+	struct ClosestRayResultCallback : public RayResultCallback
 	{
-		ClosestRayResultCallback(const btVector3&	rayFromWorld,const btVector3&	rayToWorld)
-		:m_rayFromWorld(rayFromWorld),
-		m_rayToWorld(rayToWorld)
+		ClosestRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+			: m_rayFromWorld(rayFromWorld),
+			  m_rayToWorld(rayToWorld)
 		{
 		}
 
-		btVector3	m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
-		btVector3	m_rayToWorld;
+		btVector3 m_rayFromWorld;  //used to calculate hitPointWorld from hitFraction
+		btVector3 m_rayToWorld;
+
+		btVector3 m_hitNormalWorld;
+		btVector3 m_hitPointWorld;
 
-		btVector3	m_hitNormalWorld;
-		btVector3	m_hitPointWorld;
-			
-		virtual	btScalar	addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
+		virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace)
 		{
 			//caller already does the filter on the m_closestHitFraction
 			btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
-			
+
 			m_closestHitFraction = rayResult.m_hitFraction;
 			m_collisionObject = rayResult.m_collisionObject;
 			if (normalInWorldSpace)
 			{
 				m_hitNormalWorld = rayResult.m_hitNormalLocal;
-			} else
+			}
+			else
 			{
 				///need to transform normal into worldspace
-				m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
+				m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
 			}
-			m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
+			m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
 			return rayResult.m_hitFraction;
 		}
 	};
 
-	struct	AllHitsRayResultCallback : public RayResultCallback
+	struct AllHitsRayResultCallback : public RayResultCallback
 	{
-		AllHitsRayResultCallback(const btVector3&	rayFromWorld,const btVector3&	rayToWorld)
-		:m_rayFromWorld(rayFromWorld),
-		m_rayToWorld(rayToWorld)
+		AllHitsRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+			: m_rayFromWorld(rayFromWorld),
+			  m_rayToWorld(rayToWorld)
 		{
 		}
 
-		btAlignedObjectArray<const btCollisionObject*>		m_collisionObjects;
+		btAlignedObjectArray<const btCollisionObject*> m_collisionObjects;
 
-		btVector3	m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
-		btVector3	m_rayToWorld;
+		btVector3 m_rayFromWorld;  //used to calculate hitPointWorld from hitFraction
+		btVector3 m_rayToWorld;
 
-		btAlignedObjectArray<btVector3>	m_hitNormalWorld;
-		btAlignedObjectArray<btVector3>	m_hitPointWorld;
+		btAlignedObjectArray<btVector3> m_hitNormalWorld;
+		btAlignedObjectArray<btVector3> m_hitPointWorld;
 		btAlignedObjectArray<btScalar> m_hitFractions;
-			
-		virtual	btScalar	addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
+
+		virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace)
 		{
 			m_collisionObject = rayResult.m_collisionObject;
 			m_collisionObjects.push_back(rayResult.m_collisionObject);
@@ -301,69 +289,66 @@ public:
 			if (normalInWorldSpace)
 			{
 				hitNormalWorld = rayResult.m_hitNormalLocal;
-			} else
+			}
+			else
 			{
 				///need to transform normal into worldspace
-				hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
+				hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
 			}
 			m_hitNormalWorld.push_back(hitNormalWorld);
 			btVector3 hitPointWorld;
-			hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
+			hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
 			m_hitPointWorld.push_back(hitPointWorld);
 			m_hitFractions.push_back(rayResult.m_hitFraction);
 			return m_closestHitFraction;
 		}
 	};
 
-
 	struct LocalConvexResult
 	{
-		LocalConvexResult(const btCollisionObject*	hitCollisionObject, 
-			LocalShapeInfo*	localShapeInfo,
-			const btVector3&		hitNormalLocal,
-			const btVector3&		hitPointLocal,
-			btScalar hitFraction
-			)
-		:m_hitCollisionObject(hitCollisionObject),
-		m_localShapeInfo(localShapeInfo),
-		m_hitNormalLocal(hitNormalLocal),
-		m_hitPointLocal(hitPointLocal),
-		m_hitFraction(hitFraction)
+		LocalConvexResult(const btCollisionObject* hitCollisionObject,
+						  LocalShapeInfo* localShapeInfo,
+						  const btVector3& hitNormalLocal,
+						  const btVector3& hitPointLocal,
+						  btScalar hitFraction)
+			: m_hitCollisionObject(hitCollisionObject),
+			  m_localShapeInfo(localShapeInfo),
+			  m_hitNormalLocal(hitNormalLocal),
+			  m_hitPointLocal(hitPointLocal),
+			  m_hitFraction(hitFraction)
 		{
 		}
 
-		const btCollisionObject*		m_hitCollisionObject;
-		LocalShapeInfo*			m_localShapeInfo;
-		btVector3				m_hitNormalLocal;
-		btVector3				m_hitPointLocal;
-		btScalar				m_hitFraction;
+		const btCollisionObject* m_hitCollisionObject;
+		LocalShapeInfo* m_localShapeInfo;
+		btVector3 m_hitNormalLocal;
+		btVector3 m_hitPointLocal;
+		btScalar m_hitFraction;
 	};
 
 	///RayResultCallback is used to report new raycast results
-	struct	ConvexResultCallback
+	struct ConvexResultCallback
 	{
-		btScalar	m_closestHitFraction;
-		int	m_collisionFilterGroup;
-		int	m_collisionFilterMask;
-		
+		btScalar m_closestHitFraction;
+		int m_collisionFilterGroup;
+		int m_collisionFilterMask;
+
 		ConvexResultCallback()
-			:m_closestHitFraction(btScalar(1.)),
-			m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
-			m_collisionFilterMask(btBroadphaseProxy::AllFilter)
+			: m_closestHitFraction(btScalar(1.)),
+			  m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+			  m_collisionFilterMask(btBroadphaseProxy::AllFilter)
 		{
 		}
 
 		virtual ~ConvexResultCallback()
 		{
 		}
-		
-		bool	hasHit() const
+
+		bool hasHit() const
 		{
 			return (m_closestHitFraction < btScalar(1.));
 		}
 
-		
-
 		virtual bool needsCollision(btBroadphaseProxy* proxy0) const
 		{
 			bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
@@ -371,39 +356,40 @@ public:
 			return collides;
 		}
 
-		virtual	btScalar	addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
+		virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace) = 0;
 	};
 
-	struct	ClosestConvexResultCallback : public ConvexResultCallback
+	struct ClosestConvexResultCallback : public ConvexResultCallback
 	{
-		ClosestConvexResultCallback(const btVector3&	convexFromWorld,const btVector3&	convexToWorld)
-		:m_convexFromWorld(convexFromWorld),
-		m_convexToWorld(convexToWorld),
-		m_hitCollisionObject(0)
+		ClosestConvexResultCallback(const btVector3& convexFromWorld, const btVector3& convexToWorld)
+			: m_convexFromWorld(convexFromWorld),
+			  m_convexToWorld(convexToWorld),
+			  m_hitCollisionObject(0)
 		{
 		}
 
-		btVector3	m_convexFromWorld;//used to calculate hitPointWorld from hitFraction
-		btVector3	m_convexToWorld;
+		btVector3 m_convexFromWorld;  //used to calculate hitPointWorld from hitFraction
+		btVector3 m_convexToWorld;
 
-		btVector3	m_hitNormalWorld;
-		btVector3	m_hitPointWorld;
-		const btCollisionObject*	m_hitCollisionObject;
-		
-		virtual	btScalar	addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
+		btVector3 m_hitNormalWorld;
+		btVector3 m_hitPointWorld;
+		const btCollisionObject* m_hitCollisionObject;
+
+		virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace)
 		{
-//caller already does the filter on the m_closestHitFraction
+			//caller already does the filter on the m_closestHitFraction
 			btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
-						
+
 			m_closestHitFraction = convexResult.m_hitFraction;
 			m_hitCollisionObject = convexResult.m_hitCollisionObject;
 			if (normalInWorldSpace)
 			{
 				m_hitNormalWorld = convexResult.m_hitNormalLocal;
-			} else
+			}
+			else
 			{
 				///need to transform normal into worldspace
-				m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
+				m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis() * convexResult.m_hitNormalLocal;
 			}
 			m_hitPointWorld = convexResult.m_hitPointLocal;
 			return convexResult.m_hitFraction;
@@ -411,23 +397,23 @@ public:
 	};
 
 	///ContactResultCallback is used to report contact points
-	struct	ContactResultCallback
+	struct ContactResultCallback
 	{
-		int	m_collisionFilterGroup;
-		int	m_collisionFilterMask;
-		btScalar	m_closestDistanceThreshold;
+		int m_collisionFilterGroup;
+		int m_collisionFilterMask;
+		btScalar m_closestDistanceThreshold;
 
 		ContactResultCallback()
-			:m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
-			m_collisionFilterMask(btBroadphaseProxy::AllFilter),
-			m_closestDistanceThreshold(0)
+			: m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+			  m_collisionFilterMask(btBroadphaseProxy::AllFilter),
+			  m_closestDistanceThreshold(0)
 		{
 		}
 
 		virtual ~ContactResultCallback()
 		{
 		}
-		
+
 		virtual bool needsCollision(btBroadphaseProxy* proxy0) const
 		{
 			bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
@@ -435,58 +421,57 @@ public:
 			return collides;
 		}
 
-		virtual	btScalar	addSingleResult(btManifoldPoint& cp,	const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1) = 0;
+		virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1) = 0;
 	};
 
-
-
-	int	getNumCollisionObjects() const
+	int getNumCollisionObjects() const
 	{
 		return int(m_collisionObjects.size());
 	}
 
 	/// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback
 	/// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
-	virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const; 
+	virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
 
 	/// convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback
 	/// This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback.
-	void    convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback,  btScalar allowedCcdPenetration = btScalar(0.)) const;
+	void convexSweepTest(const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = btScalar(0.)) const;
 
 	///contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback.
 	///it reports one or more contact points for every overlapping object (including the one with deepest penetration)
-	void	contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
+	void contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
 
 	///contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected.
 	///it reports one or more contact points (including the one with deepest penetration)
-	void	contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
-
+	void contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
 
 	/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
 	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
 	/// This allows more customization.
-	static void	rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
-					  btCollisionObject* collisionObject,
-					  const btCollisionShape* collisionShape,
-					  const btTransform& colObjWorldTransform,
-					  RayResultCallback& resultCallback);
+	static void rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+							  btCollisionObject* collisionObject,
+							  const btCollisionShape* collisionShape,
+							  const btTransform& colObjWorldTransform,
+							  RayResultCallback& resultCallback);
 
-	static void	rayTestSingleInternal(const btTransform& rayFromTrans,const btTransform& rayToTrans,
-					  const btCollisionObjectWrapper* collisionObjectWrap,
-					  RayResultCallback& resultCallback);
+	static void rayTestSingleInternal(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+									  const btCollisionObjectWrapper* collisionObjectWrap,
+									  RayResultCallback& resultCallback);
 
 	/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
-	static void	objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
-					  btCollisionObject* collisionObject,
-					  const btCollisionShape* collisionShape,
-					  const btTransform& colObjWorldTransform,
-					  ConvexResultCallback& resultCallback, btScalar	allowedPenetration);
+	static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans, const btTransform& rayToTrans,
+								  btCollisionObject* collisionObject,
+								  const btCollisionShape* collisionShape,
+								  const btTransform& colObjWorldTransform,
+								  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
 
-	static void	objectQuerySingleInternal(const btConvexShape* castShape,const btTransform& convexFromTrans,const btTransform& convexToTrans,
-											const btCollisionObjectWrapper* colObjWrap,
-											ConvexResultCallback& resultCallback, btScalar allowedPenetration);
+	static void objectQuerySingleInternal(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans,
+										  const btCollisionObjectWrapper* colObjWrap,
+										  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
 
-	virtual void	addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter);
+	virtual void addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
+
+	virtual void refreshBroadphaseProxy(btCollisionObject* collisionObject);
 
 	btCollisionObjectArray& getCollisionObjectArray()
 	{
@@ -498,10 +483,9 @@ public:
 		return m_collisionObjects;
 	}
 
+	virtual void removeCollisionObject(btCollisionObject* collisionObject);
 
-	virtual void	removeCollisionObject(btCollisionObject* collisionObject);
-
-	virtual void	performDiscreteCollisionDetection();
+	virtual void performDiscreteCollisionDetection();
 
 	btDispatcherInfo& getDispatchInfo()
 	{
@@ -512,20 +496,18 @@ public:
 	{
 		return m_dispatchInfo;
 	}
-	
-	bool	getForceUpdateAllAabbs() const
+
+	bool getForceUpdateAllAabbs() const
 	{
 		return m_forceUpdateAllAabbs;
 	}
-	void setForceUpdateAllAabbs( bool forceUpdateAllAabbs)
+	void setForceUpdateAllAabbs(bool forceUpdateAllAabbs)
 	{
 		m_forceUpdateAllAabbs = forceUpdateAllAabbs;
 	}
 
 	///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo)
-	virtual	void	serialize(btSerializer* serializer);
-
+	virtual void serialize(btSerializer* serializer);
 };
 
-
-#endif //BT_COLLISION_WORLD_H
+#endif  //BT_COLLISION_WORLD_H