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++)