Bullet Collision Detection & Physics Library
SpuGatheringCollisionTask.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 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.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 #include "SpuGatheringCollisionTask.h"
17 
18 //#define DEBUG_SPU_COLLISION_DETECTION 1
19 #include "../SpuDoubleBuffer.h"
20 
21 #include "../SpuCollisionTaskProcess.h"
22 #include "../SpuGatheringCollisionDispatcher.h" //for SPU_BATCHSIZE_BROADPHASE_PAIRS
23 
24 #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
25 #include "../SpuContactManifoldCollisionAlgorithm.h"
26 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
27 #include "SpuContactResult.h"
28 #include "BulletCollision/CollisionShapes/btOptimizedBvh.h"
29 #include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"
30 #include "BulletCollision/CollisionShapes/btSphereShape.h"
31 #include "BulletCollision/CollisionShapes/btConvexPointCloudShape.h"
32 
33 #include "BulletCollision/CollisionShapes/btCapsuleShape.h"
34 
35 #include "BulletCollision/CollisionShapes/btConvexShape.h"
36 #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
37 #include "BulletCollision/CollisionShapes/btConvexHullShape.h"
38 #include "BulletCollision/CollisionShapes/btCompoundShape.h"
39 
40 #include "SpuMinkowskiPenetrationDepthSolver.h"
41 //#include "SpuEpaPenetrationDepthSolver.h"
42 #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
43 
44 
45 #include "boxBoxDistance.h"
46 #include "BulletMultiThreaded/vectormath2bullet.h"
47 #include "SpuCollisionShapes.h" //definition of SpuConvexPolyhedronVertexData
48 #include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h"
49 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
50 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
51 
52 #ifdef __SPU__
53 #ifndef USE_LIBSPE2
55 //#define USE_SOFTWARE_CACHE 1
56 #endif
57 #endif //__SPU__
58 
59 int gSkippedCol = 0;
60 int gProcessedCol = 0;
61 
64 #if USE_SOFTWARE_CACHE
65 #include <spu_intrinsics.h>
66 #include <sys/spu_thread.h>
67 #include <sys/spu_event.h>
68 #include <stdint.h>
69 #define SPE_CACHE_NWAY 4
70 //#define SPE_CACHE_NSETS 32, 16
71 #define SPE_CACHE_NSETS 8
72 //#define SPE_CACHELINE_SIZE 512
73 #define SPE_CACHELINE_SIZE 128
74 #define SPE_CACHE_SET_TAGID(set) 15
75 #include "../Extras/software_cache/cache/include/spe_cache.h"
77 
78 
79 int g_CacheMisses=0;
80 int g_CacheHits=0;
81 
82 #if 0 // Added to allow cache misses and hits to be tracked, change this to 1 to restore unmodified version
83 #define spe_cache_read(ea) _spe_cache_lookup_xfer_wait_(ea, 0, 1)
84 #else
85 #define spe_cache_read(ea) \
86 ({ \
87  int set, idx, line, byte; \
88  _spe_cache_nway_lookup_(ea, set, idx); \
89  \
90  if (btUnlikely(idx < 0)) { \
91  ++g_CacheMisses; \
92  idx = _spe_cache_miss_(ea, set, -1); \
93  spu_writech(22, SPE_CACHE_SET_TAGMASK(set)); \
94  spu_mfcstat(MFC_TAG_UPDATE_ALL); \
95  } \
96  else \
97  { \
98  ++g_CacheHits; \
99  } \
100  line = _spe_cacheline_num_(set, idx); \
101  byte = _spe_cacheline_byte_offset_(ea); \
102  (void *) &spe_cache_mem[line + byte]; \
103 })
104 
105 #endif
106 
107 #endif // USE_SOFTWARE_CACHE
108 
109 bool gUseEpa = false;
110 
111 #ifdef USE_SN_TUNER
112 #include <LibSN_SPU.h>
113 #endif //USE_SN_TUNER
114 
115 #if defined (__SPU__) && !defined (USE_LIBSPE2)
116 #include <spu_printf.h>
117 #elif defined (USE_LIBSPE2)
118 #define spu_printf(a)
119 #else
120 #define IGNORE_ALIGNMENT 1
121 #include <stdio.h>
122 #include <stdlib.h>
123 #define spu_printf printf
124 
125 #endif
126 
127 //int gNumConvexPoints0=0;
128 
130 ATTRIBUTE_ALIGNED16(struct) CollisionTask_LocalStoreMemory
131 {
134 
135  ATTRIBUTE_ALIGNED16(btBroadphasePair gBroadphasePairsBuffer[SPU_BATCHSIZE_BROADPHASE_PAIRS]);
136  DoubleBuffer<unsigned char, MIDPHASE_WORKUNIT_PAGE_SIZE> g_workUnitTaskBuffers;
137  ATTRIBUTE_ALIGNED16(char gSpuContactManifoldAlgoBuffer [sizeof(SpuContactManifoldCollisionAlgorithm)+16]);
138  ATTRIBUTE_ALIGNED16(char gColObj0Buffer [sizeof(btCollisionObject)+16]);
139  ATTRIBUTE_ALIGNED16(char gColObj1Buffer [sizeof(btCollisionObject)+16]);
141  ATTRIBUTE_ALIGNED16(int spuIndices[16]);
142  btPersistentManifold gPersistentManifoldBuffer;
143  CollisionShape_LocalStoreMemory gCollisionShapes[2];
144  bvhMeshShape_LocalStoreMemory bvhShapeData;
145  ATTRIBUTE_ALIGNED16(SpuConvexPolyhedronVertexData convexVertexData[2]);
146  CompoundShape_LocalStoreMemory compoundShapeData[2];
147 
150  btCollisionObject* m_lsColObj0Ptr;
151  btCollisionObject* m_lsColObj1Ptr;
152  btBroadphasePair* m_pairsPointer;
153  btPersistentManifold* m_lsManifoldPtr;
154  SpuContactManifoldCollisionAlgorithm* m_lsCollisionAlgorithmPtr;
155 
156  bool needsDmaPutContactManifoldAlgo;
157 
158  btCollisionObject* getColObj0()
159  {
160  return m_lsColObj0Ptr;
161  }
162  btCollisionObject* getColObj1()
163  {
164  return m_lsColObj1Ptr;
165  }
166 
167 
168  btBroadphasePair* getBroadphasePairPtr()
169  {
170  return m_pairsPointer;
171  }
172 
173  SpuContactManifoldCollisionAlgorithm* getlocalCollisionAlgorithm()
174  {
175  return m_lsCollisionAlgorithmPtr;
176  }
177 
178  btPersistentManifold* getContactManifoldPtr()
179  {
180  return m_lsManifoldPtr;
181  }
182 };
183 
184 
185 #if defined(__CELLOS_LV2__) || defined(USE_LIBSPE2)
186 
187 ATTRIBUTE_ALIGNED16(CollisionTask_LocalStoreMemory gLocalStoreMemory);
188 
189 void* createCollisionLocalStoreMemory()
190 {
191  return &gLocalStoreMemory;
192 }
193 void deleteCollisionLocalStoreMemory()
194 {
195 }
196 #else
197 
198 btAlignedObjectArray<CollisionTask_LocalStoreMemory*> sLocalStorePointers;
199 
200 void* createCollisionLocalStoreMemory()
201 {
202  CollisionTask_LocalStoreMemory* localStore = (CollisionTask_LocalStoreMemory*)btAlignedAlloc( sizeof(CollisionTask_LocalStoreMemory),16);
203  sLocalStorePointers.push_back(localStore);
204  return localStore;
205 }
206 
207 void deleteCollisionLocalStoreMemory()
208 {
209  for (int i=0;i<sLocalStorePointers.size();i++)
210  {
211  btAlignedFree(sLocalStorePointers[i]);
212  }
213  sLocalStorePointers.clear();
214 }
215 
216 #endif
217 
218 void ProcessSpuConvexConvexCollision(SpuCollisionPairInput* wuInput, CollisionTask_LocalStoreMemory* lsMemPtr, SpuContactResult& spuContacts);
219 
220 
221 SIMD_FORCE_INLINE void small_cache_read(void* buffer, ppu_address_t ea, size_t size)
222 {
223 #if USE_SOFTWARE_CACHE
224  // Check for alignment requirements. We need to make sure the entire request fits within one cache line,
225  // so the first and last bytes should fall on the same cache line
226  btAssert((ea & ~SPE_CACHELINE_MASK) == ((ea + size - 1) & ~SPE_CACHELINE_MASK));
227 
228  void* ls = spe_cache_read(ea);
229  memcpy(buffer, ls, size);
230 #else
231  stallingUnalignedDmaSmallGet(buffer,ea,size);
232 #endif
233 }
234 
235 SIMD_FORCE_INLINE void small_cache_read_triple( void* ls0, ppu_address_t ea0,
236  void* ls1, ppu_address_t ea1,
237  void* ls2, ppu_address_t ea2,
238  size_t size)
239 {
240  btAssert(size<16);
241  ATTRIBUTE_ALIGNED16(char tmpBuffer0[32]);
242  ATTRIBUTE_ALIGNED16(char tmpBuffer1[32]);
243  ATTRIBUTE_ALIGNED16(char tmpBuffer2[32]);
244 
245  uint32_t i;
246 
247 
249  char* localStore0 = (char*)ls0;
250  uint32_t last4BitsOffset = ea0 & 0x0f;
251  char* tmpTarget0 = tmpBuffer0 + last4BitsOffset;
252 #ifdef __SPU__
253  cellDmaSmallGet(tmpTarget0,ea0,size,DMA_TAG(1),0,0);
254 #else
255  tmpTarget0 = (char*)cellDmaSmallGetReadOnly(tmpTarget0,ea0,size,DMA_TAG(1),0,0);
256 #endif
257 
258 
259  char* localStore1 = (char*)ls1;
260  last4BitsOffset = ea1 & 0x0f;
261  char* tmpTarget1 = tmpBuffer1 + last4BitsOffset;
262 #ifdef __SPU__
263  cellDmaSmallGet(tmpTarget1,ea1,size,DMA_TAG(1),0,0);
264 #else
265  tmpTarget1 = (char*)cellDmaSmallGetReadOnly(tmpTarget1,ea1,size,DMA_TAG(1),0,0);
266 #endif
267 
268  char* localStore2 = (char*)ls2;
269  last4BitsOffset = ea2 & 0x0f;
270  char* tmpTarget2 = tmpBuffer2 + last4BitsOffset;
271 #ifdef __SPU__
272  cellDmaSmallGet(tmpTarget2,ea2,size,DMA_TAG(1),0,0);
273 #else
274  tmpTarget2 = (char*)cellDmaSmallGetReadOnly(tmpTarget2,ea2,size,DMA_TAG(1),0,0);
275 #endif
276 
277 
278  cellDmaWaitTagStatusAll( DMA_MASK(1) );
279 
280  //this is slowish, perhaps memcpy on SPU is smarter?
281  for (i=0; btLikely( i<size );i++)
282  {
283  localStore0[i] = tmpTarget0[i];
284  localStore1[i] = tmpTarget1[i];
285  localStore2[i] = tmpTarget2[i];
286  }
287 
288 
289 }
290 
291 
292 
293 
294 ATTRIBUTE_ALIGNED16(class) spuNodeCallback : public btNodeOverlapCallback
295 {
296  SpuCollisionPairInput* m_wuInput;
297  SpuContactResult& m_spuContacts;
298  CollisionTask_LocalStoreMemory* m_lsMemPtr;
299  ATTRIBUTE_ALIGNED16(btTriangleShape) m_tmpTriangleShape;
300 
301  ATTRIBUTE_ALIGNED16(btVector3 spuTriangleVertices[3]);
302  ATTRIBUTE_ALIGNED16(btScalar spuUnscaledVertex[4]);
303 
304 
305 
306 public:
307  spuNodeCallback(SpuCollisionPairInput* wuInput, CollisionTask_LocalStoreMemory* lsMemPtr,SpuContactResult& spuContacts)
308  : m_wuInput(wuInput),
309  m_spuContacts(spuContacts),
310  m_lsMemPtr(lsMemPtr)
311  {
312  }
313 
314  virtual void processNode(int subPart, int triangleIndex)
315  {
318 
319  // spu_printf("processNode with triangleIndex %d\n",triangleIndex);
320 
321  if (m_lsMemPtr->bvhShapeData.gIndexMesh.m_indexType == PHY_SHORT)
322  {
323  unsigned short int* indexBasePtr = (unsigned short int*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexBase+triangleIndex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexStride);
324  ATTRIBUTE_ALIGNED16(unsigned short int tmpIndices[3]);
325 
326  small_cache_read_triple(&tmpIndices[0],(ppu_address_t)&indexBasePtr[0],
327  &tmpIndices[1],(ppu_address_t)&indexBasePtr[1],
328  &tmpIndices[2],(ppu_address_t)&indexBasePtr[2],
329  sizeof(unsigned short int));
330 
331  m_lsMemPtr->spuIndices[0] = int(tmpIndices[0]);
332  m_lsMemPtr->spuIndices[1] = int(tmpIndices[1]);
333  m_lsMemPtr->spuIndices[2] = int(tmpIndices[2]);
334  } else
335  {
336  unsigned int* indexBasePtr = (unsigned int*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexBase+triangleIndex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_triangleIndexStride);
337 
338  small_cache_read_triple(&m_lsMemPtr->spuIndices[0],(ppu_address_t)&indexBasePtr[0],
339  &m_lsMemPtr->spuIndices[1],(ppu_address_t)&indexBasePtr[1],
340  &m_lsMemPtr->spuIndices[2],(ppu_address_t)&indexBasePtr[2],
341  sizeof(int));
342  }
343 
344  // spu_printf("SPU index0=%d ,",spuIndices[0]);
345  // spu_printf("SPU index1=%d ,",spuIndices[1]);
346  // spu_printf("SPU index2=%d ,",spuIndices[2]);
347  // spu_printf("SPU: indexBasePtr=%llx\n",indexBasePtr);
348 
349  const btVector3& meshScaling = m_lsMemPtr->bvhShapeData.gTriangleMeshInterfacePtr->getScaling();
350  for (int j=2;btLikely( j>=0 );j--)
351  {
352  int graphicsindex = m_lsMemPtr->spuIndices[j];
353 
354  // spu_printf("SPU index=%d ,",graphicsindex);
355  btScalar* graphicsbasePtr = (btScalar*)(m_lsMemPtr->bvhShapeData.gIndexMesh.m_vertexBase+graphicsindex*m_lsMemPtr->bvhShapeData.gIndexMesh.m_vertexStride);
356  // spu_printf("SPU graphicsbasePtr=%llx\n",graphicsbasePtr);
357 
358 
360 
361  //another DMA for each vertex
362  small_cache_read_triple(&spuUnscaledVertex[0],(ppu_address_t)&graphicsbasePtr[0],
363  &spuUnscaledVertex[1],(ppu_address_t)&graphicsbasePtr[1],
364  &spuUnscaledVertex[2],(ppu_address_t)&graphicsbasePtr[2],
365  sizeof(btScalar));
366 
367  m_tmpTriangleShape.getVertexPtr(j).setValue(spuUnscaledVertex[0]*meshScaling.getX(),
368  spuUnscaledVertex[1]*meshScaling.getY(),
369  spuUnscaledVertex[2]*meshScaling.getZ());
370 
371  // spu_printf("SPU:triangle vertices:%f,%f,%f\n",spuTriangleVertices[j].x(),spuTriangleVertices[j].y(),spuTriangleVertices[j].z());
372  }
373 
374 
375  SpuCollisionPairInput triangleConcaveInput(*m_wuInput);
376 // triangleConcaveInput.m_spuCollisionShapes[1] = &spuTriangleVertices[0];
377  triangleConcaveInput.m_spuCollisionShapes[1] = &m_tmpTriangleShape;
378  triangleConcaveInput.m_shapeType1 = TRIANGLE_SHAPE_PROXYTYPE;
379 
380  m_spuContacts.setShapeIdentifiersB(subPart,triangleIndex);
381 
382  // m_spuContacts.flush();
383 
384  ProcessSpuConvexConvexCollision(&triangleConcaveInput, m_lsMemPtr,m_spuContacts);
386  // m_spuContacts.flush();
387  }
388 
389 };
390 
391 
392 
393 void btConvexPlaneCollideSingleContact (SpuCollisionPairInput* wuInput,CollisionTask_LocalStoreMemory* lsMemPtr,SpuContactResult& spuContacts)
394 {
395 
396  btConvexShape* convexShape = (btConvexShape*) wuInput->m_spuCollisionShapes[0];
397  btStaticPlaneShape* planeShape = (btStaticPlaneShape*) wuInput->m_spuCollisionShapes[1];
398 
399  bool hasCollision = false;
400  const btVector3& planeNormal = planeShape->getPlaneNormal();
401  const btScalar& planeConstant = planeShape->getPlaneConstant();
402 
403 
404  btTransform convexWorldTransform = wuInput->m_worldTransform0;
405  btTransform convexInPlaneTrans;
406  convexInPlaneTrans= wuInput->m_worldTransform1.inverse() * convexWorldTransform;
407  btTransform planeInConvex;
408  planeInConvex= convexWorldTransform.inverse() * wuInput->m_worldTransform1;
409 
410  //btVector3 vtx = convexShape->localGetSupportVertexWithoutMarginNonVirtual(planeInConvex.getBasis()*-planeNormal);
411  btVector3 vtx = convexShape->localGetSupportVertexNonVirtual(planeInConvex.getBasis()*-planeNormal);
412 
413  btVector3 vtxInPlane = convexInPlaneTrans(vtx);
414  btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant);
415 
416  btVector3 vtxInPlaneProjected = vtxInPlane - distance*planeNormal;
417  btVector3 vtxInPlaneWorld = wuInput->m_worldTransform1 * vtxInPlaneProjected;
418 
419  hasCollision = distance < lsMemPtr->getContactManifoldPtr()->getContactBreakingThreshold();
420  //resultOut->setPersistentManifold(m_manifoldPtr);
421  if (hasCollision)
422  {
424  btVector3 normalOnSurfaceB =wuInput->m_worldTransform1.getBasis() * planeNormal;
425  btVector3 pOnB = vtxInPlaneWorld;
426  spuContacts.addContactPoint(normalOnSurfaceB,pOnB,distance);
427  }
428 }
429 
430 void ProcessConvexPlaneSpuCollision(SpuCollisionPairInput* wuInput, CollisionTask_LocalStoreMemory* lsMemPtr, SpuContactResult& spuContacts)
431 {
432 
433  register int dmaSize = 0;
434  register ppu_address_t dmaPpuAddress2;
435  btPersistentManifold* manifold = (btPersistentManifold*)wuInput->m_persistentManifoldPtr;
436 
438  ATTRIBUTE_ALIGNED16(char convexHullShape0[sizeof(btConvexHullShape)]);
439  ATTRIBUTE_ALIGNED16(char convexHullShape1[sizeof(btConvexHullShape)]);
440 
441  if ( btLikely( wuInput->m_shapeType0== CONVEX_HULL_SHAPE_PROXYTYPE ) )
442  {
443  // spu_printf("SPU: DMA btConvexHullShape\n");
444 
445  dmaSize = sizeof(btConvexHullShape);
446  dmaPpuAddress2 = wuInput->m_collisionShapes[0];
447 
448  cellDmaGet(&convexHullShape0, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
449  //cellDmaWaitTagStatusAll(DMA_MASK(1));
450  }
451 
452  if ( btLikely( wuInput->m_shapeType1 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
453  {
454  // spu_printf("SPU: DMA btConvexHullShape\n");
455  dmaSize = sizeof(btConvexHullShape);
456  dmaPpuAddress2 = wuInput->m_collisionShapes[1];
457  cellDmaGet(&convexHullShape1, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
458  //cellDmaWaitTagStatusAll(DMA_MASK(1));
459  }
460 
461  if ( btLikely( wuInput->m_shapeType0 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
462  {
463  cellDmaWaitTagStatusAll(DMA_MASK(1));
464  dmaConvexVertexData (&lsMemPtr->convexVertexData[0], (btConvexHullShape*)&convexHullShape0);
465  lsMemPtr->convexVertexData[0].gSpuConvexShapePtr = wuInput->m_spuCollisionShapes[0];
466  }
467 
468 
469  if ( btLikely( wuInput->m_shapeType1 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
470  {
471  cellDmaWaitTagStatusAll(DMA_MASK(1));
472  dmaConvexVertexData (&lsMemPtr->convexVertexData[1], (btConvexHullShape*)&convexHullShape1);
473  lsMemPtr->convexVertexData[1].gSpuConvexShapePtr = wuInput->m_spuCollisionShapes[1];
474  }
475 
476 
477  btConvexPointCloudShape cpc0,cpc1;
478 
479  if ( btLikely( wuInput->m_shapeType0 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
480  {
481  cellDmaWaitTagStatusAll(DMA_MASK(2));
482  lsMemPtr->convexVertexData[0].gConvexPoints = &lsMemPtr->convexVertexData[0].g_convexPointBuffer[0];
483  btConvexHullShape* ch = (btConvexHullShape*)wuInput->m_spuCollisionShapes[0];
484  const btVector3& localScaling = ch->getLocalScalingNV();
485  cpc0.setPoints(lsMemPtr->convexVertexData[0].gConvexPoints,lsMemPtr->convexVertexData[0].gNumConvexPoints,false,localScaling);
486  wuInput->m_spuCollisionShapes[0] = &cpc0;
487  }
488 
489  if ( btLikely( wuInput->m_shapeType1 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
490  {
491  cellDmaWaitTagStatusAll(DMA_MASK(2));
492  lsMemPtr->convexVertexData[1].gConvexPoints = &lsMemPtr->convexVertexData[1].g_convexPointBuffer[0];
493  btConvexHullShape* ch = (btConvexHullShape*)wuInput->m_spuCollisionShapes[1];
494  const btVector3& localScaling = ch->getLocalScalingNV();
495  cpc1.setPoints(lsMemPtr->convexVertexData[1].gConvexPoints,lsMemPtr->convexVertexData[1].gNumConvexPoints,false,localScaling);
496  wuInput->m_spuCollisionShapes[1] = &cpc1;
497 
498  }
499 
500 
501 // const btConvexShape* shape0Ptr = (const btConvexShape*)wuInput->m_spuCollisionShapes[0];
502 // const btConvexShape* shape1Ptr = (const btConvexShape*)wuInput->m_spuCollisionShapes[1];
503 // int shapeType0 = wuInput->m_shapeType0;
504 // int shapeType1 = wuInput->m_shapeType1;
505  float marginA = wuInput->m_collisionMargin0;
506  float marginB = wuInput->m_collisionMargin1;
507 
508  SpuClosestPointInput cpInput;
509  cpInput.m_convexVertexData[0] = &lsMemPtr->convexVertexData[0];
510  cpInput.m_convexVertexData[1] = &lsMemPtr->convexVertexData[1];
511  cpInput.m_transformA = wuInput->m_worldTransform0;
512  cpInput.m_transformB = wuInput->m_worldTransform1;
513  float sumMargin = (marginA+marginB+lsMemPtr->getContactManifoldPtr()->getContactBreakingThreshold());
514  cpInput.m_maximumDistanceSquared = sumMargin * sumMargin;
515 
516  ppu_address_t manifoldAddress = (ppu_address_t)manifold;
517 
518  btPersistentManifold* spuManifold=lsMemPtr->getContactManifoldPtr();
519  //spuContacts.setContactInfo(spuManifold,manifoldAddress,wuInput->m_worldTransform0,wuInput->m_worldTransform1,wuInput->m_isSwapped);
520  spuContacts.setContactInfo(spuManifold,manifoldAddress,lsMemPtr->getColObj0()->getWorldTransform(),
521  lsMemPtr->getColObj1()->getWorldTransform(),
522  lsMemPtr->getColObj0()->getRestitution(),lsMemPtr->getColObj1()->getRestitution(),
523  lsMemPtr->getColObj0()->getFriction(),lsMemPtr->getColObj1()->getFriction(),
524  wuInput->m_isSwapped);
525 
526 
527  btConvexPlaneCollideSingleContact(wuInput,lsMemPtr,spuContacts);
528 
529 
530 
531 
532 }
533 
534 
535 
536 
540 void ProcessConvexConcaveSpuCollision(SpuCollisionPairInput* wuInput, CollisionTask_LocalStoreMemory* lsMemPtr, SpuContactResult& spuContacts)
541 {
542  //order: first collision shape is convex, second concave. m_isSwapped is true, if the original order was opposite
543 
544  btBvhTriangleMeshShape* trimeshShape = (btBvhTriangleMeshShape*)wuInput->m_spuCollisionShapes[1];
545  //need the mesh interface, for access to triangle vertices
546  dmaBvhShapeData (&lsMemPtr->bvhShapeData, trimeshShape);
547 
548  btVector3 aabbMin(-1,-400,-1);
549  btVector3 aabbMax(1,400,1);
550 
551 
552  //recalc aabbs
553  btTransform convexInTriangleSpace;
554  convexInTriangleSpace = wuInput->m_worldTransform1.inverse() * wuInput->m_worldTransform0;
555  btConvexInternalShape* convexShape = (btConvexInternalShape*)wuInput->m_spuCollisionShapes[0];
556 
557  computeAabb (aabbMin, aabbMax, convexShape, wuInput->m_collisionShapes[0], wuInput->m_shapeType0, convexInTriangleSpace);
558 
559 
560  //CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
561  //convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
562 
563  // btScalar extraMargin = collisionMarginTriangle;
564  // btVector3 extra(extraMargin,extraMargin,extraMargin);
565  // aabbMax += extra;
566  // aabbMin -= extra;
567 
569  unsigned short int quantizedQueryAabbMin[3];
570  unsigned short int quantizedQueryAabbMax[3];
571  lsMemPtr->bvhShapeData.getOptimizedBvh()->quantizeWithClamp(quantizedQueryAabbMin,aabbMin,0);
572  lsMemPtr->bvhShapeData.getOptimizedBvh()->quantizeWithClamp(quantizedQueryAabbMax,aabbMax,1);
573 
574  QuantizedNodeArray& nodeArray = lsMemPtr->bvhShapeData.getOptimizedBvh()->getQuantizedNodeArray();
575  //spu_printf("SPU: numNodes = %d\n",nodeArray.size());
576 
577  BvhSubtreeInfoArray& subTrees = lsMemPtr->bvhShapeData.getOptimizedBvh()->getSubtreeInfoArray();
578 
579 
580  spuNodeCallback nodeCallback(wuInput,lsMemPtr,spuContacts);
581  IndexedMeshArray& indexArray = lsMemPtr->bvhShapeData.gTriangleMeshInterfacePtr->getIndexedMeshArray();
582  //spu_printf("SPU:indexArray.size() = %d\n",indexArray.size());
583 
584  // spu_printf("SPU: numSubTrees = %d\n",subTrees.size());
585  //not likely to happen
586  if (subTrees.size() && indexArray.size() == 1)
587  {
589  dmaBvhIndexedMesh (&lsMemPtr->bvhShapeData.gIndexMesh, indexArray, 0 /* index into indexArray */, 1 /* dmaTag */);
590  cellDmaWaitTagStatusAll(DMA_MASK(1));
591 
592  //display the headers
593  int numBatch = subTrees.size();
594  for (int i=0;i<numBatch;)
595  {
596  //@todo- can reorder DMA transfers for less stall
597  int remaining = subTrees.size() - i;
598  int nextBatch = remaining < MAX_SPU_SUBTREE_HEADERS ? remaining : MAX_SPU_SUBTREE_HEADERS;
599 
600  dmaBvhSubTreeHeaders (&lsMemPtr->bvhShapeData.gSubtreeHeaders[0], (ppu_address_t)(&subTrees[i]), nextBatch, 1);
601  cellDmaWaitTagStatusAll(DMA_MASK(1));
602 
603 
604  // spu_printf("nextBatch = %d\n",nextBatch);
605 
606  for (int j=0;j<nextBatch;j++)
607  {
608  const btBvhSubtreeInfo& subtree = lsMemPtr->bvhShapeData.gSubtreeHeaders[j];
609 
610  unsigned int overlap = spuTestQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,subtree.m_quantizedAabbMin,subtree.m_quantizedAabbMax);
611  if (overlap)
612  {
613  btAssert(subtree.m_subtreeSize);
614 
615  //dma the actual nodes of this subtree
616  dmaBvhSubTreeNodes (&lsMemPtr->bvhShapeData.gSubtreeNodes[0], subtree, nodeArray, 2);
617  cellDmaWaitTagStatusAll(DMA_MASK(2));
618 
619  /* Walk this subtree */
620  spuWalkStacklessQuantizedTree(&nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax,
621  &lsMemPtr->bvhShapeData.gSubtreeNodes[0],
622  0,
623  subtree.m_subtreeSize);
624  }
625  // spu_printf("subtreeSize = %d\n",gSubtreeHeaders[j].m_subtreeSize);
626  }
627 
628  // unsigned short int m_quantizedAabbMin[3];
629  // unsigned short int m_quantizedAabbMax[3];
630  // int m_rootNodeIndex;
631  // int m_subtreeSize;
632  i+=nextBatch;
633  }
634 
635  //pre-fetch first tree, then loop and double buffer
636  }
637 
638 }
639 
640 
641 #define MAX_DEGENERATE_STATS 15
642 int stats[MAX_DEGENERATE_STATS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
643 int degenerateStats[MAX_DEGENERATE_STATS]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
644 
645 
649 void ProcessSpuConvexConvexCollision(SpuCollisionPairInput* wuInput, CollisionTask_LocalStoreMemory* lsMemPtr, SpuContactResult& spuContacts)
650 {
651  register int dmaSize;
652  register ppu_address_t dmaPpuAddress2;
653 
654 #ifdef DEBUG_SPU_COLLISION_DETECTION
655  //spu_printf("SPU: ProcessSpuConvexConvexCollision\n");
656 #endif //DEBUG_SPU_COLLISION_DETECTION
657  //CollisionShape* shape0 = (CollisionShape*)wuInput->m_collisionShapes[0];
658  //CollisionShape* shape1 = (CollisionShape*)wuInput->m_collisionShapes[1];
659  btPersistentManifold* manifold = (btPersistentManifold*)wuInput->m_persistentManifoldPtr;
660 
661  bool genericGjk = true;
662 
663  if (genericGjk)
664  {
665  //try generic GJK
666 
667 
668 
669  //SpuConvexPenetrationDepthSolver* penetrationSolver=0;
670  btVoronoiSimplexSolver simplexSolver;
671  btGjkEpaPenetrationDepthSolver epaPenetrationSolver2;
672 
673  btConvexPenetrationDepthSolver* penetrationSolver = &epaPenetrationSolver2;
674 
675  //SpuMinkowskiPenetrationDepthSolver minkowskiPenetrationSolver;
676 #ifdef ENABLE_EPA
677  if (gUseEpa)
678  {
679  penetrationSolver = &epaPenetrationSolver2;
680  } else
681 #endif
682  {
683  //penetrationSolver = &minkowskiPenetrationSolver;
684  }
685 
686 
688  ATTRIBUTE_ALIGNED16(char convexHullShape0[sizeof(btConvexHullShape)]);
689  ATTRIBUTE_ALIGNED16(char convexHullShape1[sizeof(btConvexHullShape)]);
690 
691  if ( btLikely( wuInput->m_shapeType0== CONVEX_HULL_SHAPE_PROXYTYPE ) )
692  {
693  // spu_printf("SPU: DMA btConvexHullShape\n");
694 
695  dmaSize = sizeof(btConvexHullShape);
696  dmaPpuAddress2 = wuInput->m_collisionShapes[0];
697 
698  cellDmaGet(&convexHullShape0, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
699  //cellDmaWaitTagStatusAll(DMA_MASK(1));
700  }
701 
702  if ( btLikely( wuInput->m_shapeType1 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
703  {
704  // spu_printf("SPU: DMA btConvexHullShape\n");
705  dmaSize = sizeof(btConvexHullShape);
706  dmaPpuAddress2 = wuInput->m_collisionShapes[1];
707  cellDmaGet(&convexHullShape1, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
708  //cellDmaWaitTagStatusAll(DMA_MASK(1));
709  }
710 
711  if ( btLikely( wuInput->m_shapeType0 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
712  {
713  cellDmaWaitTagStatusAll(DMA_MASK(1));
714  dmaConvexVertexData (&lsMemPtr->convexVertexData[0], (btConvexHullShape*)&convexHullShape0);
715  lsMemPtr->convexVertexData[0].gSpuConvexShapePtr = wuInput->m_spuCollisionShapes[0];
716  }
717 
718 
719  if ( btLikely( wuInput->m_shapeType1 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
720  {
721  cellDmaWaitTagStatusAll(DMA_MASK(1));
722  dmaConvexVertexData (&lsMemPtr->convexVertexData[1], (btConvexHullShape*)&convexHullShape1);
723  lsMemPtr->convexVertexData[1].gSpuConvexShapePtr = wuInput->m_spuCollisionShapes[1];
724  }
725 
726 
727  btConvexPointCloudShape cpc0,cpc1;
728 
729  if ( btLikely( wuInput->m_shapeType0 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
730  {
731  cellDmaWaitTagStatusAll(DMA_MASK(2));
732  lsMemPtr->convexVertexData[0].gConvexPoints = &lsMemPtr->convexVertexData[0].g_convexPointBuffer[0];
733  btConvexHullShape* ch = (btConvexHullShape*)wuInput->m_spuCollisionShapes[0];
734  const btVector3& localScaling = ch->getLocalScalingNV();
735  cpc0.setPoints(lsMemPtr->convexVertexData[0].gConvexPoints,lsMemPtr->convexVertexData[0].gNumConvexPoints,false,localScaling);
736  wuInput->m_spuCollisionShapes[0] = &cpc0;
737  }
738 
739  if ( btLikely( wuInput->m_shapeType1 == CONVEX_HULL_SHAPE_PROXYTYPE ) )
740  {
741  cellDmaWaitTagStatusAll(DMA_MASK(2));
742  lsMemPtr->convexVertexData[1].gConvexPoints = &lsMemPtr->convexVertexData[1].g_convexPointBuffer[0];
743  btConvexHullShape* ch = (btConvexHullShape*)wuInput->m_spuCollisionShapes[1];
744  const btVector3& localScaling = ch->getLocalScalingNV();
745  cpc1.setPoints(lsMemPtr->convexVertexData[1].gConvexPoints,lsMemPtr->convexVertexData[1].gNumConvexPoints,false,localScaling);
746  wuInput->m_spuCollisionShapes[1] = &cpc1;
747 
748  }
749 
750 
751  const btConvexShape* shape0Ptr = (const btConvexShape*)wuInput->m_spuCollisionShapes[0];
752  const btConvexShape* shape1Ptr = (const btConvexShape*)wuInput->m_spuCollisionShapes[1];
753  int shapeType0 = wuInput->m_shapeType0;
754  int shapeType1 = wuInput->m_shapeType1;
755  float marginA = wuInput->m_collisionMargin0;
756  float marginB = wuInput->m_collisionMargin1;
757 
758  SpuClosestPointInput cpInput;
759  cpInput.m_convexVertexData[0] = &lsMemPtr->convexVertexData[0];
760  cpInput.m_convexVertexData[1] = &lsMemPtr->convexVertexData[1];
761  cpInput.m_transformA = wuInput->m_worldTransform0;
762  cpInput.m_transformB = wuInput->m_worldTransform1;
763  float sumMargin = (marginA+marginB+lsMemPtr->getContactManifoldPtr()->getContactBreakingThreshold());
764  cpInput.m_maximumDistanceSquared = sumMargin * sumMargin;
765 
766  ppu_address_t manifoldAddress = (ppu_address_t)manifold;
767 
768  btPersistentManifold* spuManifold=lsMemPtr->getContactManifoldPtr();
769  //spuContacts.setContactInfo(spuManifold,manifoldAddress,wuInput->m_worldTransform0,wuInput->m_worldTransform1,wuInput->m_isSwapped);
770  spuContacts.setContactInfo(spuManifold,manifoldAddress,lsMemPtr->getColObj0()->getWorldTransform(),
771  lsMemPtr->getColObj1()->getWorldTransform(),
772  lsMemPtr->getColObj0()->getRestitution(),lsMemPtr->getColObj1()->getRestitution(),
773  lsMemPtr->getColObj0()->getFriction(),lsMemPtr->getColObj1()->getFriction(),
774  wuInput->m_isSwapped);
775 
776  {
777  btGjkPairDetector gjk(shape0Ptr,shape1Ptr,shapeType0,shapeType1,marginA,marginB,&simplexSolver,penetrationSolver);//&vsSolver,penetrationSolver);
778  gjk.getClosestPoints(cpInput,spuContacts,0);//,debugDraw);
779 
780  btAssert(gjk.m_lastUsedMethod <MAX_DEGENERATE_STATS);
781  stats[gjk.m_lastUsedMethod]++;
782  btAssert(gjk.m_degenerateSimplex <MAX_DEGENERATE_STATS);
783  degenerateStats[gjk.m_degenerateSimplex]++;
784 
785 #ifdef USE_SEPDISTANCE_UTIL
786  btScalar sepDist = gjk.getCachedSeparatingDistance()+spuManifold->getContactBreakingThreshold();
787  lsMemPtr->getlocalCollisionAlgorithm()->m_sepDistance.initSeparatingDistance(gjk.getCachedSeparatingAxis(),sepDist,wuInput->m_worldTransform0,wuInput->m_worldTransform1);
788  lsMemPtr->needsDmaPutContactManifoldAlgo = true;
789 #endif //USE_SEPDISTANCE_UTIL
790 
791  }
792 
793  }
794 
795 
796 }
797 
798 
799 template<typename T> void DoSwap(T& a, T& b)
800 {
801  char tmp[sizeof(T)];
802  memcpy(tmp, &a, sizeof(T));
803  memcpy(&a, &b, sizeof(T));
804  memcpy(&b, tmp, sizeof(T));
805 }
806 
807 SIMD_FORCE_INLINE void dmaAndSetupCollisionObjects(SpuCollisionPairInput& collisionPairInput, CollisionTask_LocalStoreMemory& lsMem)
808 {
809  register int dmaSize;
810  register ppu_address_t dmaPpuAddress2;
811 
812  dmaSize = sizeof(btCollisionObject);//btTransform);
813  dmaPpuAddress2 = /*collisionPairInput.m_isSwapped ? (ppu_address_t)lsMem.gProxyPtr1->m_clientObject :*/ (ppu_address_t)lsMem.getlocalCollisionAlgorithm()->getCollisionObject0();
814  lsMem.m_lsColObj0Ptr = (btCollisionObject*)cellDmaGetReadOnly(&lsMem.gColObj0Buffer, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
815 
816  dmaSize = sizeof(btCollisionObject);//btTransform);
817  dmaPpuAddress2 = /*collisionPairInput.m_isSwapped ? (ppu_address_t)lsMem.gProxyPtr0->m_clientObject :*/ (ppu_address_t)lsMem.getlocalCollisionAlgorithm()->getCollisionObject1();
818  lsMem.m_lsColObj1Ptr = (btCollisionObject*)cellDmaGetReadOnly(&lsMem.gColObj1Buffer, dmaPpuAddress2 , dmaSize, DMA_TAG(2), 0, 0);
819 
820  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
821 
822  btCollisionObject* ob0 = lsMem.getColObj0();
823  btCollisionObject* ob1 = lsMem.getColObj1();
824 
825  collisionPairInput.m_worldTransform0 = ob0->getWorldTransform();
826  collisionPairInput.m_worldTransform1 = ob1->getWorldTransform();
827 }
828 
829 
830 
831 void handleCollisionPair(SpuCollisionPairInput& collisionPairInput, CollisionTask_LocalStoreMemory& lsMem,
832  SpuContactResult &spuContacts,
833  ppu_address_t collisionShape0Ptr, void* collisionShape0Loc,
834  ppu_address_t collisionShape1Ptr, void* collisionShape1Loc, bool dmaShapes = true)
835 {
836 
837  if (btBroadphaseProxy::isConvex(collisionPairInput.m_shapeType0)
838  && btBroadphaseProxy::isConvex(collisionPairInput.m_shapeType1))
839  {
840  if (dmaShapes)
841  {
842  dmaCollisionShape (collisionShape0Loc, collisionShape0Ptr, 1, collisionPairInput.m_shapeType0);
843  dmaCollisionShape (collisionShape1Loc, collisionShape1Ptr, 2, collisionPairInput.m_shapeType1);
844  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
845  }
846 
847  btConvexInternalShape* spuConvexShape0 = (btConvexInternalShape*)collisionShape0Loc;
848  btConvexInternalShape* spuConvexShape1 = (btConvexInternalShape*)collisionShape1Loc;
849 
850  btVector3 dim0 = spuConvexShape0->getImplicitShapeDimensions();
851  btVector3 dim1 = spuConvexShape1->getImplicitShapeDimensions();
852 
853  collisionPairInput.m_primitiveDimensions0 = dim0;
854  collisionPairInput.m_primitiveDimensions1 = dim1;
855  collisionPairInput.m_collisionShapes[0] = collisionShape0Ptr;
856  collisionPairInput.m_collisionShapes[1] = collisionShape1Ptr;
857  collisionPairInput.m_spuCollisionShapes[0] = spuConvexShape0;
858  collisionPairInput.m_spuCollisionShapes[1] = spuConvexShape1;
859  ProcessSpuConvexConvexCollision(&collisionPairInput,&lsMem,spuContacts);
860  }
861  else if (btBroadphaseProxy::isCompound(collisionPairInput.m_shapeType0) &&
862  btBroadphaseProxy::isCompound(collisionPairInput.m_shapeType1))
863  {
864  //snPause();
865 
866  dmaCollisionShape (collisionShape0Loc, collisionShape0Ptr, 1, collisionPairInput.m_shapeType0);
867  dmaCollisionShape (collisionShape1Loc, collisionShape1Ptr, 2, collisionPairInput.m_shapeType1);
868  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
869 
870  // Both are compounds, do N^2 CD for now
872 
873  btCompoundShape* spuCompoundShape0 = (btCompoundShape*)collisionShape0Loc;
874  btCompoundShape* spuCompoundShape1 = (btCompoundShape*)collisionShape1Loc;
875 
876  dmaCompoundShapeInfo (&lsMem.compoundShapeData[0], spuCompoundShape0, 1);
877  dmaCompoundShapeInfo (&lsMem.compoundShapeData[1], spuCompoundShape1, 2);
878  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
879 
880 
881  dmaCompoundSubShapes (&lsMem.compoundShapeData[0], spuCompoundShape0, 1);
882  cellDmaWaitTagStatusAll(DMA_MASK(1));
883  dmaCompoundSubShapes (&lsMem.compoundShapeData[1], spuCompoundShape1, 1);
884  cellDmaWaitTagStatusAll(DMA_MASK(1));
885 
886  int childShapeCount0 = spuCompoundShape0->getNumChildShapes();
887  btAssert(childShapeCount0< MAX_SPU_COMPOUND_SUBSHAPES);
888  int childShapeCount1 = spuCompoundShape1->getNumChildShapes();
889  btAssert(childShapeCount1< MAX_SPU_COMPOUND_SUBSHAPES);
890 
891  // Start the N^2
892  for (int i = 0; i < childShapeCount0; ++i)
893  {
894  btCompoundShapeChild& childShape0 = lsMem.compoundShapeData[0].gSubshapes[i];
895  btAssert(!btBroadphaseProxy::isCompound(childShape0.m_childShapeType));
896 
897  for (int j = 0; j < childShapeCount1; ++j)
898  {
899  btCompoundShapeChild& childShape1 = lsMem.compoundShapeData[1].gSubshapes[j];
900  btAssert(!btBroadphaseProxy::isCompound(childShape1.m_childShapeType));
901 
902 
903  /* Create a new collision pair input struct using the two child shapes */
904  SpuCollisionPairInput cinput (collisionPairInput);
905 
906  cinput.m_worldTransform0 = collisionPairInput.m_worldTransform0 * childShape0.m_transform;
907  cinput.m_shapeType0 = childShape0.m_childShapeType;
908  cinput.m_collisionMargin0 = childShape0.m_childMargin;
909 
910  cinput.m_worldTransform1 = collisionPairInput.m_worldTransform1 * childShape1.m_transform;
911  cinput.m_shapeType1 = childShape1.m_childShapeType;
912  cinput.m_collisionMargin1 = childShape1.m_childMargin;
913  /* Recursively call handleCollisionPair () with new collision pair input */
914 
915  handleCollisionPair(cinput, lsMem, spuContacts,
916  (ppu_address_t)childShape0.m_childShape, lsMem.compoundShapeData[0].gSubshapeShape[i],
917  (ppu_address_t)childShape1.m_childShape, lsMem.compoundShapeData[1].gSubshapeShape[j], false);
918  }
919  }
920  }
921  else if (btBroadphaseProxy::isCompound(collisionPairInput.m_shapeType0) )
922  {
923  //snPause();
924 
925  dmaCollisionShape (collisionShape0Loc, collisionShape0Ptr, 1, collisionPairInput.m_shapeType0);
926  dmaCollisionShape (collisionShape1Loc, collisionShape1Ptr, 2, collisionPairInput.m_shapeType1);
927  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
928 
929  // object 0 compound, object 1 non-compound
930  btCompoundShape* spuCompoundShape = (btCompoundShape*)collisionShape0Loc;
931  dmaCompoundShapeInfo (&lsMem.compoundShapeData[0], spuCompoundShape, 1);
932  cellDmaWaitTagStatusAll(DMA_MASK(1));
933 
934  int childShapeCount = spuCompoundShape->getNumChildShapes();
935  btAssert(childShapeCount< MAX_SPU_COMPOUND_SUBSHAPES);
936 
937  for (int i = 0; i < childShapeCount; ++i)
938  {
939  btCompoundShapeChild& childShape = lsMem.compoundShapeData[0].gSubshapes[i];
940  btAssert(!btBroadphaseProxy::isCompound(childShape.m_childShapeType));
941  // Dma the child shape
942  dmaCollisionShape (&lsMem.compoundShapeData[0].gSubshapeShape[i], (ppu_address_t)childShape.m_childShape, 1, childShape.m_childShapeType);
943  cellDmaWaitTagStatusAll(DMA_MASK(1));
944 
945  SpuCollisionPairInput cinput (collisionPairInput);
946  cinput.m_worldTransform0 = collisionPairInput.m_worldTransform0 * childShape.m_transform;
947  cinput.m_shapeType0 = childShape.m_childShapeType;
948  cinput.m_collisionMargin0 = childShape.m_childMargin;
949 
950  handleCollisionPair(cinput, lsMem, spuContacts,
951  (ppu_address_t)childShape.m_childShape, lsMem.compoundShapeData[0].gSubshapeShape[i],
952  collisionShape1Ptr, collisionShape1Loc, false);
953  }
954  }
955  else if (btBroadphaseProxy::isCompound(collisionPairInput.m_shapeType1) )
956  {
957  //snPause();
958 
959  dmaCollisionShape (collisionShape0Loc, collisionShape0Ptr, 1, collisionPairInput.m_shapeType0);
960  dmaCollisionShape (collisionShape1Loc, collisionShape1Ptr, 2, collisionPairInput.m_shapeType1);
961  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
962  // object 0 non-compound, object 1 compound
963  btCompoundShape* spuCompoundShape = (btCompoundShape*)collisionShape1Loc;
964  dmaCompoundShapeInfo (&lsMem.compoundShapeData[0], spuCompoundShape, 1);
965  cellDmaWaitTagStatusAll(DMA_MASK(1));
966 
967  int childShapeCount = spuCompoundShape->getNumChildShapes();
968  btAssert(childShapeCount< MAX_SPU_COMPOUND_SUBSHAPES);
969 
970 
971  for (int i = 0; i < childShapeCount; ++i)
972  {
973  btCompoundShapeChild& childShape = lsMem.compoundShapeData[0].gSubshapes[i];
974  btAssert(!btBroadphaseProxy::isCompound(childShape.m_childShapeType));
975  // Dma the child shape
976  dmaCollisionShape (&lsMem.compoundShapeData[0].gSubshapeShape[i], (ppu_address_t)childShape.m_childShape, 1, childShape.m_childShapeType);
977  cellDmaWaitTagStatusAll(DMA_MASK(1));
978 
979  SpuCollisionPairInput cinput (collisionPairInput);
980  cinput.m_worldTransform1 = collisionPairInput.m_worldTransform1 * childShape.m_transform;
981  cinput.m_shapeType1 = childShape.m_childShapeType;
982  cinput.m_collisionMargin1 = childShape.m_childMargin;
983  handleCollisionPair(cinput, lsMem, spuContacts,
984  collisionShape0Ptr, collisionShape0Loc,
985  (ppu_address_t)childShape.m_childShape, lsMem.compoundShapeData[0].gSubshapeShape[i], false);
986  }
987 
988  }
989  else
990  {
991  //a non-convex shape is involved
992  bool handleConvexConcave = false;
993 
994  //snPause();
995 
996  if (btBroadphaseProxy::isConcave(collisionPairInput.m_shapeType0) &&
997  btBroadphaseProxy::isConvex(collisionPairInput.m_shapeType1))
998  {
999  // Swap stuff
1000  DoSwap(collisionShape0Ptr, collisionShape1Ptr);
1001  DoSwap(collisionShape0Loc, collisionShape1Loc);
1002  DoSwap(collisionPairInput.m_shapeType0, collisionPairInput.m_shapeType1);
1003  DoSwap(collisionPairInput.m_worldTransform0, collisionPairInput.m_worldTransform1);
1004  DoSwap(collisionPairInput.m_collisionMargin0, collisionPairInput.m_collisionMargin1);
1005 
1006  collisionPairInput.m_isSwapped = true;
1007  }
1008 
1009  if (btBroadphaseProxy::isConvex(collisionPairInput.m_shapeType0)&&
1010  btBroadphaseProxy::isConcave(collisionPairInput.m_shapeType1))
1011  {
1012  handleConvexConcave = true;
1013  }
1014  if (handleConvexConcave)
1015  {
1016  if (dmaShapes)
1017  {
1018  dmaCollisionShape (collisionShape0Loc, collisionShape0Ptr, 1, collisionPairInput.m_shapeType0);
1019  dmaCollisionShape (collisionShape1Loc, collisionShape1Ptr, 2, collisionPairInput.m_shapeType1);
1020  cellDmaWaitTagStatusAll(DMA_MASK(1) | DMA_MASK(2));
1021  }
1022 
1023  if (collisionPairInput.m_shapeType1 == STATIC_PLANE_PROXYTYPE)
1024  {
1025  btConvexInternalShape* spuConvexShape0 = (btConvexInternalShape*)collisionShape0Loc;
1026  btStaticPlaneShape* planeShape= (btStaticPlaneShape*)collisionShape1Loc;
1027 
1028  btVector3 dim0 = spuConvexShape0->getImplicitShapeDimensions();
1029  collisionPairInput.m_primitiveDimensions0 = dim0;
1030  collisionPairInput.m_collisionShapes[0] = collisionShape0Ptr;
1031  collisionPairInput.m_collisionShapes[1] = collisionShape1Ptr;
1032  collisionPairInput.m_spuCollisionShapes[0] = spuConvexShape0;
1033  collisionPairInput.m_spuCollisionShapes[1] = planeShape;
1034 
1035  ProcessConvexPlaneSpuCollision(&collisionPairInput,&lsMem,spuContacts);
1036  } else
1037  {
1038  btConvexInternalShape* spuConvexShape0 = (btConvexInternalShape*)collisionShape0Loc;
1039  btBvhTriangleMeshShape* trimeshShape = (btBvhTriangleMeshShape*)collisionShape1Loc;
1040 
1041  btVector3 dim0 = spuConvexShape0->getImplicitShapeDimensions();
1042  collisionPairInput.m_primitiveDimensions0 = dim0;
1043  collisionPairInput.m_collisionShapes[0] = collisionShape0Ptr;
1044  collisionPairInput.m_collisionShapes[1] = collisionShape1Ptr;
1045  collisionPairInput.m_spuCollisionShapes[0] = spuConvexShape0;
1046  collisionPairInput.m_spuCollisionShapes[1] = trimeshShape;
1047 
1048  ProcessConvexConcaveSpuCollision(&collisionPairInput,&lsMem,spuContacts);
1049  }
1050  }
1051 
1052  }
1053 
1054  spuContacts.flush();
1055 
1056 }
1057 
1058 
1059 void processCollisionTask(void* userPtr, void* lsMemPtr)
1060 {
1061 
1062  SpuGatherAndProcessPairsTaskDesc* taskDescPtr = (SpuGatherAndProcessPairsTaskDesc*)userPtr;
1063  SpuGatherAndProcessPairsTaskDesc& taskDesc = *taskDescPtr;
1064  CollisionTask_LocalStoreMemory* colMemPtr = (CollisionTask_LocalStoreMemory*)lsMemPtr;
1065  CollisionTask_LocalStoreMemory& lsMem = *(colMemPtr);
1066 
1067  gUseEpa = taskDesc.m_useEpa;
1068 
1069  // spu_printf("taskDescPtr=%llx\n",taskDescPtr);
1070 
1071  SpuContactResult spuContacts;
1072 
1074 
1075  ppu_address_t dmaInPtr = taskDesc.m_inPairPtr;
1076  unsigned int numPages = taskDesc.numPages;
1077  unsigned int numOnLastPage = taskDesc.numOnLastPage;
1078 
1079  // prefetch first set of inputs and wait
1080  lsMem.g_workUnitTaskBuffers.init();
1081 
1082  unsigned int nextNumOnPage = (numPages > 1)? MIDPHASE_NUM_WORKUNITS_PER_PAGE : numOnLastPage;
1083  lsMem.g_workUnitTaskBuffers.backBufferDmaGet(dmaInPtr, nextNumOnPage*sizeof(SpuGatherAndProcessWorkUnitInput), DMA_TAG(3));
1084  dmaInPtr += MIDPHASE_WORKUNIT_PAGE_SIZE;
1085 
1086 
1087  register unsigned char *inputPtr;
1088  register unsigned int numOnPage;
1089  register unsigned int j;
1090  SpuGatherAndProcessWorkUnitInput* wuInputs;
1091  register int dmaSize;
1092  register ppu_address_t dmaPpuAddress;
1093  register ppu_address_t dmaPpuAddress2;
1094 
1095  int numPairs;
1096  register int p;
1097  SpuCollisionPairInput collisionPairInput;
1098 
1099  for (unsigned int i = 0; btLikely(i < numPages); i++)
1100  {
1101 
1102  // wait for back buffer dma and swap buffers
1103  inputPtr = lsMem.g_workUnitTaskBuffers.swapBuffers();
1104 
1105  // number on current page is number prefetched last iteration
1106  numOnPage = nextNumOnPage;
1107 
1108 
1109  // prefetch next set of inputs
1110 #if MIDPHASE_NUM_WORKUNIT_PAGES > 2
1111  if ( btLikely( i < numPages-1 ) )
1112 #else
1113  if ( btUnlikely( i < numPages-1 ) )
1114 #endif
1115  {
1116  nextNumOnPage = (i == numPages-2)? numOnLastPage : MIDPHASE_NUM_WORKUNITS_PER_PAGE;
1117  lsMem.g_workUnitTaskBuffers.backBufferDmaGet(dmaInPtr, nextNumOnPage*sizeof(SpuGatherAndProcessWorkUnitInput), DMA_TAG(3));
1118  dmaInPtr += MIDPHASE_WORKUNIT_PAGE_SIZE;
1119  }
1120 
1121  wuInputs = reinterpret_cast<SpuGatherAndProcessWorkUnitInput *>(inputPtr);
1122 
1123 
1124  for (j = 0; btLikely( j < numOnPage ); j++)
1125  {
1126 #ifdef DEBUG_SPU_COLLISION_DETECTION
1127  // printMidphaseInput(&wuInputs[j]);
1128 #endif //DEBUG_SPU_COLLISION_DETECTION
1129 
1130 
1131  numPairs = wuInputs[j].m_endIndex - wuInputs[j].m_startIndex;
1132 
1133  if ( btLikely( numPairs ) )
1134  {
1135  dmaSize = numPairs*sizeof(btBroadphasePair);
1136  dmaPpuAddress = wuInputs[j].m_pairArrayPtr+wuInputs[j].m_startIndex * sizeof(btBroadphasePair);
1137  lsMem.m_pairsPointer = (btBroadphasePair*)cellDmaGetReadOnly(&lsMem.gBroadphasePairsBuffer, dmaPpuAddress , dmaSize, DMA_TAG(1), 0, 0);
1138  cellDmaWaitTagStatusAll(DMA_MASK(1));
1139 
1140 
1141  for (p=0;p<numPairs;p++)
1142  {
1143 
1144  //for each broadphase pair, do something
1145 
1146  btBroadphasePair& pair = lsMem.getBroadphasePairPtr()[p];
1147 #ifdef DEBUG_SPU_COLLISION_DETECTION
1148  spu_printf("pair->m_userInfo = %d\n",pair.m_userInfo);
1149  spu_printf("pair->m_algorithm = %d\n",pair.m_algorithm);
1150  spu_printf("pair->m_pProxy0 = %d\n",pair.m_pProxy0);
1151  spu_printf("pair->m_pProxy1 = %d\n",pair.m_pProxy1);
1152 #endif //DEBUG_SPU_COLLISION_DETECTION
1153 
1154  if (pair.m_internalTmpValue == 2 && pair.m_algorithm && pair.m_pProxy0 && pair.m_pProxy1)
1155  {
1156  dmaSize = sizeof(SpuContactManifoldCollisionAlgorithm);
1157  dmaPpuAddress2 = (ppu_address_t)pair.m_algorithm;
1158  lsMem.m_lsCollisionAlgorithmPtr = (SpuContactManifoldCollisionAlgorithm*)cellDmaGetReadOnly(&lsMem.gSpuContactManifoldAlgoBuffer, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
1159 
1160  cellDmaWaitTagStatusAll(DMA_MASK(1));
1161 
1162  lsMem.needsDmaPutContactManifoldAlgo = false;
1163 
1164  collisionPairInput.m_persistentManifoldPtr = (ppu_address_t) lsMem.getlocalCollisionAlgorithm()->getContactManifoldPtr();
1165  collisionPairInput.m_isSwapped = false;
1166 
1167  if (1)
1168  {
1169 
1171 
1172 
1173 #ifdef DEBUG_SPU_COLLISION_DETECTION
1174  // spu_printf("SPU collisionPairInput->m_shapeType0 = %d\n",collisionPairInput->m_shapeType0);
1175  // spu_printf("SPU collisionPairInput->m_shapeType1 = %d\n",collisionPairInput->m_shapeType1);
1176 #endif //DEBUG_SPU_COLLISION_DETECTION
1177 
1178 
1179  dmaSize = sizeof(btPersistentManifold);
1180 
1181  dmaPpuAddress2 = collisionPairInput.m_persistentManifoldPtr;
1182  lsMem.m_lsManifoldPtr = (btPersistentManifold*)cellDmaGetReadOnly(&lsMem.gPersistentManifoldBuffer, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
1183 
1184  collisionPairInput.m_shapeType0 = lsMem.getlocalCollisionAlgorithm()->getShapeType0();
1185  collisionPairInput.m_shapeType1 = lsMem.getlocalCollisionAlgorithm()->getShapeType1();
1186  collisionPairInput.m_collisionMargin0 = lsMem.getlocalCollisionAlgorithm()->getCollisionMargin0();
1187  collisionPairInput.m_collisionMargin1 = lsMem.getlocalCollisionAlgorithm()->getCollisionMargin1();
1188 
1189 
1190 
1191  //??cellDmaWaitTagStatusAll(DMA_MASK(1));
1192 
1193 
1194  if (1)
1195  {
1196  //snPause();
1197 
1198  // Get the collision objects
1199  dmaAndSetupCollisionObjects(collisionPairInput, lsMem);
1200 
1201  if (lsMem.getColObj0()->isActive() || lsMem.getColObj1()->isActive())
1202  {
1203 
1204  lsMem.needsDmaPutContactManifoldAlgo = true;
1205 #ifdef USE_SEPDISTANCE_UTIL
1206  lsMem.getlocalCollisionAlgorithm()->m_sepDistance.updateSeparatingDistance(collisionPairInput.m_worldTransform0,collisionPairInput.m_worldTransform1);
1207 #endif //USE_SEPDISTANCE_UTIL
1208 
1209 #define USE_DEDICATED_BOX_BOX 1
1210 #ifdef USE_DEDICATED_BOX_BOX
1211  bool boxbox = ((lsMem.getlocalCollisionAlgorithm()->getShapeType0()==BOX_SHAPE_PROXYTYPE)&&
1212  (lsMem.getlocalCollisionAlgorithm()->getShapeType1()==BOX_SHAPE_PROXYTYPE));
1213  if (boxbox)
1214  {
1215  //spu_printf("boxbox dist = %f\n",distance);
1216  btPersistentManifold* spuManifold=lsMem.getContactManifoldPtr();
1217  btPersistentManifold* manifold = (btPersistentManifold*)collisionPairInput.m_persistentManifoldPtr;
1218  ppu_address_t manifoldAddress = (ppu_address_t)manifold;
1219 
1220  spuContacts.setContactInfo(spuManifold,manifoldAddress,lsMem.getColObj0()->getWorldTransform(),
1221  lsMem.getColObj1()->getWorldTransform(),
1222  lsMem.getColObj0()->getRestitution(),lsMem.getColObj1()->getRestitution(),
1223  lsMem.getColObj0()->getFriction(),lsMem.getColObj1()->getFriction(),
1224  collisionPairInput.m_isSwapped);
1225 
1226 
1227  //float distance=0.f;
1228  btVector3 normalInB;
1229 
1230 
1231  if (
1232 #ifdef USE_SEPDISTANCE_UTIL
1233  lsMem.getlocalCollisionAlgorithm()->m_sepDistance.getConservativeSeparatingDistance()<=0.f
1234 #else
1235  1
1236 #endif
1237  )
1238  {
1239 //#define USE_PE_BOX_BOX 1
1240 #ifdef USE_PE_BOX_BOX
1241  {
1242 
1243  //getCollisionMargin0
1244  btScalar margin0 = lsMem.getlocalCollisionAlgorithm()->getCollisionMargin0();
1245  btScalar margin1 = lsMem.getlocalCollisionAlgorithm()->getCollisionMargin1();
1246  btVector3 shapeDim0 = lsMem.getlocalCollisionAlgorithm()->getShapeDimensions0()+btVector3(margin0,margin0,margin0);
1247  btVector3 shapeDim1 = lsMem.getlocalCollisionAlgorithm()->getShapeDimensions1()+btVector3(margin1,margin1,margin1);
1248 /*
1249  //Box boxA(shapeDim0.getX(),shapeDim0.getY(),shapeDim0.getZ());
1250  vmVector3 vmPos0 = getVmVector3(collisionPairInput.m_worldTransform0.getOrigin());
1251  vmVector3 vmPos1 = getVmVector3(collisionPairInput.m_worldTransform1.getOrigin());
1252  vmMatrix3 vmMatrix0 = getVmMatrix3(collisionPairInput.m_worldTransform0.getBasis());
1253  vmMatrix3 vmMatrix1 = getVmMatrix3(collisionPairInput.m_worldTransform1.getBasis());
1254 
1255  vmTransform3 transformA(vmMatrix0,vmPos0);
1256  Box boxB(shapeDim1.getX(),shapeDim1.getY(),shapeDim1.getZ());
1257  vmTransform3 transformB(vmMatrix1,vmPos1);
1258  BoxPoint resultClosestBoxPointA;
1259  BoxPoint resultClosestBoxPointB;
1260  vmVector3 resultNormal;
1261  */
1262 
1263 #ifdef USE_SEPDISTANCE_UTIL
1264  float distanceThreshold = FLT_MAX
1265 #else
1266  //float distanceThreshold = 0.f;
1267 #endif
1268 
1269 
1270  vmVector3 n;
1271  Box boxA;
1272  vmVector3 hA(shapeDim0.getX(),shapeDim0.getY(),shapeDim0.getZ());
1273  vmVector3 hB(shapeDim1.getX(),shapeDim1.getY(),shapeDim1.getZ());
1274  boxA.mHalf= hA;
1275  vmTransform3 trA;
1276  trA.setTranslation(getVmVector3(collisionPairInput.m_worldTransform0.getOrigin()));
1277  trA.setUpper3x3(getVmMatrix3(collisionPairInput.m_worldTransform0.getBasis()));
1278  Box boxB;
1279  boxB.mHalf = hB;
1280  vmTransform3 trB;
1281  trB.setTranslation(getVmVector3(collisionPairInput.m_worldTransform1.getOrigin()));
1282  trB.setUpper3x3(getVmMatrix3(collisionPairInput.m_worldTransform1.getBasis()));
1283 
1284  float distanceThreshold = spuManifold->getContactBreakingThreshold();//0.001f;
1285 
1286 
1287  BoxPoint ptA,ptB;
1288  float dist = boxBoxDistance(n, ptA, ptB,
1289  boxA, trA, boxB, trB,
1290  distanceThreshold );
1291 
1292 
1293 // float distance = boxBoxDistance(resultNormal,resultClosestBoxPointA,resultClosestBoxPointB, boxA, transformA, boxB,transformB,distanceThreshold);
1294 
1295  normalInB = -getBtVector3(n);//resultNormal);
1296 
1297  //if(dist < distanceThreshold)//spuManifold->getContactBreakingThreshold())
1298  if(dist < spuManifold->getContactBreakingThreshold())
1299  {
1300  btVector3 pointOnB = collisionPairInput.m_worldTransform1(getBtVector3(ptB.localPoint));
1301 
1302  spuContacts.addContactPoint(
1303  normalInB,
1304  pointOnB,
1305  dist);
1306  }
1307  }
1308 #else
1309  {
1310 
1311  btScalar margin0 = lsMem.getlocalCollisionAlgorithm()->getCollisionMargin0();
1312  btScalar margin1 = lsMem.getlocalCollisionAlgorithm()->getCollisionMargin1();
1313  btVector3 shapeDim0 = lsMem.getlocalCollisionAlgorithm()->getShapeDimensions0()+btVector3(margin0,margin0,margin0);
1314  btVector3 shapeDim1 = lsMem.getlocalCollisionAlgorithm()->getShapeDimensions1()+btVector3(margin1,margin1,margin1);
1315 
1316 
1317  btBoxShape box0(shapeDim0);
1318  btBoxShape box1(shapeDim1);
1319 
1320  struct SpuBridgeContactCollector : public btDiscreteCollisionDetectorInterface::Result
1321  {
1322  SpuContactResult& m_spuContacts;
1323 
1324  virtual void setShapeIdentifiersA(int partId0,int index0)
1325  {
1326  m_spuContacts.setShapeIdentifiersA(partId0,index0);
1327  }
1328  virtual void setShapeIdentifiersB(int partId1,int index1)
1329  {
1330  m_spuContacts.setShapeIdentifiersB(partId1,index1);
1331  }
1332  virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
1333  {
1334  m_spuContacts.addContactPoint(normalOnBInWorld,pointInWorld,depth);
1335  }
1336 
1337  SpuBridgeContactCollector(SpuContactResult& spuContacts)
1338  :m_spuContacts(spuContacts)
1339  {
1340 
1341  }
1342  };
1343 
1344  SpuBridgeContactCollector bridgeOutput(spuContacts);
1345 
1346  btDiscreteCollisionDetectorInterface::ClosestPointInput input;
1347  input.m_maximumDistanceSquared = BT_LARGE_FLOAT;
1348  input.m_transformA = collisionPairInput.m_worldTransform0;
1349  input.m_transformB = collisionPairInput.m_worldTransform1;
1350 
1351  btBoxBoxDetector detector(&box0,&box1);
1352 
1353  detector.getClosestPoints(input,bridgeOutput,0);
1354 
1355  }
1356 #endif //USE_PE_BOX_BOX
1357 
1358  lsMem.needsDmaPutContactManifoldAlgo = true;
1359 #ifdef USE_SEPDISTANCE_UTIL
1360  btScalar sepDist2 = distance+spuManifold->getContactBreakingThreshold();
1361  lsMem.getlocalCollisionAlgorithm()->m_sepDistance.initSeparatingDistance(normalInB,sepDist2,collisionPairInput.m_worldTransform0,collisionPairInput.m_worldTransform1);
1362 #endif //USE_SEPDISTANCE_UTIL
1363  gProcessedCol++;
1364  } else
1365  {
1366  gSkippedCol++;
1367  }
1368 
1369  spuContacts.flush();
1370 
1371 
1372  } else
1373 #endif //USE_DEDICATED_BOX_BOX
1374  {
1375  if (
1376 #ifdef USE_SEPDISTANCE_UTIL
1377  lsMem.getlocalCollisionAlgorithm()->m_sepDistance.getConservativeSeparatingDistance()<=0.f
1378 #else
1379  1
1380 #endif //USE_SEPDISTANCE_UTIL
1381  )
1382  {
1383  handleCollisionPair(collisionPairInput, lsMem, spuContacts,
1384  (ppu_address_t)lsMem.getColObj0()->getCollisionShape(), &lsMem.gCollisionShapes[0].collisionShape,
1385  (ppu_address_t)lsMem.getColObj1()->getCollisionShape(), &lsMem.gCollisionShapes[1].collisionShape);
1386  } else
1387  {
1388  //spu_printf("boxbox dist = %f\n",distance);
1389  btPersistentManifold* spuManifold=lsMem.getContactManifoldPtr();
1390  btPersistentManifold* manifold = (btPersistentManifold*)collisionPairInput.m_persistentManifoldPtr;
1391  ppu_address_t manifoldAddress = (ppu_address_t)manifold;
1392 
1393  spuContacts.setContactInfo(spuManifold,manifoldAddress,lsMem.getColObj0()->getWorldTransform(),
1394  lsMem.getColObj1()->getWorldTransform(),
1395  lsMem.getColObj0()->getRestitution(),lsMem.getColObj1()->getRestitution(),
1396  lsMem.getColObj0()->getFriction(),lsMem.getColObj1()->getFriction(),
1397  collisionPairInput.m_isSwapped);
1398 
1399  spuContacts.flush();
1400  }
1401  }
1402 
1403  }
1404 
1405  }
1406  }
1407 
1408 #ifdef USE_SEPDISTANCE_UTIL
1409 #if defined (__SPU__) || defined (USE_LIBSPE2)
1410  if (lsMem.needsDmaPutContactManifoldAlgo)
1411  {
1412  dmaSize = sizeof(SpuContactManifoldCollisionAlgorithm);
1413  dmaPpuAddress2 = (ppu_address_t)pair.m_algorithm;
1414  cellDmaLargePut(&lsMem.gSpuContactManifoldAlgoBuffer, dmaPpuAddress2 , dmaSize, DMA_TAG(1), 0, 0);
1415  cellDmaWaitTagStatusAll(DMA_MASK(1));
1416  }
1417 #endif
1418 #endif //#ifdef USE_SEPDISTANCE_UTIL
1419 
1420  }
1421  }
1422  }
1423  } //end for (j = 0; j < numOnPage; j++)
1424 
1425  }// for
1426 
1427 
1428 
1429  return;
1430 }
1431 
1432 
CollisionTask_LocalStoreMemory::getColObj0
btCollisionObject * getColObj0()
Definition: SpuGatheringCollisionTask.cpp:158
dmaCompoundShapeInfo
void dmaCompoundShapeInfo(CompoundShape_LocalStoreMemory *compoundShapeLocation, btCompoundShape *spuCompoundShape, uint32_t dmaTag)
Definition: SpuCollisionShapes.cpp:238
CollisionTask_LocalStoreMemory::gColObj1Buffer
char gColObj1Buffer[sizeof(btCollisionObject)+16]
Definition: SpuGatheringCollisionTask.cpp:139
dmaAndSetupCollisionObjects
void dmaAndSetupCollisionObjects(SpuCollisionPairInput &collisionPairInput, CollisionTask_LocalStoreMemory &lsMem)
Definition: SpuGatheringCollisionTask.cpp:807
btConvexInternalShape::getLocalScalingNV
const btVector3 & getLocalScalingNV() const
Definition: btConvexInternalShape.h:104
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:54
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:276
computeAabb
void computeAabb(btVector3 &aabbMin, btVector3 &aabbMax, btConvexInternalShape *convexShape, ppu_address_t convexShapePtr, int shapeType, const btTransform &xform)
not supported on IBM SDK, until we fix the alignment of btVector3
Definition: SpuCollisionShapes.cpp:32
CollisionTask_LocalStoreMemory::bvhShapeData
bvhMeshShape_LocalStoreMemory bvhShapeData
Definition: SpuGatheringCollisionTask.cpp:144
CollisionTask_LocalStoreMemory::gSpuContactManifoldAlgoBuffer
char gSpuContactManifoldAlgoBuffer[sizeof(SpuContactManifoldCollisionAlgorithm)+16]
Definition: SpuGatheringCollisionTask.cpp:137
BT_LARGE_FLOAT
#define BT_LARGE_FLOAT
Definition: btScalar.h:268
btQuantizedBvh::quantizeWithClamp
void quantizeWithClamp(unsigned short *out, const btVector3 &point2, int isMax) const
Definition: btQuantizedBvh.h:419
CollisionTask_LocalStoreMemory::gBroadphasePairsBuffer
btBroadphasePair gBroadphasePairsBuffer[128]
This CollisionTask_LocalStoreMemory is mainly used for the SPU version, using explicit DMA Other plat...
Definition: SpuGatheringCollisionTask.cpp:135
CollisionTask_LocalStoreMemory::getlocalCollisionAlgorithm
SpuContactManifoldCollisionAlgorithm * getlocalCollisionAlgorithm()
Definition: SpuGatheringCollisionTask.cpp:173
SpuCollisionPairInput::m_persistentManifoldPtr
ppu_address_t m_persistentManifoldPtr
Definition: SpuContactResult.h:43
BoxPoint::localPoint
vmPoint3 localPoint
Definition: Box.h:98
btBoxBoxDetector
btBoxBoxDetector wraps the ODE box-box collision detector re-distributed under the Zlib license with ...
Definition: btBoxBoxDetector.h:29
Vectormath::Aos::Transform3::setTranslation
Transform3 & setTranslation(const Vector3 &translateVec)
Definition: neon/mat_aos.h:1362
bvhMeshShape_LocalStoreMemory::gSubtreeHeaders
btBvhSubtreeInfo gSubtreeHeaders[32]
Definition: SpuCollisionShapes.h:79
cellDmaGet
int cellDmaGet(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)
Definition: SpuFakeDma.cpp:173
btAlignedObjectArray
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
Definition: btAlignedObjectArray.h:47
Vectormath::Aos::dist
float dist(const Point3 &pnt0, const Point3 &pnt1)
Definition: neon/vec_aos.h:1395
btPersistentManifold::getContactBreakingThreshold
btScalar getContactBreakingThreshold() const
Definition: btPersistentManifold.cpp:240
dmaCompoundSubShapes
void dmaCompoundSubShapes(CompoundShape_LocalStoreMemory *compoundShapeLocation, btCompoundShape *spuCompoundShape, uint32_t dmaTag)
Definition: SpuCollisionShapes.cpp:248
spuNodeCallback::m_lsMemPtr
CollisionTask_LocalStoreMemory * m_lsMemPtr
Definition: SpuGatheringCollisionTask.cpp:298
btConvexPenetrationDepthSolver
ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.
Definition: btConvexPenetrationDepthSolver.h:26
btGjkPairDetector::getCachedSeparatingDistance
btScalar getCachedSeparatingDistance() const
Definition: btGjkPairDetector.h:84
CollisionTask_LocalStoreMemory::g_workUnitTaskBuffers
DoubleBuffer< unsigned char, MIDPHASE_WORKUNIT_PAGE_SIZE > g_workUnitTaskBuffers
Definition: SpuGatheringCollisionTask.cpp:136
gUseEpa
bool gUseEpa
software caching
Definition: SpuGatheringCollisionTask.cpp:109
CollisionTask_LocalStoreMemory::getBroadphasePairPtr
btBroadphasePair * getBroadphasePairPtr()
Definition: SpuGatheringCollisionTask.cpp:168
SpuCollisionPairInput::m_worldTransform0
btTransform m_worldTransform0
Definition: SpuContactResult.h:51
SpuCollisionPairInput::m_worldTransform1
btTransform m_worldTransform1
Definition: SpuContactResult.h:52
btConvexInternalShape
The btConvexInternalShape is an internal base class, shared by most convex shape implementations.
Definition: btConvexInternalShape.h:29
CollisionTask_LocalStoreMemory::gPersistentManifoldBuffer
btPersistentManifold gPersistentManifoldBuffer
Definition: SpuGatheringCollisionTask.cpp:142
spuNodeCallback::m_wuInput
SpuCollisionPairInput * m_wuInput
Definition: SpuGatheringCollisionTask.cpp:296
ppu_address_t
uint32_t ppu_address_t
Definition: PpuAddressSpace.h:33
SpuGatherAndProcessPairsTaskDesc
Task Description for SPU collision detection.
Definition: SpuGatheringCollisionTask.h:24
SpuCollisionPairInput::m_primitiveDimensions0
btVector3 m_primitiveDimensions0
Definition: SpuContactResult.h:44
size
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:51
DMA_MASK
#define DMA_MASK(a)
Definition: SpuFakeDma.h:113
btAssert
#define btAssert(x)
Definition: btScalar.h:101
btStridingMeshInterface::getScaling
const btVector3 & getScaling() const
Definition: btStridingMeshInterface.h:88
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:58
dmaBvhSubTreeHeaders
void dmaBvhSubTreeHeaders(btBvhSubtreeInfo *subTreeHeaders, ppu_address_t subTreePtr, int batchSize, uint32_t dmaTag)
Definition: SpuCollisionShapes.cpp:140
spuNodeCallback::m_spuContacts
SpuContactResult & m_spuContacts
Definition: SpuGatheringCollisionTask.cpp:297
SPU_BATCHSIZE_BROADPHASE_PAIRS
#define SPU_BATCHSIZE_BROADPHASE_PAIRS
Tuning value to optimized SPU utilization Too small value means Task overhead is large compared to co...
Definition: SpuGatheringCollisionDispatcher.h:27
btBroadphaseProxy::isCompound
static bool isCompound(int proxyType)
Definition: btBroadphaseProxy.h:154
btCompoundShapeChild::m_childShape
btCollisionShape * m_childShape
Definition: btCompoundShape.h:35
btConvexPlaneCollideSingleContact
void btConvexPlaneCollideSingleContact(SpuCollisionPairInput *wuInput, CollisionTask_LocalStoreMemory *lsMemPtr, SpuContactResult &spuContacts)
Definition: SpuGatheringCollisionTask.cpp:393
SpuContactResult
SpuContactResult exports the contact points using double-buffered DMA transfers, only when needed So ...
Definition: SpuContactResult.h:66
DMA_TAG
#define DMA_TAG(a)
Definition: SpuFakeDma.h:112
stallingUnalignedDmaSmallGet
int stallingUnalignedDmaSmallGet(void *ls, uint64_t ea, uint32_t size)
this unalignedDma should not be frequently used, only for small data. It handles alignment and perfor...
Definition: SpuFakeDma.cpp:62
bvhMeshShape_LocalStoreMemory::gSubtreeNodes
btQuantizedBvhNode gSubtreeNodes[2048/sizeof(btQuantizedBvhNode)]
Definition: SpuCollisionShapes.h:80
handleCollisionPair
void handleCollisionPair(SpuCollisionPairInput &collisionPairInput, CollisionTask_LocalStoreMemory &lsMem, SpuContactResult &spuContacts, ppu_address_t collisionShape0Ptr, void *collisionShape0Loc, ppu_address_t collisionShape1Ptr, void *collisionShape1Loc, bool dmaShapes=true)
Definition: SpuGatheringCollisionTask.cpp:831
degenerateStats
int degenerateStats[MAX_DEGENERATE_STATS]
Definition: SpuGatheringCollisionTask.cpp:643
getVmVector3
Vectormath::Aos::Vector3 getVmVector3(const btVector3 &bulletVec)
Definition: vectormath2bullet.h:38
btVector3::dot
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:235
CollisionTask_LocalStoreMemory::spuIndices
int spuIndices[16]
we reserve 32bit integer indices, even though they might be 16bit
Definition: SpuGatheringCollisionTask.cpp:141
CollisionTask_LocalStoreMemory::gColObj0Buffer
char gColObj0Buffer[sizeof(btCollisionObject)+16]
Definition: SpuGatheringCollisionTask.cpp:138
SpuCollisionPairInput::m_collisionShapes
ppu_address_t m_collisionShapes[2]
Definition: SpuContactResult.h:40
CompoundShape_LocalStoreMemory::gSubshapeShape
char gSubshapeShape[16][256]
Definition: SpuCollisionShapes.h:61
CollisionTask_LocalStoreMemory::m_lsColObj0Ptr
btCollisionObject * m_lsColObj0Ptr
The following pointers might either point into this local store memory, or to the original/other memo...
Definition: SpuGatheringCollisionTask.cpp:150
btIndexedMesh::m_indexType
PHY_ScalarType m_indexType
Definition: btTriangleIndexVertexArray.h:41
btVector3::getZ
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:565
btConvexShape
The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape...
Definition: btConvexShape.h:31
cellDmaLargePut
int cellDmaLargePut(const void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)
cellDmaLargePut Win32 replacements for Cell DMA to allow simulating most of the SPU code (just memcpy...
Definition: SpuFakeDma.cpp:192
btAlignedObjectArray::clear
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
Definition: btAlignedObjectArray.h:184
btGjkPairDetector::getCachedSeparatingAxis
const btVector3 & getCachedSeparatingAxis() const
Definition: btGjkPairDetector.h:80
dmaBvhIndexedMesh
void dmaBvhIndexedMesh(btIndexedMesh *IndexMesh, IndexedMeshArray &indexArray, int index, uint32_t dmaTag)
Definition: SpuCollisionShapes.cpp:134
btBvhSubtreeInfo
btBvhSubtreeInfo provides info to gather a subtree of limited size
Definition: btQuantizedBvh.h:119
CollisionTask_LocalStoreMemory::m_lsColObj1Ptr
btCollisionObject * m_lsColObj1Ptr
Definition: SpuGatheringCollisionTask.cpp:151
processCollisionTask
void processCollisionTask(void *userPtr, void *lsMemPtr)
Definition: SpuGatheringCollisionTask.cpp:1059
btBvhTriangleMeshShape
The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving ...
Definition: btBvhTriangleMeshShape.h:34
deleteCollisionLocalStoreMemory
void deleteCollisionLocalStoreMemory()
Definition: SpuGatheringCollisionTask.cpp:207
CollisionTask_LocalStoreMemory::m_pairsPointer
btBroadphasePair * m_pairsPointer
Definition: SpuGatheringCollisionTask.cpp:152
btUnlikely
#define btUnlikely(_c)
Definition: btScalar.h:107
small_cache_read
void small_cache_read(void *buffer, ppu_address_t ea, size_t size)
Definition: SpuGatheringCollisionTask.cpp:221
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:303
CollisionShape_LocalStoreMemory
Definition: SpuCollisionShapes.h:51
btDiscreteCollisionDetectorInterface::Result::setShapeIdentifiersB
virtual void setShapeIdentifiersB(int partId1, int index1)=0
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btConvexPointCloudShape::setPoints
void setPoints(btVector3 *points, int numPoints, bool computeAabb=true, const btVector3 &localScaling=btVector3(1.f, 1.f, 1.f))
Definition: btConvexPointCloudShape.h:51
MAX_DEGENERATE_STATS
#define MAX_DEGENERATE_STATS
Definition: SpuGatheringCollisionTask.cpp:641
btVoronoiSimplexSolver
btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points...
Definition: btVoronoiSimplexSolver.h:95
btLikely
#define btLikely(_c)
Definition: btScalar.h:106
SpuGatherAndProcessWorkUnitInput
MidphaseWorkUnitInput stores individual primitive versus mesh collision detection input...
Definition: SpuCollisionTaskProcess.h:77
bvhMeshShape_LocalStoreMemory::gIndexMesh
btIndexedMesh gIndexMesh
only a single mesh part for now, we can add support for multiple parts, but quantized trees don't sup...
Definition: SpuCollisionShapes.h:76
Box::mHalf
vmVector3 mHalf
Definition: Box.h:42
SpuCollisionPairInput::m_spuCollisionShapes
btCollisionShape * m_spuCollisionShapes[2]
Definition: SpuContactResult.h:41
SpuCollisionPairInput::m_primitiveDimensions1
btVector3 m_primitiveDimensions1
Definition: SpuContactResult.h:45
btVector3::getY
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:563
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:42
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
btVector3::getX
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:561
ProcessConvexConcaveSpuCollision
void ProcessConvexConcaveSpuCollision(SpuCollisionPairInput *wuInput, CollisionTask_LocalStoreMemory *lsMemPtr, SpuContactResult &spuContacts)
Convex versus Concave triangle mesh collision detection (handles concave triangle mesh versus sphere...
Definition: SpuGatheringCollisionTask.cpp:540
CollisionShape_LocalStoreMemory::collisionShape
char collisionShape[256]
Definition: SpuCollisionShapes.h:53
cellDmaGetReadOnly
void * cellDmaGetReadOnly(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)
Definition: SpuFakeDma.cpp:50
btBoxBoxDetector::getClosestPoints
virtual void getClosestPoints(const ClosestPointInput &input, Result &output, class btIDebugDraw *debugDraw, bool swapResults=false)
Definition: btBoxBoxDetector.cpp:673
cellDmaWaitTagStatusAll
void cellDmaWaitTagStatusAll(int ignore)
cellDmaWaitTagStatusAll Win32 replacements for Cell DMA to allow simulating most of the SPU code (jus...
Definition: SpuFakeDma.cpp:210
bvhMeshShape_LocalStoreMemory
Definition: SpuCollisionShapes.h:64
uint32_t
unsigned int uint32_t
Definition: PlatformDefinitions.h:48
btCollisionObject::getRestitution
btScalar getRestitution() const
Definition: btCollisionObject.h:272
btIndexedMesh::m_triangleIndexBase
const unsigned char * m_triangleIndexBase
Definition: btTriangleIndexVertexArray.h:31
btTransform::inverse
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:188
btConvexShape::localGetSupportVertexNonVirtual
btVector3 localGetSupportVertexNonVirtual(const btVector3 &vec) const
Definition: btConvexShape.cpp:303
CollisionTask_LocalStoreMemory::getContactManifoldPtr
btPersistentManifold * getContactManifoldPtr()
Definition: SpuGatheringCollisionTask.cpp:178
btBroadphasePair::m_pProxy1
btBroadphaseProxy * m_pProxy1
Definition: btBroadphaseProxy.h:227
btBroadphasePair::m_algorithm
btCollisionAlgorithm * m_algorithm
Definition: btBroadphaseProxy.h:229
cellDmaSmallGetReadOnly
void * cellDmaSmallGetReadOnly(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)
Definition: SpuFakeDma.cpp:37
btBoxShape
The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by ...
Definition: btBoxShape.h:26
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:59
btBroadphasePair::m_pProxy0
btBroadphaseProxy * m_pProxy0
Definition: btBroadphaseProxy.h:226
dmaCollisionShape
void dmaCollisionShape(void *collisionShapeLocation, ppu_address_t collisionShapePtr, uint32_t dmaTag, int shapeType)
Definition: SpuCollisionShapes.cpp:230
spu_printf
#define spu_printf
Definition: SpuGatheringCollisionTask.cpp:123
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
dmaBvhShapeData
void dmaBvhShapeData(bvhMeshShape_LocalStoreMemory *bvhMeshShape, btBvhTriangleMeshShape *triMeshShape)
Definition: SpuCollisionShapes.cpp:107
SpuContactResult::addContactPoint
virtual void addContactPoint(const btVector3 &normalOnBInWorld, const btVector3 &pointInWorld, btScalar depth)
Definition: SpuContactResult.cpp:189
btBvhSubtreeInfo::m_quantizedAabbMax
unsigned short int m_quantizedAabbMax[3]
Definition: btQuantizedBvh.h:126
getVmMatrix3
Vectormath::Aos::Matrix3 getVmMatrix3(const btMatrix3x3 &btMat)
Definition: vectormath2bullet.h:63
CollisionTask_LocalStoreMemory::gCollisionShapes
CollisionShape_LocalStoreMemory gCollisionShapes[2]
Definition: SpuGatheringCollisionTask.cpp:143
btGjkEpaPenetrationDepthSolver
EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth be...
Definition: btGjkEpaPenetrationDepthSolver.h:24
btDiscreteCollisionDetectorInterface::Result::addContactPoint
virtual void addContactPoint(const btVector3 &normalOnBInWorld, const btVector3 &pointInWorld, btScalar depth)=0
getBtVector3
btVector3 getBtVector3(const Vectormath::Aos::Vector3 &vmVec)
Definition: vectormath2bullet.h:43
MIDPHASE_NUM_WORKUNITS_PER_PAGE
#define MIDPHASE_NUM_WORKUNITS_PER_PAGE
Definition: SpuCollisionTaskProcess.h:158
Box
The Box is an internal class used by the boxBoxDistance calculation.
Definition: Box.h:39
btConvexInternalShape::getImplicitShapeDimensions
const btVector3 & getImplicitShapeDimensions() const
Definition: btConvexInternalShape.h:56
btQuantizedBvh::getSubtreeInfoArray
BvhSubtreeInfoArray & getSubtreeInfoArray()
Definition: btQuantizedBvh.h:456
ProcessConvexPlaneSpuCollision
void ProcessConvexPlaneSpuCollision(SpuCollisionPairInput *wuInput, CollisionTask_LocalStoreMemory *lsMemPtr, SpuContactResult &spuContacts)
Definition: SpuGatheringCollisionTask.cpp:430
CollisionTask_LocalStoreMemory
Make sure no destructors are called on this memory.
Definition: SpuGatheringCollisionTask.cpp:130
CompoundShape_LocalStoreMemory
Definition: SpuCollisionShapes.h:56
SpuContactManifoldCollisionAlgorithm
SpuContactManifoldCollisionAlgorithm provides contact manifold and should be processed on SPU...
Definition: SpuContactManifoldCollisionAlgorithm.h:31
CollisionTask_LocalStoreMemory::convexVertexData
SpuConvexPolyhedronVertexData convexVertexData[2]
Definition: SpuGatheringCollisionTask.cpp:145
CollisionTask_LocalStoreMemory::compoundShapeData
CompoundShape_LocalStoreMemory compoundShapeData[2]
Definition: SpuGatheringCollisionTask.cpp:146
small_cache_read_triple
void small_cache_read_triple(void *ls0, ppu_address_t ea0, void *ls1, ppu_address_t ea1, void *ls2, ppu_address_t ea2, size_t size)
Definition: SpuGatheringCollisionTask.cpp:235
CollisionTask_LocalStoreMemory::needsDmaPutContactManifoldAlgo
bool needsDmaPutContactManifoldAlgo
Definition: SpuGatheringCollisionTask.cpp:156
btCollisionObject::getFriction
btScalar getFriction() const
Definition: btCollisionObject.h:281
btGjkPairDetector
btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface
Definition: btGjkPairDetector.h:30
boxBoxDistance
float boxBoxDistance(vmVector3 &normal, BoxPoint &boxPointA, BoxPoint &boxPointB, PE_REF(Box) boxA, const vmTransform3 &transformA, PE_REF(Box) boxB, const vmTransform3 &transformB, float distanceThreshold)
Definition: boxBoxDistance.cpp:777
CollisionTask_LocalStoreMemory::m_lsManifoldPtr
btPersistentManifold * m_lsManifoldPtr
Definition: SpuGatheringCollisionTask.cpp:153
btBroadphaseProxy::isConcave
static bool isConcave(int proxyType)
Definition: btBroadphaseProxy.h:149
spuWalkStacklessQuantizedTree
void spuWalkStacklessQuantizedTree(btNodeOverlapCallback *nodeCallback, unsigned short int *quantizedQueryAabbMin, unsigned short int *quantizedQueryAabbMax, const btQuantizedBvhNode *rootNode, int startNodeIndex, int endNodeIndex)
Definition: SpuCollisionShapes.cpp:261
DoubleBuffer::backBufferDmaGet
void backBufferDmaGet(uint64_t ea, unsigned int numBytes, unsigned int tag)
Definition: SpuDoubleBuffer.h:76
createCollisionLocalStoreMemory
void * createCollisionLocalStoreMemory()
Definition: SpuGatheringCollisionTask.cpp:200
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:41
btConvexHullShape
The btConvexHullShape implements an implicit convex hull of an array of vertices. ...
Definition: btConvexHullShape.h:26
bvhMeshShape_LocalStoreMemory::gTriangleMeshInterfacePtr
btTriangleIndexVertexArray * gTriangleMeshInterfacePtr
Definition: SpuCollisionShapes.h:74
btConvexPointCloudShape
The btConvexPointCloudShape implements an implicit convex hull of an array of vertices.
Definition: btConvexPointCloudShape.h:24
btCompoundShape
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
Definition: btCompoundShape.h:54
BoxPoint
The BoxPoint class is an internally used class to contain feature information for boxBoxDistance calc...
Definition: Box.h:93
CollisionTask_LocalStoreMemory::m_lsCollisionAlgorithmPtr
SpuContactManifoldCollisionAlgorithm * m_lsCollisionAlgorithmPtr
Definition: SpuGatheringCollisionTask.cpp:154
dmaConvexVertexData
void dmaConvexVertexData(SpuConvexPolyhedronVertexData *convexVertexData, btConvexHullShape *convexShapeSPU)
Definition: SpuCollisionShapes.cpp:215
btStaticPlaneShape
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. ...
Definition: btStaticPlaneShape.h:23
SpuContactResult::setContactInfo
void setContactInfo(btPersistentManifold *spuManifold, ppu_address_t manifoldAddress, const btTransform &worldTrans0, const btTransform &worldTrans1, btScalar restitution0, btScalar restitution1, btScalar friction0, btScalar friction01, bool isSwapped)
Definition: SpuContactResult.cpp:61
CompoundShape_LocalStoreMemory::gSubshapes
btCompoundShapeChild gSubshapes[16]
Definition: SpuCollisionShapes.h:60
MAX_SPU_COMPOUND_SUBSHAPES
#define MAX_SPU_COMPOUND_SUBSHAPES
Definition: SpuCollisionShapes.h:37
btBvhSubtreeInfo::m_quantizedAabbMin
unsigned short int m_quantizedAabbMin[3]
Definition: btQuantizedBvh.h:125
btDiscreteCollisionDetectorInterface::Result::setShapeIdentifiersA
virtual void setShapeIdentifiersA(int partId0, int index0)=0
setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material comb...
ProcessSpuConvexConvexCollision
void ProcessSpuConvexConvexCollision(SpuCollisionPairInput *wuInput, CollisionTask_LocalStoreMemory *lsMemPtr, SpuContactResult &spuContacts)
Convex versus Convex collision detection (handles collision between sphere, box, cylinder, triangle, cone, convex polyhedron etc)
Definition: SpuGatheringCollisionTask.cpp:649
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:218
spuTestQuantizedAabbAgainstQuantizedAabb
unsigned int spuTestQuantizedAabbAgainstQuantizedAabb(unsigned short int *aabbMin1, unsigned short int *aabbMax1, const unsigned short int *aabbMin2, const unsigned short int *aabbMax2)
Definition: SpuCollisionShapes.h:99
Vectormath::Aos::Transform3::setUpper3x3
Transform3 & setUpper3x3(const Matrix3 &mat3)
Definition: neon/mat_aos.h:1349
btQuantizedBvh::getQuantizedNodeArray
QuantizedNodeArray & getQuantizedNodeArray()
Definition: btQuantizedBvh.h:450
stats
int stats[MAX_DEGENERATE_STATS]
Definition: SpuGatheringCollisionTask.cpp:642
DoSwap
void DoSwap(T &a, T &b)
Definition: SpuGatheringCollisionTask.cpp:799
dmaBvhSubTreeNodes
void dmaBvhSubTreeNodes(btQuantizedBvhNode *nodes, const btBvhSubtreeInfo &subtree, QuantizedNodeArray &nodeArray, int dmaTag)
Definition: SpuCollisionShapes.cpp:145
MIDPHASE_WORKUNIT_PAGE_SIZE
#define MIDPHASE_WORKUNIT_PAGE_SIZE
Definition: SpuCollisionTaskProcess.h:153
spuNodeCallback::processNode
virtual void processNode(int subPart, int triangleIndex)
Definition: SpuGatheringCollisionTask.cpp:314
MAX_SPU_SUBTREE_HEADERS
#define MAX_SPU_SUBTREE_HEADERS
Definition: SpuCollisionShapes.h:77
bvhMeshShape_LocalStoreMemory::getOptimizedBvh
btOptimizedBvh * getOptimizedBvh()
Definition: SpuCollisionShapes.h:68
btBroadphaseProxy::isConvex
static bool isConvex(int proxyType)
Definition: btBroadphaseProxy.h:139
sLocalStorePointers
btAlignedObjectArray< CollisionTask_LocalStoreMemory * > sLocalStorePointers
Definition: SpuGatheringCollisionTask.cpp:198
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:266
SpuContactResult::setShapeIdentifiersB
virtual void setShapeIdentifiersB(int partId1, int index1)
Definition: SpuContactResult.cpp:79
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:262
CollisionTask_LocalStoreMemory::getColObj1
btCollisionObject * getColObj1()
Definition: SpuGatheringCollisionTask.cpp:162
SpuClosestPointInput::m_convexVertexData
struct SpuConvexPolyhedronVertexData * m_convexVertexData[2]
Definition: SpuContactResult.h:61
btGjkPairDetector::getClosestPoints
virtual void getClosestPoints(const ClosestPointInput &input, Result &output, class btIDebugDraw *debugDraw, bool swapResults=false)
Definition: btGjkPairDetector.cpp:74
btIndexedMesh::m_vertexBase
const unsigned char * m_vertexBase
Definition: btTriangleIndexVertexArray.h:35
btCompoundShape::getNumChildShapes
int getNumChildShapes() const
Definition: btCompoundShape.h:85
btBroadphasePair
The btBroadphasePair class contains a pair of aabb-overlapping objects.
Definition: btBroadphaseProxy.h:186
Generated on Wed Feb 5 2014 21:36:54 for Bullet Collision Detection & Physics Library by   doxygen 1.8.6