cours 2
10 pages
Français

cours 2

-

Le téléchargement nécessite un accès à la bibliothèque YouScribe
Tout savoir sur nos offres

Description

OpenGLProgrammation 3D avecOpenGLIUT informatique Johann Vandrommejohann.vandromme@lifl.frannée 2005-2006Cours 2• 1 – Les transformations• 2 – Le système de matrices• 3 – Les types de projection1 – Les transformations• Nous avons déjà abordé les transformations la fois dernière lorsdu TP (pour faire tourner le cube).• Il existe en 3D, trois fonctions de transformations :– La translation– La mise à l’échelle– La rotation1123Les transformations – la translation• Fonction :void glTranslatef (float transX, float transY, float transZ);• Déplace une forme de transX sur l’axe des x, de transY sur l’axedes y et de transZ sur l’axe des z.On ajoute à toutes les coordonnées x,9 y et z des points les valeurs de transX,transY et transZ7 xA + transXA’ = yA + transY3zA + transZ2 6 9 13Quels sont les paramètres du glTranslate dans cet exemple ?Quels sont les paramètres du glTranslate dans cet exemple ?Les transformations – la mise à l’échelle• Fonction :void glScalef (float factX, float factY, float factZ);• Agrandit la forme par les facteurs factX pour l’axe x, factY pourl’axe Y et factZ pour l’axe Z.2On multiplie chaque coordonnée x, y et1 z de points par les valeurs factX, factYet factZ.xA * factX11A’ = yA * factYzA * factZQuels sont les paramètres du glScale dans cet exemple ?Quels sont les paramètres du glScale dans cet exemple ?Les transformations – la rotation• Fonction :void glRotatef (float angle, float axeX, float axeY, ...

Sujets

Informations

Publié par
Nombre de lectures 26
Langue Français

Exrait

OpenGL
Programmation 3D avec OpenGL
IUT informatique Johann Vandromme johann.vandromme@lifl.fr année 20052006
1 – Les transformations 2 – Le système de matrices 3 – Les types de projection
Cours 2
1 – Les transformations
Nous avons déjà abordé les transformations la fois dernière lors du TP (pour faire tourner le cube).
Il existe en 3D, trois fonctions de transformations : La translation La mise à l’échelle La rotation
1
Les transformations – la translation
Fonction : void glTranslatef (float transX, float transY, float transZ); Déplace une forme de transX sur l’axe des x, de transY sur l’axe des y et de transZ sur l’axe des z.
9
7
3
On ajoute à toutes les coordonnées x, y et z des points les valeurs de transX, transY et transZ xA + transX A’ = yA + transY zA + transZ 2 6 9 13 Quels sont les paramètres du glTranslate dans cet exemple ?
Les transformations – la mise à l’échelle
Fonction : void glScalef (float factX, float factY, float factZ); Agrandit la forme par les facteurs factX pour l’axe x, factY pour l’axe Y et factZ pour l’axe Z.
1
1
2
1
On multiplie chaque coordonnée x, y et z de points par les valeurs factX, factY et factZ. xA * factX A’ = yA * factY zA * factZ
Quels sont les paramètres du glScale dans cet exemple ?
Les transformations – la rotation
Fonction : void glRotatef (float angle, float axeX, float axeY, float axeZ); Fait tourner la forme d’un angleangleautour de l’axe (axeX, axeY, axeZ). NOTA : le paramètre angle est exprimé en degré
Ex : rotation selon l’axe z:
A’
30°
A
A’ =
xA * cos(angle) – y * sin(angle) yA * sin (angle) + x cos (angle) zA
Quels sont les paramètres du glRotate dans cet exemple ?
2
Les matrices
Afin d’homogénéiser les calculs, les transformations sont regroupées dans des matrices que l’on multipliera entre elles afin de combiner les différentes transformations. Ex : La matrice d’homothétie :
factX 0 0
0 factY 0
0 0 factZ
*
x y z
=
x * factX y * factY z * factZ
La matrice de rotation selon l’axe x : cos(a) – sin(a) 0 x x * cos(a) – y * sin(a) cos(a) sin (a) 0 y  * =yA * sin (a) + x cos (a) 0 0 1 z zA
Translation
Comment mettre la translation sous forme de matrice ? Passage aux matrice 4 * 4 (matrices homogènes)
0 0 0 0
0 0 0 0
0 0 0 0
tx ty tz 1
 *
x y z 1
=
x + tx y + ty z + tz 1
Les points seront donc passés en coordonnées homogènes (4 coordonnées : x, y, z et w) Toutes les transformations passeront par des matrices 4*4 (matrices homogènes)
Composition de transformations
On peut maintenant composer les transformations en multipliant les matrices entre elles. Par exemple : glTranslatef (1, 0, 0); glRotatef (45, 0, 0, 1); glTranslatef (0, 1, 0); glScalef (2, 2, 2); dessine_Obj();
Composition des tranformations : Mglobale= Mt1* Mr* Mt2* Ms Calcul des nouveaux points de l’objet : {P’} = Mglobale* {P}
3
Quelques remarques
Dans ce système de matrice, la matrice « neutre » est la matrice identité 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
Lorsque l ’on défini une forme (ensemble de points), ils sont affecté par l ’ENSEMBLE des transformations se trouvant AVANT. Ex: Quelles transformations subira Obj1 ? glTranslatef (1, 0, 0); glRotatef (45, 0, 0, 1);Quelles transformations subira Obj2 ? dessineObj1(); glTranslatef (0, 1, 0); glScalef (2, 2, 2); dessineObj2();
ATTENTION : la multiplication de matrice n ’est pas (souvent ) commutative: Ma * Mb != Mb * Ma
Composition de transformations
Comment déterminer le résultat d’une composition de transformation ? Comment obtenir un résultat voulu par composition ?
Quelques fonctions utiles : glMatrixMode (GL_MODELVIEW) ; // détermine que la matrice que l ’on va modifier est la matrice de transformation (il existe d ’autres matrices que nous verrons plus tard) glLoadIdentity() // initialise la matrice courante (charge la matrice identité)
Remarque : les fonctions vues précédement (glRotatef / glTranslate / glScale) modifient la matrice courante; Il faudra toujours faire attention à ce que la matrice courante soit la MODELVIEW (pour l ’instant)
Exemples de composition
ex1 : une transformation simple (la fonction dessineSphere(float ray) dessine une sphère de rayon ray) // on va modifier la matrice de transformation glMatrixMode (GL_MODELVIEW) ; glLoadIdentity() ; glTranslatef (2, 0, 0) ; // sphère 1 dessineSphere(1) ; glTranslatef (0, 2, 0); //sphere 2 dessineSphere(1) ;
Quel est le résultat de ce code ?
4
Exemples de composition Rotation
Rotation / Translation
ex2 : glMatrixMode (GL_MODELVIEW) ; glLoadIdentity() ; // sphère 1 glutSolidSphere(0.5) ; glTranslatef (0, 2, 0); glRotatef (angleT, 0, 0, 1); //sphere 2 glutSolidSphere(0.5) ;
ex3 : glMatrixMode (GL_MODELVIEW) ; glLoadIdentity() ; // sphère 1 glutSolidSphere(0.5) ; glRotatef (angleT, 0, 0, 1); glTranslatef (0, 2, 0); //sphere 2 glutSolidSphere(0.5) ;
Résultat des ex2 et 3 ? Comment tourner autour d’un point quelconque ?
Composition :approximer un mouvement
Comment approximer un mouvement après une suite de transformations ? Il existe 2 manières d’aborder le problème :
1 – par repère global : on par de la fin, toutes les transformations sont faites par rapport à l’origine de la scène ; 2 – par repère local : on transforme le repère courant en fonction des différentes transformations successives (méthode à préférer). Ex 4: glLoadIdentity() Approximer le mouvement de la composition 4 glutSolidSphere (10) ; Par repère global; glRotatef (angleTS , 0, 0, 1) ; Par repère local. glTranslate(20, 0, 0) ; Comment déplacer cette scène ? glutSolidSphere(1) ; glRotatef (angleLT) ; glTranslatef (3, 0, 0) ; glutSolidSphere (0.3) ;
Composition :le problème de la mise à l’échelle
Un changement d’échelle modifie aussi le repère courant
glTranslate(1, 0, 0) glScale(2, 0, 0) glutSolidSphere(0.5) ;
glScale(2, 0, 0) glTranslate(1, 0, 0) glutSolidSphere(0.5) ;
Quelle est la différence entre ces 2 compositions ?
Attention : ce problème n’est pas directement identifiable avec la méthode par repère global. solution : mettre la mise à l’échelle comme dernière transformaition.
5
Composition :Problème de « relativité »
Reprenons maintenant notre système solaire : Ex 4: glLoadIdentity() // on place le système solaire ou on souhaite dans la galaxie gl…() //dessin du soleil glutSolidSphere (10) ; glRotatef (angleTS , 0, 0, 1) ; glTranslate(20, 0, 0) ; glutSolidSphere(1) ; glRotatef (angleLT) ; glTranslatef (3, 0, 0) ; glutSolidSphere (0.3) ;
Nous souhaitons maintenant modéliser mars (distance par rapport au soleil : 30). Problème : comment mettre mars en orbite autour du soleil ?
Placement relatif
Problème inverse : modélisons mars : glLoadIdentity() gl…() ; glutSolidSphere (10) ; glRotatef (angleMS , 0, 0, 1) ; glTranslate(30, 0, 0) ; glutSolidSphere (1) ; Comment modéliser la terre ? Une solution serait d’annuler les transformations occasionnées par le dessin de mars et ainsi, de « revenir » au repère du soleil pour ensuite pouvoir dessiner la terre et la lune.
Quel est alors le code nécessaire ?
Si on décide maintenant d’ajouter un satellite à mars, l’annulation des transformations risque de s’avérer plus difficile et coûteuse (en temps de calcul).
Placement relatif – LA solution
Pour palier à ce problème, OpenGL nous permet de sauvegarder et de restaurer des matrices de transformation. Le système choisi est le système des piles de matrices. On peut à tout moment sauvegarder une matrice de transformation avec un glPushMatrix(),qui place cette matrice au sommet d’une pile. Un appel à glPopMatrix() permet de « dépiler » la dernière matrice, c'estàdire, à retrouver la dernière matrice sauvegardée. (idem pour une pile d’assiettes : on empile les assiettes les unes au dessus des autres au sommet / lorsqu’on les dépile, on récupère la dernière assiette posée au sommet)
Quel est alors le code nécessaire ?
6
Placement relatif : LA solution
Remarque 1 : les push() et pop() peuvent être imbriqués. Remarque 2 : Il faut autant de push() que de pop() dans la fonction d’affichage.
Mettre en place le code pour créer un satellite géostationnaire.
Hiérarchie du système solaire
terre
Lune
Soleil
Mars
Où placer le satellite géostationnaire ?
Hiérarchie
2 - Projections
En revoyant le Tp 1, on peut remarquer que le cube créé n’est p as très fidèle à la réalité. Nous avons utilisé ici la projection parallèle : celleci cons iste à supprimer la composante Z afin que tous les points soient projetés perpendiculairement au plan. Cependant, cette vue est totalement irréaliste : elle est simplement utile pour les logiciels de modélisation en 3D.
7
Perpective
Dans la réalité, nous avons une notion de perspective, et de point de fuite. La projection en perspective conique permet ainsi à un objet éloigné d’être plus petit que s’il est proche.
Œil
Que se passe til pour un objet plus éloigné ?
D’où la notion de cône de vision
top
far
right
Cône de vision
Paramètres
La perspective est constituée de deux paramètres très importants : le plan de projection et la notion de distance focale. La distance focale est la distance entre le point de vue et le plan où est projeté le monde. C’est lui qui détermine le champs de vision : plus la focale est grande, plus le champs de vision est petit, et inversement. Le plan de projection joue aussi sur la vue : plus il est large, plus les objets seront petits et plus on pourra percevoir de choses. Ce plan de projection est très fortement lié à l’angle de champs de vision.
Champsde vision
Plan de projection
8
Commentcalculerlaperspective ?
Si on connait les paramètres de notre cone de vision, il sufit de projeter les points de leur position sur notre plan de projection.
near
Zone de projection
Xe
far
Zn
N
Xn
Z
On se rend compte que : Xe/Xn = near/Zn (ThalèsXe = (near*Xn)/Zn ; Idem pour Yn. Puis normalisation de 1/Zn
Matrice de projection
Comme pour les transformations, la projection est représentée sous forme matricielle Elle constituera la première multiplication du processus. Mperspective * Mtransformation * {P} ; La matrice de transformation est une matrice à part. Pour que la matrice courante soit la matrice de projection :
glMatrixMode (GL_PROJECTION) ;
Initialisation de la matrice de projection: glLoadIdentity();
Paramétrer la projection
2 fonctions différentes :
Void glFrustum ( GLdoubleleft, GLdoubleright, GLdoublebottom, GLdoubletop, GLdoublenear, GLdoublefar);
left
bottom
near
top
far
right
9
Paramétrer la projection
Alternative plus simple à utiliser Void gluPerspective (GLdoublefovy, GLdoubleaspect, GLdouble zNear, GLdoublezFar)
Observateur
near
fovy
far
10