source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/VisibilitySolutionLoader.cpp @ 3243

#include "VisibilitySolutionLoader.h"
#include "ViewCellsTree.h"
#include "Bvh.h"
#include <stack>


using namespace std;

        
namespace CHCDemoEngine
{


typedef vector<ViewCell *> ViewCellsContainer;


ViewCellsTree *VisibilitySolutionLoader::Load(const std::string &filename,
                                                                                          Bvh *bvh)
{
        FILE *fr = fopen(filename.c_str(), "rb");
  
        cout << "Info: Loading visibility solution from file '" + filename + "'" << endl;
  
        if (fr == NULL) 
        {
                cerr << "Error: Cannot open file for reading" << endl;
                return NULL;
        }

        float totalSamples;
        float totalTime;

        fread(&totalSamples, sizeof(float), 1, fr);
        fread(&totalTime, sizeof(float), 1, fr);

        ViewCellsTree *viewCellsTree = new ViewCellsTree();

        bool ok = viewCellsTree->_LoadFromFile(fr);
  
        if (ok) 
        {
                // skip bvh loading
                int buffer[6]; 
                fread(buffer, sizeof(int), 6, fr);

                const size_t numNodes = buffer[5];
                
                for (int i = 0; i < numNodes; ++ i)
                        fread(buffer, sizeof(int), 4, fr);

                AllocateLeafViewCells(viewCellsTree);
                
                ok = LoadPvs(fr, bvh);
        }

        fclose(fr);

        if (ok) 
                cerr << "Info: visibility solution loaded" << endl;
        else
                cerr << "Info: loading visibility solution failed." << endl;

        return viewCellsTree;
}


bool VisibilitySolutionLoader::CreateIdSortedList(Bvh *bvh, BvhNodeContainer &nodes)
{
        std::stack<BvhNode *> tStack;
        tStack.push(bvh->GetRoot());
        
        while (!tStack.empty())
        {
                BvhNode *node = tStack.top();
                tStack.pop();

                nodes.push_back(node);

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

                        BvhNode *front = interior->GetFront();
                        BvhNode *back = interior->GetBack();

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

        return true;
}


bool VisibilitySolutionLoader::LoadPvs(FILE *fw, Bvh *bvh)
{
        int number, entries;

        fread(&number, sizeof(int), 1, fw);

        if (number == 0) 
        {
                cerr << "Info: Warning empty PVSs in visibility solution" << endl;
                return true;
        }

        if (number != mViewCells.size()) 
        {
                cerr << "Info: Number of view cells does not match when loading PVSs!" << endl;
                return false;
        }

        BvhNodeContainer nodes;
        CreateIdSortedList(bvh, nodes);

        for (int i = 0; i < number; ++ i) 
        {
                fread(&entries, sizeof(int), 1, fw);

                for (int j=0; j < entries; ++ j) 
                {
                        int objectId;
                        float time;
                
                        fread(&objectId, sizeof(int), 1, fw);
                        fread(&time, sizeof(float), 1, fw);

                        BvhNode *node = nodes[objectId];

                        int geometrySize;
                        SceneEntity **entities;
                        entities = bvh->GetGeometry(node, geometrySize);

                        for (int k = 0; k < geometrySize; ++ k)
                        {
                                mViewCells[i]->mPvs.AddEntry(entities[k]);
                        }
                }
        }

        return true;
}


void VisibilitySolutionLoader::AllocateLeafViewCells(ViewCellsTree *viewCellsTree)
{
        stack< pair<ViewCellsTreeNode *, AxisAlignedBox3> > nodeStack;

        nodeStack.push(pair<ViewCellsTreeNode *, AxisAlignedBox3>
                           (viewCellsTree->mRoot, viewCellsTree->mBox));

        int id = 0;

        mViewCells.clear();
        
        while (!nodeStack.empty()) 
        {
                ViewCellsTreeNode *node = nodeStack.top().first;
                
                if (node->IsLeaf()) 
                {
                        if (node->mViewCell == NULL) 
                        {
                                node->mViewCell = new ViewCell();
                                node->mViewCell->SetId(id ++);
                                node->mViewCell->SetBox(nodeStack.top().second);
                        }

                        mViewCells.push_back(node->mViewCell);

                        nodeStack.pop();
                } 
                else 
                {
                        AxisAlignedBox3 box = nodeStack.top().second;
                        nodeStack.pop();

                        AxisAlignedBox3 newBox = box;
                        newBox.SetMin(node->mAxis, node->mPosition);

                        nodeStack.push(
                                pair<ViewCellsTreeNode *, AxisAlignedBox3>(node->mFront, newBox)
                                );

                        newBox = box;
                        newBox.SetMax(node->mAxis, node->mPosition);

                        nodeStack.push(
                                pair<ViewCellsTreeNode *, AxisAlignedBox3>(node->mBack, newBox)
                                );
                }
        }

        cout << "#of viewcells = " << id << endl;
}


}