Discussion :

[AeroMax]

Bonjour,

Je suis tombé sur le problème du gimbal lock en voulant déplacer ma caméra à l'aide de 2 glRotate suivant l'axe X et l'axe Y: il s'effectue une rotation en Z qui n'est pas voulue... Aprés avoir lu le faq et plusieurs sites web traitant de la chose, j'ai implémanté les quaternions, mais malheureusement le résultat est éxactement le même. Mon implémentation des quaternions semblent bien fonctionnée. Par contre je ne sais si j'applique correctement la méthode: j'obtient 2 angles de rotations fonction de la position de ma souris que j'associe respectivement à leur axe de rotation. Je les transforme ensuite tous 2 en quaternions que je multiplie entre eux, puis je retransforme le quaternion résultat en axe et angle de rotation. Je passe cet axe et cet angle à un glRotate. Résultat: la rotation selon l'axe Z persiste! J'ai tenté de transformer le resultat de la multiplication en matrice[16] et de la passer à openGL avec un glMultMatrix mais le résultat est le même...

Voici le code c pour positionner ma caméra:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void initCamera() {
	glMatrixMode(GL_MODELVIEW);
	gluLookAt(20.0,20.0,20.0,0.0,0.0,0.0,0.0,1.0,0.0);
	printf("Initialisation caméra\n");
}
 
void affichage() {
 
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	//Z-buffer
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);
 
	/*On place la caméra*/
	if(init==INIT) {
		initCamera();
		init=NOINIT;
	} else {
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		AxisAngle* rotX=createAxisAngle(1.0,0.0,0.0,ryVue);
		AxisAngle* rotY=createAxisAngle(0.0,1.0,0.0,rxVue);
		Quaternion* qtX=quaternionFromAxisAngle(rotX);
		Quaternion* qtY=quaternionFromAxisAngle(rotY);
		Quaternion* multXY=quaternionMult(qtY,qtX);
		AxisAngle* resultRot=axisAngleFromQuaternion(multXY);
		glRotatef(resultRot->angle,resultRot->x,resultRot->y,resultRot->z);
		glTranslatef(xVue,yVue,zVue);
		glMultMatrixd(matModelview);
		rxVue=0;
		ryVue=0;
		rzVue=0;
		zVue=0;
		xVue=0;
		yVue=0;
	}
 
	glutWarpPointer(glutGet(GLUT_WINDOW_WIDTH)/2, glutGet(GLUT_WINDOW_HEIGHT)/2);
 
	/*On défini comment on projette la scéne sur le plan*/
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(40.0,1.5,10.0,100.0);
        ...
}

Dans mon code il faut savoir que matModelview est la sauvegarde de l'ancienne matrice MODELVIEW; Je multiplie donc les transformations de la caméra à gauche de l'ancienne modelview.
Pouvez-vous m'expliquer pourquoi le gimbal lock persiste?

[acx01b]

salut je sais pas si ça te suffirais mais moi j'utilise glulookat (je trouve ça plus simple que les quaternions):
un vecteur from, un vecteur front, et un vecteur up

tout ça regroupé dans une classe ou une structure caméra, avec en plus un vecteur left

ensuite il s'agit juste de faire tourner up et front autour de left pour regarder vers le haut, et faire tourner front et left autour de up pour regarder vers la gauche

pour ça j'utilise une fonction

vector rotate(vector vec, float angle, vector axe) {
}

qui fait tourner un vecteur "vec" de "angle" degrés autour d'un "axe"

c'est pas dur à coder et je peux te donner le code de cette fonction sinon

il faut:
- normaliser axe
- faire le produit scalaire Y = vec.axe
- Y*axe c'est la composante dans la direction axe de vec
on a: a = Y*axe et b = vec - Y*axe
on a donc vec = a + b
quand on fait tourner vec autour de axe, la partie de vec parallèle à axe ne changera pas, seule la partie perpendiculaire tournera
donc rotate(vec,angle,axe) = a + rotate(b,angle,axe)

ensuite tu calcules dirX = normalize(b)
et dirZ = b x axe (produit vectoriel)

tu calcules X = norme(b)
et finalement rotate(vec,angle,axe) = (cos(angle)*dirX + sin(angle)*dirZ)*norme(b) + a