From 6ee9eb9bb52189ebc0f7448904d85d9d86170a60 Mon Sep 17 00:00:00 2001
From: erwin coumans <erwin.coumans@gmail.com>
Date: Thu, 2 May 2013 09:49:16 -0700
Subject: [PATCH] fix bug in assignment of contact constraints to solver grid
 (always use dynamic body to determine constraint assignment, otherwise write
 conflicts can occur) implement CPU version of narrowphase convex collision,
 for comparison/debug purposes start towards cpu/gpu sync, for adding/removing
 bodies (work in progress)

---
 Demos3/BasicDemo/BasicDemo.cpp                |   2 +-
 Demos3/BasicGpuDemo/BasicGpuDemo.cpp          |  54 +-
 btgui/OpenGLWindow/GLInstancingRenderer.cpp   |   8 +-
 data/testFile.bullet                          | Bin 15852 -> 73336 bytes
 demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp    |  21 +-
 demos3/BasicGpuDemo/b3GpuDynamicsWorld.h      |   4 +-
 src/Bullet3Common/b3Quaternion.h              |   2 +-
 .../b3ConvexHullContact.cpp                   | 855 +++++++++++++++++-
 .../RigidBody/b3GpuBatchingPgsSolver.cpp      |  36 +-
 .../RigidBody/b3GpuBatchingPgsSolver.h        |   2 +-
 .../RigidBody/b3GpuNarrowPhase.cpp            |   4 +-
 .../RigidBody/b3GpuNarrowPhase.h              |   4 +
 .../RigidBody/b3GpuRigidBodyPipeline.cpp      |   7 +-
 .../RigidBody/kernels/solverSetup2.cl         |  13 +-
 .../RigidBody/kernels/solverSetup2.h          |  13 +-
 15 files changed, 966 insertions(+), 59 deletions(-)

diff --git a/Demos3/BasicDemo/BasicDemo.cpp b/Demos3/BasicDemo/BasicDemo.cpp
index ae223626f..425506520 100644
--- a/Demos3/BasicDemo/BasicDemo.cpp
+++ b/Demos3/BasicDemo/BasicDemo.cpp
@@ -172,7 +172,7 @@ void	BasicDemo::initPhysics()
 				{
 					startTransform.setOrigin(SCALING*btVector3(
 										btScalar(2.0*i + start_x),
-										btScalar(20+2.0*k + start_y),
+										btScalar(6+2.0*k + start_y),
 										btScalar(2.0*j + start_z)));
 
 			
diff --git a/Demos3/BasicGpuDemo/BasicGpuDemo.cpp b/Demos3/BasicGpuDemo/BasicGpuDemo.cpp
index 9e71363ff..bca6dc85c 100644
--- a/Demos3/BasicGpuDemo/BasicGpuDemo.cpp
+++ b/Demos3/BasicGpuDemo/BasicGpuDemo.cpp
@@ -164,6 +164,10 @@ void BasicGpuDemo::exitCL()
 BasicGpuDemo::BasicGpuDemo()
 {
 	m_clData = new btInternalData;
+	setCameraDistance(btScalar(SCALING*20.));
+	this->setAzi(45);
+	this->setEle(45);
+
 }
 
 BasicGpuDemo::~BasicGpuDemo()
@@ -179,8 +183,7 @@ void	BasicGpuDemo::initPhysics()
 	setTexturing(true);
 	setShadows(true);
 
-	setCameraDistance(btScalar(SCALING*50.));
-
+	
 	///collision configuration contains default setup for memory, collision setup
 	m_collisionConfiguration = 0;
 	//m_collisionConfiguration->setConvexConvexMultipointIterations();
@@ -224,12 +227,37 @@ void	BasicGpuDemo::initPhysics()
 //	btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0),50);
 	
 	m_collisionShapes.push_back(groundShape);
+	if (0)
+	{
+		btTransform tr;
+		tr.setIdentity();
+		btVector3 faraway(-1e30,-1e30,-1e30);
 
+		tr.setOrigin(faraway);
+		btScalar mass(0.);
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0,0,0);
+		if (isDynamic)
+			groundShape->calculateLocalInertia(mass,localInertia);
+
+		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(tr);
+		btSphereShape* dummyShape = new btSphereShape(0.f);
+		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,dummyShape,localInertia);
+		btRigidBody* body = new btRigidBody(rbInfo);
+
+		//add the body to the dynamics world
+		m_dynamicsWorld->addRigidBody(body);
+
+
+	}
 	btTransform groundTransform;
 	groundTransform.setIdentity();
 	groundTransform.setOrigin(btVector3(0,-50,0));
-
-	//We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+		//We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
 	{
 		btScalar mass(0.);
 
@@ -241,15 +269,16 @@ void	BasicGpuDemo::initPhysics()
 			groundShape->calculateLocalInertia(mass,localInertia);
 
 		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
-		btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
-		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
+		//btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,0,groundShape,localInertia);
 		btRigidBody* body = new btRigidBody(rbInfo);
+		body->setWorldTransform(groundTransform);
 
 		//add the body to the dynamics world
 		m_dynamicsWorld->addRigidBody(body);
 	}
-
-
+	
+	
 	{
 		//create a few dynamic rigidbodies
 		// Re-using the same collision is better for memory usage and performance
@@ -282,9 +311,9 @@ void	BasicGpuDemo::initPhysics()
 				for(int j = 0;j<ARRAY_SIZE_Z;j++)
 				{
 					startTransform.setOrigin(SCALING*btVector3(
-										btScalar(2.0*i + start_x),
-										btScalar(20+2.0*k + start_y),
-										btScalar(2.0*j + start_z)));
+										btScalar(2.*i + start_x),
+										btScalar(6+2.0*k + start_y),
+										btScalar(2.*j + start_z)));
 
 			
 					//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
@@ -300,6 +329,9 @@ void	BasicGpuDemo::initPhysics()
 		}
 	}
 
+	
+
+
 	np->writeAllBodiesToGpu();
 	bp->writeAabbsToGpu();
 	rbp->writeAllInstancesToGpu();
diff --git a/btgui/OpenGLWindow/GLInstancingRenderer.cpp b/btgui/OpenGLWindow/GLInstancingRenderer.cpp
index 693564e64..cb1a51941 100644
--- a/btgui/OpenGLWindow/GLInstancingRenderer.cpp
+++ b/btgui/OpenGLWindow/GLInstancingRenderer.cpp
@@ -130,10 +130,10 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
 				
 			} else
 			{
-				m_cameraDistance -= deltay*0.1;
-				//b3Vector3 fwd = m_cameraTargetPosition-m_cameraPosition;
-				//fwd.normalize();
-				//m_cameraTargetPosition += fwd*deltay*0.1;
+				//m_cameraDistance -= deltay*0.1;
+				b3Vector3 fwd = m_cameraTargetPosition-m_cameraPosition;
+				fwd.normalize();
+				m_cameraTargetPosition += fwd*deltay*0.1;
 			}
         } else
 		{
diff --git a/data/testFile.bullet b/data/testFile.bullet
index bc82d49503a075f54c7bf98b0bd323b63c170de1..a444865a1d9131a548cafb0c0d53c3b0bf732ff8 100644
GIT binary patch
literal 73336
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
AKL7v#

delta 3460
zcmbuB3rtgI6vr=EpR^Q9QR>>z3CrRGL}#SEEw%_@#+f1W!F;es?2KESfNahIuGNTE
z4T`PE6lZ<lqCBch34Pso5fRif>NaBBe4rDRA)q)IBG7&3Ym2c7U6-EZrr-H`&;NYq
zch7gf+iPJw$v%6^U$cy%tc}kzwubdp5y)y2^2Bz#Qg*v>s~G&9dtbynvu!oP9QaJT
zj%IWyWmE3SXz*d)m-r5`f@e{+gqrJ*Z6HCgcxg6SofT~8je1CG<s(BGtJkcNX+Ieu
z96J`Lv)lc&_m&0EFBv>oKG~)&g_!i@2~h+=%WT5V>EIVD*G{|LI8Sf4U%-n-Nrum1
zV-;)F3_gH}|2R#2JLNPkyeT)$IEacnPPSrSvf#8)ozQ9=aDrGw9HsjY$mCsZuR!<`
zpYd}v&%#Y1sL+|?%}~UH^+9I-#b{G@*E#cWAhwJSo<F^+t6UM#R}L`?L?O6njx-Yi
zAqdkMj$Zv&G5U|jAW)Lwa{!2Kqxi}`RAFb`5;EkW&Hy61`Xwfq6Ti(eg8zA`PV{RG
z3sF&F(f%GCy`Iv^r~d6A;bXjju+Ez$NzlGUX?We31mnz8)6L24rXv=H#S@9ED|7T{
zeUY$8&KnbExT*#pEf!j1h=j)+KteSJx5TBxHu0954H(4ZA8dFZYzV8wKC7-lw03r-
z$OR&~O-FAu+?Ahcf7KGc#P7cG9#5(cji723B^D@Qk3nMTU_Ud(Y~f2hfk;Z@;dX$S
zYDT5AXq9vBbr2}Y@HqfP&N#j{nqnvwMOkFc)BqERo+`;Q{exQKkNjrb67lQ+virAY
zaldnOEWN9vvzyp)U)*w#=t1+o#3xp@@g&j%Nff0PQ?P)65AK+E?VKo)cOEr(BEiiK
ziW2&5kA#?OD|%3S(6aoW-o%^3Fpyb3`Li1IpJQ{NB*W(b5}TNOWiP5^`wbbnxlM>k
z{MaMIBt8vE#Qw_5LNfQAL=x_Ur1`(-=xE!Fxb_+c2_NGHglgs?iS%+R)iQSjCea&l
z*d)AYC9gixc<c%Gu0*~3Nh|Jw>*OT#OUu&jb6~>|5j|h&Z38Ru9QYn{*jTg@p7Y+>
zC&fE132@ctR-MEz#(23u_D7fmq<x`3`O-<@!WA8zTAviRyuv}j$9MtJoV3VdJ&{jM
z+8%)^+%McORfW$I9aT!D!}UW3oBQspFZKMKY7F80w_l^fgO>HBKgR9wpuJun>d!%A
zM>}{-0qu|;#8*Or1+pumbZ#;(yrto);RTw@{5=!<>jIO>qPv;ob0>(^mv!{$+O)Xi
zCmbMrj295hv^Gm%myU`#RF2=3*1^rvK~aX;YFy^A9m-0~)9BrWW$?JqTZ5+gp{hIU
zBhWh&9)D?Me-JCmb$oiv0VLLO9H+*bx;#ULXgRK&YuzpCMpe(;RDk`a*yZHnjRj<<
zlSDNlaqHfWxRbdK5^!qx5HBD!sX~hTyok!qI3a~90;)LD>c-9Hr_mL!lTZwONT9p?
z;Z|e~$bi8&%&n14n(MeDQjIh^Gicdakpg$jcTdA-Fb{+eeO7qP2wc{3`AT50pS{ZX
zGC+el+~2lB{0z<ccb8#5Hbg^4x0jKRoLm%jI{IOAVO-;f4lX{%3y2za3N^K~n7StB
z#6qP78+#;KHF;)HMf?BYlB4EC)z2-$uZxlQJ0gJ#pI?IgF@mbdg&&m-?HrF8ZLGt|
z@k#G5UV@eqgf2Lh{m?ZUU8B$iHUeFCr-6TS565)q;K8{tc1$ak5aTe_1!CW^i9@2}
z(X2~!3>t$ln7e5B5vIgzQ4SJti9-8;Fqpe&!X1mnYtdjN;1V5&#vlylF8XImq4%O(
zB;XPaKw}UFa~IVF&X#(;(hwxz5@n(>2!pwco?Y7Fz32oa;1Xq_F$jaXi;9Zp#CpBb
yiAcaD8i>Xq4CXExRvG5~(+@=gE>SibgD{x8s3On&pQ76QzVH2b=cc?&3jY@(f9XO1

diff --git a/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp
index 14e0de17f..9def1e17e 100644
--- a/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp
+++ b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp
@@ -10,8 +10,11 @@
 #include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
 
 #include "LinearMath/btQuickprof.h"
-#include "Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h"
+#include "Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h"
 #include "Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h"
+#include "Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h"
+
+
 
 
 #ifdef _WIN32
@@ -23,7 +26,7 @@
 b3GpuDynamicsWorld::b3GpuDynamicsWorld(class b3GpuSapBroadphase* bp,class b3GpuNarrowPhase* np, class b3GpuRigidBodyPipeline* rigidBodyPipeline)
 	:btDynamicsWorld(0,0,0),
 	m_gravity(0,-10,0),
-m_once(true),
+m_cpuGpuSync(true),
 m_bp(bp),
 m_np(np),
 m_rigidBodyPipeline(rigidBodyPipeline)
@@ -50,9 +53,12 @@ int		b3GpuDynamicsWorld::stepSimulation( btScalar timeStep,int maxSubSteps, btSc
 
 	//convert all shapes now, and if any change, reset all (todo)
 	
-	if (m_once)
+	
+	if (m_cpuGpuSync)
 	{
-		m_once = false;
+		m_cpuGpuSync = false;
+		m_np->writeAllBodiesToGpu();
+		m_bp->writeAabbsToGpu();
 		m_rigidBodyPipeline->writeAllInstancesToGpu();
 	}
 
@@ -271,7 +277,7 @@ int b3GpuDynamicsWorld::findOrRegisterCollisionShape(const btCollisionShape* col
 
 void	b3GpuDynamicsWorld::addRigidBody(btRigidBody* body)
 {
-
+	m_cpuGpuSync = true;
 	body->setMotionState(0);
 	
 
@@ -293,7 +299,12 @@ void	b3GpuDynamicsWorld::addRigidBody(btRigidBody* body)
 
 void	b3GpuDynamicsWorld::removeCollisionObject(btCollisionObject* colObj)
 {
+	m_cpuGpuSync = true;
 	btDynamicsWorld::removeCollisionObject(colObj);
 }
 
+void	b3GpuDynamicsWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
+{
+
+}
 
diff --git a/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h
index 3d4f525bd..1658385b9 100644
--- a/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h
+++ b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h
@@ -26,7 +26,7 @@ class b3GpuDynamicsWorld : public btDynamicsWorld
 
 	
 	btVector3			m_gravity;
-	bool	m_once;
+	bool	m_cpuGpuSync;
 	
 		
 	int findOrRegisterCollisionShape(const btCollisionShape* colShape);
@@ -52,7 +52,7 @@ public:
 
 	void	removeCollisionObject(btCollisionObject* colObj);
 
-	
+	void	rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
 
 	btAlignedObjectArray<class btCollisionObject*>& getCollisionObjectArray();
 
diff --git a/src/Bullet3Common/b3Quaternion.h b/src/Bullet3Common/b3Quaternion.h
index 1464e42e2..1472dbe6f 100644
--- a/src/Bullet3Common/b3Quaternion.h
+++ b/src/Bullet3Common/b3Quaternion.h
@@ -74,7 +74,7 @@ public:
 	b3Quaternion(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z, const b3Scalar& _w) 
 		: b3QuadWord(_x, _y, _z, _w) 
 	{
-		b3Assert(!((_x==1.f) && (_y==0.f) && (_z==0.f) && (_w==0.f)));
+		//b3Assert(!((_x==1.f) && (_y==0.f) && (_z==0.f) && (_w==0.f)));
 	}
   /**@brief Axis angle Constructor
    * @param axis The axis which the rotation is around
diff --git a/src/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.cpp b/src/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.cpp
index c782c525d..bdcb2a281 100644
--- a/src/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.cpp
+++ b/src/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.cpp
@@ -20,6 +20,8 @@ subject to the following restrictions:
 
 //#define B3_DEBUG_SAT_FACE
 
+int b3g_actualSATPairTests=0;
+
 #include "b3ConvexHullContact.h"
 #include <string.h>//memcpy
 #include "b3ConvexPolyhedronCL.h"
@@ -240,13 +242,12 @@ float signedDistanceFromPointToPlane(const float4& point, const float4& planeEqn
 
 
 #define cross3(a,b) (a.cross(b))
-b3Vector3 transform(b3Vector3* v, const b3Vector3* pos, const b3Vector3* orn)
+b3Vector3 transform(const b3Vector3* v, const b3Vector3* pos, const b3Quaternion* orn)
 {
 	b3Transform tr;
 	tr.setIdentity();
 	tr.setOrigin(*pos);
-	b3Quaternion* o = (b3Quaternion*) orn;
-	tr.setRotation(*o);
+	tr.setRotation(*orn);
 	b3Vector3 res = tr(*v);
 	return res;
 }
@@ -837,6 +838,840 @@ void	computeContactSphereConvex(int pairIndex,
 	
 }
 
+#define MAX_VERTS 1024
+
+
+inline void project(const b3ConvexPolyhedronCL& hull,  const float4& pos, const b3Quaternion& orn, const float4& dir, const b3AlignedObjectArray<b3Vector3>& vertices, b3Scalar& min, b3Scalar& max)
+{
+	min = FLT_MAX;
+	max = -FLT_MAX;
+	int numVerts = hull.m_numVertices;
+
+	const float4 localDir = b3QuatRotate(orn.inverse(),dir);
+
+	b3Scalar offset = dot3F4(pos,dir);
+
+	for(int i=0;i<numVerts;i++)
+	{
+		//b3Vector3 pt = trans * vertices[m_vertexOffset+i];
+		//b3Scalar dp = pt.dot(dir);
+		b3Vector3 vertex = vertices[hull.m_vertexOffset+i];
+		b3Scalar dp = dot3F4((float4&)vertices[hull.m_vertexOffset+i],localDir);
+		//b3Assert(dp==dpL);
+		if(dp < min)	min = dp;
+		if(dp > max)	max = dp;
+	}
+	if(min>max)
+	{
+		b3Scalar tmp = min;
+		min = max;
+		max = tmp;
+	}
+	min += offset;
+	max += offset;
+}
+
+
+static bool TestSepAxis(const b3ConvexPolyhedronCL& hullA, const b3ConvexPolyhedronCL& hullB, 
+	const float4& posA,const b3Quaternion& ornA,
+	const float4& posB,const b3Quaternion& ornB,
+	const float4& sep_axis, const b3AlignedObjectArray<b3Vector3>& verticesA,const b3AlignedObjectArray<b3Vector3>& verticesB,b3Scalar& depth)
+{
+	b3Scalar Min0,Max0;
+	b3Scalar Min1,Max1;
+	project(hullA,posA,ornA,sep_axis,verticesA, Min0, Max0);
+	project(hullB,posB,ornB, sep_axis,verticesB, Min1, Max1);
+
+	if(Max0<Min1 || Max1<Min0)
+		return false;
+
+	b3Scalar d0 = Max0 - Min1;
+	assert(d0>=0.0f);
+	b3Scalar d1 = Max1 - Min0;
+	assert(d1>=0.0f);
+	depth = d0<d1 ? d0:d1;
+	return true;
+}
+
+inline bool IsAlmostZero(const b3Vector3& v)
+{
+	if(fabsf(v.x)>1e-6 || fabsf(v.y)>1e-6 || fabsf(v.z)>1e-6)	return false;
+	return true;
+}
+
+
+static bool findSeparatingAxis(	const b3ConvexPolyhedronCL& hullA, const b3ConvexPolyhedronCL& hullB, 
+	const float4& posA1,
+	const b3Quaternion& ornA,
+	const float4& posB1,
+	const b3Quaternion& ornB,
+	const b3AlignedObjectArray<b3Vector3>& verticesA,
+	const b3AlignedObjectArray<b3Vector3>& uniqueEdgesA, 
+	const b3AlignedObjectArray<b3GpuFace>& facesA,
+	const b3AlignedObjectArray<int>& indicesA,
+	const b3AlignedObjectArray<b3Vector3>& verticesB, 
+	const b3AlignedObjectArray<b3Vector3>& uniqueEdgesB, 
+	const b3AlignedObjectArray<b3GpuFace>& facesB,
+	const b3AlignedObjectArray<int>& indicesB,
+
+	b3Vector3& sep)
+{
+	B3_PROFILE("findSeparatingAxis");
+
+	b3g_actualSATPairTests++;
+	float4 posA = posA1;
+	posA.w = 0.f;
+	float4 posB = posB1;
+	posB.w = 0.f;
+//#ifdef TEST_INTERNAL_OBJECTS
+	float4 c0local = (float4&)hullA.m_localCenter;
+	float4 c0 = transform(&c0local, &posA, &ornA);
+	float4 c1local = (float4&)hullB.m_localCenter;
+	float4 c1 = transform(&c1local,&posB,&ornB);
+	const float4 deltaC2 = c0 - c1;
+//#endif
+
+	b3Scalar dmin = FLT_MAX;
+	int curPlaneTests=0;
+
+	int numFacesA = hullA.m_numFaces;
+	// Test normals from hullA
+	for(int i=0;i<numFacesA;i++)
+	{
+		const float4& normal = (float4&)facesA[hullA.m_faceOffset+i].m_plane;
+		float4 faceANormalWS = b3QuatRotate(ornA,normal);
+
+		if (dot3F4(deltaC2,faceANormalWS)<0)
+			faceANormalWS*=-1.f;
+
+		curPlaneTests++;
+#ifdef TEST_INTERNAL_OBJECTS
+		gExpectedNbTests++;
+		if(gUseInternalObject && !TestInternalObjects(transA,transB, DeltaC2, faceANormalWS, hullA, hullB, dmin))
+			continue;
+		gActualNbTests++;
+#endif
+
+		
+		b3Scalar d;
+		if(!TestSepAxis( hullA, hullB, posA,ornA,posB,ornB,faceANormalWS, verticesA, verticesB,d))
+			return false;
+
+		if(d<dmin)
+		{
+			dmin = d;
+			sep = (b3Vector3&)faceANormalWS;
+		}
+	}
+
+	int numFacesB = hullB.m_numFaces;
+	// Test normals from hullB
+	for(int i=0;i<numFacesB;i++)
+	{
+		float4 normal = (float4&)facesB[hullB.m_faceOffset+i].m_plane;
+		float4 WorldNormal = b3QuatRotate(ornB, normal);
+
+		if (dot3F4(deltaC2,WorldNormal)<0)
+		{
+			WorldNormal*=-1.f;
+		}
+		curPlaneTests++;
+#ifdef TEST_INTERNAL_OBJECTS
+		gExpectedNbTests++;
+		if(gUseInternalObject && !TestInternalObjects(transA,transB,DeltaC2, WorldNormal, hullA, hullB, dmin))
+			continue;
+		gActualNbTests++;
+#endif
+
+		b3Scalar d;
+		if(!TestSepAxis(hullA, hullB,posA,ornA,posB,ornB,WorldNormal,verticesA,verticesB,d))
+			return false;
+
+		if(d<dmin)
+		{
+			dmin = d;
+			sep = (b3Vector3&)WorldNormal;
+		}
+	}
+
+	b3Vector3 edgeAstart,edgeAend,edgeBstart,edgeBend;
+
+	int curEdgeEdge = 0;
+	// Test edges
+	for(int e0=0;e0<hullA.m_numUniqueEdges;e0++)
+	{
+		const float4& edge0 = (float4&) uniqueEdgesA[hullA.m_uniqueEdgesOffset+e0];
+		float4 edge0World = b3QuatRotate(ornA,(float4&)edge0);
+
+		for(int e1=0;e1<hullB.m_numUniqueEdges;e1++)
+		{
+			const b3Vector3 edge1 = uniqueEdgesB[hullB.m_uniqueEdgesOffset+e1];
+			float4 edge1World = b3QuatRotate(ornB,(float4&)edge1);
+
+
+			float4 crossje = cross3(edge0World,edge1World);
+
+			curEdgeEdge++;
+			if(!IsAlmostZero((b3Vector3&)crossje))
+			{
+				crossje = normalize3(crossje);
+				if (dot3F4(deltaC2,crossje)<0)
+					crossje*=-1.f;
+
+
+#ifdef TEST_INTERNAL_OBJECTS
+				gExpectedNbTests++;
+				if(gUseInternalObject && !TestInternalObjects(transA,transB,DeltaC2, Cross, hullA, hullB, dmin))
+					continue;
+				gActualNbTests++;
+#endif
+
+				b3Scalar dist;
+				if(!TestSepAxis( hullA, hullB, posA,ornA,posB,ornB,crossje, verticesA,verticesB,dist))
+					return false;
+
+				if(dist<dmin)
+				{
+					dmin = dist;
+					sep = (b3Vector3&)crossje;
+				}
+			}
+		}
+
+	}
+
+	
+	if((dot3F4(-deltaC2,(float4&)sep))>0.0f)
+		sep = -sep;
+
+	return true;
+}
+
+
+__inline float4 lerp3(const float4& a,const float4& b, float  t)
+{
+	return make_float4(	a.x + (b.x - a.x) * t,
+						a.y + (b.y - a.y) * t,
+						a.z + (b.z - a.z) * t,
+						0.f);
+}
+
+
+// Clips a face to the back of a plane, return the number of vertices out, stored in ppVtxOut
+int clipFace(const float4* pVtxIn, int numVertsIn, float4& planeNormalWS,float planeEqWS, float4* ppVtxOut)
+{
+	
+	int ve;
+	float ds, de;
+	int numVertsOut = 0;
+	if (numVertsIn < 2)
+		return 0;
+
+	float4 firstVertex=pVtxIn[numVertsIn-1];
+	float4 endVertex = pVtxIn[0];
+	
+	ds = dot3F4(planeNormalWS,firstVertex)+planeEqWS;
+
+	for (ve = 0; ve < numVertsIn; ve++)
+	{
+		endVertex=pVtxIn[ve];
+
+		de = dot3F4(planeNormalWS,endVertex)+planeEqWS;
+
+		if (ds<0)
+		{
+			if (de<0)
+			{
+				// Start < 0, end < 0, so output endVertex
+				ppVtxOut[numVertsOut++] = endVertex;
+			}
+			else
+			{
+				// Start < 0, end >= 0, so output intersection
+				ppVtxOut[numVertsOut++] = lerp3(firstVertex, endVertex,(ds * 1.f/(ds - de)) );
+			}
+		}
+		else
+		{
+			if (de<0)
+			{
+				// Start >= 0, end < 0 so output intersection and end
+				ppVtxOut[numVertsOut++] = lerp3(firstVertex, endVertex,(ds * 1.f/(ds - de)) );
+				ppVtxOut[numVertsOut++] = endVertex;
+			}
+		}
+		firstVertex = endVertex;
+		ds = de;
+	}
+	return numVertsOut;
+}
+
+
+int clipFaceAgainstHull(const float4& separatingNormal, const b3ConvexPolyhedronCL* hullA,  
+	const float4& posA, const b3Quaternion& ornA, float4* worldVertsB1, int numWorldVertsB1,
+	float4* worldVertsB2, int capacityWorldVertsB2,
+	const float minDist, float maxDist,
+	const float4* verticesA,	const b3GpuFace* facesA,	const int* indicesA,
+	//const float4* verticesB,	const b3GpuFace* facesB,	const int* indicesB,
+	float4* contactsOut,
+	int contactCapacity)
+{
+	int numContactsOut = 0;
+
+	float4* pVtxIn = worldVertsB1;
+	float4* pVtxOut = worldVertsB2;
+	
+	int numVertsIn = numWorldVertsB1;
+	int numVertsOut = 0;
+
+	int closestFaceA=-1;
+	{
+		float dmin = FLT_MAX;
+		for(int face=0;face<hullA->m_numFaces;face++)
+		{
+			const float4 Normal = make_float4(
+				facesA[hullA->m_faceOffset+face].m_plane.x, 
+				facesA[hullA->m_faceOffset+face].m_plane.y, 
+				facesA[hullA->m_faceOffset+face].m_plane.z,0.f);
+			const float4 faceANormalWS = b3QuatRotate(ornA,Normal);
+		
+			float d = dot3F4(faceANormalWS,separatingNormal);
+			if (d < dmin)
+			{
+				dmin = d;
+				closestFaceA = face;
+			}
+		}
+	}
+	if (closestFaceA<0)
+		return numContactsOut;
+
+	b3GpuFace polyA = facesA[hullA->m_faceOffset+closestFaceA];
+
+	// clip polygon to back of planes of all faces of hull A that are adjacent to witness face
+	int numContacts = numWorldVertsB1;
+	int numVerticesA = polyA.m_numIndices;
+	for(int e0=0;e0<numVerticesA;e0++)
+	{
+		const float4 a = verticesA[hullA->m_vertexOffset+indicesA[polyA.m_indexOffset+e0]];
+		const float4 b = verticesA[hullA->m_vertexOffset+indicesA[polyA.m_indexOffset+((e0+1)%numVerticesA)]];
+		const float4 edge0 = a - b;
+		const float4 WorldEdge0 = b3QuatRotate(ornA,edge0);
+		float4 planeNormalA = make_float4(polyA.m_plane.x,polyA.m_plane.y,polyA.m_plane.z,0.f);
+		float4 worldPlaneAnormal1 = b3QuatRotate(ornA,planeNormalA);
+
+		float4 planeNormalWS1 = -cross3(WorldEdge0,worldPlaneAnormal1);
+		float4 worldA1 = transform(&a,&posA,&ornA);
+		float planeEqWS1 = -dot3F4(worldA1,planeNormalWS1);
+		
+		float4 planeNormalWS = planeNormalWS1;
+		float planeEqWS=planeEqWS1;
+		
+		//clip face
+		//clipFace(*pVtxIn, *pVtxOut,planeNormalWS,planeEqWS);
+		numVertsOut = clipFace(pVtxIn, numVertsIn, planeNormalWS,planeEqWS, pVtxOut);
+
+		//btSwap(pVtxIn,pVtxOut);
+		float4* tmp = pVtxOut;
+		pVtxOut = pVtxIn;
+		pVtxIn = tmp;
+		numVertsIn = numVertsOut;
+		numVertsOut = 0;
+	}
+
+	
+	// only keep points that are behind the witness face
+	{
+		float4 localPlaneNormal  = make_float4(polyA.m_plane.x,polyA.m_plane.y,polyA.m_plane.z,0.f);
+		float localPlaneEq = polyA.m_plane.w;
+		float4 planeNormalWS = b3QuatRotate(ornA,localPlaneNormal);
+		float planeEqWS=localPlaneEq-dot3F4(planeNormalWS,posA);
+		for (int i=0;i<numVertsIn;i++)
+		{
+			float depth = dot3F4(planeNormalWS,pVtxIn[i])+planeEqWS;
+			if (depth <=minDist)
+			{
+				depth = minDist;
+			}
+
+			if (depth <=maxDist)
+			{
+				float4 pointInWorld = pVtxIn[i];
+				//resultOut.addContactPoint(separatingNormal,point,depth);
+				contactsOut[numContactsOut++] = make_float4(pointInWorld.x,pointInWorld.y,pointInWorld.z,depth);
+				//printf("depth=%f\n",depth);
+			}
+		}
+	}
+
+	return numContactsOut;
+}
+
+
+
+static int	clipHullAgainstHull(const float4& separatingNormal, 
+	const b3ConvexPolyhedronCL& hullA, const b3ConvexPolyhedronCL& hullB, 
+	const float4& posA, const b3Quaternion& ornA,const float4& posB, const b3Quaternion& ornB, 
+	float4* worldVertsB1, float4* worldVertsB2, int capacityWorldVerts,
+	const float minDist, float maxDist,
+	const float4* verticesA,	const b3GpuFace* facesA,	const int* indicesA,
+	const float4* verticesB,	const b3GpuFace* facesB,	const int* indicesB,
+
+	float4*	contactsOut,
+	int contactCapacity)
+{
+	int numContactsOut = 0;
+	int numWorldVertsB1= 0;
+	
+	B3_PROFILE("clipHullAgainstHull");
+
+	float curMaxDist=maxDist;
+	int closestFaceB=-1;
+	float dmax = -FLT_MAX;
+
+	{
+		//B3_PROFILE("closestFaceB");
+		if (hullB.m_numFaces!=1)
+		{
+			//printf("wtf\n");
+		}
+		static bool once = true;
+		//printf("separatingNormal=%f,%f,%f\n",separatingNormal.x,separatingNormal.y,separatingNormal.z);
+		
+		for(int face=0;face<hullB.m_numFaces;face++)
+		{
+#ifdef BT_DEBUG_SAT_FACE
+			if (once)
+				printf("face %d\n",face);
+			const b3GpuFace* faceB = &facesB[hullB.m_faceOffset+face];
+			if (once)
+			{
+				for (int i=0;i<faceB->m_numIndices;i++)
+				{
+					float4 vert = verticesB[hullB.m_vertexOffset+indicesB[faceB->m_indexOffset+i]];
+					printf("vert[%d] = %f,%f,%f\n",i,vert.x,vert.y,vert.z);
+				}
+			}
+#endif //BT_DEBUG_SAT_FACE
+			//if (facesB[hullB.m_faceOffset+face].m_numIndices>2)
+			{
+				const float4 Normal = make_float4(facesB[hullB.m_faceOffset+face].m_plane.x, 
+					facesB[hullB.m_faceOffset+face].m_plane.y, facesB[hullB.m_faceOffset+face].m_plane.z,0.f);
+				const float4 WorldNormal = b3QuatRotate(ornB, Normal);
+#ifdef BT_DEBUG_SAT_FACE
+				if (once)
+					printf("faceNormal = %f,%f,%f\n",Normal.x,Normal.y,Normal.z);
+#endif
+				float d = dot3F4(WorldNormal,separatingNormal);
+				if (d > dmax)
+				{
+					dmax = d;
+					closestFaceB = face;
+				}
+			}
+		}
+		once = false;
+	}
+
+	
+	b3Assert(closestFaceB>=0);
+	{
+		//B3_PROFILE("worldVertsB1");
+		const b3GpuFace& polyB = facesB[hullB.m_faceOffset+closestFaceB];
+		const int numVertices = polyB.m_numIndices;
+		for(int e0=0;e0<numVertices;e0++)
+		{
+			const float4& b = verticesB[hullB.m_vertexOffset+indicesB[polyB.m_indexOffset+e0]];
+			worldVertsB1[numWorldVertsB1++] = transform(&b,&posB,&ornB);
+		}
+	}
+
+	if (closestFaceB>=0)
+	{
+		//B3_PROFILE("clipFaceAgainstHull");
+		numContactsOut = clipFaceAgainstHull((float4&)separatingNormal, &hullA, 
+				posA,ornA,
+				worldVertsB1,numWorldVertsB1,worldVertsB2,capacityWorldVerts, minDist, maxDist,
+				verticesA,				facesA,				indicesA,
+				contactsOut,contactCapacity);
+	}
+
+	return numContactsOut;
+}
+
+
+
+
+
+
+#define PARALLEL_SUM(v, n) for(int j=1; j<n; j++) v[0] += v[j];
+#define PARALLEL_DO(execution, n) for(int ie=0; ie<n; ie++){execution;}
+#define REDUCE_MAX(v, n) {int i=0;\
+for(int offset=0; offset<n; offset++) v[i] = (v[i].y > v[i+offset].y)? v[i]: v[i+offset]; }
+#define REDUCE_MIN(v, n) {int i=0;\
+for(int offset=0; offset<n; offset++) v[i] = (v[i].y < v[i+offset].y)? v[i]: v[i+offset]; }
+
+int extractManifold(const float4* p, int nPoints, const float4& nearNormal, b3Int4* contactIdx)
+{
+	if( nPoints == 0 )
+        return 0;
+    
+    if (nPoints <=4)
+        return nPoints;
+    
+    
+    if (nPoints >64)
+        nPoints = 64;
+    
+	float4 center = make_float4(0,0,0,0);
+	{
+		
+		for (int i=0;i<nPoints;i++)
+			center += p[i];
+		center /= (float)nPoints;
+	}
+    
+	
+    
+	//	sample 4 directions
+    
+    float4 aVector = p[0] - center;
+    float4 u = cross3( nearNormal, aVector );
+    float4 v = cross3( nearNormal, u );
+    u = normalize3( u );
+    v = normalize3( v );
+    
+    
+    //keep point with deepest penetration
+    float minW= FLT_MAX;
+    
+    int minIndex=-1;
+    
+    float4 maxDots;
+    maxDots.x = FLT_MIN;
+    maxDots.y = FLT_MIN;
+    maxDots.z = FLT_MIN;
+    maxDots.w = FLT_MIN;
+    
+    //	idx, distance
+    for(int ie = 0; ie<nPoints; ie++ )
+    {
+        if (p[ie].w<minW)
+        {
+            minW = p[ie].w;
+            minIndex=ie;
+        }
+        float f;
+        float4 r = p[ie]-center;
+        f = dot3F4( u, r );
+        if (f<maxDots.x)
+        {
+            maxDots.x = f;
+            contactIdx[0].x = ie;
+        }
+        
+        f = dot3F4( -u, r );
+        if (f<maxDots.y)
+        {
+            maxDots.y = f;
+            contactIdx[0].y = ie;
+        }
+        
+        
+        f = dot3F4( v, r );
+        if (f<maxDots.z)
+        {
+            maxDots.z = f;
+            contactIdx[0].z = ie;
+        }
+        
+        f = dot3F4( -v, r );
+        if (f<maxDots.w)
+        {
+            maxDots.w = f;
+            contactIdx[0].w = ie;
+        }
+        
+    }
+    
+    if (contactIdx[0].x != minIndex && contactIdx[0].y != minIndex && contactIdx[0].z != minIndex && contactIdx[0].w != minIndex)
+    {
+        //replace the first contact with minimum (todo: replace contact with least penetration)
+        contactIdx[0].x = minIndex;
+    }
+    
+    return 4;
+    
+}
+
+
+
+
+void clipHullHullSingle(
+			int bodyIndexA, int bodyIndexB,
+										 const float4& posA,
+										 const b3Quaternion& ornA,
+										 const float4& posB,
+										 const b3Quaternion& ornB,
+
+			int collidableIndexA, int collidableIndexB,
+
+			const b3AlignedObjectArray<b3RigidBodyCL>* bodyBuf, 
+			b3AlignedObjectArray<b3Contact4>* contactOut, 
+			int& nContacts,
+			
+			const b3AlignedObjectArray<b3ConvexPolyhedronCL>& hostConvexDataA,
+			const b3AlignedObjectArray<b3ConvexPolyhedronCL>& hostConvexDataB,
+	
+			const b3AlignedObjectArray<b3Vector3>& verticesA, 
+			const b3AlignedObjectArray<b3Vector3>& uniqueEdgesA, 
+			const b3AlignedObjectArray<b3GpuFace>& facesA,
+			const b3AlignedObjectArray<int>& indicesA,
+	
+			const b3AlignedObjectArray<b3Vector3>& verticesB,
+			const b3AlignedObjectArray<b3Vector3>& uniqueEdgesB,
+			const b3AlignedObjectArray<b3GpuFace>& facesB,
+			const b3AlignedObjectArray<int>& indicesB,
+
+			const b3AlignedObjectArray<b3Collidable>& hostCollidablesA,
+			const b3AlignedObjectArray<b3Collidable>& hostCollidablesB,
+			const b3Vector3& sepNormalWorldSpace			)
+{
+
+	b3ConvexPolyhedronCL hullA, hullB;
+    
+    b3Collidable colA = hostCollidablesA[collidableIndexA];
+    hullA = hostConvexDataA[colA.m_shapeIndex];
+    //printf("numvertsA = %d\n",hullA.m_numVertices);
+    
+    
+    b3Collidable colB = hostCollidablesB[collidableIndexB];
+    hullB = hostConvexDataB[colB.m_shapeIndex];
+    //printf("numvertsB = %d\n",hullB.m_numVertices);
+    
+	
+	float4 contactsOut[MAX_VERTS];
+	int contactCapacity = MAX_VERTS;
+
+#ifdef _WIN32
+	b3Assert(_finite(bodyBuf->at(bodyIndexA).m_pos.x));
+	b3Assert(_finite(bodyBuf->at(bodyIndexB).m_pos.x));
+#endif
+	
+	
+	{
+		
+		float4 worldVertsB1[MAX_VERTS];
+		float4 worldVertsB2[MAX_VERTS];
+		int capacityWorldVerts = MAX_VERTS;
+
+		float4 hostNormal = make_float4(sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ(),0.f);
+		int shapeA = hostCollidablesA[collidableIndexA].m_shapeIndex;
+		int shapeB = hostCollidablesB[collidableIndexB].m_shapeIndex;
+
+		b3Scalar minDist = -1;
+		b3Scalar maxDist = 0.;
+
+		        
+
+		b3Transform trA,trB;
+		{
+		//B3_PROFILE("transform computation");
+		//trA.setIdentity();
+		trA.setOrigin(b3Vector3(posA.x,posA.y,posA.z));
+		trA.setRotation(b3Quaternion(ornA.x,ornA.y,ornA.z,ornA.w));
+				
+		//trB.setIdentity();
+		trB.setOrigin(b3Vector3(posB.x,posB.y,posB.z));
+		trB.setRotation(b3Quaternion(ornB.x,ornB.y,ornB.z,ornB.w));
+		}
+
+		b3Quaternion trAorn = trA.getRotation();
+        b3Quaternion trBorn = trB.getRotation();
+        
+		int numContactsOut = clipHullAgainstHull(hostNormal, 
+						hostConvexDataA.at(shapeA), 
+						hostConvexDataB.at(shapeB),
+								(float4&)trA.getOrigin(), (b3Quaternion&)trAorn,
+								(float4&)trB.getOrigin(), (b3Quaternion&)trBorn,
+								worldVertsB1,worldVertsB2,capacityWorldVerts,
+								minDist, maxDist,
+								(float4*)&verticesA[0],	&facesA[0],&indicesA[0],
+								(float4*)&verticesB[0],	&facesB[0],&indicesB[0],
+								
+								contactsOut,contactCapacity);
+
+		if (numContactsOut>0)
+		{
+			B3_PROFILE("overlap");
+
+			float4 normalOnSurfaceB = -(float4&)hostNormal;
+			float4 centerOut;
+			
+			b3Int4 contactIdx;
+			contactIdx.x = 0;
+			contactIdx.y = 1;
+			contactIdx.z = 2;
+			contactIdx.w = 3;
+			
+			int numPoints = 0;
+					
+			{
+				B3_PROFILE("extractManifold");
+				numPoints = extractManifold(contactsOut, numContactsOut, normalOnSurfaceB,  &contactIdx);
+			}
+					
+			b3Assert(numPoints);
+					
+			
+			contactOut->expand();
+			b3Contact4& contact = contactOut->at(nContacts);
+			contact.m_batchIdx = 0;//i;
+			contact.m_bodyAPtrAndSignBit = (bodyBuf->at(bodyIndexA).m_invMass==0)? -bodyIndexA:bodyIndexA;
+			contact.m_bodyBPtrAndSignBit = (bodyBuf->at(bodyIndexB).m_invMass==0)? -bodyIndexB:bodyIndexB;
+
+			contact.m_frictionCoeffCmp = 45874;
+			contact.m_restituitionCoeffCmp = 0;
+					
+			float distance = 0.f;
+			for (int p=0;p<numPoints;p++)
+			{
+				contact.m_worldPos[p] = contactsOut[contactIdx.s[p]];
+				contact.m_worldNormal = normalOnSurfaceB; 
+			}
+			//printf("bodyIndexA %d,bodyIndexB %d,normal=%f,%f,%f numPoints %d\n",bodyIndexA,bodyIndexB,normalOnSurfaceB.x,normalOnSurfaceB.y,normalOnSurfaceB.z,numPoints);
+			contact.m_worldNormal.w = numPoints;
+			nContacts++;
+		}
+	}
+}
+
+
+void computeContactConvexConvex(
+					int pairIndex,
+																int bodyIndexA, int bodyIndexB, 
+																int collidableIndexA, int collidableIndexB, 
+																const b3AlignedObjectArray<b3RigidBodyCL>& rigidBodies, 
+																const b3AlignedObjectArray<b3Collidable>& collidables,
+																const b3AlignedObjectArray<b3ConvexPolyhedronCL>& convexShapes,
+																const b3AlignedObjectArray<b3Vector3>& convexVertices,
+																const b3AlignedObjectArray<b3Vector3>& uniqueEdges,
+																const b3AlignedObjectArray<int>& convexIndices,
+																const b3AlignedObjectArray<b3GpuFace>& faces,
+																b3AlignedObjectArray<b3Contact4>& globalContactsOut,
+																int& nGlobalContactsOut,
+																int maxContactCapacity)
+{
+
+	b3Vector3 posA = rigidBodies[bodyIndexA].m_pos;
+	b3Quaternion ornA = rigidBodies[bodyIndexA].m_quat;
+	b3Vector3 posB = rigidBodies[bodyIndexB].m_pos;
+	b3Quaternion ornB = rigidBodies[bodyIndexB].m_quat;
+	
+			/*int bodyIndexA, int bodyIndexB,
+		  const float4& posA,
+		  const float4& ornA,
+		  const float4& posB,
+		  const float4& ornB,
+			int collidableIndexA, int collidableIndexB,
+
+			const b3AlignedObjectArray<b3RigidBodyCL>* bodyBuf, 
+			b3AlignedObjectArray<b3Contact4>* contactOut,
+															  int& nContacts,
+
+			const b3AlignedObjectArray<b3ConvexPolyhedronCL>& hostConvexDataA,
+			const b3AlignedObjectArray<b3ConvexPolyhedronCL>& hostConvexDataB,
+	
+			const b3AlignedObjectArray<b3Vector3>& verticesA, 
+			const b3AlignedObjectArray<b3Vector3>& uniqueEdgesA, 
+			const b3AlignedObjectArray<b3GpuFace>& facesA,
+			const b3AlignedObjectArray<int>& indicesA,
+	
+			const b3AlignedObjectArray<b3Vector3>& verticesB,
+			const b3AlignedObjectArray<b3Vector3>& uniqueEdgesB,
+			const b3AlignedObjectArray<b3GpuFace>& facesB,
+			const b3AlignedObjectArray<int>& indicesB,
+
+			const b3AlignedObjectArray<b3Collidable>& hostCollidablesA,
+			const b3AlignedObjectArray<b3Collidable>& hostCollidablesB
+			)
+			*/
+
+
+	b3ConvexPolyhedronCL hullA, hullB;
+    
+	b3Vector3 sepNormalWorldSpace;
+
+	
+
+    b3Collidable colA = collidables[collidableIndexA];
+    hullA = convexShapes[colA.m_shapeIndex];
+    //printf("numvertsA = %d\n",hullA.m_numVertices);
+    
+    
+    b3Collidable colB = collidables[collidableIndexB];
+    hullB = convexShapes[colB.m_shapeIndex];
+    //printf("numvertsB = %d\n",hullB.m_numVertices);
+    
+	
+	float4 contactsOut[MAX_VERTS];
+	int contactCapacity = MAX_VERTS;
+	int numContactsOut=0;
+
+
+#ifdef _WIN32
+	b3Assert(_finite(rigidBodies[bodyIndexA].m_pos.x));
+	b3Assert(_finite(rigidBodies[bodyIndexB].m_pos.x));
+#endif
+	
+		bool foundSepAxis = findSeparatingAxis(hullA,hullB,
+							posA,
+							ornA,
+							posB,
+							ornB,
+
+							convexVertices,uniqueEdges,faces,convexIndices,
+							convexVertices,uniqueEdges,faces,convexIndices,
+							
+							sepNormalWorldSpace
+							);
+
+	
+	if (foundSepAxis)
+	{
+		
+		
+		clipHullHullSingle(
+			bodyIndexA, bodyIndexB,
+						   posA,ornA,
+						   posB,ornB,
+			collidableIndexA, collidableIndexB,
+			&rigidBodies, 
+			&globalContactsOut,
+			nGlobalContactsOut,
+			
+			convexShapes,
+			convexShapes,
+	
+			convexVertices, 
+			uniqueEdges, 
+			faces,
+			convexIndices,
+	
+			convexVertices,
+			uniqueEdges,
+			faces,
+			convexIndices,
+
+			collidables,
+			collidables,
+			sepNormalWorldSpace);
+			
+	}
+
+
+}
+
 
 void GpuSatCollision::computeConvexConvexContactsGPUSAT( const b3OpenCLArray<b3Int2>* pairs, int nPairs,
 			const b3OpenCLArray<b3RigidBodyCL>* bodyBuf,
@@ -972,6 +1807,15 @@ void GpuSatCollision::computeConvexConvexContactsGPUSAT( const b3OpenCLArray<b3I
 			
 		}
 
+		if (hostCollidables[collidableIndexA].m_shapeType == SHAPE_CONVEX_HULL &&
+			hostCollidables[collidableIndexB].m_shapeType == SHAPE_CONVEX_HULL)
+		{
+			computeContactConvexConvex(i,bodyIndexA,bodyIndexB,collidableIndexA,collidableIndexB,hostBodyBuf,
+			hostCollidables,hostConvexData,hostVertices,hostUniqueEdges,hostIndices,hostFaces,hostContacts,nContacts,maxContactCapacity);
+//			printf("plane-convex\n");
+			
+		}
+
 
 	}
 
@@ -981,7 +1825,7 @@ void GpuSatCollision::computeConvexConvexContactsGPUSAT( const b3OpenCLArray<b3I
 			contactOut->copyFromHost(hostContacts);
 		}
 
-	
+	return;
 #else
 
 	{
@@ -1016,6 +1860,7 @@ void GpuSatCollision::computeConvexConvexContactsGPUSAT( const b3OpenCLArray<b3I
 		}
 	}
 
+	
 #endif//CHECK_ON_HOST
 	
 	B3_PROFILE("computeConvexConvexContactsGPUSAT");
@@ -1508,7 +2353,7 @@ void GpuSatCollision::computeConvexConvexContactsGPUSAT( const b3OpenCLArray<b3I
                     nContacts = m_totalContactsOut.at(0);
                     contactOut->resize(nContacts);
                     
-//                    Contact4 pt = contactOut->at(0);
+//                    b3Contact4 pt = contactOut->at(0);
                     
   //                  printf("nContacts = %d\n",nContacts);
                 }
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.cpp b/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.cpp
index e54e455ff..dbffe25b9 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.cpp
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.cpp
@@ -1,4 +1,7 @@
 
+bool b3GpuBatchContacts = true;
+bool b3GpuSolveConstraint = true;
+
 
 #include "b3GpuBatchingPgsSolver.h"
 #include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h"
@@ -37,8 +40,6 @@ enum
 };
 
 
-bool b3GpuBatchContacts = true;//true;
-bool b3GpuSolveConstraint = true;//true;
 
 
 struct	b3GpuBatchingPgsSolverInternalData
@@ -401,10 +402,14 @@ void b3GpuBatchingPgsSolver::solveContactConstraint(  const b3OpenCLArray<b3Rigi
 
 
 
+static bool sortfnc(const b3SortData& a,const b3SortData& b)
+{
+	return (a.m_key<b.m_key);
+}
 
 
 
-void b3GpuBatchingPgsSolver::solveContacts(int numBodies, cl_mem bodyBuf, cl_mem inertiaBuf, int numContacts, cl_mem contactBuf, const b3Config& config)
+void b3GpuBatchingPgsSolver::solveContacts(int numBodies, cl_mem bodyBuf, cl_mem inertiaBuf, int numContacts, cl_mem contactBuf, const b3Config& config, int static0Index)
 {
 	m_data->m_bodyBufferGPU->setFromOpenCLBuffer(bodyBuf,numBodies);
 	m_data->m_inertiaBufferGPU->setFromOpenCLBuffer(inertiaBuf,numBodies);
@@ -420,7 +425,7 @@ void b3GpuBatchingPgsSolver::solveContacts(int numBodies, cl_mem bodyBuf, cl_mem
         b3ConstraintCfg csCfg( dt );
         csCfg.m_enableParallelSolve = true;
         csCfg.m_averageExtent = .2f;//@TODO m_averageObjExtent;
-        csCfg.m_staticIdx = 0;//m_static0Index;//m_planeBodyIndex;
+        csCfg.m_staticIdx = static0Index;
         
         
         b3OpenCLArray<b3RigidBodyCL>* bodyBuf = m_data->m_bodyBufferGPU;
@@ -500,6 +505,7 @@ void b3GpuBatchingPgsSolver::solveContacts(int numBodies, cl_mem bodyBuf, cl_mem
                             launcher.setConst( cdata.m_nContacts );
                             launcher.setConst( cdata.m_scale );
                             launcher.setConst(cdata.m_nSplit);
+							launcher.setConst(cdata.m_staticIdx);
                             
                             
                             launcher.launch1D( sortSize, 64 );
@@ -519,12 +525,16 @@ void b3GpuBatchingPgsSolver::solveContacts(int numBodies, cl_mem bodyBuf, cl_mem
                             b3OpenCLArray<b3SortData>& keyValuesInOut = *(m_data->m_solverGPU->m_sortDataBuffer);
                             this->m_data->m_solverGPU->m_sort32->execute(keyValuesInOut);
                             
-                            /*b3AlignedObjectArray<b3SortData> hostValues;
-                             keyValuesInOut.copyToHost(hostValues);
-                             printf("hostValues.size=%d\n",hostValues.size());
-                             */
+                           
                             
-                        }
+                        } else
+						{
+							b3OpenCLArray<b3SortData>& keyValuesInOut = *(m_data->m_solverGPU->m_sortDataBuffer);
+							 b3AlignedObjectArray<b3SortData> hostValues;
+                             keyValuesInOut.copyToHost(hostValues);
+                             hostValues.quickSort(sortfnc);
+							 keyValuesInOut.copyFromHost(hostValues);
+						}
                         
                         {
                             //	4. find entries
@@ -630,7 +640,9 @@ void b3GpuBatchingPgsSolver::solveContacts(int numBodies, cl_mem bodyBuf, cl_mem
 									
 									int simdWidth =64;//-1;//32;
 									//int numBatches = sortConstraintByBatch( &cpuContacts[0]+offset, n, simdWidth,csCfg.m_staticIdx ,numBodies);	//	on GPU
-									int numBatches = sortConstraintByBatch3( &cpuContacts[0]+offset, n, simdWidth,csCfg.m_staticIdx ,numBodies);	//	on GPU
+									int numBatches = sortConstraintByBatch2( &cpuContacts[0]+offset, n, simdWidth,csCfg.m_staticIdx ,numBodies);	//	on GPU
+									//int numBatches = sortConstraintByBatch3( &cpuContacts[0]+offset, n, simdWidth,csCfg.m_staticIdx ,numBodies);	//	on GPU
+									
 									
 
 									maxNumBatches = b3Max(numBatches,maxNumBatches);
@@ -724,10 +736,6 @@ void b3GpuBatchingPgsSolver::batchContacts( b3OpenCLArray<b3Contact4>* contacts,
 
 
 
-static bool sortfnc(const b3SortData& a,const b3SortData& b)
-{
-	return (a.m_key<b.m_key);
-}
 
 
 
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.h b/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.h
index 4c93d0964..95a9b0e89 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.h
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuBatchingPgsSolver.h
@@ -32,7 +32,7 @@ public:
 	b3GpuBatchingPgsSolver(cl_context ctx,cl_device_id device, cl_command_queue  q,int pairCapacity);
 	virtual ~b3GpuBatchingPgsSolver();
 
-	void solveContacts(int numBodies, cl_mem bodyBuf, cl_mem inertiaBuf, int numContacts, cl_mem contactBuf, const struct b3Config& config);
+	void solveContacts(int numBodies, cl_mem bodyBuf, cl_mem inertiaBuf, int numContacts, cl_mem contactBuf, const struct b3Config& config, int static0Index);
 
 };
 
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp b/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp
index 563c4dae5..044beac58 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp
@@ -156,7 +156,9 @@ m_queue(queue)
 
 	//m_data->m_contactCGPU = new b3OpenCLArray<Constraint4>(ctx,queue,config.m_maxBroadphasePairs,false);
 	//m_data->m_frictionCGPU = new b3OpenCLArray<adl::Solver<adl::TYPE_CL>::allocateFrictionConstraint( m_data->m_deviceCL, config.m_maxBroadphasePairs);
-    
+ 
+	
+
 }
 
 
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h b/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h
index 5453f490d..6cf280b39 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h
@@ -76,6 +76,10 @@ public:
 
 	int allocateCollidable();
 
+	int getStatic0Index() const
+	{
+		return m_static0Index;
+	}
 	b3Collidable& getCollidableCpu(int collidableIndex);
 	const b3Collidable& getCollidableCpu(int collidableIndex) const;
 
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp
index 843849211..4f5f98812 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp
@@ -276,7 +276,9 @@ void	b3GpuRigidBodyPipeline::stepSimulation(float deltaTime)
 #endif //TEST_OTHER_GPU_SOLVER
 		{
 			b3Config config;
-			m_data->m_solver2->solveContacts(numBodies, gpuBodies.getBufferCL(),gpuInertias.getBufferCL(),numContacts, gpuContacts.getBufferCL(),config);
+			
+			int static0Index = m_data->m_narrowphase->getStatic0Index();
+			m_data->m_solver2->solveContacts(numBodies, gpuBodies.getBufferCL(),gpuInertias.getBufferCL(),numContacts, gpuContacts.getBufferCL(),config, static0Index);
 			
 			//m_data->m_solver4->solveContacts(m_data->m_narrowphase->getNumBodiesGpu(), gpuBodies.getBufferCL(), gpuInertias.getBufferCL(), numContacts, gpuContacts.getBufferCL());
 			
@@ -366,10 +368,11 @@ void 		b3GpuRigidBodyPipeline::writeAllInstancesToGpu()
 
 int		b3GpuRigidBodyPipeline::registerPhysicsInstance(float mass, const float* position, const float* orientation, int collidableIndex, int userIndex, bool writeInstanceToGpu)
 {
+	
 	b3Vector3 aabbMin(0,0,0),aabbMax(0,0,0);
 
 	int bodyIndex = m_data->m_narrowphase->getNumRigidBodies();
-
+	
 	
 	if (collidableIndex>=0)
 	{
diff --git a/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.cl b/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.cl
index 0ab67919d..940216144 100644
--- a/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.cl
+++ b/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.cl
@@ -452,20 +452,21 @@ typedef struct
 __kernel
 __attribute__((reqd_work_group_size(WG_SIZE,1,1)))
 void SetSortDataKernel(__global Contact4* gContact, __global Body* gBodies, __global int2* gSortDataOut, 
-int nContacts,
-float scale,
-int N_SPLIT
-)
+int nContacts,float scale,int N_SPLIT, int staticIdx)
 
 {
 	int gIdx = GET_GLOBAL_IDX;
 	
 	if( gIdx < nContacts )
 	{
-		int aIdx = abs(gContact[gIdx].m_bodyAPtrAndSignBit);
+		int aPtrAndSignBit  = gContact[gIdx].m_bodyAPtrAndSignBit;
+
+		int aIdx = abs(aPtrAndSignBit );
 		int bIdx = abs(gContact[gIdx].m_bodyBPtrAndSignBit);
 
-		int idx = (gContact[gIdx].m_bodyAPtrAndSignBit<0)? bIdx: aIdx;
+		bool aStatic = (aPtrAndSignBit<0) ||(aPtrAndSignBit==staticIdx);
+		
+		int idx = (aStatic)? bIdx: aIdx;
 		float4 p = gBodies[idx].m_pos;
 		int xIdx = (int)((p.x-((p.x<0.f)?1.f:0.f))*scale) & (N_SPLIT-1);
 		int zIdx = (int)((p.z-((p.z<0.f)?1.f:0.f))*scale) & (N_SPLIT-1);
diff --git a/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h b/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h
index 1796a6c5b..9ecc33cc6 100644
--- a/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h
+++ b/src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h
@@ -454,20 +454,21 @@ static const char* solverSetup2CL= \
 "__kernel\n"
 "__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
 "void SetSortDataKernel(__global Contact4* gContact, __global Body* gBodies, __global int2* gSortDataOut, \n"
-"int nContacts,\n"
-"float scale,\n"
-"int N_SPLIT\n"
-")\n"
+"int nContacts,float scale,int N_SPLIT, int staticIdx)\n"
 "\n"
 "{\n"
 "	int gIdx = GET_GLOBAL_IDX;\n"
 "	\n"
 "	if( gIdx < nContacts )\n"
 "	{\n"
-"		int aIdx = abs(gContact[gIdx].m_bodyAPtrAndSignBit);\n"
+"		int aPtrAndSignBit  = gContact[gIdx].m_bodyAPtrAndSignBit;\n"
+"\n"
+"		int aIdx = abs(aPtrAndSignBit );\n"
 "		int bIdx = abs(gContact[gIdx].m_bodyBPtrAndSignBit);\n"
 "\n"
-"		int idx = (gContact[gIdx].m_bodyAPtrAndSignBit<0)? bIdx: aIdx;\n"
+"		bool aStatic = (aPtrAndSignBit<0) ||(aPtrAndSignBit==staticIdx);\n"
+"		\n"
+"		int idx = (aStatic)? bIdx: aIdx;\n"
 "		float4 p = gBodies[idx].m_pos;\n"
 "		int xIdx = (int)((p.x-((p.x<0.f)?1.f:0.f))*scale) & (N_SPLIT-1);\n"
 "		int zIdx = (int)((p.z-((p.z<0.f)?1.f:0.f))*scale) & (N_SPLIT-1);\n"