Discussion :

[robinsondesbois]

Bonjour,

Je suis en train de suivre le tutoriel D'OpenGL moderne sur ce site. Je suis plus ou moins coincé sur le shader d'illumination.
Le shader du tuto fonctionne correctement mais je n'arrive pas à avoir un rendu lisse de mes faces.



Pourtant j'effectue bien mes calcules dans le fragment shader.

Voici le 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
#version 330 core
 
layout(location = 0) in vec3 vertexPosition_modelspace;
layout(location = 1) in vec3 vertexNormal;
 
// Output data
out vec3 Position_worldspace;
out vec3 Normal_cameraspace;
out vec3 LightDirection_cameraspace;
out vec3 EyeDirection_cameraspace;
 
uniform mat4 Model;
uniform mat4 View;
uniform mat4 Projection;
uniform vec3 PosLamp01;
uniform vec3 PosCamera;
 
void main()
{
	gl_Position =  Projection*View*Model * vec4(vertexPosition_modelspace,1);
	Position_worldspace = (Model * vec4(vertexPosition_modelspace,1)).xyz;
 
	Normal_cameraspace = (View * Model * vec4(vertexNormal, 0)).xyz;
 
	vec3 vertexPosition_cameraspace = ( View * Model * vec4(vertexPosition_modelspace,1)).xyz;
	EyeDirection_cameraspace = PosCamera - vertexPosition_cameraspace;
 
	vec3 LightPosition_cameraspace = ( View * vec4(PosLamp01,1)).xyz;
	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;
}

et le fragment 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
#version 330 core
 
// Input data
in vec3 Position_worldspace;
in vec3 Normal_cameraspace;
in vec3 LightDirection_cameraspace;
in vec3 EyeDirection_cameraspace;
 
// Ouput data
out vec3 color;
 
uniform vec3 PosLamp01;
 
void main()
{
	vec3 LightColor = vec3(1,1,1);
	float LightPower = 30.0f;
 
	vec3 MaterialDiffuseColor = vec3(1.0, 0.0, 0.0);
	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;
	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);
 
	float distance = length(PosLamp01 - Position_worldspace );
 
	vec3 N = normalize(Normal_cameraspace);
	vec3 L = normalize(LightDirection_cameraspace);
	vec3 E = normalize(EyeDirection_cameraspace);
	vec3 R = reflect(-L, N);
	vec3 i_a = MaterialAmbientColor;
	vec3 i_d = MaterialDiffuseColor * LightColor * LightPower * clamp(dot(L, N), 0, 1) / (distance*distance);
	vec3 i_s = MaterialSpecularColor * LightColor * LightPower * pow(clamp(dot(E, R), 0, 1), 50) / (distance*distance);
	color = i_a + i_d + i_s;
}

Merci d'avance pour votre aide
Robin

[dragonjoker59]

Salut !

Franchement je ne sais pas, mais généralement j'effectue mon calcul de light direction dans mon fragment shader.

[LittleWhite]

Bonjour,

J'ai exactement eu la même pensée que dragonjoker59.
Mais en réalité, même avec un éclairage dans le vertex shader, on peut avoir un résultat plus lisse. Ce type de résultat est causé par : les normales.
En effet, actuellement, vous avez une normale par face (comprendre, par triangle), alors que les sommets des triangles sont partagés par d'autres. Le fait que les faces sont apparentes ainsi, est dû au fait que la normale pour un sommet pour la face 1, sera d'une valeur A, alors que pour le même sommet pour la face 2, il sera d'une valeur B. Du coup, il y a cassure (ou non lissage).

Pour régler ce problème, généralement on fait une moyenne des normales des faces partageant un même sommet. La moyenne permet d'avoir une normale par sommet et donc, de ne plus avoir de cassure.

Oh ... j'espère avoir été un peu clair

Après, il existe la technique des textures de normales : http://jeux.developpez.com/tutoriels...-des-normales/
Mais c'est un peu différent.

[robinsondesbois]

Merci pour cette réponse

Elle est claire

Après l'affichage des normales j'ai remarqué qu'effectivement je n'avais pas qu'une normale par sommet. (ce qui est faux mathématiquement parlant )
Existe-t-il une méthode propre pour fusionner ses normales ?
Parce que là je vais partir sur un algo bourrin en O(N^3)



Merci pour votre aide

[Jbx 2.0b]

Somme des N vecteurs normaux et division par N.

[robinsondesbois]

Je me suis mal exprimé :
Y a t-il une méthode pour parcourir les sommets de mon mesh et identifier le moment pour je doit effectuer ma moyenne de normales et quand je ne doit pas le faire.
Par exemple pour mon cube les normales sont correcte puisque je ne souhaite pas de lissage.

[dragonjoker59]

Par rapport à ça, moi j'ai opté pour la fainéantise : c'est au fournisseur du mesh de s'assurer que les normales sont bonnes.
Avant ça j'utilisais une méthode assez simple : découpage du mesh en submesh, lissage des normales sur toutes les faces des submeshes. ça fonctionne bien avec une sphère (1 seul submesh) ou un cube (6 submeshes) et je n'avais pas rencontré de problèmes.

[robinsondesbois]

Ha ha ha ^^
C'est pas un peut facile ça

Je posais juste la question pour savoir.
Je vais utiliser mon algorithme gourmand pour ne pas surcharger les graphistes.

[dragonjoker59]

Si en plus tu as des graphistes derrière, c'est évidemment à eux de s'occuper des normales de leurs modèles. Tu ne devrais pas avoir à en générer.
Quel format utilisez-vous pour l'export/import ?

[robinsondesbois]

En faisant la moyenne des normales, ça fonctionne.

Merci à vous

[dragonjoker59]

Je persiste hein, ce n'est pas au moteur de générer des normales, mais aux graphistes!
Vous utilisez un format propriétaire pour l'export/import?

[Nooay]

Pour compléter la réponse concernant le lissage des normales,
il y a une option sous blender permettant de lisser les normales dans l'éditeur.
Les modifications se répercuteront ensuite sur le fichier d'export 'obj' lorsque l'on inclut les normales.