source: GTP/trunk/Lib/Vis/Preprocessing/src/ObjParser.cpp @ 2600

#include <stdlib.h>
#include <iostream>
#include <list>
#include <map>
#include <math.h>

#include "Vector3.h"
#include "Mesh.h"
#include "SceneGraph.h"

#include "ObjParser.h"
//#include "Material.h"
#include "Triangle3.h"
#include "Environment.h"
#include "ResourceManager.h"
#include "IntersectableWrapper.h"


using namespace std;

namespace GtpVisibilityPreprocessor {

#define CONNECT_SEQUENTIAL_FACES 0
#define ROTATE_SCENE 0

// hack: define this as in the intel ray tracer
#define FLT_EPSILON 1.192092896e-07f

// HACK
static void RotateMesh(Mesh *mesh)
{
        VertexContainer::iterator it, it_end = mesh->mVertices.end();

        const float angle = 30.0f * PI / 180.0f;
        const Matrix4x4 rot = RotationYMatrix(angle);

        for (it = mesh->mVertices.begin(); it != it_end; ++ it)
        {
                (*it) = rot * (*it);        
        }
}


struct ltstr
{
        bool operator()(const string s1, const string s2) const
        {
                return s1 < s2;
        }
};


static Face *LoadFace(char *str, 
                                          const VertexContainer &vertices, 
                                          map<int, Vector3> &hashTable)
{
        char *pch = strtok(str + 1, " ");
        
        VertexIndexContainer indices;
        while (pch != NULL)
        {
                const int index = (int)strtol(pch, NULL, 10) - 1;
                //Debug << index << " x ";
                
                // store vertex in hash table
                hashTable[index] = vertices[index];
                indices.push_back(index);
                
                pch = strtok(NULL, " ");
        }

        return new Face(indices); 
}


static void LoadTriangles(char *str, 
                                                  const VertexContainer &vertices, 
                                                  vector<Triangle3> &triangles,
                                                  const int line)
{
        vector<char *> substrings;

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

        while (pch != NULL)
        {
                substrings.push_back(pch);
                pch = strtok(NULL, " ");          
        }

        //for (int i = 0; i < substrings.size(); ++ i)
        //      cout << "sub: " << substrings[i] << " ";

        VertexIndexContainer indices;

        for (int i = 0; i < substrings.size(); ++ i)
        {
                // discard normal and texture indices
                // and only keep first index
        
                char *str = strtok(substrings[i], "/");   
                const int index = (int)strtol(str, NULL, 10) - 1;

                // store indices
                if (index >= 0)
                        indices.push_back(index);

                //cout << "i " << index << " ";

                // new triangle found
                // problem: don't know how intel ray tracer tesselates
                if ((int)indices.size() > 2)
                {
                        const int idx2 = (int)indices.size() - 2;
                        const int idx3 = (int)indices.size() - 1;

                        triangles.push_back(Triangle3(vertices[indices[0]], 
                                                                                  vertices[indices[idx2]],              
                                                                                  vertices[indices[idx3]]));
                }
        }
}


static Mesh *CreateMesh(FaceContainer &faces, 
                                                const map<int, Vector3> &hashTable)
{
        Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
        
        FaceContainer::const_iterator fit, fit_end = faces.end();

        for (fit = faces.begin(); fit != fit_end; ++ fit)
        {
                Face *face = *fit;
                VertexIndexContainer::iterator vit, vit_end = face->mVertexIndices.end();
                
                for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit)
                {
                        // go through indices
                        const int index = *vit;
                        map<int, Vector3>::const_iterator hit = hashTable.find(index);

                        // correct face index (nust be relative to start of verices)
                        (*vit) = (int)distance(hashTable.begin(), hit);
                }
        }

        VertexContainer vertices;

        map<int, Vector3>::const_iterator hit, hit_end = hashTable.end();

        // store vertices in given order
        for (hit = hashTable.begin(); hit != hit_end; ++ hit)
        {
                mesh->mVertices.push_back((*hit).second);
        }

        mesh->mFaces = faces;
        // can't do cleanup because coupling with kdf file for intel ray tracer
        mesh->Preprocess(false);

        return mesh;
}


// HACK: associate mesh instances with triangles
static void AssociateFacesWithInstance(MeshInstance *mi,
                                                                           vector<FaceParentInfo> &parents)
{
        Mesh *mesh = mi->GetMesh();

        int i = 0;
        FaceContainer::const_iterator fit, fit_end = mesh->mFaces.end();

        for (fit = mesh->mFaces.begin(); fit != fit_end; ++ fit, i++)
        {
                parents.push_back(FaceParentInfo(mi, i));
        }
}


static void ProcessMesh(FaceContainer &faces, 
                                                map<int, Vector3> &hashTable,
                                                SceneGraphLeaf *root,
                                                vector<FaceParentInfo> *parents)
{
        Mesh *mesh = CreateMesh(faces, hashTable);
        // make an instance of this mesh
        MeshInstance *mi = new MeshInstance(mesh);
                
        if (parents) 
        {
                AssociateFacesWithInstance(mi, *parents);
        }

        root->mGeometry.push_back(mi);  

        // reset tables
        hashTable.clear();
        faces.clear();
}


bool TriangleValid(const Triangle3 &triangle)
{
        const Vector3 a = triangle.mVertices[0] - triangle.mVertices[1];
        const Vector3 b = triangle.mVertices[0] - triangle.mVertices[2];
        const Vector3 cross_a_b = CrossProd(a, b);

#define SMALL_FLT   1e-5
        
        if (SqrMagnitude(cross_a_b) <= 0.0001 * SMALL_FLT * SMALL_FLT) 
        {
                // v0, v1 & v2 lies on a line (area == 0)
                return false;
        }

        return true;
}


bool ObjParser::ParseFile(const string filename,
                                                  SceneGraphLeaf *root,
                                                  const bool loadMeshes,
                                                  vector<FaceParentInfo> *parents)
{
        FILE *file;
        if ((file = fopen(filename.c_str(), "rt")) == NULL)
        {       
                return false;
        }

        map<int, Vector3> hashTable; // table associating indices with vectors
        VertexContainer vertices; // table for vertices
        FaceContainer faces;

        int line = 0;

        char str[100000];
        int meshGrouping;
        Environment::GetSingleton()->GetIntValue("ObjParser.meshGrouping", meshGrouping);

        int nMaxFaces = meshGrouping;

        while (fgets(str, 100000, file) != NULL)
        {
                switch (str[0]) 
                {
                case 'v': // vertex  or normal
                        {
                                switch (str[1]) 
                                {
                                case 'n' :
                                        // do nothing for normals
                                        break;
                                case 't':
                                        // do nothing for textures
                                        break;
                                default:
                                        float x, y, z; //cout << "v";   
                                        sscanf(str + 1, "%f %f %f", &x, &y, &z);
                                        vertices.push_back(Vector3(x,y,z));

                                }
                                break;
                        }
                case 'f': 
                        {
                                if (loadMeshes)
                                {
                                        Face *face = LoadFace(str, vertices, hashTable);

                                        if (!face) break;

                                        faces.push_back(face);

                                        if ((int)faces.size() >= nMaxFaces)
                                        {
                                                ProcessMesh(faces, hashTable, root, parents);
                                        }
                                }
                                else
                                {
                                        ++ line;

                                        //////////
                                        // construct the triangles given in the current line

                                        vector<Triangle3> triangles;
                                        LoadTriangles(str, vertices, triangles, line);

                                        vector<Triangle3>::const_iterator tit, tit_end = triangles.end();

                                        for (tit = triangles.begin(); tit != tit_end; ++ tit)
                                        {
                                          // test if it is a valid triangle
                                          if (!TriangleValid(*tit))
                                            continue;

                                          TriangleIntersectable *obj = new TriangleIntersectable(*tit); 
                                          root->mGeometry.push_back(obj);
                                        }
                                }
                                break;
                        }   // end face
                default:
                        break;
                }
        }

        //cout << "\n**** " << root->mGeometry.size() << " " << " lines: " << line << endl;
        if (loadMeshes)
        {
                // there could be faces remaining
                if (!faces.empty())
                {       
                        ProcessMesh(faces, hashTable, root, parents);
                }
        }

        // reset tables
        hashTable.clear();
        faces.clear();
        fclose(file);
        
        return true;
}

}