TD d`infographie n°1

TD d'infographie n°1
Cours d'infographie
IUT Informatique
Initiation à OpenGL et Glut
Création d'une application simple de labyrinthe en OpenGL
et par la bibliothèque Glut. Création du labyrinthe, de la
navigation et de l'IHM
Le but de ce TD est de réaliser une application de navigation dans un labyrinthe. Un personnage va
être plongé dans un labyrinthe et devra s'en sortir. Le labyrinthe est chargé à partir d'un fichier
image qui représente ce labyrinthe vu de dessus (plan x0y). Les parties en blanc sont les couloirs,
les cases en noir les murs, et les 2 pixels rouge et vert respectivement l'entrée et la sortie. La
visualisation s'effectue en 3D et le déplacement dans le labyrinthe obéi à des règles simples.
Exercice A : Chargement du labyrinthe
Votre labyrinthe est créé grâce à une image au format PPM. Ce format, très simple, est facile à lire
et donc à manipuler.
1. Téléchargez l'archive iut_td1.tgz sur le site internet http://www-igm.univ-mlv.fr/~biri/.
Prenez connaissance du code source offert. Détaillez notamment les fichiers ioPPM.h et
ioPPM.c ainsi que image.h et image.c
2. Réalisez les 6 premières fonctions du fichier image.h
3. Chargez le labyrinthe dans la fonction init de td1_maze.c. Vérifiez que le chargement
est correct en sauvegardant l'image chargée dans un fichier out.ppm. Vous devriez
constater que l'image a été retournée. Après le chargement de l'image, appelez la fonction de
retournement vertical afin de « redresser » votre image. Si vous utilisez l'exemple fourni,
vérifiez alors que le pixel 6,0 est bien rouge.
Exercice B: Point d'entrée du labyrinthe
L'image représentant le labyrinthe contient un (et un seul) pixel rouge. C'est là que commence votre
personnage. Cette entrée (ce pixel rouge) ne peut pas être dans un coin de l'image et est forcément
sur un bord de l'image.
1. Réalisez la fonction locateEntryPoint (dans le fichier image.c) permettant de
retrouver la position du pixel rouge. C
2. Déterminez également la première direction du regard. Le principe est simple : c'est la
direction opposé au bord de l'image. La direction est exprimée, suivant les directions x et y
en -1, 0 ou +1.
Exercice C : Dessin du labyrinthe
Nous allons maintenant procéder au dessin du labyrinthe proprement dit. Avant tout, il convient de
bien comprendre le mécanisme en jeu : nous allons caractériser chaque case suivant les murs
présent sur ses bords est, nord, ouest et sud. Puis nous réaliserons une fonction générique
permettant de dessiner une case. Enfin nous pourrons visualiser les cases directement visibles de la
caméra.
1. Réalisez la fonction getTypeCase qui renvoie un octet indiquant sur le bit 1 si il y
présence du mur à l'est, sur le bit 2 de la présence du mur au nord, sur le bit 3 de la présence
du mur à l'ouest et enfin sur le bit 4 de la présence du mur au sud. Vous pouvez
éventuellement (mais ce n'est pas nécessaire) implémenter la fonction checkMur qui
renvoie vrai si la case indiqué en paramètre est un mur (ou est à l'extérieur de l'image).
2. Dessinez les murs de la case grâce à la fonction glDrawOneCase. Pour ce faire, vous
devrez positionner le repère local grâce à un glTranslatef puis dessiner une case
« canonique ». Vous dessinerez les bords de chaque mur grâce à l'instruction
glBegin(GL_LINE_LOOP) et à glVertex3f. Les murs ont une largeur et une hauteur
de SIZE_CASE.
3. Positionner maintenant votre caméra sur le point d'entrée calculé précédemment et faites la
regarder « dans la bonne direction ». Vous devez agir sur la fonction gluLookAt du fichier
td1_maze.c
4. Dessinez la case courante (la case d'entrée). Vérifiez que le résultat est correct.
5. Dessinez la partie du labyrinthe qui fait face à la caméra, ainsi que les cases adjacentes à
celles-ci (qui ne soient pas des murs). C'est à faire dans la fonction drawVisibleMaze.
Attention à ne pas visualiser des cases en dehors de l'image.
Exercice D : Navigation
Maintenant nous allons nous déplacer dans le labyrinthe à l'aide des flèches du clavier.
1. En réactualisant pos_x et pos_y, faites avancer et reculer le personnage. Il avance (resp.
recule) d'une case à chaque pression de la touche haut (resp. bas) dans la direction du regard.
Prenez garde à ne pas pénétrer dans les murs et à ne pas sortir du labyrinthe
2. La flèche gauche doit permettre à la caméra de pivoter de 90° dans le sens antihoraire. La
flèche droite pivote la caméra de 90° dans le sens horaire. Calculez les modifications sur la
direction du regard.
3. Détectez la fin de niveau. C'est lorsque la position de la caméra est sur le pixel vert (fonction
isExit)
Exercice E : Aide à la navigation
•
•
•
•
Remplacer le rendu filaire par un rendu de Quads. Il suffit de changer GL_LINE_LOOP en
GL_QUADS.
Permettez à votre joueur de pouvoir poser des balises dans le labyrinthe (éventuellement de
plusieurs types).
Intégrez des pièges (changement de la couleur des pixels de l'image) dans le labyrinthe et
gérez les points de vie du joueur.
A l'aide des fonctions IHM (idle, ou toute réactualisation utilisateur), insérez des éléments
mobiles dans le labyrinthe (monstres, personnages ...)