Introduction à OpenGL : la SDL
publié le jeudi 27 juillet 2006 (vu 889 fois)

OpenGL est avant tout une bibliothèque graphique.
La portabilité fait partie des raisons qui rendent cette bibliothèque si populaire.
Hors pour utiliser OpenGL, il faut lui fournir un contexte de rendu, qui est fourni par le système.
Pour conserver cette portabilité, plutôt que d’écrire le code pour différents systèmes, nous allons nous en remettre à une autre bibliothèque portable : la SDL.


Initialisation de la SDL

Se servir de la SDL pour obtenir une fenêtre d’affichage OpenGL ou un affichage plein écran est relativement simple.
Il nous faut tout d’abord les prototypes des fonctions de la bibliothèque en incluant son fichier d’entête :

Votre compilateur doit bien entendu connaître l’emplacement sur votre disque où se trouve ce fichier.
Je vous fais confiance de ce côté là, vous n’êtes pas des débutants en programmation ;-)
Comme tout programme qui se respecte, il nous faut une fonction principale : le main.

La première chose à faire pour utiliser la SDL, c’est de l’initialiser.
Ce qui se fait tout simplement avec l’appel à la fonction SDL_Init.
L’initialisation de la SDL pouvant échouer, la fonction SDL_Init retourne un int indiquant la réussite ou l’echec de l’initialisation.
Le seul paramètre de cette fonction est construit à partir de flags d’initialisation pour activer les différents sous-systèmes de la SDL qui nous intéresse.
En ce qui nous concerne, nous n’avons besoin que de l’affichage et utiliserons donc uniquement le flag SDL_INIT_VIDEO de cette manière :

La SDL initialisée, il faudra également penser à libérer les resources qu’elle utilise lorsque le programme s’arrêtera.
Pour cela, un simple appel à SDL_Quit suffit.

De cette manière, loque le programme se terminera, il effecturera automatiquement un appel à SDL_Quit.


Initialisation OpenGL

La fonction SDL_GL_SetAttribute que nous allons maintenant utiliser est spécifique au mode de rendu OpenGL.
Elle sert entre autres à paramétrer la précision du depth buffer ou encore activer le double buffer, ce à quoi nous allons nous limiter pour notre application de base.
L’activation du double buffer se fait donc avec la ligne suivante :

Notez que les appels à la fonction SDL_GL_SetAttribute sont à faire avant la création de la fenêtre OpenGL, que nous pouvons maintenant effectuer à l’aide de la fonction SDL_SetVideoMode qui sert justement à activer l’affichage de la SDL.

Ici on demande à la SDL de nous créer une fenêtre de dimensions 640x480 (respectivement la largeur et la hauteur de la fenêtre) avec une profondeur de couleurs de 32 bits.
Le 4ème paramètre est construit sur différents flags, mais pour utiliser OpenGL avec la SDL, un seul est nécessaire : SDL_OPENGL.
Un second flag vous intéressera également puisqu’il s’agit de basculer une fenêtre en mode plein écran.
pour cela, il suffit d’ajouter le flag SDL_FULLSCREEN au flag déjà présent de la manière suivante :

Comme la création de la fenêtre peut échouer, ce pour diverses raisons, il est important de vérifier que ce n’est pas le cas et que la fenêtre a effectivement été créée :

De cette manière, l’echec de la création de la fenêtre provoquera l’arrêt de notre programme.


La boucle principale

Nous avons notre fenêtre dans laquelle sera visible notre rendu OpenGL.
Pour bien faire, il reste à définir la boucle principale dans laquelle le rendu est appelé.
Cette dernière traitera également les événements de la SDL pour quitter lorsque l’utilisateur le demandera.
Initialisée à true, cette variable indique que notre boucle principale est active.

La SDL gère les événements tels que par exemple la pression d’une touche, son relachement, un déplacement de la souris et d’autres encore.
Nous avons donc besoin d’une boucle pour gérer ces événements.
Pourquoi une boucle ? tout simplement parcequ’un événement n’arrivant pas toujours seul, ils sont stockés dans une pile d’événements.
La fermeture de la fenêtre créée par la SDL est également un événement.
Donc la boucle que nous allons créer est la suivante :

A la suite de cette boucle, nous pouvons mettre la suite du programme.
Dans notre cas, on va juste effacer l’écran et demander à basculer les buffers (vu que nous avons un affichage en double buffer).
Etant donné c’est la SDL qui gère notre fenêtre et donc notre affichage, nous allons faire appel à la fonction SDL_GL_SwapBuffers pour l’échange des buffers.
Voici donc la fin de la boucle principale :


Fin du programme

Et nous voilà arrivés à la fin de notre programme.
Un petit bout de code manque pour quitter correctement ce dernier :

J’espère que cet article servira à ceux qui veulent débuter avec la SDL et OpenGL.
J’ai essayé de faire simple tout en détaillant bien ce petit programme afin de vous initier aux bases.
Bien entendu, nous sommes loin d’avoir tout vu de l’utilité de la SDL, que ce soit avec OpenGL ou non, n’hésitez donc pas à parcourir le site officiel et la documentation de cette puissante bibliothèque.

Code Source (fichier Zip de 888 octets)
Executable windows (fichier Zip de 62.6 ko)