struct Input {
	float3 position		: TEXCOORD0;
	float3 normal		: TEXCOORD1;
	float2 texCoord		: TEXCOORD2;
	float3 tangent		: TEXCOORD3;
	float3 binormal		: TEXCOORD4;
};

// textures
uniform sampler2D diffuseMap		: TEXUNIT0;
uniform sampler2D specularMap		: TEXUNIT1;
uniform sampler2D bumpMap			: TEXUNIT2;
uniform sampler2D reflectMap		: TEXUNIT3;
uniform samplerCUBE environmentMap	: TEXUNIT4;

// inverse view matrix
uniform float3x4 inverseViewMatrix;

// material properties
uniform float mtlBumpMode;		// 0 = none, 1 = normal, 2 = parallax
uniform float mtlSpecMode;		// 0 = constant, 1 = map
uniform float mtlReflectMode;	// 0 = none, 1 = constant, 2 = map
uniform float3 mtlEmissive;
uniform float3 mtlAmbient;
uniform float4 mtlDiffuse;
uniform float4 mtlSpecularShininess; // rgb = specular, a = shininess
uniform float mtlReflectivity;

// scene properties
uniform float4 sceneFog; // rgb = color, a = density
uniform float3 sceneAmbient;

// light properties
static const int MAX_LIGHTS = 8;
uniform float lightCount;
uniform float lightType[MAX_LIGHTS]; // 0 = directional, 1 = spot
uniform float3 lightPosition[MAX_LIGHTS]; // doubles as direction for directional lights
uniform float3 lightAttenuation[MAX_LIGHTS]; // usage: x + y*D + z*D^2
uniform float3 lightAmbient[MAX_LIGHTS];
uniform float3 lightDiffuseSpecular[MAX_LIGHTS]; // diffuse and specular color

float3 rgbToXyz( float3 rgb ) {
	return rgb * 2.0f - 1.0f;
}

void main( in Input input, out float4 color : COLOR ) {
	input.normal = normalize( input.normal );

	// normal or parallax mapping
	if (mtlBumpMode > 0.0f) {
		// normalize these if needed
		input.tangent = normalize( input.tangent );
		input.binormal = normalize( input.binormal );

		// parallax mapping
		if (mtlBumpMode == 2.0f) {
			// apply parallax mapping
			float bumpScale = 0.05f;
			float fDepth = 0.0f;
			float2 vHalfOffset = float2( 0.0f, 0.0f );
			float2 eyeVector = float2( dot( input.position, input.tangent ),
									   dot( input.position, input.binormal ) );
			for (int i = 0; i < 3; ++i) {
				fDepth = (fDepth + (1.0f - tex2D( bumpMap, input.texCoord + vHalfOffset ).a)) * 0.5f;
				vHalfOffset = normalize( eyeVector ).xy * fDepth * bumpScale;
			}
			input.texCoord += vHalfOffset;
		}

		// apply normal mapping by sampling our bump map and multiplying by tbn
		float3 bump = rgbToXyz( tex2D( bumpMap, input.texCoord ).rgb );
		input.normal = normalize( input.tangent * bump.x +
								  input.binormal * bump.y +
								  input.normal * bump.z );
	}

	// declare a float3 to hold our diffuse color
	float3 diffuse;

	// apply reflection mapping
	if (mtlReflectMode == 1.0f) {
		// get the reflection vector in eye space
		// multiply it by inverse view matrix to get it into world space
		float3 reflectCoord = reflect( input.position, input.normal );
		reflectCoord = mul( inverseViewMatrix, float4( reflectCoord, 0.0f ) ).xyz;
		// lerp based on reflectivity constant
		diffuse = lerp( tex2D( diffuseMap, input.texCoord ).rgb,
						texCUBE( environmentMap, reflectCoord ).rgb,
						mtlReflectivity );
	} else if (mtlReflectMode == 2.0f) {
		// get the reflection vector in eye space
		// multiply it by inverse view matrix to get it into world space
		float3 reflectCoord = reflect( input.position, input.normal );
		reflectCoord = mul( inverseViewMatrix, float4( reflectCoord, 0.0f ) ).xyz;
		// lerp based on sampled reflection map
		diffuse = lerp( tex2D( diffuseMap, input.texCoord ).rgb,
						texCUBE( environmentMap, reflectCoord ).rgb,
						tex2D( reflectMap, input.texCoord ).r );
	} else
		diffuse = tex2D( diffuseMap, input.texCoord ).rgb;

	// multiply diffuse by material diffuse
	diffuse *= mtlDiffuse.rgb;

	// declare a float4 to hold our specular color
	float4 specular;

	if (mtlSpecMode == 0.0f)
		specular = mtlSpecularShininess;
	else
		specular = tex2D( specularMap, input.texCoord ).rgba;

	// now we compute lighting

	float3 intensity = mtlEmissive + mtlAmbient*sceneAmbient;

	float3 eyeDir = -normalize( input.position );
	for (int i = 0; i < lightCount && i < MAX_LIGHTS; ++i) {
		// for each light
		// first compute direction and attenuation
		float3 lightDir;
		float attenuation;
		if (lightType == 0) {
			// directional light
			lightDir = -lightPosition;
			attenuation = 1.0f;
		} else {
			// point light
			lightDir = lightPosition - input.position;
			float dist = length( lightDir );
			lightDir /= dist;
			attenuation = 1.0f/(lightAttenuation.x +
								lightAttenuation.y * dist +
								lightAttenuation.z * dist * dist);
		}
		// compute the half vector for specularity
		float3 halfVec = normalize( (lightDir + eyeDir) * 0.5f );

		// compute N.L and N.H
		float nDotL = saturate( dot( input.normal, lightDir ) );
		float nDotH = saturate( dot( input.normal, halfVec ) );

		// determine the amount to increase the intensity by
		// we add ambient into this term because each light can contribute ambiently,
		// but only when an object is near the light; it attenuates like diffuse and specular
		// if overall ambient is wanted, use scene ambient
		float3 increase = mtlAmbient*lightAmbient +
						  (diffuse*nDotL + specular.rgb*pow( nDotH, specular.a )*saturate( nDotL*5.0f )) * lightDiffuseSpecular;

		// weight by attenuation
		intensity += attenuation * increase;
	}

	// compute the fog amount: e^-(density * z)
	float fogAmount = saturate( pow( 2.71828183f, -sceneFog.a * input.position.z ) );

	// finally, compute fragment color
	color = float4( lerp( intensity, sceneFog.rgb, fogAmount ), mtlDiffuse.a );
}

for (int i = 0; i < MAX_LIGHTS; ++i) {
	if (i >= lightCount)
		continue;
	...