source: GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.cpp @ 2756

#include <queue>
#include <stack>
#include <fstream>
#include <iostream>
#include <iomanip>

#include "Bvh.h"
#include "Camera.h"
#include "Plane3.h"
#include "glInterface.h"
#include "Triangle3.h"
#include "SceneEntity.h"
#include "Geometry.h"

namespace CHCDemo
{

#define INVALID_TEST ((unsigned int)-1)

const static bool useVbos = true;
unsigned int Bvh::sCurrentVboId = -1;

using namespace std;



/*
3 x---------x 2
  |\         \
  | \         \
  |  \         \
  |     4 x---------x 5
  |   |         | 
0 x   |     x 1 |
   \  |         |
    \ |         |
     \|         |
        7 x---------x 6             
*/

static unsigned int sIndices[] =        
{7, // degenerated
 7, 6, 4, 5, 3, 2, 0, 1,
 1, 4, // degenerated
 4, 3, 7, 0, 6, 1, 5, 2,
 2 // degenerated
};


const static int sNumIndicesPerBox = 20;

/*      Order of vertices
        0 = (0, 0, 0)
        1 = (1, 0, 0)
        2 = (1, 1, 0)
        3 = (0, 1, 0)
        4 = (0, 1, 1)
        5 = (1, 1, 1)
        6 = (1, 0, 1)
        7 = (0, 0, 1)
*/

static Plane3 sNearPlane;
static Camera::Frustum sFrustum;

/// these values are valid for all nodes
static int sClipPlaneAABBVertexIndices[12];


BvhNode::BvhNode(BvhNode *parent): 
mParent(parent),
mAxis(-1), 
mDepth(0), 
mPlaneMask(0),
mPreferredPlane(0),
mLastRenderedFrame(-999),
mFirst(-1), 
mLast(-1),
mNumTestNodes(1),
mTestNodesIdx(-1),
mIndicesPtr(-1),
mIndices(NULL),
mId(0)
{
}


void BvhNode::ResetVisibility()
{
        mVisibility.Reset();

        mLastRenderedFrame = -999;
}


BvhNode::~BvhNode() 
{
}


void BvhNode::VisibilityInfo::Reset()
{
        mIsVisible = false;
        
        mAssumedVisibleFrames = 0;

        mLastVisitedFrame = -1;
        
        mTimesInvisible = 0;
        mIsFrustumCulled = false;

        mIsNew = true;
}


BvhLeaf::~BvhLeaf()
{
}


/***********************************************************/
/*                class Bvh implementation                 */
/***********************************************************/


Bvh::Bvh():
mCamera(NULL), 
mFrameId(-1), 
mRoot(NULL), 
mVertices(NULL),
mIndices(NULL),
mTestIndices(NULL),
mCurrentIndicesPtr(0)
{}

/*
Bvh::Bvh(const GeometryVector &geometry, 
                 DistanceSortedRenderAction *const renderer):
mCamera(NULL), 
mFrameId(-1), 
mRoot(NULL), 
mVertices(NULL),
mIndices(NULL),
mTestIndices(NULL),
mCurrentIndicesPtr(0),
{
        mGeometry = new NodeGeometry*[geometry.size()];
        mGeometrySize = geometry.size();

        BoundingBox sceneBox;

        // compute scene extent
        for (size_t i = 0; i < mGeometrySize; ++ i)
        {
                mGeometry[i] = geometry[i];
                sceneBox.combine(&mGeometry[i]->mBox);

                mBvhStats.mTriangles += mGeometry[i]->mNumTriangles;
        }


        ////////
        //-- create root

        BvhLeaf *leaf = new BvhLeaf(NULL);
        leaf->mDepth = 0;
        leaf->mFirst = 0;
        leaf->mLast = (int)geometry.size() - 1;
        leaf->mBox = sceneBox;

        OUT1("geometry in root: " << leaf->mLast);

        mRoot = leaf;
        mNumNodes = 1;

        // parameters
        mMaxGeometry = Settings::Global()->get_nvocc_bvh_max_objects();
        mMaxTriangles = Settings::Global()->get_nvocc_bvh_max_triangles();
        mMaxDepth = Settings::Global()->get_nvocc_bvh_max_depth();
        mSplitType = Settings::Global()->get_nvocc_bvh_split_type();

        float sceneArea = sceneBox.getSurface();
        float minAreaRatio = Settings::Global()->get_nvocc_bvh_min_area();

        mMinArea = minAreaRatio * sceneArea;

        mMaxDepthForTestingChildren = Settings::Global()->get_nvocc_bvh_max_depth_for_testing_children();
                
        mAreaRatioThreshold = Settings::Global()->get_nvocc_area_ratio_threshold();
        mVolRatioThreshold = Settings::Global()->get_nvocc_vol_ratio_threshold();
}
*/

Bvh::~Bvh() 
{
        if (mVertices) delete []mVertices; 
        if (mIndices) delete [] mIndices;
        if (mTestIndices) delete [] mTestIndices;
        if (mGeometry) delete [] mGeometry;

        if (mRoot) delete mRoot;
}


void Bvh::PullUpLastVisited(BvhNode *node, const int frameId) const
{               
        BvhNode *parent = node->GetParent();

        while (parent && (parent->GetLastVisitedFrame() != frameId))
        {
                parent->SetLastVisitedFrame(frameId);
                parent = parent->GetParent();
        }
}


void Bvh::MakeParentsVisible(BvhNode *node)
{
        BvhNode *parent = node->GetParent();

        while (parent && (!parent->IsVisible()))
        {
                parent->SetVisible(true);
                parent = parent->GetParent();
        }
}


void Bvh::CollectLeaves(BvhNode *node, BvhLeafContainer &leaves)
{
        stack<BvhNode *> tStack;
        tStack.push(node);

        while (!tStack.empty())
        {
                BvhNode *node = tStack.top();

                tStack.pop();

                if (!node->IsLeaf())
                {
                        BvhInterior *interior = static_cast<BvhInterior *>(node);

                        tStack.push(interior->mFront);
                        tStack.push(interior->mBack);
                }
                else
                {
                        leaves.push_back(static_cast<BvhLeaf *>(node));
                }
        }
}


void Bvh::CollectNodes(BvhNode *node, BvhNodeContainer &nodes)
{
        stack<BvhNode *> tStack;

        tStack.push(node);

        while (!tStack.empty())
        {
                BvhNode *node = tStack.top();
                tStack.pop();

                nodes.push_back(node);

                if (!node->IsLeaf())
                {
                        BvhInterior *interior = static_cast<BvhInterior *>(node);

                        tStack.push(interior->mFront);
                        tStack.push(interior->mBack);
                }
        }
}


typedef pair<BvhNode *, int> tPair;

void Bvh::CollectNodes(BvhNode *root, BvhNodeContainer &nodes, int depth)
{
        stack<tPair> tStack;
        tStack.push(tPair(root, 0));

        while (!tStack.empty())
        {
                BvhNode *node = tStack.top().first;
                const int d = tStack.top().second;

                tStack.pop();

                // found depth => take this node
                if ((d == depth) || (node->IsLeaf()))
                {
                        nodes.push_back(node);
                }
                else
                {
                        BvhInterior *interior = static_cast<BvhInterior *>(node);

                        tStack.push(tPair(interior->mFront, d + 1));
                        tStack.push(tPair(interior->mBack, d + 1));
                }
        }
}


SceneEntity **Bvh::GetGeometry(BvhNode *node, int &geometrySize)
{
        geometrySize = node->CountPrimitives();
        return mGeometry + node->mFirst;
}


int     Bvh::IsWithinViewFrustum(BvhNode *node)
{
        bool bIntersect = false;

        if (node->GetParent())
                node->mPlaneMask = node->GetParent()->mPlaneMask;


        ////////
        //-- do the view frustum culling for the planes [mPreferredPlane - 5]

        for (int i = node->mPreferredPlane; i < 6; ++ i)
        {
                //-- do the test only if necessary
                if (node->mPlaneMask & (1 << i))
                {
                        //-- test the n-vertex
                        if (node->mBox.GetDistance(sClipPlaneAABBVertexIndices[i * 2 + 0], sFrustum.mClipPlanes[i]) > 0.0f)
                        {
                                //-- outside
                                node->mPreferredPlane = i;
                                return 0;
                        }

                        //-- test the p-vertex
                        if (node->mBox.GetDistance(sClipPlaneAABBVertexIndices[i * 2 + 1], sFrustum.mClipPlanes[i]) <= 0.0f)
                        {
                                //-- completely inside: children don't need to check against this plane no more
                                node->mPlaneMask^=      1 << i;
                        }
                        else 
                        {
                                bIntersect = true;
                        }
                }
        }

        //////////
        //-- do the view frustum culling for the planes [0 - m_iPreferredPlane)

        for (int i = 0; i < node->mPreferredPlane; ++ i)
        {
                // do the test only if necessary
                if (node->mPlaneMask & (1 << i))
                {
                        //-- test the n-vertex
                        if (node->mBox.GetDistance(sClipPlaneAABBVertexIndices[i * 2 + 0], sFrustum.mClipPlanes[i]) > 0.0f)
                        {
                                // outside
                                node->mPreferredPlane = i;
                                return 0;
                        }

                        //-- test the p-vertex
                        if (node->mBox.GetDistance(sClipPlaneAABBVertexIndices[i * 2 + 1], sFrustum.mClipPlanes[i]) <= 0.0f)
                        {
                                // completely inside: children don't need to check against this plane no more
                                node->mPlaneMask^= 1 << i;
                        }
                        else 
                        {
                                bIntersect = true;
                        }
                }
        }

        return bIntersect ? -1 : 1;
}


void Bvh::InitFrame(Camera *camera, int currentFrameId)
{
        // = 0011 1111 which means that at the beginning, all six planes have to frustum culled
        mRoot->mPlaneMask = 0x3f;
        mCamera = camera;

        mFrameId = currentFrameId;

        mCamera->CalcFrustum(sFrustum);
        sFrustum.CalcNPVertexIndices(sClipPlaneAABBVertexIndices);

        // calc near plane
        sNearPlane = Plane3(mCamera->GetDirection(), 
                                -mCamera->GetDirection() * mCamera->GetPosition());
}


float Bvh::CalcDistance(BvhNode *node) const
{
        return node->GetBox().GetMinVisibleDistance(sNearPlane);
}


void Bvh::RenderBoundingBox(BvhNode *node)
{
        static BvhNodeContainer dummy(1);
        dummy[0] = node;
        RenderBoundingBoxes(dummy);
}



int Bvh::RenderBoundingBoxes(const BvhNodeContainer &nodes)
{
        int renderedBoxes = PrepareBoundingBoxesWithDrawArrays(nodes);
        RenderBoundingBoxesWithDrawArrays(renderedBoxes);

        return renderedBoxes;
}


int Bvh::PrepareBoundingBoxesWithDrawArrays(const BvhNodeContainer &nodes)
{
        //////
        //-- for the first time we come here ...

        if (!mIndices)
        {       // create list of indices
                CreateIndices();
        }

        if (sCurrentVboId == -1)
        {       
                // prepare the vbo 
                PrepareVertices();
        }

        ///////////////

        int numNodes = 0;

        BvhNodeContainer::const_iterator nit, nit_end = nodes.end();

        for (nit = nodes.begin(); nit != nit_end; ++ nit)
        {
                BvhNode *node = *nit;

        const int numIndices = node->mNumTestNodes * sNumIndicesPerBox;
                
                // copy indices
                memcpy(mIndices + numNodes * sNumIndicesPerBox, 
                           mTestIndices + node->mIndicesPtr, 
#if 0 //ALIGN_INDICES
                           ((numIndices / 32) * 32 + 32) * sizeof(unsigned int));
#else
                           numIndices * sizeof(unsigned int));
#endif
                numNodes += node->mNumTestNodes;
        }

        return numNodes;
}


void Bvh::RenderBoundingBoxesWithDrawArrays(int numNodes)
{
        //////
        //-- Rendering the vbo
        if (useVbos)
                // set the vertex pointer to the vertex buffer
                glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);          
        else
                glVertexPointer(3, GL_FLOAT, 0, mVertices);

        // we do use the last or the first index (they are generate and only used to connect strips)
        const int numElements = numNodes * sNumIndicesPerBox - 1;

        // don't render first degenerate index
        glDrawElements(GL_TRIANGLE_STRIP, numElements, GL_UNSIGNED_INT, mIndices + 1); 
}


#define ALIGN_INDICES 1

void Bvh::CreateIndices()
{
        // collect bvh nodes
        BvhNodeContainer nodes;
        CollectNodes(mRoot, nodes);

        cout << "creating new indices" << endl;

        int numMaxIndices = 0;

        BvhNodeContainer::const_iterator lit, lit_end = nodes.end();

        for (lit = nodes.begin(); lit != lit_end; ++ lit)
        {
                int offset = (*lit)->mNumTestNodes * sNumIndicesPerBox;
#if ALIGN_INDICES
                // align with 32
                offset = (offset / 32) * 32 + 32; 
#endif
                numMaxIndices += offset;
        }


        cout << "creating global indices buffer" << endl;

        if (mIndices) delete [] mIndices;
        if (mTestIndices) delete [] mTestIndices;

        // global buffer: create it once so we don't have
        // to allocate memory from the chunks of the node
        mIndices = new unsigned int[numMaxIndices];

        // create new index buffer for the individual nodes
        mTestIndices = new unsigned int[numMaxIndices];
        
        mCurrentIndicesPtr = 0;

        for (lit = nodes.begin(); lit != lit_end; ++ lit)
        {
                BvhNode *node = *lit;
                
                // resize array
                node->mIndicesPtr = mCurrentIndicesPtr;

                int numIndices = 0;

                // the bounding box of the test nodes are rendered instead of the root node
                // => store their indices
                for (int i = 0; i < node->mNumTestNodes; ++ i, numIndices += sNumIndicesPerBox)
                {
                        BvhNode *testNode = mTestNodes[node->mTestNodesIdx + i];

                        // add indices to root node
                        for (int j = 0; j < sNumIndicesPerBox; ++ j)
                        {
                                mTestIndices[mCurrentIndicesPtr + numIndices + j] = sIndices[j] + testNode->GetId() * 8;
                        }
                }

                // align with 32
#if ALIGN_INDICES
                const int offset = (numIndices / 32) * 32 + 32;
#else
                const int offset = numIndices;
#endif
                mCurrentIndicesPtr += offset;
        }
}


void Bvh::ComputeIds()
{
        // collect all nodes
        BvhNodeContainer nodes;
        CollectNodes(mRoot, nodes);

        // assign ids to all nodes of the "regular" hierarchy
        int i = 0;
        BvhNodeContainer::const_iterator lit, lit_end = nodes.end();

        for (lit = nodes.begin(); lit != lit_end; ++ lit, ++ i)
        {
                (*lit)->SetId(i);
        }
}


void Bvh::PrepareVertices()
{
        // collect all nodes
        BvhNodeContainer nodes;

        nodes.reserve(GetNumNodes());
        CollectNodes(mRoot, nodes);

        const unsigned int bufferSize = 8 * (int)nodes.size();
        mVertices = new Vector3[bufferSize];
        
        int i = 0;
        
        // store bounding box vertices
        BvhNodeContainer::const_iterator lit, lit_end = nodes.end();

        for (lit = nodes.begin(); lit != lit_end; ++ lit, i += 8)
        {
                BvhNode *node = *lit;

                for (int j = 0; j < 8; ++ j)
                        ((Vector3 *)mVertices)[node->GetId() * 8 + j] = node->GetBox().GetVertex(j);
        }

        if (useVbos)
        {
                glGenBuffersARB(1, &sCurrentVboId);
                glBindBufferARB(GL_ARRAY_BUFFER_ARB, sCurrentVboId);
                glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);
        
                glBufferDataARB(GL_ARRAY_BUFFER_ARB, 
                                    bufferSize * sizeof(Vector3), 
                                    mVertices, 
                                                GL_STATIC_DRAW_ARB);

                //glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

                // data handled by graphics driver from now on
                DEL_PTR(mVertices);

                cout << "***** created vbos *********" << endl;
        }
        else
        {
                sCurrentVboId = 0;
        glVertexPointer(3, GL_FLOAT, 0, mVertices);

                cout << "******* created vertex arrays ********" << endl;
        }
}


void Bvh::SetMaxDepthForTestingChildren(int maxDepth) 
{
        if (maxDepth != mMaxDepthForTestingChildren)
        {
                mMaxDepthForTestingChildren = maxDepth;
                RecomputeBounds();
        }
}


void Bvh::SetAreaRatioThresholdForTestingChildren(float ratio) 
{
        if (ratio != mAreaRatioThreshold)
        {
                mAreaRatioThreshold = ratio;
                RecomputeBounds();
        }
}


void Bvh::RecomputeBounds()
{
        // clear old list
        mTestNodes.clear();

        // collect all nodes
        BvhNodeContainer nodes;
        CollectNodes(mRoot, nodes);

        cout << "recomputing bounds, children will be tested in depth " << mMaxDepthForTestingChildren << endl;

        int success = 0;
        BvhNodeContainer::const_iterator lit, lit_end = nodes.end();

        for (lit = nodes.begin(); lit != lit_end; ++ lit)
        {
                BvhNode *node = *lit;

                // recreate list of nodes that will be tested as a proxy ...
                if (CreateNodeRenderList(node))
                        ++ success;
        }

        float p = 100.0f * (float)success / nodes.size();
        cout << "created tighter bounds for " << p << " percent of the nodes" << endl;

        // recreate indices used for indirect mode rendering
        if (mIndices)
                CreateIndices();
}

        
bool Bvh::CreateNodeRenderList(BvhNode *node)
{
        BvhNodeContainer children;

        // collect nodes that will be tested instead of the leaf node
        // in order to get a tighter bounding box test
        CollectNodes(node, children, mMaxDepthForTestingChildren);
        

        // using the tighter bounds is not feasable in case
        // that the tighter bounds represent nearly the same projected area
        // as the old bounding box. Find this out using either volume or area
        // heuristics

        float vol = 0;
        float area = 0;

        BvhNodeContainer::const_iterator cit;

        for (cit = children.begin(); cit != children.end(); ++ cit)
                area += (*cit)->GetBox().SurfaceArea();

        const float areaRatio = area / node->GetBox().SurfaceArea();
        
        bool success;

        if (areaRatio < mAreaRatioThreshold)
                success = true;
        else
        {
                // hack: only store node itself
                children.clear();
                children.push_back(node);

                success = false;
        }

        // the new test nodes are added at the end of the vector
        node->mTestNodesIdx = (int)mTestNodes.size();

        // use the found nodes as nodes during the occlusion tests
        for (cit = children.begin(); cit != children.end(); ++ cit)
        {
                BvhNode *child = *cit;
                mTestNodes.push_back(child);
        }

        node->mNumTestNodes = (int)children.size();

        return success;
}


void Bvh::ResetNodeClassifications()
{
        BvhNodeContainer nodes;

        nodes.reserve(GetNumNodes());
        CollectNodes(mRoot, nodes);

        BvhNodeContainer::const_iterator lit, lit_end = nodes.end();

        for (lit = nodes.begin(); lit != lit_end; ++ lit)
        {
                (*lit)->ResetVisibility();
        }
}


int Bvh::CountTriangles(BvhLeaf *leaf) const
{
        int triangleCount = 0;
        
        for (int i = leaf->mFirst; i <= leaf->mLast; ++ i)
                triangleCount += mGeometry[i]->GetGeometry()->CountTriangles();
        
        return triangleCount;
}


void Bvh::ComputeBvhStats() 
{
        std::stack<BvhNode *> nodeStack;
        nodeStack.push(mRoot);

        while (!nodeStack.empty()) 
        {
                BvhNode *node = nodeStack.top();
                nodeStack.pop();

                if (node->IsLeaf()) 
                {
                        BvhLeaf *leaf = static_cast<BvhLeaf *>(node);

                        mBvhStats.mLeafSA += leaf->mBox.SurfaceArea();
                        mBvhStats.mLeafVol += leaf->mBox.GetVolume();
                } 
                else 
                {
                        mBvhStats.mInteriorSA += node->mBox.SurfaceArea();
                        mBvhStats.mInteriorVol += node->mBox.GetVolume();

                        BvhInterior *interior = static_cast<BvhInterior *>(node);
                        
                        nodeStack.push(interior->mBack);
                        nodeStack.push(interior->mFront);
                }
        }

        mBvhStats.mGeometryRatio = mGeometrySize / (float)GetNumLeaves();
        mBvhStats.mTriangleRatio = mBvhStats.mTriangles / (float)GetNumLeaves();
}


void Bvh::PrintBvhStats() const
{
        cout << "bvh stats:" << endl;
        cout << "interiorNodesSA = " << mBvhStats.mInteriorSA / mRoot->mBox.SurfaceArea() << endl;
        cout << "leafNodesSA = " << mBvhStats.mLeafSA / mRoot->mBox.SurfaceArea() << endl;
        cout << "interiorNodesVolume = " << mBvhStats.mInteriorVol / mRoot->mBox.GetVolume() << endl;
        cout << "leafNodesVolume = " << mBvhStats.mLeafVol / mRoot->mBox.GetVolume() << endl;

        cout << "boundsInteriorNodesSA = " << mBvhStats.mBoundsInteriorSA / mBvhStats.mLeafSA << endl;
        cout << "boundsLeafNodesSA = " << mBvhStats.mBoundsLeafSA / mBvhStats.mLeafSA << endl;
        cout << "boundsInteriorNodesVolume = " << mBvhStats.mBoundsInteriorVol / mBvhStats.mLeafVol << endl;
        cout << "boundsLeafNodesVolume = " << mBvhStats.mBoundsLeafVol / mBvhStats.mLeafVol << "\n" << endl;

        cout << "boundsLeaves: " <<  (float)mBvhStats.mBoundsLeavesCount / (float)GetNumLeaves() << "\n" << endl;
        cout << "geometry per leaf: " <<  mBvhStats.mGeometryRatio << endl;
        cout << "triangles per leaf: " <<  mBvhStats.mTriangleRatio << endl;
}


int Bvh::CountTriangles(BvhNode *node) const
{
        int numTriangles = 0;

        for (int i = node->mFirst; i <= node->mLast; ++ i)
                numTriangles += mGeometry[i]->GetGeometry()->CountTriangles();
        
        return numTriangles;
}


float Bvh::GetArea(BvhNode *node) const
{
        return node->mArea;
}

}