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

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


using namespace std;

        
namespace CHCDemoEngine
{


typedef vector<ViewCell *> ViewCellsContainer;


ViewCellsTree *VisibilitySolutionLoader::Load(const std::string &filename,
                                                                                          Bvh *bvh,
                                                                                          float &totalSamples,
                                                                                          float &totalTime,
                                                                                          float viewCellsScaleFactor
                                                                                          )
{
        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;
        }

        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, viewCellsScaleFactor);

        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->IsVirtualLeaf())
                {
                        BvhInterior *interior = static_cast<BvhInterior *>(node);

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

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

        return true;
}


bool VisibilitySolutionLoader::CreateIdSortedList2(BvhNode *n,
                                                                                                   BvhNodeContainer &nodes)
{
        nodes.push_back(n);

        if (!n->IsLeaf() && !n->IsVirtualLeaf())
        {
                BvhInterior *interior = static_cast<BvhInterior *>(n);

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

                CreateIdSortedList2(front, nodes);
                CreateIdSortedList2(back, nodes);
        }

        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;
        CreateIdSortedList2(bvh->GetStaticRoot(), nodes);
        //CreateIdSortedList(bvh, nodes);

        const int tenpercent = number / 10;
        int j = 0;

        for (int i = 0; i < number; ++ i) 
        {
                if ((i % tenpercent) == (tenpercent - 1))
                {
                        j += 10;
                        cout << j << " percent of the view cells loaded" << endl;
                }

                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];
                        mViewCells[i]->mPvs.AddEntry(bvh, node, time);
                }
        }

        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;
                
                        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 << "loaded " << id << " view cells" << endl;
}


}