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

#include <stdlib.h>
#include <iostream>
#include <list>
#include <map>
using namespace std;

#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"


namespace GtpVisibilityPreprocessor {

#define CONNECT_SEQUENTIAL_FACES 0
#define ROTATE_SCENE 0

// 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, " ");
        }
        //if (indices.size() > 4) return NULL;

        return new Face(indices); 
}


static Triangle3 LoadTriangle(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;
                                
                // store vertex in hash table
                hashTable[index] = vertices[index];
                indices.push_back(index);
                
                pch = strtok(NULL, " ");
        }
        
    return Triangle3(vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]); 
}


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;            
                        //Debug << "old idx: " << (*vit) << endl;
                        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);
                        //Debug << "new idx: " << (*vit) << endl;
                }
        }

        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,
                                                SceneGraphNode *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 ObjParser::ParseFile(const string filename,
                                                  SceneGraphNode *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;

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

        int nMaxFaces = meshGrouping;

        while (fgets(str, 80, file) != NULL)
        {
          switch (str[0]) 
                {
                case 'v': // vertex  or normal
                  {
                        switch (str[1]) {
                        case 'n' :
                          // normal do nothing
                          break;
                        default:
                          float x, y, z; //cout << "v"; 
                          sscanf(str + 1, "%f %f %f", &x, &y, &z);
                          vertices.push_back(Vector3(x,y,z));
                          //cout << "vertex: " << vertices.back() << endl;
                        }
                        break;
                  }
                case 'f': 
                        {
                                //      cout << "f";
                                if (loadMeshes)
                                {
                                        Face *face = LoadFace(str, vertices, hashTable);
                                        if (!face) break;
        
                                        faces.push_back(face);

                                        if (faces.size() >= nMaxFaces)
                                        {
                                                ProcessMesh(faces, hashTable, root, parents);
                                        }
                                }
                                else
                                {
                                        Triangle3 triangle = LoadTriangle(str, vertices, hashTable);
                                
                                        TriangleIntersectable *obj = new TriangleIntersectable(triangle);
                                        root->mGeometry.push_back(obj);

                                        // matt: we don't really need to keep an additional data structure
                                        // if working with triangles => remove this
                                        if (parents) 
                                        {
                                                FaceParentInfo info(obj, 0);
                                                parents->push_back(info);
                                        }
                                }
                                break;
                        }   // end face
                default:
                        break;
                }
        }

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

}