source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/BvhLoader.cpp @ 3068

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

#include "BvhLoader.h"
#include "gzstream.h"


#ifdef _CRT_SET
        #define _CRTDBG_MAP_ALLOC
        #include <stdlib.h>
        #include <crtdbg.h>

        // redefine new operator
        #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
        #define new DEBUG_NEW
#endif


namespace CHCDemoEngine
{

using namespace std;


#define TYPE_INTERIOR -2
#define TYPE_LEAF -3



BvhNode *BvhLoader::LoadNextNode(igzstream &stream, BvhInterior *parent)
{
        int nodeType;
        stream.read(reinterpret_cast<char *>(&nodeType), sizeof(int));

        BvhNode *node;

        if (nodeType == TYPE_LEAF)
                node = new BvhLeaf(parent);
        else if (nodeType == TYPE_INTERIOR)
                node = new BvhInterior(parent);
        else
                cerr << "error: wrong node type: " << nodeType << endl;
                

        Vector3 bMin, bMax;

        stream.read(reinterpret_cast<char *>(&(node->mFirst)), sizeof(int));
        stream.read(reinterpret_cast<char *>(&(node->mLast)), sizeof(int));

        stream.read(reinterpret_cast<char *>(&bMin), sizeof(Vector3));
        stream.read(reinterpret_cast<char *>(&bMax), sizeof(Vector3));

        node->mBox = AxisAlignedBox3(bMin, bMax);
        node->mArea = node->mBox.SurfaceArea();

        //cout << "box: " << node->mBox << " area: " << node->mArea << endl;
        
        return node;
}


Bvh *BvhLoader::Load(const string &filename,  
                                         const SceneEntityContainer &entities)
{
        queue<BvhNode *> tQueue;
        igzstream stream(filename.c_str());

        if (!stream.is_open()) return NULL;

        cout << "loading bvh" << endl;

        Bvh *bvh = new Bvh(entities);

        BvhNode *root = LoadNextNode(stream, NULL);

        bvh->mRoot = root;

#if 0

        //bvh->mRoot = bvh->mStaticRoot;
        bvh->mNumNodes = 1;

#else
        // we are setting a new root node 
        // and adds one level of indirection to the bvh 
        // It allows us to use dynamic objects

        // the new bvh has two main branches
        // a static branch (the old root), and adynamic branch 
        // we create a 'dynamic' leaf which basically is a container
        // for all dynamic objects underneath

        // the bounding boxes of the dynamic tree must be updated
        // once each frame in order to be able to incorporate
        // the movements of the objects within

        // create new root
        /*BvhInterior *newRoot = new BvhInterior(NULL);
        bvh->mRoot = newRoot;

        // the separation is a purely logical one
        // the bounding boxes of the child nodes are 
        // identical to those of the root node

        newRoot->mBox = bvh->mStaticRoot->mBox;
        newRoot->mArea = newRoot->mBox.SurfaceArea();

        newRoot->mFirst = bvh->mStaticRoot->mFirst;
        newRoot->mLast = bvh->mStaticRoot->mLast;

        // add static root on left subtree
        newRoot->mFront = bvh->mStaticRoot;
        bvh->mStaticRoot->mParent = newRoot;
        */
        // create and add dynamic root
        BvhLeaf *dynamicRoot = new BvhLeaf(NULL);
        
        dynamicRoot->mFirst = 0;
        dynamicRoot->mLast = 0;

        //dynamicRoot->mBox = bvh->mStaticRoot->mBox;
        dynamicRoot->mBox = bvh->mRoot->mBox;
        dynamicRoot->mArea = dynamicRoot->mBox.SurfaceArea();

        bvh->mDynamicRoot = dynamicRoot;
        //newRoot->mBack = dynamicRoot;

        bvh->mNumNodes = 1;
#endif

        tQueue.push(bvh->mRoot);
        
        while(!tQueue.empty())
        {
                BvhNode *node = tQueue.front();
                tQueue.pop();

                if (!node->IsLeaf())
                {
                        bvh->mNumNodes += 2;

                        BvhInterior *interior = static_cast<BvhInterior *>(node);

                        BvhNode *front = LoadNextNode(stream, interior);
                        BvhNode *back = LoadNextNode(stream, interior);

                        interior->mFront = front;
                        interior->mBack = back;

                        front->mDepth = interior->mDepth + 1;
                        back->mDepth = interior->mDepth + 1;

                        tQueue.push(front);                     
                        tQueue.push(back);
                }
        }


        bvh->mBox = bvh->mRoot->GetBox();

        cout << "... finished loading " << bvh->mNumNodes << " nodes" << endl;
        cout << "scene box: " << bvh->mBox << endl;

        
        ///////////
        //-- post process nodes

        /// this function must be called once after creation
        bvh->PostProcess();
        
        // set virtual leaves for specified number of triangles
        bvh->SetVirtualLeaves(INITIAL_TRIANGLES_PER_VIRTUAL_LEAVES);
        /// update the numleaves parameter of the bvh nodes
        bvh->UpdateNumLeaves(bvh->mRoot);
        // compute unique ids
        bvh->ComputeIds();
        // specify bounds for occlusion tests
        bvh->RecomputeBounds();

        // compute and print stats
        bvh->ComputeBvhStats();
        bvh->PrintBvhStats();

        return bvh;
}


}