Tutoriel 1 - Ouvrir une fenêtre

La spécification d'OpenGL ne définit pas de fonctions particulières pour manipuler des fenêtres. Les systèmes modernes de fenêtrage supportant OpenGL incluent généralement un sous-système fournissant la liaison entre un contexte OpenGL et le système de fenêtrage. Dans le système X Window, cette interface est appelée GLX. Microsoft fournit WGL (prononcé Wigueul) pour Windows et MacOS a CGL. Travailler directement avec ces interfaces afin de créer une fenêtre pour gérer l'affichage est généralement un travail fastidieux, c'est pourquoi nous allons utiliser une bibliothèque de haut niveau qui fera abstraction de ces détails.
La bibliothèque que nous allons utiliser ici est appelée « OpenGL utility library », ou GLUT. Elle fournit des fonctions simplifiées pour la gestion de fenêtres ainsi qu'une gestion évènementielle, une gestion des E/S et quelques autres services. De plus, GLUT est multiplateforme, ce qui facilite le portage.
Les alternatives à GLUT sont, entre autres, SDL ou GLFW.

glutInit(&argc, argv);

Cet appel initialise GLUT.
Les paramètres peuvent être fournis directement depuis la ligne de commande et inclure des options utiles du type « -sync » ou « -gldebug » qui désactive la nature asynchrone de X et vérifie automatiquement les erreurs GL et les affiche (respectivement).

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);

Ici nous configurons quelques options de GLUT.
GLUT_DOUBLE active le « double buffering » (dessiner dans un tampon en arrière-plan pendant qu'un autre tampon est affiché).
GLUT_RGBA définit le format des pixels du tampon de couleurs où sont appliqués les rendus (par exemple : l'écran).
On active généralement ces deux options ainsi que d'autres comme nous le verrons plus tard.

glutInitWindowSize(1024, 768);
glutInitWindowPosition(100, 100);
glutCreateWindow("Tutorial 01");

Ces appels définissent les paramètres de la fenêtre et la créent. Vous avez aussi la possibilité de spécifier le titre de la fenêtre.

glutDisplayFunc(RenderSceneCB);

Comme nous travaillons dans un système fenêtré, les interactions avec le programme vont principalement se faire au travers de callbacks sur des évènements. GLUT prend en charge les interactions avec le système de fenêtres sous-jacent et nous fournit quelques callbacks.
Ici nous en utilisons juste un : le callback « principal » pour effectuer le rendu d'une image. Cette fonction est appelée continuellement par la boucle interne de GLUT.

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

C'est notre première rencontre avec le concept d'état en OpenGL.
L'idée d'un état est que le rendu est une tâche tellement complexe qu'elle ne peut être traitée dans un seul appel de fonction avec quelques paramètres (et une fonction correctement conçue ne devrait jamais recevoir beaucoup de paramètres).
Il faut spécifier les shaders, tampons et divers indicateurs qui affectent la manière dont le rendu s'effectue. De plus vous voudrez souvent garder la même configuration au travers de plusieurs opérations de rendu (exemple : si vous ne désactivez jamais le test de profondeur, il n'y a pas lieu de le spécifier à chaque rendu). C'est pourquoi la plus grande partie de la configuration des opérations de rendu s'effectue en définissant des indicateurs et des valeurs dans la machine à états d'OpenGL. Les rendus eux-mêmes sont habituellement limités aux quelques paramètres relatant du nombre de sommets à dessiner et leur décalage de départ.
Après l'appel d'une fonction de changement d'état, cette nouvelle configuration reste inchangée jusqu'au prochain appel de cette même fonction avec une valeur différente. L'appel ci-dessus définit la couleur qui sera utilisée lors du vidage du tampon d'image (décrit plus tard). La couleur a quatre composantes (RGBA) et chaque composante est normalisée entre 0.0 et 1.0.

glutMainLoop();

Cet appel donne le contrôle à GLUT qui lance sa boucle interne. Dans cette boucle GLUT écoute les évènements du système de fenêtres et les passe aux callbacks que nous avons définies. Dans notre cas, GLUT va seulement appeler la fonction enregistrée comme callback d'affichage (RenderSceneCB) pour nous donner l'occasion de dessiner une image.

glClear(GL_COLOR_BUFFER_BIT);
glutSwapBuffers();

La seule chose que nous faisons dans notre fonction de rendu est de vider le tampon d'image (en utilisant la couleur spécifiée au-dessus - essayez de la changer). Le second appel dit à GLUT d'échanger les rôles du « backbuffer » et du « frontbuffer ». Dans le prochain appel du callback de rendu, nous rendrons dans l'actuel « frontbuffer » et l'actuel « backbuffer » sera affiché.

Vous pouvez télécharger les sources de ce projet en suivant ce lien :

Récupérez les sources

Merci à Etay Meiri de nous permettre de traduire son tutoriel.

Merci à LittleWhite pour ses corrections et à ClaudeLELOUP pour sa relecture.