Les vertex array objects (VAO) d'OpenGL 4

Dans opengl_3.h, on crée deux variables et une méthode. Cette dernière ne prendra pas de paramètre et ne retournera rien, mais créera le VAO et le VBO nécessaires pour dessiner un carré. Dans cette optique, on la nomme createSquare().

void createSquare(void); // Méthode pour créer les VAO du carré

Les deux variables seront des tableaux d'entiers non signés de longueur unitaire, on a ainsi un VAO et un VBO. On appelle ces variables privées vaoID et vboID.

unsigned int vaoID[1]; // VAO
unsigned int vboID[1]; // VBO

Jusque-là, rien d'effrayant. Dans opengl_3.cpp, on commence à l'utiliser. Dans la méthode setupScene(), on ajoute un appel à createSquare() puis on s'occupe de cette dernière. On garde à l'esprit qu'on crée le carré, le VAO et le VBO avant de les utiliser, sinon on risque d'avoir des problèmes de mémoire non allouée.

void OpenGLContext::setupScene(void) {  
	...  
	  
	createSquare(); // Crée un carré
}

Ensuite, la méthode createSquare(). On remplit ce squelette :

/** 
createSquare est utilisée pour créer le VAO qui contiendra le carré. On stocke en dur ses sommets. 
*/  
void OpenGLContext::createSquare(void) {  
  
}

Avant de créer le VAO et le VBO, on a besoin de données décrivant les sommets de la forme. On dessine un carré formé par deux triangles, on a donc besoin de six sommets (trois par triangle). Ensuite, puisque chaque sommet contient trois valeurs (les coordonnées x, y et z) et qu'on a six sommets, on aura un total de dix-huit valeurs pour décrire le carré. Il s'agira de valeurs float stockées dans un tableau vertices. On utilise un tableau dynamique, qu'il faudra supprimer à la fin de la méthode pour éviter les fuites de mémoire.

void OpenGLContext::createSquare(void) {  
	float* vertices = new float[18];  // Sommets du carré
	  
	delete [] vertices; // Supprimer les sommets
}

On remplit alors quelques valeurs pour ces sommets. On met tous les sommets à 0 sur l'axe 0 et on donne au carré une longueur d'une unité. On centre le carré à l'origine, ce qui donne un sommet en haut à gauche de coordonnées (- 0,5 ; 0,5 ; 0.0) ; en bas à droite (0,5 ; - 0,5 ; 0.0).

void OpenGLContext::createSquare(void) {  
	float* vertices = new float[18];  // Sommets du carré
  
	vertices[0] = -0.5; vertices[1] = -0.5; vertices[2] = 0.0; // Coin en bas à gauche
	vertices[3] = -0.5; vertices[4] = 0.5; vertices[5] = 0.0; // Coin en haut à gauche
	vertices[6] = 0.5; vertices[7] = 0.5; vertices[8] = 0.0; // Coin en haut à droite
	  
	vertices[9] = 0.5; vertices[10] = -0.5; vertices[11] = 0.0; // Coin en bas à droite
	vertices[12] = -0.5; vertices[13] = -0.5; vertices[14] = 0.0; // Coin en bas à gauche
	vertices[15] = 0.5; vertices[16] = 0.5; vertices[17] = 0.0; // Coin en haut à droite
  
	delete [] vertices; // Supprimer les sommets
}

Les coordonnées des sommets remplies, on peut avancer et créer un VBO avec un appel à glGenVertexArrays(). Ensuite, on utilise un appel à glBindVertexArray() pour activer le VAO. De là, on peut appeler glGenBuffers() pour créer le VBO que l'on lie avec glBindBuffer().

1. Générer le vertex array object ;
2. Lier le vertex array object ;
3. Générer le vertex buffer object ;
4. Lier le vertex buffer object ;

Dès lors, on remplit le VBO avec les données des sommets. À la création du VBO, on peut en définir le type ; dans le cas présent, on utilise GL_STATIC_DRAW pour indiquer à OpenGL qu'on n'envisage pas de changer les données, d'aucune manière, on veut juste les afficher. L'API définit également des types pour les données qui changent, notamment précisés sur le wiki OpenGL.

Ensuite, on appelle glBufferData() pour transférer les données du tableau précédemment créé dans le VBO, avant de dire à OpenGL que ce VBO servira de stockage de sommets. Finalement, on nettoie en désactivant tant le tableau d'attributs des sommets que le VAO.

void OpenGLContext::createSquare(void) {  
  
	...  
	  
	glGenVertexArrays(1, &vaoID[0]); // Créer le VAO
	glBindVertexArray(vaoID[0]); // Lier le VAO pour l'utiliser
	  
	glGenBuffers(1, vboID); // Générer le VBO
	glBindBuffer(GL_ARRAY_BUFFER, vboID[0]); // Lier le VBO
	glBufferData(GL_ARRAY_BUFFER, 18 * sizeof(GLfloat), vertices, GL_STATIC_DRAW); // Définir la taille, les données et le type du VBO
	  
	glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0); // Définir le pointeur d'attributs des sommets
	  
	glEnableVertexAttribArray(0); // Désactiver le VAO
	glBindVertexArray(0); // Désactiver le VBO
	  
	delete [] vertices; // Supprimer les sommets
}

On a maintenant un VAO avec un VBO contenant les sommets d'un carré. Jusqu'ici, cela a été relativement rapide et facile, on affiche donc ces données à l'écran. On saute ainsi à la méthode renderScene() et, après la définition des variables glUniformMatrix4vf pour le shader du tutoriel précédent, on ajoute trois lignes pour le rendu. Tout d'abord, on active le VAO ; ensuite, on le dessine ; finalement, on le désactive. Cela donne :

glBindVertexArray(vaoID[0]); // Lier le VAO
  
glDrawArrays(GL_TRIANGLES, 0, 6); // Dessiner le carré
  
glBindVertexArray(0); // Délier le VAO