I didn't showd it in the thread, because it's quit big. But here it is ...


//--------------------------------------------------------------//
// Hair Rendering
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// Ruby Hair
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// HairPrimeZ
//--------------------------------------------------------------//
string Hair_Rendering_Ruby_Hair_HairPrimeZ_HairModel : ModelData = "Hair.obj";

float3 lightPos
<
string UIName = "lightPos";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -200.00;
float UIMax = 200.00;
> = ( -20.00, 184.00, 36.00 );
float4x4 matView : View;
float4x4 matViewProjection : ViewProjection;
float4 lightDir;

struct VS_INPUT
{
float4 pos : POSITION;
float3 normal : NORMAL;
float3 tangent : BINORMAL0;
float2 texCoord : TEXCOORD0;
};

struct VS_OUTPUT
{
float4 pos : POSITION;
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

VS_OUTPUT Hair_Rendering_Ruby_Hair_HairPrimeZ_Vertex_Shader_main(VS_INPUT i)
{
VS_OUTPUT o = (VS_OUTPUT) 0;

// Output transformed position:
o.pos = mul(matViewProjection, i.pos);

// Output light vector:
o.lightVec = normalize (lightPos - i.pos);

// Compute position in view space:
float3 Pview = mul( matView, i.pos );

// hair model doesn't contain per-vertex ambient occlusion
o.ambOcc = 1.0f;

// Transform the input normal to view space:
o.normal = i.normal;//normalize( mul( matView, tempNorm ) );

o.tangent = i.tangent;

// Compute the view direction in view space:
o.viewVec = - normalize( Pview );

// Propagate texture coordinate for the object:
o.texCoord = i.texCoord;

return o;
}





texture Alpha_Tex
<
string ResourceName = "HairAlpha.bmp";
>;
sampler2D tAlpha = sampler_state
{
Texture = (Alpha_Tex);
ADDRESSU = WRAP;
ADDRESSV = CLAMP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};

struct PS_INPUT
{
float2 texCoord : TEXCOORD3;
};

float4 Hair_Rendering_Ruby_Hair_HairPrimeZ_Pixel_Shader_main(PS_INPUT i) : COLOR
{
float4 o;

o.rgb = 1.0;
o.a = tex2D (tAlpha, i.texCoord); // read alpha texture

return o;
}

//--------------------------------------------------------------//
// HairPassOpaque
//--------------------------------------------------------------//
string Hair_Rendering_Ruby_Hair_HairPassOpaque_HairModel : ModelData = "Hair.obj";

float3 Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_lightPos
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_lightPos";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -200.00;
float UIMax = 200.00;
> = ( -20.00, 184.00, 36.00 );
float4x4 Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_matView : View;
float4x4 Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_matViewProjection : ViewProjection;
float4 Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_lightDir;

struct Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_VS_INPUT
{
float4 pos : POSITION;
float3 normal : NORMAL;
float3 tangent : BINORMAL0;
float2 texCoord : TEXCOORD0;
};

struct Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_VS_OUTPUT
{
float4 pos : POSITION;
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_VS_OUTPUT Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_main(Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_VS_INPUT i)
{
Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_VS_OUTPUT o = (Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_VS_OUTPUT) 0;

// Output transformed position:
o.pos = mul(Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_matViewProjection, i.pos);

// Output light vector:
o.lightVec = normalize (Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_lightPos - i.pos);

// Compute position in view space:
float3 Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_Pview = mul( Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_matView, i.pos );

// hair model doesn't contain per-vertex ambient occlusion
o.ambOcc = 1.0f;

// Transform the input normal to view space:
o.normal = i.normal;//normalize( mul( Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_matView, tempNorm ) );

o.tangent = i.tangent;

// Compute the view direction in view space:
o.viewVec = - normalize( Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_Pview );

// Propagate texture coordinate for the object:
o.texCoord = i.texCoord;

return o;
}





float4 ambientLightColor
<
string UIName = "ambientLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.79, 0.79, 0.79, 1.00 );
float4 specularLightColor
<
string UIName = "specularLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
float4 specularColor1
<
string UIName = "specularColor1";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.76, 0.43, 0.13, 1.00 );
float4 specularColor0
<
string UIName = "specularColor0";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.73, 0.64, 0.47, 1.00 );
float2 specularExp
<
string UIName = "specularExp";
string UIWidget = "Numeric";
bool UIVisible = " false";
float UIMin = -1.00;
float UIMax = 1.00;
> = ( 200.00, 15.00 );
float4 diffuseLightColor
<
string UIName = "diffuseLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
float4 hairBaseColor
<
string UIName = "hairBaseColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.56, 0.24, 0.06, 1.00 );
float2 specularShift
<
string UIName = "specularShift";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -1.00;
float UIMax = 1.00;
> = ( 0.08, 0.54 );

texture Base_Tex
<
string ResourceName = "HairBase.bmp";
>;
sampler2D tBase = sampler_state
{
Texture = (Base_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassOpaque_Pixel_Shader_tAlpha = sampler_state
{
Texture = (Alpha_Tex);
ADDRESSU = WRAP;
ADDRESSV = CLAMP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};
texture Shift_Tex
<
string ResourceName = "HairShift.bmp";
>;
sampler2D tSpecularShift = sampler_state
{
Texture = (Shift_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MAGFILTER = LINEAR;
MIPFILTER = LINEAR;
MINFILTER = LINEAR;
};
texture SpecularMask_Tex
<
string ResourceName = "HairSpecMask.bmp";
>;
sampler2D tSpecularMask = sampler_state
{
Texture = (SpecularMask_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};

struct Hair_Rendering_Ruby_Hair_HairPassOpaque_Pixel_Shader_PS_INPUT
{
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

float HairDiffuseTerm(float3 N, float3 L)
{
return saturate(0.75 * dot(N, L) + 0.25);
}

float HairSingleSpecularTerm(float3 T, float3 H, float exponent)
{
float dotTH = dot(T, H);
float sinTH = sqrt(1.0 - dotTH*dotTH);
return pow(sinTH, exponent);
}

float3 ShiftTangent(float3 T, float3 N, float shiftAmount)
{
return normalize(T + shiftAmount * N);
}

float4 Hair_Rendering_Ruby_Hair_HairPassOpaque_Pixel_Shader_main(Hair_Rendering_Ruby_Hair_HairPassOpaque_Pixel_Shader_PS_INPUT i) : COLOR
{
// shift tangents
float shiftTex = tex2D(tSpecularShift, i.texCoord) - 0.5;

float3 N = normalize (i.normal);

float3 T1 = ShiftTangent(i.tangent, N, specularShift.x + shiftTex);
float3 T2 = ShiftTangent(i.tangent, N, specularShift.y + shiftTex);

// diffuse term
float3 diffuse = hairBaseColor * diffuseLightColor *
HairDiffuseTerm(N, i.lightVec);

// specular term
float3 H = normalize(i.lightVec + i.viewVec);
float3 specular = specularColor0 *
HairSingleSpecularTerm(T1, H, specularExp.x);

float3 specular2 = specularColor1 *
HairSingleSpecularTerm(T2, H, specularExp.y);

// modulate secondary specular term with noise
float specularMask = tex2D(tSpecularMask, i.texCoord * 10.0f);
specular2 *= specularMask;

// specular attenuation for hair facing away from light
float specularAttenuation = saturate(1.75 * dot(N, i.lightVec) + 0.25);

specular = (specular + specular2) * specularLightColor *
specularAttenuation;

// read base texture
float base = tex2D(tBase, i.texCoord);

// combine terms for final output
float4 o;

o.rgb = (diffuse + ambientLightColor * hairBaseColor) * base;
base = 1.5 * base - 0.5;
o.rgb += specular * base;
//o.rgb *= i.ambOcc;
o.a = tex2D (Hair_Rendering_Ruby_Hair_HairPassOpaque_Pixel_Shader_tAlpha, i.texCoord); // read alpha texture

return o;

return i.ambOcc;
}

//--------------------------------------------------------------//
// HairPassBackFacingTransparent
//--------------------------------------------------------------//
string Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_HairModel : ModelData = "Hair.obj";

float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_lightPos
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_lightPos";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -200.00;
float UIMax = 200.00;
> = ( -20.00, 184.00, 36.00 );
float4x4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_matView : View;
float4x4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_matViewProjection : ViewProjection;
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_lightDir;

struct Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_VS_INPUT
{
float4 pos : POSITION;
float3 normal : NORMAL;
float3 tangent : BINORMAL0;
float2 texCoord : TEXCOORD0;
};

struct Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_VS_OUTPUT
{
float4 pos : POSITION;
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_VS_OUTPUT Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_main(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_VS_INPUT i)
{
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_VS_OUTPUT o = (Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_VS_OUTPUT) 0;

// Output transformed position:
o.pos = mul(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_matViewProjection, i.pos);

// Output light vector:
o.lightVec = normalize (Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_lightPos - i.pos);

// Compute position in view space:
float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_Pview = mul( Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_matView, i.pos );

// hair model doesn't contain per-vertex ambient occlusion
o.ambOcc = 1.0f;

// Transform the input normal to view space:
o.normal = i.normal;//normalize( mul( Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_matView, tempNorm ) );

o.tangent = i.tangent;

// Compute the view direction in view space:
o.viewVec = - normalize( Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_Pview );

// Propagate texture coordinate for the object:
o.texCoord = i.texCoord;

return o;
}





float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_ambientLightColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_ambientLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.79, 0.79, 0.79, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularLightColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularColor1
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularColor1";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.76, 0.43, 0.13, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularColor0
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularColor0";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.73, 0.64, 0.47, 1.00 );
float2 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularExp
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularExp";
string UIWidget = "Numeric";
bool UIVisible = " false";
float UIMin = -1.00;
float UIMax = 1.00;
> = ( 200.00, 15.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_diffuseLightColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_diffuseLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_hairBaseColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_hairBaseColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.56, 0.24, 0.06, 1.00 );
float2 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularShift
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularShift";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -1.00;
float UIMax = 1.00;
> = ( 0.08, 0.54 );

sampler2D Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tBase = sampler_state
{
Texture = (Base_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tAlpha = sampler_state
{
Texture = (Alpha_Tex);
ADDRESSU = WRAP;
ADDRESSV = CLAMP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tSpecularShift = sampler_state
{
Texture = (Shift_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MAGFILTER = LINEAR;
MIPFILTER = LINEAR;
MINFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tSpecularMask = sampler_state
{
Texture = (SpecularMask_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};

struct Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_PS_INPUT
{
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

float Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_HairDiffuseTerm(float3 N, float3 L)
{
return saturate(0.75 * dot(N, L) + 0.25);
}

float Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_HairSingleSpecularTerm(float3 T, float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_H, float exponent)
{
float dotTH = dot(T, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_H);
float sinTH = sqrt(1.0 - dotTH*dotTH);
return pow(sinTH, exponent);
}

float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_ShiftTangent(float3 T, float3 N, float shiftAmount)
{
return normalize(T + shiftAmount * N);
}

float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_main(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_PS_INPUT i) : COLOR
{
// shift tangents
float shiftTex = tex2D(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tSpecularShift, i.texCoord) - 0.5;

float3 N = normalize (i.normal);

float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_T1 = Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_ShiftTangent(i.tangent, N, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularShift.x + shiftTex);
float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_T2 = Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_ShiftTangent(i.tangent, N, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularShift.y + shiftTex);

// Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_diffuse term
float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_diffuse = Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_hairBaseColor * Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_diffuseLightColor *
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_HairDiffuseTerm(N, i.lightVec);

// Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular term
float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_H = normalize(i.lightVec + i.viewVec);
float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular = Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularColor0 *
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_HairSingleSpecularTerm(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_T1, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_H, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularExp.x);

float3 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular2 = Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularColor1 *
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_HairSingleSpecularTerm(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_T2, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_H, Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularExp.y);

// modulate secondary Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular term with noise
float Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularMask = tex2D(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tSpecularMask, i.texCoord * 10.0f);
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular2 *= Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularMask;

// Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular attenuation for hair facing away from light
float Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularAttenuation = saturate(1.75 * dot(N, i.lightVec) + 0.25);

Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular = (Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular + Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular2) * Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularLightColor *
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specularAttenuation;

// read Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_base texture
float Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_base = tex2D(Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tBase, i.texCoord);

// combine terms for final output
float4 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_o;

Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_o.rgb = (Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_diffuse + Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_ambientLightColor * Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_hairBaseColor) * Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_base;
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_base = 1.5 * Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_base - 0.5;
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_o.rgb += Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_specular * Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_base;
//Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_o.rgb *= i.ambOcc;
Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_o.a = tex2D (Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_tAlpha, i.texCoord); // read alpha texture

return Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_o;

return i.ambOcc;
}

//--------------------------------------------------------------//
// HairPassFrontFacingTransparent
//--------------------------------------------------------------//
string Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_HairModel : ModelData = "Hair.obj";

float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_lightPos
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_lightPos";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -200.00;
float UIMax = 200.00;
> = ( -20.00, 184.00, 36.00 );
float4x4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_matView : View;
float4x4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_matViewProjection : ViewProjection;
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_lightDir;

struct Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_VS_INPUT
{
float4 pos : POSITION;
float3 normal : NORMAL;
float3 tangent : BINORMAL0;
float2 texCoord : TEXCOORD0;
};

struct Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_VS_OUTPUT
{
float4 pos : POSITION;
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_VS_OUTPUT Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_main(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_VS_INPUT i)
{
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_VS_OUTPUT o = (Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_VS_OUTPUT) 0;

// Output transformed position:
o.pos = mul(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_matViewProjection, i.pos);

// Output light vector:
o.lightVec = normalize (Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_lightPos - i.pos);

// Compute position in view space:
float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_Pview = mul( Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_matView, i.pos );

// hair model doesn't contain per-vertex ambient occlusion
o.ambOcc = 1.0f;

// Transform the input normal to view space:
o.normal = i.normal;//normalize( mul( Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_matView, tempNorm ) );

o.tangent = i.tangent;

// Compute the view direction in view space:
o.viewVec = - normalize( Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_Pview );

// Propagate texture coordinate for the object:
o.texCoord = i.texCoord;

return o;
}





float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_ambientLightColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_ambientLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.79, 0.79, 0.79, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularLightColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularColor1
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularColor1";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.76, 0.43, 0.13, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularColor0
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularColor0";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.73, 0.64, 0.47, 1.00 );
float2 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularExp
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularExp";
string UIWidget = "Numeric";
bool UIVisible = " false";
float UIMin = -1.00;
float UIMax = 1.00;
> = ( 200.00, 15.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_diffuseLightColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_diffuseLightColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_hairBaseColor
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_hairBaseColor";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.56, 0.24, 0.06, 1.00 );
float2 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularShift
<
string UIName = "Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularShift";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = -1.00;
float UIMax = 1.00;
> = ( 0.08, 0.54 );

sampler2D Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tBase = sampler_state
{
Texture = (Base_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tAlpha = sampler_state
{
Texture = (Alpha_Tex);
ADDRESSU = WRAP;
ADDRESSV = CLAMP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tSpecularShift = sampler_state
{
Texture = (Shift_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MAGFILTER = LINEAR;
MIPFILTER = LINEAR;
MINFILTER = LINEAR;
};
sampler2D Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tSpecularMask = sampler_state
{
Texture = (SpecularMask_Tex);
ADDRESSU = WRAP;
ADDRESSV = WRAP;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
MAGFILTER = LINEAR;
};

struct Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_PS_INPUT
{
float3 normal : TEXCOORD0;
float3 tangent : TEXCOORD1;
float3 viewVec : TEXCOORD2;
float2 texCoord : TEXCOORD3;
float ambOcc : TEXCOORD4;
float3 lightVec : TEXCOORD5;
};

float Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_HairDiffuseTerm(float3 N, float3 L)
{
return saturate(0.75 * dot(N, L) + 0.25);
}

float Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_HairSingleSpecularTerm(float3 T, float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_H, float exponent)
{
float dotTH = dot(T, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_H);
float sinTH = sqrt(1.0 - dotTH*dotTH);
return pow(sinTH, exponent);
}

float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_ShiftTangent(float3 T, float3 N, float shiftAmount)
{
return normalize(T + shiftAmount * N);
}

float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_main(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_PS_INPUT i) : COLOR
{
// shift tangents
float shiftTex = tex2D(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tSpecularShift, i.texCoord) - 0.5;

float3 N = normalize (i.normal);

float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_T1 = Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_ShiftTangent(i.tangent, N, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularShift.x + shiftTex);
float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_T2 = Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_ShiftTangent(i.tangent, N, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularShift.y + shiftTex);

// Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_diffuse term
float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_diffuse = Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_hairBaseColor * Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_diffuseLightColor *
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_HairDiffuseTerm(N, i.lightVec);

// Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular term
float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_H = normalize(i.lightVec + i.viewVec);
float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular = Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularColor0 *
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_HairSingleSpecularTerm(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_T1, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_H, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularExp.x);

float3 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular2 = Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularColor1 *
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_HairSingleSpecularTerm(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_T2, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_H, Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularExp.y);

// modulate secondary Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular term with noise
float Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularMask = tex2D(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tSpecularMask, i.texCoord * 10.0f);
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular2 *= Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularMask;

// Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular attenuation for hair facing away from light
float Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularAttenuation = saturate(1.75 * dot(N, i.lightVec) + 0.25);

Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular = (Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular + Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular2) * Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularLightColor *
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specularAttenuation;

// read Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_base texture
float Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_base = tex2D(Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tBase, i.texCoord);

// combine terms for final output
float4 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_o;

Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_o.rgb = (Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_diffuse + Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_ambientLightColor * Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_hairBaseColor) * Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_base;
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_base = 1.5 * Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_base - 0.5;
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_o.rgb += Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_specular * Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_base;
//Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_o.rgb *= i.ambOcc;
Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_o.a = tex2D (Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_tAlpha, i.texCoord); // read alpha texture

return Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_o;

return i.ambOcc;
}

//--------------------------------------------------------------//
// KajiyaKayNormalPS
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// Back side
//--------------------------------------------------------------//
string Hair_Rendering_KajiyaKayNormalPS_Back_side_HairPatch : ModelData = "HairPatch.3ds";

float4x4 view_proj_matrix : ViewProjection;
float displacement;
float4 view_position : ViewPosition;
float4x4 view_matrix;
float4x4 inv_view_matrix : ViewInverse;

struct Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_VS_INPUT
{
float4 Pos: POSITION;
float3 Normal: NORMAL;
float3 Color: COLOR0;
float2 uv: TEXCOORD0;
float3 Tangent: TANGENT0;
float3 Binormal:BINORMAL0;
};

struct Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_VS_OUTPUT
{
float4 Pos: POSITION;
float2 uv: TEXCOORD0;
float3 Tangent: TEXCOORD1;
float3 viewDir: TEXCOORD2;
};

Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_VS_OUTPUT Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_vs_main( Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_VS_INPUT In )
{
Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_VS_OUTPUT Out;

Out.Pos = mul(view_proj_matrix, In.Pos);

Out.Tangent = In.Tangent;

// compute normalized vector from vertex to camera
Out.viewDir = normalize (mul(inv_view_matrix, view_position) - In.Pos);

Out.uv = In.uv;

return Out;
}




float4 Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_lightDir
<
string UIName = "Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_lightDir";
string UIWidget = "Direction";
bool UIVisible = " true";
float4 UIMin = ( -10.00, -10.00, -10.00, -10.00 );
float4 UIMax = ( 10.00, 10.00, 10.00, 10.00 );
bool Normalize = " false";
> = ( -0.67, -0.72, -0.20, 1.00 );
float4 Kd
<
string UIName = "Kd";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.86, 0.52, 0.31, 1.00 );
float specularity
<
string UIName = "specularity";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = 0.00;
float UIMax = 500.00;
> = 385.00;
float4 Ks
<
string UIName = "Ks";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
texture HairStrand_Tex
<
string ResourceName = "HairStrand.bmp";
>;
sampler ColorTexture = sampler_state
{
Texture = (HairStrand_Tex);
MINFILTER = ANISOTROPIC;
MAXANISOTROPY = 4;
MIPFILTER = LINEAR;
};
texture HairStrandAlpha_Tex
<
string ResourceName = "HairStrandAlpha.bmp";
>;
sampler AlphaTexture = sampler_state
{
Texture = (HairStrandAlpha_Tex);
};

struct Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_VS_OUTPUT
{
float4 Pos: POSITION;
float2 uv: TEXCOORD0;
float3 Tangent: TEXCOORD1;
float3 viewDir: TEXCOORD2;
};

float4 Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_ps_main( Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_VS_OUTPUT In ) : COLOR0
{
float dotTL = dot (In.Tangent, Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_lightDir);
float dotTV = dot (In.Tangent, normalize (In.viewDir));

float sinTL = sqrt (1 - dotTL*dotTL);
float sinTV = sqrt (1 - dotTV*dotTV);

float3 Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_diffuse = Kd * sinTL;
float3 Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_specular = Ks * pow (dotTL*dotTV + sinTL*sinTV, specularity);

float4 color = float4(Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_diffuse + Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_specular, 0);

// modulate everything with grayscale base texture and apply alpha
// texture
color.rgb *= tex2D (ColorTexture, In.uv.yx);
color.a = tex2D (AlphaTexture, In.uv.yx).r;

return color;
}




//--------------------------------------------------------------//
// Front side
//--------------------------------------------------------------//
string Hair_Rendering_KajiyaKayNormalPS_Front_side_HairPatch : ModelData = "HairPatch.3ds";

float4x4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_view_proj_matrix : ViewProjection;
float Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_displacement;
float4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_view_position : ViewPosition;
float4x4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_view_matrix;
float4x4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_inv_view_matrix : ViewInverse;

struct Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_VS_INPUT
{
float4 Pos: POSITION;
float3 Normal: NORMAL;
float3 Color: COLOR0;
float2 uv: TEXCOORD0;
float3 Tangent: TANGENT0;
float3 Binormal:BINORMAL0;
};

struct Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_VS_OUTPUT
{
float4 Pos: POSITION;
float2 uv: TEXCOORD0;
float3 Tangent: TEXCOORD1;
float3 viewDir: TEXCOORD2;
};

Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_VS_OUTPUT Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_vs_main( Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_VS_INPUT In )
{
Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_VS_OUTPUT Out;

Out.Pos = mul(Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_view_proj_matrix, In.Pos);

Out.Tangent = In.Tangent;

// compute normalized vector from vertex to camera
Out.viewDir = normalize (mul(Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_inv_view_matrix, Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_view_position) - In.Pos);

Out.uv = In.uv;

return Out;
}




float4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_lightDir
<
string UIName = "Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_lightDir";
string UIWidget = "Direction";
bool UIVisible = " true";
float4 UIMin = ( -10.00, -10.00, -10.00, -10.00 );
float4 UIMax = ( 10.00, 10.00, 10.00, 10.00 );
bool Normalize = " false";
> = ( -0.67, -0.72, -0.20, 1.00 );
float4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_Kd
<
string UIName = "Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_Kd";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 0.86, 0.52, 0.31, 1.00 );
float Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_specularity
<
string UIName = "Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_specularity";
string UIWidget = "Numeric";
bool UIVisible = " true";
float UIMin = 0.00;
float UIMax = 500.00;
> = 385.00;
float4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_Ks
<
string UIName = "Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_Ks";
string UIWidget = "ColorPicker";
bool UIVisible = " true";
> = ( 1.00, 1.00, 1.00, 1.00 );
sampler Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_ColorTexture = sampler_state
{
Texture = (HairStrand_Tex);
MINFILTER = ANISOTROPIC;
MAXANISOTROPY = 4;
MIPFILTER = LINEAR;
};
sampler Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_AlphaTexture = sampler_state
{
Texture = (HairStrandAlpha_Tex);
};

struct Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_VS_OUTPUT
{
float4 Pos: POSITION;
float2 uv: TEXCOORD0;
float3 Tangent: TEXCOORD1;
float3 viewDir: TEXCOORD2;
};

float4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_ps_main( Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_VS_OUTPUT In ) : COLOR0
{
float dotTL = dot (In.Tangent, Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_lightDir);
float Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_dotTV = dot (In.Tangent, normalize (In.viewDir));

float Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_sinTL = sqrt (1 - dotTL*dotTL);
float Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_sinTV = sqrt (1 - Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_dotTV*Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_dotTV);

float3 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_diffuse = Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_Kd * Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_sinTL;
float3 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_specular = Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_Ks * pow (dotTL*Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_dotTV + Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_sinTL*Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_sinTV, Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_specularity);

float4 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_color = float4(Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_diffuse + Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_specular, 0);

// modulate everything with grayscale base texture and apply alpha
// texture
Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_color.rgb *= tex2D (Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_ColorTexture, In.uv.yx);
Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_color.a = tex2D (Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_AlphaTexture, In.uv.yx).r;

return Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_color;
}




//--------------------------------------------------------------//
// Technique Section for Hair Rendering
//--------------------------------------------------------------//
technique Ruby_Hair
{
pass HairPrimeZ
{
CULLMODE = NONE;
ALPHAFUNC = LESSEQUAL;
ALPHAREF = 0x2;
ALPHATESTENABLE = TRUE;
ZENABLE = TRUE;
ZFUNC = LESSEQUAL;
ZWRITEENABLE = TRUE;
COLORWRITEENABLE = 0;

VertexShader = compile vs_1_1 Hair_Rendering_Ruby_Hair_HairPrimeZ_Vertex_Shader_main();
PixelShader = compile ps_2_0 Hair_Rendering_Ruby_Hair_HairPrimeZ_Pixel_Shader_main();
}

pass HairPassOpaque
{
CULLMODE = NONE;
ALPHATESTENABLE = FALSE;
ZENABLE = TRUE;
ZFUNC = EQUAL;
ZWRITEENABLE = FALSE;
COLORWRITEENABLE = RED | GREEN | BLUE | ALPHA;

VertexShader = compile vs_1_1 Hair_Rendering_Ruby_Hair_HairPassOpaque_Vertex_Shader_main();
PixelShader = compile ps_2_0 Hair_Rendering_Ruby_Hair_HairPassOpaque_Pixel_Shader_main();
}

pass HairPassBackFacingTransparent
{
CULLMODE = CW;
ZENABLE = TRUE;
ZWRITEENABLE = FALSE;
ZFUNC = LESS;
ALPHABLENDENABLE = TRUE;
DESTBLEND = SRCALPHA;
SRCBLEND = INVSRCALPHA;

VertexShader = compile vs_1_1 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Vertex_Shader_main();
PixelShader = compile ps_2_0 Hair_Rendering_Ruby_Hair_HairPassBackFacingTransparent_Pixel_Shader_main();
}

pass HairPassFrontFacingTransparent
{
CULLMODE = CCW;
ALPHATESTENABLE = FALSE;
ZWRITEENABLE = TRUE;

VertexShader = compile vs_1_1 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Vertex_Shader_main();
PixelShader = compile ps_2_0 Hair_Rendering_Ruby_Hair_HairPassFrontFacingTransparent_Pixel_Shader_main();
}

}

technique KajiyaKayNormalPS
{
pass Back_side
{
CULLMODE = CW;
ALPHABLENDENABLE = TRUE;
BLENDFACTOR = 0x2000000;
SRCBLEND = SRCALPHA;
DESTBLEND = INVSRCALPHA;
ZWRITEENABLE = FALSE;

VertexShader = compile vs_2_0 Hair_Rendering_KajiyaKayNormalPS_Back_side_Vertex_Shader_vs_main();
PixelShader = compile ps_2_0 Hair_Rendering_KajiyaKayNormalPS_Back_side_Pixel_Shader_ps_main();
}

pass Front_side
{
CULLMODE = CCW;
ALPHABLENDENABLE = TRUE;
BLENDFACTOR = 0x2000000;
SRCBLEND = SRCALPHA;
DESTBLEND = INVSRCALPHA;
ZENABLE = TRUE;
ZWRITEENABLE = TRUE;

VertexShader = compile vs_2_0 Hair_Rendering_KajiyaKayNormalPS_Front_side_Vertex_Shader_vs_main();
PixelShader = compile ps_2_0 Hair_Rendering_KajiyaKayNormalPS_Front_side_Pixel_Shader_ps_main();
}

}