Discussion :

[laurencew]

Bonjour,

Je me pose une question par rapport à la mise à jour des normales d'un objet qui est amené à être déplacé dans une scène.

J'ai un objet modèle qui contient une géométrie qui est envoyé à la carte via VBO. Ce modèle possède une matrice 4x4 que je modifie au besoin pour le déplacer dans la scène. Cette matrice (ainsi que la matrice de la caméra) est envoyé aux shaders pour mettre à jour les positions des sommets. J'envoie également la position d'un point fixe représentant la position de la lumière qui me permet d'obtenir un effet d'ombrage ainsi :

dans le vertex shader

Code :

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

colorFactor = max(dot(normal, lightDirection), 0.0);

dans le fragment shader :

Code :

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

color = colorFactor * vec4(texture2D(texture, v_texCoord).rgb, 1.0);

Quand le modèle est de face, pas de problème, il est bien éclairé par la lumière qui est en face de lui, mais le souci, c'est que quand le modèle est de dos, il est tout sombre, alors qu'il devrait être éclairé par la lumière qui n'a pas bougée.





Pour régler ce problème je serai bien tenté de multiplier chaque normale par la matrice du modèle, mais je n'ai jamais vu faire ça dans les shaders que j'ai pu regarder (bon pas énorme, mais quelques uns). Qu'en pensez vous ?

[CrankFlash]

Si je comprends bien, tu ne recalcules pas les normales lorsque tu déplaces ton mesh.
Ya deux moyens de procéder :

1 - Tu recalcules ces normales à chaque frame sur le CPU et tu les envoies tout frais sur le GPU en ayant pris soin de déclarer ton VBO en dynamic avec les flags d'accès en écriture pour le CPU. (technique pas vraiment performante, mais qui a le mérite d'être simple à mettre en place)

2 - Tu fais tous tes calculs sur le GPU. Ça requiert de bonnes connaissances en mathématiques (là de tête, à 4h30 du mat, je crois qu'il faut faire des dérivées partielles). (Technique plus complexe à mettre en place, mais plus performante dans la mesure où il n'y a plus de transfert entre la RAM CPU et la RAM GPU. Et puis le GPU est beaucoup plus rapide à traiter ce genre de calcul).

J'ai oublié de préciser qu'il ne suffit bien évidemment pas d'appliquer la matrice world aux normales pour que ça marche . Il faut vraiment les recalculer.

[laurencew]

Salut CrankFlash,

donc je suis pas là seule à trainer sur developpez à ces heures

Je vais tenter de mettre en place la première méthode pour plein de raisons (j'aime pas les dérivées, pas forte en maths et surtout il me reste peu de temps avant de devoir présenter ce projet). Mais comment je dois faire ? Parce qu'à part les multiplier par la matrice de transformations du modèle, je vois pas. Pourquoi d'ailleurs tu dis qu'évidemment appliquer appliquer la matrice world ne suffit pas ? Les normales me sont fournies par le fichier de description du modèle.

Sinon la solution extrêmement couteuse que je vois ce serait de les calculer par produit vectoriel en fonction de deux bords d'un triangle (mais il faudrait dans ce cas que j'applique d'abord la matrice de transformations aux positions alors que ça, je le fais dans le vertex shader...)

[AuraHxC]

C'est pas une histoire de transformer les normales dans l'espace camera pour faire des calculs de lumière ?
http://www.lighthouse3d.com/tutorial...normal-matrix/

[CrankFlash]

Sinon la solution extrêmement couteuse que je vois ce serait de les calculer par produit vectoriel en fonction de deux bords d'un triangle (mais il faudrait dans ce cas que j'applique d'abord la matrice de transformations aux positions alors que ça, je le fais dans le vertex shader...)

C'est exactement ça.

[laurencew]

Ce que je comprends pas, c'est pourquoi le fait d'appliquer sur les normales la matrice qui permet de déplacer le modèle ne fonctionne pas ? Ça devrait pourtant transformer les vecteurs/normales suivant les rotations et translations du modèle.

Je pense pas que j'aurai le temps d'apporter ces modifs rapidement, mais, par curiosité, si tu as un lien qui explique la façon de le faire dans le GPU, ça m'intéresse. J'aurai pas le temps de le faire pour la présentation, mais de toute façon je compte pas lâcher ce projet tout de suite, me reste plein de trucs que j'ai pas eu le temps de faire.

[CrankFlash]

La réponse à ton "pourquoi" se trouve dans le lien qu'a donné AuraHxC.

Il faudrait en fait appliquer la matrice transpose inverse de la transformation pour avoir la normale.

[laurencew]

D'ailleurs, je viens de lire très très rapidement l'article que tu indiques AuraHxC et donc si je n'applique pas de scale non uniform (ce qui est le cas, pas de scale du tout) je devrais pouvoir transformer mes normales par la matrice du modèle * celle de la caméra pour que mes normales soient bien orientées ?

Donc j'ai tenté ça :

Code :

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

1
2
3
v_normal = MVP * vec4(normal.xyz, 0.0);
v_normal = normalize(v_normal);
colorFactor = max(dot(v_normal, lightDirection), 0.0);

Mais mon modèle devient tout noir, dans tous les sens, tout le temps...

[laurencew]

Bon après avoir lu en entier l'article j'ai corrigé :

Code :

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

1
2
3
4
 
vec3 normalModif = gl_NormalMatrix * vec3(normal.xyz);
normalModif = normalize(normalModif);
colorFactor = max(dot(normalModif, lightDirection.xyz), 0.0);

Mais c'est toujours pas ça :





Bon en plus j'ai un warning car j'utilise glsl 130 et gl_NormalMatrix est deprecated après la version 120... Donc faudrait que je trouve un moyen de calculer la transposé inverse d'une matrice.

[AuraHxC]

C'est assez simple tu as doit avoir ta ModelView donc tu peux faire :
glm::mat4 normalMatrix = glm::gtx::inverse_transpose::inverseTranspose(modelview);
avec modelview qui sera du type glm::mat4 aussi

Bien sur c'est avec la librairie GLM que je te conseil fortement

Pour plus d'info, n'hésite pas a aller sur le site officiel := http://glm.g-truc.net/

[laurencew]

Pourriez-vous m'apporter quelques précisions car je vois le principe, mais dans l'application...

Les coordonnées de mon vecteur lumière, doit-il être modifié par la matrice de transfo du modèle, de la caméra, des deux, d'aucune ? Je voudrais une lumière directionnelle orientée sur l'axe des z (donc face au modèle), pour l'instant je file aux shaders un vecteur (0, 0, 1) qui n'est pas transformé, mais je doute.

Même question pour la matrice transposée inverse. Cette matrice qui me sert à modifier mes normales, c'est la transposée inverse de la matrice de transfo du modèle uniquement ou il faut que je lui ajoute également la matrice view de la caméra (voir la matrice projection de la cam, mais ça je suis quasi sur que non) ?

Pour calculer la transposée inverse d'une matrice et la filer aux shaders, je me sers des fonctions sur les matrices de Qt. Je me sers déjà de glm dans ce projet, mais là bizarrement, pas moyen de trouver glm::gtx::inverse_transpose::inverseTranspose dans ma version de la lib (0.9.0). chelou ?!