float4x4 matW : World;  // World matrix for object
float4x4 matWit : WorldInverseTranspose;
float4x4 matWvp : WorldViewProjection;	// World * View * Projection matrix
float4x4 matVi : ViewInverse;

struct vsIn
{
	float4 position : Position;
	float3 normals : Normal;
	float2 tex : TexCoord0;
	float3 tangent : Tangent;
	float3 binormal : Binormal;
};
struct vsOut
{
	float4 position : Position;
	float2 tex : TexCoord0;
	float4 worldPosition : TexCoord1;
	float3 tbnRow1 : TexCoord2;
	float3 tbnRow2 : TexCoord3;
	float3 tbnRow3 : TexCoord4;
};
struct psOut
{
	float4 diffuse : Color0;
	float4 normals : Color1;
	float4 position : Color2;
};

texture diffuseTexture;
sampler sDiffuseTexture = sampler_state {
	texture = <diffuseTexture>;
	MipFilter = Linear;
	MagFilter = Linear;
	MinFilter = Linear;
};

texture normalMap;
sampler sNormalMap = sampler_state {
	texture = <normalMap>;
	MipFilter = Linear;
	MagFilter = Linear;
	MinFilter = Linear;
};


vsOut deferredSetup_Vs(vsIn In)
{
	vsOut Out;
	
	Out.position = mul(In.position, matWvp);
	Out.tex = In.tex;
	Out.worldPosition = mul(In.position, matW);
	
	float3x3 tbnI = mul(float3x3(In.tangent, In.binormal, In.normals), matWit);
	tbnI /= -1.0f;
	
	Out.tbnRow1 = tbnI[0];
	Out.tbnRow2 = tbnI[1];
	Out.tbnRow3 = tbnI[2];
	
	return Out;
}

psOut deferredSetup_Ps(vsOut In)
{
	psOut Out;
	
	Out.diffuse = tex2D(sDiffuseTexture, In.tex);
	Out.normals = float4(mul(2.0f * tex2D(sNormalMap, In.tex) - 1.0f, float3x3(In.tbnRow1, In.tbnRow2, In.tbnRow3)), 1);
	Out.position = In.worldPosition;
	
	return Out;
}


float4 deferredSetup_Ps_color(vsOut In) : COLOR
{
	return tex2D(sDiffuseTexture, In.tex);
}

float4 deferredSetup_Ps_normal(vsOut In) : COLOR
{
	return float4(mul(2.0f * tex2D(sNormalMap, In.tex) - 1.0f, float3x3(In.tbnRow1, In.tbnRow2, In.tbnRow3)), 1);
}

float4 deferredSetup_Ps_position(vsOut In) : COLOR
{

	return In.worldPosition;
}



technique Deferred_Shading_Position
{
    pass P0
    {
		VertexShader = compile vs_1_1 deferredSetup_Vs();
		PixelShader = compile ps_2_0 deferredSetup_Ps_position();
    }
}

technique Deferred_Shading_Normal
{
    pass P0
    {
		VertexShader = compile vs_1_1 deferredSetup_Vs();
		PixelShader = compile ps_2_0 deferredSetup_Ps_normal();
    }
}

technique Deferred_Shading_Color
{
    pass P0
    {
		VertexShader = compile vs_1_1 deferredSetup_Vs();
		PixelShader = compile ps_2_0 deferredSetup_Ps_color();
    }
}

technique Deferred_Shading_MRT
{
    pass P0
    {
		VertexShader = compile vs_1_1 deferredSetup_Vs();
		PixelShader = compile ps_2_0 deferredSetup_Ps();
    }
}

///////////////////////////////////////////////////////////////////

texture normals, position, diffuse;
sampler sNormals = sampler_state { texture = <normals>; };
sampler sPosition = sampler_state { texture = <position>; };
sampler sDiffuse = sampler_state { texture = <diffuse>; };

float3 lightPosition;
float3 lightColor;

float4 deferredLighting_Ps(float2 uv : TEXCOORD0) : Color0
{
	float3 pos = tex2D(sPosition, uv);
	float3 normal = normalize(tex2D(sNormals, uv));
	float4 diffuse = tex2D(sDiffuse, uv);
	
	float3 lightDir = normalize(lightPosition - pos);
	float3 vte = normalize(matVi[3] - pos);
	
	float3 lightCol = lightColor / (0.01f * distance(pos, lightPosition));
	
	float3 halfVec = normalize((lightDir + vte) * .5f);
	
	float3 specular = 0;//pow(max(0.0f, dot(normal, halfVec)), 2);

	return float4(lightCol * diffuse.rgb * max(0, dot(normal, lightDir)) + specular, 1);
}

technique Light
{
	pass p0
	{
		VertexShader = null;
		PixelShader = compile ps_2_0 deferredLighting_Ps();
	}
}