source: GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/VisibilitySolutionConverter.cpp @ 3236

#include "VisibilitySolutionConverter.h"
#include "SimpleTri.h"
#include "SimpleVec.h"
#include "gzstream.h"
#include <iostream>


using namespace std;

// MAGIC of all bin exports
#ifndef MAGIC 
#define MAGIC 0x827923
#endif

#define BVH_VERSION 2.1


static void LoadIndices(char *str, 
                                                const VertexArray &vertices, 
                                                const VertexArray &normals, 
                                                const vector<pair<float, float> > &texCoords,
                                                VertexArray &faceVertices,
                                                VertexArray &faceNormals,
                                                vector<TexCoord> &faceTexCoords
                                                )
{
        vector<string> triples;

        char *next_token;

        // extract the triples of the form v/t/n v/t/n ...
        char *pch = strtok_s(str + 1, " ", &next_token);

        while (pch)
        {
                string s(pch);
                //s += "\n",
                triples.push_back(s);
                
                pch = strtok_s(NULL, " ", &next_token);   
        }

        vector<int> indices;
        vector<int> nIndices;
        vector<int> tIndices;

        char seps[] = " /\t\n";

        for (size_t i = 0; i < triples.size(); ++ i)
        {
                static int dummy = 0;

                size_t found;
                found = triples[i].find_first_of(seps);
                size_t prevfound = 0;
                // vertex, normal, texture indices
                string str = triples[i].substr(prevfound, found);

                int index = (int)strtol(str.c_str(), NULL, 10) - 1;

                int tIndex = index;
                int nIndex = index;     
                
                prevfound = found;
                found = triples[i].find_first_of(seps, found + 1);  

                if (found != string::npos)
                {
                        str = triples[i].substr(prevfound, found);

                        int idx = (int)strtol(str.c_str(), NULL, 10) - 1;
                        if (idx > 0) tIndex = idx;
                }

                if ((found + 1) < triples[i].size())
                {
                        str = triples[i].substr(found + 1);

                        int idx = (int)strtol(str.c_str(), NULL, 10) - 1;
                        if (idx > 0) nIndex = idx;
                }

                // store indices
                if (index >= 0)
                {
                        indices.push_back(index);
                        nIndices.push_back(nIndex);
                        tIndices.push_back(tIndex);
                }

                // new triangle found
                if (indices.size() > 2)
                {
                        // change orientation of faces?
#if 1
                        int idx1 = 0;
                        int idx2 = (int)indices.size() - 2;
                        int idx3 = (int)indices.size() - 1;
#else
                        int idx3 = 0;
                        int idx2 = (int)indices.size() - 2;
                        int idx1 = (int)indices.size() - 1;
#endif
                        faceVertices.push_back(vertices[indices[idx1]]);
                        faceVertices.push_back(vertices[indices[idx2]]);
                        faceVertices.push_back(vertices[indices[idx3]]);


                        if (!normals.empty())
                        {
                                faceNormals.push_back(normals[nIndices[idx1]]);
                                faceNormals.push_back(normals[nIndices[idx2]]);
                                faceNormals.push_back(normals[nIndices[idx3]]);
                        }
                        else
                        {
                                // no face normals? => create normals
                                const SimpleTri tri(vertices[indices[idx1]],
                                                        vertices[indices[idx2]], 
                                                                        vertices[indices[idx3]]);

                                const SimpleVec n = tri.GetNormal();

                                faceNormals.push_back(n);
                                faceNormals.push_back(n);
                                faceNormals.push_back(n);
                        }

                        if (!texCoords.empty())
                        {
                                faceTexCoords.push_back(texCoords[tIndices[idx1]]);
                                faceTexCoords.push_back(texCoords[tIndices[idx2]]);
                                faceTexCoords.push_back(texCoords[tIndices[idx3]]);
                        }
                }
        }
}


VisibilitySolutionConverter::VisibilitySolutionConverter()
{}


VisibilitySolutionConverter::~VisibilitySolutionConverter()
{
        for (size_t i = 0; i < mGeometry.size(); ++ i)
        {
                delete [] mGeometry[i]->mVertices;
                delete [] mGeometry[i]->mNormals;
                delete [] mGeometry[i]->mTexCoords;

                delete mGeometry[i];
        }
        
        mGeometry.clear();
}


void VisibilitySolutionConverter::LoadShape(const VertexArray &vertices,
                                                                                        const VertexArray &normals,
                                                                                        const vector<TexCoord> &texCoords)
{
        int numElements = (int)vertices.size();
        Geometry *geom = new Geometry();

        // convert the triangles to geometry
        geom->mVertices = new SimpleVec[numElements];
        geom->mNormals = new SimpleVec[numElements];
        geom->mTexCoords = new TexCoord[numElements];

        geom->mVertexCount = numElements;
        geom->mTexcoordCount = (int)texCoords.size();

        cout << "number of vertices=" << numElements << endl;

        for (int i = 0; i < numElements; ++ i)
        {
#if 1
                // convert to our camera system: change y and z
                geom->mVertices[i].x =  vertices[i].x;
                geom->mVertices[i].y = -vertices[i].z;
                geom->mVertices[i].z =  vertices[i].y;
        
                geom->mNormals[i].x =  normals[i].x;
                geom->mNormals[i].y = -normals[i].z;
                geom->mNormals[i].z =  normals[i].y;

#else
                geom->mVertices[i].x = vertices[i].x;
                geom->mVertices[i].y = vertices[i].y;
                geom->mVertices[i].z = vertices[i].z;
        
                geom->mNormals[i].x = normals[i].x;
                geom->mNormals[i].y = normals[i].y;
                geom->mNormals[i].z = normals[i].z;

#endif

                if (i < geom->mTexcoordCount)
                {
                        geom->mTexCoords[i].first = texCoords[i].first;
                        geom->mTexCoords[i].second = texCoords[i].second;
                }
        }

        mGeometry.push_back(geom);
}


bool VisibilitySolutionConverter::Convert(const std::string &sceneInputFilename,
                                                                                  const std::string &sceneOutputFilename,
                                                                                  const std::string &bvhInputFilename,
                                                                                  const std::string &bvhOutputFilename)
{
        mNumShapes = 0;
        
        // delete previous geometry
        for (size_t i = 0; i < mGeometry.size(); ++ i)
        {
                delete [] mGeometry[i]->mVertices;
                delete [] mGeometry[i]->mNormals;
                delete [] mGeometry[i]->mTexCoords;

                delete mGeometry[i];
        }
        
        mGeometry.clear();

        if (!LoadSolution(bvhInputFilename))
        {
                cerr << "could not read file" << endl;
                return false;
        }

        if (!ReadScene(sceneInputFilename))
        {
                cerr << "could not read file" << endl;
                return false;
        }

        if (!WriteScene(sceneOutputFilename))
        {
                cerr << "could not write file" << endl;
                return false;
        }

        /*if (!WriteBvh(bvhOutputFilename))
        {
                cerr << "could not write file" << endl;
                return false;
        }*/

        return true;
}


bool VisibilitySolutionConverter::ReadScene(const string &filename) 
{
        FILE *file;

        if ((file = fopen(filename.c_str(), "r")) == NULL)
        {       
                return false;
        }
        
        VertexArray faceVertices; 
        VertexArray faceNormals;
        vector<TexCoord> faceTexcoords;

        VertexArray vertices; 
        VertexArray normals;
        vector<TexCoord> texcoords;

        vector<int> indices;

        int line = 0;
        const int len = 10000;
        char str[len];

        while (fgets(str, len, file) != NULL)
        {
                if (line % 1000000 == 0)
                        cout << line << " " << str << endl;

                ++ line;

                switch (str[0])
                {
                case 'v': // vertex or normal
                        {
                                float x, y, z;

                                if (vertices.size() >= 1000000 * 3) continue;

                                switch (str[1]) 
                                {
                                case 'n' :
                                        sscanf(str + 2, "%f %f %f", &x, &y, &z);
                                        normals.push_back(SimpleVec(x, y, z));
                                        break;
                                case 't':
                                        sscanf(str + 2, "%f %f", &x, &y);
                                        texcoords.push_back(pair<float, float>(x, y));
                                        break;
                                default:
                                        sscanf(str + 1, "%f %f %f", &x, &y, &z);
                                        //const float scale = 5e-3f;
                                        const float scale = 0.1f;
                                        vertices.push_back(SimpleVec(x * scale, y * scale, z * scale));
                                        //cout <<"v " << x << " " << y << " "<< z << " ";
                                }
                                break;
                        }
                case 'f': 
                        {
                                //////////
                                //-- indices in the current line

                                if (faceVertices.size() >= 1000000 * 3) continue;

                                LoadIndices(str, 
                                                vertices, normals, texcoords, 
                                                faceVertices, faceNormals, faceTexcoords);

                                break;
                        }  
                        break;
                default:
                        // throw away line
                        break;
                }
        }

        if (!faceVertices.empty())
        {
                ++ mNumShapes;

                ConstructBvhObjects(faceVertices, faceNormals, faceTexcoords);

                faceVertices.clear();
                faceNormals.clear();
                faceTexcoords.clear();
        }

        fclose(file);
        
        return true;
}


static inline float RandomColor(float x)
{
        return x + (1.0f - x) * (float)rand() / RAND_MAX; 
}


void VisibilitySolutionConverter::WriteGeometry(ogzstream &str, Geometry *geom)
{
        int vertexCount = geom->mVertexCount;
        str.write(reinterpret_cast<char *>(&vertexCount), sizeof(int));
  
        str.write(reinterpret_cast<char *>(geom->mVertices), sizeof(SimpleVec) * vertexCount);
        str.write(reinterpret_cast<char *>(geom->mNormals), sizeof(SimpleVec) * vertexCount);

        int texCoordCount = 0;//geom->mTexcoordCount;
        str.write(reinterpret_cast<char *>(&texCoordCount), sizeof(int));

        if (texCoordCount)
        {
                str.write(reinterpret_cast<char *>(geom->mTexCoords), sizeof(float) * texCoordCount * 2);
        }

        ///////
        //-- texture

        int texId = -1;
        str.write(reinterpret_cast<char *>(&texId), sizeof(int));

        bool alphaTestEnabled = false;
        bool cullFaceEnabled = true;

        str.write(reinterpret_cast<char *>(&alphaTestEnabled), sizeof(bool));
        str.write(reinterpret_cast<char *>(&cullFaceEnabled), sizeof(bool));

        // material
        bool hasMaterial = true;
        
        str.write(reinterpret_cast<char *>(&hasMaterial), sizeof(bool));
        
        if (hasMaterial)
        {
                SimpleVec ambient, diffuse, spec, emm;

                ambient.x = ambient.y = ambient.z = 0.2f;
                //diffuse.x = diffuse.y = diffuse.z = 1.0f;

                diffuse.x = RandomColor(0.5f); 
                diffuse.y = RandomColor(0.5f);
                diffuse.z = RandomColor(0.5f);

                spec.x    = spec.y    = spec.z    =  .0f;
                emm = spec;

                // only write rgb part of the material
                str.write(reinterpret_cast<char *>(&ambient), sizeof(SimpleVec));
                str.write(reinterpret_cast<char *>(&diffuse), sizeof(SimpleVec));
                str.write(reinterpret_cast<char *>(&spec), sizeof(SimpleVec));
                str.write(reinterpret_cast<char *>(&emm), sizeof(SimpleVec));
        }
}


bool VisibilitySolutionConverter::WriteScene(const string &filename)
{
        ogzstream ofile(filename.c_str());

        if (!ofile.is_open())
                return false;
        

        int textureCount = 0;
        ofile.write(reinterpret_cast<char *>(&textureCount), sizeof(int));


        ///////////
        //-- write shapes

        int numShapes = (int)mGeometry.size();
        ofile.write(reinterpret_cast<char *>(&numShapes), sizeof(int));

        vector<Geometry *>::const_iterator it, it_end = mGeometry.end();

        for (it = mGeometry.begin(); it != it_end; ++ it)
        {
                WriteGeometry(ofile, *it);
        }


        int entityCount = numShapes;
        ofile.write(reinterpret_cast<char *>(&entityCount), sizeof(int));


        //////////
        //-- write single scene entity for each shape

        // all shapes belong to this scene entity
        for (int i = 0; i < numShapes; ++ i)
        {
                // no transformation
                bool hasTrafo = false;
                ofile.write(reinterpret_cast<char *>(&hasTrafo), sizeof(bool));

                // a dummy lod
                int numLODs = 1;
                ofile.write(reinterpret_cast<char *>(&numLODs), sizeof(int));

                float dist = 0;
                ofile.write(reinterpret_cast<char *>(&dist), sizeof(float));

                int shapesPerEnt = 1;
                ofile.write(reinterpret_cast<char *>(&shapesPerEnt), sizeof(int));

                int shapeId = i;
                ofile.write(reinterpret_cast<char *>(&shapeId), sizeof(int));
        }

        return true;
}


void VisibilitySolutionConverter::ConstructBvhObjects(const VertexArray &vertices,
                                                                                                          const VertexArray &normals,
                                                                                                          const vector<TexCoord> &texCoords)
{
        cout << "vtx: " << vertices.size() << endl;

        for (size_t i = 0; i < mBvhNodes.size(); ++ i)
        {
                VertexArray _vertices;
                VertexArray _normals;
                vector<TexCoord> _texCoords;

                BvhNode *node = mBvhNodes[i];

                //for (size_t j = 0; j < node->mTriangleIds.size(); ++ j)
                for (int j = node->first; j < node->last; ++ j)
                {
                        const int idx = 3 * mGlobalTriangleIds[j];

                        //cout << "idx: " << idx << " ";

                        if (idx < 1000000 * 3)
                        {
                                for (int k = 0; k < 3; ++ k)
                                {
                                        _vertices.push_back(vertices[idx + k]);
                                        _normals.push_back(normals[idx + k]);
                                        //_texCoords.push_back(texCoords[idx + k]);
                                }
                        }
                }

                if (!_vertices.empty())
                {
                        ++ mNumShapes;
                        LoadShape(_vertices, _normals, _texCoords);
                }
        }
}


bool VisibilitySolutionConverter::WriteBvh(const string &filename)
{
        
        return true;
}


bool VisibilitySolutionConverter::ReadBvh(FILE *fr) 
{
        int buffer[6]; 
        fread(buffer, sizeof(int), 6, fr);

        if (buffer[0] != MAGIC) 
        {
                cerr << "Error: Wrong file type" << endl;
                return false;
        }

        if (buffer[1] != (int)(1000 * BVH_VERSION)) 
        {
                cerr << "Error: Wrong BVH version" << endl;
                return false;
        }

        // load triangle ids
        size_t numTriangles = buffer[2];

        for (size_t i = 0; i < numTriangles; ++i) 
        {
                int id;
                fread(&id, sizeof(int), 1, fr);
                mGlobalTriangleIds.push_back(id);
                //triangles[i] = scene->triangles[id];
        }

        //if (mRoot) delete mRoot;

        mNumNodes = 0; // this was set to 1 in constructor!

        mRoot = LoadNode(fr, 0);

        if (mNumNodes != buffer[5]) 
        {
                cerr << "Warning: Loaded " << mNumNodes <<
                            " bvh nodes instead of " << buffer[5] << endl;
        }

        fclose(fr);
        
        return true;
}


BvhNode *VisibilitySolutionConverter::LoadNode(FILE *fr, int depth)
{
        ++ mNumNodes;
        
        int buffer[4];
        fread(buffer, sizeof(int), 4, fr);

        if (buffer[2] != -1) 
        {
                BvhInterior *interior = new BvhInterior();
                
                interior->first = buffer[0];
                interior->last  = buffer[1];
                interior->axis  = buffer[2];
                interior->id    = buffer[3];
                interior->depth = depth;

                BvhNode *front, *back;

                front = LoadNode(fr, depth + 1);
                back  = LoadNode(fr, depth + 1);

                // front->parent = (BvhNode *)interior;
                // back->parent = (BvhNode *)interior;
                interior->front = front;
                interior->back = back;

                //interior->box = Union(front->box, back->box);
        
                return (BvhNode *)interior;
        }
        else 
        {
                // leaf
                //Debug << "Info: Loading leaf (id: " << numberOfNodes << ", depth: " << depth << ")" << endl;
                BvhLeaf *leaf = new BvhLeaf();
                leaf->first = buffer[0];
                leaf->last  = buffer[1];
                leaf->axis  = buffer[2];
                leaf->id  = buffer[3];

                leaf->depth = depth;
                //UpdateLeafBox(leaf);

                mBvhNodes.push_back(leaf);
                // leaf->id = numberOfNodes;
                return (BvhNode *)leaf;
        }
}


bool VisibilitySolutionConverter::ReadDummyTree(FILE *fr)
{
        int buffer[256]; 
        fread(buffer, sizeof(int), 3, fr);

        // read dummy bounding box
        float dummy[6];
        fread(dummy, sizeof(float) * 6, 1, fr);

        int stack = 1;

        // read dummy tree
        while (stack)
        {
                int axis;
                fread(&axis, sizeof(int), 1, fr);
                -- stack;

                if (axis != - 1) 
                {
                        float dummy;
                        fread(&dummy, sizeof(float), 1, fr);
                        
                        stack += 2;
                }
        }
  
        return true;
}



bool VisibilitySolutionConverter::LoadSolution(const string &filename)
{
        FILE *fr = fopen(filename.c_str(), "rb");

        cerr << "Info: Loading visibility solution from file '" + filename + "'" << endl;
  
        if (fr == NULL) 
        {
                cerr << "Error: Cannot open file for reading" << endl;
                return false;
        }

        float totalSamples, totalTime;

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

        //viewCellsTree = new ViewCellsTree;
        //bool ok = viewCellsTree->_LoadFromFile(fr);

        bool ok = ReadDummyTree(fr);

        if (ok) 
        {
                //AllocateLeafViewCells();
                
                //objectsTree = new Bvh(*scene);
                //ok = objectsTree->_LoadFromFile(fr);
                ok = ReadBvh(fr);

                /*if (ok) 
                { 
                    AllocatePvsObjects();
                        ok = LoadPvs(fr);
                }
                */
        }

        fclose(fr);
        
        if (ok) 
                cout << "Info: visibility solution loaded" << endl;
        else
                cout << "Info: loading visibility solution failed" << endl;
  
        return true;
}


#if 0
bool VisibilitySolution::LoadPvs(FILE *fw)
{  
        int number, entries;
  
        fread(&number, sizeof(int), 1, fw);

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

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

        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);
                        viewCells[i]->pvs.Insert(objectId, time);
                }
        }
        return true;
}


bool ViewCellsTree::_LoadFromFile(FILE *fr)
{
        int buffer[256]; 
        fread(buffer, sizeof(int), 3, fr);

        if (buffer[0] != MAGIC) 
        {
                Message( "Error: Wrong file type");
                return false;
        }

        if (buffer[1] != (int)(1000*VIEWCELLS_VERSION)) 
        {
                Message( "Error: Wrong viewcells version" );
                
                return false;
        }

        // get the bounding box
        fread(&box, sizeof(AxisAlignedBox3), 1, fr);

        stack<ViewCellsTreeNode **> nodeStack;
        nodeStack.push(&root);

        while(!nodeStack.empty()) 
        {
                ViewCellsTreeNode *&node = *nodeStack.top();
                
                nodeStack.pop();
                node = new ViewCellsTreeNode;
                
                fread(&node->axis, sizeof(int), 1, fr);
                
                if (!node->IsLeaf()) 
                {
                        fread(&node->position, sizeof(float), 1, fr);
                        
                        nodeStack.push(&node->front);
                        nodeStack.push(&node->back);
                }
        }
  
        return true;
}
#endif