Discussion :

[Ekinoks]

Salut !

J'aimerais savoir si il est possible d'envoyer une matrice de transformation a ajouter a celle qui se trouve déjà ?
il me semble que les translations doivent s'ajouter, et pour la matrice de rotation, il se multiplie, c'est bien ca ?

Y a t'il une fonction dans opengl qui fait ca, ou il faut que je le fasse moi meme les calcules ?

Merci

Edit : A non, multiplier les sous-matrices qui correspond aux la matrices de rotation ne marche pas... J'espaire qu'il existe une fonction pour faire se que je souhaite car il y a l'aire d'avoir pas mal de maths en fait...

Edit2 : Comme je suis pas sur d'avoir bien expliqué voici un petit exemple de se que je veux faire :
Au lieu de faire deux rotations successive avec :

Code :

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

1
2
3
 
glRotated(Alpha, vx, vy, vz);
glRotated(Alpha2, vx2, vy2, vz2);

j'aimerais faire un truc du genre :

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
 
glLoadIdentity();
glRotated(Alpha1, vx1, vy1, vz1);
glGetFloatv(GL_MODELVIEW_MATRIX, M1);
 
glLoadIdentity();
glRotated(Alpha2, vx2, vy2, vz2);
glGetFloatv(GL_MODELVIEW_MATRIX, M2);
 
glLoadIdentity();
/// Ici j'aimerais effectuer les transformation de M1 puis de M2
/// une sorte de :
///    glMatrixMode(GL_MODELVIEW);
///    glLoadMatrixf(M1);
///    glAddMatrixf(M2);   /// seulement cette fonction n'existe pas...

Vous savez si une tel fonction existe ?

[Ti-R]

Pourquoi pas:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotated(Alpha1, vx1, vy1, vz1);
glRotated(Alpha2, vx2, vy2, vz2);
glGetFloatv(GL_MODELVIEW_MATRIX, M12);
 
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf(M12);

Tout simplement ?

[Laurent Gomila]

Pour composer les transformations de plusieurs matrices il faut les multiplier ; ça marche pour tout type de matrice quelque soit leur contenu.

Après il faut juste faire gaffe à l'ordre de multiplication, et aux points de pivot pour les rotations.

Tu as jeté un oeil à la FAQ des matrices et quaternions ?

[Ekinoks]

Merci pour vos réponses ! =)

Ti-R> non justement cette technique ne peu pas être réalisable dans mon vrais cas... cas serais trop beau ^^

Laurent Gomila> Ha, effectivement, maintenant que tu me le dit... en multipliant l'integraliter de la matrice 4x4 ca devrais marcher ^^
Moi je multiplier que le petit carre du haut de 3x3 :^/ du coup c'était les translation qui foiré ^^

Merci !

[bafman]

heu...

Code :

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

1
2
 
glMultMatrix()

ca devrait t'allez tellement mieux
quand on cherche à multiplier des matrix, on charche une fonction avec mult dedans

[Ekinoks]

ha oui effectivement ca devient plus simple avec glMultMatrixf() =)

Par contre j'ai un autre problème qui a aussi raport avec les rotation, ducoup je le met ici ^^;

Voila, j'ai écrit une fonction qui sert a faire des rotations d'un objet en fonction de son propre repaire. voici ce que j'ai fait :

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
 
...
void Mouvement::setSlopeL(float x, float y, float z)
{
   float sgMatrix[16];
   glGetFloatv(GL_MODELVIEW_MATRIX, sgMatrix);
 
      glMatrixMode(GL_MODELVIEW);
      glLoadMatrixf(m_tfMatrix);  //on charge la position de l'objet
 
      glRotated(x,m_tfMatrix[0],m_tfMatrix[1],m_tfMatrix[2]); // on applique la rotation de x sur son vecteur x
      glRotated(y,m_tfMatrix[4],m_tfMatrix[5],m_tfMatrix[6]);// on applique la rotation de y sur son vecteur y
      glRotated(z,m_tfMatrix[8],m_tfMatrix[9],m_tfMatrix[10]);// on applique la rotation de z sur son vecteur z
         glGetFloatv(GL_MODELVIEW_MATRIX, m_tfMatrix);  //on sauvegarde la nouvelle matrice
 
   glMatrixMode(GL_MODELVIEW);
   glLoadMatrixf(sgMatrix);
}
...
void Mouvement::loadMatrixModelView()
{
   glMatrixMode(GL_MODELVIEW);
   glLoadMatrixf(m_tfMatrix);
}
...

ensuite pour placer la camera je fait :

Code :

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

1
2
 
objet->loadMatrixModelView();

Le problème qui se pose, c'est que ca ne marche pas, les rotation se font n'importe comment et je ne comprend pas pourquoi, ca devrais marcher comme j'ai fait non ?

Merci

[Laurent Gomila]

Juste une remarque, tu devrais utiliser une bibliothèque de calcul mathématique, parce qu'utiliser OpenGL de cette manière pour faire tes calculs n'est pas très optimisé et surtout assez limité. Je suis sûr que les codeurs OpenGL ont déjà lâché dans la nature quelques bonnes classes de vecteurs et matrices

[Ekinoks]

Ca y est j'ai trouver d'où vien le problème... les vecteurs du repaire sont écrit
verticalement et non pas horizontalement...

tu devrais utiliser une bibliothèque de calcul mathématique, parce qu'utiliser OpenGL de cette manière pour faire tes calculs n'est pas très optimisé

Ha ? je croyait que l'OpenGL était avant tout une bibliothèque de calcule de matrice très très optimisé, il existerais un bibliothèque qui arriverais a multiplier deux matrice 4x4 plus rapidement qu'OpenGL ?

[bafman]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
...
void Mouvement::setSlopeL(float x, float y, float z)
{
   float sgMatrix[16];
   glGetFloatv(GL_MODELVIEW_MATRIX, sgMatrix);
 
   [...]
 
   glMatrixMode(GL_MODELVIEW);
   glLoadMatrixf(sgMatrix);
}

arg !!!
une petit glPushMatrix()/glPopMatrix sera bien plus efficace (car la matrice restera en memoire video et ne repassera pas par le bus graphique)
ca donne ca :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
...
void Mouvement::setSlopeL(float x, float y, float z)
{
   glPushMatrix()
 
   [...]
 
   glPopMatrix()
}

oui oui, c'est bien super simple

sinon, pour ce qui est des performance des calculs matriciel, en OpenGL, ils sont super rapides car géré en hardware, mais il ne sont efficace que si les matrices restent en memoire video, ce qui n'est pas le cas ici...
typiquement, ici, tu fait des aller/retour entre la memoire graphique et la memoire video, ce qui te fait perdre tout aventage du hard (un calcul utilisant à bon escient les instruction SSE et le cache sera bien plus performant). En plus tu a les couts de synchronisation entre la carte graphique et le CPU qui ne sont pas négligeables...

[Ekinoks]

ha ok d'accord, en fait OpenGL est très performant en calcule matriciel a condition de bien l'utiliser ^^

Merci d'avoir pris la peine de corriger mon code et de m'avoir expliqué en quoi il n'allait pas ! =)