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

#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 << "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);

        cout << "loading view cells" << endl;

        ViewCellsTree *viewCellsTree = new ViewCellsTree();

        bool ok = viewCellsTree->_LoadFromFile(fr);

        cout << "finished loading view cells" << endl;

  
        if (ok) 
        {
                // skip loading of bvh nodes
                int buffer[6]; 
                fread(buffer, sizeof(int), 6, fr);

                const int numNodes = buffer[5];
                const int numTriangleIds = buffer[2];

                // skip triangle ids
                cout << "skipping " << numTriangleIds << " triangle ids" << endl;

                int tid;
                for (int i = 0; i < numTriangleIds; ++ i) 
                        fread(&tid, sizeof(int), 1, fr);
        
                cout << "skipping " << numNodes << " bvh nodes" << endl;

                for (int i = 0; i < numNodes; ++ i)
                        fread(buffer, sizeof(int), 4, fr);


                cout << "allocating view cells" << endl;

                AllocateLeafViewCells(viewCellsTree);
                
                cout << "loading pvss" << endl;

                ok = LoadPvs(fr, bvh);

                cout << "finished loading pvss" << endl;
        }

        fclose(fr);

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

        return viewCellsTree;
}


bool VisibilitySolutionLoader::CreateIdSortedList(Bvh *bvh, BvhNodeContainer &nodes)
{
        std::stack<BvhNode *> tStack;
        tStack.push(bvh->GetStaticRoot());
        
        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) 
        {
                cerr << "Warning: empty PVSs in visibility solution" << endl;
                return true;
        }

        if (number != mViewCells.size()) 
        {
                cerr << "Warning: Number of view cells (" << number << ", " << (int)mViewCells.size() << ") 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);

                        //if (node->IsLeaf() && (geometrySize != 1))
                        //if (geometrySize != 1) cout << "Error!! " << geometrySize << endl;
                        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();
        int axes[] = {0, 0, 0};

        while (!nodeStack.empty()) 
        {
                ViewCellsTreeNode *node = nodeStack.top().first;
                
                if (node->IsLeaf()) 
                {
                        if (!node->mViewCell) 
                        {
                                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 newBox1 = box;
                        AxisAlignedBox3 newBox2 = box;
                        /*if (node->mPosition < newBox.Min(node->mAxis))
                                cout << "e: " << node->mPosition << " " << newBox.Min(node->mAxis) << endl;
                        else if (node->mPosition > newBox.Min(node->mAxis))
                                cout << "o: " << node->mPosition << " " << newBox.Min(node->mAxis) << endl;
*/
                        newBox1.SetMin(node->mAxis, node->mPosition);
                        newBox2.SetMax(node->mAxis, node->mPosition);

                        ++ axes[node->mAxis];

                        if (node->mAxis == 1)
                        {
                                nodeStack.push(pair<ViewCellsTreeNode *, AxisAlignedBox3>(node->mBack, newBox2));
                                nodeStack.push(pair<ViewCellsTreeNode *, AxisAlignedBox3>(node->mFront, newBox1));
                        }
                        else
                        {
                                nodeStack.push(pair<ViewCellsTreeNode *, AxisAlignedBox3>(node->mFront, newBox1));
                                nodeStack.push(pair<ViewCellsTreeNode *, AxisAlignedBox3>(node->mBack, newBox2));
                        }
                }
        }

        cout << "#of viewcells = " << id << " " << axes[0] << " " << axes[1] << " " << axes[2] << endl;
}


}