• Attention: pour pouvoir effectuer les TPs correctement, vous aurez besoin de votre cours. Vous pouvez aussi vous référer au guide de programmation 1.1 (pdf,html):
  
  http://www.opengl.org/
  http://rush3d.com/reference/opengl-redbook-1.1/
  
  Vous pouvez aussi accéder à l'aide en ligne avec la commande :
  
  man <nom_fonction>
  
  Ou encore utiliser konqueror et taper :
  
  man:<nom_fonction>
  
  
• L'évaluation des TPs se fera à partir:
  
  
  1. D'une scéance de validation qui aura lieu après les 8 scéances de TPs. L'étudiant montrera les résultats qu'il est arrivé à obtenir au terme des scéances de TP.
  2. D'un compte rendu de TPs qui sera remis à l'enseignant en version imprimée ou manuscrite lors de la validation. Ce compte rendu comprendra les réponses aux questions posées dans les sujets des différents TPs, ainsi qu'un récapitulatif mettant en évidence le travail effectué par l'étudiant.


• Avant de pouvoir commencer votre TP, il vous faut installer la structure de programme de départ. Suivez les instructions suivantes :
  
  
  1. Créez un répertoire qui sera votre répertoire de travail pour les TPs d'OpenGL.
  2. Téléchargez dans ce répertoire le fichier suivant:
     https://www.irit.fr/~Loic.Barthe/Enseignements/TPs_OpenGL/TP1/intro_OpenGL.tar.gz
  
  
  3. Décompressez l'archive dans le répertoire puis effacez la.
  4. Dans un shell, placez vous dans le répertoire  où vous avez décompressé les fichiers et compilez le programme en tapant:
     make depend
     make
     Par la suite, il suffira de taper "make" pour compiler le programme. La commande "make depend" ne sera à utiliser que si un "Makefile" est modifié.
     Les fichiers objets (.o) et l'exécutable (nommé "tp1") sont dans le répertoire "bin".
     Lancez le programme avec la commande:
     ./bin/tp1
  5. Editez le programme principal "main.c". Il est suggéré d'utiliser l'éditeur "kate" qui se lance avec la commande:
     kate main.c &
  
  
• Attendez maintenant que votre enseignant explique les différentes fonctions qui sont déjà présentes dans le programme. Il vous expliquera aussi le principe de la programmation OpenGL: machine à état avec laquelle on fait de la programmation événementielle.


• Le but de ce TP est de se familiariser avec le mode d'affichage OpenGL, les matrices de projection, le positionnement d'un objet, la gestion de la couleur en RVB.
  A la fin de ce TP vous aurez créé la scène suivante:
  
  
  • Effacement de la fenêtre:
    
    
    1. Que se passe-t-il quand vous exécutez le programme? Pourquoi?
    
    
    2. Dans la fonction "display" du fichier "main.c", ajoutez la fonction suivante en première ligne:
       glClear (GL_COLOR_BUFFER_BIT);
       Que se passe-t-il? Pourquoi?
    
    
    3. Ajoutez juste après la fonction:
       glClearColor (1.0, 1.0, 1.0, 0.0);
       Quelle est la couleur (1.0, 1.0, 1.0)? On notera que la 4ème composante de la couleur est la composante Alpha qui sert à régler la transparence. Pour les TPs, cette composante sera fixée à 0.0 (pas de transparence).
       Que se passe-t-il? Pourquoi?
       Positionnez cette fonction à la bonne place pour que la fenêtre soit effacée avec la couleur souhaitée.
       Faites effacer la fenêtre en rouge, puis en gris foncé.
  
  
  • L'effacement du buffer image est en général la première chose que l'on fait dans la fonction de rendu (display). Ensuite, on va définir la fenêtre de projection puis la matrice de projection et enfin on va tracer les objets.
    
    
    1. La fenêtre et la matrice de projection ont des valeurs par défaut, ainsi, il est possible de tracer directement un objet.
       Tracez une théière de rayon 1 centrée sur l'origine du repère scène à l'aide de la fonction suivante:
       glutSolidTeapot(1.);
       
    
    
    2. La fonction "glColor3f(...)" permet de modifier la couleur d'affichage des objets à l'aide de 3 flottants (rouge,vert,bleu) passés en paramètre. Placez cette fonction au mieux pour que la théière soit tracée en jaune.
    
    
    3. Il s'agit maintenant de retrouver les valeurs par défaut de la fenêtre et la matrice de projection. On précise que la projection par défaut est une projection orthogonale (pas de perspective).
       Intéressons nous tout d'abord à la fenêtre de projection. Elle définit la position et la taille de l'image qui va être affichée dans la fenêtre de l'application OpenGL. Elle est définie par la fonction:
       glViewport(x,y,l,h);
       Que représentent les paramètres x,y,l et h?
       Insérez cette fonction dans votre programme et retrouvez la valeur par défaut de ses paramètres.
       Quelles valeurs faut-il donner à ces paramètres pour obtenir l'image suivante (l'image occupe la moitié supérieure de la fenêtre, calée à droite et elle est carrée: 300 pixels de côté):
       
       Reprenons maintenant les valeurs par défaut de la fenêtre de projection. Il va s'agir de régler la matrice de projection orthogonale pour que la théière soit affichée sans distorsion.
       Tout d'abord, il nous faut ajouter à la fonction de rendu (display) les fonctions permettant de contrôler la projection.
       
       
       • Dans un premier temps, il nous faut passer en mode de modification de la matrice de projection avec la fonction:
         glMatrixMode (GL_PROJECTION);
       
       
       • Puis on va initialiser la matrice de projection avec la fonction:
         glLoadIdentity ();
         Quelle est la valeur de la matrice de projection?
         Que se passe-t-il au niveau de l'affichage?
       
       
       • Ajoutez maintenant la matrice de projection orthogonale à l'aide de la fonction suivante:
         glOrtho (-0.1, 0.3, -0.8, 1.2, 0., 1.);
         Que représentent les paramètres de cette fonctions?
         Retrouvez la valeur par défaut de ces paramètres.
         Modifiez ces paramètres pour que l'on voit la théière dans son intégralité, en grand, et sans distorsion.
         
  
  
  • Nous allons maintenant déplacer la théière.
    
    
    1. Faites un schéma représentant le repère scène, la position de la théière et le volume de vision (défini par la matrice de projection).
    
    
    2. Pour déplacer la théière, nous allons utiliser les matrices de transformation (mode MODELVIEW). Il nous faut donc dans un premier temps activer le mode de modification de matrice de transformation (ceci désactivera le mode de modification de matrice de projection que nous avions activé précédemment). Ceci est fait en ajoutant au programme la fonction:
       glMatrixMode (GL_MODELVIEW);
       Comment initialiser cette matrice de transformation? Une fois la fonction précédente ajoutée à votre programme, initialisez la matrice.
       Où est tracée la théière?
    
    
    3. Déplacez maintenant la théière en faisant la translation suivante:
       glTranslatef(-0.5,0.3,-100.);
       Vous pouvez constater que l'on ne voit plus la théière. Modifiez les plans "near" et "far" de votre projection pour que l'on voit à nouveau la théière.
       
    
    
    4. Appliquez maintenant dans le bon ordre les deux transformations suivantes pour obtenir le résultat présenté dans l'image ci-dessous.
       glScalef(2./3.,2./3., 2./3.);
       glRotatef (25.,0.,0.,1.);
       Représentez par un schéma les positions des repères scène et objet après chaque transformation.
       
  
  
  • Sur le résultat que nous venons d'obtenir, nous allons ajouter le tracé de la théière avec une matrice de projection perspective, dans une autre position et en filaire.
    
    
    1. Dans un premier temps, après avoir tracé la théière, redéfinissez la fenêtre de projection. Cette nouvelle fenêtre est carrée (500 pixels de côté) calée dans le coin en bas à droite.
       Puis, il faut définir une nouvelle matrice de projection. Pour l'instant, contentez vous de la matrice identité (qui comme on l'a vu est équivalente à une projection orthogonale).
       Enfin, tracez la théière dans sa position initiale (centre du repère scène).
       Affichez la théière en rouge.
       Donnez la séquence de fonction qui vous a permis d'afficher la deuxième théière.
       
    
    
    2. La projection de cette deuxième théière va être en perspective. Pour cela, ajoutez dans votre programme la fonction:
       gluPerspective(90.,2.,2.,100.);
       Donnez la signification de chacun de ses paramètres.
       Que se passe-t-il quand vous affichez? Pourquoi?
       Translatez la théière sur un seul axe pour qu'elle soit à nouveau visible dans son intégralité.
       Modifiez un paramètre dans la perspective pour que la théière soit affichée sans distorsion.
       Faites un schéma illustrant le repère scène, le repère objet et la pyramide de vision.
       
    
    
    3. Translatez la théière à différentes profondeurs. Que constatez-vous?
    
    
    4. Donnez et utilisez les fonctions de translation et de rotation pour amener la théière dans une position proche de celle illustrée dans l'image suivante:
       
    
    
    5. L'affichage par défaut est un mode plein. On peut passer en affichage filaire en utilisant la fonction:
       glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
       On peut repasser en mode plein avec les paramètres:
       glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
       Modifiez votre programme pour que la théière rouge soit affichée en filaire.
       Faites passer une fenêtre devant votre fenêtre OpenGL. Si la théière jaune est elle aussi tracée en filaire, modifiez votre programme pour que ce ne soit plus le cas.
       
       
    6. Modifiez les différentes valeurs de la matrice de projection perspective et observez ce qu'il se passe.