/*********************************************************************NVMH3****
File:  $Id: //sw/devtools/SDK/9.5/SDK/MEDIA/HLSL/Grisaille.fx#2 $

Copyright NVIDIA Corporation 2002
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

******************************************************************************/

#define USE_TIMER
#include <include\\Quad.fxh>

// Compile-time flags
// feature flags

// performance flags
//#define USE_NORMALIZATION_CUBEMAP
//#define USE_HALF

// float for pixel shaders
#ifdef USE_HALF
#define REAL half
#define REAL2 half2
#define REAL3 half3
#define REAL4 half4
#else /* !USE_HALF */
#define REAL float
#define REAL2 float2
#define REAL3 float3
#define REAL4 float4
#endif /* !USE_HALF */

float Script : STANDARDSGLOBAL <
    string UIWidget = "none";
    string ScriptClass = "object";
    string ScriptOrder = "standard";
    string ScriptOutput = "color";
    string Script = "Technique=Technique?grisaille:untextured;";
> = 0.8;

///////////////////////////////////////////////////////////////
/// TWEAKABLES ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////

////////////////////////////////////////////// spot light

half3 LightDir : DIRECTION <
	string UIName = "Light Direction";
	string Object = "DirectionalLight";
	string Space = "World";
> = {-0.707f, 0.707f, 0.0f};

////////////////////////////////////////////// ambient light

half4 AmbiLightColor : Ambient
<
    string UIName = "Ambient Light Color";
> = {0.07f, 0.07f, 0.07f, 1};

////////////////////////////////////////////// surface

half4 SurfColor : Diffuse
<
    string UIName = "Surface Color";
	string UIWidget = "Color";
> = {1.0f, 0.7f, 0.3f, 1};

float Ks
<
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.5;
    float UIStep = 0.01;
    string UIName = "Specular";
> = 1.0;


float SpecExpon : SpecularPower
<
    string UIWidget = "slider";
    float UIMin = 1.0;
    float UIMax = 128.0;
    float UIStep = 1.0;
    string UIName = "Specular power";
> = 52.0;


float Flatness
<
    string UIWidget = "slider";
    float UIMin = 0.01;
    float UIMax = 20.0;
    float UIStep = 0.01;
    string UIName = "Flatness";
> = 8.0;


////////////////////////////////////////////////////////
/// TEXTURES ///////////////////////////////////////////
////////////////////////////////////////////////////////

texture DiffTexture : Diffuse <
	string ResourceName = "default_color.dds";
	string TextureType = "2D";
>;

sampler2D DiffSampler = sampler_state
{
	Texture = <DiffTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = WRAP;
	AddressV = WRAP;
};

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

#ifdef USE_NORMALIZATION_CUBEMAP
#include <include\\normalize.fxh>
// only for pixel shaders....

/*
half3 my_normalize(half3 v)
{
	half3 v2 = texCUBE(NormalizeSampler,v);
	return (2*(v2-0.5));
}
half4 my_normalize(half4 v)
{
	half3 v2 = texCUBE(NormalizeSampler,v.xyz);
	return half4((2*(v2-0.5)),1);
}
*/

#define NORM my_normalize
#else /* !USE_NORMALIZATION_CUBEMAP */
#define NORM normalize
#endif /* !USE_NORMALIZATION_CUBEMAP */

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

/************* "UN-TWEAKABLES," TRACKED BY CPU APPLICATION **************/

float4x4 WorldITXf : WorldInverseTranspose <string UIWidget="None";>;
float4x4 WvpXf : WorldViewProjection <string UIWidget="None";>;
float4x4 WorldXf : World <string UIWidget="None";>;
float4x4 ViewIXf : ViewInverse <string UIWidget="None";>;
float4x4 ViewTXf : ViewTranspose <string UIWidget="None";>;
float4x4 WorldViewITXf : WorldViewInverseTranspose <string UIWidget="None";>;
float4x4 WorldViewXf : WorldView <string UIWidget="None";>;
float4x4 ViewXf : View <string UIWidget="None";>;
float4x4 ViewITXf : ViewInverseTranspose <string UIWidget="None";>;

#ifdef USE_TIMER
float Timer : TIME <string UIWidget="None";>;
#else /* !USE_TIMER */

float Timer <
	string UIName = "Time At Frame Start";
	string UIWidget = "slider";
	float UIMin = 0.0;
	float UIMax = 10.0;
	float UIStep = 0.1;
> = 0.0f;
#endif /* !USE_TIMER */

////////////////////////////////////////////////////////////////////////////
/// SHADER CODE BEGINS /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

/* data from application vertex buffer */
struct appdata {
    half3 Position	: POSITION;
    half4 UV		: TEXCOORD0;
    half4 Normal	: NORMAL;
};

// used for all other passes
struct vertexOutput {
    half4 HPosition	: POSITION;
    half2 UV		: TEXCOORD0;
    float3 WNormal	: TEXCOORD1;
    float3 WView		: TEXCOORD2;
	half4 DiffCol : COLOR0;
};

/*********************************************************/
/*********** vertex shader *******************************/
/*********************************************************/

vertexOutput spinVS(appdata IN)
{
    vertexOutput OUT;
    OUT.UV = IN.UV.xy;
    // half3 Nn = normalize(mul(IN.Normal, WorldITXf).xyz); // world coords
    half3 Ne = normalize(mul(IN.Normal, WorldViewITXf).xyz); // view coords
    Ne = normalize(half3(Ne.xy,Ne.z*Flatness));
    half3 Nn = normalize(mul(Ne, ViewTXf).xyz); // world coords
    half4 Po = half4(IN.Position.xyz,1);	// obj coords
    OUT.WView = normalize(ViewIXf[3].xyz - Po.xyz);	// obj coords
    OUT.WNormal = Nn; // mul(Po,WorldViewProjXf);	// screen clipspace coords
	float d = dot(-LightDir,Nn);
	OUT.DiffCol = half4(max(0,d).xxx,1.0);
    half4 Ph = mul(Po, WvpXf);
    OUT.HPosition = Ph;
    return OUT;
}

/*********************************************************/
/*********** pixel shader ********************************/
/*********************************************************/

half4 nPS(vertexOutput IN) : COLOR
{
    float3 Nn = NORM(IN.WNormal);
    float3 Vn = NORM(IN.WView);
    float3 Ln = -LightDir;
    float3 Hn = NORM(Vn + Ln);
    float hdn = Ks * pow(dot(Hn,Nn),SpecExpon);
    half4 sc = half4(hdn.xxx,0);
	half4 tc = tex2D(DiffSampler,IN.UV);
	half4 dc = tc * SurfColor * (IN.DiffCol + AmbiLightColor);
	return dc+sc;
}

half4 ntPS(vertexOutput IN) : COLOR
{
    float3 Nn = NORM(IN.WNormal);
    float3 Vn = NORM(IN.WView);
    float3 Ln = -LightDir;
    float3 Hn = NORM(Vn + Ln);
    float hdn = Ks * pow(dot(Hn,Nn),SpecExpon);
    half4 sc = half4(hdn.xxx,0);
	half4 dc = SurfColor * (IN.DiffCol + AmbiLightColor);
	return dc+sc;
}


////////////////////////////////////////////////////////////////////
/// TECHNIQUES /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////

technique grisaille <
	string Script = "Pass=p0;";
> {
	pass p0 <
	string Script = "Draw=geometry;";
> {
		VertexShader = compile vs_2_0 spinVS();
		ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;
		AlphaBlendEnable = false;
		PixelShader = compile ps_2_a nPS();
	}
}

technique untextured <
	string Script = "Pass=p0;";
> {
	pass p0 <
	string Script = "Draw=geometry;";
> {
		VertexShader = compile vs_2_0 spinVS();
		ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;
		AlphaBlendEnable = false;
		PixelShader = compile ps_2_a ntPS();
	}
}
/***************************** eof ***/