[GLSL] Phong shader

Version imprimable

1 pièce(s) jointe(s)

[GLSL] Phong shader

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.

Pièce jointe 172646

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

Voici le vertex shader

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
#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:

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

24/03/2015, 15h47
dragonjoker59

Salut !

Franchement je ne sais pas, mais généralement j'effectue mon calcul de light direction dans mon fragment shader.
25/03/2015, 08h48
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 :aie:

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

1 pièce(s) jointe(s)

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 :aie: )
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) :(

Pièce jointe 172766

Merci pour votre aide :)
25/03/2015, 16h35
Jbx 2.0b

Somme des N vecteurs normaux et division par N.
25/03/2015, 16h39
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.
25/03/2015, 17h48
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.
25/03/2015, 18h33
robinsondesbois

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

Je posais juste la question pour savoir.
Je vais utiliser mon algorithme gourmand pour ne pas surcharger les graphistes.
26/03/2015, 11h01
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 ?
02/04/2015, 10h57
robinsondesbois

En faisant la moyenne des normales, ça fonctionne.

Merci à vous :)
02/04/2015, 15h25
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?
02/11/2016, 19h21
Nooay

1 pièce(s) jointe(s)

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.

Pièce jointe 223956