optimising per-pixel lighting shader

[supagu]

i've written my first per-pixel lighting shader,
and its not optimised, i've looked at it, tryed moving some things to the vertex shader, but i loose visual quality.

any quick hints as to how i could optimise this?

phong.vert

varying vec3 eye;
varying vec3 light;
varying vec3 normal;
 
void main()
{
	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
	gl_TexCoord[0] = gl_MultiTexCoord0;
 
	eye = vec3( gl_ModelViewMatrix * gl_Vertex );
	light = normalize( gl_LightSource[0].position.xyz - eye );
	normal = normalize( gl_NormalMatrix * gl_Normal );
}

phong.frag

uniform sampler2D texture;
 
varying vec3 eye;
varying vec3 light;
varying vec3 normal;
 
void main()
{
	vec3 nEye = normalize( eye );
	vec3 nLight = normalize( light );
	vec3 nNormal = normalize( normal );	
	vec3 reflectEye = reflect( nEye, nNormal );
 
	float diff = clamp( dot( nLight, nNormal ), 0.0, 1.0 );
 
	float spec = 0.0;		
	if( diff > 0.0 )
		spec = clamp( pow( clamp( dot( reflectEye, nLight ), 0.0, 1.0 ), gl_FrontMaterial.shininess ), 0.0, 1.0);
 
	vec4 difCol = texture2D( texture, vec2(gl_TexCoord[0]) ) * 
		((gl_LightSource[0].diffuse * diff) + gl_LightSource[0].ambient );
 
	vec4 specCol = gl_LightSource[0].specular * spec * gl_FrontMaterial.specular;
 
	gl_FragColor = difCol + specCol;
}

edit: also if you could say why you would do it so i can also understand and learn
cheers

[zed]

vec3 nEye = normalize( eye );
u can normalize this in the vs,
perhaps also the same with the normal
get rid of the if statement

[wizzo]

hi,
here are a couple of thoughts:

first, you dont need to normalize the vectors in the vertex shader, as you will do it in the fragement shader: they WILL become wrong when interpolated for each fragment, so you can save this.

the second point is the if-statement. unless you have a sm3.0 complient card, you wont benefit from it, and it will even be slower than just calculate the sper variable for each fragment.

hope it helped a bit
wizzo.

[splat]

If u want high speed, do what zed says and normalize the vectors only in the vertex shader.
If u don't want the resulting less quality, normalize them in the fs, then u can get rid of of the normalizations in the vertex shader like wizzo says.

But there is another big optimisation:
a dot product never can become more than 1.0. That's why you don't need to clamp it. Use max(dot(), 0.0) instead, so it can't become less than 0.0.

[Volker]

just to correct splat: a dot product with _normalized_ vectors is always in the range [-1..1]. I guess he meant the same thing though.

You can try speeding your shader up by using a cubemap normalizer. On non SM3 hardware and not using half there is no fast native normalize instruction afaik.

Another hint: if you got an nvidia card, use half! Its range is limited (+-65536 i think) but you can use it for unit length vectors, scalars, colors (texture values).

[gulgi]

Originally posted by splat:

But there is another big optimisation:
a dot product never can become more than 1.0. That's why you don't need to clamp it. Use max(dot(), 0.0) instead, so it can't become less than 0.0.

I am also trying to optimize my per-pixel-lighting and for me (GeForce FX5800) using max(dot(), 0) is _slower_ than using clamp(dot(), 0.0, 1.0).
Probably the clamp turns into a dot_sat instruction? (If I remeber correctly, there is a _sat modifier)

Using a normalization cubemap is a _big_ performance boost on a GeForceFX. Or is for me..