bvh_pbrt.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015-2016 Mario Luzeiro <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

 
#include "bvh_pbrt.h"
#include "../../../3d_fastmath.h"
#include <macros.h>
 
#include <boost/range/algorithm/nth_element.hpp>
#include <boost/range/algorithm/partition.hpp>
#include <cstdlib>
#include <vector>
 
#include <stack>
#include <wx/debug.h>
 
#ifdef PRINT_STATISTICS_3D_VIEWER
#include <stdio.h>
#endif
 
// BVHAccel Local Declarations
struct BVHPrimitiveInfo
{
    BVHPrimitiveInfo()
    {
        primitiveNumber = 0;
        bounds.Reset();
        centroid = SFVEC3F( 0.0f );
    }
 
    BVHPrimitiveInfo( int aPrimitiveNumber, const BBOX_3D& aBounds ) :
        primitiveNumber( aPrimitiveNumber ),
        bounds( aBounds ),
        centroid( .5f * aBounds.Min() + .5f * aBounds.Max() ) {}
 
    int     primitiveNumber;
    BBOX_3D bounds;
    SFVEC3F centroid;
};
 
 
struct BVHBuildNode
{
    // BVHBuildNode Public Methods
    void InitLeaf( int first, int n, const BBOX_3D& b)
    {
        firstPrimOffset = first;
        nPrimitives = n;
        bounds = b;
        children[0] = children[1] = nullptr;
    }
 
    void InitInterior( int axis, BVHBuildNode* c0, BVHBuildNode* c1 )
    {
        children[0] = c0;
        children[1] = c1;
        bounds.Set( c0->bounds );
        bounds.Union( c1->bounds );
        splitAxis = axis;
        nPrimitives = 0;
    }
 
    BBOX_3D bounds;
    BVHBuildNode* children[2];
    int splitAxis, firstPrimOffset, nPrimitives;
};
 
 
struct MortonPrimitive
{
    int primitiveIndex;
    uint32_t mortonCode;
};
 
 
struct LBVHTreelet
{
    int startIndex, numPrimitives;
    BVHBuildNode *buildNodes;
};
 
 
// BVHAccel Utility Functions
inline uint32_t LeftShift3( uint32_t x )
{
    wxASSERT( x <= (1 << 10) );
 
    if( x == ( 1 << 10 ) )
        --x;
 
    x = ( x | ( x << 16 ) ) & 0b00000011000000000000000011111111;
    // x = ---- --98 ---- ---- ---- ---- 7654 3210
    x = ( x | ( x << 8 ) ) & 0b00000011000000001111000000001111;
    // x = ---- --98 ---- ---- 7654 ---- ---- 3210
    x = ( x | ( x << 4 ) ) & 0b00000011000011000011000011000011;
    // x = ---- --98 ---- 76-- --54 ---- 32-- --10
    x = ( x | ( x << 2 ) ) & 0b00001001001001001001001001001001;
    // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
 
    return x;
}
 
 
inline uint32_t EncodeMorton3( const SFVEC3F& v )
{
    wxASSERT( v.x >= 0 && v.x <= ( 1 << 10 ) );
    wxASSERT( v.y >= 0 && v.y <= ( 1 << 10 ) );
    wxASSERT( v.z >= 0 && v.z <= ( 1 << 10 ) );
 
    return ( LeftShift3( v.z ) << 2 ) | ( LeftShift3( v.y ) << 1 ) | LeftShift3( v.x );
}
 
 
static void RadixSort( std::vector<MortonPrimitive>* v )
{
    std::vector<MortonPrimitive> tempVector( v->size() );
 
    const int bitsPerPass = 6;
    const int nBits = 30;
 
    wxASSERT( ( nBits % bitsPerPass ) == 0 );
 
    const int nPasses = nBits / bitsPerPass;
 
    for( int pass = 0; pass < nPasses; ++pass )
    {
        // Perform one pass of radix sort, sorting _bitsPerPass_ bits
        const int lowBit = pass * bitsPerPass;
 
        // Set in and out vector pointers for radix sort pass
        std::vector<MortonPrimitive>& in = ( pass & 1 ) ? tempVector : *v;
        std::vector<MortonPrimitive>& out = ( pass & 1 ) ? *v : tempVector;
 
        // Count number of zero bits in array for current radix sort bit
        const int nBuckets = 1 << bitsPerPass;
        int bucketCount[nBuckets] = {0};
        const int bitMask = ( 1 << bitsPerPass ) - 1;
 
        for( uint32_t i = 0; i < in.size(); ++i )
        {
            const MortonPrimitive &mp = in[i];
            int bucket = ( mp.mortonCode >> lowBit ) & bitMask;
 
            wxASSERT( ( bucket >= 0 ) && ( bucket < nBuckets ) );
 
            ++bucketCount[bucket];
        }
 
        // Compute starting index in output array for each bucket
        int startIndex[nBuckets];
        startIndex[0] = 0;
 
        for( int i = 1; i < nBuckets; ++i )
            startIndex[i] = startIndex[i - 1] + bucketCount[i - 1];
 
        // Store sorted values in output array
        for( uint32_t i = 0; i < in.size(); ++i )
        {
            const MortonPrimitive& mp = in[i];
            int bucket = (mp.mortonCode >> lowBit) & bitMask;
            out[startIndex[bucket]++] = mp;
        }
    }
 
    // Copy final result from _tempVector_, if needed
    if( nPasses & 1 )
        std::swap( *v, tempVector );
}
 
 
BVH_PBRT::BVH_PBRT( const CONTAINER_3D_BASE& aObjectContainer, int aMaxPrimsInNode,
                    SPLITMETHOD aSplitMethod ) :
    m_maxPrimsInNode( std::min( 255, aMaxPrimsInNode ) ),
    m_splitMethod( aSplitMethod )
{
    if( aObjectContainer.GetList().empty() )
    {
        m_nodes = nullptr;
 
        return;
    }
 
    // Initialize the indexes of ray packet for partition traversal
    for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i )
    {
        m_I[i] = i;
    }
 
    // Convert the objects list to vector of objects
    aObjectContainer.ConvertTo( m_primitives );
 
    wxASSERT( aObjectContainer.GetList().size() == m_primitives.size() );
 
    // Initialize _primitiveInfo_ array for primitives
    std::vector<BVHPrimitiveInfo> primitiveInfo( m_primitives.size() );
 
    for( size_t i = 0; i < m_primitives.size(); ++i )
    {
        wxASSERT( m_primitives[i]->GetBBox().IsInitialized() );
 
        primitiveInfo[i] = BVHPrimitiveInfo( i, m_primitives[i]->GetBBox() );
    }
 
    // Build BVH tree for primitives using _primitiveInfo_
    int totalNodes = 0;
 
    CONST_VECTOR_OBJECT orderedPrims;
    orderedPrims.clear();
    orderedPrims.reserve( m_primitives.size() );
 
    BVHBuildNode *root;
 
    if( m_splitMethod == SPLITMETHOD::HLBVH )
        root = HLBVHBuild( primitiveInfo, &totalNodes, orderedPrims );
    else
        root = recursiveBuild( primitiveInfo, 0, m_primitives.size(), &totalNodes, orderedPrims );
 
    wxASSERT( m_primitives.size() == orderedPrims.size() );
 
    m_primitives.swap( orderedPrims );
 
    // Compute representation of depth-first traversal of BVH tree
    m_nodes = static_cast<LinearBVHNode*>( malloc( sizeof( LinearBVHNode ) * totalNodes ) );
    m_nodesToFree.push_back( m_nodes );
 
    for( int i = 0; i < totalNodes; ++i )
    {
        m_nodes[i].bounds.Reset();
        m_nodes[i].primitivesOffset = 0;
        m_nodes[i].nPrimitives = 0;
        m_nodes[i].axis = 0;
    }
 
    uint32_t offset = 0;
 
    flattenBVHTree( root, &offset );
 
    wxASSERT( offset == (unsigned int)totalNodes );
}
 
 
BVH_PBRT::~BVH_PBRT()
{
    if( !m_nodesToFree.empty() )
    {
        for( std::list<void *>::iterator ii = m_nodesToFree.begin(); ii != m_nodesToFree.end();
             ++ii )
        {
            free( *ii );
            *ii = nullptr;
        }
    }
 
    m_nodesToFree.clear();
}
 
 
struct ComparePoints
{
    explicit ComparePoints( int d ) { dim = d; }
 
    int dim;
 
    bool operator()( const BVHPrimitiveInfo& a, const BVHPrimitiveInfo& b ) const
    {
        return a.centroid[dim] < b.centroid[dim];
    }
};
 
 
struct CompareToMid
{
    explicit CompareToMid( int d, float m ) { dim = d; mid = m; }
 
    int dim;
    float mid;
 
    bool operator()( const BVHPrimitiveInfo& a ) const
    {
        return a.centroid[dim] < mid;
    }
};
 
 
struct CompareToBucket
{
    CompareToBucket( int split, int num, int d, const BBOX_3D& b )
        : centroidBounds( b )
    {
        splitBucket = split;
        nBuckets = num;
        dim = d;
    }
 
    bool operator()( const BVHPrimitiveInfo& p ) const;
 
    int splitBucket, nBuckets, dim;
 
    const BBOX_3D& centroidBounds;
};
 
 
bool CompareToBucket::operator()( const BVHPrimitiveInfo& p ) const
{
    const float centroid = p.centroid[dim];
 
    int b = nBuckets *
            // Computes the offset (0.0 - 1.0) for one axis
            ( ( centroid - centroidBounds.Min()[dim] ) /
              ( centroidBounds.Max()[dim] - centroidBounds.Min()[dim] ) );
 
    if( b == nBuckets )
        b = nBuckets - 1;
 
    wxASSERT( ( b >= 0 ) && ( b < nBuckets ) );
 
    return b <= splitBucket;
}
 
 
struct HLBVH_SAH_Evaluator
{
    HLBVH_SAH_Evaluator( int split, int num, int d, const BBOX_3D& b )
        : centroidBounds(b)
    {
        minCostSplitBucket = split;
        nBuckets = num; dim = d;
    }
 
    bool operator()( const BVHBuildNode* node ) const;
 
    int minCostSplitBucket, nBuckets, dim;
    const BBOX_3D& centroidBounds;
};
 
 
bool HLBVH_SAH_Evaluator::operator()( const BVHBuildNode* node ) const
{
    const float centroid = node->bounds.GetCenter( dim );
 
    int b = nBuckets *
            // Computes the offset (0.0 - 1.0) for one axis
            ( ( centroid - centroidBounds.Min()[dim] ) /
              ( centroidBounds.Max()[dim] - centroidBounds.Min()[dim] ) );
 
    if( b == nBuckets )
        b = nBuckets - 1;
 
    wxASSERT( b >= 0 && b < nBuckets );
 
    return b <= minCostSplitBucket;
}
 
 
struct BucketInfo
{
    int count;
    BBOX_3D bounds;
};
 
 
BVHBuildNode *BVH_PBRT::recursiveBuild ( std::vector<BVHPrimitiveInfo>& primitiveInfo,
                                         int start, int end, int* totalNodes,
                                         CONST_VECTOR_OBJECT& orderedPrims )
{
    wxASSERT( totalNodes != nullptr );
    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 a memory arena
    BVHBuildNode *node = static_cast<BVHBuildNode *>( malloc( sizeof( BVHBuildNode ) ) );
    m_nodesToFree.push_back( node );
 
    node->bounds.Reset();
    node->firstPrimOffset = 0;
    node->nPrimitives = 0;
    node->splitAxis = 0;
    node->children[0] = nullptr;
    node->children[1] = nullptr;
 
    // Compute bounds of all primitives in BVH node
    BBOX_3D 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_
        BBOX_3D 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 OBJECT_3D* obj = static_cast<const OBJECT_3D*>( m_primitives[ primitiveNr ] );
 
                wxASSERT( obj != nullptr );
 
                orderedPrims.push_back( obj );
            }
 
            node->InitLeaf( firstPrimOffset, nPrimitives, bounds );
        }
        else
        {
            // Partition primitives based on _splitMethod_
            switch( m_splitMethod )
            {
            case SPLITMETHOD::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 ) )
                    break;
            }
 
            // Intentionally fall through to SPLITMETHOD::EQUAL_COUNTS since prims
            // with large overlapping bounding boxes may fail to partition
            KI_FALLTHROUGH;
 
            case SPLITMETHOD::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 SPLITMETHOD::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 )
                    {
                        BBOX_3D 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 *BVH_PBRT::HLBVHBuild( const std::vector<BVHPrimitiveInfo>& primitiveInfo,
                                    int* totalNodes, CONST_VECTOR_OBJECT& orderedPrims )
{
    // Compute bounding box of all primitive centroids
    BBOX_3D bounds;
    bounds.Reset();
 
    for( unsigned int i = 0; i < primitiveInfo.size(); ++i )
        bounds.Union( primitiveInfo[i].centroid );
 
    // Compute Morton indices of primitives
    std::vector<MortonPrimitive> mortonPrims( primitiveInfo.size() );
 
    for( int i = 0; i < (int)primitiveInfo.size(); ++i )
    {
        // Initialize _mortonPrims[i]_ for _i_th primitive
        const int mortonBits  = 10;
        const int mortonScale = 1 << mortonBits;
 
        wxASSERT( primitiveInfo[i].primitiveNumber < (int)primitiveInfo.size() );
 
        mortonPrims[i].primitiveIndex = primitiveInfo[i].primitiveNumber;
 
        const SFVEC3F centroidOffset = bounds.Offset( primitiveInfo[i].centroid );
 
        wxASSERT( ( centroidOffset.x >= 0.0f ) && ( centroidOffset.x <= 1.0f ) );
        wxASSERT( ( centroidOffset.y >= 0.0f ) && ( centroidOffset.y <= 1.0f ) );
        wxASSERT( ( centroidOffset.z >= 0.0f ) && ( centroidOffset.z <= 1.0f ) );
 
        mortonPrims[i].mortonCode = EncodeMorton3( centroidOffset * SFVEC3F( (float)mortonScale ) );
    }
 
    // Radix sort primitive Morton indices
    RadixSort( &mortonPrims );
 
    // Create LBVH treelets at bottom of BVH
 
    // Find intervals of primitives for each treelet
    std::vector<LBVHTreelet> treeletsToBuild;
 
    for( int start = 0, end = 1; end <= (int)mortonPrims.size(); ++end )
    {
        const uint32_t mask = 0b00111111111111000000000000000000;
 
        if( ( end == (int) mortonPrims.size() )
          || ( ( mortonPrims[start].mortonCode & mask )
               != ( mortonPrims[end].mortonCode & mask ) ) )
        {
            // Add entry to _treeletsToBuild_ for this treelet
            const int numPrimitives = end - start;
            const int maxBVHNodes = 2 * numPrimitives;
 
            // !TODO: implement a memory arena
            BVHBuildNode *nodes = static_cast<BVHBuildNode *>( malloc( maxBVHNodes *
                                                                       sizeof( BVHBuildNode ) ) );
 
            m_nodesToFree.push_back( nodes );
 
            for( int i = 0; i < maxBVHNodes; ++i )
            {
                nodes[i].bounds.Reset();
                nodes[i].firstPrimOffset = 0;
                nodes[i].nPrimitives = 0;
                nodes[i].splitAxis = 0;
                nodes[i].children[0] = nullptr;
                nodes[i].children[1] = nullptr;
            }
 
            LBVHTreelet tmpTreelet;
 
            tmpTreelet.startIndex = start;
            tmpTreelet.numPrimitives = numPrimitives;
            tmpTreelet.buildNodes = nodes;
 
            treeletsToBuild.push_back( tmpTreelet );
 
            start = end;
        }
    }
 
    // Create LBVHs for treelets in parallel
    int atomicTotal = 0;
    int orderedPrimsOffset = 0;
 
    orderedPrims.resize( m_primitives.size() );
 
    for( int index = 0; index < (int)treeletsToBuild.size(); ++index )
    {
        // Generate _index_th LBVH treelet
        int nodesCreated = 0;
        const int firstBit = 29 - 12;
 
        LBVHTreelet &tr = treeletsToBuild[index];
 
        wxASSERT( tr.startIndex < (int)mortonPrims.size() );
 
        tr.buildNodes = emitLBVH( tr.buildNodes, primitiveInfo, &mortonPrims[tr.startIndex],
                                  tr.numPrimitives, &nodesCreated, orderedPrims,
                                  &orderedPrimsOffset, firstBit );
 
        atomicTotal += nodesCreated;
    }
 
    *totalNodes = atomicTotal;
 
    // Initialize _finishedTreelets_ with treelet root node pointers
    std::vector<BVHBuildNode *> finishedTreelets;
    finishedTreelets.reserve( treeletsToBuild.size() );
 
    for( int index = 0; index < (int)treeletsToBuild.size(); ++index )
        finishedTreelets.push_back( treeletsToBuild[index].buildNodes );
 
    // Create and return SAH BVH from LBVH treelets
    return buildUpperSAH( finishedTreelets, 0, finishedTreelets.size(), totalNodes );
}
 
 
BVHBuildNode *BVH_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 != nullptr );
    wxASSERT( orderedPrimsOffset != nullptr );
    wxASSERT( nPrimitives > 0 );
    wxASSERT( mortonPrims != nullptr );
 
    if( ( bit == -1 ) || ( nPrimitives < m_maxPrimsInNode ) )
    {
        // Create and return leaf node of LBVH treelet
        (*totalNodes)++;
 
        BVHBuildNode *node = buildNodes++;
        BBOX_3D 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 *BVH_PBRT::buildUpperSAH( std::vector<BVHBuildNode*>& treeletRoots, int start,
                                       int end, int* totalNodes )
{
    wxASSERT( totalNodes != nullptr );
    wxASSERT( start < end );
    wxASSERT( end <= (int)treeletRoots.size() );
 
    int nNodes = end - start;
 
    if( nNodes == 1 )
        return treeletRoots[start];
 
    (*totalNodes)++;
 
    BVHBuildNode* node = static_cast<BVHBuildNode*>( malloc( sizeof( BVHBuildNode ) ) );
 
    m_nodesToFree.push_back( node );
 
    node->bounds.Reset();
    node->firstPrimOffset = 0;
    node->nPrimitives = 0;
    node->splitAxis = 0;
    node->children[0] = nullptr;
    node->children[1] = nullptr;
 
    // Compute bounds of all nodes under this HLBVH node
    BBOX_3D 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_
    BBOX_3D 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 )
    {
        BBOX_3D 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;
}
 
 
int BVH_PBRT::flattenBVHTree( BVHBuildNode* node, uint32_t* offset )
{
    LinearBVHNode *linearNode = &m_nodes[*offset];
 
    linearNode->bounds = node->bounds;
 
    int myOffset = (*offset)++;
 
    if( node->nPrimitives > 0 )
    {
        wxASSERT( ( !node->children[0] ) && ( !node->children[1] ) );
        wxASSERT( node->nPrimitives < 65536 );
 
        linearNode->primitivesOffset = node->firstPrimOffset;
        linearNode->nPrimitives = node->nPrimitives;
    }
    else
    {
        // Create interior flattened BVH node
        linearNode->axis = node->splitAxis;
        linearNode->nPrimitives = 0;
        flattenBVHTree( node->children[0], offset );
        linearNode->secondChildOffset = flattenBVHTree( node->children[1], offset );
    }
 
    return myOffset;
}
 
 
#define MAX_TODOS 64
 
 
bool BVH_PBRT::Intersect( const RAY& aRay, HITINFO& aHitInfo ) const
{
    if( !m_nodes )
        return false;
 
    bool hit = false;
 
    // Follow ray through BVH nodes to find primitive intersections
    int todoOffset = 0, nodeNum = 0;
    int todo[MAX_TODOS];
 
    while( true )
    {
        const LinearBVHNode *node = &m_nodes[nodeNum];
 
        wxASSERT( todoOffset < MAX_TODOS );
 
        // Check ray against BVH node
        float hitBox = 0.0f;
 
        const bool hitted = node->bounds.Intersect( aRay, &hitBox );
 
        if( hitted && ( hitBox < aHitInfo.m_tHit ) )
        {
            if( node->nPrimitives > 0 )
            {
                // Intersect ray with primitives in leaf BVH node
                for( int i = 0; i < node->nPrimitives; ++i )
                {
                    if( m_primitives[node->primitivesOffset + i]->Intersect( aRay, aHitInfo ) )
                    {
                        aHitInfo.m_acc_node_info = nodeNum;
                        hit = true;
                    }
                }
            }
            else
            {
                // Put far BVH node on _todo_ stack, advance to near node
                if( aRay.m_dirIsNeg[node->axis] )
                {
                    todo[todoOffset++] = nodeNum + 1;
                    nodeNum = node->secondChildOffset;
                }
                else
                {
                    todo[todoOffset++] = node->secondChildOffset;
                    nodeNum = nodeNum + 1;
                }
 
                continue;
            }
        }
 
        if( todoOffset == 0 )
            break;
 
        nodeNum = todo[--todoOffset];
    }
 
    return hit;
}
 

bool BVH_PBRT::Intersect( const RAY& aRay, HITINFO& aHitInfo, unsigned int aAccNodeInfo ) const
{
    if( !m_nodes )
        return false;
 
    bool hit = false;
 
    // Follow ray through BVH nodes to find primitive intersections
    int todoOffset = 0, nodeNum = aAccNodeInfo;
    int todo[MAX_TODOS];
 
    while( true )
    {
        const LinearBVHNode *node = &m_nodes[nodeNum];
 
        wxASSERT( todoOffset < MAX_TODOS );
 
        // Check ray against BVH node
        float hitBox = 0.0f;
 
        const bool hitted = node->bounds.Intersect( aRay, &hitBox );
 
        if( hitted && ( hitBox < aHitInfo.m_tHit ) )
        {
            if( node->nPrimitives > 0 )
            {
                // Intersect ray with primitives in leaf BVH node
                for( int i = 0; i < node->nPrimitives; ++i )
                {
                    if( m_primitives[node->primitivesOffset + i]->Intersect( aRay, aHitInfo ) )
                    {
                        //aHitInfo.m_acc_node_info = nodeNum;
                        hit = true;
                    }
                }
            }
            else
            {
                // Put far BVH node on _todo_ stack, advance to near node
                if( aRay.m_dirIsNeg[node->axis] )
                {
                    todo[todoOffset++] = nodeNum + 1;
                    nodeNum = node->secondChildOffset;
                }
                else
                {
                    todo[todoOffset++] = node->secondChildOffset;
                    nodeNum = nodeNum + 1;
                }
 
                continue;
            }
        }
 
        if( todoOffset == 0 )
            break;
 
        nodeNum = todo[--todoOffset];
    }
 
    return hit;
}
 
 
bool BVH_PBRT::IntersectP( const RAY& aRay, float aMaxDistance ) const
{
    if( !m_nodes )
        return false;
 
    // Follow ray through BVH nodes to find primitive intersections
    int todoOffset = 0, nodeNum = 0;
    int todo[MAX_TODOS];
 
    while( true )
    {
        const LinearBVHNode* node = &m_nodes[nodeNum];
 
        wxASSERT( todoOffset < MAX_TODOS );
 
        // Check ray against BVH node
        float hitBox = 0.0f;
 
        const bool hitted = node->bounds.Intersect( aRay, &hitBox );
 
        if( hitted && ( hitBox < aMaxDistance ) )
        {
            if( node->nPrimitives > 0 )
            {
                // Intersect ray with primitives in leaf BVH node
                for( int i = 0; i < node->nPrimitives; ++i )
                {
                    const OBJECT_3D* obj = m_primitives[node->primitivesOffset + i];
 
                    if( obj->GetMaterial()->GetCastShadows()
                      && obj->IntersectP( aRay, aMaxDistance ) )
                        return true;
                }
            }
            else
            {
                // Put far BVH node on _todo_ stack, advance to near node
                if( aRay.m_dirIsNeg[node->axis] )
                {
                    todo[todoOffset++] = nodeNum + 1;
                    nodeNum = node->secondChildOffset;
                }
                else
                {
                    todo[todoOffset++] = node->secondChildOffset;
                    nodeNum = nodeNum + 1;
                }
 
                continue;
            }
        }
 
        if( todoOffset == 0 )
            break;
 
        nodeNum = todo[--todoOffset];
    }
 
    return false;
}