diff --git a/Demos/AllBulletDemos/Main.cpp b/Demos/AllBulletDemos/Main.cpp
index 2eb367c53..d6909f1e9 100644
--- a/Demos/AllBulletDemos/Main.cpp
+++ b/Demos/AllBulletDemos/Main.cpp
@@ -335,7 +335,7 @@ int main(int argc, char** argv)
 	printf("Bullet version %d\n",bulletVersion);
 
 	glutInit(&argc, argv);
-	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE |GLUT_DEPTH);
+	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE |GLUT_DEPTH | GLUT_STENCIL);
 	glutInitWindowSize(width, height);
 	mainWindow = glutCreateWindow("http://bulletphysics.com");
 #ifdef BT_USE_FREEGLUT
diff --git a/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp b/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp
index 0131e8f13..dfac0affa 100644
--- a/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp
+++ b/Demos/ConcaveDemo/ConcavePhysicsDemo.cpp
@@ -184,7 +184,9 @@ void	ConcaveDemo::initPhysics()
 //comment out the next line to read the BVH from disk (first run the demo once to create the BVH)
 #define SERIALIZE_TO_DISK 1
 #ifdef SERIALIZE_TO_DISK
-	trimeshShape  = new btBvhTriangleMeshShape(m_indexVertexArrays,useQuantizedAabbCompression);
+	btVector3 aabbMin(-1000,-1000,-1000),aabbMax(1000,1000,1000);
+	
+	trimeshShape  = new btBvhTriangleMeshShape(m_indexVertexArrays,useQuantizedAabbCompression,aabbMin,aabbMax);
 	m_collisionShapes.push_back(trimeshShape);
 	
 	
@@ -295,7 +297,7 @@ void	ConcaveDemo::initPhysics()
 	startTransform.setIdentity();
 	staticBody = localCreateRigidBody(mass, startTransform,groundShape);
 
-	staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_STATIC_OBJECT);
+	staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);//STATIC_OBJECT);
 
 	//enable custom material callback
 	staticBody->setCollisionFlags(staticBody->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
diff --git a/Demos/ConcaveDemo/main.cpp b/Demos/ConcaveDemo/main.cpp
index 2c72b3bf1..3f0f4c17a 100644
--- a/Demos/ConcaveDemo/main.cpp
+++ b/Demos/ConcaveDemo/main.cpp
@@ -2,13 +2,17 @@
 #include "ConcaveDemo.h"
 #include "GlutStuff.h"
 
+#include "GLDebugDrawer.h"
+#include "btBulletDynamicsCommon.h"
 
+GLDebugDrawer	gDebugDrawer;
 int main(int argc,char** argv)
 {
 
         ConcaveDemo* concaveDemo = new ConcaveDemo();
         concaveDemo->initPhysics();
         concaveDemo->setCameraDistance(30.f);
+		concaveDemo->getDynamicsWorld()->setDebugDrawer(&gDebugDrawer);
 
         return glutmain(argc, argv,640,480,"Static Concave Mesh Demo",concaveDemo);
 }
diff --git a/Demos/OpenGL/DemoApplication.cpp b/Demos/OpenGL/DemoApplication.cpp
index a92d6143c..c8f9d5a6c 100644
--- a/Demos/OpenGL/DemoApplication.cpp
+++ b/Demos/OpenGL/DemoApplication.cpp
@@ -599,6 +599,8 @@ btVector3	DemoApplication::getRayTo(int x,int y)
 	return rayTo;
 }
 
+btScalar mousePickClamping = 3.f;
+
 
 void DemoApplication::mouseFunc(int button, int state, int x, int y)
 {
@@ -686,6 +688,8 @@ void DemoApplication::mouseFunc(int button, int state, int x, int y)
 								btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
 
 								btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body,localPivot);
+								p2p->m_setting.m_impulseClamp = mousePickClamping;
+
 								m_dynamicsWorld->addConstraint(p2p);
 								m_pickConstraint = p2p;
 								
@@ -965,6 +969,8 @@ for(int i=0;i<numObjects;i++)
 //
 void DemoApplication::renderme()
 {
+	myinit();
+
 	updateCamera();
 
 	if (m_dynamicsWorld)
diff --git a/Demos/OpenGL/GL_ShapeDrawer.cpp b/Demos/OpenGL/GL_ShapeDrawer.cpp
index a2c028a57..d00507a8f 100644
--- a/Demos/OpenGL/GL_ShapeDrawer.cpp
+++ b/Demos/OpenGL/GL_ShapeDrawer.cpp
@@ -116,14 +116,14 @@ public:
 		glVertex3d(triangle[0].getX(), triangle[0].getY(), triangle[0].getZ());
 		glEnd();*/
 
-		
+
 	}
 };
 
 GLuint  OGL_get_displaylist_for_shape(btCollisionShape * shape)
 {
 	TRIMESH_KEY_MAP::iterator map_iter;
-	
+
 	unsigned long key = (unsigned long)shape;
 	map_iter = g_display_lists.find(key);
 	if(map_iter!=g_display_lists.end())
@@ -163,7 +163,7 @@ void OGL_displaylist_register_shape(btCollisionShape * shape)
 	unsigned long key = (unsigned long)shape;
 
 	g_display_lists.insert(TRIMESH_KEY_PAIR(key,dlist));
-	
+
 	glNewList(dlist.m_dlist,GL_COMPILE);
 
 	glEnable(GL_CULL_FACE);
@@ -184,18 +184,18 @@ void OGL_displaylist_register_shape(btCollisionShape * shape)
 #endif //USE_DISPLAY_LISTS
 
 void GL_ShapeDrawer::drawCoordSystem()  {
-    glBegin(GL_LINES);
-    glColor3f(1, 0, 0);
-    glVertex3d(0, 0, 0);
-    glVertex3d(1, 0, 0);
-    glColor3f(0, 1, 0);
-    glVertex3d(0, 0, 0);
-    glVertex3d(0, 1, 0);
-    glColor3f(0, 0, 1);
-    glVertex3d(0, 0, 0);
-    glVertex3d(0, 0, 1);
-    glEnd();
-	
+	glBegin(GL_LINES);
+	glColor3f(1, 0, 0);
+	glVertex3d(0, 0, 0);
+	glVertex3d(1, 0, 0);
+	glColor3f(0, 1, 0);
+	glVertex3d(0, 0, 0);
+	glVertex3d(0, 1, 0);
+	glColor3f(0, 0, 1);
+	glVertex3d(0, 0, 0);
+	glVertex3d(0, 0, 1);
+	glEnd();
+
 }
 
 
@@ -273,7 +273,7 @@ public:
 
 void GL_ShapeDrawer::drawCylinder(float radius,float halfHeight, int upAxis)
 {
-	
+
 
 	glPushMatrix();
 	switch (upAxis)
@@ -287,7 +287,7 @@ void GL_ShapeDrawer::drawCylinder(float radius,float halfHeight, int upAxis)
 		glTranslatef(0.0, 0.0, -halfHeight);
 		break;
 	case 2:
-		
+
 		glTranslatef(0.0, 0.0, -halfHeight);
 		break;
 	default:
@@ -296,18 +296,18 @@ void GL_ShapeDrawer::drawCylinder(float radius,float halfHeight, int upAxis)
 		}
 
 	}
-	
+
 	GLUquadricObj *quadObj = gluNewQuadric();
 
 	//The gluCylinder subroutine draws a cylinder that is oriented along the z axis. 
 	//The base of the cylinder is placed at z = 0; the top of the cylinder is placed at z=height. 
 	//Like a sphere, the cylinder is subdivided around the z axis into slices and along the z axis into stacks.
-	
+
 	gluQuadricDrawStyle(quadObj, (GLenum)GLU_FILL);
 	gluQuadricNormals(quadObj, (GLenum)GLU_SMOOTH);
-	
+
 	gluDisk(quadObj,0,radius,15, 10);
-	
+
 	gluCylinder(quadObj, radius, radius, 2.f*halfHeight, 15, 10);
 	glTranslatef(0.0, 0.0, 2.*halfHeight);
 	glRotatef(-180.0, 0.0, 1.0, 0.0);
@@ -319,53 +319,53 @@ void GL_ShapeDrawer::drawCylinder(float radius,float halfHeight, int upAxis)
 
 GL_ShapeDrawer::ShapeCache*		GL_ShapeDrawer::cache(btConvexShape* shape)
 {
-ShapeCache*		sc=(ShapeCache*)shape->getUserPointer();
-if(!sc)
+	ShapeCache*		sc=(ShapeCache*)shape->getUserPointer();
+	if(!sc)
 	{
-	sc=new(btAlignedAlloc(sizeof(ShapeCache),16)) ShapeCache(shape);
-	sc->m_shapehull.buildHull(shape->getMargin());
-	m_shapecaches.push_back(sc);
-	shape->setUserPointer(sc);
-	/* Build edges	*/ 
-	const int			ni=sc->m_shapehull.numIndices();
-	const int			nv=sc->m_shapehull.numVertices();
-	const unsigned int*	pi=sc->m_shapehull.getIndexPointer();
-	const btVector3*	pv=sc->m_shapehull.getVertexPointer();
-	btAlignedObjectArray<ShapeCache::Edge*>	edges;
-	sc->m_edges.reserve(ni);
-	edges.resize(nv*nv,0);
-	for(int i=0;i<ni;i+=3)
+		sc=new(btAlignedAlloc(sizeof(ShapeCache),16)) ShapeCache(shape);
+		sc->m_shapehull.buildHull(shape->getMargin());
+		m_shapecaches.push_back(sc);
+		shape->setUserPointer(sc);
+		/* Build edges	*/ 
+		const int			ni=sc->m_shapehull.numIndices();
+		const int			nv=sc->m_shapehull.numVertices();
+		const unsigned int*	pi=sc->m_shapehull.getIndexPointer();
+		const btVector3*	pv=sc->m_shapehull.getVertexPointer();
+		btAlignedObjectArray<ShapeCache::Edge*>	edges;
+		sc->m_edges.reserve(ni);
+		edges.resize(nv*nv,0);
+		for(int i=0;i<ni;i+=3)
 		{
-		const unsigned int* ti=pi+i;
-		const btVector3		nrm=cross(pv[ti[1]]-pv[ti[0]],pv[ti[2]]-pv[ti[0]]).normalized();
-		for(int j=2,k=0;k<3;j=k++)
+			const unsigned int* ti=pi+i;
+			const btVector3		nrm=cross(pv[ti[1]]-pv[ti[0]],pv[ti[2]]-pv[ti[0]]).normalized();
+			for(int j=2,k=0;k<3;j=k++)
 			{
-			const unsigned int	a=ti[j];
-			const unsigned int	b=ti[k];
-			ShapeCache::Edge*&	e=edges[btMin(a,b)*nv+btMax(a,b)];
-			if(!e)
+				const unsigned int	a=ti[j];
+				const unsigned int	b=ti[k];
+				ShapeCache::Edge*&	e=edges[btMin(a,b)*nv+btMax(a,b)];
+				if(!e)
 				{
-				sc->m_edges.push_back(ShapeCache::Edge());
-				e=&sc->m_edges[sc->m_edges.size()-1];
-				e->n[0]=nrm;e->n[1]=-nrm;
-				e->v[0]=a;e->v[1]=b;
+					sc->m_edges.push_back(ShapeCache::Edge());
+					e=&sc->m_edges[sc->m_edges.size()-1];
+					e->n[0]=nrm;e->n[1]=-nrm;
+					e->v[0]=a;e->v[1]=b;
 				}
 				else
 				{
-				e->n[1]=nrm;
+					e->n[1]=nrm;
 				}
 			}
 		}
 	}
-return(sc);
+	return(sc);
 }
 
 void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, const btVector3& color,int	debugMode)
 {
 
-	
+
 	glPushMatrix(); 
-  btglMultMatrix(m);
+	btglMultMatrix(m);
 
 	if (shape->getShapeType() == UNIFORM_SCALING_SHAPE_PROXYTYPE)
 	{
@@ -374,10 +374,10 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 		float	scalingFactor = (float)scalingShape->getUniformScalingFactor();
 		{
 			btScalar tmpScaling[4][4]={{scalingFactor,0,0,0},
-				{0,scalingFactor,0,0},
-				{0,0,scalingFactor,0},
-				{0,0,0,1}};
-			
+			{0,scalingFactor,0,0},
+			{0,0,scalingFactor,0},
+			{0,0,0,1}};
+
 			drawOpenGL( (btScalar*)tmpScaling,convexShape,color,debugMode);
 		}
 		glPopMatrix();
@@ -399,20 +399,20 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 	} else
 	{
 		if(m_textureenabled&&(!m_textureinitialized))
-			{
+		{
 			GLubyte*	image=new GLubyte[256*256*3];
 			for(int y=0;y<256;++y)
-				{
+			{
 				const int	t=y>>4;
 				GLubyte*	pi=image+y*256*3;
 				for(int x=0;x<256;++x)
-					{
+				{
 					const int		s=x>>4;
 					const GLubyte	b=180;					
 					GLubyte			c=b+((s+t&1)&1)*(255-b);
 					pi[0]=pi[1]=pi[2]=c;pi+=3;
-					}
 				}
+			}
 			glGenTextures(1,&m_texturehandle);
 			glBindTexture(GL_TEXTURE_2D,m_texturehandle);
 			glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
@@ -422,11 +422,11 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 			glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 			gluBuild2DMipmaps(GL_TEXTURE_2D,3,256,256,GL_RGB,GL_UNSIGNED_BYTE,image);
 			delete[] image;
-			
+
 			glMatrixMode(GL_TEXTURE);
 			glLoadIdentity();
 			glScalef(0.025,0.025,0.025);
-			
+
 			static const GLfloat	planex[]={1,0,0,0};
 			static const GLfloat	planey[]={0,1,0,0};
 			static const GLfloat	planez[]={0,0,1,0};
@@ -438,12 +438,18 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 			glEnable(GL_TEXTURE_GEN_T);
 			glEnable(GL_TEXTURE_GEN_R);
 			m_textureinitialized=true;
-			}
+		}
 		//drawCoordSystem();
-	    
+
 		//glPushMatrix();
 		glEnable(GL_COLOR_MATERIAL);
-		if(m_textureenabled) glEnable(GL_TEXTURE_2D);
+		if(m_textureenabled) 
+		{
+			glEnable(GL_TEXTURE_2D);
+			glBindTexture(GL_TEXTURE_2D,m_texturehandle);
+		}
+
+		
 		glColor3f(color.x(),color.y(), color.z());		
 
 		bool useWireframeFallback = true;
@@ -464,8 +470,8 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					useWireframeFallback = false;
 					break;
 				}
-		
-			
+
+
 			case SPHERE_SHAPE_PROXYTYPE:
 				{
 					const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
@@ -474,7 +480,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					useWireframeFallback = false;
 					break;
 				}
-			
+
 			case CONE_SHAPE_PROXYTYPE:
 				{
 					const btConeShape* coneShape = static_cast<const btConeShape*>(shape);
@@ -495,14 +501,14 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 						{
 						}
 					};
-					
+
 					glTranslatef(0.0, 0.0, -0.5*height);
 					glutSolidCone(radius,height,10,10);
 					useWireframeFallback = false;
 					break;
 
 				}
-		
+
 
 			case STATIC_PLANE_PROXYTYPE:
 				{
@@ -524,7 +530,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					glVertex3f(pt3.getX(),pt3.getY(),pt3.getZ());
 					glEnd();
 
-					
+
 					break;
 
 				}
@@ -533,8 +539,8 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 				{
 					const btCylinderShape* cylinder = static_cast<const btCylinderShape*>(shape);
 					int upAxis = cylinder->getUpAxis();
-					
-					
+
+
 					float radius = cylinder->getRadius();
 					float halfHeight = cylinder->getHalfExtentsWithMargin()[upAxis];
 
@@ -542,22 +548,22 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 
 					break;
 				}
-			
+
 			default:
 				{
-					
-					
+
+
 					if (shape->isConvex())
 					{
 						ShapeCache*	sc=cache((btConvexShape*)shape);
-						#if 0
+#if 0
 						btConvexShape* convexShape = (btConvexShape*)shape;
 						if (!shape->getUserPointer())
 						{
 							//create a hull approximation
 							void* mem = btAlignedAlloc(sizeof(btShapeHull),16);
 							btShapeHull* hull = new(mem) btShapeHull(convexShape);
-					
+
 							///cleanup memory
 							m_shapeHulls.push_back(hull);
 
@@ -565,15 +571,15 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 							hull->buildHull(margin);
 							convexShape->setUserPointer(hull);
 
-							
-						//	printf("numTriangles = %d\n", hull->numTriangles ());
-						//	printf("numIndices = %d\n", hull->numIndices ());
-						//	printf("numVertices = %d\n", hull->numVertices ());
-							
+
+							//	printf("numTriangles = %d\n", hull->numTriangles ());
+							//	printf("numIndices = %d\n", hull->numIndices ());
+							//	printf("numVertices = %d\n", hull->numVertices ());
+
 
 						}
-						#endif
-						
+#endif
+
 
 
 						//if (shape->getUserPointer())
@@ -581,13 +587,13 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 							//glutSolidCube(1.0);
 							btShapeHull* hull = &sc->m_shapehull/*(btShapeHull*)shape->getUserPointer()*/;
 
-							
+
 							if (hull->numTriangles () > 0)
 							{
 								int index = 0;
 								const unsigned int* idx = hull->getIndexPointer();
 								const btVector3* vtx = hull->getVertexPointer();
-								
+
 								glBegin (GL_TRIANGLES);
 
 								for (int i = 0; i < hull->numTriangles (); i++)
@@ -611,31 +617,31 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 									btVector3 v3 = vtx[index3];
 									btVector3 normal = (v3-v1).cross(v2-v1);
 									normal.normalize ();
-									
+
 									glNormal3f(normal.getX(),normal.getY(),normal.getZ());
 									glVertex3f (v1.x(), v1.y(), v1.z());
 									glVertex3f (v2.x(), v2.y(), v2.z());
 									glVertex3f (v3.x(), v3.y(), v3.z());
-									
+
 								}
 								glEnd ();
-						
+
+							}
 						}
 					}
 				}
 			}
-		}
 
 		}
-		
 
-		
+
+
 
 		/// for polyhedral shapes
 		if (debugMode==btIDebugDraw::DBG_DrawFeaturesText && (shape->isPolyhedral()))
 		{
 			btPolyhedralConvexShape* polyshape = (btPolyhedralConvexShape*) shape;
-			
+
 			{
 				glRasterPos3f(0.0,  0.0,  0.0);
 				//BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),polyshape->getExtraDebugInfo());
@@ -663,16 +669,16 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					char buf[12];
 					sprintf(buf," plane %d",i);
 					BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),buf);
-					
+
 				}
 			}
-				
+
 		}
 
 
 #ifdef USE_DISPLAY_LISTS
 
-	if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE||shape->getShapeType() == GIMPACT_SHAPE_PROXYTYPE)
+		if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE||shape->getShapeType() == GIMPACT_SHAPE_PROXYTYPE)
 		{
 			GLuint dlist =   OGL_get_displaylist_for_shape((btCollisionShape * )shape);
 			if (dlist)
@@ -682,8 +688,8 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 			else
 			{
 #else		
-	if (shape->isConcave())//>getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE||shape->getShapeType() == GIMPACT_SHAPE_PROXYTYPE)
-//		if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+		if (shape->isConcave())//>getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE||shape->getShapeType() == GIMPACT_SHAPE_PROXYTYPE)
+			//		if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
 		{
 			btConcaveShape* concaveMesh = (btConcaveShape*) shape;
 			//btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
@@ -702,133 +708,133 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 #endif
 
 #ifdef USE_DISPLAY_LISTS
-		}
 	}
+}
 #endif
 
-	/*
-		if (shape->getShapeType() == CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE)
-		{
-			btConvexTriangleMeshShape* convexMesh = (btConvexTriangleMeshShape*) shape;
-			
-			//todo: pass camera for some culling			
-			btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
-			btVector3 aabbMin(-btScalar(1e30),-btScalar(1e30),-btScalar(1e30));
-			TriangleGlDrawcallback drawCallback;
-			convexMesh->getMeshInterface()->InternalProcessAllTriangles(&drawCallback,aabbMin,aabbMax);
+/*
+if (shape->getShapeType() == CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE)
+{
+btConvexTriangleMeshShape* convexMesh = (btConvexTriangleMeshShape*) shape;
 
-		}
-		*/
+//todo: pass camera for some culling			
+btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+btVector3 aabbMin(-btScalar(1e30),-btScalar(1e30),-btScalar(1e30));
+TriangleGlDrawcallback drawCallback;
+convexMesh->getMeshInterface()->InternalProcessAllTriangles(&drawCallback,aabbMin,aabbMax);
 
-		
+}
+*/
 
-		glDisable(GL_DEPTH_BUFFER_BIT);
-		glRasterPos3f(0,0,0);//mvtx.x(),  vtx.y(),  vtx.z());
-		if (debugMode&btIDebugDraw::DBG_DrawText)
-		{
-			BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),shape->getName());
-		}
 
-		if (debugMode& btIDebugDraw::DBG_DrawFeaturesText)
-		{
-			//BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),shape->getExtraDebugInfo());
-		}
-		glEnable(GL_DEPTH_BUFFER_BIT);
 
-	//	glPopMatrix();	
-	if(m_textureenabled) glDisable(GL_TEXTURE_2D);
+glDisable(GL_DEPTH_BUFFER_BIT);
+glRasterPos3f(0,0,0);//mvtx.x(),  vtx.y(),  vtx.z());
+if (debugMode&btIDebugDraw::DBG_DrawText)
+{
+	BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),shape->getName());
+}
+
+if (debugMode& btIDebugDraw::DBG_DrawFeaturesText)
+{
+	//BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),shape->getExtraDebugInfo());
+}
+glEnable(GL_DEPTH_BUFFER_BIT);
+
+//	glPopMatrix();	
+if(m_textureenabled) glDisable(GL_TEXTURE_2D);
 	}
-    glPopMatrix();
-	
+	glPopMatrix();
+
 }
 
 //
 void		GL_ShapeDrawer::drawShadow(btScalar* m,const btVector3& extrusion,const btCollisionShape* shape)
 {
-glPushMatrix(); 
-btglMultMatrix(m);
-if(shape->getShapeType() == UNIFORM_SCALING_SHAPE_PROXYTYPE)
+	glPushMatrix(); 
+	btglMultMatrix(m);
+	if(shape->getShapeType() == UNIFORM_SCALING_SHAPE_PROXYTYPE)
 	{
-	const btUniformScalingShape* scalingShape = static_cast<const btUniformScalingShape*>(shape);
-	const btConvexShape* convexShape = scalingShape->getChildShape();
-	float	scalingFactor = (float)scalingShape->getUniformScalingFactor();
-	btScalar tmpScaling[4][4]={	{scalingFactor,0,0,0},
-								{0,scalingFactor,0,0},
-								{0,0,scalingFactor,0},
-								{0,0,0,1}};
-	drawShadow((btScalar*)tmpScaling,extrusion,convexShape);
-	glPopMatrix();
-	return;
+		const btUniformScalingShape* scalingShape = static_cast<const btUniformScalingShape*>(shape);
+		const btConvexShape* convexShape = scalingShape->getChildShape();
+		float	scalingFactor = (float)scalingShape->getUniformScalingFactor();
+		btScalar tmpScaling[4][4]={	{scalingFactor,0,0,0},
+		{0,scalingFactor,0,0},
+		{0,0,scalingFactor,0},
+		{0,0,0,1}};
+		drawShadow((btScalar*)tmpScaling,extrusion,convexShape);
+		glPopMatrix();
+		return;
 	}
-else if(shape->getShapeType()==COMPOUND_SHAPE_PROXYTYPE)
+	else if(shape->getShapeType()==COMPOUND_SHAPE_PROXYTYPE)
 	{
-	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(shape);
-	for (int i=compoundShape->getNumChildShapes()-1;i>=0;i--)
+		const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(shape);
+		for (int i=compoundShape->getNumChildShapes()-1;i>=0;i--)
 		{
-		btTransform childTrans = compoundShape->getChildTransform(i);
-		const btCollisionShape* colShape = compoundShape->getChildShape(i);
-		btScalar childMat[16];
-		childTrans.getOpenGLMatrix(childMat);
-		drawShadow(childMat,extrusion*childTrans.getBasis(),colShape);
+			btTransform childTrans = compoundShape->getChildTransform(i);
+			const btCollisionShape* colShape = compoundShape->getChildShape(i);
+			btScalar childMat[16];
+			childTrans.getOpenGLMatrix(childMat);
+			drawShadow(childMat,extrusion*childTrans.getBasis(),colShape);
 		}
 	}
-else
+	else
 	{
 		bool useWireframeFallback = true;
 		if (shape->isConvex())
+		{
+			ShapeCache*	sc=cache((btConvexShape*)shape);
+			btShapeHull* hull =&sc->m_shapehull;
+			glBegin(GL_QUADS);
+			for(int i=0;i<sc->m_edges.size();++i)
+			{			
+				const btScalar		d=dot(sc->m_edges[i].n[0],extrusion);
+				if((d*dot(sc->m_edges[i].n[1],extrusion))<0)
 				{
-					ShapeCache*	sc=cache((btConvexShape*)shape);
-					btShapeHull* hull =&sc->m_shapehull;
-					glBegin(GL_QUADS);
-					for(int i=0;i<sc->m_edges.size();++i)
-						{			
-						const btScalar		d=dot(sc->m_edges[i].n[0],extrusion);
-						if((d*dot(sc->m_edges[i].n[1],extrusion))<0)
-							{
-							const int			q=	d<0?1:0;
-							const btVector3&	a=	hull->getVertexPointer()[sc->m_edges[i].v[q]];
-							const btVector3&	b=	hull->getVertexPointer()[sc->m_edges[i].v[1-q]];
-							glVertex3f(a[0],a[1],a[2]);
-							glVertex3f(b[0],b[1],b[2]);
-							glVertex3f(b[0]+extrusion[0],b[1]+extrusion[1],b[2]+extrusion[2]);
-							glVertex3f(a[0]+extrusion[0],a[1]+extrusion[1],a[2]+extrusion[2]);
-							}
-						}
-					glEnd();
+					const int			q=	d<0?1:0;
+					const btVector3&	a=	hull->getVertexPointer()[sc->m_edges[i].v[q]];
+					const btVector3&	b=	hull->getVertexPointer()[sc->m_edges[i].v[1-q]];
+					glVertex3f(a[0],a[1],a[2]);
+					glVertex3f(b[0],b[1],b[2]);
+					glVertex3f(b[0]+extrusion[0],b[1]+extrusion[1],b[2]+extrusion[2]);
+					glVertex3f(a[0]+extrusion[0],a[1]+extrusion[1],a[2]+extrusion[2]);
+				}
+			}
+			glEnd();
+		}
+
 	}
 
-		}
-		
 
-		
+
 
 	if (shape->isConcave())//>getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE||shape->getShapeType() == GIMPACT_SHAPE_PROXYTYPE)
-//		if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
-		{
-			btConcaveShape* concaveMesh = (btConcaveShape*) shape;
-			//btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
-			//btVector3 aabbMax(100,100,100);//btScalar(1e30),btScalar(1e30),btScalar(1e30));
+		//		if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+	{
+		btConcaveShape* concaveMesh = (btConcaveShape*) shape;
+		//btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+		//btVector3 aabbMax(100,100,100);//btScalar(1e30),btScalar(1e30),btScalar(1e30));
 
-			//todo pass camera, for some culling
-			btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
-			btVector3 aabbMin(-btScalar(1e30),-btScalar(1e30),-btScalar(1e30));
+		//todo pass camera, for some culling
+		btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+		btVector3 aabbMin(-btScalar(1e30),-btScalar(1e30),-btScalar(1e30));
 
-			GlDrawcallback drawCallback;
-			drawCallback.m_wireframe = false;
+		GlDrawcallback drawCallback;
+		drawCallback.m_wireframe = false;
 
-			concaveMesh->processAllTriangles(&drawCallback,aabbMin,aabbMax);
+		concaveMesh->processAllTriangles(&drawCallback,aabbMin,aabbMax);
+
+	}
+	glPopMatrix();
 
-		}
-    glPopMatrix();
-	
 }
 
 //
 GL_ShapeDrawer::GL_ShapeDrawer()
 {
-m_texturehandle			=	0;
-m_textureenabled		=	false;
-m_textureinitialized	=	false;
+	m_texturehandle			=	0;
+	m_textureenabled		=	false;
+	m_textureinitialized	=	false;
 }
 
 GL_ShapeDrawer::~GL_ShapeDrawer()
@@ -836,14 +842,14 @@ GL_ShapeDrawer::~GL_ShapeDrawer()
 	int i;
 	for (i=0;i<m_shapecaches.size();i++)
 	{
-	m_shapecaches[i]->~ShapeCache();
-	btAlignedFree(m_shapecaches[i]);
+		m_shapecaches[i]->~ShapeCache();
+		btAlignedFree(m_shapecaches[i]);
 	}
 	m_shapecaches.clear();
 	if(m_textureinitialized)
-		{
+	{
 		glDeleteTextures(1,&m_texturehandle);
-		}
+	}
 }
 
 
diff --git a/Extras/BulletColladaConverter/ColladaConverter.cpp b/Extras/BulletColladaConverter/ColladaConverter.cpp
index b01395610..b79e30f98 100644
--- a/Extras/BulletColladaConverter/ColladaConverter.cpp
+++ b/Extras/BulletColladaConverter/ColladaConverter.cpp
@@ -1597,7 +1597,7 @@ ColladaConverter::addConcaveMesh(btCollisionShape* shape, const char* nodeName)
 		{
 			for (int t = 0; t < numFaces; t++)
 			{
-				short int* index = (short int*)indexBase;
+				unsigned short int* index = (unsigned short int*)indexBase;
 				indices.append3( index[0], index[1], index[2]);
 				indexBase += indexStride;
 			}
@@ -1605,7 +1605,7 @@ ColladaConverter::addConcaveMesh(btCollisionShape* shape, const char* nodeName)
 		{
 			for (int t = 0; t < numFaces; t++)
 			{
-				int* index = (int*)indexBase;
+				unsigned int* index = (unsigned int*)indexBase;
 				indices.append3( index[0], index[1], index[2]);
 				indexBase += indexStride;
 			}
diff --git a/Extras/BulletMultiThreaded/SpuGatheringCollisionDispatcher.cpp b/Extras/BulletMultiThreaded/SpuGatheringCollisionDispatcher.cpp
index d42545422..9f6a14363 100644
--- a/Extras/BulletMultiThreaded/SpuGatheringCollisionDispatcher.cpp
+++ b/Extras/BulletMultiThreaded/SpuGatheringCollisionDispatcher.cpp
@@ -181,19 +181,23 @@ void	SpuGatheringCollisionDispatcher::dispatchAllCollisionPairs(btOverlappingPai
 				{
 					btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject;
 					btCollisionObject* colObj1 = (btCollisionObject*)collisionPair.m_pProxy1->m_clientObject;
-					btManifoldResult contactPointResult(colObj0,colObj1);
-					
-					if (dispatchInfo.m_dispatchFunc == 		btDispatcherInfo::DISPATCH_DISCRETE)
-					{
-						//discrete collision detection query
-						collisionPair.m_algorithm->processCollision(colObj0,colObj1,dispatchInfo,&contactPointResult);
-					} else
-					{
-						//continuous collision detection query, time of impact (toi)
-						btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
-						if (dispatchInfo.m_timeOfImpact > toi)
-							dispatchInfo.m_timeOfImpact = toi;
 
+					if (dispatcher->needsCollision(colObj0,colObj1))
+					{
+						btManifoldResult contactPointResult(colObj0,colObj1);
+						
+						if (dispatchInfo.m_dispatchFunc == 		btDispatcherInfo::DISPATCH_DISCRETE)
+						{
+							//discrete collision detection query
+							collisionPair.m_algorithm->processCollision(colObj0,colObj1,dispatchInfo,&contactPointResult);
+						} else
+						{
+							//continuous collision detection query, time of impact (toi)
+							btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
+							if (dispatchInfo.m_timeOfImpact > toi)
+								dispatchInfo.m_timeOfImpact = toi;
+
+						}
 					}
 				}
 			}
diff --git a/Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.cpp b/Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.cpp
index 04515489d..c6e211677 100644
--- a/Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.cpp
+++ b/Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.cpp
@@ -270,20 +270,20 @@ public:
 		// ugly solution to support both 16bit and 32bit indices
 		if (m_lsMemPtr->bvhShapeData.gIndexMesh.m_indexType == PHY_SHORT)
 		{
-			short int* indexBasePtr = (short int*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexBase+triangleIndex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexStride);
-			ATTRIBUTE_ALIGNED16(short int tmpIndices[3]);
+			unsigned short int* indexBasePtr = (unsigned short int*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexBase+triangleIndex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexStride);
+			ATTRIBUTE_ALIGNED16(unsigned short int tmpIndices[3]);
 
 			small_cache_read_triple(&tmpIndices[0],(ppu_address_t)&indexBasePtr[0],
 									&tmpIndices[1],(ppu_address_t)&indexBasePtr[1],
 									&tmpIndices[2],(ppu_address_t)&indexBasePtr[2],
-									sizeof(short int));
+									sizeof(unsigned short int));
 
 			m_lsMemPtr->spuIndices[0] = int(tmpIndices[0]);
 			m_lsMemPtr->spuIndices[1] = int(tmpIndices[1]);
 			m_lsMemPtr->spuIndices[2] = int(tmpIndices[2]);
 		} else
 		{
-			int* indexBasePtr = (int*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexBase+triangleIndex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexStride);
+			unsigned int* indexBasePtr = (unsigned int*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexBase+triangleIndex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexStride);
 
 			small_cache_read_triple(&m_lsMemPtr->spuIndices[0],(ppu_address_t)&indexBasePtr[0],
 								&m_lsMemPtr->spuIndices[1],(ppu_address_t)&indexBasePtr[1],
@@ -978,9 +978,12 @@ void	processCollisionTask(void* userPtr, void* lsMemPtr)
 								// Get the collision objects
 								dmaAndSetupCollisionObjects(collisionPairInput, lsMem);
 
-								handleCollisionPair(collisionPairInput, lsMem, spuContacts, 
-									(ppu_address_t)lsMem.getColObj0()->getCollisionShape(), &lsMem.gCollisionShapes[0].collisionShape,
-									(ppu_address_t)lsMem.getColObj1()->getCollisionShape(), &lsMem.gCollisionShapes[1].collisionShape);
+								if (lsMem.getColObj0()->isActive() || lsMem.getColObj1()->isActive())
+								{
+									handleCollisionPair(collisionPairInput, lsMem, spuContacts, 
+										(ppu_address_t)lsMem.getColObj0()->getCollisionShape(), &lsMem.gCollisionShapes[0].collisionShape,
+										(ppu_address_t)lsMem.getColObj1()->getCollisionShape(), &lsMem.gCollisionShapes[1].collisionShape);
+								}
 
 							}
 						}
diff --git a/Extras/BulletMultiThreaded/SpuRaycastTask/SpuRaycastTask.cpp b/Extras/BulletMultiThreaded/SpuRaycastTask/SpuRaycastTask.cpp
index 03d82f9d6..49b8827a2 100644
--- a/Extras/BulletMultiThreaded/SpuRaycastTask/SpuRaycastTask.cpp
+++ b/Extras/BulletMultiThreaded/SpuRaycastTask/SpuRaycastTask.cpp
@@ -404,9 +404,9 @@ void	spuWalkStacklessQuantizedTreeAgainstRays(RaycastTask_LocalStoreMemory* lsMe
 
 #define RAYAABB2
 #ifdef RAYAABB2
-	unsigned int sign[numWorkUnits][3];
-	btVector3 rayInvDirection[numWorkUnits];
-	btScalar lambda_max[numWorkUnits];
+	unsigned int sign[SPU_RAYCAST_WORK_UNITS_PER_TASK][3];
+	btVector3 rayInvDirection[SPU_RAYCAST_WORK_UNITS_PER_TASK];
+	btScalar lambda_max[SPU_RAYCAST_WORK_UNITS_PER_TASK];
 	for (int i = 0; i < numWorkUnits; i++)
 	{
 		btVector3 rayDirection = (rayTo[i]-rayFrom[i]);
@@ -512,10 +512,10 @@ void performRaycastAgainstConcave (RaycastGatheredObjectData* gatheredObjectData
 	//need the mesh interface, for access to triangle vertices
 	dmaBvhShapeData (&(lsMemPtr->bvhShapeData), trimeshShape);
 
-	unsigned short int quantizedQueryAabbMin[numWorkUnits][3];
-	unsigned short int quantizedQueryAabbMax[numWorkUnits][3];
-	btVector3 rayFromInTriangleSpace[numWorkUnits];
-	btVector3 rayToInTriangleSpace[numWorkUnits];
+	unsigned short int quantizedQueryAabbMin[SPU_RAYCAST_WORK_UNITS_PER_TASK][3];
+	unsigned short int quantizedQueryAabbMax[SPU_RAYCAST_WORK_UNITS_PER_TASK][3];
+	btVector3 rayFromInTriangleSpace[SPU_RAYCAST_WORK_UNITS_PER_TASK];
+	btVector3 rayToInTriangleSpace[SPU_RAYCAST_WORK_UNITS_PER_TASK];
 
 	/* Calculate the AABB for the ray in the triangle mesh shape */
 	btTransform rayInTriangleSpace;
@@ -781,4 +781,4 @@ void	processRaycastTask(void* userPtr, void* lsMemory)
 			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp b/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp
index ec497011e..8802d0e78 100644
--- a/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp
+++ b/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp
@@ -235,7 +235,7 @@ btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getCollisionAlg
 
 	if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE))
 	{
-		return m_boxBoxCF;
+		//return m_boxBoxCF;
 	}
 	
 	if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE))
diff --git a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
index 04524c396..ffab43e3c 100644
--- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
+++ b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
@@ -143,17 +143,13 @@ class btPersistentManifoldSortPredicate
 };
 
 
-
-
-
-//
-// todo: this is random access, it can be walked 'cache friendly'!
-//
-void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback)
+void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects)
 {
 
 	BT_PROFILE("islandUnionFindAndQuickSort");
 	
+	m_islandmanifold.resize(0);
+
 	//we are going to sort the unionfind array, and store the element id in the size
 	//afterwards, we clean unionfind, to make sure no-one uses it anymore
 	
@@ -287,6 +283,23 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 #endif //SPLIT_ISLANDS
 		}
 	}
+}
+
+
+
+//
+// todo: this is random access, it can be walked 'cache friendly'!
+//
+void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback)
+{
+
+	buildIslands(dispatcher,collisionObjects);
+
+	int endIslandIndex=1;
+	int startIslandIndex;
+	int numElem = getUnionFind().getNumElements();
+
+	BT_PROFILE("processIslands");
 
 #ifndef SPLIT_ISLANDS
 	btPersistentManifold** manifold = dispatcher->getInternalManifoldPointer();
@@ -367,5 +380,5 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 	}
 #endif //SPLIT_ISLANDS
 
-	m_islandmanifold.resize(0);
+
 }
diff --git a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
index 01a059b5f..5f4d54cd8 100644
--- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
+++ b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
@@ -63,6 +63,8 @@ public:
 
 	void	buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback);
 
+	void buildIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects);
+
 };
 
 #endif //SIMULATION_ISLAND_MANAGER_H
diff --git a/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp b/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
index 662830a0b..5cf50931c 100644
--- a/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
+++ b/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
@@ -127,13 +127,13 @@ void	btBvhTriangleMeshShape::performRaycast (btTriangleCallback* callback, const
 				indicestype,
 				nodeSubPart);
 
-			int* gfxbase = (int*)(indexbase+nodeTriangleIndex*indexstride);
+			unsigned int* gfxbase = (unsigned int*)(indexbase+nodeTriangleIndex*indexstride);
 			btAssert(indicestype==PHY_INTEGER||indicestype==PHY_SHORT);
 	
 			const btVector3& meshScaling = m_meshInterface->getScaling();
 			for (int j=2;j>=0;j--)
 			{
-				int graphicsindex = indicestype==PHY_SHORT?((short*)gfxbase)[j]:gfxbase[j];
+				int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
 
 				btScalar* graphicsbase = (btScalar*)(vertexbase+graphicsindex*stride);
 
@@ -187,13 +187,13 @@ void	btBvhTriangleMeshShape::performConvexcast (btTriangleCallback* callback, co
 				indicestype,
 				nodeSubPart);
 
-			int* gfxbase = (int*)(indexbase+nodeTriangleIndex*indexstride);
+			unsigned int* gfxbase = (unsigned int*)(indexbase+nodeTriangleIndex*indexstride);
 			btAssert(indicestype==PHY_INTEGER||indicestype==PHY_SHORT);
 	
 			const btVector3& meshScaling = m_meshInterface->getScaling();
 			for (int j=2;j>=0;j--)
 			{
-				int graphicsindex = indicestype==PHY_SHORT?((short*)gfxbase)[j]:gfxbase[j];
+				int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
 
 				btScalar* graphicsbase = (btScalar*)(vertexbase+graphicsindex*stride);
 
@@ -259,14 +259,14 @@ void	btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,co
 				indicestype,
 				nodeSubPart);
 
-			int* gfxbase = (int*)(indexbase+nodeTriangleIndex*indexstride);
+			unsigned int* gfxbase = (unsigned int*)(indexbase+nodeTriangleIndex*indexstride);
 			btAssert(indicestype==PHY_INTEGER||indicestype==PHY_SHORT);
 	
 			const btVector3& meshScaling = m_meshInterface->getScaling();
 			for (int j=2;j>=0;j--)
 			{
 				
-				int graphicsindex = indicestype==PHY_SHORT?((short*)gfxbase)[j]:gfxbase[j];
+				int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
 
 
 #ifdef DEBUG_TRIANGLE_MESH
@@ -299,22 +299,37 @@ void	btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,co
 
 }
 
-
-void	btBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling)
+void   btBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling)
 {
-	if ((getLocalScaling() -scaling).length2() > SIMD_EPSILON)
-	{
-		btTriangleMeshShape::setLocalScaling(scaling);
-		if (m_ownsBvh)
-		{
-			m_bvh->~btOptimizedBvh();
-			btAlignedFree(m_bvh);
-		}
-		///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
-		void* mem = btAlignedAlloc(sizeof(btOptimizedBvh),16);
-		m_bvh = new(mem) btOptimizedBvh();
-		//rebuild the bvh...
-		m_bvh->build(m_meshInterface,m_useQuantizedAabbCompression,m_localAabbMin,m_localAabbMax);
-
-	}
+   if ((getLocalScaling() -scaling).length2() > SIMD_EPSILON)
+   {
+      btTriangleMeshShape::setLocalScaling(scaling);
+      if (m_ownsBvh)
+      {
+         m_bvh->~btOptimizedBvh();
+         btAlignedFree(m_bvh);
+      }
+      ///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
+      void* mem = btAlignedAlloc(sizeof(btOptimizedBvh),16);
+      m_bvh = new(mem) btOptimizedBvh();
+      //rebuild the bvh...
+      m_bvh->build(m_meshInterface,m_useQuantizedAabbCompression,m_localAabbMin,m_localAabbMax);
+      m_ownsBvh = true;
+   }
 }
+
+void   btBvhTriangleMeshShape::setOptimizedBvh(btOptimizedBvh* bvh, const btVector3& scaling)
+{
+   btAssert(!m_bvh);
+   btAssert(!m_ownsBvh);
+
+   m_bvh = bvh;
+   m_ownsBvh = false;
+   // update the scaling without rebuilding the bvh
+   if ((getLocalScaling() -scaling).length2() > SIMD_EPSILON)
+   {
+      btTriangleMeshShape::setLocalScaling(scaling);
+   }
+}
+
+
diff --git a/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h b/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
index 4dd996578..499bd8d35 100644
--- a/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
+++ b/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
@@ -75,14 +75,7 @@ public:
 	}
 
 
-	void	setOptimizedBvh(btOptimizedBvh* bvh)
-	{
-		btAssert(!m_bvh);
-		btAssert(!m_ownsBvh);
-
-		m_bvh = bvh;
-		m_ownsBvh = false;
-	}
+	void	setOptimizedBvh(btOptimizedBvh* bvh, const btVector3& localScaling=btVector3(1,1,1));
 
 	bool	usesQuantizedAabbCompression() const
 	{
diff --git a/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp b/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
index cd850bb97..fdf2ddc85 100644
--- a/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
+++ b/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
@@ -334,13 +334,13 @@ void	btOptimizedBvh::updateBvhNodes(btStridingMeshInterface* meshInterface,int f
 				}
 				//triangles->getLockedReadOnlyVertexIndexBase(vertexBase,numVerts,
 
-				int* gfxbase = (int*)(indexbase+nodeTriangleIndex*indexstride);
+				unsigned int* gfxbase = (unsigned int*)(indexbase+nodeTriangleIndex*indexstride);
 				
 				
 				for (int j=2;j>=0;j--)
 				{
 					
-					int graphicsindex = indicestype==PHY_SHORT?((short*)gfxbase)[j]:gfxbase[j];
+					int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
 					btScalar* graphicsbase = (btScalar*)(vertexbase+graphicsindex*stride);
 #ifdef DEBUG_PATCH_COLORS
 					btVector3 mycolor = color[index&3];
diff --git a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
index 3129b7c83..752a5fc1d 100644
--- a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
+++ b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
@@ -51,7 +51,7 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 			{
 				for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
 				{
-					int* tri_indices= (int*)(indexbase+gfxindex*indexstride);
+					unsigned int* tri_indices= (unsigned int*)(indexbase+gfxindex*indexstride);
 					graphicsbase = (btScalar*)(vertexbase+tri_indices[0]*stride);
 					triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
 					graphicsbase = (btScalar*)(vertexbase+tri_indices[1]*stride);
@@ -66,7 +66,7 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 			{
 				for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
 				{
-					short int* tri_indices= (short int*)(indexbase+gfxindex*indexstride);
+					unsigned short int* tri_indices= (unsigned short int*)(indexbase+gfxindex*indexstride);
 					graphicsbase = (btScalar*)(vertexbase+tri_indices[0]*stride);
 					triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
 					graphicsbase = (btScalar*)(vertexbase+tri_indices[1]*stride);
diff --git a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
index 86b4652c9..7b3716154 100644
--- a/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
+++ b/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
@@ -47,7 +47,7 @@ class  btStridingMeshInterface
 
 
 
-		void	InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;
+		virtual void	InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;
 
 		///brute force method to calculate aabb
 		void	calculateAabbBruteForce(btVector3& aabbMin,btVector3& aabbMax);
diff --git a/src/BulletCollision/CollisionShapes/btTriangleMesh.h b/src/BulletCollision/CollisionShapes/btTriangleMesh.h
index f4d2eb3a1..109a735bd 100644
--- a/src/BulletCollision/CollisionShapes/btTriangleMesh.h
+++ b/src/BulletCollision/CollisionShapes/btTriangleMesh.h
@@ -30,8 +30,8 @@ class btTriangleMesh : public btTriangleIndexVertexArray
 	btAlignedObjectArray<btVector3>	m_4componentVertices;
 	btAlignedObjectArray<float>		m_3componentVertices;
 
-	btAlignedObjectArray<int>		m_32bitIndices;
-	btAlignedObjectArray<short int>		m_16bitIndices;
+	btAlignedObjectArray<unsigned int>		m_32bitIndices;
+	btAlignedObjectArray<unsigned short int>		m_16bitIndices;
 	bool	m_use32bitIndices;
 	bool	m_use4componentVertices;
 
diff --git a/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp b/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp
index 5c7056509..8b0249680 100644
--- a/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp
+++ b/src/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp
@@ -120,7 +120,7 @@ bool	btSubsimplexConvexCast::calcTimeOfImpact(
 			dist2 = v.length2();
 			hasResult = true;
 			//todo: check this normal for validity
-			n=v;
+			//n=v;
 			//printf("V=%f , %f, %f\n",v[0],v[1],v[2]);
 			//printf("DIST2=%f\n",dist2);
 			//printf("numverts = %i\n",m_simplexSolver->numVertices());
diff --git a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp
index ff918ea56..2b69ad904 100644
--- a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp
+++ b/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp
@@ -100,6 +100,16 @@ void	btPoint2PointConstraint::solveConstraint(btScalar	timeStep)
 		btScalar depth = -(pivotAInW - pivotBInW).dot(normal); //this is the error projected on the normal
 		
 		btScalar impulse = depth*m_setting.m_tau/timeStep  * jacDiagABInv -  m_setting.m_damping * rel_vel * jacDiagABInv;
+
+		btScalar impulseClamp = m_setting.m_impulseClamp;
+		if (impulseClamp > 0)
+		{
+			if (impulse < -impulseClamp) 
+				impulse = -impulseClamp;
+			if (impulse > impulseClamp) 
+				impulse = impulseClamp;
+		}
+
 		m_appliedImpulse+=impulse;
 		btVector3 impulse_vector = normal * impulse;
 		m_rbA.applyImpulse(impulse_vector, pivotAInW - m_rbA.getCenterOfMassPosition());
diff --git a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h b/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h
index 27872b9c8..c9d596853 100644
--- a/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h
+++ b/src/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h
@@ -26,11 +26,13 @@ struct	btConstraintSetting
 {
 	btConstraintSetting()	:
 		m_tau(btScalar(0.3)),
-		m_damping(btScalar(1.))
+		m_damping(btScalar(1.)),
+		m_impulseClamp(btScalar(0.))
 	{
 	}
 	btScalar		m_tau;
 	btScalar		m_damping;
+	btScalar		m_impulseClamp;
 };
 
 /// point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space
diff --git a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp b/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp
index d624c810f..b8afbd6aa 100644
--- a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp
+++ b/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp
@@ -154,7 +154,6 @@ void	initSolverBody(btSolverBody* solverBody, btCollisionObject* collisionObject
 }
 
 
-
 int		gNumSplitImpulseRecoveries = 0;
 
 btScalar restitutionCurve(btScalar rel_vel, btScalar restitution);