// recursively add a node to an accelerator
void make_accelerator_node(int nodeid,
vector<pair<range3f,int>>& boxed_prims,
vector<BVHNode>& nodes,
int start, int end) {
range3f bbox;
auto node = BVHNode();
for(auto i : range(start, end)) bbox = runion(bbox,boxed_prims[i].first);
if(end-start <= BVHAccelerator_min_prims) {
node.bbox = bbox;
node.leaf = true;
node.start = start;
node.end = end;
} else {
int middle = make_accelerator_split(boxed_prims,start,end,bbox,BVHAccelerator_build_maxaxis);
node.bbox = bbox;
node.leaf = false;
nodes.push_back(BVHNode());
node.n0 = nodes.size();
nodes.push_back(BVHNode());
node.n1 = nodes.size();
nodes.push_back(BVHNode());
make_accelerator_node(node.n0,boxed_prims,nodes,start,middle);
make_accelerator_node(node.n1,boxed_prims,nodes,middle,end);
}
nodes[nodeid] = node;
}
// build accelerator
BVHAccelerator* make_accelerator(vector<range3f>& bboxes) {
vector<pair<range3f,int>> boxed_prims(bboxes.size());
for(auto i : range(bboxes.size())) boxed_prims[i] = pair<range3f,int>(rscale(bboxes[i],1+BVHAccelerator_epsilon),i);
auto bvh = new BVHAccelerator();
bvh->nodes.push_back(BVHNode());
make_accelerator_node(0, boxed_prims, bvh->nodes, 0, bboxes.size());
bvh->prims.reserve(bboxes.size());
for(auto i : range(boxed_prims.size())) bvh->prims[i] = boxed_prims[i].second;
return bvh;
}
void BVH::buildNode( SplitMethod i_method, BVHItems &i_buildItems, size_t i_start, size_t i_end )
{
Bounds3f bounds;
Bounds3f centerBounds;
// Save the index for later access of the node
size_t nodeIndex = m_nodes.size();
// Push back a node, we will initialize it later
m_nodes.push_back( BVHNode() );
// Calculate bounds
for ( size_t i = i_start; i < i_end; i++ )
{
const BVHItem &item = i_buildItems[ i ];
bounds = boundsUnion( bounds, item.bounds );
centerBounds = boundsUnion( centerBounds, item.center );
}
size_t count = i_end - i_start;
// Create a leaf
if ( count == 1 )
{
m_nodes[ nodeIndex ].initLeaf( bounds, m_items.size(), 1 );
m_items.push_back( i_buildItems[ i_start ] );
}
// Split
else
{
int dim = static_cast< int >( bounds.maximumExtent() );
const vec3f &min = centerBounds.getMin();
const vec3f &max = centerBounds.getMax();
// Cannot split, create leaf items
if ( min[ dim ] == max[ dim ] )
{
m_nodes[ nodeIndex ].initLeaf( bounds, m_items.size(), count );
for ( size_t i = i_start; i < i_end; i++ )
{
m_items.push_back( i_buildItems[ i ] );
}
}
// Split by method
else
{
size_t mid = ( i_start + i_end ) / 2.0;
switch ( i_method ) {
case SplitMethod::MIDDLE:
{
// Split the items at the midpoint of the axis
float dimMid = ( centerBounds.getMin()[ dim ] + centerBounds.getMax()[ dim ] ) / 2.0;
BVHItem* midPtr = std::partition(
&i_buildItems[ i_start ],
&i_buildItems[ i_end - 1 ] + 1,
[ dim, dimMid ]( const BVHItem &item ) {
return item.center[ dim ] < dimMid;
} );
mid = midPtr - &i_buildItems[0];
// Continue onto splitting equally if failed
if ( mid != i_start && mid != i_end )
{
break;
}
}
case SplitMethod::EQUAL:
default:
{
// Reset mid in case we are defaulting to equal splitting
mid = ( i_start + i_end ) / 2.0;
// Split into equal sized subsets
std::nth_element(
&i_buildItems[ i_start ],
&i_buildItems[ mid ],
&i_buildItems[ i_end - 1 ] + 1,
[ dim ]( const BVHItem &i0, const BVHItem &i1 ) {
return i0.center[ dim ] < i1.center[ dim ];
} );
break;
}
}
// Build left tree
buildNode( i_method, i_buildItems, i_start, mid );
size_t offset = m_nodes.size();
// Build right tree
buildNode( i_method, i_buildItems, mid, i_end );
// Initialize the interior node
m_nodes[ nodeIndex ].initInterior( bounds, offset, dim );
}
}
}
