transformations multiples

Version imprimable

14/05/2006, 12h27
Trunks

transformations multiples

Bonjour,

Je suis débutant en OpenGL et j'ai un peu de mal à restituer le mouvement d'un objet dans un scene (qui sera éventuellement une caméra).

Pour cela, j'applique à l'objet des transformations multiples (rotations horizontale, et verticale, translations avant et arrière). Vu que l'ordre des transformations a une importance (une rotation horizontale puis une rotation verticale étant différent d'une rotation verticale puis une rotation horizontale), il faudrait que je puisse enregistrer la matrice de transformation appliqué à l'objet que je puisse ajouter la nouvelle matrice de transformation par la suite et ainsi de suite.

Concrètement, je dessine la scène dans la fonction display() que je place entre glPushMatrix() et glPopMatrix() afin d'isoler les transformations. Puis je place mon objet (un rectangle) sur lequel j'applique une translation pour positionner l'objet (où il se trouve après la dernière transformation), puis la nouvelle transformation (composé de translation et rotations) lors j'appuie sur les touches correspondant à ces transformations. Cependant, vu que j'applique une rotation horizontale et une autre verticale, ça pose problème. En effet, je dois respecter l'ordre dans lesquels ils ont été appliqués. Pour celà, je dois récupérer l'ancienne matrice de transformation pour celà, mais je en sais pas comment faire. Avec glPushMatrix()? ... comment faire? Faut-il utiliser une autre approche?

Je vous remercie d'avance pour votre aide.
14/05/2006, 12h48
Trunks

En parcourant un tutoriel que j'ai trouvé sur le net, je me suis rendu compte que je pouvais utiliser glLoadIdentity(); à la place de glPushMatrix() et glPopMatrix() pour englober ma scène. Il me reste cependant encore mon problème...
14/05/2006, 19h55
Omfraax

En fait, pour le moment, tu multiplie à cahque fois par une matrice quand t'appuie sur une touche.

Et si tu mettais tes deux glRotatef dans le bon ordre au sein de ta fonction display, laissant des variables pour les angles, et tu modifies alors seulement ces variables lors de l'appui sur les touches. Ainsi, tes transformations seront toujours utilisées dans le bon ordre...
14/05/2006, 21h01
Trunks

Imaginons que je fasse une rotation horizontale de 10°, puis une autre verticale de 30°, puis une verticale de -65° et enfin une horzontale de 35. Ca ne revient pas a faire une rotation horizontale de 45° et verticale de -35°, ni en inversant ces 2 rotations. Alors comment faire dans ce cas là?
15/05/2006, 12h57
Omfraax

Mais qu'est ce que tu veux au juste?

Admettons que tu sois dans une position quelconque et que tu veuilles bouger.
Tu veux bouger par rapport aux axes du monde(fixes) ou aux axes de ton objet?

J'ai peut être du mal à expliquer. Voici un exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#include <GL/glut.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <math.h> 
 
static int spin_h = 0; 
static int spin_v = 0; 
static GLfloat pos_x = 0.0; 
static GLfloat pos_y = 0.0; 
static GLfloat pos_z = 0.0; 
 
void init(void)  
{ 
   glClearColor (0.0, 0.0, 0.0, 0.0); 
   glShadeModel (GL_SMOOTH); 
   /*glEnable(GL_LIGHTING); 
   glEnable(GL_LIGHT0); 
   glEnable(GL_DEPTH_TEST);*/ 
} 
 
void display(void) 
{ 
   GLfloat position[] = { 0.0, 0.0, 1.5, 1.0 }; 
 
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
 
   //glPushMatrix ();
 
   glLoadIdentity();
   //gluLookAt (pos_x, pos_y , pos_z, pos_x - sin((spin_h * (2 * M_PI)) / 360.0) * cos((spin_v * (2 * M_PI)) / 360.0), pos_y + sin((spin_v * (2 * M_PI)) / 360.0), pos_z - cos((spin_h * (2 * M_PI)) / 360.0) * cos((spin_v * (2 * M_PI)) / 360.0), 0.0, 1.0, 0.0);
   // La caméra
   glPushMatrix ();
 
   glTranslated (pos_x, pos_y, pos_z);
 
   glRotatef((GLdouble) spin_h, 0.0, 1.0, 0.0);
   glRotatef((GLdouble) spin_v, 1.0, 0.0, 0.0);
 
   glTranslated (0.0, 0.0, -1.0);
   glScalef (1.0, 1.0, 2.0); 
   glutWireCube (1.0); 
   glTranslated (0.0, 0.45, -0.45);
   glScalef (0.1, 0.1, 0.1); 
   glutWireCube (1.0);
   glPopMatrix();
 
   glTranslated (0.0, 0.0, -20.0);
 
   // La maison
   glPushMatrix ();
   glScalef(10.0, 6.0, 3.0); 
   glutWireCube (1.0);
   glPopMatrix();
 
   // La fenêtre 
   glTranslated (3.0, 1.0, -1.3);
   glScalef(2.0, 2.0, 0.2); 
   glutWireCube (1.0);
   //glPopMatrix();
 
   glFlush (); 
} 
 
void reshape (int w, int h) 
{ 
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION); 
   glLoadIdentity(); 
   gluPerspective(45.0, (GLfloat) w/(GLfloat) h, 1.0, 100.0); 
   glMatrixMode(GL_MODELVIEW); 
   glLoadIdentity(); 
} 
 
void mouse(int button, int state, int x, int y) 
{ 
   switch (button)
   { 
      case GLUT_LEFT_BUTTON: 
         if (state == GLUT_DOWN)
         { 
            spin_h = (spin_h - 10) % 360; 
            glutPostRedisplay(); 
         } 
         break; 
      case GLUT_RIGHT_BUTTON: 
         if (state == GLUT_DOWN)
         { 
            spin_h = (spin_h + 10) % 360; 
            glutPostRedisplay(); 
         } 
         break; 
      default: 
         break; 
   } 
} 
 
void keyboard(unsigned char key, int x, int y) 
{ 
   switch (key)
   {
      case 'r':
         pos_x = 0.0;
         pos_y = 0.0;
         pos_z = 0.0;
         spin_h = 0;
         spin_v = 0; 
         glutPostRedisplay();
         break;
 
      case 'q':
         spin_h = (spin_h + 10) % 360; 
         glutPostRedisplay();
         break;
 
      case 'd':
         spin_h = (spin_h - 10) % 360; 
         glutPostRedisplay();
         break;
 
      case 'a':
         spin_v = (spin_v + 10) % 360; 
         glutPostRedisplay();
         break;
 
      case 'e':
         spin_v = (spin_v - 10) % 360; 
         glutPostRedisplay();
         break;
 
      case 's':
         pos_x += sin((spin_h * (2 * M_PI)) / 360.0) * cos((spin_v * (2 * M_PI)) / 360.0);
         pos_y -= sin((spin_v * (2 * M_PI)) / 360.0);
         pos_z += cos((spin_h * (2 * M_PI)) / 360.0) * cos((spin_v * (2 * M_PI)) / 360.0); 
         glutPostRedisplay();
         break;
 
      case 'z':
         pos_x -= sin((spin_h * (2 * M_PI)) / 360.0) * cos((spin_v * (2 * M_PI)) / 360.0);
         pos_y += sin((spin_v * (2 * M_PI)) / 360.0);
         pos_z -= cos((spin_h * (2 * M_PI)) / 360.0) * cos((spin_v * (2 * M_PI)) / 360.0); 
         glutPostRedisplay();
         break;
 
      case 27: 
         exit(0); 
         break; 
   } 
} 
 
int main(int argc, char** argv) 
{ 
   glutInit(&argc, argv); 
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); 
   glutInitWindowSize (500, 500);  
   glutInitWindowPosition (100, 100); 
   glutCreateWindow (argv[0]); 
   init (); 
   glutDisplayFunc(display);  
   glutReshapeFunc(reshape); 
   glutMouseFunc(mouse); 
   glutKeyboardFunc(keyboard); 
   glutMainLoop(); 
   return 0; 
}

Dans un premier temps, j'ai désactivé la caméra (gluLookAt en commentaire). Avance la caméra (le rectangle, la vue reste figée pour l'exemple).
Puis fais une rotation verticale en appuyant sur 'a'. ET enfin une rotation horisontale en appuyant sur 'q'. Alors la caméra ne bouge pas selon son axe horizontale, mais par rapport à celui du plan (normal car la rotation horizontale est appelée avant celle verticale). Si j'inverse l'ordre des 2 rotations, j'ai un problème analogue dans l'autre sens. Si je choisis l'ordre par rapport a la derniere rotation, ça ne marche pas non plus (car AB != BA).
J'ai donc pensé, a sauvegarder la derniere matice de transformation pour la caméra, puis appliquer la nouvelle transformation en multipliant la nouvelle matrice par la matrice sauvegardée. AInsi l'orientation du plan devrait être bon et ainsi obtenir le résultat souhaité.

J'espère avoir été clair cette fois-ci avec l'exemple a l'appui

17/05/2006, 12h07
Omfraax
Tu veux donc à chaque fois bouger selon les axes de ton objet, un peu comme on contrôlerait un avion ?

Dans ce cas là, il me semble alors qu'il faille multiplier par la matice correspondante à chaque appui sur une touche et désactiver le glLoadIdentity dans ta fonction display.
(Evidemment, c'est l'identité qui sera chargée initialement)

par exemple, le code d'une touche:
Code:

1 2 3 4 5 case 'a': glRotatef(10,0,1,0); glutPostRedisplay(); break;
19/05/2006, 19h15
Trunks

Merci Omfraax pour ta réponse, je ne m'y attendait plus.
Si je ne me trompe pas, si j'utilise ta solution, ça bougera l'axe du plan, de la scène entière, et moi je souhaiterais isoler la transformation à un seul objet de la scène. :oops:

Désolé, j'ai encore un peu de mal, j'espère avec m'être débloqué de ce problèmeça ira mieux.

Ben, en jouant sur les glPushMatrix et glPopMatrix, je crois qu'on peut s'en tirer.
Le truc, c'est de garder en bas de la pile notre matrice qu'on trafique.

Donc, par exemple, un pseudocode de display:
Code:

1 2 3 4 5 6 7 8 //à ce stade, la matrice est celle de "travail" affichage cube glPushMatrix(); glLoadIdentity(); // on retourne à l'origine pour placer les autres objets affichage autres objets glPopMatrix(); // on revient sur notre matrice "de travail"

19/05/2006, 20h34
Trunks

Hum c'est pas une mauvaise idée. Merci pour ton idée, je vais essayer !
C'est dommage qu'il n'y ait pas de solution plus simple, imaginons qu'on veule modéliser un défilé d'avions, dans ce cas là, il y aura plusieurs objets de la scènes à modifier, dans ce cas-là, ta solution en marcherait plus. Je sais je titille, mais c'est dans un soucis de perfection et pour éviter un problème qui viendra à un moment où un autre.

EN attendant, je te remercie beaucoup pour l'aide que tu m'as apporté.
19/05/2006, 21h42
Omfraax

Hum, d'un autre, côté, on serait toujours en train de modifier un seul avion en même temps, donc ça serait peut-être jouable, mais je préfère pas y réfléchir pour l'instant.
Donne-moi des nouvelles de ton truc pour savoir si ça marche ;)
PS: Et puis, c'est pas si compliqué, si on réussit à s'en tirer sans avoir à extraire soi-même les matrices pour les stocker et/ou les multiplier à la main...

Bon ta solution fonctionne bien ! Merci je n'y avait pas pensé ! Et en plus elle est plus simple, ça m'évite les calculs complexes sur les matrices que j'avais utilisé pour replacé l'élément dans la scène !!!

Voici le code si tu veux tester :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include <GL/glut.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <math.h> 
 
void init(void)  
{ 
   glClearColor(0.0, 0.0, 0.0, 0.0); 
   glShadeModel(GL_SMOOTH); 
} 
 
void display(void) 
{ 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
 
   gluLookAt(0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0);
 
   glPushMatrix(); 
      glMatrixMode(GL_MODELVIEW); 
      glLoadIdentity();
 
      glTranslated(0.0, 0.0, -20.0);
 
      // La maison
      glPushMatrix();
         glScalef(10.0, 6.0, 3.0); 
         glutWireCube(1.0);
      glPopMatrix();
 
      // La fenêtre
      glPushMatrix(); 
         glTranslated(3.0, 1.0, -1.3);
         glScalef(2.0, 2.0, 0.2); 
         glutWireCube(1.0);
      glPopMatrix();
   glPopMatrix();
 
   // La caméra
   glPushMatrix();
      glTranslated(0.0, 0.0, -1.0);
 
      glPushMatrix();
         glScalef(1.0, 1.0, 2.0); 
         glutWireCube(1.0);
      glPopMatrix(); 
 
      glPushMatrix();
         glTranslated(0.0, 0.45, -0.95);
         glScalef(0.1, 0.1, 0.1); 
         glutWireCube(1.0);
      glPopMatrix();
   glPopMatrix();
 
   glFlush(); 
} 
 
void reshape(int w, int h) 
{ 
   glViewport(0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode(GL_PROJECTION); 
   glLoadIdentity(); 
   gluPerspective(45.0, (GLfloat) w/(GLfloat) h, 1.0, 100.0); 
   glMatrixMode(GL_MODELVIEW); 
   glLoadIdentity(); 
} 
 
void keyboard(unsigned char key, int x, int y) 
{ 
   switch (key)
   { 
      case 'q':
         glRotatef(10.0, 0.0, 1.0, 0.0); 
         glutPostRedisplay();
         break;
 
      case 'd':
         glRotatef(-10.0, 0.0, 1.0, 0.0); 
         glutPostRedisplay();
         break;
 
      case 'a':
         glRotatef(10.0, 1.0, 0.0, 0.0); 
         glutPostRedisplay();
         break;
 
      case 'e':
         glRotatef(-10.0, 1.0, 0.0, 0.0); 
         glutPostRedisplay();
         break;
 
      case 's':
         glTranslated (0.0, 0.0, 1.0); 
         glutPostRedisplay();
         break;
 
      case 'z':
         glTranslated (0.0, 0.0, -1.0); 
         glutPostRedisplay();
         break;
 
      case 27: 
         exit(0); 
         break; 
   } 
} 
 
int main(int argc, char** argv) 
{ 
   glutInit(&argc, argv); 
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); 
   glutInitWindowSize(500, 500);  
   glutInitWindowPosition(100, 100); 
   glutCreateWindow(argv[0]); 
   init(); 
   glutDisplayFunc(display);  
   glutReshapeFunc(reshape); 
   glutKeyboardFunc(keyboard); 
   glutMainLoop(); 
   return 0; 
}

Cependant, si je veux faire déplacer 2 objets différents de façon analogue, comment tu ferais? (soit l'un, soit l'autre).

Merci encore.

20/05/2006, 01h08
Trunks

Bon, j'ai pas encore compris exactement comment celà fonctionnait exactement, pourquoi ça marche ...
Toutefois un problème persiste. Avec la matière que j'ai fait, je ne peux plus bouger la caméra de l'origine, sinon l'axe de rotation se trouve également changé :?
Décidément, j'ai du mal ...
20/05/2006, 11h23
Omfraax

Je pensais que pour le moment, le mouvement de ton objet simulait plus ou moins un mouvement de caméra...

Quelle idée a-tu vraiment derrière la tête, parce que tu ne penses surement pas à bouger un cube, mais probablement à un truc genre avion, etc...
Comprendre quel effet tu veux vraiment rendre (caméra subjective/objective, ce genre de truc...) m'aiderait peut-être un peu ?;)
20/05/2006, 15h28
Trunks

Merci Omfraax pour ta précieuse aide !