The Project | About Us | Contribute | Donations | License

HOME

In this section, we will guide you through the process of creating a 3D model viewer using OpenGL. This project will help you integrate various OpenGL concepts and techniques you've learned throughout the course. By the end of this module, you will have a functional 3D model viewer capable of loading and displaying 3D models.

Objectives

Understand the basics of loading 3D models.
Implement camera controls for navigating the 3D space.
Apply textures and materials to the 3D models.
Handle user input for interaction.

Prerequisites

Before starting this module, ensure you are familiar with:

Basic OpenGL rendering techniques.
Loading and using textures.
Implementing lighting and shading.
Handling user input.

Step-by-Step Guide

Setting Up the Project

First, set up your development environment. Ensure you have the necessary libraries and tools installed, such as GLFW for window management and GLAD for loading OpenGL functions.

#include <GLFW/glfw3.h>
#include <glad/glad.h>
#include <iostream>

// Callback function for resizing the window
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

int main() {
    // Initialize GLFW
    if (!glfwInit()) {
        std::cerr << "Failed to initialize GLFW" << std::endl;
        return -1;
    }

    // Create a windowed mode window and its OpenGL context
    GLFWwindow* window = glfwCreateWindow(800, 600, "3D Model Viewer", NULL, NULL);
    if (!window) {
        std::cerr << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    // Make the window's context current
    glfwMakeContextCurrent(window);

    // Load OpenGL functions using GLAD
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cerr << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // Set the viewport
    glViewport(0, 0, 800, 600);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // Main loop
    while (!glfwWindowShouldClose(window)) {
        // Render here

        // Swap front and back buffers
        glfwSwapBuffers(window);

        // Poll for and process events
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

Loading 3D Models

To load 3D models, we will use the Assimp library. Assimp (Open Asset Import Library) is a library to import various well-known 3D model formats.

Installing Assimp

Follow the instructions on the Assimp GitHub page to install the library.

Loading a Model

Create a function to load a model using Assimp.

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

void loadModel(const std::string& path) {
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) {
        std::cerr << "ERROR::ASSIMP::" << importer.GetErrorString() << std::endl;
        return;
    }

    // Process the scene
    processNode(scene->mRootNode, scene);
}

void processNode(aiNode* node, const aiScene* scene) {
    // Process each mesh located at the current node
    for (unsigned int i = 0; i < node->mNumMeshes; i++) {
        aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
        processMesh(mesh, scene);
    }

    // Recursively process each of the children nodes
    for (unsigned int i = 0; i < node->mNumChildren; i++) {
        processNode(node->mChildren[i], scene);
    }
}

void processMesh(aiMesh* mesh, const aiScene* scene) {
    // Process vertex positions, normals, and texture coordinates
    for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
        // Process vertex positions, normals, and texture coordinates here
    }

    // Process indices
    for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
        aiFace face = mesh->mFaces[i];
        // Process indices here
    }

    // Process material
    if (mesh->mMaterialIndex >= 0) {
        aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
        // Process material here
    }
}

Implementing Camera Controls

Implement a camera class to navigate the 3D space. This will allow you to move around and view the model from different angles.

class Camera {
public:
    glm::vec3 Position;
    glm::vec3 Front;
    glm::vec3 Up;
    glm::vec3 Right;
    glm::vec3 WorldUp;

    float Yaw;
    float Pitch;

    float MovementSpeed;
    float MouseSensitivity;
    float Zoom;

    Camera(glm::vec3 position, glm::vec3 up, float yaw, float pitch)
        : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(2.5f), MouseSensitivity(0.1f), Zoom(45.0f) {
        Position = position;
        WorldUp = up;
        Yaw = yaw;
        Pitch = pitch;
        updateCameraVectors();
    }

    glm::mat4 GetViewMatrix() {
        return glm::lookAt(Position, Position + Front, Up);
    }

    void ProcessKeyboard(Camera_Movement direction, float deltaTime) {
        float velocity = MovementSpeed * deltaTime;
        if (direction == FORWARD)
            Position += Front * velocity;
        if (direction == BACKWARD)
            Position -= Front * velocity;
        if (direction == LEFT)
            Position -= Right * velocity;
        if (direction == RIGHT)
            Position += Right * velocity;
    }

    void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true) {
        xoffset *= MouseSensitivity;
        yoffset *= MouseSensitivity;

        Yaw += xoffset;
        Pitch += yoffset;

        if (constrainPitch) {
            if (Pitch > 89.0f)
                Pitch = 89.0f;
            if (Pitch < -89.0f)
                Pitch = -89.0f;
        }

        updateCameraVectors();
    }

    void ProcessMouseScroll(float yoffset) {
        if (Zoom >= 1.0f && Zoom <= 45.0f)
            Zoom -= yoffset;
        if (Zoom <= 1.0f)
            Zoom = 1.0f;
        if (Zoom >= 45.0f)
            Zoom = 45.0f;
    }

private:
    void updateCameraVectors() {
        glm::vec3 front;
        front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
        front.y = sin(glm::radians(Pitch));
        front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
        Front = glm::normalize(front);
        Right = glm::normalize(glm::cross(Front, WorldUp));
        Up = glm::normalize(glm::cross(Right, Front));
    }
};

Applying Textures and Materials

Load and apply textures and materials to the 3D model. This involves setting up shaders and binding textures.

void loadMaterialTextures(aiMaterial* mat, aiTextureType type, std::string typeName) {
    for (unsigned int i = 0; i < mat->GetTextureCount(type); i++) {
        aiString str;
        mat->GetTexture(type, i, &str);
        // Load texture and store it
    }
}

Handling User Input

Handle user input to interact with the 3D model viewer. This includes keyboard and mouse input for camera movement and zooming.

void processInput(GLFWwindow* window) {
    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        camera.ProcessKeyboard(RIGHT, deltaTime);
}

void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
    if (firstMouse) {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos;
    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
    camera.ProcessMouseScroll(yoffset);
}

Rendering the Model

Finally, render the loaded model using the camera and shaders.

void renderModel() {
    // Set up shaders and transformations
    shader.use();
    glm::mat4 view = camera.GetViewMatrix();
    glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    shader.setMat4("view", view);
    shader.setMat4("projection", projection);

    // Render the model
    for (unsigned int i = 0; i < meshes.size(); i++) {
        meshes[i].Draw(shader);
    }
}

Practical Exercise

Task

Create a 3D model viewer that can load and display a 3D model, navigate the 3D space using camera controls, and apply textures and materials to the model.

Solution

Set up the project and include necessary libraries.
Implement functions to load and process 3D models using Assimp.
Create a camera class to handle navigation.
Load and apply textures and materials.
Handle user input for interaction.
Render the model using shaders and transformations.

Conclusion

In this module, you learned how to create a 3D model viewer using OpenGL. This project integrated various OpenGL concepts, including model loading, camera controls, textures, and user input handling. By completing this module, you have gained practical experience in building a functional 3D application, preparing you for more advanced OpenGL projects.

Creating a 3D Model Viewer

Objectives

Prerequisites

Step-by-Step Guide

Setting Up the Project

Loading 3D Models

Installing Assimp

Loading a Model

Implementing Camera Controls

Applying Textures and Materials

Handling User Input

Rendering the Model

Practical Exercise

Task

Solution

Conclusion

OpenGL Programming Course

Module 1: Introduction to OpenGL

Module 2: Basic Rendering

Module 3: Intermediate Rendering Techniques

Module 4: Advanced Rendering Techniques

Module 5: Performance Optimization

Module 6: Special Effects and Techniques

Module 7: Advanced Topics

Module 8: Real-World Applications