How do I draw an OBJ file in OpenGL using tinyobjloader?

Question

I am trying to draw this free airwing model from Starfox 64 in OpenGL. I converted the .fbx file to .obj in Blender and am using tinyobjloader to load it (all requirements for my university subject).

I pretty much slapped the example code (with the modern API) into my program, replaced the file name, and grabbed the attrib.vertices and attrib.normals vectors to draw the airwing.

I can view the vertices with GL_POINTS:

glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
glDrawArrays(GL_POINTS, 0, vertices.size() / 3);
glDisableClientState(GL_VERTEX_ARRAY);

Which looks correct (I ... think?):

But I'm not sure how to render a solid model. Simply replacing GL_POINTS with GL_TRIANGLES (shown) or GL_QUADS doesn't work:

I am using OpenGL 1.1 w/ GLUT (again, university). I think I just don't know what I'm doing, really. Help?

Answer 1

E: When I wrote this answer originally I had only worked with vertices and normals. I've figured out how to get materials and textures working, but don't have time to write that out at the moment. I will add that in when I have some time, but it's largely the same logic if you wanna poke around the tinyobj header yourselves in the meantime. :-)

I've learned a lot about TinyOBJLoader in the last day so I hope this helps someone in the future. Credit goes to this GitHub repository which uses TinyOBJLoader very clearly and cleanly in fileloader.cpp.

To summarise what I learned studying that code:

Shapes are of type shape_t. For a single model OBJ, the size of shapes is 1. I'm assuming OBJ files can contain multiple objects but I haven't used the file format much to know.

shape_t's have a member mesh of type mesh_t. This member stores the information parsed from the face rows of the OBJ. You can figure out the number of faces your object has by checking the size of the material_ids member.

The vertex, texture coordinate and normal indices of each face are stored in the indices member of the mesh. This is of type std::vector<index_t>. This is a flattened vector of indices. So for a model with triangulated faces f1, f2 ... fi, it stores v1, t1, n1, v2, t2, n2 ... vi, ti, ni. Remember that these indices correspond to the whole vertex, texture coordinate or normal. Personally I triangulated my model by importing into Blender and exporting it with triangulation turned on. TinyOBJ has its own triangulation algorithm you can turn on by setting the reader_config.triangulate flag.

I've only worked with the vertices and normals so far. Here's how I access and store them to be used in OpenGL:

1. Convert the flat vertices and normal arrays into groups of 3, i.e. 3D vectors

for (size_t vec_start = 0; vec_start < attrib.vertices.size(); vec_start += 3) {
    vertices.emplace_back(
        attrib.vertices[vec_start],
        attrib.vertices[vec_start + 1],
        attrib.vertices[vec_start + 2]);
}

for (size_t norm_start = 0; norm_start < attrib.normals.size(); norm_start += 3) {
    normals.emplace_back(
        attrib.normals[norm_start],
        attrib.normals[norm_start + 1],
        attrib.normals[norm_start + 2]);
}

This way the index of the vertices and normals containers will correspond with the indices given by the face entries.

2. Loop over every face, and store the vertex and normal indices in a separate object

for (auto shape = shapes.begin(); shape < shapes.end(); ++shape) {
    const std::vector<tinyobj::index_t>& indices = shape->mesh.indices;
    const std::vector<int>& material_ids = shape->mesh.material_ids;

    for (size_t index = 0; index < material_ids.size(); ++index) {
        // offset by 3 because values are grouped as vertex/normal/texture
        triangles.push_back(Triangle(
            { indices[3 * index].vertex_index, indices[3 * index + 1].vertex_index, indices[3 * index + 2].vertex_index },
            { indices[3 * index].normal_index, indices[3 * index + 1].normal_index, indices[3 * index + 2].normal_index })
        );
    }
}

Drawing is then quite easy:

glBegin(GL_TRIANGLES);
for (auto triangle = triangles.begin(); triangle != triangles.end(); ++triangle) {
    glNormal3f(normals[triangle->normals[0]].X, normals[triangle->normals[0]].Y, normals[triangle->normals[0]].Z);
    glVertex3f(vertices[triangle->vertices[0]].X, vertices[triangle->vertices[0]].Y, vertices[triangle->vertices[0]].Z);

    glNormal3f(normals[triangle->normals[1]].X, normals[triangle->normals[1]].Y, normals[triangle->normals[1]].Z);
    glVertex3f(vertices[triangle->vertices[1]].X, vertices[triangle->vertices[1]].Y, vertices[triangle->vertices[1]].Z);

    glNormal3f(normals[triangle->normals[2]].X, normals[triangle->normals[2]].Y, normals[triangle->normals[2]].Z);
    glVertex3f(vertices[triangle->vertices[2]].X, vertices[triangle->vertices[2]].Y, vertices[triangle->vertices[2]].Z);
}
glEnd();