Free online content available in this course.

You can get support and mentoring from a private teacher via videoconference on this course.

Got it!

Last updated on 1/8/13

Introduction à OpenGL

Log in or subscribe for free to enjoy all this course has to offer!

Dans ce chapitre nous découvrirons brièvement les possiblités d'OpenGL et réaliserons notre première application OpenGL grâce à SDL.

Qu'est-ce qu'OpenGL ?

Image utilisateur

OpenGL (Open Graphics Library) est une blibliothèque graphique très complète qui permet aux programmeurs de développer des applications 2D, 3D assez facilement.
Vous avez déjà dû l'utiliser ou en entendre parler, car de nombreux jeux, comme Quake III, proposent l'OpenGL comme mode d'affichage.

Image utilisateur

Quake III Arena

Bon d'accord, je dois vous l'avouer après avoir lu ce tuto vous ne saurez pas encore faire des jeux comme ça (notamment à cause du moteur physique pour gérer les collisions, déplacements et projectiles) mais il est beau de rêver. :p

OpenGL s'utilise principalement en C++, c'est pourquoi il est conseillé de connaître ce langage. Mais rassurez-vous ! Même sans base vous arriverez parfaitement à comprendre tous les exemples du cours, cependant les applications que vous serez amenés à développer par vous-mêmes seront peut-être moins poussées. La lecture du tuto C/C++ est fortement recommandée.

Une multitude de fonctionnalités

OpenGL dispose de nombreuses fonctions que vous pourrez « facilement » utiliser, notamment la gestion de :

Image utilisateur
  • la caméra ;

  • la rotation 3D des objets ;

  • le remplissage des faces ;

  • les textures ;

  • la lumière ;

  • et bien plus encore...

Dans ce tuto je compte vous montrer un maximum de techniques telles que la génération d'un terrain 3D, un moteur de particules, le bump-mapping, le cell-shading, etc. Comment alors ne pas saliver devant toutes ces possibilités qui s'ouvrent à vous ? D'autant que la plupart sont très accessibles d'un point de vue difficulté de programmation.

Fenêtrage et événements

OpenGL ne fournit que des fonctions 3D qui doivent être exécutées dans un contexte graphique déjà créé. Il nous faut donc choisir un système pour créer les fenêtres et gérer les événements pour donner une interactivité aux applications. OpenGL étant implémenté sur de nombreuses plates-formes, j'ai choisi de vous faire utiliser la SDL (d'autant que son installation/utilisation vous est enseignée dans le cours de M@teo).

La SDL nous permettra ainsi :

  • de créer une fenêtre ;

  • de charger très facilement des textures grâce à SDL_image ;

  • d'utiliser le clavier et la souris ;

  • d'animer nos scènes.

Ainsi nous combinerons la facilité d'utilisation de la SDL avec la puissance d'OpenGL tout en gardant le coté multi plate-formes.

Et les moteurs 3D ?

Je reviendrai en détail plus tard dans ce tutoriel sur ce qui diffère OpenGL des moteurs 3D et sur comment créer son moteur 3D basé sur OpenGL. Quoi qu'il en soit ce que vous apprendrez ici est souvent applicable ailleurs et vous fournit des explications générales sur la programmation 3D. Se plonger dans un moteur tel Irrlicht ou Ogre sera d'autant plus facile que vous saurez ce qu'ils utilisent derrière.

Que dois-je installer ?

Vous êtes enfin décidés à vous lancer ? ^^ Parfait !

Les fichiers nécessaires pour développer

Si vous avez téléchargé Code::Block ou DevC++pour suivre le tuto de C/C++ ne changez rien, vous avez déjà les headers et les .a nécessaires. Vous devez donc avoir :

OS

include

lib

Windows

GL/gl.h
GL/glu.h

libopengl32.a*
libglu32.a

Unix**

libopengl.a
libglu.a

* Si vous utilisez Visual Studio, vous devez déjà avoir l'équivalent en .lib.
** Nous verrons lors de la création de notre premier programme quoi rajouter exactement sous Linux.

Les fichiers nécessaires pour exécuter

  • Sous Windows sauf cas rare très exceptionnel vous avez déjà les .dll nécessaires soit : opengl32.dll et glu32.dll. Vous n'aurez pas à les fournir avec votre exécutable, car ils sont présents par défaut sous Windows.

  • Sous Linux il vous faut les .so associés au .a.

Vérifier que l'accélération 3D est activée

Avoir les bons fichiers ne signifie pas forcément que les applications 3D tourneront parfaitement. Si l'accélération matérielle n'est pas activée, les performances en seront très fortement diminuées.
Vérifiez donc que vous avez bien installé les derniers drivers de votre carte graphique. Sous Windows si vous avez l'habitude de jouer à des jeux vidéos sans problèmes c'est que c'est bon ! :D
Sous Linux utilisez le fameux programme glxgears pour tester. Les instructions étant trop dépendantes de votre distribution et de votre carte, reportez-vous aux nombreuses ressources disponibles sur Internet.

Première application OpenGL avec SDL

Je vous l'ai dit plus haut nous allons utiliser OpenGL dans un contexte SDL. La première chose à faire est donc de créer un projet SDL de base (comme expliqué dans le tuto de M@teo). Nous viendrons y remplacer tout le code et compléter les options de compilation pour rajouter OpenGL lors de la phase d'édition des liens.

Je fournirai d'ailleurs en fin de chapitre le projet final utilisé et vous pourrez vous en servir comme point de départ pour vos applications OpenGL créées en suivant ce tutoriel.

Code de départ

Souvenez-vous du code minimal pour ouvrir une fenêtre SDL :

#include <SDL/SDL.h>

int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_VIDEO);

    SDL_Surface* ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

    SDL_Flip(ecran);

    bool continuer = true;
    SDL_Event event;

    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = false;
        }
    }

    SDL_Quit();

    return 0;
}

Initialiser SDL en mode OpenGL

La première chose à changer est au niveau de l'initialisation de mode vidéo. Nous allons utiliser SDL_OPENGL au lieu de SDL_HWSURFACE :

SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);

Que devient le SDL_DOUBLEBUF utilisé avec la SDL normalement pour activer le double-buffering (cf. Travailler avec le double buffer) ?

L'équivalent avec OpenGL reviendrait à appeler SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); mais il s'avère qu'il est déjà activé par défaut pour OpenGL. Rien de spécial à faire donc.

Le premier dessin

Ensuite nous allons faire nos premiers appels OpenGL pour dessiner un simple triangle.
Nous rajoutons donc les headers nécessaires :

#include <GL/gl.h>
#include <GL/glu.h>

Voici le code du triangle qui vous sera expliqué dans le prochaine chapitre :

glClear(GL_COLOR_BUFFER_BIT);

    glBegin(GL_TRIANGLES);
        glColor3ub(255,0,0);    glVertex2d(-0.75,-0.75);
        glColor3ub(0,255,0);    glVertex2d(0,0.75);
        glColor3ub(0,0,255);    glVertex2d(0.75,-0.75);
    glEnd();

SDL_Flip(ecran); disparaît au profit de l'appel suivant :

glFlush();
    SDL_GL_SwapBuffers();

La première commande, glFlush, vient s'assurer que toutes les commandes OpenGL ont été exécutées, et SDL_GL_SwapBuffers est l'équivalent de l'ancien SDL_Flip.

Le code complet

#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>

int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_VIDEO);
    SDL_WM_SetCaption("Mon premier programme OpenGL !",NULL);
    SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);

    bool continuer = true;
    SDL_Event event;

    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = false;
        }

         glClear(GL_COLOR_BUFFER_BIT);

        glBegin(GL_TRIANGLES);
            glColor3ub(255,0,0);    glVertex2d(-0.75,-0.75);
            glColor3ub(0,255,0);    glVertex2d(0,0.75);
            glColor3ub(0,0,255);    glVertex2d(0.75,-0.75);
        glEnd();

        glFlush();
        SDL_GL_SwapBuffers();
    }

    SDL_Quit();

    return 0;
}

Compilation

Pour compiler il nous faut rajouter les fichiers cités plus haut. Dans nos options de projet nous rajoutons donc :

IDE / Compilateur

lib

Code::Blocks Windows

opengl32
glu32

DevC++ Windows

-lopengl32
-lglu32

Visual Studio Windows

opengl32.lib
glu32.lib

Code::Blocks Linux

GL
GLU

gcc / g++ Linux

-lGL -lGLU

Résultat

Image utilisateur

Téléchargez le projet Code::Blocks final, l'exécutable Windows et le Makefile Unix (116 Ko)

Et voilà ce n'était pas sorcier ! :p Direction le prochain chapitre pour comprendre le code OpenGL que nous avons utilisé et pour dessiner plein de jolies choses.

Example of certificate of achievement
Example of certificate of achievement