Définition des besoins

• Prototype papier
• Besoins fonctionnels
• Besoins non fonctionnels
• Plate-forme cible et de développement
• Analyse des risques
• Lexique

1- Prototype papier

2- Besoins fonctionnels

Les fonctionnalités de la bibliothèque graphique doivent êtres les suivantes :

• Tracé: points, lignes, triangles avec remplissage.
• Projection perspective avec clipping par rapport â un frustum.
• Transformations standards sur les points : translation, rotation, scaling.
• Gestion de la caméra.
• Eclairage: flat et gouraud avec une seule source de lumière.
• Culling en window coordinate pour éviter des tracés supplémentaires.

• Vertex arrays (VertexPointer, NormalPointer, ColorPointer.
• Viewport.

• Enable(mode)/Disable(Mode)
  mode = DEPTH | CULLFACE...

• Begin(mode)
  mode = POINTS | LINES | LINE_STRIP | LINE_LOOP | TRIANGLES

• ArrayElement, DrawArrays, DrawElements.
• Zbuffer
• Gestion des materiaux

• Gestion de la lumière dans des modes particuliers : diffuse, specular, ambiant lighting (Light, LightModel)
• Sous ensemble de glut (OpenGL Utility Library) pour créer facilement les fenêtres (grâce â l'utilisation de CLX).

• Vertex(x, y, z, w) : définition d'un point dans le repère, où x, y, z et w sont ses coordonnées.

• Normal(nx, ny, nz) : définie un vecteur normal.

• Color(r, g, b, a) : définie la couleur courante, avec les valeurs RGB et Alpha, cette dernière ne sera pas utilisé dans notre implémentation.

• Les normales et l'éclairage sont effectués en eye coordinates.
• Le clipping est effectué en clip coordinates
• Le culling est effectué en window coordinates

Il y a deux matrices courantes, matrices globales permettant toutes les opérations :

• une matrice de projection.
• une matrice modelview (ou une pile de matrices modelview pour gérer les objets hierarchiques).

• MatrixMode(mode) : changement de la matrice courante
  mode = MODELVIEW | PROJECTION

• LoadIdentity() : la matrice courante devient la matrice identité.
• LoadMatrix(mat) : la matrice courante est remplacée par la matrice passée en paramètre.
• Rotate(angle, x, y, z) : la matrice courante est multipliee par la matrice de rotation d'angle 'angle' autour de la droite passant par les points (0,0,0) et (x,y,z).
• Translate(tx, ty, tz) : multiplie la matrice courante par la matrice de translation pour une translation de vecteur (tx, ty, tz).
• Scale(sx, sy, sz) : multiplie la matrice courante par la matrice de scaling sx en X, sy en Y en sz en Z.

• LookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz) : la camera est placee au point (eyex, eyey, eyez), pointe vers un point de reference (centerx, centery, centerz) et le vecteur (upx, upy, upz) indique quelle direction est le haut.

• Frustum(left, right, bottom, top, near, far) : left, right, bottom et top définissent les plans limitant la vue â gauche, â droite, dessous et en haut. Near et far spécifient la distance â partir de laquelle les objets trop près et trop loin pour êtres vus.

• Perspective(fovy, aspect, near, far) : défini le même type d'objet, non pas â partir de plans mais â partir de deux angles de vision fovy et aspect respectivement liés aux axes y et x. near et far sont utilisés de la même façon que pour l'opération précédente.

• Viewport(x, y, w, h): le trace s'effectue dans le cadre défini par les points (en pixels) (x,y) et (x+w, y+h).

Le viewport permet d'avoir plusieurs vues d'un meme objet observé sous des angles différents, comme le font les modeleurs 3D.

3- Besoins non fonctionnels

La plupart des opérations précédentes utilisent des opérations mathématiques sur des vecteurs et des matrices. Cette bibliothèque donnant les bases de toute l'application, doit être particulièrement optimisée, en effet la contrainte la plus importante du projet est celle de la vitesse. Le temps de calcul doit donc être minimisé au niveau de la partie mathématique. En effet les transformations effectuées sur les points (Figure 1.) montrent toutes les multiplications matrices-vecteurs produites pour un seul affichage.

Cette bibliothèque sera composée des opérations suivantes :

• Vecteurs : addition, soustraction, négation, produit scalaire, produit vectoriel, ...
• Matrices : addition, multiplication, inverse, multiplication par un vecteur, ...

L'implémentation d'OpenGL (en C) génère dans certains cas une erreur si des arguments passés aux fonctions sont incorrects. Il est alors â la charge du programmeur d'appeler glGet() pour savoir si une erreur s'est produite ou pas. En Lisp, les avantages sont déjâ importants, il sera possible d'utiliser les mécanismes d'exceptions (conditions) pou systématiquement signaler les erreurs â la compilation.

Avec OpenGL, les primitives de tracé ne sont valides que dans un bloc Begin()/End(), ainsi qu'un certain nombre d'autres informations relatives â chaque vertex (couleur, normale, ...). Une macro lisp utilisée pour les blocs Begin/End d'OpenGL nous permet de vérifier *â la compilation* plutôt qu'â l'exécution la validité du corps du bloc : c'est une source d'erreur en moins pour le programmeur.

4- Plate-forme cible et de développement

L'objectif est de faire tourner l'application sur un PC ayant CMU CL, et donc tournant sous Linux ou Unix.
Aucune accelération matérielle n'est envisagée ou requise.

5- Analyse des risques

Le principal risque va être dû â l'utilisation de la bibliothèque CLX. Cette bibliothèque pose de nombreux problèmes, elle est de réalisation assez ancienne (1988-1989), et l'évolution de l'environnement X soulève de nombreuses questions. Nous ne savons pas si CLX sera totalement optimisée, ce qui rend dépendante la contrainte sur la vitesse d'exécution du projet.

Le projet en lui-même ne pose pas de problème de développement (projet trop important, ou trop court). En effet, une fois le noyau mathématique réalisé et les primitives de bases réalisées, la programmation se fera de manière incrémentielle. De cette façon, avec le langage Common LISP, les fonctions pourront en plus êtres testées au fur et â mesure. Nous pourrons donc avoir â la fin du projet un ensemble de fonctionnalités valide et utilisable.

6- Lexique

• Frustum : il s'agit du volume de vision de notre monde 3d. Un frustum est en français une pyramide tronquee par des plans. Tous les objets â l'intérieur de ce plan sont visibles, ceux partiellement a l'intérieur sont découpés (i.e. clippes) par rapport a un ou plusieurs des 6 plans du frustum. Les objets â l'extérieur du frustum ne sont pas visible du tout. La base de la pyramide est appelé plan de coupe arrière (far clipping plane) et le plan parallèle au plan de coupe arrière et qui tronque la pyramide est le plan de coupe avant (near clipping plane).

• Clipping : c'est l'opération qui consiste â supprimer les objets et parties d'objets qui ne doivent pas être affichées.

• Flat : il s'agit du mode d'éclairage le plus simple où chaque triangle est de couleur unie, l'intensité de la couleur étant déterminée par l'angle entre un vecteur représentant la source de lumière et le vecteur normal â la face (triangle).

• Gouraud : c'est un mode d'éclairage qui effectue un dégradé lisse (smooth) des couleur d'un point (vertex) â un autre par interpolation linéaire.

• Culling : un triangle a toujours une orientation de ses sommets. S'ils sont ordonné dans le sens des aiguilles d'une montre l'ordre est dit clockwise (CW) et front-facing sinon ils sont CCW (counter clock-wise) et back-facing. Le (backface) culling est le fait d'éliminer certains triangles du traçage si on sait déterminer lesquels sont visibles des autres. On peut le savoir suivant le signe de l'aire du triangle calculée en window coordinates (c'est a dire au stade final des transformations, lorsqu'on le point â afficher en coordonnées x et y).

accueil