Pipeline de Rendu OpenGL

OpenGL fonctionne dans un espace 3D, tandis que les écrans sont des tableaux de pixels 2D. La majeure partie du travail d'OpenGL consiste à convertir des coordonnées 3D en pixels 2D adaptés à votre écran. Ce processus de transformation est géré par le pipeline de rendu graphique d'OpenGL.

Le pipeline de rendu peut être divisé en deux parties principales : la première convertit vos coordonnées 3D en coordonnées 2D, et la seconde transforme ces coordonnées 2D en pixels colorés.

Les Shaders

Le pipeline de rendu accepte un ensemble de coordonnées 3D et les transforme en pixels colorés 2D en sortie. Le pipeline est divisé en plusieurs étapes, chacune traitant les données de manière spécialisée. Ces étapes sont exécutées en parallèle sur le GPU grâce à de petits programmes appelés shaders.

Certains shaders peuvent être configurés par les développeurs, permettant un contrôle fin du pipeline de rendu. Les shaders OpenGL sont écrits en GLSL (OpenGL Shading Language).

Coordonnées Normalisées

OpenGL traite uniquement les coordonnées situées dans une plage spécifiée sur les trois axes (x, y, z) de -1.0 à 1.0. Ces coordonnées sont appelées coordonnées noramlisées de périphérique (NDC). Toute coordonnée en dehors de cette plage est ignorée.

Gestion des Sommets

Pour dessiner une forme, nous devons d'abord fournir des données de sommets à OpenGL. Chaque sommet est une collection de données (position, couleur, etc.). Pour un triangle, nous définissons trois sommets avec leurs coordonnées 3D.

Nous utilisons des objets tampon de sommets (VBO) pour stocker ces données dans la mémoire vidéo. Cela permet d'envoyer de grandes quantités de données d'un seul coup au GPU, ce qui est plus efficace.

Création des Shaders

OpenGL moderne nécessite au moins un shader de sommet et un shader de fragment. Le shader de sommet traite chaque sommet individuellement, tandis que le shader de fragment détermine la couleur finale de chaque pixel.

Voici un exemple simple de shader de sommet :

#version 330 core
layout (location = 0) in vec3 position;

void main()
{
    gl_Position = vec4(position, 1.0);
}

Et un shader de fragment qui produit une couleur orange :

#version 330 core
out vec4 color;

void main()
{
    color = vec4(1.0, 0.5, 0.2, 1.0);
}

Compilation des Shaders

Après avoir écrit les shaders en GLSL, nous devons les compiler et les lier dans un programme shader. Ce programme contient tous les shaders nécessaires au rendu.

Attributs de Sommet

Nous devons indiquer à OpenGL comment interpréter les données de sommets dans le tampon. Cela se fait avec la fonction glVertexAttribPointer, qui spécifie comment les données sont organisées en mémoire.

Objets de Tableau de Sommets (VAO)

Les objets de tableau de sommets (VAO) stockent la configuraton des attributs de sommet et des tampons associés. Une fois configuré, un VAO peut être rapidement lié pour restaurer cet état, simplifiant le rendu de plusieurs objets.

Dessin du Triangle

Pour dessiner notre triangle, nous utilisons la fonction glDrawArrays, qui utilise les shaders activés, la configuration des attributs et les données du tampon pour dessiner des primitives.

Objets Tampon d'Éléments (EBO)

Pour des formes plus complexes comme des rectangles, nous pouvons utiliser des objets tampon d'éléments (EBO) pour spécifier l'ordre de dessin des sommets. Cela permet de réutiliser des sommets communs, réduisant la quantité de données nécessaires.

Voici comment définir des sommets et des indices pour un rectangle composé de deux triangles :

GLfloat sommets[] = {
    0.5f, 0.5f, 0.0f,   // coin supérieur droit
    0.5f, -0.5f, 0.0f,  // coin inférieur droit
    -0.5f, -0.5f, 0.0f, // coin inférieur gauche
    -0.5f, 0.5f, 0.0f   // coin supérieur gauche
};

GLuint indices[] = {
    0, 1, 3,  // premier triangle
    1, 2, 3   // deuxième triangle
};

Nous utilisons ensuite glDrawElements au lieu de glDrawArrays pour dessiner en utilisant ces indices.