// DELighting structs 
// ************************************************************
struct DELight_s
{
	int	Type;	
	bool	Active;	
	bool	LightingActive;	
	float4	Position;	
	float4	Diffuse;
	float4	Specular;	
	float4	Direction;	
	float	Attenuation;	
	float	Range;	
	float	Theta;	
	float	Phi;
	float	Falloff;
};

struct DEAmbient_s
{
	bool 	Active;	
	float4 	Color;
};

// Variables
// ************************************************************
DELight_s		DE1NALight 		: DENALIGHT1;
DEAmbient_s		DEAmbient 		: DEAMBIENTLIGHT;	
float4x4		DEWorld			: DEWORLD;
float4x4		DEWorldViewProj	 	: DEWORLDVIEWPERSPECTIVE;
float4x4 		DEViewInverse 		: DEVIEW_INVERSE;

texture NormalTexture : DETEXTURE 
<
	string name="Dwarf_Normal.tga";
>;

texture ColorTexture : DEBASIC_MATERIAL_TEXTURE; 

// The sample state for the basic texture
sampler2D NormalMap = sampler_state
{
	Texture 		= (NormalTexture);
	MinFilter 		= Linear;	
	MagFilter		= Linear;	
	AddressU		= Wrap;	
	AddressV		= Wrap;
};

// The sample state for the basic texture
sampler2D ColorMap = sampler_state
{
	Texture 		= (ColorTexture);
	MinFilter 		= Linear;	
	MagFilter		= Linear;
	AddressU		= Wrap;	
	AddressV		= Wrap;
};

// Shader I/O structs 
// ************************************************************
struct sVSIN
{	
	float4 Position 	: POSITION;    
	float4 Normal   	: NORMAL;
	float2 UV		: TEXCOORD0;    
	float4 Tangent  	: TANGENT;   
};



struct sPSIN
{				
	float4 Position 	: POSITION;
	float4 Normal		: COLOR0;
	float4 LightVector	: TEXCOORD0;
	float2 TexCoord0	: TEXCOORD1;
	float2 TexCoord1	: TEXCOORD2; 
};

// Vertex Shader 
// ************************************************************
sPSIN VertexShader(sVSIN VIN)
{	
	// Create struct to send to pixel shader   
	sPSIN OUT = (sPSIN)0;
	
	// Get the Eye Position
	float3 World_Eye_Position = DEViewInverse[3].xyz;

	// Calculate the transformed world vertex position
	float3 World_Vertex_Position = mul(VIN.Position, DEWorld).xyz;

	// Calculate light direction from the Nearest Active Light
	float3 Light_Direction = World_Vertex_Position - DE1NALight.Position;
			
	// Tangent
	float3 T = mul(VIN.Tangent, DEWorld);		
	// Normal vector
	float4 N = mul(VIN.Normal, DEWorld);
	// Eye vector
	float3 E = normalize(World_Eye_Position - World_Vertex_Position); 
	// Light vector
	float3 L = normalize(-Light_Direction.xyz);				
	// Compute the tangent rotation matrix
	float3 B = cross(T, N);	

	// Compute the 3x3 tranform from tangent space to object space
   	float3x3 Object_To_Tangent_Space;
   	Object_To_Tangent_Space[0] = T;
   	Object_To_Tangent_Space[1] = B;
	Object_To_Tangent_Space[2] = N;

	// Transform normal from object space to tangent space
	OUT.Normal.xyz = 0.5 * 
		mul(Object_To_Tangent_Space, N) + 0.5.xxx;

	// Transform light vector from object space to tangent space
	OUT.LightVector.xyz = 0.5 * 
		mul(Object_To_Tangent_Space, L.xyz) + 0.5.xxx;

	// Pass the calculated vertex position	
	OUT.Position = mul(VIN.Position, DEWorldViewProj);

	// Pass texture coordinates
	OUT.TexCoord0 = VIN.UV;
	OUT.TexCoord1 = VIN.UV;
	
	return OUT;
}

// Pixel Shader 
// ************************************************************
float4 PixelShader(sPSIN PIN) : COLOR

{
	// Get the bump normal
	float4 Bump_Normal = 2 * (tex2D(NormalMap, PIN.TexCoord0) - 0.5);

	// Get the color map color 
	float4 Texture_Color = tex2D(ColorMap, PIN.TexCoord1);

	// Expand iterated normal to [-1,1]
	float4 Normal = 2 * (PIN.Normal - 0.5);

	// Expand iterated light vector to [-1,1]
	float4 Light_Vector = 2 * (PIN.LightVector - 0.5);
	
	// Compute self-shadowing term
   	float Shadow = saturate(4 * dot(Normal.xyz, Light_Vector.xyz));
		
	// Calculate Annenuation
	float Attenuation = 1/DE1NALight.Attenuation;

	// Computer diffuse term
	float4 Diffuse_Term = Attenuation * 
		saturate(dot(Bump_Normal.xyz, Light_Vector.xyz)-0.2);   	
		
	return Texture_Color * (Diffuse_Term * Shadow  + DEAmbient.Color);
}

// Technique
// ************************************************************
technique DETechnique
<float vs=1.1; float ps=2.0;>
{   
	pass Pass0    
	{				
		VertexShader 	= compile vs_1_1 VertexShader();		
		PixelShader  	= compile ps_2_0 PixelShader();   
	}  	
}

// Tangentfloat3 T = mul(VIN.Tangent, DEWorld);		// Normal vectorfloat4 N = mul(VIN.Normal, DEWorld);