// define the light types used (same enums as CLightTemplate)
#define kPoint 0
#define kDirectional  1
#define kSpot  2

// Max num lights. Keep this synchd to CRenderManager MAX_NUM_LIGHTS
#define MAX_NUM_LIGHTS 5

int gActualNumLights; //pass in actual number of lights, for for loop checks

int	   gLightType[MAX_NUM_LIGHTS];
float3 gLightPosition[MAX_NUM_LIGHTS]; 
float3 gLightColor[MAX_NUM_LIGHTS];   
float3 gLightDirection[MAX_NUM_LIGHTS];
float  gLightIntensity[MAX_NUM_LIGHTS];
float  gLightCosHalfAngle[MAX_NUM_LIGHTS];

uniform extern float4x4 gWorld; 
uniform extern float4x4 gVP;
uniform extern float4x4 gWorldInverseTranspose; //used to transform normal without shearing
uniform extern float4 gAmbientMaterial; 
uniform extern float4 gAmbientLight;
uniform extern float4 gDiffuseMaterial;
uniform extern float4 gSpecularMaterial; 
uniform extern float gSpecularPower;
uniform extern float3 gEyePosW;

uniform extern texture gTex;
uniform extern texture gNormalMapTex;


sampler Tex0S = sampler_state
{
	Texture = <gTex>;
	MinFilter = LINEAR;
	MagFilter = LINEAR;
	MipFilter = LINEAR;
	AddressU  = WRAP;
	AddressV  = WRAP;
};

sampler NormMapS = sampler_state
{
	Texture = <gNormalMapTex>;
	MinFilter = LINEAR;
	MagFilter = LINEAR;
	MipFilter = LINEAR;
	AddressU  = WRAP;
	AddressV  = WRAP;
};



struct OutputVS
{
    float4 posH     : POSITION0;
    float3 normalL  : TEXCOORD0;
    float3 posW     : TEXCOORD1;
    float2 tex      : TEXCOORD2; 
    float3 tangentL : TEXCOORD3;
};


OutputVS TransformVS(float3 posL : POSITION0, float3 normalL : NORMAL0, float3 tangentL : TANGENT0, float3 tex0 : TEXCOORD0)
{
        // Zero out our output.
	OutputVS outVS = (OutputVS)0;
	
	//pass on normal and tangent
	outVS.normalL   = normalL;
	outVS.tangentL  = tangentL;  
	
	//Transform vertex position to world space(easier for spec lighting)
	float3 posW = mul(float4(posL,1.0f), gWorld).xyz;
	outVS.posW = posW;
	
	// Transform to homogeneous clip space.
	outVS.posH = mul(float4(posW, 1.0f), gVP);
	
	outVS.tex     = tex0;
	
	// Done--return the output.
       return outVS;
}


float4 TransformPS( float3 normalL  : TEXCOORD0,
					float3 posW     : TEXCOORD1,
					float2 tex      : TEXCOORD2, 
					float3 tangentL : TEXCOORD3 ) : COLOR
{
	
	
	//================================
	// Normal Map Extraction
	//================================
	
	// Step 1) renormalise (interpolated)
	normalL  = normalize(normalL);
	tangentL = normalize(tangentL);
	
	// Step 2) Calculate biTangent
	float3 biTangentL = normalize(cross( normalL, tangentL ));
	float3x3 InvTangentMatrix = float3x3(tangentL, biTangentL, normalL);
	
	// Step 3) Extract normal in correct range (stored 0 -> 1 convert to -1 ->1 
	//float3 TextureNormal = (tex2D( NormMapS, tex )*tex2D( NormMapS, tex ));
	float3 TextureNormal = 2.0f *  tex2D( NormMapS,tex ) - 1.0f; // Scale from 0->1 to -1->1
	
	// step 4) now transform from tangentspace -> model space -> world space
	float3 normalW = normalize( mul( mul( TextureNormal, InvTangentMatrix ), gWorld) );
	
	// TURN FOLLOWING LINES ON FOR DEBUG
	//float4 FinalColor = float4((normalW.x*0.5f)+0.5f,(normalW.y*0.5f)+0.5f,(normalW.z*0.5f)+0.5f,1.0f);
	//return FinalColor;


	//================================
	// Do one off calculations
	
	// Calculate the vector to the eye
	float3 toEye = normalize(gEyePosW - posW);
	
	//================================
	// Now do PER LIGHT calculations
	
	float3 toLight;
	float3 reflected;
	float3 halfway;
	float3 TotalSpecular = 0.0f;
	float3 TotalDiffuse = 0.0f; //add ambient on here for now? 
	float  diffIntensity;
	float  specIntensity;
	float  dist;
	
	for(unsigned int i = 0; i < gActualNumLights; i++)
	{
		if(gLightType == kPoint || gLightType == kSpot)
		{
			// Now calculate the to light vector
			toLight = normalize(gLightPosition - posW);					
		}
		else
		{
			// Directional lights specify their direction globally
			toLight = -normalize(gLightDirection); 			
		}
		
		// Compute the reflection vector
		reflected = reflect(-toLight, normalW);
		
		// proceed exactly in same way (for now) for pixels in point lights and pixels in spot light cones
		if(gLightType == kPoint || (gLightType == kSpot && dot(gLightDirection,-toLight) > gLightCosHalfAngle) || gLightType == kDirectional )
		{	
			// Next calculate the diffuse light intensity hitting the vertex
			diffIntensity = saturate(dot(toLight, normalW));
			
			// Attenuation
			if(gLightType == kDirectional)
			dist = 1;
			else
			dist = distance(gLightPosition, posW);
						
			halfway = normalize( toEye + toLight );
			
			// Use dot to work out intensity of specular (how much actually hits eye)
			// the dot of the reflected and to eye vectors, can be -1 -> 1 so we use
			// max(x,0.0f) to make sure we get a dot in range 0 ->1, then we raise
			// result by the specular power
			specIntensity = pow(saturate(dot(halfway,normalW)), gSpecularPower);
			
			// Now calculate all the light of each type separately
			TotalSpecular += specIntensity  * (gLightIntensity * (gSpecularMaterial*gLightColor)) /dist;	
			
			// Calculate diffuse and ambient, and add together
			// Standard equation: Diffuse = max(0, N.L)
			TotalDiffuse  +=  diffIntensity * (gLightIntensity*(gDiffuseMaterial*gLightColor))/dist;
		}
	}
	
	// calculate ambient
	float3 ambient = (gAmbientMaterial*gAmbientLight).rgb;

	// Now calculate final color based on Total specular/diffuse + ambient
	float4 texColor = tex2D(Tex0S, tex);
	float4 finalColor;
	finalColor.rgb = (TotalDiffuse * texColor  + (TotalSpecular * texColor.a) ); //tweak max attenuation so we dont get /0.01 etc n get super bright
	finalColor.rgb += ambient * texColor ;
	//finalColor.rgb = dot(finalColor, float3(0.33f, 0.33f, 0.33f));
	finalColor.a = texColor.a; //change to texcolor.a for spec map


	return finalColor;

}

technique NormalMapTech
{
    pass P0
    {
        // Specify the vertex and pixel shader associated with this pass.
        vertexShader = compile vs_3_0 TransformVS();
        pixelShader  = compile ps_3_0 TransformPS();

    }
}

PS_IN VS(VS_IN input){	PS_IN output=(PS_IN)0;		float4 wp=mul(float4(input.pos,1.0f),world);	output.pos=mul(wp,viewproj);		output.light=worldLight-wp.xyz;		float3 tan=input.tangent;	float3 binorm=input.binormal;	float3 norm=input.normal;		float3x3 tsm;	tsm[0]=normalize(tan);	tsm[1]=normalize(binorm);	tsm[2]=normalize(norm);			output.light=mul(tsm,output.light);		output.texcoord=input.texcoord;			return output;}float4 PS(PS_IN input) :SV_TARGET{		float3 light=normalize(input.light);		float3 normal=2*normalTexture.Sample(sampler1,input.texcoord)-1.0f;	float dp=saturate(dot(light,normal));		return dp;}