OpenGL/GLSL tout ce qui touche aux transformations

Version imprimable

15/12/2009, 00h30
AuraHxC

OpenGL/GLSL tout ce qui touche aux transformations

Bonjour/bonsoir

Je m'intéresse en ce moment à la programmation OpenGL et surtout à l'utilisation des VBO et Shaders. Alors mon but était de faire un cube 3D assez simplement avec un VBO qui contient les vertices et les couleurs et un VBO qui contient les indices. Après un glDrawElements, mon cube apparaît.
Maintenant j'aimerais exécuter des transformations de type zoom/dezoom, déplacement de la vue (donc l'oeil) à droite ou gauche, ainsi que faire une translation et rotation (droite/gauche/haut/bas) à l'aide uniquement des shaders (à priori Vertex Shader dans ce cas).
Malheureusement, je ne sais pas trop comment mis prendre du côté GLSL et du côté API. En gros, je n'arrive pas trop à savoir quoi faire en GLSL et ce que je dois lier dans l'API au shader pour que cela fonctionne correctement.

Si quelqu'un a déjà fait ce genre de chose, j'aimerais quelques explications avec pourquoi pas des exemples.

Merci d'avance.

EDIT : Précision, j'utilise la bibliothèque GLM pour tout ce qui touche aux mathématiques (librairie inspiré de GLSL : http://glm.g-truc.net/ )
15/12/2009, 10h26
Syl_20
Citation:

Envoyé par AuraHxC

Bonjour/bonsoir

[...]
Maintenant j'aimerais exécuter des transformations de type zoom/dezoom, déplacement de la vue (donc l'oeil) à droite ou gauche, ainsi que faire une translation et rotation (droite/gauche/haut/bas) à l'aide uniquement des shaders (à priori Vertex Shader dans ce cas).
Malheureusement, je ne sais pas trop comment mis prendre du côté GLSL et du côté API. En gros, je n'arrive pas trop à savoir quoi faire en GLSL et ce que je dois lier dans l'API au shader pour que cela fonctionne correctement.

Si quelqu'un a déjà fait ce genre de chose, j'aimerais quelques explications avec pourquoi pas des exemples.

Merci d'avance.

EDIT : Précision, j'utilise la bibliothèque GLM pour tout ce qui touche aux mathématiques (librairie inspiré de GLSL : http://glm.g-truc.net/ )

Dans ton shader crée une mat4 uniform qui contient la transformation a appliqué a tout les vertex de ton cube. A chaque fois que tu bouges ton cube tu mets ta matrice à jour coté API avec glUniform4f
Dans ton shader une multiplication entre la matrice et le vertex devrait faire l'affaire.

ton vertex shader minimaliste(de tête)
Code:

1 2 3 4 5 6 7 8 uniform mat4 matriceTransformation; void main() { vec4 positionVertex = vec4(matriceTransformation * gl_Vertex); gl_Position = gl_ModelViewProjectionMatrix * positionVertex ; }
15/12/2009, 12h14
Soack

Je me trompe peut-être (merci de me corriger si c'est le cas) mais il me semble qu'à partir d'OpenGL 3.2 on doit spécifier nous-même les matrices aux Shader. Faut-il donc s'habituer à spécifier nous-même la matrice gl_ModelViewProjection ?

Oui je suis d'accord avec toi au niveau de spécifier les matrices aux shaders.
En gros, je pensais grâce à la librairie GLM créer une matrice de translation par exemple.
On trouve dans la GLM ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 detail::tmat4x4<T> glm::gtx::transform::translate ( detail::tmat4x4< T > const & m, T x, T y, T z ) Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. From GLM_GTX_transform extension. et detail::tmat4x4<T> glm::gtx::transform::translate ( T x, T y, T z ) Builds a translation 4 * 4 matrix created from 3 scalars. From GLM_GTX_transform extension.
Je pensais utiliser la seconde version mais je sais pas trop faire exactement. Mon idée aurait été de faire une matrice 4x4 du côté API :
Code:

1 2 3 4 5 6 glm::mat4 translation = ( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f );
puis utiliser la fonction que la GLM me propose, disons que je veux une translation de 1.0f sur l'axe des x :
Code:

1 2 3 translation = glm::translate(1.0f, 0.0f, 0.0f);
Du coté shader, je déclare une variable uniform :
Code:

1 2 3 uniform mat4 translation;
puis du côté API je lie cette variable uniform avec ma mat4 translation de mon API. Et du côté shader je multiplie ma uniform mat4 par la matrice gl_ModelViewMatrix et gl_Vertex que je stock dans la variable gl_Position.
Code:

1 2 gl_Position = gl_ModelViewMatrix * gl_Vertex * transformation;
Vous en pensez quoi ? Est-ce correct ?

15/12/2009, 13h08
Syl_20
Ta matrice glm::mat4 translation doit être une matrice identité sinon tu aura des problèmes:aie: et aussi comme les multiplication de matrices et vecteurs ne sont pas commutatives
Code:

1 2 gl_Position = gl_ModelViewMatrix * gl_Vertex * transformation
risque de poser des problèmes. Fait le en plusieurs étapes comme dans mon post précédent.
15/12/2009, 13h12
AuraHxC

Outch!!! effectivement, j'avais mal tapé ma matrice pourtant j'ai une matrice identité dans mon API que j'appelle pour initialiser mes matrices.
Sinon je suis Ok aussi pour la multiplication par étape, j'avais zappé ce petit soucis :s

Voilà au départ mon vertex shader

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
// VERTEX SHADER
#version 130
 
// Attributs
in vec3 vertexPosition_in;
in vec3 color_in;
 
// Uniform
uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
 
 
// Sorties
out vec3 color_v;
 
void main ()
{
	gl_Position = projectionMatrix * viewMatrix * vec4(vertexPosition_in, 1.0);
	color_v = color_in;
}

Je mets aussi du côté API les liaisons pour faire le lien entre le shader et l'API
Ceci est dans ma fonction init.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
_projIndex =
       glGetUniformLocation(_shaderPgm->programId(), "projectionMatrix");
_positionIndex =
       glGetAttribLocation(_shaderPgm->programId(), "vertexPosition_in");
 
mat4 id = mat4( 1.0f, 0.0f, 0.0f, 0.0f,
                      0.0f, 1.0f, 0.0f, 0.0f,
                      0.0f, 0.0f, 1.0f, 0.0f,
                      0.0f, 0.0f, 0.0f, 1.0f );
_proj = id;
_view = id;
 
_proj =
       glm::perspective(70.0f, ((GLfloat) width()) / ((GLfloat) height()),
                        1.0f, 1000.0f);
 
eye = vec3(0.0f, 0.0f, -5.0f);
 
_view =
       glm::lookAt(eye, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));

Ma fonction draw :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
glUniformMatrix4fv(_projIndex, 1, GL_FALSE, value_ptr(_proj));
glUniformMatrix4fv(_viewIndex, 1, GL_FALSE, value_ptr(_view));
 
glEnableVertexAttribArray(_positionIndex);
glEnableVertexAttribArray(_colorIndex);
 
glVertexAttribPointer(_positionIndex, 3, GL_FLOAT, GL_FALSE,
                         6 * sizeof(GLfloat), BUFFER_OFFSET(0));
glVertexAttribPointer(_colorIndex, 3, GL_FLOAT, GL_FALSE,
                         6 * sizeof(GLfloat), BUFFER_OFFSET(3));

Je n'ai pas mon VBO mais bon je pense que c'est compréhensible pour la liaison des attributs et variable du shader.

Donc j'aimerais savoir si mon départ est bon et ce que je devrais modifier pour insérer mes transformations.

15/12/2009, 13h24
Soack

Pour "enchaîner" les transformations, tu peux multiplier les matrices. Comme avec OpenGL on travaille dans des repères locaux, il me semble qu'on "post-multiplie".

Par exemple tu veux d'abord faire une rotation (R) et ensuite une translation (T) ça donne:
R * T * gl_Vertex

Donc si on prend ton cas ça donnera:
gl_ModelViewMatrix * transformation * gl_Vertex

Ce qui est bien ce que Syl_20 disait. ^^

Aussi, tu ne peux pas faire ça: gl_Vertex * transformation
gl_Vertex est de dimension (4,1)
transformation est de dimenssion (4,4)

(4,1) x (4,4) impossible.
(4,4) x (4,1) possible.

EDIT:
pour ajouter une transformation, tu donnes une nouvelle matrice au shader, et tu feras je pense:
gl_Position = projectionMatrix * viewMatrix * transformationMatrix * vec4(vertexPosition_in, 1.0);

(à vérifier)
15/12/2009, 13h30
AuraHxC

En fait en regardant mon code shader est ce que ce que j'ai fait n'est pas finalement la non utilisation des variables pré-définis de GLSL. Je m'explique : Est ce que projectionMatrix correspond à gl_ProjectionMatrix, viewMatrix correspond à gl_ModelViewMatrix, vertexPosition_in correspond à gl_Vertex et pour finir color_in correspond à gl_Color.

Si oui est ce que vous me conseilleriez de modifier mon code pour utiliser plutôt les choses prédéfinis en GLSL ?
15/12/2009, 14h02
Soack

Citation:

Si oui est ce que vous me conseilleriez de modifier mon code pour utiliser plutôt les choses prédéfinis en GLSL ?

Il me semble que tout est bon.
Pour ce qui est de l'utilisation des choses prédéfinis en GLSL, tu entends la matrice gl_ModelViewProjection et gl_Vertex par exemple ? Si c'est le cas, alors je dirai que non.

Dans la nouvelle version d'OpenGL 3.2 on ne peut plus utiliser (sauf extensions) le pipeline fixe. Or, gl_Vertex & compagnie sont liés au pipeline fixe, donc ont disparu. Tu peux les utiliser si tu veux, mais je te conseille de prendre de bonnes habitudes dès maintenant.

Pour plus d'information, tu peux lire les spécification du GLSL 1.50 sur le site d'opengl. ^^
15/12/2009, 14h08
AuraHxC

Woki merci beaucoup justement mon but étant au maximum de ne pas utiliser le pipeline fixe.
Merci pour ta réponse ;)

Alors j'ai fait les modifications suivantes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
Init : 
 
_transIndex =
       glGetUniformLocation(_shaderPgm->programId(), "translation");
 
mat4 id = mat4(1.0f, 0.0f, 0.0f, 0.0f,
                  0.0f, 1.0f, 0.0f, 0.0f,
                  0.0f, 0.0f, 1.0f, 0.0f,
                  0.0f, 0.0f, 0.0f, 1.0f);
   _proj = id;
   _view = id;
   _trans = id;

Code:

1
2
3
4
5
 
 
draw : 
 
glUniformMatrix4fv(_transIndex, 1, GL_FALSE, value_ptr(_trans));

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
 
 
fonction clavier : 
 
void GL3Widget::keyPressEvent(QKeyEvent * e)
{
   if (e->key() == Qt::Key_Escape)
      QApplication::exit(0);
 
   if (e->key() == Qt::Key_Left) {
      cout << "Left\n";
      _trans = glm::translate(glm::vec3(0.1f, 0.0f, 0.0f));
      repaint();
   }
 
   if (e->key() == Qt::Key_Right) {
      cout << "Right\n";
      _trans = glm::translate(glm::vec3(-0.1f, 0.0f, 0.0f));
      repaint();
   }
 
   if(e->key() == Qt::Key_Up) {
      cout << "Up\n";
      _trans = glm::translate(glm::vec3(0.0f, 0.1f, 0.0f));
      repaint();
   }
 
   if(e->key() == Qt::Key_Down) {
      cout << "Down\n";
      _trans = glm::translate(glm::vec3(0.0f, -0.1f, 0.0f));
      repaint();
   }
}

Ce qui fait bien un décalage mais je peux l'effectuer qu'une seule fois pour chaque composante... En gros je peux faire une fois Up après cela ne fait plus aucun effet d'appuyer sur la touche Up pourtant ca rentre bien dans le if pas de soucis.

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
 
 
Shader : 
 
// VERTEX SHADER
#version 130
 
// Attributs
in vec3 vertexPosition_in;
in vec3 color_in;
 
// Uniform
uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 translation;
 
 
// Sorties
out vec3 color_v;
 
void main ()
{
	gl_Position = projectionMatrix * viewMatrix * translation *
                      vec4(vertexPosition_in, 1.0);
	color_v = color_in;
}

Une idée peut être ?

15/12/2009, 14h45
Soack

Pas sur que ça soit ça, mais en fait les transformations faut les combiner.
Par exemple, si tu as appuyé sur la touche haut, tu vas avoir une translation.
Au prochain tour de boucle, il faut que cette transformation soit toujours là, il ne faut pas la remettre à zéro.

En gros, imagine l'algorithme suivant:
var transformation:Matrice

Boucle
Si (touche_haut) Alors:
| transformation = transformation * Translation(tx, ty, tz)
FinSi

transmettre_au_shader(transformation)
FinBoucle

En gros, faut pas:
transformation = Translation
Mais:
transformation *= Translation

Effectivement cela marche beaucoup mieux avec ceci :

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
 
if (e->key() == Qt::Key_Left) {
      cout << "Left\n";
      _trans *= glm::translate(glm::vec3(-0.1f, 0.0f, 0.0f));
      repaint();
   }
 
   if (e->key() == Qt::Key_Right) {
      cout << "Right\n";
      _trans *= glm::translate(glm::vec3(0.1f, 0.0f, 0.0f));
      repaint();
   }
 
   if(e->key() == Qt::Key_Up) {
      cout << "Up\n";
      _trans *= glm::translate(glm::vec3(0.0f, 0.1f, 0.0f));
      repaint();
   }
 
   if(e->key() == Qt::Key_Down) {
      cout << "Down\n";
      _trans *= glm::translate(glm::vec3(0.0f, -0.1f, 0.0f));
      repaint();
   }