void BVH::createLeafNode(int start, int end, AABoundingBox &bbox, BVHBuildNode *node, int *numTotalNodes)
{
int firstTriOffset = m_orderedTriangles.size();
int firstInstanceOffset = m_orderedInstances.size();
int numTris = 0;
int numInstances = 0;
for(int i=start; i<end;i++){
if(m_buildData[i].m_type == 0){
int triangleId = m_buildData[i].m_triangleId;
m_orderedTriangles.push_back(m_triangles[triangleId]);
numTris++;
}
else{
int instanceId = m_buildData[i].m_triangleId;
m_orderedInstances.push_back(m_instances[instanceId]);
numInstances++;
}
}
if(numInstances == 0)
node->initLeaf(firstTriOffset, numTris, bbox, 0);
else{
BVHBuildNode *leftNode;
BVHBuildNode *rightNode;
rightNode = node;
if(numTris > 0){
rightNode = new BVHBuildNode();
leftNode = new BVHBuildNode();
(*numTotalNodes)+=2;
leftNode->initLeaf(firstTriOffset, numTris, bbox, 0);
node->initInterior(0, leftNode, rightNode);
}
rightNode->initLeaf(firstInstanceOffset, numInstances, bbox, 1);
}
}
BVHBuildNode *BVH::recursiveBuild(int start, int end, int *numTotalNodes)
{
AABoundingBox bbox;
for(int i=start; i<end; i++){
bbox.join(m_buildData[i].m_bbox);
}
BVHBuildNode *node = new BVHBuildNode();
(*numTotalNodes)++;
int numTriangles = end - start;
if(numTriangles == 1){
createLeafNode(start,end,bbox,node, numTotalNodes);
}
else{
AABoundingBox bboxCentroids;
for(int i=start; i<end; i++){
bboxCentroids.join(m_buildData[i].m_centroid);
}
int dim = bboxCentroids.getMaximumExtent();
if(bboxCentroids.min(dim) == bboxCentroids.max(dim)){
createLeafNode(start,end,bbox,node,numTotalNodes);
}
else{
float splitCost;
int splitBucket;
findSAHSplit(dim,start,end,bboxCentroids,bbox, &splitCost, &splitBucket);
if(numTriangles > 6 || splitCost < numTriangles){
BVHTriangleInfo *midPtr = std::partition(&m_buildData[start], &m_buildData[end], CompareToBucket(dim, splitBucket, 12, bboxCentroids));
int mid = midPtr - &m_buildData[0];
if(mid == start || mid == end){
mid = start+1;
}
node->initInterior(dim, recursiveBuild(start,mid,numTotalNodes), recursiveBuild(mid,end,numTotalNodes));
}
else{
createLeafNode(start,end,bbox,node,numTotalNodes);
}
}
}
return node;
}
BVHBuildNode *CBVH_PBRT::buildUpperSAH(
std::vector<BVHBuildNode *> &treeletRoots,
int start, int end,
int *totalNodes )
{
wxASSERT( totalNodes != NULL );
wxASSERT( start < end );
wxASSERT( end <= (int)treeletRoots.size() );
int nNodes = end - start;
if( nNodes == 1 )
return treeletRoots[start];
(*totalNodes)++;
BVHBuildNode *node = static_cast<BVHBuildNode *>( _mm_malloc( sizeof( BVHBuildNode ),
L1_CACHE_LINE_SIZE ) );
m_addresses_pointer_to_mm_free.push_back( node );
node->bounds.Reset();
node->firstPrimOffset = 0;
node->nPrimitives = 0;
node->splitAxis = 0;
node->children[0] = NULL;
node->children[1] = NULL;
// Compute bounds of all nodes under this HLBVH node
CBBOX bounds;
bounds.Reset();
for( int i = start; i < end; ++i )
bounds.Union( treeletRoots[i]->bounds );
// Compute bound of HLBVH node centroids, choose split dimension _dim_
CBBOX centroidBounds;
centroidBounds.Reset();
for( int i = start; i < end; ++i )
{
SFVEC3F centroid =
(treeletRoots[i]->bounds.Min() + treeletRoots[i]->bounds.Max()) *
0.5f;
centroidBounds.Union(centroid);
}
const int dim = centroidBounds.MaxDimension();
// FIXME: if this hits, what do we need to do?
// Make sure the SAH split below does something... ?
wxASSERT( centroidBounds.Max()[dim] != centroidBounds.Min()[dim] );
// Allocate _BucketInfo_ for SAH partition buckets
const int nBuckets = 12;
BucketInfo buckets[nBuckets];
for( int i = 0; i < nBuckets; ++i )
{
buckets[i].count = 0;
buckets[i].bounds.Reset();
}
// Initialize _BucketInfo_ for HLBVH SAH partition buckets
for( int i = start; i < end; ++i )
{
const float centroid = ( treeletRoots[i]->bounds.Min()[dim] +
treeletRoots[i]->bounds.Max()[dim] ) *
0.5f;
int b =
nBuckets * ( (centroid - centroidBounds.Min()[dim] ) /
(centroidBounds.Max()[dim] - centroidBounds.Min()[dim] ) );
if( b == nBuckets )
b = nBuckets - 1;
wxASSERT( (b >= 0) && (b < nBuckets) );
buckets[b].count++;
buckets[b].bounds.Union( treeletRoots[i]->bounds );
}
// Compute costs for splitting after each bucket
float cost[nBuckets - 1];
for( int i = 0; i < nBuckets - 1; ++i )
{
CBBOX b0, b1;
b0.Reset();
b1.Reset();
int count0 = 0, count1 = 0;
for( int j = 0; j <= i; ++j )
{
if( buckets[j].count )
{
count0 += buckets[j].count;
b0.Union( buckets[j].bounds );
}
}
for( int j = i + 1; j < nBuckets; ++j )
{
if( buckets[j].count )
{
count1 += buckets[j].count;
b1.Union( buckets[j].bounds );
}
}
cost[i] = .125f +
( count0 * b0.SurfaceArea() + count1 * b1.SurfaceArea() ) /
bounds.SurfaceArea();
}
// Find bucket to split at that minimizes SAH metric
float minCost = cost[0];
int minCostSplitBucket = 0;
for( int i = 1; i < nBuckets - 1; ++i )
{
if( cost[i] < minCost )
{
minCost = cost[i];
minCostSplitBucket = i;
}
}
// Split nodes and create interior HLBVH SAH node
BVHBuildNode **pmid = std::partition( &treeletRoots[start],
&treeletRoots[end - 1] + 1,
HLBVH_SAH_Evaluator( minCostSplitBucket,
nBuckets,
dim,
centroidBounds ) );
const int mid = pmid - &treeletRoots[0];
wxASSERT( (mid > start) && (mid < end) );
node->InitInterior( dim,
buildUpperSAH( treeletRoots, start, mid, totalNodes ),
buildUpperSAH( treeletRoots, mid, end, totalNodes ) );
return node;
}
BVHBuildNode *CBVH_PBRT::emitLBVH(
BVHBuildNode *&buildNodes,
const std::vector<BVHPrimitiveInfo> &primitiveInfo,
MortonPrimitive *mortonPrims, int nPrimitives, int *totalNodes,
CONST_VECTOR_OBJECT &orderedPrims,
int *orderedPrimsOffset, int bit)
{
wxASSERT( nPrimitives > 0 );
wxASSERT( totalNodes != NULL );
wxASSERT( orderedPrimsOffset != NULL );
wxASSERT( nPrimitives > 0 );
wxASSERT( mortonPrims != NULL );
if( (bit == -1) || (nPrimitives < m_maxPrimsInNode) )
{
// Create and return leaf node of LBVH treelet
(*totalNodes)++;
BVHBuildNode *node = buildNodes++;
CBBOX bounds;
bounds.Reset();
int firstPrimOffset = *orderedPrimsOffset;
*orderedPrimsOffset += nPrimitives;
wxASSERT( (firstPrimOffset + (nPrimitives - 1)) < (int)orderedPrims.size() );
for( int i = 0; i < nPrimitives; ++i )
{
const int primitiveIndex = mortonPrims[i].primitiveIndex;
wxASSERT( primitiveIndex < (int)m_primitives.size() );
orderedPrims[firstPrimOffset + i] = m_primitives[primitiveIndex];
bounds.Union( primitiveInfo[primitiveIndex].bounds );
}
node->InitLeaf( firstPrimOffset, nPrimitives, bounds );
return node;
}
else
{
int mask = 1 << bit;
// Advance to next subtree level if there's no LBVH split for this bit
if( (mortonPrims[0].mortonCode & mask) ==
(mortonPrims[nPrimitives - 1].mortonCode & mask) )
return emitLBVH( buildNodes, primitiveInfo, mortonPrims, nPrimitives,
totalNodes, orderedPrims, orderedPrimsOffset,
bit - 1 );
// Find LBVH split point for this dimension
int searchStart = 0;
int searchEnd = nPrimitives - 1;
while( searchStart + 1 != searchEnd )
{
wxASSERT(searchStart != searchEnd);
const int mid = (searchStart + searchEnd) / 2;
if( (mortonPrims[searchStart].mortonCode & mask) ==
(mortonPrims[mid].mortonCode & mask) )
searchStart = mid;
else
{
wxASSERT( (mortonPrims[mid].mortonCode & mask) ==
(mortonPrims[searchEnd].mortonCode & mask) );
searchEnd = mid;
}
}
const int splitOffset = searchEnd;
wxASSERT( splitOffset <= (nPrimitives - 1) );
wxASSERT( (mortonPrims[splitOffset - 1].mortonCode & mask) !=
(mortonPrims[splitOffset].mortonCode & mask) );
// Create and return interior LBVH node
(*totalNodes)++;
BVHBuildNode *node = buildNodes++;
BVHBuildNode *lbvh[2];
lbvh[0] = emitLBVH( buildNodes, primitiveInfo, mortonPrims, splitOffset,
totalNodes, orderedPrims, orderedPrimsOffset, bit - 1 );
lbvh[1] = emitLBVH( buildNodes, primitiveInfo, &mortonPrims[splitOffset],
nPrimitives - splitOffset, totalNodes, orderedPrims,
orderedPrimsOffset, bit - 1 );
const int axis = bit % 3;
node->InitInterior( axis, lbvh[0], lbvh[1] );
return node;
}
}
BVHBuildNode *CBVH_PBRT::recursiveBuild ( std::vector<BVHPrimitiveInfo> &primitiveInfo,
int start,
int end,
int *totalNodes,
CONST_VECTOR_OBJECT &orderedPrims )
{
wxASSERT( totalNodes != NULL );
wxASSERT( start >= 0 );
wxASSERT( end >= 0 );
wxASSERT( start != end );
wxASSERT( start < end );
wxASSERT( start <= (int)primitiveInfo.size() );
wxASSERT( end <= (int)primitiveInfo.size() );
(*totalNodes)++;
// !TODO: implement an memory Arena
BVHBuildNode *node = static_cast<BVHBuildNode *>( _mm_malloc( sizeof( BVHBuildNode ),
L1_CACHE_LINE_SIZE ) );
m_addresses_pointer_to_mm_free.push_back( node );
node->bounds.Reset();
node->firstPrimOffset = 0;
node->nPrimitives = 0;
node->splitAxis = 0;
node->children[0] = NULL;
node->children[1] = NULL;
// Compute bounds of all primitives in BVH node
CBBOX bounds;
bounds.Reset();
for( int i = start; i < end; ++i )
bounds.Union( primitiveInfo[i].bounds );
int nPrimitives = end - start;
if( nPrimitives == 1 )
{
// Create leaf _BVHBuildNode_
int firstPrimOffset = orderedPrims.size();
for( int i = start; i < end; ++i )
{
int primitiveNr = primitiveInfo[i].primitiveNumber;
wxASSERT( primitiveNr < (int)m_primitives.size() );
orderedPrims.push_back( m_primitives[ primitiveNr ] );
}
node->InitLeaf( firstPrimOffset, nPrimitives, bounds );
}
else
{
// Compute bound of primitive centroids, choose split dimension _dim_
CBBOX centroidBounds;
centroidBounds.Reset();
for( int i = start; i < end; ++i )
centroidBounds.Union( primitiveInfo[i].centroid );
const int dim = centroidBounds.MaxDimension();
// Partition primitives into two sets and build children
int mid = (start + end) / 2;
if( fabs( centroidBounds.Max()[dim] -
centroidBounds.Min()[dim] ) < (FLT_EPSILON + FLT_EPSILON) )
{
// Create leaf _BVHBuildNode_
const int firstPrimOffset = orderedPrims.size();
for( int i = start; i < end; ++i )
{
int primitiveNr = primitiveInfo[i].primitiveNumber;
wxASSERT( (primitiveNr >= 0) &&
(primitiveNr < (int)m_primitives.size()) );
const COBJECT *obj = static_cast<const COBJECT *>( m_primitives[ primitiveNr ] );
wxASSERT( obj != NULL );
orderedPrims.push_back( obj );
}
node->InitLeaf( firstPrimOffset, nPrimitives, bounds );
}
else
{
// Partition primitives based on _splitMethod_
switch( m_splitMethod )
{
case SPLIT_MIDDLE:
{
// Partition primitives through node's midpoint
float pmid = centroidBounds.GetCenter( dim );
BVHPrimitiveInfo *midPtr = std::partition( &primitiveInfo[start],
&primitiveInfo[end - 1] + 1,
CompareToMid( dim, pmid ) );
mid = midPtr - &primitiveInfo[0];
wxASSERT( (mid >= start) &&
(mid <= end) );
if( (mid != start) && (mid != end) )
// for lots of prims with large overlapping bounding boxes, this
// may fail to partition; in that case don't break and fall through
// to SPLIT_EQUAL_COUNTS
break;
}
case SPLIT_EQUALCOUNTS:
{
// Partition primitives into equally-sized subsets
mid = (start + end) / 2;
std::nth_element( &primitiveInfo[start],
&primitiveInfo[mid],
&primitiveInfo[end - 1] + 1,
ComparePoints( dim ) );
break;
}
case SPLIT_SAH:
default:
{
// Partition primitives using approximate SAH
if( nPrimitives <= 2 )
{
// Partition primitives into equally-sized subsets
mid = (start + end) / 2;
std::nth_element( &primitiveInfo[start],
&primitiveInfo[mid],
&primitiveInfo[end - 1] + 1,
ComparePoints( dim ) );
}
else
{
// Allocate _BucketInfo_ for SAH partition buckets
const int nBuckets = 12;
BucketInfo buckets[nBuckets];
for( int i = 0; i < nBuckets; ++i )
{
buckets[i].count = 0;
buckets[i].bounds.Reset();
}
// Initialize _BucketInfo_ for SAH partition buckets
for( int i = start; i < end; ++i )
{
int b = nBuckets *
centroidBounds.Offset( primitiveInfo[i].centroid )[dim];
if( b == nBuckets )
b = nBuckets - 1;
wxASSERT( b >= 0 && b < nBuckets );
buckets[b].count++;
buckets[b].bounds.Union( primitiveInfo[i].bounds );
}
// Compute costs for splitting after each bucket
float cost[nBuckets - 1];
for( int i = 0; i < (nBuckets - 1); ++i )
{
CBBOX b0, b1;
b0.Reset();
b1.Reset();
int count0 = 0;
int count1 = 0;
for( int j = 0; j <= i; ++j )
{
if( buckets[j].count )
{
count0 += buckets[j].count;
b0.Union( buckets[j].bounds );
}
}
for( int j = i + 1; j < nBuckets; ++j )
{
if( buckets[j].count )
{
count1 += buckets[j].count;
b1.Union( buckets[j].bounds );
}
}
cost[i] = 1.0f +
( count0 * b0.SurfaceArea() +
count1 * b1.SurfaceArea() ) /
bounds.SurfaceArea();
}
// Find bucket to split at that minimizes SAH metric
float minCost = cost[0];
int minCostSplitBucket = 0;
for( int i = 1; i < (nBuckets - 1); ++i )
{
if( cost[i] < minCost )
{
minCost = cost[i];
minCostSplitBucket = i;
}
}
// Either create leaf or split primitives at selected SAH
// bucket
if( (nPrimitives > m_maxPrimsInNode) ||
(minCost < (float)nPrimitives) )
{
BVHPrimitiveInfo *pmid =
std::partition( &primitiveInfo[start],
&primitiveInfo[end - 1] + 1,
CompareToBucket( minCostSplitBucket,
nBuckets,
dim,
centroidBounds ) );
mid = pmid - &primitiveInfo[0];
wxASSERT( (mid >= start) &&
(mid <= end) );
}
else
{
// Create leaf _BVHBuildNode_
const int firstPrimOffset = orderedPrims.size();
for( int i = start; i < end; ++i )
{
const int primitiveNr = primitiveInfo[i].primitiveNumber;
wxASSERT( primitiveNr < (int)m_primitives.size() );
orderedPrims.push_back( m_primitives[ primitiveNr ] );
}
node->InitLeaf( firstPrimOffset, nPrimitives, bounds );
return node;
}
}
break;
}
}
node->InitInterior( dim,
recursiveBuild( primitiveInfo,
start,
mid,
totalNodes,
orderedPrims ),
recursiveBuild( primitiveInfo,
mid,
end,
totalNodes,
orderedPrims) );
}
}
return node;
}
BVHBuildNode *BVHAccel::recursiveBuild(MemoryArena &buildArena,
vector<BVHPrimitiveInfo> &buildData, uint32_t start,
uint32_t end, uint32_t *totalNodes,
vector<Reference<Primitive> > &orderedPrims) {
Assert(start != end);
(*totalNodes)++;
BVHBuildNode *node = buildArena.Alloc<BVHBuildNode>();
// Compute bounds of all primitives in BVH node
BBox bbox;
for (uint32_t i = start; i < end; ++i)
bbox = Union(bbox, buildData[i].bounds);
uint32_t nPrimitives = end - start;
if (nPrimitives == 1) {
// Create leaf _BVHBuildNode_
uint32_t firstPrimOffset = orderedPrims.size();
for (uint32_t i = start; i < end; ++i) {
uint32_t primNum = buildData[i].primitiveNumber;
orderedPrims.push_back(primitives[primNum]);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bbox);
}
else {
// Compute bound of primitive centroids, choose split dimension _dim_
BBox centroidBounds;
for (uint32_t i = start; i < end; ++i)
centroidBounds = Union(centroidBounds, buildData[i].centroid);
int dim = centroidBounds.MaximumExtent();
// Partition primitives into two sets and build children
uint32_t mid = (start + end) / 2;
if (centroidBounds.pMax[dim] == centroidBounds.pMin[dim]) {
// Create leaf _BVHBuildNode_
uint32_t firstPrimOffset = orderedPrims.size();
for (uint32_t i = start; i < end; ++i) {
uint32_t primNum = buildData[i].primitiveNumber;
orderedPrims.push_back(primitives[primNum]);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bbox);
return node;
}
// Partition primitives based on _splitMethod_
switch (splitMethod) {
case SPLIT_MIDDLE: {
// Partition primitives through node's midpoint
float pmid = .5f * (centroidBounds.pMin[dim] + centroidBounds.pMax[dim]);
BVHPrimitiveInfo *midPtr = std::partition(&buildData[start],
&buildData[end-1]+1,
CompareToMid(dim, pmid));
mid = midPtr - &buildData[0];
if (mid != start && mid != end)
// for lots of prims with large overlapping bounding boxes, this
// may fail to partition; in that case don't break and fall through
// to SPLIT_EQUAL_COUNTS
break;
}
case SPLIT_EQUAL_COUNTS: {
// Partition primitives into equally-sized subsets
mid = (start + end) / 2;
std::nth_element(&buildData[start], &buildData[mid],
&buildData[end-1]+1, ComparePoints(dim));
break;
}
case SPLIT_SAH: default: {
// Partition primitives using approximate SAH
if (nPrimitives <= 4) {
// Partition primitives into equally-sized subsets
mid = (start + end) / 2;
std::nth_element(&buildData[start], &buildData[mid],
&buildData[end-1]+1, ComparePoints(dim));
}
else {
// Allocate _BucketInfo_ for SAH partition buckets
const int nBuckets = 12;
struct BucketInfo {
BucketInfo() { count = 0; }
int count;
BBox bounds;
};
BucketInfo buckets[nBuckets];
// Initialize _BucketInfo_ for SAH partition buckets
for (uint32_t i = start; i < end; ++i) {
int b = nBuckets *
((buildData[i].centroid[dim] - centroidBounds.pMin[dim]) /
(centroidBounds.pMax[dim] - centroidBounds.pMin[dim]));
if (b == nBuckets) b = nBuckets-1;
Assert(b >= 0 && b < nBuckets);
buckets[b].count++;
buckets[b].bounds = Union(buckets[b].bounds, buildData[i].bounds);
}
// Compute costs for splitting after each bucket
float cost[nBuckets-1];
for (int i = 0; i < nBuckets-1; ++i) {
BBox b0, b1;
int count0 = 0, count1 = 0;
for (int j = 0; j <= i; ++j) {
b0 = Union(b0, buckets[j].bounds);
count0 += buckets[j].count;
}
for (int j = i+1; j < nBuckets; ++j) {
b1 = Union(b1, buckets[j].bounds);
count1 += buckets[j].count;
}
cost[i] = .125f + (count0*b0.SurfaceArea() + count1*b1.SurfaceArea()) /
bbox.SurfaceArea();
}
// Find bucket to split at that minimizes SAH metric
float minCost = cost[0];
uint32_t minCostSplit = 0;
for (int i = 1; i < nBuckets-1; ++i) {
if (cost[i] < minCost) {
minCost = cost[i];
minCostSplit = i;
}
}
// Either create leaf or split primitives at selected SAH bucket
if (nPrimitives > maxPrimsInNode ||
minCost < nPrimitives) {
BVHPrimitiveInfo *pmid = std::partition(&buildData[start],
&buildData[end-1]+1,
CompareToBucket(minCostSplit, nBuckets, dim, centroidBounds));
mid = pmid - &buildData[0];
}
else {
// Create leaf _BVHBuildNode_
uint32_t firstPrimOffset = orderedPrims.size();
for (uint32_t i = start; i < end; ++i) {
uint32_t primNum = buildData[i].primitiveNumber;
orderedPrims.push_back(primitives[primNum]);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bbox);
return node;
}
}
break;
}
}
node->InitInterior(dim,
recursiveBuild(buildArena, buildData, start, mid,
totalNodes, orderedPrims),
recursiveBuild(buildArena, buildData, mid, end,
totalNodes, orderedPrims));
}
return node;
}
BVHBuildNode *BVHAccel::buildUpperSAH(MemoryArena &arena,
std::vector<BVHBuildNode *> &treeletRoots,
int start, int end,
int *totalNodes) const {
Assert(start < end);
int nNodes = end - start;
if (nNodes == 1) return treeletRoots[start];
(*totalNodes)++;
BVHBuildNode *node = arena.Alloc<BVHBuildNode>();
// Compute bounds of all nodes under this HLBVH node
Bounds3f bounds;
for (int i = start; i < end; ++i)
bounds = Union(bounds, treeletRoots[i]->bounds);
// Compute bound of HLBVH node centroids, choose split dimension _dim_
Bounds3f centroidBounds;
for (int i = start; i < end; ++i) {
Point3f centroid =
(treeletRoots[i]->bounds.pMin + treeletRoots[i]->bounds.pMax) *
0.5f;
centroidBounds = Union(centroidBounds, centroid);
}
int dim = centroidBounds.MaximumExtent();
// FIXME: if this hits, what do we need to do?
// Make sure the SAH split below does something... ?
Assert(centroidBounds.pMax[dim] != centroidBounds.pMin[dim]);
// Allocate _BucketInfo_ for SAH partition buckets
constexpr int nBuckets = 12;
struct BucketInfo {
int count = 0;
Bounds3f bounds;
};
BucketInfo buckets[nBuckets];
// Initialize _BucketInfo_ for HLBVH SAH partition buckets
for (int i = start; i < end; ++i) {
Float centroid = (treeletRoots[i]->bounds.pMin[dim] +
treeletRoots[i]->bounds.pMax[dim]) *
0.5f;
int b =
nBuckets * ((centroid - centroidBounds.pMin[dim]) /
(centroidBounds.pMax[dim] - centroidBounds.pMin[dim]));
if (b == nBuckets) b = nBuckets - 1;
Assert(b >= 0 && b < nBuckets);
buckets[b].count++;
buckets[b].bounds = Union(buckets[b].bounds, treeletRoots[i]->bounds);
}
// Compute costs for splitting after each bucket
Float cost[nBuckets - 1];
for (int i = 0; i < nBuckets - 1; ++i) {
Bounds3f b0, b1;
int count0 = 0, count1 = 0;
for (int j = 0; j <= i; ++j) {
b0 = Union(b0, buckets[j].bounds);
count0 += buckets[j].count;
}
for (int j = i + 1; j < nBuckets; ++j) {
b1 = Union(b1, buckets[j].bounds);
count1 += buckets[j].count;
}
cost[i] = .125f +
(count0 * b0.SurfaceArea() + count1 * b1.SurfaceArea()) /
bounds.SurfaceArea();
}
// Find bucket to split at that minimizes SAH metric
Float minCost = cost[0];
int minCostSplitBucket = 0;
for (int i = 1; i < nBuckets - 1; ++i) {
if (cost[i] < minCost) {
minCost = cost[i];
minCostSplitBucket = i;
}
}
// Split nodes and create interior HLBVH SAH node
BVHBuildNode **pmid = std::partition(
&treeletRoots[start], &treeletRoots[end - 1] + 1,
[=](const BVHBuildNode *node) {
Float centroid =
(node->bounds.pMin[dim] + node->bounds.pMax[dim]) * 0.5f;
int b = nBuckets *
((centroid - centroidBounds.pMin[dim]) /
(centroidBounds.pMax[dim] - centroidBounds.pMin[dim]));
if (b == nBuckets) b = nBuckets - 1;
Assert(b >= 0 && b < nBuckets);
return b <= minCostSplitBucket;
});
int mid = pmid - &treeletRoots[0];
Assert(mid > start && mid < end);
node->InitInterior(
dim, buildUpperSAH(arena, treeletRoots, start, mid, totalNodes),
buildUpperSAH(arena, treeletRoots, mid, end, totalNodes));
return node;
}
BVHBuildNode *BVHAccel::emitLBVH(
BVHBuildNode *&buildNodes,
const std::vector<BVHPrimitiveInfo> &primitiveInfo,
MortonPrimitive *mortonPrims, int nPrimitives, int *totalNodes,
std::vector<std::shared_ptr<Primitive>> &orderedPrims,
std::atomic<int> *orderedPrimsOffset, int bitIndex) const {
Assert(nPrimitives > 0);
if (bitIndex == -1 || nPrimitives < maxPrimsInNode) {
// Create and return leaf node of LBVH treelet
(*totalNodes)++;
BVHBuildNode *node = buildNodes++;
Bounds3f bounds;
int firstPrimOffset = orderedPrimsOffset->fetch_add(nPrimitives);
for (int i = 0; i < nPrimitives; ++i) {
int primitiveIndex = mortonPrims[i].primitiveIndex;
orderedPrims[firstPrimOffset + i] = primitives[primitiveIndex];
bounds = Union(bounds, primitiveInfo[primitiveIndex].bounds);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bounds);
return node;
} else {
int mask = 1 << bitIndex;
// Advance to next subtree level if there's no LBVH split for this bit
if ((mortonPrims[0].mortonCode & mask) ==
(mortonPrims[nPrimitives - 1].mortonCode & mask))
return emitLBVH(buildNodes, primitiveInfo, mortonPrims, nPrimitives,
totalNodes, orderedPrims, orderedPrimsOffset,
bitIndex - 1);
// Find LBVH split point for this dimension
int searchStart = 0, searchEnd = nPrimitives - 1;
while (searchStart + 1 != searchEnd) {
Assert(searchStart != searchEnd);
int mid = (searchStart + searchEnd) / 2;
if ((mortonPrims[searchStart].mortonCode & mask) ==
(mortonPrims[mid].mortonCode & mask))
searchStart = mid;
else {
Assert((mortonPrims[mid].mortonCode & mask) ==
(mortonPrims[searchEnd].mortonCode & mask));
searchEnd = mid;
}
}
int splitOffset = searchEnd;
Assert(splitOffset <= nPrimitives - 1);
Assert((mortonPrims[splitOffset - 1].mortonCode & mask) !=
(mortonPrims[splitOffset].mortonCode & mask));
// Create and return interior LBVH node
(*totalNodes)++;
BVHBuildNode *node = buildNodes++;
BVHBuildNode *lbvh[2] = {
emitLBVH(buildNodes, primitiveInfo, mortonPrims, splitOffset,
totalNodes, orderedPrims, orderedPrimsOffset,
bitIndex - 1),
emitLBVH(buildNodes, primitiveInfo, &mortonPrims[splitOffset],
nPrimitives - splitOffset, totalNodes, orderedPrims,
orderedPrimsOffset, bitIndex - 1)};
int axis = bitIndex % 3;
node->InitInterior(axis, lbvh[0], lbvh[1]);
return node;
}
}
BVHBuildNode *BVHAccel::recursiveBuild(
MemoryArena &arena, std::vector<BVHPrimitiveInfo> &primitiveInfo, int start,
int end, int *totalNodes,
std::vector<std::shared_ptr<Primitive>> &orderedPrims) {
Assert(start != end);
BVHBuildNode *node = arena.Alloc<BVHBuildNode>();
(*totalNodes)++;
// Compute bounds of all primitives in BVH node
Bounds3f bounds;
for (int i = start; i < end; ++i)
bounds = Union(bounds, primitiveInfo[i].bounds);
int nPrimitives = end - start;
if (nPrimitives == 1) {
// Create leaf _BVHBuildNode_
int firstPrimOffset = orderedPrims.size();
for (int i = start; i < end; ++i) {
int primNum = primitiveInfo[i].primitiveNumber;
orderedPrims.push_back(primitives[primNum]);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bounds);
} else {
// Compute bound of primitive centroids, choose split dimension _dim_
Bounds3f centroidBounds;
for (int i = start; i < end; ++i)
centroidBounds = Union(centroidBounds, primitiveInfo[i].centroid);
int dim = centroidBounds.MaximumExtent();
// Partition primitives into two sets and build children
int mid = (start + end) / 2;
if (centroidBounds.pMax[dim] == centroidBounds.pMin[dim]) {
// Create leaf _BVHBuildNode_
int firstPrimOffset = orderedPrims.size();
for (int i = start; i < end; ++i) {
int primNum = primitiveInfo[i].primitiveNumber;
orderedPrims.push_back(primitives[primNum]);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bounds);
} else {
// Partition primitives based on _splitMethod_
switch (splitMethod) {
case SplitMethod::Middle: {
// Partition primitives through node's midpoint
Float pmid =
(centroidBounds.pMin[dim] + centroidBounds.pMax[dim]) / 2;
BVHPrimitiveInfo *midPtr = std::partition(
&primitiveInfo[start], &primitiveInfo[end - 1] + 1,
[dim, pmid](const BVHPrimitiveInfo &pi) {
return pi.centroid[dim] < pmid;
});
mid = midPtr - &primitiveInfo[0];
// For lots of prims with large overlapping bounding boxes, this
// may fail to partition; in that case don't break and fall
// through
// to EqualCounts.
if (mid != start && mid != end) break;
}
case SplitMethod::EqualCounts: {
// Partition primitives into equally-sized subsets
mid = (start + end) / 2;
std::nth_element(&primitiveInfo[start], &primitiveInfo[mid],
&primitiveInfo[end - 1] + 1,
[dim](const BVHPrimitiveInfo &a,
const BVHPrimitiveInfo &b) {
return a.centroid[dim] < b.centroid[dim];
});
break;
}
case SplitMethod::SAH:
default: {
// Partition primitives using approximate SAH
if (nPrimitives <= 4) {
// Partition primitives into equally-sized subsets
mid = (start + end) / 2;
std::nth_element(&primitiveInfo[start], &primitiveInfo[mid],
&primitiveInfo[end - 1] + 1,
[dim](const BVHPrimitiveInfo &a,
const BVHPrimitiveInfo &b) {
return a.centroid[dim] <
b.centroid[dim];
});
} else {
// Allocate _BucketInfo_ for SAH partition buckets
constexpr int nBuckets = 12;
struct BucketInfo {
int count = 0;
Bounds3f bounds;
};
BucketInfo buckets[nBuckets];
// Initialize _BucketInfo_ for SAH partition buckets
for (int i = start; i < end; ++i) {
int b = nBuckets *
centroidBounds.Offset(
primitiveInfo[i].centroid)[dim];
if (b == nBuckets) b = nBuckets - 1;
Assert(b >= 0 && b < nBuckets);
buckets[b].count++;
buckets[b].bounds =
Union(buckets[b].bounds, primitiveInfo[i].bounds);
}
// Compute costs for splitting after each bucket
Float cost[nBuckets - 1];
for (int i = 0; i < nBuckets - 1; ++i) {
Bounds3f b0, b1;
int count0 = 0, count1 = 0;
for (int j = 0; j <= i; ++j) {
b0 = Union(b0, buckets[j].bounds);
count0 += buckets[j].count;
}
for (int j = i + 1; j < nBuckets; ++j) {
b1 = Union(b1, buckets[j].bounds);
count1 += buckets[j].count;
}
cost[i] = .125f +
(count0 * b0.SurfaceArea() +
count1 * b1.SurfaceArea()) /
bounds.SurfaceArea();
}
// Find bucket to split at that minimizes SAH metric
Float minCost = cost[0];
int minCostSplitBucket = 0;
for (int i = 1; i < nBuckets - 1; ++i) {
if (cost[i] < minCost) {
minCost = cost[i];
minCostSplitBucket = i;
}
}
// Either create leaf or split primitives at selected SAH
// bucket
Float leafCost = nPrimitives;
if (nPrimitives > maxPrimsInNode || minCost < leafCost) {
BVHPrimitiveInfo *pmid = std::partition(
&primitiveInfo[start], &primitiveInfo[end - 1] + 1,
[=](const BVHPrimitiveInfo &pi) {
int b = nBuckets *
centroidBounds.Offset(pi.centroid)[dim];
if (b == nBuckets) b = nBuckets - 1;
Assert(b >= 0 && b < nBuckets);
return b <= minCostSplitBucket;
});
mid = pmid - &primitiveInfo[0];
} else {
// Create leaf _BVHBuildNode_
int firstPrimOffset = orderedPrims.size();
for (int i = start; i < end; ++i) {
int primNum = primitiveInfo[i].primitiveNumber;
orderedPrims.push_back(primitives[primNum]);
}
node->InitLeaf(firstPrimOffset, nPrimitives, bounds);
}
}
break;
}
}
node->InitInterior(dim,
recursiveBuild(arena, primitiveInfo, start, mid,
totalNodes, orderedPrims),
recursiveBuild(arena, primitiveInfo, mid, end,
totalNodes, orderedPrims));
}
}
return node;
}
