Discussion :

[Chouquette]

Salut,

Je decouvre les shaders depuis quelques jours maintenant, et j'essaye d'implementer la luminosite per pixel via un shader.
Le probleme c'est que mon resultat n'est qu'un plan miserablement gris... et je ne comprend pas pourquoi j'ai l'impression de suivre correctement le tuto4 de typhoonlabs...
Voila en gros ce que j'obtiens avec sans shader :

et avec :


Je m'aventure donc a en deduire que mon code marche en ce qui concerne la partie OpenGL...
Au niveau du code du shader c'est globalement le meme que dans le tuto typhoonlabs, je le paste quand meme au cas ou :
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
 
uniform sampler2D 	texture;
varying vec3		normal;
varying vec3		position;
//uniform vec3		CAMERA_POSITION;
void	 main(void)
{
	gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
	gl_Position = ftransform();
 
	normal = gl_Normal.xyz;
	position = gl_Vertex.xyz;
}

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
34
35
 
uniform sampler2D 	texture;
//uniform vec3		CAMERA_POSITION;
varying vec3		normal;
varying vec3		position;
 
void	main(void)
{
	vec4	color = texture2D(texture, vec2(gl_TexCoord[0].x, gl_TexCoord[0].y));
	vec4	specular = vec4(0.0);
	vec4	diffuse;
 
	vec3	norm = normalize(normal);
	vec3	lightVector = gl_LightSource[0].position.xyz - position;
	float	dist = length(lightVector);
	float	attenuation = 1.0 / (gl_LightSource[0].constantAttenuation +
									gl_LightSource[0].linearAttenuation * dist +
									gl_LightSource[0].quadraticAttenuation * dist * dist);
	lightVector = normalize(lightVector);
 
	float 	nxDir = max(0.0, dot(norm, lightVector));
	diffuse = gl_LightSource[0].diffuse * nxDir * attenuation;
 
//	if (nxDir != 0.0)
//	{
//		vec3	cameraVector = normalize(CAMERA_POSITION - position.xyz);
//		vec3	halfVector = normalize(lightVector + cameraVector);
//		float	nxHalf = max(0.0, dot(norm, halfVector));
//		float	specularPower = pow(nxHalf, gl_FrontMaterial.shininess);
//		specular = gl_LightSource[0].specular * specularPower * attenuation;
//	}
	gl_FragColor = gl_LightSource[0].ambient +
						(diffuse * vec4(color.rgb, 1.0)) +
						(specular * color.a);
}

J'ai bien conscience que ca fait un peu "debugguez mon programme pour moi" donc je suis tout a fait preneur d'une ligne directrice pour chercher la solution a mon probleme
Merci beaucoup a ceux qui prendront le temps de m'aider

[razmott]

Salut !

A moins que je ne me trompe le problème viens du fragment shader :
lors de ton calcul des composantes ambientes, diffuses et spéculaires, tu oublies tout simplement d'utiliser la couleur issue de la texture.

Bon coding !
@+

[Chouquette]

J'ai essaye de patcher un peu mals le resultat reste le meme plus ou moins...

si je me souviens l'algo de base c'est
couleur * cos(angle(normal, lumiere))

je t'avoue que je vois pas vraiment pourquoi
gl_FragColor = color * nxDir + gl_LightSource[0].diffuse * nxDir; (surface totalement noir)
ou encore plus simplement color*nxDir ne marche pas (surface grise comme dans le screen)

Ca me semble quand meme assez logique comme calcul
Je cherche plutot au niveau du calcul du cosinus entre les 2 vecteurs mais je vois pas trop ou est l'erreur

[razmott]

Salut !

On pourrait débugguer comme ça pendant longtemps, alors voici un lien qui devrait t'aider :
http://www.lighthouse3d.com/opengl/g...dex.php?lights

Sinon, j'ai vu que tu ne transformes ni la position du vertice ni la normale.

Bon coding !
@+

[Chouquette]

Justement j'ai essaye de le suivre et meme resultat : surface noire

J'ai trouve un autre tuto je vais essayer de le suivre, mais j'ai l'impression que selon les tutos ils transforment ou non....
Pourtant si je ne m'abuse, la normal est en position simple (par simple, j'entend sur un repere 0, 0, 0 d'ailleurs si il y a un nom plus approprie je suis preneur ) soit en 0, 1, 0
En prenant juste la position du spot, on en deduit le vecteur 0, 0, 0 - spot
Il suffit d'avoir les deux en normalise, puis de faire un produit scalaire sur les deux et paf ca fait des chocapics, ou tout du moins la lumiere devrait marcher.... mais enfait non
Je me sens un peu perdu la enfait :p

[Chouquette]

Bon ca marche mieux avec ce tuto :
http://www.davidcornette.com/glsl/glsl.html
Y a deux trois trucs a corriger mais chez moi ca marche quand meme vachement mieux.