add btActivationCollisionAlgoritm to fix deactivation problems, reported here:

http://bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=2616

provide access to active objects, requested here:
http://code.google.com/p/bullet/issues/detail?id=128

src/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp

@@ -0,0 +1,49 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "btCollisionDispatcher.h"
+#include "btCollisionObject.h"
+
+btActivatingCollisionAlgorithm::btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci)
+:btCollisionAlgorithm(ci),
+m_colObj0(0),
+m_colObj1(0)
+{
+}
+btActivatingCollisionAlgorithm::btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* colObj0,btCollisionObject* colObj1)
+:btCollisionAlgorithm(ci),
+m_colObj0(0),
+m_colObj1(0)
+{
+	if (ci.m_dispatcher1->needsCollision(colObj0,colObj1))
+	{
+		m_colObj0 = colObj0;
+		m_colObj1 = colObj1;
+		
+		if (!m_colObj0->isActive())
+			m_colObj0->activate();
+		if (!m_colObj1->isActive())
+			m_colObj1->activate();
+	}
+}
+
+btActivatingCollisionAlgorithm::~btActivatingCollisionAlgorithm()
+{
+	if (m_colObj0)
+			m_colObj0->activate();
+	if (m_colObj1)
+		m_colObj1->activate();
+}

src/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h

@@ -0,0 +1,35 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H
+#define __BT_ACTIVATING_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+
+class btActivatingCollisionAlgorithm : public btCollisionAlgorithm
+{
+	btCollisionObject* m_colObj0;
+	btCollisionObject* m_colObj1;
+
+public:
+
+	btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci);
+
+	btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* colObj0,btCollisionObject* colObj1);
+
+	virtual ~btActivatingCollisionAlgorithm();
+
+};
+#endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H

src/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp

@@ -22,7 +22,7 @@ subject to the following restrictions:
 #define USE_PERSISTENT_CONTACTS 1
 
 btBoxBoxCollisionAlgorithm::btBoxBoxCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* obj0,btCollisionObject* obj1)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,obj0,obj1),
 m_ownManifold(false),
 m_manifoldPtr(mf)
 {

src/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef BOX_BOX__COLLISION_ALGORITHM_H
 #define BOX_BOX__COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
@@ -24,14 +24,14 @@ subject to the following restrictions:
 class btPersistentManifold;
 
 ///box-box collision detection
-class btBoxBoxCollisionAlgorithm : public btCollisionAlgorithm
+class btBoxBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
 	bool	m_ownManifold;
 	btPersistentManifold*	m_manifoldPtr;
 	
 public:
 	btBoxBoxCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-		: btCollisionAlgorithm(ci) {}
+		: btActivatingCollisionAlgorithm(ci) {}
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 

src/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -183,9 +183,9 @@ public:
 		m_collisionShape = collisionShape;
 	}
 
-	int	getActivationState() const { return m_activationState1;}
+	SIMD_FORCE_INLINE	int	getActivationState() const { return m_activationState1;}
 	
-	void setActivationState(int newState);
+	SIMD_FORCE_INLINE	void setActivationState(int newState);
 
 	void	setDeactivationTime(btScalar time)
 	{
@@ -200,7 +200,7 @@ public:
 
 	void	activate(bool forceActivation = false);
 
-	inline bool isActive() const
+	SIMD_FORCE_INLINE bool isActive() const
 	{
 		return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
 	}

src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -114,6 +114,21 @@ void	btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject,sho
 
 
 
+}
+
+
+void	btCollisionWorld::findActiveObjects()
+{
+	m_activeObjects.resize(0);
+
+	for ( int i=0;i<m_collisionObjects.size();i++)
+	{
+		btCollisionObject* colObj = m_collisionObjects[i];
+		if (colObj->isActive())
+		{
+			m_activeObjects.push_back(colObj);
+		}
+	}
 }
 
 void	btCollisionWorld::updateAabbs()
@@ -121,9 +136,9 @@ void	btCollisionWorld::updateAabbs()
 	BT_PROFILE("updateAabbs");
 
 	btTransform predictedTrans;
-	for ( int i=0;i<m_collisionObjects.size();i++)
+	for ( int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 
 		//only update aabb of active objects
 		if (colObj->isActive())

src/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -84,6 +84,10 @@ protected:
 
 	btAlignedObjectArray<btCollisionObject*>	m_collisionObjects;
 	
+	///temporarily solution to keep track of active objects. This work-in-progress will improve when we refactor island management.
+	btAlignedObjectArray<btCollisionObject*>	m_activeObjects;
+
+
 	btDispatcher*	m_dispatcher1;
 
 	btDispatcherInfo	m_dispatchInfo;
@@ -94,6 +98,9 @@ protected:
 
 	btIDebugDraw*	m_debugDrawer;
 
+protected:
+
+	void	findActiveObjects();
 	
 public:
 
@@ -135,6 +142,16 @@ public:
 
 	virtual void	updateAabbs();
 
+	btCollisionObjectArray& getActiveObjects()
+	{
+		return m_activeObjects;
+	}
+
+	const btCollisionObjectArray& getActiveObjects() const
+	{
+		return m_activeObjects;
+	}
+	
 	virtual void	setDebugDrawer(btIDebugDraw*	debugDrawer)
 	{
 			m_debugDrawer = debugDrawer;

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -21,7 +21,7 @@ subject to the following restrictions:
 #include "LinearMath/btAabbUtil2.h"
 
 btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
-:btCollisionAlgorithm(ci),
+:btActivatingCollisionAlgorithm(ci,body0,body1),
 m_isSwapped(isSwapped),
 m_sharedManifold(ci.m_manifold)
 {

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef COMPOUND_COLLISION_ALGORITHM_H
 #define COMPOUND_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
 
@@ -28,7 +28,7 @@ class btDispatcher;
 class btDispatcher;
 
 /// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
-class btCompoundCollisionAlgorithm  : public btCollisionAlgorithm
+class btCompoundCollisionAlgorithm  : public btActivatingCollisionAlgorithm
 {
 	btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithms;
 	bool m_isSwapped;

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -27,7 +27,7 @@ subject to the following restrictions:
 #include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
 
 btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,body0,body1),
 m_isSwapped(isSwapped),
 m_btConvexTriangleCallback(ci.m_dispatcher1,body0,body1,isSwapped)
 {

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef CONVEX_CONCAVE_COLLISION_ALGORITHM_H
 #define CONVEX_CONCAVE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
 #include "BulletCollision/CollisionShapes/btTriangleCallback.h"
@@ -70,7 +70,7 @@ int	m_triangleCount;
 
 
 /// btConvexConcaveCollisionAlgorithm  supports collision between convex shapes and (concave) trianges meshes.
-class btConvexConcaveCollisionAlgorithm  : public btCollisionAlgorithm
+class btConvexConcaveCollisionAlgorithm  : public btActivatingCollisionAlgorithm
 {
 
 	bool	m_isSwapped;

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -60,7 +60,7 @@ btConvexConvexAlgorithm::CreateFunc::~CreateFunc()
 }
 
 btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,body0,body1),
 m_simplexSolver(simplexSolver),
 m_pdSolver(pdSolver),
 m_ownManifold (false),

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef CONVEX_CONVEX_ALGORITHM_H
 #define CONVEX_CONVEX_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
@@ -30,7 +30,7 @@ class btConvexPenetrationDepthSolver;
 #define USE_SEPDISTANCE_UTIL2 1
 
 ///ConvexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations.
-class btConvexConvexAlgorithm : public btCollisionAlgorithm
+class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
 {
 #ifdef USE_SEPDISTANCE_UTIL2
 	btConvexSeparatingDistanceUtil	m_sepDistance;

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -143,11 +143,13 @@ class btPersistentManifoldSortPredicate
 };
 
 
-void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects)
+void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisionWorld* collisionWorld)
 {
 
 	BT_PROFILE("islandUnionFindAndQuickSort");
 	
+	btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray();
+
 	m_islandmanifold.resize(0);
 
 	//we are going to sort the unionfind array, and store the element id in the size
@@ -238,6 +240,7 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisio
 					if ( colObj0->getActivationState() == ISLAND_SLEEPING)
 					{
 						colObj0->setActivationState( WANTS_DEACTIVATION);
+						colObj0->setDeactivationTime(0.f);
 					}
 				}
 			}
@@ -270,10 +273,18 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisio
 			//kinematic objects don't merge islands, but wake up all connected objects
 			if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING)
 			{
+				if (!colObj1->isActive())
+				{
+					collisionWorld->getActiveObjects().push_back(colObj1);
+				}
 				colObj1->activate();
 			}
 			if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING)
 			{
+				if (!colObj0->isActive())
+				{
+					collisionWorld->getActiveObjects().push_back(colObj0);
+				}
 				colObj0->activate();
 			}
 #ifdef SPLIT_ISLANDS
@@ -288,10 +299,11 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisio
 
 
 ///@todo: this is random access, it can be walked 'cache friendly'!
-void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback)
+void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionWorld* collisionWorld, IslandCallback* callback)
 {
+	btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray();
 
-	buildIslands(dispatcher,collisionObjects);
+	buildIslands(dispatcher,collisionWorld);
 
 	int endIslandIndex=1;
 	int startIslandIndex;

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h

@@ -61,9 +61,9 @@ public:
 		virtual	void	ProcessIsland(btCollisionObject** bodies,int numBodies,class btPersistentManifold**	manifolds,int numManifolds, int islandId) = 0;
 	};
 
-	void	buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback);
+	void	buildAndProcessIslands(btDispatcher* dispatcher,btCollisionWorld* collisionWorld, IslandCallback* callback);
 
-	void buildIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects);
+	void buildIslands(btDispatcher* dispatcher,btCollisionWorld* colWorld);
 
 };
 

src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp

@@ -21,7 +21,7 @@ subject to the following restrictions:
 //#include <stdio.h>
 
 btSphereBoxCollisionAlgorithm::btSphereBoxCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,col0,col1),
 m_ownManifold(false),
 m_manifoldPtr(mf),
 m_isSwapped(isSwapped)

src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef SPHERE_BOX_COLLISION_ALGORITHM_H
 #define SPHERE_BOX_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
 class btPersistentManifold;
@@ -26,7 +26,7 @@ class btPersistentManifold;
 
 /// btSphereBoxCollisionAlgorithm  provides sphere-box collision detection.
 /// Other features are frame-coherency (persistent data) and collision response.
-class btSphereBoxCollisionAlgorithm : public btCollisionAlgorithm
+class btSphereBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
 	bool	m_ownManifold;
 	btPersistentManifold*	m_manifoldPtr;

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -19,7 +19,7 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
 
 btSphereSphereCollisionAlgorithm::btSphereSphereCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,col0,col1),
 m_ownManifold(false),
 m_manifoldPtr(mf)
 {

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef SPHERE_SPHERE_COLLISION_ALGORITHM_H
 #define SPHERE_SPHERE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
 #include "btCollisionDispatcher.h"
@@ -26,7 +26,7 @@ class btPersistentManifold;
 /// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
 /// Other features are frame-coherency (persistent data) and collision response.
 /// Also provides the most basic sample for custom/user btCollisionAlgorithm
-class btSphereSphereCollisionAlgorithm : public btCollisionAlgorithm
+class btSphereSphereCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
 	bool	m_ownManifold;
 	btPersistentManifold*	m_manifoldPtr;
@@ -35,7 +35,7 @@ public:
 	btSphereSphereCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1);
 
 	btSphereSphereCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-		: btCollisionAlgorithm(ci) {}
+		: btActivatingCollisionAlgorithm(ci) {}
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 

src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp

@@ -22,7 +22,7 @@ subject to the following restrictions:
 
 
 btSphereTriangleCollisionAlgorithm::btSphereTriangleCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1,bool swapped)
-: btCollisionAlgorithm(ci),
+: btActivatingCollisionAlgorithm(ci,col0,col1),
 m_ownManifold(false),
 m_manifoldPtr(mf),
 m_swapped(swapped)

src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h

@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
 #define SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
 #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
 class btPersistentManifold;
@@ -25,7 +25,7 @@ class btPersistentManifold;
 /// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
 /// Other features are frame-coherency (persistent data) and collision response.
 /// Also provides the most basic sample for custom/user btCollisionAlgorithm
-class btSphereTriangleCollisionAlgorithm : public btCollisionAlgorithm
+class btSphereTriangleCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
 	bool	m_ownManifold;
 	btPersistentManifold*	m_manifoldPtr;
@@ -35,7 +35,7 @@ public:
 	btSphereTriangleCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,bool swapped);
 
 	btSphereTriangleCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-		: btCollisionAlgorithm(ci) {}
+		: btActivatingCollisionAlgorithm(ci) {}
 
 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
 

src/BulletCollision/Gimpact/btGImpactCollisionAlgorithm.cpp

@@ -192,7 +192,7 @@ float btGImpactCollisionAlgorithm::getAverageTriangleCollisionTime()
 
 
 btGImpactCollisionAlgorithm::btGImpactCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
-: btCollisionAlgorithm(ci)
+: btActivatingCollisionAlgorithm(ci,body0,body1)
 {
 	m_manifoldPtr = NULL;
 	m_convex_algorithm = NULL;

src/BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h

@@ -24,7 +24,7 @@ subject to the following restrictions:
 #ifndef BVH_CONCAVE_COLLISION_ALGORITHM_H
 #define BVH_CONCAVE_COLLISION_ALGORITHM_H
 
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
 #include "BulletCollision/BroadphaseCollision/btDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
@@ -51,7 +51,7 @@ btCollisionDispatcher * dispatcher = static_cast<btCollisionDispatcher *>(m_dyna
 btGImpactCollisionAlgorithm::registerAlgorithm(dispatcher);
  \endcode
 */
-class btGImpactCollisionAlgorithm : public btCollisionAlgorithm
+class btGImpactCollisionAlgorithm : public btActivatingCollisionAlgorithm
 {
 protected:
 	btCollisionAlgorithm * m_convex_algorithm;

src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp

@@ -104,9 +104,9 @@ btDiscreteDynamicsWorld::~btDiscreteDynamicsWorld()
 void	btDiscreteDynamicsWorld::saveKinematicState(btScalar timeStep)
 {
 
-	for (int i=0;i<m_collisionObjects.size();i++)
+	for (int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body)
 		{
@@ -151,10 +151,9 @@ void	btDiscreteDynamicsWorld::debugDrawWorld()
 	{
 		int i;
 
-		//todo: iterate over awake simulation islands!
+		for (  i=0;i<m_activeObjects.size();i++)
-		for (  i=0;i<m_collisionObjects.size();i++)
 		{
-			btCollisionObject* colObj = m_collisionObjects[i];
+			btCollisionObject* colObj = m_activeObjects[i];
 			if (getDebugDrawer() && getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawWireframe)
 			{
 				btVector3 color(btScalar(255.),btScalar(255.),btScalar(255.));
@@ -222,9 +221,9 @@ void	btDiscreteDynamicsWorld::debugDrawWorld()
 void	btDiscreteDynamicsWorld::clearForces()
 {
 	///@todo: iterate over awake simulation islands!
-	for ( int i=0;i<m_collisionObjects.size();i++)
+	for ( int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 		
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body)
@@ -238,9 +237,9 @@ void	btDiscreteDynamicsWorld::clearForces()
 void	btDiscreteDynamicsWorld::applyGravity()
 {
 	///@todo: iterate over awake simulation islands!
-	for ( int i=0;i<m_collisionObjects.size();i++)
+	for ( int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 		
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body && body->isActive())
@@ -257,9 +256,9 @@ void	btDiscreteDynamicsWorld::synchronizeMotionStates()
 	BT_PROFILE("synchronizeMotionStates");
 	{
 		//todo: iterate over awake simulation islands!
-		for ( int i=0;i<m_collisionObjects.size();i++)
+		for ( int i=0;i<m_activeObjects.size();i++)
 		{
-			btCollisionObject* colObj = m_collisionObjects[i];
+			btCollisionObject* colObj = m_activeObjects[i];
 			
 			btRigidBody* body = btRigidBody::upcast(colObj);
 			if (body && body->getMotionState() && !body->isStaticOrKinematicObject())
@@ -365,6 +364,8 @@ void	btDiscreteDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
 	
 	BT_PROFILE("internalSingleStepSimulation");
 
+	findActiveObjects();
+	
 	///apply gravity, predict motion
 	predictUnconstraintMotion(timeStep);
 
@@ -406,9 +407,9 @@ void	btDiscreteDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
 void	btDiscreteDynamicsWorld::setGravity(const btVector3& gravity)
 {
 	m_gravity = gravity;
-	for ( int i=0;i<m_collisionObjects.size();i++)
+	for ( int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body)
 		{
@@ -666,7 +667,7 @@ void	btDiscreteDynamicsWorld::solveConstraints(btContactSolverInfo& solverInfo)
 	m_constraintSolver->prepareSolve(getCollisionWorld()->getNumCollisionObjects(), getCollisionWorld()->getDispatcher()->getNumManifolds());
 	
 	/// solve all the constraints for this island
-	m_islandManager->buildAndProcessIslands(getCollisionWorld()->getDispatcher(),getCollisionWorld()->getCollisionObjectArray(),&solverCallback);
+	m_islandManager->buildAndProcessIslands(getCollisionWorld()->getDispatcher(),getCollisionWorld(),&solverCallback);
 
 	m_constraintSolver->allSolved(solverInfo, m_debugDrawer, m_stackAlloc);
 }
@@ -790,9 +791,9 @@ void	btDiscreteDynamicsWorld::integrateTransforms(btScalar timeStep)
 {
 	BT_PROFILE("integrateTransforms");
 	btTransform predictedTrans;
-	for ( int i=0;i<m_collisionObjects.size();i++)
+	for ( int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body)
 		{
@@ -836,25 +837,25 @@ void	btDiscreteDynamicsWorld::integrateTransforms(btScalar timeStep)
 
 
 
+
+
 void	btDiscreteDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
 {
 	BT_PROFILE("predictUnconstraintMotion");
-	for ( int i=0;i<m_collisionObjects.size();i++)
+	for ( int i=0;i<m_activeObjects.size();i++)
 	{
-		btCollisionObject* colObj = m_collisionObjects[i];
+		btCollisionObject* colObj = m_activeObjects[i];
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body)
 		{
 			if (!body->isStaticOrKinematicObject())
 			{
-				if (body->isActive())
-				{
-					body->integrateVelocities( timeStep);
-					//damping
-					body->applyDamping(timeStep);
 				
-					body->predictIntegratedTransform(timeStep,body->getInterpolationWorldTransform());
+				body->integrateVelocities( timeStep);
-				}
+				//damping
+				body->applyDamping(timeStep);
+
+				body->predictIntegratedTransform(timeStep,body->getInterpolationWorldTransform());
 			}
 		}
 	}

src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h

@@ -42,7 +42,6 @@ protected:
 
 	btAlignedObjectArray<btTypedConstraint*> m_constraints;
 
-
 	btVector3	m_gravity;
 
 	//for variable timesteps
@@ -79,6 +78,7 @@ protected:
 
 	void	debugDrawSphere(btScalar radius, const btTransform& transform, const btVector3& color);
 
+
 public:
 
 
@@ -91,6 +91,7 @@ public:
 	virtual int	stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
 
 	
+
 	void	addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies=false);
 
 	void	removeConstraint(btTypedConstraint* constraint);
@@ -114,7 +115,6 @@ public:
 		return this;
 	}
 
-
 	virtual void	setGravity(const btVector3& gravity);
 	virtual btVector3 getGravity () const;