25                                                                    m_useQuantization(false),
 
   27                                                                    m_traversalMode(TRAVERSAL_STACKLESS)
 
   30                                                                    m_subtreeHeaderCount(0)  
 
   72 #ifdef DEBUG_PATCH_COLORS 
   79 #endif  //DEBUG_PATCH_COLORS 
   84         btVector3 clampValue(quantizationMargin, quantizationMargin, quantizationMargin);
 
   93                 unsigned short vecIn[3];
 
  116 #ifdef DEBUG_TREE_BUILDING 
  118 int gMaxStackDepth = 0;
 
  119 #endif  //DEBUG_TREE_BUILDING 
  123 #ifdef DEBUG_TREE_BUILDING 
  125         if (gStackDepth > gMaxStackDepth)
 
  126                 gMaxStackDepth = gStackDepth;
 
  127 #endif  //DEBUG_TREE_BUILDING 
  129         int splitAxis, splitIndex, i;
 
  130         int numIndices = endIndex - startIndex;
 
  137 #ifdef DEBUG_TREE_BUILDING 
  139 #endif  //DEBUG_TREE_BUILDING 
  159         for (i = startIndex; i < endIndex; i++)
 
  177 #ifdef DEBUG_TREE_BUILDING 
  179 #endif  //DEBUG_TREE_BUILDING 
  187                 const int treeSizeInBytes = escapeIndex * sizeQuantizedNode;
 
  206         int leftSubTreeSizeInBytes = leftSubTreeSize * static_cast<int>(
sizeof(
btQuantizedBvhNode));
 
  210         int rightSubTreeSizeInBytes = rightSubTreeSize * static_cast<int>(
sizeof(
btQuantizedBvhNode));
 
  235         int splitIndex = startIndex;
 
  236         int numIndices = endIndex - startIndex;
 
  240         for (i = startIndex; i < endIndex; i++)
 
  247         splitValue = means[splitAxis];
 
  250         for (i = startIndex; i < endIndex; i++)
 
  253                 if (center[splitAxis] > splitValue)
 
  270         int rangeBalancedIndices = numIndices / 3;
 
  271         bool unbalanced = ((splitIndex <= (startIndex + rangeBalancedIndices)) || (splitIndex >= (endIndex - 1 - rangeBalancedIndices)));
 
  275                 splitIndex = startIndex + (numIndices >> 1);
 
  278         bool unbal = (splitIndex == startIndex) || (splitIndex == (endIndex));
 
  291         int numIndices = endIndex - startIndex;
 
  293         for (i = startIndex; i < endIndex; i++)
 
  300         for (i = startIndex; i < endIndex; i++)
 
  304                 diff2 = diff2 * diff2;
 
  319                 unsigned short int quantizedQueryAabbMin[3];
 
  320                 unsigned short int quantizedQueryAabbMax[3];
 
  356         int escapeIndex, curIndex = 0;
 
  357         int walkIterations = 0;
 
  360         unsigned aabbOverlap;
 
  372                 if (isLeafNode && (aabbOverlap != 0))
 
  378                 if ((aabbOverlap != 0) || isLeafNode)
 
  386                         rootNode += escapeIndex;
 
  387                         curIndex += escapeIndex;
 
  421         unsigned aabbOverlap;
 
  428         if (aabbOverlap != 0)
 
  451         int escapeIndex, curIndex = 0;
 
  452         int walkIterations = 0;
 
  455         unsigned aabbOverlap = 0;
 
  456         unsigned rayBoxOverlap = 0;
 
  462         rayAabbMin.
setMin(rayTarget);
 
  463         rayAabbMax.
setMax(rayTarget);
 
  466         rayAabbMin += aabbMin;
 
  467         rayAabbMax += aabbMax;
 
  470         btVector3 rayDir = (rayTarget - raySource);
 
  472         lambda_max = rayDir.
dot(rayTarget - raySource);
 
  478         unsigned int sign[3] = {rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0};
 
  501                 rayBoxOverlap = aabbOverlap ? 
btRayAabb2(raySource, rayDirectionInverse, sign, 
bounds, param, 0.0f, lambda_max) : 
false;
 
  514                 if (isLeafNode && (rayBoxOverlap != 0))
 
  520                 if ((rayBoxOverlap != 0) || isLeafNode)
 
  528                         rootNode += escapeIndex;
 
  529                         curIndex += escapeIndex;
 
  540         int curIndex = startNodeIndex;
 
  541         int walkIterations = 0;
 
  542         int subTreeSize = endNodeIndex - startNodeIndex;
 
  550         unsigned boxBoxOverlap = 0;
 
  551         unsigned rayBoxOverlap = 0;
 
  556         btVector3 rayDirection = (rayTarget - raySource);
 
  558         lambda_max = rayDirection.
dot(rayTarget - raySource);
 
  563         unsigned int sign[3] = {rayDirection[0] < 0.0, rayDirection[1] < 0.0, rayDirection[2] < 0.0};
 
  569         rayAabbMin.
setMin(rayTarget);
 
  570         rayAabbMax.
setMax(rayTarget);
 
  573         rayAabbMin += aabbMin;
 
  574         rayAabbMax += aabbMax;
 
  576         unsigned short int quantizedQueryAabbMin[3];
 
  577         unsigned short int quantizedQueryAabbMax[3];
 
  581         while (curIndex < endNodeIndex)
 
  584 #ifdef VISUALLY_ANALYZE_BVH 
  586                 static int drawPatch = 0;
 
  589                 if (curIndex == drawPatch)
 
  595                         debugDrawerPtr->
drawAabb(aabbMin, aabbMax, color);
 
  597 #endif  //VISUALLY_ANALYZE_BVH 
  600                 btAssert(walkIterations < subTreeSize);
 
  619                         bool ra2 = 
btRayAabb2 (raySource, rayDirection, sign, 
bounds, param, 0.0, lambda_max);
 
  623                                 printf(
"functions don't match\n");
 
  632                         rayBoxOverlap = 
btRayAabb2(raySource, rayDirection, sign, 
bounds, param, 0.0f, lambda_max);
 
  635                         rayBoxOverlap = 
true;  
 
  639                 if (isLeafNode && rayBoxOverlap)
 
  645                 if ((rayBoxOverlap != 0) || isLeafNode)
 
  653                         rootNode += escapeIndex;
 
  654                         curIndex += escapeIndex;
 
  665         int curIndex = startNodeIndex;
 
  666         int walkIterations = 0;
 
  667         int subTreeSize = endNodeIndex - startNodeIndex;
 
  675         unsigned aabbOverlap;
 
  677         while (curIndex < endNodeIndex)
 
  680 #ifdef VISUALLY_ANALYZE_BVH 
  682                 static int drawPatch = 0;
 
  685                 if (curIndex == drawPatch)
 
  691                         debugDrawerPtr->
drawAabb(aabbMin, aabbMax, color);
 
  693 #endif  //VISUALLY_ANALYZE_BVH 
  696                 btAssert(walkIterations < subTreeSize);
 
  703                 if (isLeafNode && aabbOverlap)
 
  709                 if ((aabbOverlap != 0) || isLeafNode)
 
  717                         rootNode += escapeIndex;
 
  718                         curIndex += escapeIndex;
 
  811 static const unsigned BVH_ALIGNMENT = 16;
 
  812 static const unsigned BVH_ALIGNMENT_MASK = BVH_ALIGNMENT-1;
 
  814 static const unsigned BVH_ALIGNMENT_BLOCKS = 2;
 
  876         unsigned char* nodeData = (
unsigned char*)targetBvh;
 
  879         unsigned sizeToAdd = 0;  
 
  880         nodeData += sizeToAdd;
 
  890                         for (
int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
 
  905                         for (
int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
 
  931                         for (
int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
 
  943                         for (
int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
 
  962         nodeData += sizeToAdd;
 
 1011         *((
void**)o_alignedDataBuffer) = NULL;
 
 1018         if (i_alignedDataBuffer == NULL)  
 
 1037         btAssert(calculatedBufSize <= i_dataBufferSize);
 
 1039         if (calculatedBufSize > i_dataBufferSize)
 
 1044         unsigned char* nodeData = (
unsigned char*)bvh;
 
 1047         unsigned sizeToAdd = 0;  
 
 1048         nodeData += sizeToAdd;
 
 1062                         for (
int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
 
 1083                         for (
int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
 
 1097         nodeData += sizeToAdd;
 
 1123                                                                                                                                                           m_bvhAabbMax(self.m_bvhAabbMax),
 
 1124                                                                                                                                                           m_bvhQuantization(self.m_bvhQuantization),
 
 1146                         for (
int i = 0; i < numElem; i++, memPtr++)
 
 1164                         for (
int i = 0; i < numElem; i++, memPtr++)
 
 1185                         for (
int i = 0; i < numElem; i++, memPtr++)
 
 1217                         for (
int i = 0; i < numElem; i++, memPtr++)
 
 1235                         for (
int i = 0; i < numElem; i++, memPtr++)
 
 1256                         for (
int i = 0; i < numElem; i++, memPtr++)
 
 1285         if (quantizedData->m_contiguousNodesPtr)
 
 1291                 for (
int i = 0; i < numElem; i++, memPtr++)
 
 1299                         memset(memPtr->m_pad, 0, 
sizeof(memPtr->m_pad));
 
 1307         if (quantizedData->m_quantizedContiguousNodesPtr)
 
 1313                 for (
int i = 0; i < numElem; i++, memPtr++)
 
 1330         if (quantizedData->m_subTreeInfoPtr)
 
 1336                 for (
int i = 0; i < numElem; i++, memPtr++)