source: GTP/trunk/App/Demos/Vis/FriendlyCulling/VisibilitySolutionConverter/VisibilitySolutionConverter.h @ 3282

#ifndef _VISIBILITYSOLUTIONCONVERTER_H
#define _VISIBILITYSOLUTIONCONVERTER_H


#include "Vector3.h"
#include "Triangle3.h"
#include <string>
#include <vector>
#include "AxisAlignedBox3.h"

        

typedef std::vector<CHCDemoEngine::Vector3> VertexArray;
typedef std::pair<float, float> TexCoord;

class ogzstream;
struct BvhInterior;



struct Geometry
{
        CHCDemoEngine::Vector3 *mVertices;
        CHCDemoEngine::Vector3 *mNormals;
        TexCoord *mTexCoords;

        int mVertexCount;
        int mTexcoordCount;
};


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; }

        CHCDemoEngine::AxisAlignedBox3 box;

        BvhInterior *parent;
        std::vector<int> mTriangleIds;
};


struct BvhInterior: public BvhNode
{
        BvhInterior():back(NULL), front(NULL) { }
        BvhNode *back;
        BvhNode *front;
};


struct BvhLeaf: public BvhNode
{
        BvhLeaf(): BvhNode() {}
};


/** Converts obj format into objects readable by our format
*/
class VisibilitySolutionConverter
{
public:

        VisibilitySolutionConverter();

        ~VisibilitySolutionConverter();

        bool Convert(const std::string &sceneInputFilename,
                                 const std::string &sceneOutputFilename,
                                 const std::string &bvhInputFilename,
                         const std::string &bvhOutputFilename);
        

protected:


        void LoadShape(const VertexArray &vertices,
                           const VertexArray &normals,
                                   const std::vector<TexCoord> &texCoords);

        void WriteGeometry(ogzstream &str, Geometry *geom);

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

        bool ReadObj(const std::string &filename,
                         VertexArray &vertices,
                                 VertexArray &normals,
                                 std::vector<TexCoord> &texcoords);

        bool ReadBinObj(const std::string &filename,
                    VertexArray &vertices);

        bool WriteBinObj(const std::string &filename,
                             const VertexArray &vertices);

        bool ExportBinObj(const std::string &filename,
                              const VertexArray &vertices);

        void WriteNextNode(ogzstream &stream, BvhNode *parent);

        void UpdateLeafBox(BvhLeaf *leaf);
        /** Prepare bvh for exporting.
        */
        void UpdateBvh(BvhNode *node);

        bool LoadSolutionTest(const std::string &filename);


        bool ReadObjSimple(const std::string &filename,
                std::vector<CHCDemoEngine::Triangle3 *> &triangles);

        void ConstructBvhObjects2(const std::vector<CHCDemoEngine::Triangle3 *> &triangles);



        //////////////////////////////////

        std::vector<Geometry *> mGeometry;

        int mNumShapes;

        std::vector<int> mGlobalTriangleIds;

        std::vector<BvhLeaf *> mBvhLeaves;

        BvhNode *mRoot;

        int mNumNodes;
};



#endif