Discussion :

[Nooay]

Bonjour,

j'ai remarqué pour le code suivant après affichage de la matrice de transformation:
glloadidentity();
glrotated(teta, 0, 1, 0); // Ry(teta)
glrotated(phi, 0, 0 , 1); // Rz(phi)

que la matrice de transformation résultante M vaut:
M= Ry(teta) * Rz(phi)

pourtant mathématiquement ça devrait être
M= Rz(phi) * Ry(teta)

mais en effet, il est précisé dans la doc https://www.opengl.org/sdk/docs/man2...MultMatrix.xml
qu'utiliser un glrotated revient à utiliser glMultMatrix() avec la matrice de rotation en paramètre
ce qui revient à multiplier la matrice de transformation courante par la matrice de rotation soit :
C = C * R

ce qui au final dans notre exemple donne:
C = I * Ry(teta) * Rz(phi)

Puisque ensuite pour effectuer notre transformation sur un vecteur quelconque V on a:
V' = C * V soit
V' = I * Ry(teta) * Rz(phi) * V

D'un point vue calcul, cela revient donc à appliquer Rz(phi) puis Ry(teta).

Pourtant visuellement on a bien le résultat de l'application de Ry(teta) puis Rz(phi).


Voilà, il y a quelque chose qui cloche dans ma compréhension sur le sujet au vue du résultat mais je ne vois pas où,
merci de m'apporter vos lumières.

[monwarez]

Bonjour
Quitte à utiliser des matrices de transformation, pourquoi ne pas simplement oublier les glRotated... et utiliser les shaders pour les transformation de matrices de projection et de modèle ?
Lors de l'utilisation de shader le processus de multiplication de matrice est laissé au programmeur, ainsi pour faire Ry(teta) suivi de Rz(phi) la matrice résultante sera bien
M = Rz(phi) * Ry(teta) .

Pour répondre à la question, il se pourrait que glRotated et autre utilise une convention de multiplication à droite (ce qui revient à prendre le dual des matrice de transformations, modèle et projection).

[dragonjoker59]

C'est le cas si je ne me trompe pas. OpenGL utilise des matrices column major, et multiplie à droite

[Nooay]

monwarez, je te remercie pour le conseil, j'y penserai dans un futur proche.
Aujourd'hui, je cherche à plutôt comprendre comment openGL utilise ses transformations.

dragonjoker59, pour ce qui est du column-major, effectivement c'est bien le cas, pour:

Code :

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

1
2
glLoadIdentity();
glTranslated(-2, 5, 3);

Le tableau contenant les valeurs de la matrice courante vaut:
1 0 0 0 0 1 0 0 0 0 1 0 -2 5 3 1

en choisissant l'arrangement column-major, on obtient donc:
1 0 0 -2
0 1 0 5
0 0 1 3
0 0 0 1

ce qui correspond à la matrice de translation non transposé.

On peut donc conclure que l'utilisation de l'arrangement column major correspond aux matrices non transposées.


J'en viens maintenant au problème, pour:

Code :

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

1
2
3
glLoadIdentity();
glRotated(-45, 0, 1, 0);
glRotated(-45, 0, 0, 1);

Le tableau contenant les valeurs de la matrice courante vaut:
0.5 -0.707107 0.5 0 0.5 0.707107 0.5 0 -0.707107 0 0.707107 0 0 0 0 1

soit en column major
0.5 0.5 -0.71 0
-0.71 0.71 0 0
0.5 0.5 0.71 0
0 0 0 1

Pour retrouver ce résultat, on fait:
Ry(-45) * Rz(-45)

soit

Code :

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

1
2
3
4
5
 
  0.71    0     -0.71  0            *               0.71   0.71   0    0                                        
  0        1     0     0			    -0.71  0.71   0    0
  0.71    0     0.71   0			   0        0      1    0
  0        0     0     1			    0        0      0    1

On voit donc que openGL fait une multiplication à droite des transformations non transposées ... je ne vois pas comment il utilise ensuite cette matrice pour appliquer la transformation aux vecteurs positions. En effet, soit X un vecteur colonne position, cela ne correspond mathématiquement ni à Rz(-45) * Ry(-45) * X, ni à Xt * Ry(-45)t * Rz(-45)t.

Merci d'avance pour vos lumières.

[monwarez]

Lorsque je regarde l'entête de glm https://github.com/g-truc/glm/blob/m..._transform.hpp, je peux voir qu'en row-major une translation serrait

Code :

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

1
2
3
4
5
 
1 0 0 0
0 1 0 0
0 0 1 0
X Y Z 1

Code :

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

1
2
3
4
5
6
7
8
 
template <typename T, precision P>
	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
	{
		tmat4x4<T, P> Result(m);
		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
		return Result;
}

Ce qui correspond bien à une transposée (de glTranslate) , donc en fait si on veut faire une composition en multipliant à droite, on utilise des matrices en colum-major, sinon des matrices row-major.
Cette formule devrait faire la correspondance M1 * M2 * X = t(tX * tM2 * tM1)

[Nooay]

Voici l'explication:

On a vu qu'openGL utilise la multiplication à droite pour calculer sa matrice de transformation alors que mathématiquement,
nous savons qu'une composition est une multiplication à gauche des matrices non transposées.

La grosse différence, c'est que openGL applique ses transformations sur le repère et non pas sur les objets.
En openGL, une composition comprenant une translation suivit d'une rotation puis d'un scale donnera la matrice de transformation suivante:
M = T(2,2)*R(45)*Scale(2).

Mais mathématiquement de manière classique (c'est à dire appliqué aux objets et non au repère),
si l'on applique cette matrice M à un objet, c'est à dire que l'on fait T(2,2)*R(45)*Scale(2) * Position.
On appliquera ces transformations dans l'ordre inverse soit le scale, la rotation puis la translation.

On se rend compte que le résultat est le même.

Voici le lien qui met en lumière tout ça:
http://web.cse.ohio-state.edu/~hwshe.../transform.pdf

Conclusion, la série de transformation T1 -> T2 -> T3 appliqué au repère (comme dans openGL),
reviens à appliquer la série de transformation T3 -> T2 -> T1 appliqué à l'objet (comme en math classique)