Changeset 3235 for GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter

Timestamp:

12/26/08 02:44:45 (16 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter

Files:

• VisibilitySolutionConverter.cpp (moved) (moved from GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/ObjConverter.cpp) (29 diffs)
• VisibilitySolutionConverter.h (moved) (moved from GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/ObjConverter.h) (4 diffs)
• main.cpp (modified) (3 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/VisibilitySolutionConverter.cpp

@@ -1 @@
-#include "ObjConverter.h"
+#include "VisibilitySolutionConverter.h"
 #include "SimpleTri.h"
 #include "SimpleVec.h"
@@ -8 +8 @@
 using namespace std;
 
-//#define USE_TEXTURE
+// MAGIC of all bin exports
+#ifndef MAGIC 
+#define MAGIC 0x827923
+#endif
+
+#define BVH_VERSION 2.1
 
 
@@ -14 +19 @@
                                                 const VertexArray &vertices, 
                                                 const VertexArray &normals, 
-                                                const vector<pair<float, float> > &texcoords,
+                                                const vector<pair<float, float> > &texCoords,
                                                 VertexArray &faceVertices,
                                                 VertexArray &faceNormals,
-                                                vector<Texcoord> &faceTexcoords
+                                                vector<TexCoord> &faceTexCoords
                                                 )
 {
@@ -104 +109 @@
                         if (!normals.empty())
                         {
-                                //if (dummy < 3) cout << nIndices[idx1] << " " << nIndices[idx2] << " " << nIndices[idx3] << endl;
                                 faceNormals.push_back(normals[nIndices[idx1]]);
                                 faceNormals.push_back(normals[nIndices[idx2]]);
@@ -115 +119 @@
                                                         vertices[indices[idx2]], 
                                                                         vertices[indices[idx3]]);
+
                                 const SimpleVec n = tri.GetNormal();
 
@@ -122 +127 @@
                         }
 
-                        ++ dummy;
-                        if (!texcoords.empty())
+                        if (!texCoords.empty())
                         {
-                                faceTexcoords.push_back(texcoords[tIndices[idx1]]);
-                                faceTexcoords.push_back(texcoords[tIndices[idx2]]);
-                                faceTexcoords.push_back(texcoords[tIndices[idx3]]);
+                                faceTexCoords.push_back(texCoords[tIndices[idx1]]);
+                                faceTexCoords.push_back(texCoords[tIndices[idx2]]);
+                                faceTexCoords.push_back(texCoords[tIndices[idx3]]);
                         }
                 }
@@ -134 +138 @@
 
 
-ObjConverter::ObjConverter()
+VisibilitySolutionConverter::VisibilitySolutionConverter()
 {}
 
 
-ObjConverter::~ObjConverter()
+VisibilitySolutionConverter::~VisibilitySolutionConverter()
 {
         for (size_t i = 0; i < mGeometry.size(); ++ i)
@@ -144 +148 @@
                 delete [] mGeometry[i]->mVertices;
                 delete [] mGeometry[i]->mNormals;
-                delete [] mGeometry[i]->mTexcoords;
+                delete [] mGeometry[i]->mTexCoords;
 
                 delete mGeometry[i];
@@ -153 +157 @@
 
 
-void ObjConverter::LoadShape(const VertexArray &faceVertices,
-                                                         const VertexArray &faceNormals,
-                                                         const vector<Texcoord> &faceTexcoords)
-{
-        int numElements = (int)faceVertices.size();
+void VisibilitySolutionConverter::LoadShape(const VertexArray &vertices,
+                                                                                        const VertexArray &normals,
+                                                                                        const vector<TexCoord> &texCoords)
+{
+        int numElements = (int)vertices.size();
         Geometry *geom = new Geometry();
 
@@ -163 +167 @@
         geom->mVertices = new SimpleVec[numElements];
         geom->mNormals = new SimpleVec[numElements];
-        geom->mTexcoords = new Texcoord[numElements];
+        geom->mTexCoords = new TexCoord[numElements];
 
         geom->mVertexCount = numElements;
-        geom->mTexcoordCount = (int)faceTexcoords.size();
+        geom->mTexcoordCount = (int)texCoords.size();
 
         cout << "number of vertices=" << numElements << endl;
@@ -172 +176 @@
         for (int i = 0; i < numElements; ++ i)
         {
-#if 0
+#if 1
                 // convert to our camera system: change y and z
-                geom->mVertices[i].x = faceVertices[i].x;
-                geom->mVertices[i].y = -faceVertices[i].z;
-                geom->mVertices[i].z = faceVertices[i].y;
-        
-                geom->mNormals[i].x = faceNormals[i].x;
-                geom->mNormals[i].y = -faceNormals[i].z;
-                geom->mNormals[i].z = faceNormals[i].y;
+                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 = faceVertices[i].x;
-                geom->mVertices[i].y = faceVertices[i].y;
-                geom->mVertices[i].z = faceVertices[i].z;
-        
-                geom->mNormals[i].x = faceNormals[i].x;
-                geom->mNormals[i].y = faceNormals[i].y;
-                geom->mNormals[i].z = faceNormals[i].z;
+                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
@@ -195 +199 @@
                 if (i < geom->mTexcoordCount)
                 {
-                        geom->mTexcoords[i].first = faceTexcoords[i].first;
-                        geom->mTexcoords[i].second = faceTexcoords[i].second;
+                        geom->mTexCoords[i].first = texCoords[i].first;
+                        geom->mTexCoords[i].second = texCoords[i].second;
                 }
         }
@@ -204 +208 @@
 
 
-bool ObjConverter::Convert(const string &filename, const std::string &outputFilename)
+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]->mTexCoords;
 
                 delete mGeometry[i];
@@ -219 +227 @@
         mGeometry.clear();
 
-        if (!ReadFile(filename))
+        if (!LoadSolution(bvhInputFilename))
         {
                 cerr << "could not read file" << endl;
@@ -225 +233 @@
         }
 
-        if (!WriteFile(outputFilename))
+        if (!ReadScene(sceneInputFilename))
+        {
+                cerr << "could not read file" << endl;
+                return false;
+        }
+
+        if (!WriteScene(sceneOutputFilename))
         {
                 cerr << "could not write file" << endl;
@@ -231 +245 @@
         }
 
+        /*if (!WriteBvh(bvhOutputFilename))
+        {
+                cerr << "could not write file" << endl;
+                return false;
+        }*/
 
         return true;
@@ -236 +255 @@
 
 
-bool ObjConverter::ReadFile(const string &filename) 
+bool VisibilitySolutionConverter::ReadScene(const string &filename) 
 {
         FILE *file;
@@ -247 +266 @@
         VertexArray faceVertices; 
         VertexArray faceNormals;
-        vector<Texcoord> faceTexcoords;
+        vector<TexCoord> faceTexcoords;
 
         VertexArray vertices; 
         VertexArray normals;
-        vector<Texcoord> texcoords;
+        vector<TexCoord> texcoords;
 
         vector<int> indices;
@@ -261 +280 @@
         while (fgets(str, len, file) != NULL)
         {
+                if (line % 1000000 == 0)
+                        cout << line << " " << str << endl;
+
+                ++ line;
+
                 switch (str[0])
                 {
@@ -266 +290 @@
                         {
                                 float x, y, z;
+
+                                if (vertices.size() >= 1000000 * 3) continue;
 
                                 switch (str[1]) 
@@ -280 +306 @@
                                         sscanf(str + 1, "%f %f %f", &x, &y, &z);
                                         //const float scale = 5e-3f;
-                                        const float scale = 1.0f;
-                                        vertices.push_back(SimpleVec(x * scale, y * scale, z* scale));
+                                        const float scale = 0.1f;
+                                        vertices.push_back(SimpleVec(x * scale, y * scale, z * scale));
                                         //cout <<"v " << x << " " << y << " "<< z << " ";
                                 }
@@ -291 +317 @@
                                 //-- indices in the current line
 
+                                if (faceVertices.size() >= 1000000 * 3) continue;
+
                                 LoadIndices(str, 
                                                 vertices, normals, texcoords, 
                                                 faceVertices, faceNormals, faceTexcoords);
 
-                                if (0 &&
-                                        (((line % 1000) == 999) && !faceVertices.empty()))
-                                {
-                                        ++ mNumShapes;
-
-                                        LoadShape(faceVertices, faceNormals, faceTexcoords);
-
-                                        faceVertices.clear();
-                                        faceNormals.clear();
-                                        faceTexcoords.clear();
-                                }
-
                                 break;
-                        }   // end face
-                case 'g': // load a new shape
-                        {/*
-                                if (!faceVertices.empty())
-                                {
-                                        ++ mNumShapes;
-
-                                        LoadShape(faceVertices, faceNormals, faceTexcoords);
-
-                                        faceVertices.clear();
-                                        faceNormals.clear();
-                                        faceTexcoords.clear();
-                                }*/
-                        }
+                        }  
                         break;
                 default:
@@ -327 +330 @@
                         break;
                 }
-
-                ++ line;
         }
 
@@ -335 +336 @@
                 ++ mNumShapes;
 
-                LoadShape(faceVertices, faceNormals, faceTexcoords);
+                ConstructBvhObjects(faceVertices, faceNormals, faceTexcoords);
 
                 faceVertices.clear();
@@ -348 +349 @@
 
 
-void ObjConverter::WriteGeometry(ogzstream &str, Geometry *geom)
+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;
@@ -360 +367 @@
 
         if (texCoordCount)
-                str.write(reinterpret_cast<char *>(geom->mTexcoords), sizeof(float) * texCoordCount * 2);
-        
+        {
+                str.write(reinterpret_cast<char *>(geom->mTexCoords), sizeof(float) * texCoordCount * 2);
+        }
 
         ///////
@@ -392 +400 @@
                 ambient.x = ambient.y = ambient.z = 0.2f;
                 //diffuse.x = diffuse.y = diffuse.z = 1.0f;
-                diffuse.x = 0.7f; diffuse.y = 0.5f; diffuse.z = 0.2f;
+
+                diffuse.x = RandomColor(0.5f); 
+                diffuse.y = RandomColor(0.5f);
+                diffuse.z = RandomColor(0.5f);
+
                 spec.x    = spec.y    = spec.z    =  .0f;
                 emm = spec;
@@ -405 +417 @@
 
 
-bool ObjConverter::WriteFile(const string &filename)
+bool VisibilitySolutionConverter::WriteScene(const string &filename)
 {
         ogzstream ofile(filename.c_str());
@@ -482 +494 @@
         return true;
 }
+
+
+void VisibilitySolutionConverter::ConstructBvhObjects(const VertexArray &vertices,
+                                                                                                          const VertexArray &normals,
+                                                                                                          const vector<TexCoord> &texCoords)
+{
+        cout << "vtx: " << vertices.size() << endl;
+/*      BvhNode n;
+        
+        mGlobalTriangleIds.clear();
+        for (size_t i = 0; i < vertices.size() / 3; ++ i)
+        {
+                mGlobalTriangleIds.push_back((int)i);
+        }
+
+        for (size_t i = 0; i < vertices.size() / 3; ++ i)
+                n.mTriangleIds.push_back((int)i);
+
+        mBvhNodes.push_back(n);
+*/
+        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]);
+                                }
+                        }
+                }
+
+                LoadShape(_vertices, _normals, _texCoords);
+        }
+}
+
+
+bool VisibilitySolutionConverter::WriteBvh(const string &filename)
+{
+        ogzstream ofile(filename.c_str());
+
+        if (!ofile.is_open())
+                return false;
+        
+
+        /////////
+        //-- write textures
+
+#ifdef USE_TEXTURE
+        int textureCount = 1;
+#else
+        int textureCount = 0;
+#endif
+        ofile.write(reinterpret_cast<char *>(&textureCount), sizeof(int));
+
+        if (textureCount > 0)
+        {
+                // hack
+                const string texName("wood.jpg");
+
+                int texnameSize = (int)texName.length() + 1;
+                ofile.write(reinterpret_cast<char *>(&texnameSize), sizeof(int));
+
+                ofile.write(texName.c_str(), sizeof(char) * texnameSize);
+
+                int boundS = 1, boundT = 1;
+
+                ofile.write(reinterpret_cast<char *>(&boundS), sizeof(int));
+                ofile.write(reinterpret_cast<char *>(&boundT), sizeof(int));
+        }
+
+
+        ///////////
+        //-- write shapes
+
+        ofile.write(reinterpret_cast<char *>(&mNumShapes), sizeof(int));
+
+        vector<Geometry *>::const_iterator it, it_end = mGeometry.end();
+
+        for (it = mGeometry.begin(); it != it_end; ++ it)
+        {
+                WriteGeometry(ofile, *it);
+        }
+
+
+        int entityCount = 1;
+        ofile.write(reinterpret_cast<char *>(&entityCount), sizeof(int));
+
+
+        //////////
+        //-- write single scene entity
+
+        // 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));
+
+        ofile.write(reinterpret_cast<char *>(&mNumShapes), sizeof(int));
+
+        // all shapes belong to this scene entity
+        for (int i = 0; i < mNumShapes; ++ i)
+        {
+                int shapeId = i;
+                ofile.write(reinterpret_cast<char *>(&shapeId), sizeof(int));
+        }
+
+        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[i] = 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

GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/VisibilitySolutionConverter.h

@@ -1 @@
-#ifndef _OBJCONVERTER_H
-#define _OBJCONVERTER_H
+#ifndef _VISIBILITYSOLUTIONCONVERTER_H
+#define _VISIBILITYSOLUTIONCONVERTER_H
+
 
 #include "SimpleVec.h"
@@ -6 +7 @@
 #include <vector>
 
-/*struct SimpleVec
-{
-        SimpleVec() {}
-        SimpleVec(float _x, float _y, float _z): x(_x), y(_y), z(_z) {}
 
-        float x, y, z;
-};*/
 
 typedef std::vector<SimpleVec> VertexArray;
-typedef std::pair<float, float> Texcoord;
+typedef std::pair<float, float> TexCoord;
 
 class ogzstream;
 
+
+struct BvhNode
+{
+        int id;
+        char axis;
+        unsigned char depth;
+        short flags;
+
+        // indices to first and last triangle in the triangle array
+        // assumes the traingle are placed in continuous chunk of memory
+        // however this need not be a global array!
+        int first;
+        // one after the last triangle!
+        int last;
+
+        BvhNode(): axis(-1), first(-1), flags(0) {}
+
+        bool IsLeaf() { return axis == -1; }
+        bool Empty() const { return first == -1; }
+        int Count() const { return last - first + 1; }
+
+        std::vector<int> mTriangleIds;
+};
+
+
+struct BvhInterior: public BvhNode
+{
+        BvhInterior():back(NULL), front(NULL) { }
+        BvhNode *back;
+        BvhNode *front;
+};
+
+
+struct BvhLeaf: public BvhNode
+{
+        //Color color;
+        int texture;
+
+        BvhLeaf(): BvhNode(), texture(0) {}
+};
+
+
 /** Converts obj format into objects readable by our format
 */
-class ObjConverter
+class VisibilitySolutionConverter
 {
 public:
 
-        ObjConverter();
+        VisibilitySolutionConverter();
 
-        bool Convert(const std::string &inputFilename, 
-                         const std::string &outputFilename);
-        // const std::string textureFilename) const;
+        ~VisibilitySolutionConverter();
 
-        ~ObjConverter();
+        bool Convert(const std::string &sceneInputFilename,
+                                 const std::string &sceneOutputFilename,
+                                 const std::string &bvhInputFilename,
+                         const std::string &bvhOutputFilename);
+        
+
 
 protected:
@@ -39 +79 @@
                 SimpleVec *mVertices;
                 SimpleVec *mNormals;
-                Texcoord *mTexcoords;
+                TexCoord *mTexCoords;
 
                 int mVertexCount;
@@ -45 +85 @@
         };
 
-        void LoadShape(const VertexArray &faceVertices,
-                           const VertexArray &faceNormals,
-                                   const std::vector<Texcoord> &faceTexcoords);
+        void LoadShape(const VertexArray &vertices,
+                           const VertexArray &normals,
+                                   const std::vector<TexCoord> &texCoords);
 
         void WriteGeometry(ogzstream &str, Geometry *geom);
 
-        bool ReadFile(const std::string &inputFilename);
-        bool WriteFile(const std::string &outputFilename);
+        bool ReadScene(const std::string &iFilename);
 
+        bool WriteScene(const std::string &oFilename);
+
+        bool ReadBvh(FILE *fr);
+
+        bool WriteBvh(const std::string &oFilename);
+
+        void ConstructBvhObjects(const VertexArray &vertices,
+                                     const VertexArray &normals,
+                                                         const std::vector<TexCoord> &texCoords);
+
+        bool LoadSolution(const std::string &filename);
+
+
+        BvhNode *LoadNode(FILE *fr, int depth);
+
+        bool ReadDummyTree(FILE *fr);
+
+
+
+        //////////////////////////////////
 
         std::vector<Geometry *> mGeometry;
 
         int mNumShapes;
+
+        std::vector<int> mGlobalTriangleIds;
+
+        std::vector<BvhNode *> mBvhNodes;
+
+        BvhNode *mRoot;
+
+        int mNumNodes;
 };
 

GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/main.cpp

@@ -1 @@
-#include "ObjConverter.h"
+#include "VisibilitySolutionConverter.h"
 #include <iostream>
 #include <time.h>
@@ -11 +11 @@
         int returnCode = 0;
 
-        ObjConverter converter;
+        VisibilitySolutionConverter converter;
 
         cout << "converting obj to dem format" << endl;
 
-        if (!converter.Convert(model_path + argv[1], model_path + argv[2]))
+        if (!converter.Convert(model_path + argv[1], model_path + argv[2], model_path + argv[3], model_path + argv[4]))
         {
                 cerr << "conversion failed" << endl;
@@ -22 +22 @@
                 exit(0);
         }
-        //std::cin.get();
+        
+        std::cin.get();
         cout << "conversion successful" << endl;