Hello out there,

i've got an .fx-Shader-File, which is simulating realistic Hair. It's written for DX9 and uses some files (Object-Model, JPG's). When i use it, the modell doesn't appear. It's simple hidden. When i deassign the effect, the model is there.

I think there must be a little convert-work done to be able to use it. Does anyone have interest to have a look at it ? If yes, i will mail the files. About myself i can say, i'm a totally noob in shader-programming. That's why i request the help

Kind Regards

It most probably has got something to do with those models it uses.. I'm no shader guru, but I can take a look at it if you want. (blablableblobrox(at)hotmail.com)

Cheers

yeah, cool, how often must one tell you to show your fx files and probably provide your model where the problem appears, so one could at least try to help you...

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();
}

}