If you add the different point lights within your one shader (effect), you don't have to enable blending. The reason is that the light calculations are added up already within the shader, therefor you don't need to blend the different lights 'on to the mesh'.

Here's a part of my lighting shader which basically does this:

// globals in the effect

#define MaxPointLights 8

extern float3		PointLightPos[MaxPointLights];
extern float2		PointLightRange[MaxPointLights];	// x = range, y = FP range
extern float3		PointLightColInt[MaxPointLights];				

// directional and point lights, calculation in the pixel shader

float4 PS_function(VS_OUTPUT input): COLOR0
{
	float4 textureColor = tex2D(textureSampler, input.TexCoord);

	float3 normalMap = normalize(2.0f * tex2D(normalMapSampler, input.TexCoord).xyz - 1.0f);
	normalMap = mul(normalMap, input.WorldToTangent);

	float3 diffuseAcc = 0.0f;
	float3 specularAcc = 0.0f;

/** 	DIRECTIONAL LIGHTS - PER PIXEL (DIFFUSE & SPECULAR) **/
	for(int i=0;i<MaxDirectionalLights;i++)
	{	
		diffuseAcc	= saturate(DirLightColInt[i] * dot(normalMap,  DirLightDir[i]) + diffuseAcc); 

		if(any(diffuseAcc) && any(MatSpec))
		{
			float3 lightdir = normalize(DirLightDir[i] - input.wPos);
			float3 h = normalize(lightdir + input.ViewDir);
			
			specularAcc = pow(saturate(dot(h, normalMap)), MatSpecPower) * DirLightColInt[i] + specularAcc;
		}
	}

/** 	POINT LIGHTS - PER PIXEL (DIFFUSE & SPECULAR) **/

	for(int i=0;i<MaxPointLights;++i)
	{
		float3 lightDir = (PointLightPos[i] - input.wPos);

		// PER PIXEL ATTENUATION
		float dist = length(lightDir);
		lightDir = lightDir / (dist + 0.001);

		float att = saturate(1 - ((dist - PointLightRange[i].y) / (PointLightRange[i].x - PointLightRange[i].y)));
		att *= att;	// optional, not correct for full power range !?!?

		// DIFFUSE

		float diffIntPoint = saturate(dot(normalMap, lightDir) * att);			
		diffuseAcc = diffIntPoint * PointLightColInt[i] + diffuseAcc;

		// SPECULAR; USING BLINN HALF ANGLE

		if(any(diffuseAcc) && any(MatSpec))
		{
			float3 h = normalize(lightDir + input.ViewDir);

			specularAcc = pow(saturate(dot(h, normalMap)), MatSpecPower) * att * PointLightColInt[i] + specularAcc;
		}
	}

Nothing looks wrong with your depth states, except which pass is this? If you are rendering with multiple passes we need to see multiple states, one for each pass.
If you are using z-prepass then your depth function should be testing for “equal” on following passes, for one. Why is your alpha operation “max”?


L. Spiro

If you add the different point lights within your one shader (effect), you don't have to enable blending. The reason is that the light calculations are added up already within the shader, therefor you don't need to blend the different lights 'on to the mesh'.

Here's a part of my lighting shader which basically does this:

// globals in the effect

#define MaxPointLights 8

extern float3		PointLightPos[MaxPointLights];
extern float2		PointLightRange[MaxPointLights];	// x = range, y = FP range
extern float3		PointLightColInt[MaxPointLights];				

// directional and point lights, calculation in the pixel shader

float4 PS_function(VS_OUTPUT input): COLOR0
{
	float4 textureColor = tex2D(textureSampler, input.TexCoord);

	float3 normalMap = normalize(2.0f * tex2D(normalMapSampler, input.TexCoord).xyz - 1.0f);
	normalMap = mul(normalMap, input.WorldToTangent);

	float3 diffuseAcc = 0.0f;
	float3 specularAcc = 0.0f;

/** 	DIRECTIONAL LIGHTS - PER PIXEL (DIFFUSE & SPECULAR) **/
	for(int i=0;i<MaxDirectionalLights;i++)
	{	
		diffuseAcc	= saturate(DirLightColInt[i] * dot(normalMap,  DirLightDir[i]) + diffuseAcc); 

		if(any(diffuseAcc) && any(MatSpec))
		{
			float3 lightdir = normalize(DirLightDir[i] - input.wPos);
			float3 h = normalize(lightdir + input.ViewDir);
			
			specularAcc = pow(saturate(dot(h, normalMap)), MatSpecPower) * DirLightColInt[i] + specularAcc;
		}
	}

/** 	POINT LIGHTS - PER PIXEL (DIFFUSE & SPECULAR) **/

	for(int i=0;i<MaxPointLights;++i)
	{
		float3 lightDir = (PointLightPos[i] - input.wPos);

		// PER PIXEL ATTENUATION
		float dist = length(lightDir);
		lightDir = lightDir / (dist + 0.001);

		float att = saturate(1 - ((dist - PointLightRange[i].y) / (PointLightRange[i].x - PointLightRange[i].y)));
		att *= att;	// optional, not correct for full power range !?!?

		// DIFFUSE

		float diffIntPoint = saturate(dot(normalMap, lightDir) * att);			
		diffuseAcc = diffIntPoint * PointLightColInt[i] + diffuseAcc;

		// SPECULAR; USING BLINN HALF ANGLE

		if(any(diffuseAcc) && any(MatSpec))
		{
			float3 h = normalize(lightDir + input.ViewDir);

			specularAcc = pow(saturate(dot(h, normalMap)), MatSpecPower) * att * PointLightColInt[i] + specularAcc;
		}
	}

This is probably off-topic...

In the past I have used a similar solution but right now I'm using permutations. With permutations you have one specialized PS for 1 point light, another for two, another for 3... All of them index everything directly, so the 3rd light won't use PointLightColInt, where i == 2. It will use PointLightColInt[2]. I guess the same effect could be achieved with a for loop ending in different constant upper bounds and unrolled loops, but just to be safe everything is explicitly indexed. The code is auto-generated anyway. This solution works well and performs well, but it is kind of cumbersome.

Has anybody any experience regarding the performance difference between the two approaches? Is it significant or is my approach suffering from premature optimization? I'm using pixel shader 3 under DX9.