Loading 3D Models

Introduction

Welcome back to our Advanced Geometry and Model Loading course! In our previous lesson, we explored face culling and learned how proper vertex organization can dramatically improve rendering performance. Now, we're ready to tackle the next major challenge: loading complex, industry-standard 3D models into our OpenGL applications. While manually defining simple geometric shapes like cubes and spheres teaches us fundamental concepts, real-world graphics applications require the ability to load detailed models created by artists using professional 3D modeling software. These models, often stored in formats like OBJ, contain thousands or even millions of vertices, complex surface details, and sophisticated material properties that would be impractical to define manually in code. In this lesson, we'll integrate the powerful tiny_obj_loader library to handle the industry-standard OBJ file format, implement robust data structures for managing complex geometry, and develop a complete model loading system that seamlessly integrates with our existing OpenGL pipeline.

Understanding the OBJ File Format

The OBJ file format is one of the most widely supported 3D model formats in computer graphics. Created by Wavefront Technologies, OBJ files use simple, human-readable text to describe 3D geometry. This format stores vertex positions, texture coordinates, surface normals, and face definitions using straightforward ASCII commands. Let's examine a simple square defined in OBJ format to understand the structure: text # Simple square OBJ file # Vertex positions (v x y z) v -1.0 -1.0 0.0 v 1.0 -1.0 0.0 v 1.0 1.0 0.0 v -1.0 1.0 0.0 # Texture coordinates (vt u v) vt 0.0 0.0 vt 1.0 0.0 vt 1.0 1.0 vt 0.0 1.0 # Surface normals (vn x y z) vn 0.0 0.0 1.0 vn 0.0 0.0 1.0 vn 0.0 0.0 1.0 vn 0.0 0.0 1.0 # Faces (f v/vt/vn v/vt/vn v/vt/vn) f 1/1/1 2/2/2 3/3/3 f 1/1/1 3/3/3 4/4/4 # Simple square OBJ file # Vertex positions (v x y z) v -1.0 -1.0 0.0 v 1.0 -1.0 0.0 v 1.0 1.0 0.0 v -1.0 1.0 0.0 # Texture coordinates (vt u v) vt 0.0 0.0 vt 1.0 0.0 vt 1.0 1.0 vt 0.0 1.0 # Surface normals (vn x y z) vn 0.0 0.0 1.0 vn 0.0 0.0 1.0 vn 0.0 0.0 1.0 vn 0.0 0.0 1.0 # Faces (f v/vt/vn v/vt/vn v/vt/vn) f 1/1/1 2/2/2 3/3/3 f 1/1/1 3/3/3 4/4/4 Each line begins with a command specifier: v for vertex positions, vt for texture coordinates, vn for normals, and f for faces. The faces use 1-based indexing to reference vertices, texture coordinates, and normals in the format vertex/texture/normal . This simple yet flexible structure allows OBJ files to represent complex geometry while remaining human-readable and easy to parse.

Introducing the tiny_obj_loader Library

The tiny_obj_loader library provides a robust, header-only solution for parsing OBJ files in C++ applications. Unlike complex model loading frameworks, this library focuses specifically on OBJ format support, offering excellent performance and minimal dependencies while handling the intricate details of file parsing, memory management, and data organization. C++ #define TINYOBJLOADER_IMPLEMENTATION #include <tiny_obj_loader.h> tinyobj::attrib_t attrib; std::vector<tinyobj::shape_t> shapes; std::vector<tinyobj::material_t> materials; std::string warn, err; bool success = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str()); #define TINYOBJLOADER_IMPLEMENTATION #include <tiny_obj_loader.h> tinyobj::attrib_t attrib; std::vector<tinyobj::shape_t> shapes; std::vector<tinyobj::material_t> materials; std::string warn, err; bool success = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str()); The library organizes loaded data into three primary structures: attrib_t contains all vertex attribute arrays (positions, normals, texture coordinates), shapes represent individual geometric objects within the file, and materials store surface material properties. The LoadObj function handles all parsing complexity, returning a boolean success status and providing detailed warning and error messages for debugging purposes.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

text

# Simple square OBJ file
# Vertex positions (v x y z)
v -1.0 -1.0 0.0
v  1.0 -1.0 0.0
v  1.0  1.0 0.0
v -1.0  1.0 0.0

# Texture coordinates (vt u v)
vt 0.0 0.0
vt 1.0 0.0
vt 1.0 1.0
vt 0.0 1.0

# Surface normals (vn x y z)
vn 0.0 0.0 1.0
vn 0.0 0.0 1.0
vn 0.0 0.0 1.0
vn 0.0 0.0 1.0

# Faces (f v/vt/vn v/vt/vn v/vt/vn)
f 1/1/1 2/2/2 3/3/3
f 1/1/1 3/3/3 4/4/4

C++

#define TINYOBJLOADER_IMPLEMENTATION
#include <tiny_obj_loader.h>

tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string warn, err;

bool success = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str());

C++

struct Vertex {
    glm::vec3 Position;   // 3D world position
    glm::vec2 TexCoords;  // 2D texture coordinates
    glm::vec3 Normal;     // Surface normal vector
    glm::vec3 Tangent;    // Tangent vector for normal mapping
};

struct Vertex {
    glm::vec3 Position;   // 3D world position
    glm::vec2 TexCoords;  // 2D texture coordinates
    glm::vec3 Normal;     // Surface normal vector
    glm::vec3 Tangent;    // Tangent vector for normal mapping
};

C++

class Mesh {
public:
    std::vector<Vertex> vertices;      // All vertex data
    std::vector<unsigned int> indices; // Triangle connectivity
    GLuint VAO, VBO, EBO;              // OpenGL buffer objects
    
    Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices);
    ~Mesh();
    void Draw(GLuint shaderID);
private:
    void setupMesh();
};

class Mesh {
public:
    std::vector<Vertex> vertices;      // All vertex data
    std::vector<unsigned int> indices; // Triangle connectivity
    GLuint VAO, VBO, EBO;              // OpenGL buffer objects
    
    Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices);
    ~Mesh();
    void Draw(GLuint shaderID);
private:
    void setupMesh();
};

C++

void Mesh::setupMesh() {
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);
    
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
    
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
    
    // Vertex attribute configuration goes here
}

void Mesh::setupMesh() {
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);
    
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
    
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
    
    // Vertex attribute configuration goes here
}

C++

// Position attribute (location = 0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);

// UV attribute (location = 1)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
glEnableVertexAttribArray(1);

// Normal attribute (location = 2)
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
glEnableVertexAttribArray(2);

// Tangent attribute (location = 3)
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
glEnableVertexAttribArray(3);

// Position attribute (location = 0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);

// UV attribute (location = 1)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
glEnableVertexAttribArray(1);

// Normal attribute (location = 2)
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
glEnableVertexAttribArray(2);

// Tangent attribute (location = 3)
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
glEnableVertexAttribArray(3);

C++

void Mesh::Draw(GLuint shaderID) {
    glUseProgram(shaderID);
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
}

void Mesh::Draw(GLuint shaderID) {
    glUseProgram(shaderID);
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
}

C++

class Model {
public:
    std::vector<Mesh> meshes;  // All meshes in the model
    std::string directory;     // Base path for assets
    
    Model(const std::string& path);
    void Draw(GLuint shaderID);
private:
    void loadModel(const std::string& path);
    void calculateTangents(std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices);
};

class Model {
public:
    std::vector<Mesh> meshes;  // All meshes in the model
    std::string directory;     // Base path for assets
    
    Model(const std::string& path);
    void Draw(GLuint shaderID);
private:
    void loadModel(const std::string& path);
    void calculateTangents(std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices);
};

C++

void Model::loadModel(const std::string& path) {
    tinyobj::attrib_t attrib;
    std::vector<tinyobj::shape_t> shapes;
    std::vector<tinyobj::material_t> materials;
    std::string warn, err;

    if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str())) {
        std::cerr << "ERROR::TINYOBJ::" << warn << err << std::endl;
        return;
    }

    directory = path.substr(0, path.find_last_of('/'));

void Model::loadModel(const std::string& path) {
    tinyobj::attrib_t attrib;
    std::vector<tinyobj::shape_t> shapes;
    std::vector<tinyobj::material_t> materials;
    std::string warn, err;

    if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str())) {
        std::cerr << "ERROR::TINYOBJ::" << warn << err << std::endl;
        return;
    }

    directory = path.substr(0, path.find_last_of('/'));

C++

for (const auto& shape : shapes) {
    std::vector<Vertex> vertices;
    std::vector<unsigned int> indices;

    for (const auto& index : shape.mesh.indices) {
        Vertex vertex{};

        // Extract position data
        vertex.Position = {
            attrib.vertices[3 * index.vertex_index + 0],
            attrib.vertices[3 * index.vertex_index + 1],
            attrib.vertices[3 * index.vertex_index + 2]
        };

        vertices.push_back(vertex);
        indices.push_back(vertices.size() - 1);
    }
}

for (const auto& shape : shapes) {
    std::vector<Vertex> vertices;
    std::vector<unsigned int> indices;

    for (const auto& index : shape.mesh.indices) {
        Vertex vertex{};

        // Extract position data
        vertex.Position = {
            attrib.vertices[3 * index.vertex_index + 0],
            attrib.vertices[3 * index.vertex_index + 1],
            attrib.vertices[3 * index.vertex_index + 2]
        };

        vertices.push_back(vertex);
        indices.push_back(vertices.size() - 1);
    }
}

C++

// Texture coordinates with bounds checking
if (index.texcoord_index >= 0) {
    vertex.TexCoords = {
        attrib.texcoords[2 * index.texcoord_index + 0],
        1.0f - attrib.texcoords[2 * index.texcoord_index + 1] // Flip Y for OpenGL
    };
} else {
    vertex.TexCoords = {0.0f, 0.0f};
}

// Surface normals with bounds checking
if (index.normal_index >= 0) {
    vertex.Normal = {
        attrib.normals[3 * index.normal_index + 0],
        attrib.normals[3 * index.normal_index + 1],
        attrib.normals[3 * index.normal_index + 2]
    };
} else {
    vertex.Normal = {0.0f, 1.0f, 0.0f}; // Default upward normal
}

// Texture coordinates with bounds checking
if (index.texcoord_index >= 0) {
    vertex.TexCoords = {
        attrib.texcoords[2 * index.texcoord_index + 0],
        1.0f - attrib.texcoords[2 * index.texcoord_index + 1] // Flip Y for OpenGL
    };
} else {
    vertex.TexCoords = {0.0f, 0.0f};
}

// Surface normals with bounds checking
if (index.normal_index >= 0) {
    vertex.Normal = {
        attrib.normals[3 * index.normal_index + 0],
        attrib.normals[3 * index.normal_index + 1],
        attrib.normals[3 * index.normal_index + 2]
    };
} else {
    vertex.Normal = {0.0f, 1.0f, 0.0f}; // Default upward normal
}

C++

    // Normalize all accumulated tangents
    for (auto& vertex : vertices) {
        vertex.Tangent = glm::normalize(vertex.Tangent);
    }

    // Calculate the tangent vectors
    calculateTangents(vertices, indices);
    // Create and store the mesh
    meshes.emplace_back(vertices, indices);
    }
}

    // Normalize all accumulated tangents
    for (auto& vertex : vertices) {
        vertex.Tangent = glm::normalize(vertex.Tangent);
    }

    // Calculate the tangent vectors
    calculateTangents(vertices, indices);
    // Create and store the mesh
    meshes.emplace_back(vertices, indices);
    }
}

C++

// Load 3D model
Model model("models/teapot.obj");

// Main rendering loop
glm::mat4 modelMatrix = glm::rotate(glm::mat4(1.0f), currentTime * 0.3f, glm::vec3(0.0f, 1.0f, 0.0f));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMatrix));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));

// Draw the model
model.Draw(shaderProgram);

// Load 3D model
Model model("models/teapot.obj");

// Main rendering loop
glm::mat4 modelMatrix = glm::rotate(glm::mat4(1.0f), currentTime * 0.3f, glm::vec3(0.0f, 1.0f, 0.0f));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMatrix));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));

// Draw the model
model.Draw(shaderProgram);

C++

struct Vertex {
    glm::vec3 Position;   // 3D world position
    glm::vec2 TexCoords;  // 2D texture coordinates
    glm::vec3 Normal;     // Surface normal vector
    glm::vec3 Tangent;    // Tangent vector for normal mapping
};

C++

class Mesh {
public:
    std::vector<Vertex> vertices;      // All vertex data
    std::vector<unsigned int> indices; // Triangle connectivity
    GLuint VAO, VBO, EBO;              // OpenGL buffer objects
    
    Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices);
    ~Mesh();
    void Draw(GLuint shaderID);
private:
    void setupMesh();
};

C++

void Mesh::setupMesh() {
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);
    
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
    
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
    
    // Vertex attribute configuration goes here
}

C++

// Position attribute (location = 0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);

// UV attribute (location = 1)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
glEnableVertexAttribArray(1);

// Normal attribute (location = 2)
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
glEnableVertexAttribArray(2);

// Tangent attribute (location = 3)
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
glEnableVertexAttribArray(3);

C++

void Mesh::Draw(GLuint shaderID) {
    glUseProgram(shaderID);
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
}

C++

class Model {
public:
    std::vector<Mesh> meshes;  // All meshes in the model
    std::string directory;     // Base path for assets
    
    Model(const std::string& path);
    void Draw(GLuint shaderID);
private:
    void loadModel(const std::string& path);
    void calculateTangents(std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices);
};

C++

void Model::loadModel(const std::string& path) {
    tinyobj::attrib_t attrib;
    std::vector<tinyobj::shape_t> shapes;
    std::vector<tinyobj::material_t> materials;
    std::string warn, err;

    if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str())) {
        std::cerr << "ERROR::TINYOBJ::" << warn << err << std::endl;
        return;
    }

    directory = path.substr(0, path.find_last_of('/'));

C++

for (const auto& shape : shapes) {
    std::vector<Vertex> vertices;
    std::vector<unsigned int> indices;

    for (const auto& index : shape.mesh.indices) {
        Vertex vertex{};

        // Extract position data
        vertex.Position = {
            attrib.vertices[3 * index.vertex_index + 0],
            attrib.vertices[3 * index.vertex_index + 1],
            attrib.vertices[3 * index.vertex_index + 2]
        };

        vertices.push_back(vertex);
        indices.push_back(vertices.size() - 1);
    }
}

C++

// Texture coordinates with bounds checking
if (index.texcoord_index >= 0) {
    vertex.TexCoords = {
        attrib.texcoords[2 * index.texcoord_index + 0],
        1.0f - attrib.texcoords[2 * index.texcoord_index + 1] // Flip Y for OpenGL
    };
} else {
    vertex.TexCoords = {0.0f, 0.0f};
}

// Surface normals with bounds checking
if (index.normal_index >= 0) {
    vertex.Normal = {
        attrib.normals[3 * index.normal_index + 0],
        attrib.normals[3 * index.normal_index + 1],
        attrib.normals[3 * index.normal_index + 2]
    };
} else {
    vertex.Normal = {0.0f, 1.0f, 0.0f}; // Default upward normal
}

C++

    // Normalize all accumulated tangents
    for (auto& vertex : vertices) {
        vertex.Tangent = glm::normalize(vertex.Tangent);
    }

    // Calculate the tangent vectors
    calculateTangents(vertices, indices);
    // Create and store the mesh
    meshes.emplace_back(vertices, indices);
    }
}

C++

// Load 3D model
Model model("models/teapot.obj");

// Main rendering loop
glm::mat4 modelMatrix = glm::rotate(glm::mat4(1.0f), currentTime * 0.3f, glm::vec3(0.0f, 1.0f, 0.0f));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMatrix));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));

// Draw the model
model.Draw(shaderProgram);

Introduction

Understanding the OBJ File Format

Introducing the tiny_obj_loader Library

Join the 1M+ learners on CodeSignal

Designing the Vertex Data Structure

Building the Mesh Class Foundation

Implementing Mesh Setup and Configuration

Completing Vertex Attribute Configuration

Implementing Mesh Rendering

Architecting the Model Class

Processing OBJ File Data

Converting Shape Data to Meshes

Extracting Texture Coordinates and Normals

Integrating Model Rendering

Final Result

Conclusion and Next Steps