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

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

shared float4 ambientColor = 1.0;

shared float3 cameraPosition;

// 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 AlphaMapVertexShaderOutput
{
    float4 Position : POSITION0;
    float4 WorldPosition : TEXCOORD0;
    float3 WorldNormal : TEXCOORD1;
    float2 UV : TEXCOORD2;
    float2 AlphaUV : TEXCOORD3;
};

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;
}

AlphaMapVertexShaderOutput AlphaMapVertexShaderFunction(VertexShaderInput input)
{
    AlphaMapVertexShaderOutput 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;
	
	output.AlphaUV = input.UV;

    return output;
}


float4 CalculateSingleLight(Light light, float3 worldPosition, float3 worldNormal)
{
	float4 diffuse;
	if(light.enable)
	{
		float diffuseIntensity = saturate( dot(light.direction, worldNormal));
		diffuse = diffuseIntensity * light.color;
	}
	return  (ambientColor + diffuse);
}

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;
	}
	else
	{
		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;
}

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 AlphaMapPixelShaderFunction(AlphaMapVertexShaderOutput input) : COLOR0
{
	VertexShaderOutput temp;
	temp.UV = input.UV;
	temp.WorldPosition = input.WorldPosition;
	temp.Position = input.Position;
	temp.WorldNormal = input.WorldNormal;
	
	float4 outputColor = PixelShaderFunction(temp);
	float4 alphaVal = tex2D(AlphaSampler, input.AlphaUV);
	outputColor.a = alphaVal.b;
	return outputColor;
}

float4 GridPixelShaderFunction(GridVertexShaderOutput input) : COLOR0
{
	float4 color;
	color.rgba = 0; 
	
	float xPos = input.WorldPosition.x - (int)input.WorldPosition.x; 
	float yPos = input.WorldPosition.z - (int)input.WorldPosition.z;
	
	//bool onX = xPos < gridThreshold;
	//bool onY = yPos < gridThreshold;
	//bool onAxis = onX || onY;

	if(xPos < gridThreshold || yPos < gridThreshold) //|| xPos < -gridThreshold)
	{
		color.r = 0;
		color.g = 1;
		color.b = 0;
		color.a = .25;
	}
	//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 = 1;
		//	color.g = 0;
		//	color.b = 0;
		//	color.a = .25;
		//}
		//else
		//{
			color.rgba = 0;
		//}	
	//}
	
	return color;
}

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

technique AlphaMapSpecularAndDiffuse
{
    pass Pass1
    {
        // TODO: set renderstates here.
        AlphaBlendEnable = true;
        VertexShader = compile vs_1_1 AlphaMapVertexShaderFunction();
		PixelShader = compile ps_1_1 AlphaMapPixelShaderFunction();
    }
}

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

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