shared float4x4 World;
shared float4x4 View;
shared float4x4 Projection;

shared float4 ambientColor = 1.0;

shared float3 cameraPosition;

//material properties
shared float specularPower;
shared float specularIntensity;

// TODO: add effect parameters here.
Texture inTexture;
float2 UVoffSet = 0;

sampler TextureSampler = sampler_state 
{ 
	texture = <inTexture>; 
	magfilter = LINEAR; 
	minfilter = LINEAR; 
	mipfilter = LINEAR; 
	AddressU = WRAP; 
	AddressV = WRAP;
};

struct Light 
{
    float4 color;
    float3 position;
    bool enable;
};

Light light;

struct VertexShaderInput
{
    float4 Position : POSITION0;
    float3 Normal : NORMAL;
    float2 UV : TEXCOORD1;

};

struct VertexShaderOutput
{
    float4 Position : POSITION0;
    float4 WorldPosition : TEXCOORD0;
    float3 WorldNormal : TEXCOORD1;
    float2 UV : TEXCOORD2;
};

//This simply populates the struct used by the pixel shader.
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
    VertexShaderOutput output;

	float4x4 wvp = mul(mul(World,View),Projection);
    output.Position = mul(input.Position, wvp);
    output.UV = input.UV;

	output.WorldNormal =  mul(input.Normal, World);
	float4 worldPosition =  mul(float4(input.Position.x,input.Position.y,input.Position.z, 1.0), World);
	output.WorldPosition = worldPosition / worldPosition.w;

    return output;
}

float4 CalculateSingleLight(Light light, float3 worldPosition, float3 worldNormal)
{
	float4 diffuse;
	float4 specular;
	 if(light.enable)
	 {
		 float3 lightVector = light.position - worldPosition;
		 float3 directionToLight = normalize(lightVector);
	     
		 float diffuseIntensity = saturate( dot(directionToLight, worldNormal));
		 diffuse = diffuseIntensity * light.color;

		 //calculate Phong components per-pixel
		 float3 reflectionVector = normalize(reflect(-directionToLight, worldNormal));
		 float3 directionToCamera = normalize(cameraPosition - worldPosition);
	     
		 //calculate specular component
		 specular = saturate(light.color * specularIntensity * 
						   pow(saturate(dot(reflectionVector, directionToCamera)), 
							   specularPower));
     }
     return  (ambientColor + diffuse + specular);
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
	float4 outputColor;
	outputColor.a = 1;
	
	float2 UVCoord = input.UV;
	UVCoord.x += UVoffSet.x;
	UVCoord.y += UVoffSet.y;
    outputColor = tex2D(TextureSampler, UVCoord);
    
	outputColor *= CalculateSingleLight(light, input.WorldPosition, input.WorldNormal);
	
    return outputColor;
}

technique SpecularAndDiffuse
{
    pass Pass1
    {
        // TODO: set renderstates here.
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 PixelShaderFunction();
    }
}