| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
   16 #ifndef BT_QUANTIZED_BVH_H 
   17 #define BT_QUANTIZED_BVH_H 
   22 #ifdef DEBUG_CHECK_DEQUANTIZATION 
   24 #define printf spu_printf 
   29 #endif  //DEBUG_CHECK_DEQUANTIZATION 
   34 #ifdef BT_USE_DOUBLE_PRECISION 
   35 #define btQuantizedBvhData btQuantizedBvhDoubleData 
   36 #define btOptimizedBvhNodeData btOptimizedBvhNodeDoubleData 
   37 #define btQuantizedBvhDataName "btQuantizedBvhDoubleData" 
   39 #define btQuantizedBvhData btQuantizedBvhFloatData 
   40 #define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData 
   41 #define btQuantizedBvhDataName "btQuantizedBvhFloatData" 
   47 #define MAX_SUBTREE_SIZE_IN_BYTES 2048 
   51 #define MAX_NUM_PARTS_IN_BITS 10 
   61         unsigned short int m_quantizedAabbMin[3];
 
   62         unsigned short int m_quantizedAabbMax[3];
 
   69                 return (m_escapeIndexOrTriangleIndex >= 0);
 
   74                 return -m_escapeIndexOrTriangleIndex;
 
   82                 return (m_escapeIndexOrTriangleIndex & ~(y));
 
  123         unsigned short int m_quantizedAabbMin[3];
 
  124         unsigned short int m_quantizedAabbMax[3];
 
  152         virtual void processNode(
int subPart, 
int triangleIndex) = 0;
 
  172                 TRAVERSAL_STACKLESS = 0,
 
  203                 if (m_useQuantization)
 
  205                         quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0], aabbMin, 0);
 
  209                         m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin;
 
  214                 if (m_useQuantization)
 
  216                         quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0], aabbMax, 1);
 
  220                         m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax;
 
  226                 if (m_useQuantization)
 
  228                         return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]);
 
  231                 return m_leafNodes[nodeIndex].m_aabbMinOrg;
 
  235                 if (m_useQuantization)
 
  237                         return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]);
 
  240                 return m_leafNodes[nodeIndex].m_aabbMaxOrg;
 
  245                 if (m_useQuantization)
 
  247                         m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex;
 
  251                         m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex;
 
  257                 if (m_useQuantization)
 
  259                         unsigned short int quantizedAabbMin[3];
 
  260                         unsigned short int quantizedAabbMax[3];
 
  261                         quantize(quantizedAabbMin, newAabbMin, 0);
 
  262                         quantize(quantizedAabbMax, newAabbMax, 1);
 
  263                         for (
int i = 0; i < 3; i++)
 
  265                                 if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i])
 
  266                                         m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i];
 
  268                                 if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i])
 
  269                                         m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i];
 
  275                         m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin);
 
  276                         m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax);
 
  280         void swapLeafNodes(
int firstIndex, 
int secondIndex);
 
  282         void assignInternalNodeFromLeafNode(
int internalNode, 
int leafNodeIndex);
 
  285         void buildTree(
int startIndex, 
int endIndex);
 
  287         int calcSplittingAxis(
int startIndex, 
int endIndex);
 
  289         int sortAndCalcSplittingIndex(
int startIndex, 
int endIndex, 
int splitAxis);
 
  294         void walkStacklessQuantizedTree(
btNodeOverlapCallback * nodeCallback, 
unsigned short int* quantizedQueryAabbMin, 
unsigned short int* quantizedQueryAabbMax, 
int startNodeIndex, 
int endNodeIndex) 
const;
 
  298         void walkStacklessQuantizedTreeCacheFriendly(
btNodeOverlapCallback * nodeCallback, 
unsigned short int* quantizedQueryAabbMin, 
unsigned short int* quantizedQueryAabbMax) 
const;
 
  301         void walkRecursiveQuantizedTreeAgainstQueryAabb(
const btQuantizedBvhNode* currentNode, 
btNodeOverlapCallback* nodeCallback, 
unsigned short int* quantizedQueryAabbMin, 
unsigned short int* quantizedQueryAabbMax) 
const;
 
  306         void updateSubtreeHeaders(
int leftChildNodexIndex, 
int rightChildNodexIndex);
 
  319         void buildInternal();
 
  338                 btVector3 v = (point - m_bvhAabbMin) * m_bvhQuantization;
 
  344                         out[0] = (
unsigned short)(((
unsigned short)(v.getX() + 
btScalar(1.)) | 1));
 
  345                         out[1] = (
unsigned short)(((
unsigned short)(v.getY() + 
btScalar(1.)) | 1));
 
  346                         out[2] = (
unsigned short)(((
unsigned short)(v.getZ() + 
btScalar(1.)) | 1));
 
  350                         out[0] = (
unsigned short)(((
unsigned short)(v.getX()) & 0xfffe));
 
  351                         out[1] = (
unsigned short)(((
unsigned short)(v.getY()) & 0xfffe));
 
  352                         out[2] = (
unsigned short)(((
unsigned short)(v.getZ()) & 0xfffe));
 
  355 #ifdef DEBUG_CHECK_DEQUANTIZATION 
  361                                 printf(
"unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.
getX() - point.
getX(), newPoint.
getX(), point.
getX());
 
  365                                 printf(
"unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.
getY() - point.
getY(), newPoint.
getY(), point.
getY());
 
  369                                 printf(
"unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.
getZ() - point.
getZ(), newPoint.
getZ(), point.
getZ());
 
  376                                 printf(
"unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.
getX() - point.
getX(), newPoint.
getX(), point.
getX());
 
  380                                 printf(
"unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.
getY() - point.
getY(), newPoint.
getY(), point.
getY());
 
  384                                 printf(
"unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.
getZ() - point.
getZ(), newPoint.
getZ(), point.
getZ());
 
  387 #endif  //DEBUG_CHECK_DEQUANTIZATION 
  395                 clampedPoint.
setMax(m_bvhAabbMin);
 
  396                 clampedPoint.
setMin(m_bvhAabbMax);
 
  398                 quantize(out, clampedPoint, isMax);
 
  408                 vecOut += m_bvhAabbMin;
 
  415                 m_traversalMode = traversalMode;
 
  420                 return m_quantizedContiguousNodes;
 
  425                 return m_SubtreeHeaders;
 
  431         unsigned calculateSerializeBufferSize() 
const;
 
  434         virtual bool serialize(
void* o_alignedDataBuffer, 
unsigned i_dataBufferSize, 
bool i_swapEndian) 
const;
 
  437         static btQuantizedBvh* deSerializeInPlace(
void* i_alignedDataBuffer, 
unsigned int i_dataBufferSize, 
bool i_swapEndian);
 
  439         static unsigned int getAlignmentSerializationPadding();
 
  442         virtual int calculateSerializeBufferSizeNew() 
const;
 
  445         virtual const char* serialize(
void* dataBuffer, 
btSerializer* serializer) 
const;
 
  455                 return m_useQuantization;
 
  543 #endif  //BT_QUANTIZED_BVH_H 
  
btVector3 getAabbMin(int nodeIndex) const
btVector3 unQuantize(const unsigned short *vecIn) const
btVector3DoubleData m_bvhAabbMin
btAlignedObjectArray< btOptimizedBvhNode > NodeArray
for code readability:
btTraversalMode m_traversalMode
btBvhSubtreeInfoData * m_subTreeInfoPtr
#define btQuantizedBvhData
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
btAlignedObjectArray< btBvhSubtreeInfo > BvhSubtreeInfoArray
btVector3DoubleData m_bvhQuantization
btVector3 m_bvhQuantization
int m_escapeIndexOrTriangleIndex
btQuantizedBvhNodeData * m_quantizedContiguousNodesPtr
void setTraversalMode(btTraversalMode traversalMode)
setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree trave...
btQuantizedBvhNode is a compressed aabb node, 16 bytes.
The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU.
#define MAX_NUM_PARTS_IN_BITS
btVector3FloatData m_bvhAabbMin
btQuantizedBvhNodeData * m_quantizedContiguousNodesPtr
void setInternalNodeAabbMax(int nodeIndex, const btVector3 &aabbMax)
btVector3FloatData m_bvhAabbMax
void quantizeWithClamp(unsigned short *out, const btVector3 &point2, int isMax) const
btBvhSubtreeInfoData * m_subTreeInfoPtr
btVector3FloatData m_bvhQuantization
NodeArray m_contiguousNodes
const btScalar & getX() const
Return the x value.
int getEscapeIndex() const
void mergeInternalNodeAabb(int nodeIndex, const btVector3 &newAabbMin, const btVector3 &newAabbMax)
unsigned short m_quantizedAabbMin[3]
btBvhSubtreeInfo provides info to gather a subtree of limited size
unsigned short int m_quantizedAabbMax[3]
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
btVector3FloatData m_aabbMinOrg
btVector3DoubleData m_bvhAabbMax
QuantizedNodeArray & getLeafNodeArray()
btAlignedObjectArray< btQuantizedBvhNode > QuantizedNodeArray
btVector3FloatData m_aabbMaxOrg
btOptimizedBvhNodeDoubleData * m_contiguousNodesPtr
QuantizedNodeArray m_quantizedLeafNodes
unsigned short m_quantizedAabbMin[3]
#define BT_DECLARE_ALIGNED_ALLOCATOR()
btVector3 can be used to represent 3D points and vectors.
int m_numContiguousLeafNodes
btOptimizedBvhNodeFloatData * m_contiguousNodesPtr
virtual void processNode(int subPart, int triangleIndex)=0
#define ATTRIBUTE_ALIGNED16(a)
BvhSubtreeInfoArray m_SubtreeHeaders
void setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex)
virtual ~btNodeOverlapCallback()
const btScalar & getZ() const
Return the z value.
const btScalar & getY() const
Return the y value.
unsigned short m_quantizedAabbMax[3]
#define SIMD_FORCE_INLINE
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
void setInternalNodeAabbMin(int nodeIndex, const btVector3 &aabbMin)
two versions, one for quantized and normal nodes.
int m_numQuantizedContiguousNodes
virtual int calculateSerializeBufferSizeNew() const
void quantize(unsigned short *out, const btVector3 &point, int isMax) const
btVector3 getAabbMax(int nodeIndex) const
btOptimizedBvhNode contains both internal and leaf node information.
unsigned short m_quantizedAabbMax[3]
btVector3DoubleData m_aabbMinOrg
void setAabbFromQuantizeNode(const btQuantizedBvhNode &quantizedNode)
btVector3DoubleData m_aabbMaxOrg
int m_escapeIndexOrTriangleIndex
QuantizedNodeArray & getQuantizedNodeArray()
int getTriangleIndex() const
int m_numContiguousLeafNodes
BvhSubtreeInfoArray & getSubtreeInfoArray()
QuantizedNodeArray m_quantizedContiguousNodes
int m_numQuantizedContiguousNodes
unsigned short int m_quantizedAabbMin[3]