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

shared float gridThreshold = .05f;
shared float2 GridDimensions = 0;
shared float3 NonTextureColor = 0;

shared float4 ambientColor;

shared float3 cameraPosition;

//material properties
float specularPower = 0;
float specularIntensity = 0;

// TODO: add effect parameters here.
Texture inTexture;
shared Texture buildArea;
Texture alphaMap;

float2 UVoffSet = 0;

float alpha = .5f;
float4 colorToAdd = 0;

sampler AlphaSampler = sampler_state
{
	texture = <alphaMap>;
	magfilter = LINEAR; 
	minfilter = LINEAR; 
	mipfilter = LINEAR; 
	AddressU = WRAP; 
	AddressV = WRAP;

};

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

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


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

shared Light light;

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

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

struct GridVertexShaderOutput
{
    float4 Position : POSITION0;
    float4 WorldPosition : TEXCOORD0;
    float2 UV : TEXCOORD1;
};
    
//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)
	{ 
		 float diffuseIntensity = saturate( dot(light.direction, worldNormal));
		 diffuse = diffuseIntensity * light.color;

		 //calculate Phong components per-pixel
		 float3 reflectionVector = normalize(reflect(-light.direction, 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;

    outputColor = tex2D(TextureSampler, UVCoord);
    if(!any(outputColor.rgb))
		outputColor.rgba = 1;
		
    outputColor += colorToAdd;
    
	outputColor *= CalculateSingleLight(light, input.WorldPosition, input.WorldNormal);
	
    return outputColor;
}

float4 TransparentPixelShaderFunction(VertexShaderOutput input) : COLOR0
{
	float4 outputColor = PixelShaderFunction(input);
	outputColor.a = alpha;
	return outputColor;
}

float4 AlphaMapPixelShaderFunction(VertexShaderOutput input) : COLOR0
{
	float4 outputColor = PixelShaderFunction(input);
	float4 alphaVal = tex2D(AlphaSampler, input.UV);
	outputColor.a = 0;
	outputColor.a = alphaVal.b;
	return outputColor;
	
}

GridVertexShaderOutput GridVertexShaderFunction(VertexShaderInput input)
{
    GridVertexShaderOutput output;
    VertexShaderOutput temp = VertexShaderFunction(input);
    output.Position = temp.Position;
    output.WorldPosition = temp.WorldPosition;
    output.UV = temp.UV;
    
    return output;
}

float4 GridPixelShaderFunction(GridVertexShaderOutput input) : COLOR0
{
	float4 color;
	bool alongX = false;
	bool alongY = false;
	
	float xPos = distance(input.WorldPosition.x,floor(input.WorldPosition.x)); 
	float yPos = distance(input.WorldPosition.z,floor(input.WorldPosition.z));

	if(xPos < gridThreshold || yPos < gridThreshold) //|| xPos < -gridThreshold)
	{
		color.r = 0;
		color.g = 1;
		color.b = 0;
		color.a = .25;
		alongX = true;
	}
	else
	{
		float2 buildCoord;
		buildCoord.x = (floor(input.WorldPosition.x) + .5)/GridDimensions.x;
		buildCoord.y = (floor(input.WorldPosition.z) + .5)/GridDimensions.y;
		float4 buildInfo = tex2D(BuildAreaSampler, buildCoord);
		if(buildInfo.r == 1)
		{
			color.r = .392;
			color.g = .584;
			color.b = .929;
			color.a = .25;
		}
		else
		{
			color.rgba = 0;
		}	
	}
	
	return color;
}

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

technique AlphaMapSpecularAndDiffuse
{
    pass Pass1
    {
        // TODO: set renderstates here.
        AlphaBlendEnable = true;
        VertexShader = compile vs_2_0 VertexShaderFunction();
		PixelShader = compile ps_2_0 AlphaMapPixelShaderFunction();
    }
}

technique SpecularAndDiffuseTransparent
{
	pass Pass1
	{
	    AlphaBlendEnable = true;
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 TransparentPixelShaderFunction();
	}
}

technique Grid
{
	pass Pass1
	{
	    AlphaBlendEnable = true;
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 GridPixelShaderFunction();
	}
}