Hi,

I'm trying to load an .obj model to OpenGL and I need to parse the file. What I've done until now:
v 0.000000 3.897879 -1.378193
v -0.309017 3.856391 -1.352228

vt 0.314607 0.256292
vt 0.226357 0.365001

vn -0.156435 0.837235 -0.523990
vn -0.309017 0.806183 -0.504556

f 13/3/45 14/6/46 24/29/47
f 24/29/47 14/6/46 25/31/48

So for the v / vt / vn the code source is:

 std::vector<glm::vec3> vertex;
    std::vector<glm::vec2> texture;
    std::vector<glm::vec3> normals;
    
   
    std::string lineStr;

    
    while (inf)
    {
        getline(inf, lineStr);

        //std::cout << "LINESTR: " << lineStr << std::endl;

        if (lineStr[0] == 'v' && lineStr[1] == ' ')
        {
            std::stringstream os;
            std::string unsused;
            double posx, posy, posz;
            os << lineStr;
            os >> unsused >> posx >> posy >> posz;
            std::cout << " Pos X: " << posx << " Pos Y: " << posy << " Pos Z: " << posz << std::endl;

            vertex.push_back(glm::vec3(posx, posy, posz));
        }
       

// The same source code is for vt and vn
 }

It seems that it works. But I have some problems parsing the faces. I don't know exactly how to do it. Well I could use a lot of "if", but I'm not sure if this would be a good idea.
Any advices ?

Thank you!

I used a set of switch statements in my obj parser like this

//based on graphics API (GL/VK) defined GHandle
GHandle Asset::ObjRead(IDataReader& stream)
{
   ...
   while(!stream.Eof())
   {
       String::Skip(stream, " \t\r\n");
       switch(stream.Peek())
       {
           case '#': //skip comment  
           case 'v':
           {
               stream.Get();
               switch(stream.Peek())
               {
                   case 't': //process texcoord
                   case 'n': //process normal
                   default: //process vertex
               }
           }
           break;
           case 'f': //process face group
           case 'g': //process group
           case 'o': //process object
           case 'u':
           {
               ...
               if(bufferLength == 6 && memcmp(buffer, "usemtl", 6) == 0) //process material use
           }
           break;
           case 'm':
           {
               ...
               if(bufferLength == 6 && memcmp(buffer, "mtllib", 6) == 0) //process material include
           }
           break;
       }
   }
   ...
     
   return vboHandle;
}

My engine uses exessive streaming rather than pure text-array support so it is setup be stream optimized and do as low string reading as possible except it is needed (for those material tags and group/object names for example) and a strict string comparsion that skip early outs as soon as possible

I would personally read 'word' by 'word', letting spaces and newlines be the separators.

For the faces, I would simply read an integer, a char, an integer, a char and an integer again, so with something like this:

	int vert1,vert2,vert3; // face indices
	char dump; // for the slash
	ifs >> vert1 >> dump >> vert2 >> dump >> vert3;
	

I already did something. I didn't to use the char for the slash. It would have been more easy.:P. Instead I eliminated the slash from the line. 
Here is my code.

 

if (lineStr[0] == 'f')
		{
			std::cout << "LINE STR FACE: " << lineStr << std::endl;

			for (int i = 0; i < lineStr.length(); i++)
			{
				if (lineStr == '/')
				{
					lineStr = ' ';
				}
			}

			std::stringstream os;
			std::string unused;

			os << lineStr;

			unsigned int v1, t1, n1, v2, t2, n2, v3, t3, n3;

			os >> unused >> v1 >> t1 >> n1 >> v2 >> t2 >> n2 >> v3 >> t3 >> n3;
              
              //...
              }

That certainly works. However, it's not the most efficient way to solve this since you essentialy parse the string twice. You could use a combination of peek(), ignore() and operator>> to do this better. You also have to consider the different combinations of indices. There are 4 possible ways a face vertex can be given:

1. f v v v ...
2. f v/vt v/vt v/vt ...
3. f v//vn v//vn v//vn ...
4. f v/vt/vn v/vt/vn v/vt/vn ...

You can assume that a vertex position is always given and then check with peek() if the next character is a slash. This way you can distinguish between the different cases. If it's a slash just use ignore() to skip it. Also, if you want to support even more possibilities then you have to consider negative indices. For more in depth information about the format you can read the relevant parts on http://paulbourke.net/dataformats/obj/ and http://paulbourke.net/dataformats/mtl/