cours 2

Vandromme

Description

OpenGLProgrammation 3D avecOpenGLIUT informatique Johann [e-mail]é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

• informatique

Informations

• Publié par: Feduh
• Nombre de lectures: 26
• Langue: Français

Extrait

OpenGL

Programmation 3D avec OpenGL

IUT informatique Johann Vandromme [e-mail] 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 : M globale = M t1 * M r * M t2 * M s Calcul des nouveaux points de l’objet : {P’} = M globale * {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