added (and stripped) a simple C/C++ preprocessor (written in Lua), so the stringifier can handle the #include directive,

and embed the included files directly in the stringified files.
We need this, because we start sharing struct definitions and code between C/C++ and OpenCL (and potentially other languages)
preprocessor is from http://github.com/willsteel/lcpp

src/Bullet3OpenCL/BroadphaseCollision/kernels/sapKernels.h

@@ -355,5 +355,4 @@ static const char* sapCL= \
 "	sum[i]=s;\n"
 "	sum2[i]=s*s;	\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.cpp

@@ -0,0 +1,305 @@
+#if 0
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "b3ContactCache.h"
+#include "Bullet3Common/b3Transform.h"
+
+
+b3Scalar					gContactBreakingThreshold = b3Scalar(0.02);
+b3Scalar					m_contactBreakingThreshold;
+b3Scalar					m_contactProcessingThreshold;
+
+///gContactCalcArea3Points will approximate the convex hull area using 3 points
+///when setting it to false, it will use 4 points to compute the area: it is more accurate but slower
+bool						gContactCalcArea3Points = true;
+
+
+b3ContactCache::b3ContactCache()
+:m_index1a(0)
+{
+}
+
+
+
+
+#ifdef DEBUG_PERSISTENCY
+#include <stdio.h>
+void	b3ContactCache::DebugPersistency()
+{
+	int i;
+	printf("DebugPersistency : numPoints %d\n",m_cachedPoints);
+	for (i=0;i<m_cachedPoints;i++)
+	{
+		printf("m_pointCache[%d].m_userPersistentData = %x\n",i,m_pointCache[i].m_userPersistentData);
+	}
+}
+#endif //DEBUG_PERSISTENCY
+
+void b3ContactCache::clearUserCache(btManifoldPoint& pt)
+{
+
+	void* oldPtr = pt.m_userPersistentData;
+	if (oldPtr)
+	{
+#ifdef DEBUG_PERSISTENCY
+		int i;
+		int occurance = 0;
+		for (i=0;i<m_cachedPoints;i++)
+		{
+			if (m_pointCache[i].m_userPersistentData == oldPtr)
+			{
+				occurance++;
+				if (occurance>1)
+					printf("error in clearUserCache\n");
+			}
+		}
+		btAssert(occurance<=0);
+#endif //DEBUG_PERSISTENCY
+
+		if (pt.m_userPersistentData && gContactDestroyedCallback)
+		{
+			(*gContactDestroyedCallback)(pt.m_userPersistentData);
+			pt.m_userPersistentData = 0;
+		}
+		
+#ifdef DEBUG_PERSISTENCY
+		DebugPersistency();
+#endif
+	}
+
+	
+}
+
+static inline b3Scalar calcArea4Points(const btVector3 &p0,const btVector3 &p1,const btVector3 &p2,const btVector3 &p3)
+{
+	// It calculates possible 3 area constructed from random 4 points and returns the biggest one.
+
+	btVector3 a[3],b[3];
+	a[0] = p0 - p1;
+	a[1] = p0 - p2;
+	a[2] = p0 - p3;
+	b[0] = p2 - p3;
+	b[1] = p1 - p3;
+	b[2] = p1 - p2;
+
+	//todo: Following 3 cross production can be easily optimized by SIMD.
+	btVector3 tmp0 = a[0].cross(b[0]);
+	btVector3 tmp1 = a[1].cross(b[1]);
+	btVector3 tmp2 = a[2].cross(b[2]);
+
+	return btMax(btMax(tmp0.length2(),tmp1.length2()),tmp2.length2());
+}
+
+int b3ContactCache::sortCachedPoints(const btManifoldPoint& pt) 
+{
+		//calculate 4 possible cases areas, and take biggest area
+		//also need to keep 'deepest'
+		
+		int maxPenetrationIndex = -1;
+#define KEEP_DEEPEST_POINT 1
+#ifdef KEEP_DEEPEST_POINT
+		b3Scalar maxPenetration = pt.getDistance();
+		for (int i=0;i<4;i++)
+		{
+			if (m_pointCache[i].getDistance() < maxPenetration)
+			{
+				maxPenetrationIndex = i;
+				maxPenetration = m_pointCache[i].getDistance();
+			}
+		}
+#endif //KEEP_DEEPEST_POINT
+		
+		b3Scalar res0(b3Scalar(0.)),res1(b3Scalar(0.)),res2(b3Scalar(0.)),res3(b3Scalar(0.));
+
+	if (gContactCalcArea3Points)
+	{
+		if (maxPenetrationIndex != 0)
+		{
+			btVector3 a0 = pt.m_localPointA-m_pointCache[1].m_localPointA;
+			btVector3 b0 = m_pointCache[3].m_localPointA-m_pointCache[2].m_localPointA;
+			btVector3 cross = a0.cross(b0);
+			res0 = cross.length2();
+		}
+		if (maxPenetrationIndex != 1)
+		{
+			btVector3 a1 = pt.m_localPointA-m_pointCache[0].m_localPointA;
+			btVector3 b1 = m_pointCache[3].m_localPointA-m_pointCache[2].m_localPointA;
+			btVector3 cross = a1.cross(b1);
+			res1 = cross.length2();
+		}
+
+		if (maxPenetrationIndex != 2)
+		{
+			btVector3 a2 = pt.m_localPointA-m_pointCache[0].m_localPointA;
+			btVector3 b2 = m_pointCache[3].m_localPointA-m_pointCache[1].m_localPointA;
+			btVector3 cross = a2.cross(b2);
+			res2 = cross.length2();
+		}
+
+		if (maxPenetrationIndex != 3)
+		{
+			btVector3 a3 = pt.m_localPointA-m_pointCache[0].m_localPointA;
+			btVector3 b3 = m_pointCache[2].m_localPointA-m_pointCache[1].m_localPointA;
+			btVector3 cross = a3.cross(b3);
+			res3 = cross.length2();
+		}
+	} 
+	else
+	{
+		if(maxPenetrationIndex != 0) {
+			res0 = calcArea4Points(pt.m_localPointA,m_pointCache[1].m_localPointA,m_pointCache[2].m_localPointA,m_pointCache[3].m_localPointA);
+		}
+
+		if(maxPenetrationIndex != 1) {
+			res1 = calcArea4Points(pt.m_localPointA,m_pointCache[0].m_localPointA,m_pointCache[2].m_localPointA,m_pointCache[3].m_localPointA);
+		}
+
+		if(maxPenetrationIndex != 2) {
+			res2 = calcArea4Points(pt.m_localPointA,m_pointCache[0].m_localPointA,m_pointCache[1].m_localPointA,m_pointCache[3].m_localPointA);
+		}
+
+		if(maxPenetrationIndex != 3) {
+			res3 = calcArea4Points(pt.m_localPointA,m_pointCache[0].m_localPointA,m_pointCache[1].m_localPointA,m_pointCache[2].m_localPointA);
+		}
+	}
+	btVector4 maxvec(res0,res1,res2,res3);
+	int biggestarea = maxvec.closestAxis4();
+	return biggestarea;
+	
+}
+
+
+int b3ContactCache::getCacheEntry(const btManifoldPoint& newPoint) const
+{
+	b3Scalar shortestDist =  getContactBreakingThreshold() * getContactBreakingThreshold();
+	int size = getNumContacts();
+	int nearestPoint = -1;
+	for( int i = 0; i < size; i++ )
+	{
+		const btManifoldPoint &mp = m_pointCache[i];
+
+		btVector3 diffA =  mp.m_localPointA- newPoint.m_localPointA;
+		const b3Scalar distToManiPoint = diffA.dot(diffA);
+		if( distToManiPoint < shortestDist )
+		{
+			shortestDist = distToManiPoint;
+			nearestPoint = i;
+		}
+	}
+	return nearestPoint;
+}
+
+int b3ContactCache::addManifoldPoint(const btManifoldPoint& newPoint, bool isPredictive)
+{
+	if (!isPredictive)
+	{
+		btAssert(validContactDistance(newPoint));
+	}
+	
+	int insertIndex = getNumContacts();
+	if (insertIndex == MANIFOLD_CACHE_SIZE)
+	{
+#if MANIFOLD_CACHE_SIZE >= 4
+		//sort cache so best points come first, based on area
+		insertIndex = sortCachedPoints(newPoint);
+#else
+		insertIndex = 0;
+#endif
+		clearUserCache(m_pointCache[insertIndex]);
+		
+	} else
+	{
+		m_cachedPoints++;
+
+		
+	}
+	if (insertIndex<0)
+		insertIndex=0;
+
+	btAssert(m_pointCache[insertIndex].m_userPersistentData==0);
+	m_pointCache[insertIndex] = newPoint;
+	return insertIndex;
+}
+
+b3Scalar	b3ContactCache::getContactBreakingThreshold() const
+{
+	return m_contactBreakingThreshold;
+}
+
+
+
+void b3ContactCache::refreshContactPoints(const btTransform& trA,const btTransform& trB)
+{
+	int i;
+#ifdef DEBUG_PERSISTENCY
+	printf("refreshContactPoints posA = (%f,%f,%f) posB = (%f,%f,%f)\n",
+		trA.getOrigin().getX(),
+		trA.getOrigin().getY(),
+		trA.getOrigin().getZ(),
+		trB.getOrigin().getX(),
+		trB.getOrigin().getY(),
+		trB.getOrigin().getZ());
+#endif //DEBUG_PERSISTENCY
+	/// first refresh worldspace positions and distance
+	for (i=getNumContacts()-1;i>=0;i--)
+	{
+		btManifoldPoint &manifoldPoint = m_pointCache[i];
+		manifoldPoint.m_positionWorldOnA = trA( manifoldPoint.m_localPointA );
+		manifoldPoint.m_positionWorldOnB = trB( manifoldPoint.m_localPointB );
+		manifoldPoint.m_distance1 = (manifoldPoint.m_positionWorldOnA -  manifoldPoint.m_positionWorldOnB).dot(manifoldPoint.m_normalWorldOnB);
+		manifoldPoint.m_lifeTime++;
+	}
+
+	/// then 
+	b3Scalar distance2d;
+	btVector3 projectedDifference,projectedPoint;
+	for (i=getNumContacts()-1;i>=0;i--)
+	{
+		
+		btManifoldPoint &manifoldPoint = m_pointCache[i];
+		//contact becomes invalid when signed distance exceeds margin (projected on contactnormal direction)
+		if (!validContactDistance(manifoldPoint))
+		{
+			removeContactPoint(i);
+		} else
+		{
+			//contact also becomes invalid when relative movement orthogonal to normal exceeds margin
+			projectedPoint = manifoldPoint.m_positionWorldOnA - manifoldPoint.m_normalWorldOnB * manifoldPoint.m_distance1;
+			projectedDifference = manifoldPoint.m_positionWorldOnB - projectedPoint;
+			distance2d = projectedDifference.dot(projectedDifference);
+			if (distance2d  > getContactBreakingThreshold()*getContactBreakingThreshold() )
+			{
+				removeContactPoint(i);
+			} else
+			{
+				//contact point processed callback
+				if (gContactProcessedCallback)
+					(*gContactProcessedCallback)(manifoldPoint,(void*)m_body0,(void*)m_body1);
+			}
+		}
+	}
+#ifdef DEBUG_PERSISTENCY
+	DebugPersistency();
+#endif //
+}
+
+
+
+
+
+
+#endif

src/Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h

@@ -0,0 +1,216 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_CONTACT_CACHE_H
+#define B3_CONTACT_CACHE_H
+
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "btManifoldPoint.h"
+class btCollisionObject;
+#include "LinearMath/btAlignedAllocator.h"
+
+struct btCollisionResult;
+
+///maximum contact breaking and merging threshold
+extern b3Scalar gContactBreakingThreshold;
+
+//the enum starts at 1024 to avoid type conflicts with btTypedConstraint
+enum btContactManifoldTypes
+{
+	MIN_CONTACT_MANIFOLD_TYPE = 1024,
+	BT_PERSISTENT_MANIFOLD_TYPE
+};
+
+#define MANIFOLD_CACHE_SIZE 4
+
+///b3ContactCache is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase.
+///Those contact points are created by the collision narrow phase.
+///The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time.
+///updates/refreshes old contact points, and throw them away if necessary (distance becomes too large)
+///reduces the cache to 4 points, when more then 4 points are added, using following rules:
+///the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points
+///note that some pairs of objects might have more then one contact manifold.
+
+
+B3_ATTRIBUTE_ALIGNED16( class) b3ContactCache
+{
+
+	
+
+	
+	/// sort cached points so most isolated points come first
+	int	sortCachedPoints(const btManifoldPoint& pt);
+
+	int		findContactPoint(const btManifoldPoint* unUsed, int numUnused,const btManifoldPoint& pt);
+
+public:
+
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+
+	int m_index1a;
+
+	b3ContactCache();
+
+	b3ContactCache(const btCollisionObject* body0,const btCollisionObject* body1,int , b3Scalar contactBreakingThreshold,b3Scalar contactProcessingThreshold)
+		: btTypedObject(BT_PERSISTENT_MANIFOLD_TYPE),
+	m_body0(body0),m_body1(body1),m_cachedPoints(0),
+		m_contactBreakingThreshold(contactBreakingThreshold),
+		m_contactProcessingThreshold(contactProcessingThreshold)
+	{
+	}
+
+	B3_FORCE_INLINE const btCollisionObject* getBody0() const { return m_body0;}
+	B3_FORCE_INLINE const btCollisionObject* getBody1() const { return m_body1;}
+
+	void	setBodies(const btCollisionObject* body0,const btCollisionObject* body1)
+	{
+		m_body0 = body0;
+		m_body1 = body1;
+	}
+
+	void clearUserCache(btManifoldPoint& pt);
+
+#ifdef DEBUG_PERSISTENCY
+	void	DebugPersistency();
+#endif //
+	
+	B3_FORCE_INLINE int	getNumContacts() const { return m_cachedPoints;}
+	/// the setNumContacts API is usually not used, except when you gather/fill all contacts manually
+	void setNumContacts(int cachedPoints)
+	{
+		m_cachedPoints = cachedPoints;
+	}
+
+
+	B3_FORCE_INLINE const btManifoldPoint& getContactPoint(int index) const
+	{
+		btAssert(index < m_cachedPoints);
+		return m_pointCache[index];
+	}
+
+	B3_FORCE_INLINE btManifoldPoint& getContactPoint(int index)
+	{
+		btAssert(index < m_cachedPoints);
+		return m_pointCache[index];
+	}
+
+	
+	void setContactBreakingThreshold(b3Scalar contactBreakingThreshold)
+	{
+		m_contactBreakingThreshold = contactBreakingThreshold;
+	}
+
+	void setContactProcessingThreshold(b3Scalar	contactProcessingThreshold)
+	{
+		m_contactProcessingThreshold = contactProcessingThreshold;
+	}
+	
+	
+
+
+	int getCacheEntry(const btManifoldPoint& newPoint) const;
+
+	int addManifoldPoint( const btManifoldPoint& newPoint, bool isPredictive=false);
+
+	void removeContactPoint (int index)
+	{
+		clearUserCache(m_pointCache[index]);
+
+		int lastUsedIndex = getNumContacts() - 1;
+//		m_pointCache[index] = m_pointCache[lastUsedIndex];
+		if(index != lastUsedIndex) 
+		{
+			m_pointCache[index] = m_pointCache[lastUsedIndex]; 
+			//get rid of duplicated userPersistentData pointer
+			m_pointCache[lastUsedIndex].m_userPersistentData = 0;
+			m_pointCache[lastUsedIndex].m_appliedImpulse = 0.f;
+			m_pointCache[lastUsedIndex].m_lateralFrictionInitialized = false;
+			m_pointCache[lastUsedIndex].m_appliedImpulseLateral1 = 0.f;
+			m_pointCache[lastUsedIndex].m_appliedImpulseLateral2 = 0.f;
+			m_pointCache[lastUsedIndex].m_lifeTime = 0;
+		}
+
+		btAssert(m_pointCache[lastUsedIndex].m_userPersistentData==0);
+		m_cachedPoints--;
+	}
+	void replaceContactPoint(const btManifoldPoint& newPoint,int insertIndex)
+	{
+		btAssert(validContactDistance(newPoint));
+
+#define MAINTAIN_PERSISTENCY 1
+#ifdef MAINTAIN_PERSISTENCY
+		int	lifeTime = m_pointCache[insertIndex].getLifeTime();
+		b3Scalar	appliedImpulse = m_pointCache[insertIndex].m_appliedImpulse;
+		b3Scalar	appliedLateralImpulse1 = m_pointCache[insertIndex].m_appliedImpulseLateral1;
+		b3Scalar	appliedLateralImpulse2 = m_pointCache[insertIndex].m_appliedImpulseLateral2;
+//		bool isLateralFrictionInitialized = m_pointCache[insertIndex].m_lateralFrictionInitialized;
+		
+		
+			
+		btAssert(lifeTime>=0);
+		void* cache = m_pointCache[insertIndex].m_userPersistentData;
+		
+		m_pointCache[insertIndex] = newPoint;
+
+		m_pointCache[insertIndex].m_userPersistentData = cache;
+		m_pointCache[insertIndex].m_appliedImpulse = appliedImpulse;
+		m_pointCache[insertIndex].m_appliedImpulseLateral1 = appliedLateralImpulse1;
+		m_pointCache[insertIndex].m_appliedImpulseLateral2 = appliedLateralImpulse2;
+		
+		m_pointCache[insertIndex].m_appliedImpulse =  appliedImpulse;
+		m_pointCache[insertIndex].m_appliedImpulseLateral1 = appliedLateralImpulse1;
+		m_pointCache[insertIndex].m_appliedImpulseLateral2 = appliedLateralImpulse2;
+
+
+		m_pointCache[insertIndex].m_lifeTime = lifeTime;
+#else
+		clearUserCache(m_pointCache[insertIndex]);
+		m_pointCache[insertIndex] = newPoint;
+	
+#endif
+	}
+
+	
+	bool validContactDistance(const btManifoldPoint& pt) const
+	{
+		return pt.m_distance1 <= getContactBreakingThreshold();
+	}
+	/// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin
+	void	refreshContactPoints(  const btTransform& trA,const btTransform& trB);
+
+	
+	B3_FORCE_INLINE	void	clearManifold()
+	{
+		int i;
+		for (i=0;i<m_cachedPoints;i++)
+		{
+			clearUserCache(m_pointCache[i]);
+		}
+		m_cachedPoints = 0;
+	}
+
+
+
+}
+;
+
+
+
+
+
+#endif //B3_CONTACT_CACHE_H

src/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.cpp

@@ -1571,7 +1571,7 @@ int clipHullHullSingle(
 #include "b3GjkEpa.h"
 #include "b3VoronoiSimplexSolver.h"
 
-int computeContactConvexConvex(
+int computeContactConvexConvex( b3AlignedObjectArray<b3Int4>& pairs,
 																int pairIndex,
 																int bodyIndexA, int bodyIndexB, 
 																int collidableIndexA, int collidableIndexB, 
@@ -1610,6 +1610,8 @@ int computeContactConvexConvex(
 	int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;
 	int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;
 
+	int sz = sizeof(b3Contact4);
+
 	bool result2 = getClosestPoints(&gjkDetector, transA, transB,
 		convexShapes[shapeIndexA], convexShapes[shapeIndexB],
 		convexVertices,convexVertices,
@@ -1617,7 +1619,8 @@ int computeContactConvexConvex(
 		sepAxis2,
 		distance2,
 		resultPointOnB);
-
+	
+	
 	if (result2)
 	{
 		if (nGlobalContactsOut<maxContactCapacity)
@@ -1634,9 +1637,15 @@ int computeContactConvexConvex(
 					
 			
 			int numPoints = 1;
+			if (pairs[pairIndex].z>=0)
+			{
+				printf("add existing points?\n");
+				
+			}
 			for (int p=0;p<numPoints;p++)
 			{
 				resultPointOnB.w = distance2;
+
 				contact.m_worldPos[p] = resultPointOnB;
 				
 				contact.m_worldNormal = -sepAxis2; 
@@ -1900,7 +1909,7 @@ void GpuSatCollision::computeConvexConvexContactsGPUSAT( b3OpenCLArray<b3Int4>*
 			hostCollidables[collidableIndexB].m_shapeType == SHAPE_CONVEX_HULL)
 		{
 			//printf("hostPairs[i].z=%d\n",hostPairs[i].z);
-			int contactIndex = computeContactConvexConvex(i,bodyIndexA,bodyIndexB,collidableIndexA,collidableIndexB,hostBodyBuf,
+			int contactIndex = computeContactConvexConvex(hostPairs,i,bodyIndexA,bodyIndexB,collidableIndexA,collidableIndexB,hostBodyBuf,
 					hostCollidables,hostConvexData,hostVertices,hostUniqueEdges,hostIndices,hostFaces,hostContacts,nContacts,maxContactCapacity,
 					oldHostContacts);
 

src/Bullet3OpenCL/NarrowphaseCollision/b3GjkPairDetector.cpp

@@ -229,7 +229,7 @@ bool getClosestPoints(b3GjkPairDetector* gjkDetector, const b3Transform&	transA,
 				if (l2>B3_EPSILON*B3_EPSILON)
 				{
 
-					b3Vector3 testAxis = gjkDetector->m_cachedSeparatingAxis*(1./b3Sqrt(l2));
+					b3Vector3 testAxis = gjkDetector->m_cachedSeparatingAxis*(1.f/b3Sqrt(l2));
 					float computedDepth=1e30f;
 					if (!TestSepAxis(hullA,hullB,transA.getOrigin(),transA.getRotation(),
 						transB.getOrigin(),transB.getRotation(),testAxis,verticesA,verticesB,computedDepth))
@@ -362,7 +362,7 @@ bool getClosestPoints(b3GjkPairDetector* gjkDetector, const b3Transform&	transA,
 				if (l2>B3_EPSILON*B3_EPSILON)
 				{
 
-					b3Vector3 testAxis = gjkDetector->m_cachedSeparatingAxis*(1./b3Sqrt(l2));
+					b3Vector3 testAxis = gjkDetector->m_cachedSeparatingAxis*(1.f/b3Sqrt(l2));
 					float computedDepth=1e30f;
 					if (!TestSepAxis(hullA,hullB,transA.getOrigin(),transA.getRotation(),
 						transB.getOrigin(),transB.getRotation(),testAxis,verticesA,verticesB,computedDepth))
@@ -576,7 +576,7 @@ bool getClosestPoints(b3GjkPairDetector* gjkDetector, const b3Transform&	transA,
 				if (l2>B3_EPSILON*B3_EPSILON)
 				{
 
-					b3Vector3 testAxis = gjkDetector->m_cachedSeparatingAxis*(1./b3Sqrt(l2));
+					b3Vector3 testAxis = gjkDetector->m_cachedSeparatingAxis*(1.f/b3Sqrt(l2));
 					float computedDepth=1e30f;
 					if (!TestSepAxis(hullA,hullB,transA.getOrigin(),transA.getRotation(),
 						transB.getOrigin(),transB.getRotation(),testAxis,verticesA,verticesB,computedDepth))

src/Bullet3OpenCL/NarrowphaseCollision/b3GjkPairDetector.h

@@ -9,7 +9,7 @@
 #include "Bullet3Common/b3Vector3.h"
 #include "Bullet3Common/b3AlignedObjectArray.h"
 
-struct b3Transform;
+class b3Transform;
 struct b3GjkEpaSolver2;
 class b3VoronoiSimplexSolver;
 struct b3ConvexPolyhedronCL;

src/Bullet3OpenCL/NarrowphaseCollision/kernels/satClipHullContacts.h

@@ -1,6 +1,5 @@
 //this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
 static const char* satClipKernelsCL= \
-"\n"
 "#define TRIANGLE_NUM_CONVEX_FACES 5\n"
 "\n"
 "#define SHAPE_CONVEX_HULL 3\n"
@@ -47,15 +46,15 @@ static const char* satClipKernelsCL= \
 "{\n"
 "	float4 m_worldPos[4];\n"
 "	float4 m_worldNormal;	//	w: m_nPoints\n"
+"\n"
 "	u32 m_coeffs;\n"
 "	u32 m_batchIdx;\n"
-"\n"
 "	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
 "	int m_bodyBPtrAndSignBit;\n"
 "\n"
 "	int	m_childIndexA;\n"
 "	int	m_childIndexB;\n"
-"	int m_unused1;\n"
+"	float m_unused1;\n"
 "	int m_unused2;\n"
 "\n"
 "} Contact4;\n"
@@ -678,10 +677,8 @@ static const char* satClipKernelsCL= \
 "\n"
 "#define PARALLEL_SUM(v, n) for(int j=1; j<n; j++) v[0] += v[j];\n"
 "#define PARALLEL_DO(execution, n) for(int ie=0; ie<n; ie++){execution;}\n"
-"#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]; }\n"
-"#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]; }\n"
+"#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]; }\n"
+"#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]; }\n"
 "\n"
 "int extractManifoldSequentialGlobal(__global const float4* p, int nPoints, float4 nearNormal, int4* contactIdx)\n"
 "{\n"
@@ -1947,4 +1944,5 @@ static const char* satClipKernelsCL= \
 "    \n"
 "}\n"
 "\n"
+"\n"
 ;

src/Bullet3OpenCL/NarrowphaseCollision/kernels/satKernels.h

@@ -1316,5 +1316,4 @@ static const char* satKernelsCL= \
 "		concavePairs[pairIdx].w = -1;\n"
 "	}\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/ParallelPrimitives/kernels/BoundSearchKernelsCL.h

@@ -106,5 +106,4 @@ static const char* boundSearchKernelsCL= \
 "	}\n"
 "}\n"
 "\n"
-"\n"
 ;

src/Bullet3OpenCL/ParallelPrimitives/kernels/FillKernelsCL.h

@@ -107,5 +107,4 @@ static const char* fillKernelsCL= \
 "	}\n"
 "}\n"
 "\n"
-"\n"
 ;

src/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsCL.h

@@ -154,5 +154,4 @@ static const char* prefixScanKernelsCL= \
 "		dst[cb.m_numBlocks] = sum;\n"
 "	}\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsFloat4CL.h

@@ -154,5 +154,4 @@ static const char* prefixScanKernelsFloat4CL= \
 "		dst[cb.m_numBlocks] = sum;\n"
 "	}\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/Raycast/kernels/rayCastKernels.h

@@ -1,6 +1,5 @@
 //this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
 static const char* rayCastKernelCL= \
-"\n"
 "#define SHAPE_CONVEX_HULL 3\n"
 "#define SHAPE_PLANE 4\n"
 "#define SHAPE_CONCAVE_TRIMESH 5\n"
@@ -339,5 +338,4 @@ static const char* rayCastKernelCL= \
 "	}\n"
 "\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp

@@ -570,4 +570,3 @@ void	b3GpuRigidBodyPipeline::castRays(const b3AlignedObjectArray<b3RayInfo>& ray
 		m_data->m_narrowphase->getNumCollidablesGpu(), m_data->m_narrowphase->getCollidablesCpu(),	m_data->m_narrowphase->getInternalData()
 		);
 }
-

src/Bullet3OpenCL/RigidBody/kernels/batchingKernels.h

@@ -352,5 +352,4 @@ static const char* batchingKernelsCL= \
 "\n"
 "\n"
 "\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/batchingKernelsNew.h

@@ -242,5 +242,4 @@ static const char* batchingKernelsNewCL= \
 "	\n"
 "	//return batchIdx;\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/integrateKernel.h

@@ -106,5 +106,4 @@ static const char* integrateKernelCL= \
 "		\n"
 "	}\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/jointSolver.h

@@ -877,5 +877,4 @@ static const char* solveConstraintRowsCL= \
 "		}\n"
 "	}\n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/solveContact.h

@@ -493,5 +493,4 @@ static const char* solveContactCL= \
 "	\n"
 "    \n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/solveFriction.h

@@ -515,5 +515,4 @@ static const char* solveFrictionCL= \
 "	\n"
 "    \n"
 "}\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/solverSetup.h

@@ -1,6 +1,5 @@
 //this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
 static const char* solverSetupCL= \
-"\n"
 "/*\n"
 "Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
 "\n"
@@ -666,5 +665,4 @@ static const char* solverSetupCL= \
 "\n"
 "\n"
 "\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h

@@ -626,5 +626,4 @@ static const char* solverSetup2CL= \
 "\n"
 "\n"
 "\n"
-"\n"
 ;

src/Bullet3OpenCL/RigidBody/kernels/updateAabbsKernel.h

@@ -1,6 +1,5 @@
 //this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
 static const char* updateAabbsKernelCL= \
-"\n"
 "#define SHAPE_CONVEX_HULL 3\n"
 "\n"
 "typedef float4 Quaternion;\n"
@@ -195,5 +194,4 @@ static const char* updateAabbsKernelCL= \
 "		}\n"
 "	} \n"
 "}\n"
-"\n"
 ;