Shader qui fonctionne mal

Version imprimable

Bonjour à tous,

J’essaie de créer un Shader qui peut gérer plusieurs lumières (Directionnel, Point et Spot). Le problème que je rencontre est que le modèle 3D texturé s'affiche mais c'est comme s'il n'y avait pas de lumière du tout. Le modèle est affiché à l'écran mais il est tout noir.

Alors voici le VerrtexShader :

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
#version 140
 
in vec3 Position;
in vec3 Normal;
in vec2 UVMap;
in vec3 Tangent;
 
out vec2 STMap;
out vec3 normal0;
out vec3 FragPos;
 
uniform mat4 ModelMatrix;
uniform mat4 ViewMatrix;
uniform mat4 ProjectionMatrix;
 
void main()
{
	vec4 WorldPosition = ModelMatrix * vec4(Position, 1.0);
        gl_Position = ProjectionMatrix * ViewMatrix * WorldPosition;
 
	normal0 = vec3(ModelMatrix * vec4(Normal, 0.0));
	STMap = UVMap;
        FragPos = WorldPosition.xyz;
}

Et le FragmentShader qui va avec :

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#version 140
 
#define NUMBER_OF_POINT_LIGHTS 4
#define NUMBER_OF_SPOT_LIGHTS 4
 
struct SMaterial
{
    sampler2D Diffuse;
    sampler2D Specular;
    float Shininess;
};
 
struct SDirectionalLight
{
    vec3 Direction;
    vec3 Ambient;
    vec3 Diffuse;
    vec3 Specular;
};
 
struct SPointLight
{
    vec3 Position;
    vec3 Ambient;
    vec3 Diffuse;
    vec3 Specular;
    float Constant;
    float Linear;
    float Quadratic;
};
 
struct SSpotLight
{
    vec3 Position;
    vec3 Direction;
    vec3 Ambient;
    vec3 Diffuse;
    vec3 Specular;
    float CutOff;
    float OuterCutOff;
    float Constant;
    float Linear;
    float Quadratic;
};
 
 
 
in vec2 STMap;
in vec3 normal0;
in vec3 FragPos;
 
uniform vec3 ViewPos;
uniform SDirectionalLight DirectionalLight;
uniform SPointLight PointLights[NUMBER_OF_POINT_LIGHTS];
uniform SSpotLight SpotLights[NUMBER_OF_SPOT_LIGHTS];
uniform SMaterial Material;
 
vec3 CalcDirectionalLight(SDirectionalLight Light, vec3 Normal, vec3 ViewDir);
vec3 CalcPointLight(SPointLight Light, vec3 Normal, vec3 FragPos, vec3 ViewDir);
vec3 CalcSpotLight(SSpotLight Light, vec3 Normal, vec3 FragPos, vec3 ViewDir);
 
void main()
{
 
	vec3 norm = normalize(normal0);
	vec3 ViewDirection = normalize(ViewPos - FragPos);
 
	vec3 Result = CalcDirectionalLight(DirectionalLight, norm, ViewDirection);
 
	for (int i = 0; i < NUMBER_OF_POINT_LIGHTS; i++)
	{
		Result += CalcPointLight(PointLights[i], norm, FragPos, ViewDirection);
	}
 
	for (int i = 0; i < NUMBER_OF_SPOT_LIGHTS; i++)
	{
		Result += CalcSpotLight(SpotLights[i], norm, FragPos, ViewDirection);
	}
 
	gl_FragColor = vec4(Result, 1.0);
 
}
 
 
// Calculates the color when using a directional light.
vec3 CalcDirectionalLight(SDirectionalLight Light, vec3 Normal, vec3 ViewDir)
{
    vec3 LightDir = normalize(-Light.Direction);
 
    // Diffuse shading
    float Diff = max(dot(Normal, LightDir), 0.0);
 
    // Specular shading
    vec3 ReflectDir = reflect( -LightDir, Normal);
    float Spec = pow( max( dot( ViewDir, ReflectDir ), 0.0 ), Material.Shininess);
 
    // Combine results
    vec3 Ambient = Light.Ambient * vec3( texture(Material.Diffuse, STMap));
    vec3 Diffuse = Light.Diffuse * Diff * vec3( texture(Material.Diffuse, STMap));
    vec3 Specular = Light.Specular * Spec * vec3( texture(Material.Specular, STMap));
 
    return (Ambient + Diffuse + Specular);
}
 
// Calculates the color when using a point light.
vec3 CalcPointLight(SPointLight Light, vec3 Normal, vec3 FragPosition, vec3 ViewDir)
{
    vec3 LightDir = normalize(Light.Position - FragPosition);
 
    // Diffuse shading
    float Diff = max(dot(Normal, LightDir), 0.0);
 
    // Specular shading
    vec3 ReflectDir = reflect( -LightDir, Normal);
    float Spec = pow( max( dot( ViewDir, ReflectDir ), 0.0 ), Material.Shininess);
 
    // Attenuation
    float Distance = length(Light.Position - FragPosition);
    float Attenuation = 1.0f / (Light.Constant + Light.Linear * Distance + Light.Quadratic * Distance * Distance);
 
    // Combine results
    vec3 Ambient = Light.Ambient * vec3( texture(Material.Diffuse, STMap));
    vec3 Diffuse = Light.Diffuse * Diff * vec3( texture(Material.Diffuse, STMap));
    vec3 Specular = Light.Specular * Spec * vec3( texture(Material.Specular, STMap));
 
    Ambient *= Attenuation;
    Diffuse *= Attenuation;
    Specular *= Attenuation;
 
    return (Ambient + Diffuse + Specular);
}
 
// Calculates the color when using a spot light.
vec3 CalcSpotLight(SSpotLight Light, vec3 Normal, vec3 FragPosition, vec3 ViewDir )
{
    vec3 LightDir = normalize(Light.Position - FragPosition );
 
    // Diffuse shading
    float Diff = max( dot(Normal, LightDir ), 0.0 );
 
    // Specular shading
    vec3 ReflectDir = reflect(-LightDir, Normal );
    float Spec = pow( max( dot( ViewDir, ReflectDir ), 0.0 ), Material.Shininess );
 
    // Attenuation
    float Distance = length(Light.Position - FragPosition );
    float Attenuation = 1.0f / (Light.Constant + Light.Linear * Distance + Light.Quadratic * Distance * Distance);
 
    // Spotlight intensity
    float Theta = dot(LightDir, normalize(-Light.Direction));
    float Epsilon = Light.CutOff - Light.OuterCutOff;
    float Intensity = clamp((Theta - Light.OuterCutOff ) / Epsilon, 0.0, 1.0);
 
    // Combine results
    vec3 Ambient = Light.Ambient * vec3( texture(Material.Diffuse, STMap));
    vec3 Diffuse = Light.Diffuse * Diff * vec3( texture(Material.Diffuse, STMap));
    vec3 Specular = Light.Specular * Spec * vec3( texture(Material.Specular, STMap));
 
    Ambient *= Attenuation * Intensity;
    Diffuse *= Attenuation * Intensity;
    Specular *= Attenuation * Intensity;
 
    return (Ambient + Diffuse + Specular);
}

C'est inspiré du code disponible ici : https://github.com/SonarSystems/Modern-OpenGL-Tutorials

Ça fait plusieurs jours que j'étudie le problème et je comprends pas pourquoi ça marche pas totalement alors que le code original fonctionne. Voir ici

https://www.youtube.com/watch?v=vnUQ...?v=vnUQOIODAKc

Merci à l'avance.
StarBootics

28/01/2019, 09h46
LittleWhite

Bonjour,

Cela peut être un problème de texture (mal chargée ou mal configurée).
Si vous voulez un autre source d'inspiration, vous pouvez voir ces tutoriels OpenGL en français.

Bonjour à tous,

Voici le premier prototype (Point light) qui fonctionne, 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
31
#version 140
 
in vec3 Position;
in vec3 Normal;
in vec2 UVMap;
in vec3 Tangent;
 
out vec2 STMap;
out vec3 normal0;
out vec3 ToLightVector[4];
out vec3 ToCameraVector;
 
uniform mat4 ModelMatrix;
uniform mat4 ViewMatrix;
uniform mat4 ProjectionMatrix;
uniform vec3 LightPosition[4];
 
void main()
{
	vec4 WorldPosition = ModelMatrix * vec4(Position, 1.0);
        gl_Position = ProjectionMatrix * ViewMatrix * WorldPosition;
 
	normal0 = vec3(ModelMatrix * vec4(Normal, 0.0));
	STMap = UVMap;
 
	for (int i=0;i<4;i++){
		ToLightVector[i] = LightPosition[i] - WorldPosition.xyz;
	}
 
	ToCameraVector = (inverse(ViewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz - WorldPosition.xyz;
}

Le fragement shader qui va avec :

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
34
35
36
37
38
#version 140
 
in vec2 STMap;
in vec3 normal0;
in vec3 ToLightVector[4];
in vec3 ToCameraVector;
 
uniform sampler2D DiffuseTexture;
uniform vec4 LightColor[4];
uniform vec3 Attenuation[4];
uniform float ShineDamper;
uniform float Shininess;
 
void main()
{
	vec3 UnitNormal = normalize(normal0);
	vec3 UnitToCameraVector = normalize(ToCameraVector);
	vec4 TotalDiffuse = vec4(0.0);
	vec4 TotalSpecular = vec4(0.0);
 
	for(int i=0; i<4; i++){
		float Distance = length(ToLightVector[i]);
		float AttFactor = Attenuation[i].x + (Attenuation[i].y * Distance) + (Attenuation[i].z * Distance * Distance);
		vec3 UnitLightVector = normalize(ToLightVector[i]);
		float Brightness = max(dot(UnitNormal, UnitLightVector), 0.0);
 
		vec3 LightDirection = -UnitLightVector;
		vec3 ReflectedLightDirection = reflect(LightDirection, UnitNormal);
		float SpecularFactor = max(dot(ReflectedLightDirection, UnitToCameraVector), 0.0);
		float DampedFactor = pow(SpecularFactor, ShineDamper); 
		TotalDiffuse = TotalDiffuse + (Brightness * LightColor[i]) / AttFactor;	
		TotalSpecular = TotalSpecular + (DampedFactor * Shininess * LightColor[i]) / AttFactor;
	}
 
	TotalDiffuse = max(TotalDiffuse, 0.2);
	gl_FragColor = TotalDiffuse * texture(DiffuseTexture, STMap) + TotalSpecular;
 
}

Sans rien changer à la commande qui charge la texture ce shader fonctionne mais pas le nouveau. Je commence à être à court d'idée parce que la seule différence est que le sampler2D pour la texture est dans une structure et j'utilise une Map spéculaire ce que je ne faisait pas avant.

@ LittleWhite : Merci pour ta réponse

A+
StarBootics

29/01/2019, 11h35
dragonjoker59

J'ai un doute sur la validité d'un sampler dans une struct.
29/01/2019, 15h41
StarBootics

Nouveau développement,

La lumière directionnel fonctionne bien lorsque utilisé seule. Le problème se trouve dans les calculs des points de lumière. J'ai pas encore testé les spots.
Je vous garde au courant.

A+
StarBootics
31/01/2019, 02h18
StarBootics

Bonjour à tous,

Je viens de trouver le problème, laisser moi vous expliquer. Pour le moment je n'ai ajouté qu'une seule lumière de type point même s'il y en a 4 de prévue. Je charge tout de même les 3 autres lumières avec des valeurs de couleurs nulles et curieusement c'est de faire ça qui pose problème. Étant donné que c'est de l'addition vectoriel j'aurais pensé que mettre des valeurs nulles pour les lumières non utilisées ferait en sorte qu'elles n'auraient aucun impact sur la couleur finale. C'est manifestement pas le cas.

Maintenant que je comprends le problème je vais pouvoir avancer.

A+
StarBootics
31/01/2019, 21h18
StarBootics

Bonjour à tous,

Lumière Directionnelle --> OK
Point de lumière --> OK
Spot de lumière --> KO

Apparemment la Brillance (Shininess) égale à 0.0 causait beaucoup de problème. Je l'ai mis à 1.0 comme valeur minimum et pouf d'un seul coup plusieurs problèmes ont disparus. Il me reste que les Spot de lumière à étudier pour comprendre pourquoi eux ne fonctionne pas. Je vous tient au courant.

A+
StarBootics
08/02/2019, 23h13
StarBootics

Bonjour à tous,

J'ai réussi à solutionner le problème avec la technique de rendu dite "Forward Rendering" qui consiste à faire l'éclairage en plusieurs passes. Il me reste quelques soucis mais en gros ça fonctionne.

A+
StarBootics