WebSVN – gelsvn – Diff – /trunk/src/Geometry/obj_load.cpp


/* ----------------------------------------------------------------------- *
 * 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':
        material_file >> materials[nummaterials].transmission[0]
                      >> materials[nummaterials].transmission[1]
                      >> materials[nummaterials].transmission[2];
        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);
  }    
}
 

Rev 606	Rev 612
1	`/* ----------------------------------------------------------------------- *`	1	`/* ----------------------------------------------------------------------- *`
2	`* This file is part of GEL, http://www.imm.dtu.dk/GEL`	2	`* This file is part of GEL, http://www.imm.dtu.dk/GEL`
3	`* Copyright (C) the authors and DTU Informatics`	3	`* Copyright (C) the authors and DTU Informatics`
4	`* For license and list of authors, see ../../doc/intro.pdf`	4	`* For license and list of authors, see ../../doc/intro.pdf`
5	`* ----------------------------------------------------------------------- */`	5	`* ----------------------------------------------------------------------- */`
6		6
7	`#include "TriMesh.h"`	7	`#include "TriMesh.h"`
8	`#include "../CGLA/Vec3f.h"`	8	`#include "../CGLA/Vec3f.h"`
9	`#include <fstream>`	9	`#include <fstream>`
10	`#include <iostream>`	10	`#include <iostream>`
11		11
12	`using namespace std;`	12	`using namespace std;`
13	`using namespace CGLA;`	13	`using namespace CGLA;`
14		14
15	`namespace Geometry {`	15	`namespace Geometry {`
16		16
17	`namespace`	17	`namespace`
18	`{`	18	`{`
19	`string get_path(const string& _filename)`	19	`string get_path(const string& _filename)`
20	`{`	20	`{`
21	`// Make sure we only have slashes and not backslashes`	21	`// Make sure we only have slashes and not backslashes`
22	`string filename = _filename;`	22	`string filename = _filename;`
23	`replace(filename.begin(),filename.end(),'\\','/');`	23	`replace(filename.begin(),filename.end(),'\\','/');`
24		24
25	`// Find the last occurrence of slash.`	25	`// Find the last occurrence of slash.`
26	`// Everything before is path.`	26	`// Everything before is path.`
27	`size_t n = filename.rfind("/");`	27	`size_t n = filename.rfind("/");`
28	`if(n > filename.size())`	28	`if(n > filename.size())`
29	`return "./";`	29	`return "./";`
30	`string pathname(filename,0,n);`	30	`string pathname(filename,0,n);`
31	`pathname.append("/");`	31	`pathname.append("/");`
32	`return pathname;`	32	`return pathname;`
33	`}`	33	`}`
34	`}`	34	`}`
35	`class TriMeshObjLoader`	35	`class TriMeshObjLoader`
36	`{`	36	`{`
37	`TriMesh *mesh;`	37	`TriMesh *mesh;`
38	`std::string pathname;`	38	`std::string pathname;`
39		39
40	`int get_vert(int i) {`	40	`int get_vert(int i) {`
41	`assert(i!=0);`	41	`assert(i!=0);`
42	`if (i<0) {`	42	`if (i<0) {`
43	`return mesh->geometry.no_vertices()+i;`	43	`return mesh->geometry.no_vertices()+i;`
44	`} else`	44	`} else`
45	`return i-1;`	45	`return i-1;`
46	`}`	46	`}`
47		47
48	`int get_normal(int i) {`	48	`int get_normal(int i) {`
49	`if (i<0) {`	49	`if (i<0) {`
50	`return mesh->normals.no_vertices()+i;`	50	`return mesh->normals.no_vertices()+i;`
51	`} else`	51	`} else`
52	`return i-1;`	52	`return i-1;`
53	`}`	53	`}`
54		54
55	`int get_texcoord(int i) {`	55	`int get_texcoord(int i) {`
56	`if (i<0) {`	56	`if (i<0) {`
57	`return mesh->texcoords.no_vertices()+i;`	57	`return mesh->texcoords.no_vertices()+i;`
58	`} else`	58	`} else`
59	`return i-1;`	59	`return i-1;`
60	`}`	60	`}`
61		61
62	`void read_material_library(const string& filename, vector<Material>& materials);`	62	`void read_material_library(const string& filename, vector<Material>& materials);`
63		63
64	`public:`	64	`public:`
65		65
66	`TriMeshObjLoader(TriMesh *_mesh): mesh(_mesh) {}`	66	`TriMeshObjLoader(TriMesh *_mesh): mesh(_mesh) {}`
67		67
68	`void load(const std::string& filename);`	68	`void load(const std::string& filename);`
69		69
70	`void load_material_library(const string& filename, vector<Material>& materials)`	70	`void load_material_library(const string& filename, vector<Material>& materials)`
71	`{`	71	`{`
72	`pathname = get_path(filename);`	72	`pathname = get_path(filename);`
73	`read_material_library(filename, materials);`	73	`read_material_library(filename, materials);`
74	`}`	74	`}`
75	`};`	75	`};`
76		76
77	`void TriMeshObjLoader::read_material_library(const string& filename, vector<Material>& materials)`	77	`void TriMeshObjLoader::read_material_library(const string& filename, vector<Material>& materials)`
78	`{`	78	`{`
79	`string fn = pathname + filename;`	79	`string fn = pathname + filename;`
80	`ifstream material_file(fn.data());`	80	`ifstream material_file(fn.data());`
81	`if(!material_file)`	81	`if(!material_file)`
82	`{`	82	`{`
83	`cerr << "Could not open " << filename << endl;`	83	`cerr << "Could not open " << filename << endl;`
84	`return;`	84	`return;`
85	`}`	85	`}`
-		86	`materials.resize(1);`
86		87
87	`string buf;`	88	`string buf;`
88	`unsigned int nummaterials=0;`	89	`unsigned int nummaterials=0;`
89	`while(material_file >> buf)`	90	`while(material_file >> buf)`
90	`{`	91	`{`
91	`switch(buf[0])`	92	`switch(buf[0])`
92	`{`	93	`{`
93	`case 'n':`	94	`case 'n':`
94	`++nummaterials;`	95	`++nummaterials;`
95	`mesh->materials.push_back(Material());`	96	`materials.push_back(Material());`
96	`material_file >> materials[nummaterials].name;`	97	`material_file >> materials[nummaterials].name;`
97	`break;`	98	`break;`
98	`case 'N':`	99	`case 'N':`
99	`switch(buf[1])`	100	`switch(buf[1])`
100	`{`	101	`{`
101	`case 's':`	102	`case 's':`
102	`material_file >> materials[nummaterials].shininess;`	103	`material_file >> materials[nummaterials].shininess;`
103	`materials[nummaterials].shininess *= 128.0f/1000.0f;`	104	`materials[nummaterials].shininess *= 128.0f/1000.0f;`
104	`break;`	105	`break;`
105	`case 'i':`	106	`case 'i':`
106	`material_file >> materials[nummaterials].ior;`	107	`material_file >> materials[nummaterials].ior;`
107	`break;`	108	`break;`
108	`}`	109	`}`
109	`break;`	110	`break;`
110	`case 'K':`	111	`case 'K':`
111	`switch(buf[1])`	112	`switch(buf[1])`
112	`{`	113	`{`
113	`case 'd':`	114	`case 'd':`
114	`material_file >> materials[nummaterials].diffuse[0]`	115	`material_file >> materials[nummaterials].diffuse[0]`
115	`>> materials[nummaterials].diffuse[1]`	116	`>> materials[nummaterials].diffuse[1]`
116	`>> materials[nummaterials].diffuse[2];`	117	`>> materials[nummaterials].diffuse[2];`
117	`break;`	118	`break;`
118	`case 's':`	119	`case 's':`
119	`material_file >> materials[nummaterials].specular[0]`	120	`material_file >> materials[nummaterials].specular[0]`
120	`>> materials[nummaterials].specular[1]`	121	`>> materials[nummaterials].specular[1]`
121	`>> materials[nummaterials].specular[2];`	122	`>> materials[nummaterials].specular[2];`
122	`break;`	123	`break;`
123	`case 'a':`	124	`case 'a':`
124	`material_file >> materials[nummaterials].ambient[0]`	125	`material_file >> materials[nummaterials].ambient[0]`
125	`>> materials[nummaterials].ambient[1]`	126	`>> materials[nummaterials].ambient[1]`
126	`>> materials[nummaterials].ambient[2];`	127	`>> materials[nummaterials].ambient[2];`
127	`break;`	128	`break;`
128	`}`	129	`}`
129	`break;`	130	`break;`
130	`case 'T':`	131	`case 'T':`
131	`material_file >> materials[nummaterials].transmission[0]`	132	`material_file >> materials[nummaterials].transmission[0]`
132	`>> materials[nummaterials].transmission[1]`	133	`>> materials[nummaterials].transmission[1]`
133	`>> materials[nummaterials].transmission[2];`	134	`>> materials[nummaterials].transmission[2];`
134	`break;`	135	`break;`
135	`case 'i':`	136	`case 'i':`
136	`material_file >> materials[nummaterials].illum;`	137	`material_file >> materials[nummaterials].illum;`
137	`break;`	138	`break;`
138	`case 'm': // Map ... all maps are treated equally.`	139	`case 'm': // Map ... all maps are treated equally.`
139	`material_file >> materials[nummaterials].tex_name;`	140	`material_file >> materials[nummaterials].tex_name;`
140	`materials[nummaterials].has_texture = true;`	141	`materials[nummaterials].has_texture = true;`
141	`materials[nummaterials].tex_path = pathname;`	142	`materials[nummaterials].tex_path = pathname;`
142	`break;`	143	`break;`
143	`case '#':`	144	`case '#':`
144	`default:`	145	`default:`
145	`material_file.ignore(1024, '\n');`	146	`material_file.ignore(1024, '\n');`
146	`break;`	147	`break;`
147	`}`	148	`}`
148	`}`	149	`}`
149	`}`	150	`}`
150		151
151	`void TriMeshObjLoader::load(const std::string& filename)`	152	`void TriMeshObjLoader::load(const std::string& filename)`
152	`{`	153	`{`
153	`pathname = get_path(filename);`	154	`pathname = get_path(filename);`
154	`ifstream obj_file(filename.data());`	155	`ifstream obj_file(filename.data());`
155	`if(!obj_file)`	156	`if(!obj_file)`
156	`{`	157	`{`
157	`cerr << "File " << filename << " does not exist" << endl;`	158	`cerr << "File " << filename << " does not exist" << endl;`
158	`exit(0);`	159	`exit(0);`
159	`}`	160	`}`
160		161
161	`mesh->materials.resize(1);`	162	`mesh->materials.resize(1);`
162	`string buf;`	163	`string buf;`
163	`int current_material=0;`	164	`int current_material=0;`
164	`while(obj_file >> buf)`	165	`while(obj_file >> buf)`
165	`{`	166	`{`
166	`switch(buf[0])`	167	`switch(buf[0])`
167	`{`	168	`{`
168	`case 'v': // v, vn, vt`	169	`case 'v': // v, vn, vt`
169	`{`	170	`{`
170	`if(buf == "v")`	171	`if(buf == "v")`
171	`{`	172	`{`
172	`Vec3f v_geo;`	173	`Vec3f v_geo;`
173	`obj_file >> v_geo;`	174	`obj_file >> v_geo;`
174	`mesh->geometry.add_vertex(v_geo);`	175	`mesh->geometry.add_vertex(v_geo);`
175	`}`	176	`}`
176	`else if(buf == "vn")`	177	`else if(buf == "vn")`
177	`{`	178	`{`
178	`Vec3f v_norm;`	179	`Vec3f v_norm;`
179	`obj_file >> v_norm;`	180	`obj_file >> v_norm;`
180	`mesh->normals.add_vertex(v_norm);`	181	`mesh->normals.add_vertex(v_norm);`
181	`}`	182	`}`
182	`else if(buf == "vt")`	183	`else if(buf == "vt")`
183	`{`	184	`{`
184	`Vec3f v_tex;`	185	`Vec3f v_tex;`
185	`obj_file >> v_tex[0] >> v_tex[1];`	186	`obj_file >> v_tex[0] >> v_tex[1];`
186	`v_tex[2]=1;`	187	`v_tex[2]=1;`
187	`mesh->texcoords.add_vertex(v_tex);`	188	`mesh->texcoords.add_vertex(v_tex);`
188	`}`	189	`}`
189	`}`	190	`}`
190	`break;`	191	`break;`
191	`case 'f':`	192	`case 'f':`
192	`{`	193	`{`
193	`char line[1024];`	194	`char line[1024];`
194		195
195	`vector<int> v_indices;`	196	`vector<int> v_indices;`
196	`vector<int> t_indices;`	197	`vector<int> t_indices;`
197	`vector<int> n_indices;`	198	`vector<int> n_indices;`
198		199
199	`obj_file.getline(line, 1022);`	200	`obj_file.getline(line, 1022);`
200	`char* pch = strtok(line, " \t");`	201	`char* pch = strtok(line, " \t");`
201	`while(pch != 0)`	202	`while(pch != 0)`
202	`{`	203	`{`
203	`int v,t,n;`	204	`int v,t,n;`
204	`if(sscanf(pch, "%d/%d/%d", &v, &t, &n)==3)`	205	`if(sscanf(pch, "%d/%d/%d", &v, &t, &n)==3)`
205	`{`	206	`{`
206	`v_indices.push_back(get_vert(v));`	207	`v_indices.push_back(get_vert(v));`
207	`t_indices.push_back(get_texcoord(t));`	208	`t_indices.push_back(get_texcoord(t));`
208	`n_indices.push_back(get_normal(n));`	209	`n_indices.push_back(get_normal(n));`
209	`}`	210	`}`
210	`else if(sscanf(pch, "%d//%d", &v, &n)==2)`	211	`else if(sscanf(pch, "%d//%d", &v, &n)==2)`
211	`{`	212	`{`
212	`v_indices.push_back(get_vert(v));`	213	`v_indices.push_back(get_vert(v));`
213	`n_indices.push_back(get_normal(n));`	214	`n_indices.push_back(get_normal(n));`
214	`}`	215	`}`
215	`else if(sscanf(pch, "%d/%d", &v, &t)==2)`	216	`else if(sscanf(pch, "%d/%d", &v, &t)==2)`
216	`{`	217	`{`
217	`v_indices.push_back(get_vert(v));`	218	`v_indices.push_back(get_vert(v));`
218	`t_indices.push_back(get_texcoord(t));`	219	`t_indices.push_back(get_texcoord(t));`
219	`}`	220	`}`
220	`else if(sscanf(pch, "%d", &v)==1)`	221	`else if(sscanf(pch, "%d", &v)==1)`
221	`v_indices.push_back(get_vert(v));`	222	`v_indices.push_back(get_vert(v));`
222	`pch = strtok(0, " \t");`	223	`pch = strtok(0, " \t");`
223	`}`	224	`}`
224	`if(v_indices.size()>=3)`	225	`if(v_indices.size()>=3)`
225	`for(size_t i=0;i<=(v_indices.size()-3);++i)`	226	`for(size_t i=0;i<=(v_indices.size()-3);++i)`
226	`{`	227	`{`
227	`int idx = mesh->geometry.add_face(Vec3i(v_indices[0], v_indices[i+1], v_indices[i+2]));`	228	`int idx = mesh->geometry.add_face(Vec3i(v_indices[0], v_indices[i+1], v_indices[i+2]));`
228	`if(t_indices.size())`	229	`if(t_indices.size())`
229	`mesh->texcoords.add_face(Vec3i(t_indices[0], t_indices[i+1], t_indices[i+2]), idx);`	230	`mesh->texcoords.add_face(Vec3i(t_indices[0], t_indices[i+1], t_indices[i+2]), idx);`
230	`if(n_indices.size())`	231	`if(n_indices.size())`
231	`mesh->normals.add_face(Vec3i(n_indices[0], n_indices[i+1], n_indices[i+2]), idx);`	232	`mesh->normals.add_face(Vec3i(n_indices[0], n_indices[i+1], n_indices[i+2]), idx);`
232	`mesh->mat_idx.push_back(current_material);`	233	`mesh->mat_idx.push_back(current_material);`
233	`}`	234	`}`
234	`}`	235	`}`
235	`break;`	236	`break;`
236	`case 'm':`	237	`case 'm':`
237	`obj_file >> buf;`	238	`obj_file >> buf;`
238	`read_material_library(buf, mesh->materials);`	239	`read_material_library(buf, mesh->materials);`
239	`break;`	240	`break;`
240	`case 'u':`	241	`case 'u':`
241	`obj_file >> buf;`	242	`obj_file >> buf;`
242	`current_material = mesh->find_material(buf);`	243	`current_material = mesh->find_material(buf);`
243	`break;`	244	`break;`
244	`case '#':`	245	`case '#':`
245	`default:`	246	`default:`
246	`obj_file.ignore(1024, '\n');`	247	`obj_file.ignore(1024, '\n');`
247	`break;`	248	`break;`
248	`}`	249	`}`
249	`}`	250	`}`
250	`}`	251	`}`
251		252
252	`void obj_load(const string& filename, TriMesh &mesh)`	253	`void obj_load(const string& filename, TriMesh &mesh)`
253	`{`	254	`{`
254	`TriMeshObjLoader loader(&mesh);`	255	`TriMeshObjLoader loader(&mesh);`
255	`loader.load(filename);`	256	`loader.load(filename);`
256	`}`	257	`}`
257		258
258	`/// Load materials from an MTL file`	259	`/// Load materials from an MTL file`
259	`void mtl_load(const std::string& filename, std::vector<Material>& materials)`	260	`void mtl_load(const std::string& filename, std::vector<Material>& materials)`
260	`{`	261	`{`
261	`TriMeshObjLoader loader(0);`	262	`TriMeshObjLoader loader(0);`
262	`loader.load_material_library(filename, materials);`	263	`loader.load_material_library(filename, materials);`
263	`}`	264	`}`
264	`}`	265	`}`
265		266

Subversion Repositories gelsvn

(root)/trunk/src/Geometry/obj_load.cpp – Rev 606 → 612