void BuildHierarchy(List <uint> tempTree, buildData dat, BuildStats stats)
{
// create space for the first node
tempTree.Add(3u << 30); // dummy leaf
tempTree.Add(0);
tempTree.Add(0);
// seed bbox
AABound gridBox = new();
gridBox.lo = bounds.Lo;
gridBox.hi = bounds.Hi;
AABound nodeBox = gridBox;
// seed subdivide function
Subdivide(0, (int)(dat.numPrims - 1), tempTree, dat, gridBox, nodeBox, 0, 1, stats);
}
void Subdivide(int left, int right, List <uint> tempTree, buildData dat, AABound gridBox, AABound nodeBox, int nodeIndex, int depth, BuildStats stats)
{
if ((right - left + 1) <= dat.maxPrims || depth >= 64)
{
// write leaf node
stats.UpdateLeaf(depth, right - left + 1);
CreateNode(tempTree, nodeIndex, left, right);
return;
}
// calculate extents
int axis = -1, prevAxis, rightOrig;
float clipL = float.NaN, clipR = float.NaN, prevClip = float.NaN;
float split = float.NaN, prevSplit;
bool wasLeft = true;
while (true)
{
prevAxis = axis;
prevSplit = split;
// perform quick consistency checks
Vector3 d = gridBox.hi - gridBox.lo;
for (int i = 0; i < 3; i++)
{
if (nodeBox.hi[i] < gridBox.lo[i] || nodeBox.lo[i] > gridBox.hi[i])
{
Log.outError(LogFilter.Server, "Reached tree area in error - discarding node with: {0} objects", right - left + 1);
}
}
// find longest axis
axis = (int)d.primaryAxis();
split = 0.5f * (gridBox.lo[axis] + gridBox.hi[axis]);
// partition L/R subsets
clipL = float.NegativeInfinity;
clipR = float.PositiveInfinity;
rightOrig = right; // save this for later
float nodeL = float.PositiveInfinity;
float nodeR = float.NegativeInfinity;
for (int i = left; i <= right;)
{
int obj = (int)dat.indices[i];
float minb = dat.primBound[obj].Lo[axis];
float maxb = dat.primBound[obj].Hi[axis];
float center = (minb + maxb) * 0.5f;
if (center <= split)
{
// stay left
i++;
if (clipL < maxb)
{
clipL = maxb;
}
}
else
{
// move to the right most
int t = (int)dat.indices[i];
dat.indices[i] = dat.indices[right];
dat.indices[right] = (uint)t;
right--;
if (clipR > minb)
{
clipR = minb;
}
}
nodeL = Math.Min(nodeL, minb);
nodeR = Math.Max(nodeR, maxb);
}
// check for empty space
if (nodeL > nodeBox.lo[axis] && nodeR < nodeBox.hi[axis])
{
float nodeBoxW = nodeBox.hi[axis] - nodeBox.lo[axis];
float nodeNewW = nodeR - nodeL;
// node box is too big compare to space occupied by primitives?
if (1.3f * nodeNewW < nodeBoxW)
{
stats.UpdateBVH2();
int nextIndex1 = tempTree.Count;
// allocate child
tempTree.Add(0);
tempTree.Add(0);
tempTree.Add(0);
// write bvh2 clip node
stats.UpdateInner();
tempTree[nodeIndex + 0] = (uint)((axis << 30) | (1 << 29) | nextIndex1);
tempTree[nodeIndex + 1] = FloatToRawIntBits(nodeL);
tempTree[nodeIndex + 2] = FloatToRawIntBits(nodeR);
// update nodebox and recurse
nodeBox.lo[axis] = nodeL;
nodeBox.hi[axis] = nodeR;
Subdivide(left, rightOrig, tempTree, dat, gridBox, nodeBox, nextIndex1, depth + 1, stats);
return;
}
}
// ensure we are making progress in the subdivision
if (right == rightOrig)
{
// all left
if (prevAxis == axis && MathFunctions.fuzzyEq(prevSplit, split))
{
// we are stuck here - create a leaf
stats.UpdateLeaf(depth, right - left + 1);
CreateNode(tempTree, nodeIndex, left, right);
return;
}
if (clipL <= split)
{
// keep looping on left half
gridBox.hi[axis] = split;
prevClip = clipL;
wasLeft = true;
continue;
}
gridBox.hi[axis] = split;
prevClip = float.NaN;
}
else if (left > right)
{
// all right
right = rightOrig;
if (prevAxis == axis && MathFunctions.fuzzyEq(prevSplit, split))
{
// we are stuck here - create a leaf
stats.UpdateLeaf(depth, right - left + 1);
CreateNode(tempTree, nodeIndex, left, right);
return;
}
if (clipR >= split)
{
// keep looping on right half
gridBox.lo[axis] = split;
prevClip = clipR;
wasLeft = false;
continue;
}
gridBox.lo[axis] = split;
prevClip = float.NaN;
}
else
{
// we are actually splitting stuff
if (prevAxis != -1 && !float.IsNaN(prevClip))
{
// second time through - lets create the previous split
// since it produced empty space
int nextIndex0 = tempTree.Count;
// allocate child node
tempTree.Add(0);
tempTree.Add(0);
tempTree.Add(0);
if (wasLeft)
{
// create a node with a left child
// write leaf node
stats.UpdateInner();
tempTree[nodeIndex + 0] = (uint)((prevAxis << 30) | nextIndex0);
tempTree[nodeIndex + 1] = FloatToRawIntBits(prevClip);
tempTree[nodeIndex + 2] = FloatToRawIntBits(float.PositiveInfinity);
}
else
{
// create a node with a right child
// write leaf node
stats.UpdateInner();
tempTree[nodeIndex + 0] = (uint)((prevAxis << 30) | (nextIndex0 - 3));
tempTree[nodeIndex + 1] = FloatToRawIntBits(float.NegativeInfinity);
tempTree[nodeIndex + 2] = FloatToRawIntBits(prevClip);
}
// count stats for the unused leaf
depth++;
stats.UpdateLeaf(depth, 0);
// now we keep going as we are, with a new nodeIndex:
nodeIndex = nextIndex0;
}
break;
}
}
// compute index of child nodes
int nextIndex = tempTree.Count;
// allocate left node
int nl = right - left + 1;
int nr = rightOrig - (right + 1) + 1;
if (nl > 0)
{
tempTree.Add(0);
tempTree.Add(0);
tempTree.Add(0);
}
else
{
nextIndex -= 3;
}
// allocate right node
if (nr > 0)
{
tempTree.Add(0);
tempTree.Add(0);
tempTree.Add(0);
}
// write leaf node
stats.UpdateInner();
tempTree[nodeIndex + 0] = (uint)((axis << 30) | nextIndex);
tempTree[nodeIndex + 1] = FloatToRawIntBits(clipL);
tempTree[nodeIndex + 2] = FloatToRawIntBits(clipR);
// prepare L/R child boxes
AABound gridBoxL = gridBox;
AABound gridBoxR = gridBox;
AABound nodeBoxL = nodeBox;
AABound nodeBoxR = nodeBox;
gridBoxL.hi[axis] = gridBoxR.lo[axis] = split;
nodeBoxL.hi[axis] = clipL;
nodeBoxR.lo[axis] = clipR;
// recurse
if (nl > 0)
{
Subdivide(left, right, tempTree, dat, gridBoxL, nodeBoxL, nextIndex, depth + 1, stats);
}
else
{
stats.UpdateLeaf(depth + 1, 0);
}
if (nr > 0)
{
Subdivide(right + 1, rightOrig, tempTree, dat, gridBoxR, nodeBoxR, nextIndex + 3, depth + 1, stats);
}
else
{
stats.UpdateLeaf(depth + 1, 0);
}
}