Discussion :

[Sahengette]

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]

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]

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]

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]

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]

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/