![[ email ]](3demail2.gif)
OpenGL
OpenGL est une librairie proposant une interface pour le matériel graphique, permettant de produire des objets 2D ou 3D. C'est une abstraction entre le matériel graphique et les applications.
OpenGL est une API professionnelle de graphisme 2D/3D développée initialement par Silicon Graphics Inc. ( controlée de nos jours par un consortium industriel : ARB-OpenGL Architectural Review Board). Elle réalise une interface entre le matériel graphique installé sur la machine et l'application elle-même. Cela permet de faire abstraction du hardware, vu du coté du programmeur. Cette API est disponible sous divers systèmes d'exploitation tels que DOS, Windows, MacOS, AmigaOS, Linux/UNIX ou OS/2.
Le kit de développement OpenGL est constitué de deux ensembles : GL qui fournit les appels aux 120 fonctions OpenGL et Glu qui est une surcouche OpenGL fournissant des fonctions plus évoluées pour la gestion des caméras ou la création de surfaces Nurbs.
Les schémas ci-dessous représente la manière dont
l'interface hardware/application est réalisée au sein de
l'API.
On peut remarquer que tous les appels à OpenGL passent par un véritable PipeLine d'exécution, partant de vertices, jusqu'au frame buffer de la carte vidéo. Cette architecture est répercutée au niveau de l'utilisation de la librairie, notamment avec la gestion des matrices organisées autour d'une pile. OpenGL est une machine à état et chaque appel à une primitive de l'API contribue à modifier l'état courant. La quasi totalité des primitives agit soit sur des variables d'état de la machine, soit sur les matrices courantes. La pile sert donc à empiler ces états pour pouvoir les restituer plus tard ( glPushMatrix, glPushAttrib ).
Les objets 3D manipulés sont constitués d'un ensemble de vertices (sommets) que l'on définit entre deux appels à glBegin et glEnd ( placent la machine dans un état prêt pour recevoir cet ensemble de vertex ).
Un des objets OpenGL les plus importants et la displaylist qui permet d'encapsuler une séquence d'instruction OpenGL en vue d'être compilée en mémoire pour pouvoir être exécutée par la machine de façon optimale. Ainsi, dans notre programme, nous avons utilisé ces displaylists pour optimiser les performances d'affichage et stocker les vertices et autres (normales, coordonnées de mapping ) de chaque objet. Une fois que la liste est créée, elle est figée et ne peut plus être modifiée, elle est à l'intèrieur de la machine et il n'y a plus d'accés possible mise à part la demande d'exécution glCallList(indice). Lors de l'appel de la liste, la matrice courante est appliquée.
En permanence, nous avons accés à deux matrices GL_MODELVIEW_MATRIX qui représente la position du modèle dans le monde, GL_PROJECTION_MATRIX qui est la matrice qui définit la zone de projection du monde en tenant compte des plans de clipping et des paramètres de la caméra. Chaque appel à glRotate, glMultMatrix, glScale ou glTranslate effectue la multiplication entre la matrice courante et la matrice de la transformation générée par l'appel à la fonction. La matrice courante peut être changée par glMatrixMode ( permet de sélectionner MODELVIEW ou PROJECTION ) ou encore glLoadMatrix. La pile sert alors à sauvegarder l'état de la matrice pour la restituer ultérieurement.
Tous ces appels sont "assemblés" ( module primitive assembly ) et fournis à l'évaluateur qui va effectuer le rendu effectif en tenant compte de tous les paramètres de la machine.
![[ OpenGL ]](opengl.jpg){kind=small}
Pour expliquer les potentialités d'OpenGL je propose ci-dessous des mini-programmes, regroupés sous la bannière de glDino, mettant en oeuvre les différentes fonctionnalités d'OpenGL.
Bien que cette librairie présente des imperfections notables en ce qui concerne la gestion des évènements clavier et souris, on utilisera GLUT pour gérer l'interface avec le système d'exploitation, de façon à ce que l'ensemble des programmes soient portables sous tous les systèmes.
GLUT ( GL Utility Toolkit ) fournit une interface simple, portable et indépendante du système d'exploitation utilisé pour la réalisation d'interface et d'intéraction avec le matériel du type souris ou clavier. GLUT s'occupe de gérer les évènements qui peuvent survenir ainsi que la gestion d'une fenêtre d'affichage ( rafraichissement, etc... )
D'autres Toolkit sont également disponibles tels que aux, GLx (pour sytèmes Xwindows) ou Open Inventor qui est beaucoup plus évolué.
Dans un premier temps voyons l'ensemble des librairies nécessaires :
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> /* for cos(), sin(), and sqrt() */ #include <GL/glu.h> /* OpenGL Utility Library */ #include <GL/glut.h> /* OpenGL Utility Toolkit header */
On notera ici que que la librairie GL/gl.h est inclue implicitement par
GL/glu.h et GL/glut.h.
La structure d'un programme OpenGL écrit avec GLUT se presente à peu près toujours sous la même forme, la définition d'un ensemble de variables globales définissant les paramètres OpenGL et GLUT et un ensemble de fonctions standard :
static void draw(void); /* draw stuff here */ static void display(void); /* redraw */ static void init(); /* initialise OpenGL state machine */ static void menu(int value); /* menu managment */ static void mouse(int button, int state, int x, int y); /* mouse callback registration */ static void motion(int x, int y); static void keys(unsigned char c, int x, int y); /* key callback registration */ static void specialkeys(int c, int x, int y); static void idle(void); /* animation */ static void timer(void); static void reshape(GLsizei w, GLsizei h); /* window management */ static void entry(int state); static void visibility(int state);
Une fois vue la structure générale d'un programme OpenGL écrit avec GLUT, on va voire ici les différentes possibilitées qu'offre l'API OpenGL en elle-même.
L'ensemble du travail ci-dessous est basé sur les notes de Mark Kilgard (mjk@sgi.com) Silicon Graphics.
 |
Squelette GLUT.
Librairie de tracé d'un Dinosaure. |
 |
Animation du dino. |
 |
Exemple de réflection d'objets 3D en temps réel avec OpenGL. (Deux versions avec ou sans Stencil Buffer). |
 |
Implémentation de la boule virtuelle. |
 |
Implémentation d'une TrackBall avec la méthode des Quaternions. |
 |
Implémentation de la marche (pas de gestion des collisions). |
 |
Démonstration des possibilitées de texturage ( caustics ) d'OpenGL. |
 |
Implémentation d'une librairie décrivant les mouvemants
d'un vaisseau spatial, très utile pour l'écriture d'un simulateur
de vol.
Utilisation d'une librairie : view3ds permettant la convertion d'objets 3ds au format OpenGL. |
  |
Animation par squelette. |
Lens Flare
| Démonstration de Lens Flare. |
Particles
| Systèmes de particules. |
Grids
| Déformation de grilles. |
Multi
| Textures multi-passes. |
RealTimeShadow
| Les ombres portés en temps réel avec les fonctions "boundary tessellation" de glu.1.2. |
VisualizeLights
| Visualisation des lumières. |
TexFont
| Mapping de textes. |
InPlaceScaleAndBias
| Changer le contrast et la brillance d'une texture sans la recharger. |
TexShadowReflectLight
| Textures, éclairages, ombres portés et reflections en temps réel. |
Le but de ce projet est de réaliser une interface interactive de visualisation d'images médicales en trois dimensions. Pour nous, ces images sont issues de fichiers d'objets de divers formats (obj,asc,s3d,...), pouvant donner plusieurs objets à afficher simultanément. On doit pouvoir observer ces objets depuis n'importe quel point de vue. Ils peuvent être imbriqués les uns dans les autres: c'est pourquoi, on doit permettre d'en rendre certains transparents ou de ne pas les afficher du tout, pour pouvoir les visualiser facilement et très clairement. On doit également pouvoir effectuer des actions dessus, comme des transformations géométriques ou le changement des couleurs. La possibilité doit être laissée de sauvegarder les modifications ainsi faites.
Ce logiciel doit fonctionner sous différents systèmes d'exploitation: Windows95/NT, Linux, UNIX/Solaris ;OpenGL représente une bonne solution en terme de portabilité et permet le support des cartes accélératrices 3D ( 3DFX ou autres ...) pour gagner en rapidité.
Le logiciel est écrit en C et fut développé avec Visual C++ 4.0 pour la version Windows ainsi que gcc/xemacs/gdb pour la version UNIX.
Archives :
Mini-projet OpenGL : Animation par squelette. (linux)
Auteurs :
Notes techniques sur la hierarchie, la reflection, les ombres portes.
Version Windobe disponible.
