Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *

 * This file is part of GEL, http://www.imm.dtu.dk/GEL

 * Copyright (C) the authors and DTU Informatics

 * For license and list of authors, see ../../doc/intro.pdf

 * ----------------------------------------------------------------------- */

#include "TriMesh.h"

#include "../CGLA/Vec3f.h"

#include <fstream>

#include <iostream>

using namespace std;

using namespace CGLA;

namespace Geometry {

	namespace

	{

		string get_path(const string& _filename)

		{

			// Make sure we only have slashes and not backslashes

			string filename = _filename;

			replace(filename.begin(),filename.end(),'\\','/');

			// Find the last occurrence of slash.

			// Everything before is path.

			size_t n = filename.rfind("/");

			if(n > filename.size())

				return "./";

			string pathname(filename,0,n);

			pathname.append("/");

			return pathname;

		}

	}

	class TriMeshObjLoader

	{

		TriMesh *mesh;

		std::string pathname;

		int get_vert(int i) {

			assert(i!=0);

			if (i<0) {

				return mesh->geometry.no_vertices()+i;

			} else

				return i-1;

		}

		int get_normal(int i) {

			if (i<0) {

				return mesh->normals.no_vertices()+i;

			} else

				return i-1;

		}

		int get_texcoord(int i) {

			if (i<0) {

				return mesh->texcoords.no_vertices()+i;

			} else

				return i-1;

		}

    void read_material_library(const string& filename, vector<Material>& materials);

	public:

		TriMeshObjLoader(TriMesh *_mesh): mesh(_mesh) {}

		void load(const std::string& filename);

    void load_material_library(const string& filename, vector<Material>& materials)

    {

      pathname = get_path(filename);

      read_material_library(filename, materials);

    }        

	};

	void TriMeshObjLoader::read_material_library(const string& filename, vector<Material>& materials)

	{

    string fn = pathname + filename;

    ifstream material_file(fn.data());  

    if(!material_file)

    {

      cerr << "Could not open " << filename << endl;

      return;

    }

    materials.resize(1);

    string buf;

    unsigned int nummaterials=0;

    while(material_file >> buf)

    {

      switch(buf[0])

      {

      case 'n':

        ++nummaterials;

        materials.push_back(Material());

        material_file >> materials[nummaterials].name;

        break;

      case 'N':

        switch(buf[1])

        {

        case 's':

          material_file >> materials[nummaterials].shininess;

          materials[nummaterials].shininess *= 128.0f/1000.0f;

          break;

        case 'i':

          material_file >> materials[nummaterials].ior;

          break;

        }

        break;

      case 'K':

        switch(buf[1])

        {

        case 'd':

          material_file >> materials[nummaterials].diffuse[0]

                        >> materials[nummaterials].diffuse[1]

                        >> materials[nummaterials].diffuse[2];

          break;

        case 's':

          material_file >> materials[nummaterials].specular[0]

                        >> materials[nummaterials].specular[1]

                        >> materials[nummaterials].specular[2];

          break;

        case 'a':

          material_file >> materials[nummaterials].ambient[0]

                        >> materials[nummaterials].ambient[1]

                        >> materials[nummaterials].ambient[2];

          break;

        }

        break;

      case 'T':

        switch(buf[1])

        {

        case 'f':

          material_file >> materials[nummaterials].transmission[0]

                        >> materials[nummaterials].transmission[1]

                        >> materials[nummaterials].transmission[2];

          break;

        }

        break;

      case 'i':

        material_file >> materials[nummaterials].illum;

        break;

      case 'm': // Map ... all maps are treated equally.

        material_file >> materials[nummaterials].tex_name;

        materials[nummaterials].has_texture = true;

        materials[nummaterials].tex_path = pathname;

        break;

      case '#':

      default:

        material_file.ignore(1024, '\n');

        break;

      }

    }

  }

  void TriMeshObjLoader::load(const std::string& filename)

  {

    pathname = get_path(filename);

    ifstream obj_file(filename.data());

    if(!obj_file)

    {

			cerr << "File " << filename << " does not exist" << endl;

      exit(0);

    }

    mesh->materials.resize(1);

    string buf;

    int current_material=0;

    while(obj_file >> buf)

    {

      switch(buf[0])

      {

      case 'v': // v, vn, vt

        {

          if(buf == "v")

          {

            Vec3f v_geo;

            obj_file >> v_geo;

            mesh->geometry.add_vertex(v_geo);

          }

          else if(buf == "vn")

          {

            Vec3f v_norm;

            obj_file >> v_norm;

            mesh->normals.add_vertex(v_norm);

          }

          else if(buf == "vt")

          {

            Vec3f v_tex;

            obj_file >> v_tex[0] >> v_tex[1];

            v_tex[2]=1;

            mesh->texcoords.add_vertex(v_tex);

          }

        }

        break;

      case 'f':

        {

          char line[1024];

          vector<int> v_indices;

          vector<int> t_indices;

          vector<int> n_indices;

          obj_file.getline(line, 1022);

          char* pch = strtok(line, " \t");

          while(pch != 0)

          {

            int v,t,n;

            if(sscanf(pch, "%d/%d/%d", &v, &t, &n)==3)

            {

              v_indices.push_back(get_vert(v));

              t_indices.push_back(get_texcoord(t));

              n_indices.push_back(get_normal(n));

            }

            else if(sscanf(pch, "%d//%d", &v, &n)==2)

            {

              v_indices.push_back(get_vert(v));

              n_indices.push_back(get_normal(n));

            }

            else if(sscanf(pch, "%d/%d", &v, &t)==2)

            {

              v_indices.push_back(get_vert(v));

              t_indices.push_back(get_texcoord(t));

            }

            else if(sscanf(pch, "%d", &v)==1)

              v_indices.push_back(get_vert(v));

            pch = strtok(0, " \t");

          }

          if(v_indices.size()>=3)

            for(size_t i=0;i<=(v_indices.size()-3);++i)

            {

              int idx = mesh->geometry.add_face(Vec3i(v_indices[0], v_indices[i+1], v_indices[i+2]));

              if(t_indices.size())

              mesh->texcoords.add_face(Vec3i(t_indices[0], t_indices[i+1], t_indices[i+2]), idx);

              if(n_indices.size())

              mesh->normals.add_face(Vec3i(n_indices[0], n_indices[i+1], n_indices[i+2]), idx);

              mesh->mat_idx.push_back(current_material);

            }

        }

        break;

      case 'm':

        obj_file >> buf;

        read_material_library(buf, mesh->materials);

        break;

      case 'u':

        obj_file >> buf;

        current_material = mesh->find_material(buf);

        break;

      case '#':

      default:

        obj_file.ignore(1024, '\n');

        break;                        

      }

    }

  }

	void obj_load(const string& filename, TriMesh &mesh)

	{

		TriMeshObjLoader loader(&mesh);

		loader.load(filename);

	}

  /// Load materials from an MTL file

  void mtl_load(const std::string& filename, std::vector<Material>& materials)

  {

    TriMeshObjLoader loader(0);

    loader.load_material_library(filename, materials);

  }    

}