TD OpenGL

Introduction

• OpenGL est une API C (interface logicielle) 2D/3D.
• Elle a été développée en 1989 (GL) par Sillicon Graphics, puis portée sur d'autres architectures en 1993 (OpenGL)
• Avec OpenGL, on peut produire des images synthétiques sophistiquées (reflets, ombres) en temps réel si on dispose du hardware adéquat
• Existe sur de nombreuses architectures (NT, Unix, OS2, Amiga, etc...)
• Nombreuses implémentations (Exemple sous NT : SGI OpenGL, 3dfx OpenGL, Mesa, Microsoft OpenGL...)

Exercice 1: compilation d'un exemple

Nous allons utiliser la bibliothèque GLUT (GL Utility Toolkit) qui fournit plusieurs fonctions pour faciliter l'utilisation d'OpenGL.

GLUT n'est pas installé sur les stations,

1. chargez la sur http://www.xmission.com/~nate/glut.html (la version "-bin").
2. décompressez le fichier dans un de vos repertoires (par exemple Z:\glut)
3. dans Visual C++, indiquez dans le menu "Tools --> Options" que les fichiers d'entêtes (headers) dont vous allez avoir besoin sont dans Z:\glut
4. téléchargez le fichier exemple.c
5. compilez le en utilisant Visual C++ (un projet sera alors créé), (il vous faudra aussi indiquer où se situe la bibliothèque GLUT pour le "linkage", ou recopier cette bibliothèque dans le repertoire contenant exemple.c)
6. lancez l'exécutable créé (sûrement dans un répertoire DEBUG)

Les matrices dans OpenGL

Matrice MODELVIEW

• Passe les coordonnées des objets à dessiner (modèles) dans le repère de la caméra. Définit un repère !
• La position de la caméra est en général (0,0,0) donc la matrice MODELVIEW représente la position où sera dessiné le prochain objet.

Matrice PROJECTION

• Clippe les coordonnées des points et les projette

Division perspective

• Division par la coordonnée homogène w pour obtenir des coordonnées normalisées

Viewport transformation

• Passage en pixel pour dessin dans une partie d'une fenêtre graphique (viewport)

Il existe une "matrice courante" que l'on spécifie avec la commande glMatrixMode(GL_MODELVIEW) ou glMatrixMode(GL_PROJECTION)

En général on travaille tout le temps sur la matrice MODELVIEW sauf lorsqu'on doit modifier les paramètres intrinsèques de la caméra (focale, taille du viewport, etc...).

On peut multiplier la matrice courante par une matrice quelconque avec glMultMatrix.

La fonction glLoadIdentity() permet de reinitialiser la matrice courante à la matrice identité.

La Projection

• fovy : angle de vue (en degrés)
• aspect : ratio entre la largeur et la hauteur de la zone visible (viewport), c'est le champ de vision.
• znear : distance entre la caméra et le plan de projection
• zfar : distance entre la caméra et le plan au-dela duquel on ne dessinera plus les objets.

Seuls les objets situés entre les plans near et far seront dessinés (opération effectuée lors du cliping).

La caméra regarde l'axe des y.

Les Transformations

retour en haut

• glRotatef(α,x,y,z): rotation d'angle α, autour de l'axe passant par les points (0,0,0) et (x,y,z).
• glTranslatef(x,y,z): translation de vecteur (x,y,z)
• glScalef(x,y,z): étirement de facteurs (x,y,z).

Exercice 2

1. Déplacez la caméra (en cliquant dans les projections fixes sur la caméra), observez le résultat
2. Déplacez le plan de projection "near" (en utilisant la barre en bas à gauche), observez le résultat

Les objets de GLUT

• Le cube centré en (0,0,0), d'arête d:
  • glutWireCube(d) modèle fil de fer
  • glutSolidCube(d) modèle à facette
• La sphère centrée en (0,0,0), de rayon d:
  • glutWireSphere(d) modèle fil de fer
  • glutSolidSphere(d) modèle à facette
• et ainsi de suite: vous trouverez d'autres formes élémentaires sur la doc officielle, même une théière: glutSolidTeapot...

// on choisi la matrice courante 
   glMatrixMode(GL_MODELVIEW); 
// on la change en l'identité
   glLoadIdentity();
// si on veut faire tourner le cube autour de l'axe passant par
// (0,0,0) et (1,1,0)
   glRotatef(30,1.0,1.0,0.0);
// on translate le cube en (1,2,3))
   glTranslatef(1.0,2.0,3.0)
// on dessine le cube
   glutWireCube(0.8);

Les couleurs

les couleurs ont ici 3 composantes: R (rouge), V (vert), B (bleu), et sont positionnées avec glColor3f(R,V,B).

mais on peut en définir une 4eme pour la transparence, ainsi on pourra rendre les objets plus ou moins opaque pour voir plus ou moins à travers (fonction glColor4f).

Les fonctions de bases d'OpenGL

  // initialisation
  glutInit(&argc, argv); 

  // initialisation du mode d'affichage
  glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

  // taille et position de la fenetre de l'application
  glutInitWindowSize (250, 250);
  glutInitWindowPosition (100, 100);
  // creation de la fenêtre
  glutCreateWindow ("Exemple");

  // couleur du fond (ici: noir)
  glClearColor (0.0, 0.0, 0.0, 0.0);

  // positionnement du nom de la fonction permettant de dessiner le
  // contenu de la fenêtre
  glutDisplayFunc(display);

  // positionnement du nom de la fonction appelée lors du
  // redimensionnement de la fenêtre de l'appliquation
  glutReshapeFunc(reshape);

  // pour démarrer une boucle infinie (pour l'instant)
  glutMainLoop();

  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutMainLoop();

Gestion de la profondeur : z-Buffer

Exercice 3: z-buffer

1. Afficher un cube dessiné avec des facettes bleues, en perspective, centré en (2,2,2), avec les arêtes de longueur 1.
2. Afficher une sphère avec des facettes, centré en (2,2,2), de rayon 1.1 .
3. L'affichage vous paraît-il naturel ?
4. Pour gérer la profondeur, il faut utiliser l'algorithme du z-buffer et ainsi éliminer les parties qui devraient être cachées.
   Pour cela: ajouter "GLUT_DEPTH" au mode d'affichage:
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   
   Activer le z-buffer:
   glEnable(GL_DEPTH_TEST);
   
   Et avant chaque reaffichage (donc dans le fonction display), réinitialiser le buffer du z-buffer:
   glClear(GL_DEPTH_BUFFER_BIT);

Les primitives

Pour définir un point en 3D défini avec des coordonnées de type "float", il faut utiliser glVertex3f(x,y,z), où 3 pour 3 dimensions, f pour le typage, et x,y,z sont les coordonnées.

Des structures particulières peuvent être construites en utilisant des points définis par glVertex3f. On défini le type de structure et on délimite les points de cette structure par

• glBegin(mode) où mode décrit le type de structure
• glEnd() pour terminer la structure.

• GL_POINTS (des points)
• GL_LINES (des lignes)
• GL_LINE_STRIP (une ligne brisée)
• GL_LINE_LOOP (une ligne brisée fermée)
• GL_TRIANGLES (des triangles)
• GL_TRIANGLE_STRIP (groupe de triangles connectés)
• GL_TRIANGLE_FAN
• GL_QUADS (quadrilatères)
• GL_QUAD_STRIP (quadrilatères connectés)
• GL_POLYGON (polygone)

• Tracer un trait entre (0,0,0) et (1,0,0):

  glBegin(GL_LINES);
   glVertex3f(0,0,0);
   glVertex3f(1,0,0);
  glEnd();
      

• Tracer deux traits, un trait entre (0,0,0) et (1,0,0) et un entre (0,0,0) et (0,0,1):

  glBegin(GL_LINES);
   glVertex3f(0,0,0);
   glVertex3f(1,0,0);
   glVertex3f(0,0,0);
   glVertex3f(0,0,1);
  glEnd();
      

• Tracer un quadrilatère:

  glBegin(GL_QUADS);
   glVertex3f(0,0,0);
   glVertex3f(1,0,0);
   glVertex3f(0,1,0);
   glVertex3f(0,0,1);
  glEnd();
      

Exercice 4 : Tracé du repère

1. Faites afficher le repère de l'espace en utilisant la primitive GL_LINES, en utilisant une couleur différente pour chaque axe (on reculera la caméra pour pouvoir observer l'origine du repère)
2. Afficher un cube centré en O, ayant subi une rotation.

Exercice 5 : Gestion du clavier

pour utiliser les touches du clavier, il suffit de définir une fonction (par exemple "key") donc l'entête est static void key(unsigned char c, int x, int y) où c correspondra au caractère tapé.

Il n'y a plus qu'à déclarer dans le "main" le nom de la fonction en charge de caractères tapés au clavier ainsi: glutKeyboardFunc(key); Pour forcer à redessiner la scène, il faut utiliser la fonction glutPostRedisplay();
Exemple

1. reprenez l'exercice précédent, et modifiez le code pour que lorsque qu'on appuie sur la touche 'a', le cube tourne sur lui même (selon l'axe que vous voulez); bien entendu le repère ne devra pas bouger
2. ajouter une touche pour déplacer le cube
3. ajouter une touche pour passer en mode fil de fer (avec glPolygonMode(GL_FRONT_AND_BACK, GL_LINES); )
4. ajouter une touche pour passer en mode facettes (avec glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);)

La transparence (blending)

OpenGL permet d'afficher un objet avec composition de la couleur de chacun de ses pixels avec la couleur du pixel déjà présent dans l'image à cette place -> transparence.

Le niveau de transparence est considéré comme une composante supplémentaire de la couleur, elle peut être définie avec glColor4f(R,V,B,alpha) où alpha désigne le niveau de transparensce entre 0 et 1.

• Activation du la gestion de la transparence: glEnable(GL_BLEND);
• Choix de l'artihmétique de composition:glBlendFunc(GLenum sfactor,GLenum dfactor);

• on garde 1-alpha du pixel présent et on ajoute alpha du pixel calculé
• objet non transparent avec alpha = 1
• objet transparent avec alpha = 0.

ATTENTION: La composition entre les pixels présents et placés implique que l'ordre de dessin des objets graphiques a une influence sur l'image finale.

Exercice 6

1. Dans le programme avec le cube et la sphère, rendez la sphère à moitié transparente
2. changer l'ordre de dessin du cube et de la sphère, que ce passe-t-il ?

Lissage

Le lissage permet d'attenuer l'aspect des facettes des objets en modes facettes.

Exercice 7

Eclairage

L'activation de l'éclairage se fait grâce à glEnable(GL_LIGHTING);

Les lumières

   float blanc[4] = { 1.0,1.0,1.0,1.0 };
   float noir[4]  = { 0.0,0.0,0.0,1.0 };
   glLightfv(GL_LIGHT0, GL_DIFFUSE, blanc);// couleur de lumière diffuse
   glLightfv(GL_LIGHT0, GL_AMBIENT, noir); // couleur de lumière ambiante

Pour donner la position de la lumière 0: glLightfv(GL_LIGHT0,GL_POSITION,light0_pos);

Pour allumer la lumière 0: glEnable(GL_LIGHT0);.
Pour éteindre la lumière 0: glDisable(GL_LIGHT0);.

Les matériaux

Il faut définir le type de surface de chaque objet afin d'en déterminer les propriétés reflectrices.
Pour simplifier, utilisez:

Textures

L'opération de texturage consiste à recouvrir un objet d'une image pour donner l'impression que cet objet est constitué du matériel représenté sur l'image (du bois, du marbre, ...).

L'intérêt du texturage est que cette technique permet de créer de manière simple des détails sur les objets qu'il aurait fallu autrement modéliser au moyen de surfaces. Les modèles restent géométriquement simples et rapide d'affichage avec une qualité d'affichage qui être bonne ou même excellente.

1. spécification de la texture,
2. spécification de la technique à utiliser pour appliquer la texture à chaque pixel,
3. autorisation du plaquage,
4. dessin de la scène qui sera implicitement texturée au moyen des paramètres définis en (1) et (2).

L'ombrage (ray-tracing)

Le principal algorithme permettant d'obtenir des effets d'ombre sur les objets est le lancer de rayons (ray tracing, Appel(1968), Whitted(1980)). Dans sa formulation sommaire, le principe est le suivant :

Pour chaque point de l'écran (plan de projection),

1. on détermine les points d'intersection entre les facettes de l'objet 3D et le rayon visuel. Parmi tous les points obtenus, on retient celui qui est le plus proche de l'observateur.
2. On trace un rayon secondaire allant de ce point vers une source lumineuse Si. Si ce rayon intercepte une facette, on considère que le point P est ombré, sinon il est pleinement éclairé. Il faut évidemment refaire cette opération pour toutes les autres sources lumineuses.

En fait, un rayon lumineux ne se réfléchit pas seulement, il se transmet. Il faut donc tenir compte à la fois de la réflexion ( lumière spéculaire) et de la réfraction (lumière transmise). On est alors conduit à raffiner l'algorithme précédent en tenant compte pour toutes les intersections de la lumière réfléchie et de la lumière transmise.

Sélection souris (picking)