Thanks.

I was trying to see if it's possible without using the color of the light, because that would save me 2 float3's.

Because the specular intensity is just a single float:

float diffIntPoint = saturate(dot(normal, lightDir) * att);			
diffusePoint += saturate(diffIntPoint * PointLightColInt[i]);	// float3

In the end pixel calculation is now have:

return float4((saturate(AmbientColInt + (MatDiff * (diffuseDir + diffusePoint)) + (MatSpec * (specularDir + specularPoint)) + MatEmi) * textureColor.rgb), textureColor.a);

How should I define specularAlbedo within the shader with 2 'variants'.

I think I should use the MaterialSpec color to distinguish metals / non metals, but I don't understand how to define 'RGB' and 'monochrome' (distinguish them with 1 calculation).

Hi Styves,

I've tried your suggestion and did the following, is this what you mean?

Maybe there's a better way to check if the vector/float3 is 0,0,0.

I didn't profile yet (with pix) if there's an advantage in doing the if check/ branch, compared to calculating the specular values without result.

In my code/ engine:

		if(mMaterials[mc].d3dMaterial.Specular.r != 0.0f &&
		   mMaterials[mc].d3dMaterial.Specular.g != 0.0f &&
		   mMaterials[mc].d3dMaterial.Specular.b != 0.0f)
		{
			D3dcolorToFloat4Array(mMaterials[mc].d3dMaterial.Specular, mMaterials[mc].specularF);
		}

(specularF is the float arrat that feeds the shader constant)

And in the pixel shader:

uniform extern float4	MatSpec		: MATERIAL_SPECULAR = {0.0f, 0.0f, 0.0f, 0.0f};


	for(int i=0;i<MaxDirectionalLights;i++)
	{	
		diffuseDir	+= saturate(DirLightColInt[i] * dot(normal,  DirLightDir[i]));

		if(MatSpec != 0.0f, 0.0f, 0.0f, 0.0f)
		{	
			float3 lightdir = normalize(DirLightDir[i] - input.wPos);
			float3 h = normalize(lightdir + input.ViewDir);
			specularDir += (pow(saturate(dot(h, normal)), MatSpecPower) * DirLightColInt[i]);
		}
	}

// and for point lights:

		if(MatSpec != 0.0f, 0.0f, 0.0f, 0.0f)
		{	
			float3 h = normalize(lightDir + input.ViewDir);

			specularPoint += pow(saturate(dot(h, normal)), MatSpecPower) * att * PointLightColInt[i];

		}

Update; although it compiles, my specular highlights are gone now, probably something with checking the MatSpec float4 array

Thanks, I've got working using the "if(any(..." statement.

Not sure though what the performance gain is, I'll profile it later.

Here's the result, might you have remarks..

The engine code:

		// only save specular material for shader constant when needed
		// shader checks 'if(any)' and saves cycles when no specular needed
		if(mMaterials[mc].d3dMaterial.Specular.r != 0 && 
		   mMaterials[mc].d3dMaterial.Specular.g != 0 &&
		   mMaterials[mc].d3dMaterial.Specular.b != 0) 
		{
			D3dcolorToFloat4Array(mMaterials[mc].d3dMaterial.Specular, mMaterials[mc].specularF);
		}
		else
		{
			mMaterials[mc].specularF[0] = 0.0f;
			mMaterials[mc].specularF[1] = 0.0f;
			mMaterials[mc].specularF[2] = 0.0f;
			mMaterials[mc].specularF[3] = 0.0f;
		}

Relevant parts of the (pixel) shader:

/** 	DIRECTIONAL LIGHTS - PER PIXEL (DIFFUSE & SPECULAR) **/
	float3 diffuseDir = 0.0f;
	float3 specularDir = 0.0f;

	for(int i=0;i<MaxDirectionalLights;i++)
	{	
		diffuseDir	+= saturate(DirLightColInt[i] * dot(normal,  DirLightDir[i]));
	
		if(any(MatSpec))
		{
			float3 lightdir = normalize(DirLightDir[i] - input.wPos);
			float3 h = normalize(lightdir + input.ViewDir);
			specularDir += (pow(saturate(dot(h, normal)), MatSpecPower) * DirLightColInt[i]);
		}
	}

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

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

In the calculation of the final pixel color I still take the specular components into account.

I might also do the check there (if any) and have 2 final pixel color calculations, don't think that's that big of a gain.

Thanks, I think I've got it.

So summarize:

- combining 2 multiplications + 1 add is done more efficiently on the GPU, so making 'sets' is better for performance

- I can combine the diffuse and specular light float3's for diffuse total and specular total (diffuseAcc/ specularAcc), for both the directional and point lights

I've made the changes and it's all working nice.

Here's my resulting pixelshader, how does it look?

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

	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(normal,  DirLightDir[i]));

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

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

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

		// PER PIXEL ATTENUATION
		float dist = length(PointLightPos[i] - input.wPos);

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

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

		// SPECULAR; USING BLINN HALF ANGLE

		if(any(MatSpec))
		{
			float3 h = normalize(lightDir + input.ViewDir);
			specularAcc += pow(saturate(dot(h, normal)), MatSpecPower) * att * PointLightColInt[i];
		}
	}

/**	FINAL PIXEL COLOR **/

	return float4(textureColor.rgb * (MatDiff * diffuseAcc + AmbientColInt) + (MatSpec * specularAcc + MatEmi), textureColor.a);
}

Ps.; I might be able to raise the max. number of point lights from 3 to 4 for my Shader Model 2.0 versions of my shaders, because of less instructions

On the optimization side;

- I could use one float2 for point light range and full power range, and save another 'instruction'/constant

Do you see any other small things to improve?

I think I've moved as much as possible from the PX to the VS and pre-calculate as much as possible/ acceptable on the CPU side.