matrix matWorldViewProj;
matrix matWorld;vector vecSunDir;
texture entSkin1;texture mtlSkin1;
technique t0{
pass p0 // shade it
{
zwriteenable= true;
zenable = true;
Texture[0]=<mtlSkin1>;
ColorOp[0]=Modulate;
ColorArg1[0]=Texture;
ColorArg2[0]=Texture;
AddressU[0]=Clamp;
AddressV[0]=Clamp;
AddressW[0]=Clamp;
TexCoordIndex[0]=0;
Texture[1]=<entSkin1>;
ColorOp[1]=Modulate;
ColorArg1[1]=Texture;
ColorArg2[1]=Current;
TexCoordIndex[1]=1;
VertexShaderConstant[0] = <matWorldViewProj>;
VertexShaderConstant[4] = <matWorld>;
VertexShaderConstant[7] = <vecSunDir>; 

VertexShader =		asm
{
vs_1_0
dcl_position  v0
dcl_normal    v3
dcl_texcoord0 v7
dcl_texcoord1 v8
mov oT2.xy, v7
dp4 oPos.x, c0, v0
dp4 oPos.y, c1, v0
dp4 oPos.z, c2, v0
dp4 oPos.w, c3, v0
dp3 r0.x, c4.xyz, v3.xyz
dp3 r0.y, c5.xyz, v3.xyz
dp3 r0.z, c6.xyz, v3.xyz
dp3 oT0.x, r0.xyz, -c7.xyz
mov oT1.xyz, v8
};
}
pass p1 // ink it
{
CULLMODE=CW;
vertexShaderConstant[0]=<matWorldViewProj>;
vertexShaderConstant[16]=0.2; // outline thickness
vertexShader =		asm
{
vs_1_0
dcl_position v0
dcl_normal v3
dcl_texcoord v7
mov r0,v0
mul r1,c16.x,v3
// Scale the normal
add r0.xyz,r0.xyz,r1.xyz
m4x4 oPos,r0,c0
// Transorm position to clip space
mov oD0, c0
mov r0,c0
};
}
}

/************* UN-TWEAKABLES **************/

//float4x4 WorldIT : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 matMtl;
//float4x4 WorldViewProj : WorldViewProjection < string UIWidget="None"; >;
float4x4 matWorldViewProj;
//float4x4 World : World < string UIWidget="None"; >;
float4x4 matWorld;

/************* TWEAKABLES *****************/

float4 vecViewPos;

float4 vecLightPos[8];
float4 AmbiColor = {0.4f, 0.4f, 0.4f, 1.0f};
float4 DiffColor = {1.3f, 1.4f, 1.3f, 1.0f};
float4 SubColor = {0.2f, 0.2f, 0.8f, 1.0f};
float RollOff = 0.4;

float4 DiffColor2 = {1.0f, 1.0f, 1.0f, 1.0f};
float4 SubColor2 = {10.0f, 10.0f, 10.0f, 1.0f};
float RollOff2 = 0.05;



/////////////// texture /////////////////
texture entSkin1;

sampler2D ColorSampler = sampler_state
{
	Texture = <entSkin1>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = WRAP;
	AddressV = WRAP;
};
/************* DATA STRUCTS **************/

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

/* data passed from vertex shader to pixel shader */
struct shadedVertexOutput {
    float4 HPosition	: POSITION;
    float4 TexCoord	: TEXCOORD0;
    float4 diffCol	: COLOR0;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    half4 HPosition	: POSITION;
    half4 TexCoord		: TEXCOORD0;
    half3 LightVec		: TEXCOORD1;
    half3 WorldNormal	: TEXCOORD2;
    half3 ViewVec			: TEXCOORD3;
};

///////////////////////////////////////////////
// Shared "lambskin" diffuse function /////////
///////////////////////////////////////////////

//
// vectors are assumed to be normalized as needed
//

void lambskin(float3 N,
			  float3 L,
			  out float4 Diffuse,
			  out float4 Subsurface
) {
    float ldn = dot(L,N);
    float diffComp = max(0,ldn);
    Diffuse = float4((diffComp * DiffColor).xyz,1);
    float subLamb = smoothstep(-RollOff,1.0,ldn) - smoothstep(0.0,1.0,ldn);
    subLamb = max(0.0,subLamb);
    Subsurface = subLamb * SubColor;
}

void lambskin2(float3 N,
			  float3 L,
			  out float4 Diffuse,
			  out float4 Subsurface
) {
    float ldn = dot(L,N);
    float diffComp = max(0,ldn);
    Diffuse = float4((diffComp * DiffColor2).xyz,1);
    float subLamb = smoothstep(-RollOff2,1.0,ldn) - smoothstep(0.0,1.0,ldn);
    subLamb = max(0.0,subLamb);
    Subsurface = subLamb * SubColor2;
}

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

shadedVertexOutput lambVS(appdata IN) {
    shadedVertexOutput OUT;
    float3 Nn = normalize(mul(IN.Normal, matMtl).xyz);
    float4 Po = float4(IN.Position.xyz,1);
    float3 Pw = mul(Po, matWorld).xyz;
    float3 Ln = normalize(vecLightPos[0] - Pw);
    float4 diffContrib;
    float4 subContrib;
	lambskin(Nn,Ln,diffContrib,subContrib);
    OUT.diffCol = diffContrib + AmbiColor + subContrib;
    OUT.TexCoord = IN.UV;
    OUT.HPosition = mul(Po, matWorldViewProj);
    return OUT;
}

vertexOutput simpleVS(appdata IN) {
    vertexOutput OUT;
    half4 normal = normalize(IN.Normal);
    OUT.WorldNormal = mul(normal, matMtl).xyz;
    half4 Po = half4(IN.Position.xyz,1);
    half3 Pw = mul(Po, matWorld).xyz;
    OUT.LightVec = normalize(vecLightPos[0] - Pw);
    OUT.ViewVec = normalize(vecViewPos - Pw);
    OUT.TexCoord = IN.UV;
    OUT.HPosition = mul(Po, matWorldViewProj);
    return OUT;
}

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

void lamb_ps_shared(vertexOutput IN,
			out float4 DiffuseContrib,
			out float4 SubContrib)
{
    half3 Ln = normalize(IN.LightVec);
    half3 Nn = normalize(IN.WorldNormal);
	lambskin(Nn,Ln,DiffuseContrib,SubContrib);
}


void lamb_ps_shared2(vertexOutput IN,
			out float4 DiffuseContrib,
			out float4 SubContrib)
{
    half3 Ln = normalize(IN.ViewVec);
    half3 Nn = normalize(IN.WorldNormal);
	lambskin2(Nn,Ln,DiffuseContrib,SubContrib);
}


float4 lambPS(vertexOutput IN) : COLOR {
	float4 diffContrib;
	float4 subContrib;
	lamb_ps_shared(IN,diffContrib,subContrib);
	float4 litC = diffContrib + AmbiColor + subContrib;
	return litC;
}

float4 lambPS_t(vertexOutput IN) : COLOR {
	float4 diffContrib;
	float4 subContrib;
	float4 diffContrib2;
	float4 subContrib2;
	lamb_ps_shared(IN,diffContrib,subContrib);
	lamb_ps_shared2(IN,diffContrib2,subContrib2);
	float4 litC = diffContrib + AmbiColor + subContrib;
	//float4 litC = AmbiColor + subContrib;
	litC.rgb = ((1-(litC.rgb*2))*subContrib2)+litC.rgb;
	return (litC*tex2D(ColorSampler,IN.TexCoord.xy));
}