Disable TEST_NON_VIRTUAL debugging for btGjkPairDetector

Reverted BulletMultiThreaded, there are some performance issues to be resolved.

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuCollisionShapes.cpp

@@ -16,155 +16,6 @@ subject to the following restrictions:
 
 #include "SpuCollisionShapes.h"
 
-#if 0
-int  SpuInternalShape::dmaShapeTypeIntoShapeStorage (ppu_address_t ppuAddress, uint32_t dmaTag)
-{
-	m_ppuConvexShapePtr = ppuAddress;
-	/* This assumes that m_shapeType is the first entry in the struct */
-	cellDmaSmallGet (m_collisionShape, m_ppuConvexShapePtr, 4, DMA_TAG(dmaTag), 0, 0);
-	cellDmaWaitTagStatusAll(DMA_MASK(dmaTag));
-	return m_collisionShape->getShapeType ();
-}
-#endif
-
-void SpuInternalShape::dmaShapeData (ppu_address_t ppuAddress, int shapeType, uint32_t dmaTag)
-{
-	m_ppuConvexShapePtr = ppuAddress;
-	uint32_t shapeSize = getShapeTypeSize (shapeType);
-	cellDmaGet (m_collisionShape, m_ppuConvexShapePtr, shapeSize, DMA_TAG(dmaTag), 0, 0);
-}
-
-
-void SpuInternalConvexHull::dmaPointsData (const SpuInternalShape& shape, uint32_t dmaTag)
-{
-	btAssert (shape.m_collisionShape->getShapeType () == CONVEX_HULL_SHAPE_PROXYTYPE);
-	btConvexHullShape* convexHullShape = (btConvexHullShape*)shape.m_collisionShape;
-	ppu_address_t ppuPointsAddress = (ppu_address_t)convexHullShape->getPoints();
-	int numPoints = convexHullShape->getNumPoints ();
-	dmaPointsData (ppuPointsAddress, numPoints, dmaTag);
-}
-
-void SpuInternalConvexHull::dmaPointsData (ppu_address_t ppuPointsAddress, int numPoints, uint32_t dmaTag)
-{
-	m_ppuPointsPtr = ppuPointsAddress;
-	m_numPoints = numPoints;
-	cellDmaGet (m_points, m_ppuPointsPtr, sizeof(btVector3)*numPoints, DMA_TAG(dmaTag), 0, 0);
-}
-
-void SpuCompoundShape::dmaChildShapeInfo (btCompoundShape* compoundShape, uint32_t dmaTag)
-{
-	register int dmaSize;
-	register ppu_address_t dmaPpuAddress;
-	int childShapeCount = compoundShape->getNumChildShapes();
-	dmaSize = childShapeCount * sizeof(btCompoundShapeChild);
-	dmaPpuAddress = (ppu_address_t)compoundShape->getChildList();
-	cellDmaGet(&m_subshapes[0], dmaPpuAddress, dmaSize, DMA_TAG(dmaTag), 0, 0);
-}
-
-void SpuCompoundShape::dmaChildShape (int childShape,
-							SpuInternalShape* localShape,
-							SpuInternalConvexHull* localShapeHull,
-							uint32_t dmaTag)
-{
-	btCompoundShapeChild& compoundChildShape = m_subshapes[childShape];
-	localShape->dmaShapeData ((ppu_address_t)compoundChildShape.m_childShape, compoundChildShape.m_childShapeType, dmaTag);
-	cellDmaWaitTagStatusAll (DMA_MASK(dmaTag));
-	if (compoundChildShape.m_childShapeType == CONVEX_HULL_SHAPE_PROXYTYPE)
-	{
-		localShapeHull->dmaPointsData (*localShape, dmaTag);
-	}
-}
-
-
-void dmaBvhShapeData (bvhMeshShape_LocalStoreMemory* bvhMeshShape, btBvhTriangleMeshShape* triMeshShape)
-{
-	register int dmaSize;
-	register ppu_address_t	dmaPpuAddress2;
-
-	dmaSize = sizeof(btTriangleIndexVertexArray);
-	dmaPpuAddress2 = reinterpret_cast<ppu_address_t>(triMeshShape->getMeshInterface());
-	//	spu_printf("trimeshShape->getMeshInterface() == %llx\n",dmaPpuAddress2);
-#ifdef __SPU__
-	cellDmaGet(&bvhMeshShape->gTriangleMeshInterfaceStorage, dmaPpuAddress2  , dmaSize, DMA_TAG(1), 0, 0);
-	bvhMeshShape->gTriangleMeshInterfacePtr = &bvhMeshShape->gTriangleMeshInterfaceStorage;
-#else
-	bvhMeshShape->gTriangleMeshInterfacePtr = (btTriangleIndexVertexArray*)cellDmaGetReadOnly(&bvhMeshShape->gTriangleMeshInterfaceStorage, dmaPpuAddress2  , dmaSize, DMA_TAG(1), 0, 0);
-#endif
-
-	//cellDmaWaitTagStatusAll(DMA_MASK(1));
-	
-	///now DMA over the BVH
-	
-	dmaSize = sizeof(btOptimizedBvh);
-	dmaPpuAddress2 = reinterpret_cast<ppu_address_t>(triMeshShape->getOptimizedBvh());
-	//spu_printf("trimeshShape->getOptimizedBvh() == %llx\n",dmaPpuAddress2);
-	cellDmaGet(&bvhMeshShape->gOptimizedBvh, dmaPpuAddress2  , dmaSize, DMA_TAG(2), 0, 0);
-	//cellDmaWaitTagStatusAll(DMA_MASK(2));
-	cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
-}
-
-void dmaBvhIndexedMesh (btIndexedMesh* IndexMesh, IndexedMeshArray& indexArray, int index, uint32_t dmaTag)
-{		
-	cellDmaGet(IndexMesh, (ppu_address_t)&indexArray[index]  , sizeof(btIndexedMesh), DMA_TAG(dmaTag), 0, 0);
-	
-}
-
-void dmaBvhSubTreeHeaders (btBvhSubtreeInfo* subTreeHeaders, ppu_address_t subTreePtr, int batchSize, uint32_t dmaTag)
-{
-	cellDmaGet(subTreeHeaders, subTreePtr, batchSize * sizeof(btBvhSubtreeInfo), DMA_TAG(dmaTag), 0, 0);
-}
-
-void dmaBvhSubTreeNodes (btQuantizedBvhNode* nodes, const btBvhSubtreeInfo& subtree, QuantizedNodeArray&	nodeArray, int dmaTag)
-{
-	cellDmaGet(nodes, reinterpret_cast<ppu_address_t>(&nodeArray[subtree.m_rootNodeIndex]) , subtree.m_subtreeSize* sizeof(btQuantizedBvhNode), DMA_TAG(2), 0, 0);
-}
-
-
-void SpuBvhMeshShape::dmaMeshInterfaceAndOptimizedBvh (const SpuInternalShape& triangleMeshShape, uint32_t dmaTag1, uint32_t dmaTag2)
-{
-	register int dmaSize;
-	register ppu_address_t dmaPpuAddress;
-
-	btBvhTriangleMeshShape* triMeshShape = (btBvhTriangleMeshShape*)triangleMeshShape.m_collisionShape;
-
-	// DMA: triangle mesh interface
-	dmaSize = sizeof(btTriangleIndexVertexArray);
-	dmaPpuAddress = reinterpret_cast<ppu_address_t>(triMeshShape->getMeshInterface());
-#ifdef __SPU__
-	cellDmaGet(&m_triangleMeshInterfaceBuffer, dmaPpuAddress, dmaSize, DMA_TAG(dmaTag1), 0, 0);
-#else
-	m_triangleMeshInterface = (btTriangleIndexVertexArray*)cellDmaGetReadOnly(&m_triangleMeshInterfaceBuffer, dmaPpuAddress, dmaSize, DMA_TAG(dmaTag1), 0, 0);
-#endif
-
-	//cellDmaWaitTagStatusAll(DMA_MASK(dmaTag1));
-	
-	// DMA: btOptimizedBvh
-	dmaSize = sizeof(btOptimizedBvh);
-	dmaPpuAddress = reinterpret_cast<ppu_address_t>(triMeshShape->getOptimizedBvh());
-	cellDmaGet(m_optimizedBvh, dmaPpuAddress  , dmaSize, DMA_TAG(dmaTag2), 0, 0);
-
-	//cellDmaWaitTagStatusAll(DMA_MASK(dmaTag2));
-
-	// wait for both triangle mesh interface and optimized bvh 
-	cellDmaWaitTagStatusAll(DMA_MASK(dmaTag1) | DMA_MASK(dmaTag2));
-}
-
-void SpuBvhMeshShape::dmaIndexedMesh (int index, uint32_t dmaTag)
-{
-	cellDmaGet(&m_indexMesh, (ppu_address_t)&m_triangleMeshInterface->getIndexedMeshArray()[index]  , sizeof(btIndexedMesh), DMA_TAG(dmaTag), 0, 0);
-}
-
-void SpuBvhMeshShape::dmaSubTreeHeaders (ppu_address_t subTreePtr, int numHeaders, uint32_t dmaTag)
-{
-	cellDmaGet(&m_subtreeHeaders[0], subTreePtr, numHeaders * sizeof(btBvhSubtreeInfo), DMA_TAG(dmaTag), 0, 0);
-}
-
-void SpuBvhMeshShape::dmaSubTreeNodes (const btBvhSubtreeInfo& subtree, QuantizedNodeArray&	nodeArray, int dmaTag)
-{
-	cellDmaGet(&m_subtreeNodes[0], reinterpret_cast<ppu_address_t>(&nodeArray[subtree.m_rootNodeIndex]) , subtree.m_subtreeSize* sizeof(btQuantizedBvhNode), DMA_TAG(dmaTag), 0, 0);
-}
-
-
 btPoint3 localGetSupportingVertexWithoutMargin(int shapeType, void* shape, const btVector3& localDir,struct	SpuConvexPolyhedronVertexData* convexVertexData)//, int *featureIndex)
 {
     switch (shapeType)
@@ -447,6 +298,49 @@ void computeAabb (btVector3& aabbMin, btVector3& aabbMax, btConvexInternalShape*
 	};
 }
 
+void dmaBvhShapeData (bvhMeshShape_LocalStoreMemory* bvhMeshShape, btBvhTriangleMeshShape* triMeshShape)
+{
+	register int dmaSize;
+	register ppu_address_t	dmaPpuAddress2;
+
+	dmaSize = sizeof(btTriangleIndexVertexArray);
+	dmaPpuAddress2 = reinterpret_cast<ppu_address_t>(triMeshShape->getMeshInterface());
+	//	spu_printf("trimeshShape->getMeshInterface() == %llx\n",dmaPpuAddress2);
+#ifdef __SPU__
+	cellDmaGet(&bvhMeshShape->gTriangleMeshInterfaceStorage, dmaPpuAddress2  , dmaSize, DMA_TAG(1), 0, 0);
+	bvhMeshShape->gTriangleMeshInterfacePtr = &bvhMeshShape->gTriangleMeshInterfaceStorage;
+#else
+	bvhMeshShape->gTriangleMeshInterfacePtr = (btTriangleIndexVertexArray*)cellDmaGetReadOnly(&bvhMeshShape->gTriangleMeshInterfaceStorage, dmaPpuAddress2  , dmaSize, DMA_TAG(1), 0, 0);
+#endif
+
+	//cellDmaWaitTagStatusAll(DMA_MASK(1));
+	
+	///now DMA over the BVH
+	
+	dmaSize = sizeof(btOptimizedBvh);
+	dmaPpuAddress2 = reinterpret_cast<ppu_address_t>(triMeshShape->getOptimizedBvh());
+	//spu_printf("trimeshShape->getOptimizedBvh() == %llx\n",dmaPpuAddress2);
+	cellDmaGet(&bvhMeshShape->gOptimizedBvh, dmaPpuAddress2  , dmaSize, DMA_TAG(2), 0, 0);
+	//cellDmaWaitTagStatusAll(DMA_MASK(2));
+	cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
+}
+
+void dmaBvhIndexedMesh (btIndexedMesh* IndexMesh, IndexedMeshArray& indexArray, int index, uint32_t dmaTag)
+{		
+	cellDmaGet(IndexMesh, (ppu_address_t)&indexArray[index]  , sizeof(btIndexedMesh), DMA_TAG(dmaTag), 0, 0);
+	
+}
+
+void dmaBvhSubTreeHeaders (btBvhSubtreeInfo* subTreeHeaders, ppu_address_t subTreePtr, int batchSize, uint32_t dmaTag)
+{
+	cellDmaGet(subTreeHeaders, subTreePtr, batchSize * sizeof(btBvhSubtreeInfo), DMA_TAG(dmaTag), 0, 0);
+}
+
+void dmaBvhSubTreeNodes (btQuantizedBvhNode* nodes, const btBvhSubtreeInfo& subtree, QuantizedNodeArray&	nodeArray, int dmaTag)
+{
+	cellDmaGet(nodes, reinterpret_cast<ppu_address_t>(&nodeArray[subtree.m_rootNodeIndex]) , subtree.m_subtreeSize* sizeof(btQuantizedBvhNode), DMA_TAG(2), 0, 0);
+}
+
 ///getShapeTypeSize could easily be optimized, but it is not likely a bottleneck
 int		getShapeTypeSize(int shapeType)
 {

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuCollisionShapes.h

@@ -4,7 +4,6 @@
 #include "../SpuDoubleBuffer.h"
 
 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "BulletCollision/CollisionShapes/btCollisionShape.h"
 #include "BulletCollision/CollisionShapes/btConvexInternalShape.h"
 #include "BulletCollision/CollisionShapes/btCylinderShape.h"
 
@@ -19,69 +18,8 @@
 #include "BulletCollision/CollisionShapes/btConvexHullShape.h"
 #include "BulletCollision/CollisionShapes/btCompoundShape.h"
 
-#define MAX_SHAPE_SIZE 256
 #define MAX_NUM_SPU_CONVEX_POINTS 128
 
-struct SpuInternalShape
-{
-	ATTRIBUTE_ALIGNED16(char m_collisionShapeStorage[MAX_SHAPE_SIZE]);
-	btConvexShape* m_convexShape;
-	btCollisionShape* m_collisionShape;
-	ppu_address_t m_ppuConvexShapePtr;
-	SpuInternalShape ()
-	{
-		m_convexShape = (btConvexShape*)&m_collisionShapeStorage[0];
-		m_collisionShape = (btCollisionShape*)&m_collisionShapeStorage[0];
-		m_ppuConvexShapePtr = 0;
-	}
-
-	void dmaShapeData (ppu_address_t ppuAddress, int shapeType, uint32_t dmaTag);
-};
-
-struct SpuInternalConvexHull
-{
-	ATTRIBUTE_ALIGNED16(btVector3 m_pointsBuffer[MAX_NUM_SPU_CONVEX_POINTS]);
-	int m_numPoints;
-	btVector3* m_points;
-	ppu_address_t m_ppuPointsPtr;
-
-	SpuInternalConvexHull ()
-	{
-		m_points = (btVector3*)&m_pointsBuffer[0];
-		m_numPoints = 0;
-		m_ppuPointsPtr = 0;
-	}
-
-	void dmaPointsData (const SpuInternalShape& shape, uint32_t dmaTag);
-	void dmaPointsData (ppu_address_t ppuPointsAddress, int numPoints, uint32_t dmaTag);
-};
-
-
-
-struct SpuBvhMeshShape
-{
-	ATTRIBUTE_ALIGNED16(char m_optimizedBvhBuffer[sizeof(btOptimizedBvh)+16]);
-	ATTRIBUTE_ALIGNED16(btTriangleIndexVertexArray m_triangleMeshInterfaceBuffer);
-	#define MAX_SPU_SUBTREE_HEADERS 32
-	///only a single mesh part for now, we can add support for multiple parts, but quantized trees don't support this at the moment 
-	ATTRIBUTE_ALIGNED16(btIndexedMesh	m_indexMesh);
-	ATTRIBUTE_ALIGNED16(btBvhSubtreeInfo m_subtreeHeaders[MAX_SPU_SUBTREE_HEADERS]);
-	ATTRIBUTE_ALIGNED16(btQuantizedBvhNode m_subtreeNodes[MAX_SUBTREE_SIZE_IN_BYTES/sizeof(btQuantizedBvhNode)]);
-	btOptimizedBvh* m_optimizedBvh;
-	btTriangleIndexVertexArray* m_triangleMeshInterface;
-
-	SpuBvhMeshShape ()
-	{
-		m_optimizedBvh = (btOptimizedBvh*)&m_optimizedBvhBuffer[0];
-		m_triangleMeshInterface = (btTriangleIndexVertexArray*)&m_triangleMeshInterfaceBuffer;
-	}
-
-	void dmaMeshInterfaceAndOptimizedBvh (const SpuInternalShape& triangleMeshShape, uint32_t dmaTag1, uint32_t dmaTag2);
-	void dmaIndexedMesh (int index, uint32_t dmaTag);
-	void dmaSubTreeHeaders (ppu_address_t subTreePtr, int numHeaders, uint32_t dmaTag);
-	void dmaSubTreeNodes (const btBvhSubtreeInfo& subtree, QuantizedNodeArray&	nodeArray, int dmaTag);
-};
-
 struct	SpuConvexPolyhedronVertexData
 {
 	void*	gSpuConvexShapePtr;
@@ -90,19 +28,7 @@ struct	SpuConvexPolyhedronVertexData
 	ATTRIBUTE_ALIGNED16(btPoint3 g_convexPointBuffer[MAX_NUM_SPU_CONVEX_POINTS]);
 };
 
-struct SpuCompoundShape
+#define MAX_SHAPE_SIZE 256
-{
-	#define MAX_SPU_COMPOUND_SUBSHAPES 16
-	ATTRIBUTE_ALIGNED16(btCompoundShapeChild m_subshapes[MAX_SPU_COMPOUND_SUBSHAPES]);
-
-	void dmaChildShapeInfo (btCompoundShape* compoundShape, uint32_t dmaTag);
-	void dmaChildShape (int childShape,
-							SpuInternalShape* localShape,
-							SpuInternalConvexHull* localShapeHull,
-							uint32_t dmaTag);
-};
-
-
 
 struct CollisionShape_LocalStoreMemory
 {

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuContactResult.cpp

@@ -170,7 +170,7 @@ void SpuContactResult::writeDoubleBufferedManifold(btPersistentManifold* lsManif
 	//no, the swapBuffers does the wait
 }
 
-void SpuContactResult::addContactPoint(const btVector3& normalOnBInWorld,const btPoint3& pointInWorld,btScalar depth)
+void SpuContactResult::addContactPoint(const btVector3& normalOnBInWorld,const btPoint3& pointInWorld,float depth)
 {
 	//spu_printf("*** SpuContactResult::addContactPoint: depth = %f\n",depth);
 

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuContactResult.h

@@ -1,113 +1,113 @@
-/*
+/*
-Bullet Continuous Collision Detection and Physics Library
+Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
+
-This software is provided 'as-is', without any express or implied warranty.
+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.
+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, 
+Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
+including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
+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.
+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.
+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.
+3. This notice may not be removed or altered from any source distribution.
-*/
+*/
-
+
-#ifndef SPU_CONTACT_RESULT2_H
+#ifndef SPU_CONTACT_RESULT2_H
-#define SPU_CONTACT_RESULT2_H
+#define SPU_CONTACT_RESULT2_H
-
+
-
+
-#ifndef WIN32
+#ifndef WIN32
-#include <stdint.h>
+#include <stdint.h>
-#endif
+#endif
-
+
-
+
-
+
-#include "../SpuDoubleBuffer.h"
+#include "../SpuDoubleBuffer.h"
-
+
-
+
-#include "LinearMath/btTransform.h"
+#include "LinearMath/btTransform.h"
-#include "LinearMath/btPoint3.h"
+#include "LinearMath/btPoint3.h"
-
+
-
+
-#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
-#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+
-
+
-struct SpuCollisionPairInput
+struct SpuCollisionPairInput
-{
+{
-	ppu_address_t m_collisionShapes[2];
+	ppu_address_t m_collisionShapes[2];
-	void*	m_spuCollisionShapes[2];
+	void*	m_spuCollisionShapes[2];
-
+
-	ppu_address_t m_persistentManifoldPtr;
+	ppu_address_t m_persistentManifoldPtr;
-	btVector3	m_primitiveDimensions0;
+	btVector3	m_primitiveDimensions0;
-	btVector3	m_primitiveDimensions1;
+	btVector3	m_primitiveDimensions1;
-	int		m_shapeType0;
+	int		m_shapeType0;
-	int		m_shapeType1;	
+	int		m_shapeType1;	
-	float	m_collisionMargin0;
+	float	m_collisionMargin0;
-	float	m_collisionMargin1;
+	float	m_collisionMargin1;
-
+
-	btTransform	m_worldTransform0;
+	btTransform	m_worldTransform0;
-	btTransform m_worldTransform1;
+	btTransform m_worldTransform1;
-	
+	
-	bool	m_isSwapped;
+	bool	m_isSwapped;
-	bool    m_useEpa;
+	bool    m_useEpa;
-};
+};
-
+
-struct SpuClosestPointInput
+
-{
+struct SpuClosestPointInput
-    SpuClosestPointInput()
+{
-        :m_maximumDistanceSquared(float(1e30)),
+    SpuClosestPointInput()
-        m_stackAlloc(0)
+        :m_maximumDistanceSquared(float(1e30)),
-    {
+        m_stackAlloc(0)
-    }
+    {
-
+    }
-    btTransform m_transformA;
+
-    btTransform m_transformB;
+    btTransform m_transformA;
-    float       m_maximumDistanceSquared;
+    btTransform m_transformB;
-    class       btStackAlloc* m_stackAlloc;
+    float	m_maximumDistanceSquared;
-        struct SpuConvexPolyhedronVertexData* m_convexVertexData[2];
+    class	btStackAlloc* m_stackAlloc;
-};
+	struct SpuConvexPolyhedronVertexData* m_convexVertexData[2];
-
+};
-
+
-///SpuContactResult exports the contact points using double-buffered DMA transfers, only when needed
+///SpuContactResult exports the contact points using double-buffered DMA transfers, only when needed
-///So when an existing contact point is duplicated, no transfer/refresh is performed.
+///So when an existing contact point is duplicated, no transfer/refresh is performed.
-class SpuContactResult : public btDiscreteCollisionDetectorInterface::Result
+class SpuContactResult
-{
+{
-    btTransform		m_rootWorldTransform0;
+    btTransform		m_rootWorldTransform0;
-	btTransform		m_rootWorldTransform1;
+	btTransform		m_rootWorldTransform1;
-	ppu_address_t	m_manifoldAddress;
+	ppu_address_t	m_manifoldAddress;
-
+
-    btPersistentManifold* m_spuManifold;
+    btPersistentManifold* m_spuManifold;
-	bool m_RequiresWriteBack;
+	bool m_RequiresWriteBack;
-	btScalar	m_combinedFriction;
+	btScalar	m_combinedFriction;
-	btScalar	m_combinedRestitution;
+	btScalar	m_combinedRestitution;
-	
+	
-	bool m_isSwapped;
+	bool m_isSwapped;
-
+
-	DoubleBuffer<btPersistentManifold, 1> g_manifoldDmaExport;
+	DoubleBuffer<btPersistentManifold, 1> g_manifoldDmaExport;
-
+
-	public:
+	public:
-		SpuContactResult();
+		SpuContactResult();
-		virtual ~SpuContactResult();
+		virtual ~SpuContactResult();
-
+
-		btPersistentManifold*	GetSpuManifold() const
+		btPersistentManifold*	GetSpuManifold() const
-		{
+		{
-			return m_spuManifold;
+			return m_spuManifold;
-		}
+		}
-
+
-		virtual void setShapeIdentifiers(int partId0,int index0,	int partId1,int index1);
+		virtual void setShapeIdentifiers(int partId0,int index0,	int partId1,int index1);
-
+
-		void	setContactInfo(btPersistentManifold* spuManifold, ppu_address_t	manifoldAddress,const btTransform& worldTrans0,const btTransform& worldTrans1, btScalar restitution0,btScalar restitution1, btScalar friction0,btScalar friction01, bool isSwapped);
+		void	setContactInfo(btPersistentManifold* spuManifold, ppu_address_t	manifoldAddress,const btTransform& worldTrans0,const btTransform& worldTrans1, btScalar restitution0,btScalar restitution1, btScalar friction0,btScalar friction01, bool isSwapped);
-
+
-
+
-        void writeDoubleBufferedManifold(btPersistentManifold* lsManifold, btPersistentManifold* mmManifold);
+        void writeDoubleBufferedManifold(btPersistentManifold* lsManifold, btPersistentManifold* mmManifold);
-
+
-        virtual void addContactPoint(const btVector3& normalOnBInWorld,const btPoint3& pointInWorld,btScalar depth);
+        virtual void addContactPoint(const btVector3& normalOnBInWorld,const btPoint3& pointInWorld,float depth);
-
+
-		void flush();
+		void flush();
-};
+};
-
+
-
+
-
+
-#endif //SPU_CONTACT_RESULT2_H
+#endif //SPU_CONTACT_RESULT2_H
-
+

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuConvexPenetrationDepthSolver.h

@@ -22,7 +22,7 @@ subject to the following restrictions:
 
 class btStackAlloc;
 class btIDebugDraw;
-class btVoronoiSimplexSolver;
+class SpuVoronoiSimplexSolver;
 
 #include <LinearMath/btTransform.h>
 #include <LinearMath/btPoint3.h>
@@ -34,7 +34,7 @@ class SpuConvexPenetrationDepthSolver
 public:	
 	
 	virtual ~SpuConvexPenetrationDepthSolver() {};
-	virtual bool calcPenDepth( btVoronoiSimplexSolver& simplexSolver,
+	virtual bool calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,
 	        void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,
             btTransform& transA,const btTransform& transB,
 			btVector3& v, btPoint3& pa, btPoint3& pb,

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuEpaPenetrationDepthSolver.cpp

@@ -13,14 +13,13 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
-#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
-#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
-
 #include "SpuEpaPenetrationDepthSolver.h"
+#include "SpuVoronoiSimplexSolver.h"
+#include "SpuGjkPairDetector.h"
 #include "SpuContactResult.h"
 #include "SpuGjkEpa2.h"
 
-bool SpuEpaPenetrationDepthSolver::calcPenDepth( btVoronoiSimplexSolver& simplexSolver,
+bool SpuEpaPenetrationDepthSolver::calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,
 	        void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,
 		btTransform& transA,const btTransform& transB,
 			btVector3& v, btPoint3& pa, btPoint3& pb,

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuEpaPenetrationDepthSolver.h

@@ -22,7 +22,7 @@ subject to the following restrictions:
 
 class btStackAlloc;
 class btIDebugDraw;
-class btVoronoiSimplexSolver;
+class SpuVoronoiSimplexSolver;
 
 ///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
 ///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.
@@ -30,7 +30,7 @@ class SpuEpaPenetrationDepthSolver : public SpuConvexPenetrationDepthSolver
 {
 public:
 
-	virtual bool calcPenDepth( btVoronoiSimplexSolver& simplexSolver,
+	virtual bool calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,
 	        void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,
             btTransform& transA,const btTransform& transB,
 			btVector3& v, btPoint3& pa, btPoint3& pb,

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGjkPairDetector.cpp

@@ -36,7 +36,7 @@ int gSpuNumGjkChecks = 0;
 
 
 
-SpuGjkPairDetector::SpuGjkPairDetector(void* objectA,void* objectB,int shapeTypeA, int shapeTypeB, float marginA,float marginB,btVoronoiSimplexSolver* simplexSolver, const SpuConvexPenetrationDepthSolver*	penetrationDepthSolver)
+SpuGjkPairDetector::SpuGjkPairDetector(void* objectA,void* objectB,int shapeTypeA, int shapeTypeB, float marginA,float marginB,SpuVoronoiSimplexSolver* simplexSolver, const SpuConvexPenetrationDepthSolver*	penetrationDepthSolver)
 :m_cachedSeparatingAxis(float(0.),float(0.),float(1.)),
 m_penetrationDepthSolver(penetrationDepthSolver),
 m_simplexSolver(simplexSolver),

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGjkPairDetector.h

@@ -24,15 +24,18 @@ subject to the following restrictions:
 
 #include "SpuContactResult.h"
 
-#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+
+#include "SpuVoronoiSimplexSolver.h"
 class SpuConvexPenetrationDepthSolver;
 
 /// btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface
 class SpuGjkPairDetector 
 {
+	
+
 	btVector3	m_cachedSeparatingAxis;
 	const SpuConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
-	btVoronoiSimplexSolver* m_simplexSolver;
+	SpuVoronoiSimplexSolver* m_simplexSolver;
 	void* m_minkowskiA;
 	void* m_minkowskiB;
     int m_shapeTypeA;
@@ -51,7 +54,7 @@ public:
 	int			m_catchDegeneracies;
 
 
-	SpuGjkPairDetector(void* objectA,void* objectB,int m_shapeTypeA, int m_shapeTypeB, float marginA, float marginB, btVoronoiSimplexSolver* simplexSolver, const SpuConvexPenetrationDepthSolver*	penetrationDepthSolver);
+	SpuGjkPairDetector(void* objectA,void* objectB,int m_shapeTypeA, int m_shapeTypeB, float marginA, float marginB, SpuVoronoiSimplexSolver* simplexSolver, const SpuConvexPenetrationDepthSolver*	penetrationDepthSolver);
 	virtual ~SpuGjkPairDetector() {};
 
 	virtual void	getClosestPoints(const SpuClosestPointInput& input,SpuContactResult& output);

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuMinkowskiPenetrationDepthSolver.cpp

@@ -13,15 +13,15 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
-#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
-#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
-
-#include "SpuCollisionShapes.h"
 #include "SpuMinkowskiPenetrationDepthSolver.h"
+#include "SpuVoronoiSimplexSolver.h"
+#include "SpuGjkPairDetector.h"
 #include "SpuContactResult.h"
 #include "SpuPreferredPenetrationDirections.h"
 
 
+#include "SpuCollisionShapes.h"
+
 #define NUM_UNITSPHERE_POINTS 42
 static btVector3	sPenetrationDirections[NUM_UNITSPHERE_POINTS+MAX_PREFERRED_PENETRATION_DIRECTIONS*2] = 
 {
@@ -69,7 +69,7 @@ btVector3(btScalar(-0.425323) , btScalar(0.309011),btScalar(0.850654)),
 btVector3(btScalar(0.162456) , btScalar(0.499995),btScalar(0.850654))
 };
 
-bool SpuMinkowskiPenetrationDepthSolver::calcPenDepth( btVoronoiSimplexSolver& simplexSolver,
+bool SpuMinkowskiPenetrationDepthSolver::calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,
 	        void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,
             btTransform& transA,const btTransform& transB,
 			btVector3& v, btPoint3& pa, btPoint3& pb,
@@ -113,7 +113,7 @@ bool SpuMinkowskiPenetrationDepthSolver::calcPenDepth( btVoronoiSimplexSolver& s
 
 	//just take fixed number of orientation, and sample the penetration depth in that direction
 	btScalar minProj = btScalar(1e30);
-	btVector3 minNorm = btVector3(btScalar(0.0f), btScalar(0.0f), btScalar(0.0f));
+	btVector3 minNorm;
 	btVector3 minVertex;
 	btVector3 minA,minB;
 	btVector3 seperatingAxisInA,seperatingAxisInB;
@@ -291,8 +291,7 @@ bool SpuMinkowskiPenetrationDepthSolver::calcPenDepth( btVoronoiSimplexSolver& s
 	}
 #endif //DEBUG_DRAW
 
-	return false;
+	
-#if 0 //FIXME
 
 	SpuGjkPairDetector gjkdet(convexA,convexB,shapeTypeA,shapeTypeB,marginA,marginB,&simplexSolver,0);
 
@@ -342,7 +341,6 @@ bool SpuMinkowskiPenetrationDepthSolver::calcPenDepth( btVoronoiSimplexSolver& s
 		btAssert (false);
 	}
 	return res.m_hasResult;
-#endif
 }
 
 

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuMinkowskiPenetrationDepthSolver.h

@@ -22,7 +22,7 @@ subject to the following restrictions:
 
 class btStackAlloc;
 class btIDebugDraw;
-class btVoronoiSimplexSolver;
+class SpuVoronoiSimplexSolver;
 
 ///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
 ///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.
@@ -30,7 +30,7 @@ class SpuMinkowskiPenetrationDepthSolver : public SpuConvexPenetrationDepthSolve
 {
 public:
 
-	virtual bool calcPenDepth( btVoronoiSimplexSolver& simplexSolver,
+	virtual bool calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,
 	        void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,
             btTransform& transA,const btTransform& transB,
 			btVector3& v, btPoint3& pa, btPoint3& pb,

Extras/BulletMultiThreaded/SpuRaycastTask/SpuRaycastTask.cpp

@@ -632,7 +632,7 @@ void performRaycastAgainstCompound (RaycastGatheredObjectData* gatheredObjectDat
 void
 performRaycastAgainstConvex (RaycastGatheredObjectData* gatheredObjectData, const SpuRaycastTaskWorkUnit& workUnit, SpuRaycastTaskWorkUnitOut* workUnitOut, RaycastTask_LocalStoreMemory* lsMemPtr)
 {
-	btVoronoiSimplexSolver simplexSolver;
+	SpuVoronoiSimplexSolver simplexSolver;
 
 	btTransform rayFromTrans, rayToTrans;
 	rayFromTrans.setIdentity ();

Extras/BulletMultiThreaded/SpuRaycastTask/SpuSubSimplexConvexCast.cpp

@@ -22,7 +22,7 @@ subject to the following restrictions:
 
 
 SpuSubsimplexRayCast::SpuSubsimplexRayCast (void* shapeB, SpuConvexPolyhedronVertexData* convexDataB, int shapeTypeB, float marginB,
-										    btVoronoiSimplexSolver* simplexSolver)
+										    SpuVoronoiSimplexSolver* simplexSolver)
 	:m_simplexSolver(simplexSolver), m_shapeB(shapeB), m_convexDataB(convexDataB), m_shapeTypeB(shapeTypeB), m_marginB(marginB)
 {
 }

Extras/BulletMultiThreaded/SpuRaycastTask/SpuSubSimplexConvexCast.h

@@ -17,7 +17,7 @@ subject to the following restrictions:
 #ifndef SPU_SUBSIMPLEX_RAY_CAST_H
 #define SPU_SUBSIMPLEX_RAY_CAST_H
 
-#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "../SpuNarrowPhaseCollisionTask/SpuVoronoiSimplexSolver.h"
 #include "../SpuNarrowPhaseCollisionTask/SpuCollisionShapes.h"
 #include "SpuRaycastTask.h"
 
@@ -35,7 +35,7 @@ struct SpuCastResult
 /// Objects should not start in overlap, otherwise results are not defined.
 class SpuSubsimplexRayCast
 {
-	btVoronoiSimplexSolver* m_simplexSolver;
+	SpuVoronoiSimplexSolver* m_simplexSolver;
 	void* m_shapeB;
 	SpuConvexPolyhedronVertexData* m_convexDataB;
 	int m_shapeTypeB;
@@ -43,7 +43,7 @@ class SpuSubsimplexRayCast
 
 public:
 	SpuSubsimplexRayCast (void* shapeB, SpuConvexPolyhedronVertexData* convexDataB, int shapeTypeB, float marginB,
-						  btVoronoiSimplexSolver* simplexSolver);
+						  SpuVoronoiSimplexSolver* simplexSolver);
 
 	//virtual ~btSubsimplexConvexCast();