| #ifndef RTVIEW_OBJ_PARSER_HXX |
| #define RTVIEW_OBJ_PARSER_HXX |
| |
| #include "RTTL/common/RTInclude.hxx" |
| #include "RTTL/common/RTVec.hxx" |
| #include "RTTL/common/RTShader.hxx" |
| #include "ImagePPM.hxx" |
| #include <map> |
| #include <set> |
| #include <algorithm> |
| #include <vector> |
| #include <fstream> |
| #include <string> |
| |
| using namespace std; |
| |
| #define NOT_SUPPORTED(x) cout << x << " currently not supported" << endl |
| |
| |
| class ObjParser { |
| private: |
| RTBox3f sceneAABB; |
| std::vector<RTVec3f> vertex; |
| std::vector<RTVec3f> normal; |
| std::vector<RTVec2f> textureCoord; |
| |
| /* temporary vertex data arrays, required for vertex mapping */ |
| |
| std::vector<RTVec3f> tmpVtx; |
| std::vector<RTVec3f> tmpNor; |
| std::vector<RTVec2f> tmpTxt; |
| map<pair<int, pair<int,int> >,int> vertexMap; |
| |
| /* ---------------------------- */ |
| |
| |
| std::vector<RTVec3i> triangle; |
| std::vector<int> triangleShaderId; |
| std::vector<RTVec4i> quad; |
| std::vector<int> quadShaderId; |
| |
| |
| std::vector<RTMaterial> material; |
| map<string,int> material_map; |
| std::vector<ImagePPM*> texture; |
| |
| |
| void ParseMTL(const string base, const string fname) |
| { |
| DBG_PRINT(base); |
| DBG_PRINT(fname); |
| |
| string name; |
| const string filename = base+"/"+fname; |
| fstream file; |
| file.open(filename.c_str()); |
| |
| cout << "parsing material file " << filename << endl; |
| |
| if(!file.is_open()) |
| { |
| FATAL("Error: cannot open %s for reading!\n" << fname.c_str()); |
| } |
| |
| while(!file.eof()) |
| { |
| string s; |
| file >> s; |
| |
| if (s[0] == '#'){ |
| getline(file, s, '\n'); // skip an entire line ... |
| continue; |
| } |
| else if (s == "newmtl") |
| { |
| file >> name; |
| material_map[name] = material.size(); |
| //cout << "New material with shader ID " << material.size() << endl; |
| material.push_back(RTMaterial()); |
| } |
| else if (s == "Ns") |
| { |
| RTMaterial &m = material[material_map[name]]; |
| file >> m.m_shininess; |
| } |
| else if (s == "Tr") |
| { |
| RTMaterial &m = material[material_map[name]]; |
| file >> m.m_transparency; |
| } |
| else if (s == "Ka") |
| { |
| RTMaterial &m = material[material_map[name]]; |
| file >> m.m_ambient.x; |
| file >> m.m_ambient.y; |
| file >> m.m_ambient.z; |
| } |
| else if (s == "Kd") |
| { |
| RTMaterial &m = material[material_map[name]]; |
| file >> m.m_diffuse.x; |
| file >> m.m_diffuse.y; |
| file >> m.m_diffuse.z; |
| } |
| else if (s == "Ks") |
| { |
| RTMaterial &m = material[material_map[name]]; |
| file >> m.m_specular.x; |
| file >> m.m_specular.y; |
| file >> m.m_specular.z; |
| } |
| else if (s == "map_Ka") |
| { |
| string textureName; |
| file >> textureName; |
| texture.push_back(new ImagePPM((base+"/"+textureName).c_str())); |
| } |
| else if (s == "map_Kd") |
| { |
| string textureName; |
| file >> textureName; |
| texture.push_back(new ImagePPM((base+"/"+textureName).c_str())); |
| RTMaterial &m = material[material_map[name]]; |
| m.m_textureId = 0; |
| } |
| else if (s == "map_Ks") |
| { |
| string textureName; |
| file >> textureName; |
| texture.push_back(new ImagePPM((base+"/"+textureName).c_str())); |
| } |
| else { |
| getline(file, s, '\n'); |
| } |
| } |
| cout << "finished parsing material file." << endl; |
| } |
| |
| _INLINE int getVertexID(int vtxID,int norID, int txtID) |
| { |
| pair<int, pair < int, int > > v(vtxID, pair<int, int>(txtID, norID)); |
| if (vertexMap.find(v) == vertexMap.end()) |
| { |
| vertexMap[v] = vertex.size(); |
| vertex.push_back(tmpVtx[vtxID]); |
| if (norID >= 0) normal.push_back(tmpNor[norID]); else normal.push_back(RTVec3f(0.0f,0.0f,0.0f)); |
| if (txtID >= 0) textureCoord.push_back(tmpTxt[txtID]); else textureCoord.push_back(RTVec2f(0.0f,0.0f)); |
| } |
| return vertexMap[v]; |
| |
| } |
| |
| public: |
| |
| _INLINE int quads() { return quad.size(); } |
| _INLINE int vertices() { return vertex.size(); } |
| _INLINE int triangles() { return triangle.size(); } |
| _INLINE int normals() { return normal.size(); } |
| _INLINE int textureCoordinates() { return textureCoord.size(); } |
| _INLINE int materials() { return material.size(); } |
| _INLINE int textures() { return texture.size(); } |
| _INLINE int triangleShaderIDs() { return triangleShaderId.size(); } |
| _INLINE int quadShaderIDs() { return quadShaderId.size(); } |
| |
| _INLINE RTBox3f &getSceneAABB() { return sceneAABB; } |
| _INLINE RTVec3f *getVertexPtr() { return vertex.size() ? &*vertex.begin() : NULL; } |
| _INLINE RTVec3i *getTrianglePtr() { return triangle.size() ? &*triangle.begin() : NULL; } |
| _INLINE RTVec4i *getQuadPtr() { return quad.size() ? &*quad.begin() : NULL; } |
| _INLINE RTVec3f *getNormalPtr() { return normal.size() ? &*normal.begin() : NULL; } |
| _INLINE RTVec2f *getTextureCoordinatePtr() { return textureCoord.size() ? &*textureCoord.begin() : NULL; } |
| _INLINE RTMaterial *getMaterialPtr() { return material.size() ? &*material.begin() : NULL; } |
| _INLINE int *getTriangleShaderPtr() { return triangleShaderId.size() ? &*triangleShaderId.begin() : NULL; } |
| _INLINE int *getQuadShaderPtr() { return quadShaderId.size() ? &*quadShaderId.begin() : NULL ; } |
| |
| // might replace this with a more general texture interface (not restricted to PPM) |
| _INLINE ImagePPM *getTexture(const int i) { return texture[i]; } |
| |
| ObjParser() |
| { |
| sceneAABB.reset(); |
| } |
| |
| _INLINE void Free() |
| { |
| tmpVtx.clear(); |
| tmpNor.clear(); |
| tmpTxt.clear(); |
| vertexMap.clear(); |
| vertex.clear(); |
| triangle.clear(); |
| normal.clear(); |
| textureCoord.clear(); |
| triangleShaderId.clear(); |
| quadShaderId.clear(); |
| for (unsigned int i=0;i<texture.size();i++) |
| delete texture[i]; |
| texture.clear(); |
| material_map.clear(); |
| } |
| |
| void Parse(string fileName) |
| { |
| |
| fstream mFile; |
| const char* fn = fileName.c_str(); |
| mFile.open(fn, ios_base::in); |
| |
| /* extrace base directory */ |
| int p = -1; |
| for (unsigned int i=0; i<fileName.size(); i++) |
| #if !defined(_WIN32) |
| if (fileName[i] == '/') |
| #else |
| if (fileName[i] == '\\') |
| #endif |
| p = i; |
| string base; |
| if (p != -1) |
| base = fileName.substr(0,p); |
| else |
| { |
| //FIXME: Implement proper base extraction |
| base = "."; |
| } |
| |
| if(!mFile.is_open()) |
| { |
| cout << "Error: cannot open " << fileName << " for reading!" << endl; |
| perror("Error code"); |
| exit(-1); |
| } |
| |
| int shaderId = 0; |
| |
| int count = 0; |
| while(!mFile.eof()) |
| { |
| count++; |
| string s; |
| mFile >> s; |
| |
| if (s[0] == '#'){ |
| continue; |
| } |
| else if (s == "mtllib") |
| { |
| string mtllib; |
| mFile >> mtllib; |
| ParseMTL(base,mtllib); |
| } |
| else if (s == "g") |
| { |
| string temp; |
| mFile >> temp; |
| } |
| else if (s == "usemtl") |
| { |
| string material; |
| mFile >> material; |
| shaderId = material_map[material]; |
| //cout << "using material " << material << " -> active shaderId " << shaderId << endl; |
| } |
| else if (s == "v") |
| { |
| RTVec3f v; |
| mFile >> v[0]; |
| mFile >> v[1]; |
| mFile >> v[2]; |
| sceneAABB.extend(v); |
| tmpVtx.push_back(v); |
| } |
| else if (s == "vt") |
| { |
| RTVec2f c; |
| mFile >> c[0]; |
| mFile >> c[1]; |
| tmpTxt.push_back(c); |
| } |
| else if (s == "vn") |
| { |
| RTVec3f n; |
| mFile >> n[0]; |
| mFile >> n[1]; |
| mFile >> n[2]; |
| tmpNor.push_back(n); |
| } |
| else if (s == "f" || s == "fo") |
| { |
| string dash; |
| int ta = -1,tta=0,tna=0; |
| int tb = -1,ttb=0,tnb=0; |
| int tc = -1,ttc=0,tnc=0; |
| int td = -1,ttd=0,tnd=0; |
| |
| mFile >> dash; |
| |
| if (sscanf(dash.c_str(),"%d", &ta) != 1&& |
| sscanf(dash.c_str(),"%d/%d", &ta ,&tta) != 2&& |
| sscanf(dash.c_str(),"%d//%d", &ta ,&tna) != 2&& |
| sscanf(dash.c_str(),"%d/%d/%d", &ta ,&tta, &tna) != 3 |
| ) |
| { |
| printf("Parsing error v0: %i\n",count); |
| exit(-1); |
| } |
| |
| mFile >> dash; |
| |
| if (sscanf(dash.c_str(),"%d", &tb) != 1&& |
| sscanf(dash.c_str(),"%d/%d", &tb ,&ttb) != 2 && |
| sscanf(dash.c_str(),"%d//%d", &tb ,&tnb) != 2 && |
| sscanf(dash.c_str(),"%d/%d/%d", &tb, &ttb, &tnb) != 3 |
| ) |
| { |
| printf("Parsing error v1: %i\n",count); |
| exit(-1); |
| }; |
| |
| mFile >> dash; |
| |
| if (sscanf(dash.c_str(),"%d", &tc) != 1 && |
| sscanf(dash.c_str(),"%d/%d", &tc ,&ttc) != 2 && |
| sscanf(dash.c_str(),"%d//%d", &tc ,&tnc) != 2 && |
| sscanf(dash.c_str(),"%d/%d/%d", &tc, &ttc, &tnc) != 3 |
| ) |
| { |
| printf("Parsing error v2: %i\n",count); |
| exit(-1); |
| }; |
| |
| |
| bool isQuad = true; |
| |
| char c; |
| while (mFile.peek() == ' ') mFile.get(c); |
| |
| if (mFile.peek() == 0x0D || mFile.peek() == 0x0A) { |
| while (mFile.peek() == 0x0D || mFile.peek() == 0x0A) mFile.get(c); |
| isQuad = false; |
| } |
| else |
| { |
| mFile >> dash; |
| if (sscanf(dash.c_str(),"%d", &td) != 1 && |
| sscanf(dash.c_str(),"%d/%d", &td ,&ttd) != 2 && |
| sscanf(dash.c_str(),"%d//%d", &td ,&tnd) != 2 && |
| sscanf(dash.c_str(),"%d/%d/%d", &td, &ttd, &tnd) != 3 |
| ) |
| { |
| isQuad = false; |
| } |
| } |
| |
| bool has_na = tna != 0; |
| bool has_nb = tnb != 0; |
| bool has_nc = tnc != 0; |
| bool has_nd = tnd != 0; |
| |
| bool has_ta = tta != 0; |
| bool has_tb = ttb != 0; |
| bool has_tc = ttc != 0; |
| bool has_td = ttd != 0; |
| |
| if (ta > 0) ta--; |
| if (tb > 0) tb--; |
| if (tc > 0) tc--; |
| if (td > 0) td--; |
| |
| if (tta > 0) tta--; |
| if (ttb > 0) ttb--; |
| if (ttc > 0) ttc--; |
| if (ttd > 0) ttd--; |
| |
| if (tna > 0) tna--; |
| if (tnb > 0) tnb--; |
| if (tnc > 0) tnc--; |
| if (tnd > 0) tnd--; |
| |
| if (ta < 0) ta += tmpVtx.size(); |
| if (tb < 0) tb += tmpVtx.size(); |
| if (tc < 0) tc += tmpVtx.size(); |
| if (td < 0) td += tmpVtx.size(); |
| |
| if (tta < 0) tta += tmpTxt.size(); |
| if (ttb < 0) ttb += tmpTxt.size(); |
| if (ttc < 0) ttc += tmpTxt.size(); |
| if (ttd < 0) ttd += tmpTxt.size(); |
| |
| if (tna < 0) tna += tmpNor.size(); |
| if (tnb < 0) tnb += tmpNor.size(); |
| if (tnc < 0) tnc += tmpNor.size(); |
| if (tnd < 0) tnc += tmpNor.size(); |
| |
| /* |
| DBG_PRINT(ta); |
| DBG_PRINT(tb); |
| DBG_PRINT(tc); |
| DBG_PRINT(td); |
| DBG_PRINT(quad); |
| */ |
| |
| if (ta < 0 || ta >= (int)tmpVtx.size() || |
| tb < 0 || tb >= (int)tmpVtx.size() || |
| tc < 0 || tc >= (int)tmpVtx.size() || |
| (isQuad && (td < 0 || td >= (int)tmpVtx.size()))) |
| /* |
| (tta < 0 || tta >= (int)textureCoord.size()) && has_ta || |
| (ttb < 0 || ttb >= (int)textureCoord.size()) && has_tb || |
| (ttc < 0 || ttc >= (int)textureCoord.size()) && has_tc || |
| (ttd < 0 || ttd >= (int)textureCoord.size()) && has_td || |
| (tna < 0 || tna >= (int)normal.size()) && has_na || |
| (tnb < 0 || tnb >= (int)normal.size()) && has_nb || |
| (tnc < 0 || tnc >= (int)normal.size()) && has_nc || |
| (tnd < 0 || tnd >= (int)normal.size()) && has_nd |
| */ |
| { |
| DBG_PRINT(td); |
| DBG_PRINT(tmpVtx.size()); |
| printf("Invalid triangle %i: (%i,%i,%i) (%i,%i,%i) (%i,%i,%i) (%i,%i,%i) (%i,%i,%i) %i %i %i\n", |
| count,ta,tb,tc,tta,ttb,ttc,tna,tnb,tnc,has_na,has_nb,has_nc,has_ta,has_tb,has_tc, |
| int(tmpVtx.size()), |
| int(tmpTxt.size()), |
| int(tmpNor.size())); |
| exit(-1); |
| } |
| |
| if (!has_ta) tta = -1; |
| if (!has_tb) ttb = -1; |
| if (!has_tc) ttc = -1; |
| if (!has_td) ttd = -1; |
| |
| if (!has_na) tna = -1; |
| if (!has_nb) tnb = -1; |
| if (!has_nc) tnc = -1; |
| if (!has_nd) tnd = -1; |
| |
| if (isQuad) |
| { |
| const int newA = getVertexID(ta,tna,tta); |
| const int newB = getVertexID(tb,tnb,ttb); |
| const int newC = getVertexID(tc,tnc,ttc); |
| const int newD = getVertexID(td,tnd,ttd); |
| quad.push_back(RTVec4i(newA,newB,newC,newD)); |
| quadShaderId.push_back(shaderId); |
| } |
| else |
| { |
| const int newA = getVertexID(ta,tna,tta); |
| const int newB = getVertexID(tb,tnb,ttb); |
| const int newC = getVertexID(tc,tnc,ttc); |
| triangle.push_back(RTVec3i(newA,newB,newC)); |
| triangleShaderId.push_back(shaderId); |
| } |
| } |
| else |
| continue; |
| } |
| |
| assert( textureCoordinates() == vertices() ); |
| assert( normals() == vertices() ); |
| } |
| |
| |
| }; |
| |
| #endif |
