//-----------------------------------------------------------------------------
// Gooch.fx
//
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Parameters
//-----------------------------------------------------------------------------
float4x4 Transform : WorldViewProjection;
float4x4 ModelWorld : World;
float4 LightCol = float4(1,1,1,1);
float4 LightPos = float4(0,500,-500,0);
float4 CameraPosition : ViewPosition;
float4 Material = float4( 1.0f, 1.0f, 1.0f, 1.0f);

float4 cool : Scratch1 = float4( 0.2f, 0.2f, 0.8f, 1.0f );
float4 warm : Scratch0 = float4( 1.0f, 1.0f, 0.2f, 1.0f );

texture DiffuseTexture : ColorMap0; 
//-----------------------------------------------------------------------------
samplerCUBE Sampler = sampler_state
{
    Texture   = (DiffuseTexture);
    MipFilter = Linear;
    MinFilter = Linear;
    MagFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
    AddressW = Wrap;
};

//-----------------------------------------------------------------------------
// Structures
//-----------------------------------------------------------------------------
struct vertex
{
    float3 position	: POSITION;
    float3 normal   : NORMAL;
};
//-----------------------------------------------------------------------------
struct fragment
{
    float4 position : POSITION;
	float3 normal   : TEXCOORD0;
	float3 eye      : TEXCOORD1;
    float3 light	: TEXCOORD2;
};
//-----------------------------------------------------------------------------
struct outline_fragment
{
    float4 position : POSITION;
};
//-----------------------------------------------------------------------------
struct pixel
{
	float4 color    : COLOR;
};
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Diffuse lighting function
//-----------------------------------------------------------------------------
float DiffuseCalculation(float3 L, float3 N)
{
    float Intensity = max(dot(N, L), 0);
	return Intensity;
};
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Specular lighting function
//-----------------------------------------------------------------------------
float SpecularCalculation( float3 H, float3 N, float fShininess )
{
	float Intensity = pow(max(dot(N,H), 0), fShininess);
	return Intensity;
};
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Vertex shaders
//-----------------------------------------------------------------------------
fragment VS_Colored( vertex IN )
{
    fragment OUT;

	float4 WorldPos = mul( float4(IN.position, 1), ModelWorld );
	float3 P = WorldPos.xyz; 
	float3 N = normalize(mul(IN.normal, (float3x3)ModelWorld));
	float3 L = normalize(LightPos.xyz - P);
	float3 E = CameraPosition.xyz;
	float3 V = normalize(E - P);

	OUT.position = mul( float4(IN.position, 1), Transform );
	OUT.normal = N;
	OUT.light = L;
	OUT.eye = V;
	
	return OUT;
}
//-----------------------------------------------------------------------------
outline_fragment VS_Outline( vertex IN )
{
    outline_fragment OUT;

	float4 ClipPos = mul( float4(IN.position, 1), Transform );
	float ratio = saturate((ClipPos.z / ClipPos.w) * 0.05f);

	float3 P = IN.position + ratio * normalize(IN.normal);
	
	OUT.position = mul( float4(P, 1), Transform );
	
	return OUT;
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Pixel Shader
//-----------------------------------------------------------------------------
pixel PS_Colored( fragment IN )
{
    pixel OUT;

	float3 N = texCUBE( Sampler, IN.normal ).xyz;
	
	float NdotL = saturate( DiffuseCalculation( IN.light, N ) );
	
	float4 color = NdotL * warm + (1 - NdotL) * cool;

	float3 H = normalize(IN.light + IN.eye);

	float NdotH = SpecularCalculation( H, N, 100 );
	float3 specular = float3( NdotH, NdotH, NdotH );

	OUT.color.rgb = max( color.rgb, specular );
	
	OUT.color.rgb = N;
	OUT.color.a = 1.0f;

    return OUT;
}
//-----------------------------------------------------------------------------
pixel PS_Outline( outline_fragment IN )
{
    pixel OUT;

	OUT.color.rgb = float3( 0.0, 0.0, 0.0 );
	OUT.color.a = 1.0f;

    return OUT;
}

//-----------------------------------------------------------------------------
// Techniques
//-----------------------------------------------------------------------------

technique LitTexturedSpecular
{
    pass P0
    {
		ZEnable = true;

		VertexShader = compile vs_1_1 VS_Colored();
		PixelShader  = compile ps_2_0 PS_Colored();
    }
  
    pass P1
    {
		ZEnable = true;

		CullMode = CW;
		VertexShader = compile vs_1_1 VS_Outline();
		PixelShader  = compile ps_2_0 PS_Outline();
    }

}