OpenGL et les normales

**Sahengette** · 22/02/2012, 11h51

Bonjour,
J'aimerais implémenter dans mon moteur le flat shading (rien de trés jojo, juste histoire de me faire une idée avant de passer au Gouraud puis au BlinnPhong ...) et je sais que j'ai besoin de normales.
J'utilise le format OBJ, j'ai donc pleins de normales et une normale par face, j'ai donc des normales indexées (comme les vertices ou même les coordonées de textures ... que je ne gère pas

), comment dois je passer ces fameuses normales à mes shaders ?
En uniform ? Avec les in ?
En fait j'aimerais une lampe directionelle, donc je dois aussi envoyer quelques vecteurs, comme la direction de cette source de lumière.

J'ai aussi entendu dire que on ne multiplie pas les normales par la matrice modelview, on utilise un matrice pour les normales (l'ancienne gl_NormalMatrix ...), en quoi est elle différente ? comment est ce qu'elle se construit ?

Merci de votre patience avec un débutant amateur comme moi !

Je viens de faire une recherche et apparemment, la matrice normale c'est la transposée de l'inverse de la modelview (ou le contraire, parceque c'est un calcul réversible).
Est-ce correct ?

**Robxley** · 22/02/2012, 18h28

Salut Sahengette,

Normalement pour les normales, les données sont transmises en même temps que vos points (vertex positions) formant vos surfaces, après si vous n'avez qu'une normale par surface, cela revient à avoir la même normale pour l'ensemble des points formant votre surface. Par exemple si vous avez une normale pour une surface triangulaire c'est trois fois la même pour les 3 points formant la surface.

Pour passer les normales à votre shader, il faut utiliser des vertex attributs comme pour les points de tes faces ou comme pour les coordonnées textures ou tous autres attributs qui changent par vertex.

Concernant les informations de votre lumière (position, direction de la lumière, couleur....), ces informations étant identiques (au sens uniforme) pour l'ensemble de tes vertex, ces infos sont généralement transmisses par les routines glUniform et non pas par vertex attribut comme pour les normales.

Sinon, effectivement, on ne multiplie pas directement les normales par la matrice modelview. Cela vient du fait que les normales d'un objet sont invariants par translation. La translation d'un objet ne doit pas modifier la valeur des normals (une ligne, si je la translate change de position mais pas de direction, ni de normal). Les normales sont des vecteurs, donc représente une direction et non une position.

Par contre les normales d'un objet sont modifiée par toutes transformations ( rotations, symétries, déformations....). Or la matrice modelview contient à la fois l'ensemble des transformations et les translations/positions. C'est pourquoi généralement on applique uniquement la partie transformation de la matrice modelview aux normales (et autre vecteur ex: tangente,...).

Pour info la matrice modelview se décompose facilement entre une matrice de transformation et une matrice de translation :

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
 
          a b c x
M = R*T = e f g y
          i j k z
          0 0 0 1
 
    a b c 0
R = e f g 0
    i j k 0
    0 0 0 1
 
    1 0 0 x
T = 0 1 0 y
    0 0 1 z
    0 0 0 1

Attention tout de même avec décomposition si vous avez effectué des changement d'échelle sur vos données (ex : glScale) en utilisant directement R, vos normales ne seront plus de norme égale à 1.

Si vous avez un scale de parametre (Sx,Sy,Sz) il est nécessaire de modifier les paramètres de la diagonale de R de la facon suivante :

Code :

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

1
2
3
4
 
a = a/Sx;
f = f/Sy;
k = k/Sz;

Cela évite de renormaliser à chaque fois vos normales.

Si non pour plus d'info y a la fag : http://jeux.developpez.com/faq/math/...ransformations

**Sahengette** · 22/02/2012, 18h40

Super merci

c'est un peu plus clair, mais en fait j'aimerais savoir comment se passe l'affaire :
J'envoie des positions de vertices indexées (j'ai donc un tableau de positions vertices, et un d'index), dois je indexer mes normales ?

**Robxley** · 22/02/2012, 18h59

j'aimerais savoir comment se passe l'affaire

Pour ça, il va nous falloir un peu plus d'infos, la version d'opengl que tu utilise ? version 2.4 ? version 3.x+ ? si tu utilises les vba, vbo...
Comment tu dessines tes objets ? etc...

Un peu de code aussi peut faciliter la chose.

**Sahengette** · 22/02/2012, 19h23

En fait, j'ai qu'un seul vertex attrib, c'est la position du vertex, j'ai donc aussi qu'un seul vertexattribpointer, c'est mon tableau de vertices.
Je dessine avec glDrawElements, j'envoie donc un tableau d'indices, et avec glDrawElements j'active mon shader.

Mon shader ne fait rien d'extraordinaire (multiplie proj', modelview, position et applique une couleure arbitraire), pour l'instant en tout cas, car je souhaite instaurer un système d'éclairage (flat shading puis gouranud shading).

Et maintenant j'aimerais savoir comment envoyer mes normales depuis le CPU ...

**Robxley** · 23/02/2012, 09h27

Pour envoyer tes normales, c'est exactement la même chose que pour les positions. Pour un vertex tu auras 2 attributs, les positions et les normales.

Ensuite lors que tu dessines, tu as juste à rajouter l'activation de l'attribut correspondant à tes normales et c'est gagné

, ton glDrawElement est inchangé, vu que c'est par vertex donc pour l'ensemble des attributs associés (pour les attributs activés au préalable biensur

)

Je ne sais tjrs pas quelle version d'opengl tu utilises je ne peux pas t'aider plus que ca.
Quelques liens utiles en fonction de la version que tu utilises

Si c'est opengl 2.4 : http://raptor.developpez.com/tutorial/opengl/vbo/

**Sahengette** · 23/02/2012, 12h06

J'utilise OGL 3.3, j'ai donc fait comme ça, et je ne sais pas trop si ca marche ^^ :
Voilà mon vertex shader :

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
#version 330
///////////////////////////////
//	Attributs de vertex RENTRANTS
	in vec3 aVertex;
	in vec3 aNormal;
//
///////////////////////////////
 
///////////////////////////////
//	Données passées au FRAGMENT SHADER
	out vec4 vColor;
//
///////////////////////////////
 
///////////////////////////////
//	Variables Uniforms
	uniform mat4 modelview;
	uniform mat4 projection;
	uniform vec3 lightpos; //je l'ai défini à 0,0,-1 dans mon programme, comme un rayon de soleil de midi
//
///////////////////////////////
 
///////////////////////////////
//	Variables constantes
	const vec4 AMBIENT_COLOR = vec4 (0.2, 0.2, 0.2  ,  1);
//
///////////////////////////////
 
mat3 NormalMatrix(mat4 mdv)
{
	return inverse(transpose(mat3(	mdv[0][0],mdv[0][1],mdv[0][2],
					mdv[1][0],mdv[1][1],mdv[1][2],
					mdv[2][0],mdv[2][1],mdv[2][2])));
}
 
void main()
{
	gl_Position = projection * modelview * vec4( aVertex, 1.0 );
 
 
	mat3 nMatrix = NormalMatrix(modelview);	
	vec3 Normal = nMatrix * aNormal;
	float light = max(dot(aNormal, lightpos), 0);
 
	vColor = vec4(1,1,1, 1) * light + AMBIENT_COLOR;
}

Suzanne en very high poly, ca donne un rendu ... psychédélique !!

Simple cube ...

Suzanne en low poly

Et j'ai ajouté mes normales comme un "vertex attrib" supplémentaire.
Je comprends pas trop le résultat de tout ca, le rendu n'a pas l'air super (surtout que je m'attendais à du flat shading, ce qui n'a pas l'air d'être le cas

).

**Robxley** · 23/02/2012, 14h27

Effectivement c'est pas génial

Effectivement la tu as un problème avec les normales.
Je peux voir la partie C/C++ ou tu envoies tes attributs de vertex ?

Je pencherais sur le fait que tes normales sont mal-orientés. En effet tes normales doivent être définit de façon à avoir la direction de la normale vers "l’extérieur" de l'objet.

avec

Code :

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

1
2
 
float light = max(dot(aNormal, lightpos), 0);

l'orientation des Normales des faces est importante pour le signe de dot qui permet de déterminer si la face fait front ou non à la lumière.
Je pense que ton problème vient de là au vue de tes images. Mais bon je peux me tromper

**math_lab** · 23/02/2012, 14h54

Moi je dirais que le problème c'est qu'OpenGL veut une normale par sommet et que le flat shading requiert une normale par face. Si tu veux un smooth shading, il faut juste faire un petit preprocess sur ta géométrie: tu mets la normale a 0 sur tous tes sommets. Pour chaque triangle, tu rajoutes ajoutes sa valeur de normale a celle de chaque sommet. Et enfin, pour chaque sommet, tu normalises leur normale.
Si tu veux vraiment un flat shading (utile si tu veux un cube), c'est un peu plus compliqué: tu dois dupliquer tes sommets de façon a ce que chaque triangle soit fait de 3 sommets uniques qui ont la même valeur de normale. Pour le coup, tu n'as plus besoin d'indices vu que les triangles ne partagent plus de sommets.

En gros, le truc a retenir: il ne faut pas se contenter de donner les normales du fichier OBJ directement a OpenGL. D'ailleurs, 99% du temps, tu n'as même pas besoin de les lire depuis le OBJ, puisque tu peux les calculer facilement avec un produit vectoriel (cross product) de deux sommets d'un triangle.

**Sahengette** · 23/02/2012, 15h45

voilà ce que je fais, je récupère directement les normales et les vertices, que je garde dans deux tableaux, et avec les informations de faces (les lignes commencant par un f), je crée un tableau d'indice de vertices.
je pense qu'il y a une étape intermediaire nécessaire, mais je vois pas laquelle

.

voilà le code qui dessine un mesh

Code :

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

1
2
3
4
5
6
7
8
9
 glEnableVertexAttribArray(0);
          glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, cible.m_Mesh->getVertices());
 
          //on active seulement les normales s'il y en a
          if(TEST_NORMAL)
          {
                 glEnableVertexAttribArray(1);
                 glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, cible.m_Mesh->getNormales());
         }

entre temps j'envoie les variables uniforms .... puis je dessine

Code :

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

glDrawElements(GL_TRIANGLES, cible.m_Mesh->getIndexTaille(), GL_UNSIGNED_INT, cible.m_Mesh->getIndex());

**gbdivers** · 24/02/2012, 09h47

@Robxley
Petite précision, tu donnes un lien vers un tutoriel sur les VBO. Ici, c'est simplement des vertex array. C'est différent puisque le buffer et renvoyé à chaque appel.
@Sahengette
Ceci étant dit, tu devrais regarder le tutoriel indiqué par Robxley, les VBO sont plus performants que les VA (les données sont transférées une seule fois au gpu et stockées en VRAM)

En complément, tu peux regarder ce tutoriel sur les différentes méthodes pour envoyer des données au gpu Envoyer des données au processeur graphique et la partie sur les lumières Afficher les lumières avec les shaders

Envoyé par Sahengette

Voilà mon vertex shader :

Il faudrait que je vérifie mais a priori, c'est gênant d'utiliser des mat3. Par habitude, j'utilise toujours des mat4 alors je ne sais plus les conséquences sur le calcul des normales. Je te conseille :
- d'utiliser des vec4 et mat4 (convertie tes normales en vec4 comme tu l'as fait pour tes positions)
- tu refais exactement le même calcul (inversion et transposition d'une matrice constante) pour chaque vertex... c'est probablement pas optimal. Tu devrais calculer la matrice côté cpu puis l'envoyé comme uniform. Idem pour ta modelview * projection

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
#version 330
///////////////////////////////
//	Attributs de vertex RENTRANTS
	in vec3 aVertex;
	in vec3 aNormal;
//
///////////////////////////////
 
///////////////////////////////
//	Données passées au FRAGMENT SHADER
	out vec4 vColor;
//
///////////////////////////////
 
///////////////////////////////
//	Variables Uniforms
	uniform mat4 mvp; // model view projection
	uniform mat4 itmvp; // inverse transform mvp
	uniform vec3 lightpos; //je l'ai défini à 0,0,-1 dans mon programme, comme un rayon de soleil de midi
//
///////////////////////////////
 
///////////////////////////////
//	Variables constantes
	const vec4 AMBIENT_COLOR = vec4 (0.2, 0.2, 0.2  ,  1);
//
///////////////////////////////
 
void main()
{
	gl_Position = mvp * vec4(aVertex, 1.0);
	vec4 Normal = itmvp * vec4(aNormal, 1.0);
	float light = max(dot(aNormal, lightpos), 0);
 
	vColor = vec4(1,1,1,1) * light + AMBIENT_COLOR;
}

Pour le flat shading, la remarque de math_lab est juste, ce qui signifie :
- plus de calcul côté cpu pour convertir des meshs pour créer les vertices supplémentaires
- plus de données à envoyer au gpu puisque tu n'utilises plus les indices
- c'est moins joli
Donc aucune raison de s'embêter avec ça. En plus, tu es parti sur du Gouraud là

**Robxley** · 24/02/2012, 10h13

@gbdivers en faite dans le tuto que j'ai indiqué, il parle des VBOs certes mais aussi des VBA

, j'aurais peut être du préciser le chapitre 2 à regarder ^^

Mais effectivement l'idéal c'est d'utiliser les VBOs en priorité.

**gbdivers** · 24/02/2012, 10h31

Envoyé par Robxley

@gbdivers en faite dans le tuto que j'ai indiqué, il parle des VBOs certes mais aussi des VBA

, j'aurais peut être du préciser le chapitre 2 à regarder ^^

Mais effectivement l'idéal c'est d'utiliser les VBOs en priorité.

oups... ça fait longtemps que j'ai pas relu ce tuto

**Robxley** · 24/02/2012, 10h34

L'erreur est humaine, si non les forums n'existeraient pas.

**Sahengette** · 24/02/2012, 10h52

Vous avez raison, je vais partir tout de suite sur du Gouraud.
Par contre pour l'histoire de la mat3 pour la matrice des normales, je crois bien que cela soit nécessaire comme l'a dit Robxley plus haut, si je la transforme en mat4 je n'aurais pas le même résultat ...

En fait je crois que je vais revoir mon loader OBJ pour qu'il me génère directement une normale par vertex et qu'il me les indexe en conséquence avec mes positions de vertices.

**gbdivers** · 24/02/2012, 11h09

Sauf que...
L'inversion d'un matrice mat3 et mat4 ne donne pas le même résultat. Par exemple :

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
mat4
   1   2   3   0
   4   5   6   0
   7   8   9   0
   0   0   0   1
 
mat3
   1   2   3
   4   5   6
   7   8   9
 
inverse(mat4)
  -2.2518e+15   4.5036e+15  -2.2518e+15   0.0000e+00
   4.5036e+15  -9.0072e+15   4.5036e+15   0.0000e+00
  -2.2518e+15   4.5036e+15  -2.2518e+15   0.0000e+00
   0.0000e+00   0.0000e+00   0.0000e+00   1.0000e+00
 
inverse(mat3)
   2.2513e+15  -4.5025e+15   2.2513e+15
  -4.5025e+15   9.0050e+15  -4.5025e+15
   2.2513e+15  -4.5025e+15   2.2513e+15

On voit que mat3 = -mat4

**Robxley** · 24/02/2012, 11h10

Je ne suis pas sur que le fait de repasser en mat4 pour la transformée des normales soit réellement nécessaire, en tout cas au niveau mathématique. Car si tu repasse en mat4 ça te donne la matrice de transformation normal

Code :

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

1
2
3
4
5
 
    a b c 0
R = e f g 0
    i j k 0
    0 0 0 1

et donc si tu multiplies par ton vecteur normal vec3 (x,y,z) convertie en vec4 (x,y,z,0) vu que la ligne 4 et colonne 4 est diagonale (1 sur la diagonal) mathématiquement ça n'a aucune influence sur le résultat de ton vec4 par rapport à ton vec3, la composante w de ton vec4 sera tjrs nuls. Après peut être que les GPU sont plus optimisés pour des calcules des routines mat4, vec4 vu que c'est généralement le type de données traités mais honnêtement j'en ai pas la moindre idée.

Edit : Tiens effectivement l'inverse n'est pas la même....Bon va je sais pas trop quoi en penser au final, je me suis peut être trompé. Je vais vérifier ça.

**Sahengette** · 24/02/2012, 11h15

Zut alors ^^, je dois utiliser quoi alors, la modelview directement inversée et transposée ou une mat3 de la modelview inversée et transposée, j'avoue que je ne vous suis plus