Sorry your browser is not supported!

  //--------------------------------
  // un-tweaks
  //--------------------------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;   

  //--------------------------------
  // tweaks
  //--------------------------------
   float4 FurColor = {0.32f, 0.17f, 0.021f, 1.0f};
   float  FurHeight = 0.3f;
   float4 LightPosition = {0.0f, 50.0f, -100.0f, 1.0f};    
   float4 LightColor = {1.0f, 1.0f, 1.0f, 1.0f};    
   float  LightRange = 125.0f;
   float4 Ambient = {0.3f, 0.3f, 0.3f, 1.0f};
   float U = 1.0f; 
   float V = 1.0f; 

  //--------------------------------
  // Textures
  //--------------------------------
   texture FurTX 
      <
	string Name="";
      >;	
   sampler2D Fur = sampler_state 
      {
 	texture = <FurTX>;
      };

  //--------------------------------
  // structs
  //--------------------------------
   struct Input
      {
    	float4 Pos:POSITION; 
    	float2 UV:TEXCOORD; 
 	float3 Normal:NORMAL;  
      };
   struct Output
      {
    	float4 OPos:POSITION; 
    	float2 Tex:TEXCOORD0; 
     	float4 Diffuse:COLOR0; 
      };

  //--------------------------------
  // vertex shader
  //--------------------------------
   Output VS(Input IN,uniform float Dir) 
      {
    	Output OUT;
	float4 VPos;
	VPos.xyz=IN.Pos+(IN.Normal*(Dir*FurHeight));VPos.w=IN.Pos.w;
  	OUT.OPos=mul(VPos,WorldVP);
	OUT.Tex=IN.UV*float2(U,V);
	float3 WNor=mul(IN.Normal,World); WNor=normalize(WNor);
	float3 WPos=mul(IN.Pos,World); 
  	float3 LPos=LightPosition-WPos;
   	float4 Light=max(saturate(0.025f+mul(LPos,WNor)*0.025f),0);
	float Dis=max(saturate(1-(length(LPos)/LightRange)),0);
  	OUT.Diffuse=(Ambient+(Light*Dis*LightColor))*FurColor; 
  	return OUT;
      }

  //-----------------
  // techniques 
  //-----------------
    technique VFur
      {
 	pass p0
      {		
 	vertexShader = compile vs_1_1 VS(0); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      	SRCBLEND = SRCALPHA;
      	DESTBLEND = ZERO;
      	ALPHABLENDENABLE = TRUE;
     	BLENDOP = ADD;
      }
  	pass p1
      {		
 	vertexShader = compile vs_1_1 VS(1); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      	SRCBLEND = SRCALPHA;
      	DESTBLEND = ONE;
      	ALPHABLENDENABLE = TRUE;
      	BLENDOP = ADD;
      }
  	pass p2
      {		
 	vertexShader = compile vs_1_1 VS(2); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      }
  	pass p3
      {		
 	vertexShader = compile vs_1_1 VS(3); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE; 
      }
  	pass p4
      {		
 	vertexShader = compile vs_1_1 VS(4); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      }
  	pass p5
      {		
 	vertexShader = compile vs_1_1 VS(5); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      }
  	pass p6
      {		
 	vertexShader = compile vs_1_1 VS(6); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      }
  	pass p7
      {		
 	vertexShader = compile vs_1_1 VS(7); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE; 
      }
  	pass p8
      {		
 	vertexShader = compile vs_1_1 VS(8); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE; 
      }
  	pass p9
      {		
 	vertexShader = compile vs_1_1 VS(9); 
        Sampler[0] = <Fur>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      }
      }

//--------------
// un-tweaks
//--------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;   
   float4 eyePos : CameraPosition;
 
//--------------
// tweaks
//--------------
   float BumpyNess = 0.5f;
   float Alpha = 1.0f;

//--------------
// Textures
//--------------
   texture ScreenTX 
      <
	string Name="";
      >;	
   sampler2D Screen=sampler_state
      {
	Texture = <ScreenTX>;
   	ADDRESSU = CLAMP;
   	ADDRESSV = CLAMP;
   	ADDRESSW = CLAMP;
      };
   texture BaseTX 
    <
	string Name="";
    >;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalmapTX 
      <
	string Name=""; 
      >; 
   sampler2D Normalmap=sampler_state 
      {
   	Texture = <NormalmapTX>;
      };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD;
	float3 normal : NORMAL;
     };
   struct output
     {
 	float4 OPos:POSITION; 
 	float2 Tex:TEXCOORD0; 
        float4 posview:TEXCOORD1;

     };

//--------------
// vertex shader
//--------------
   output VS(input IN)
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
        OUT.posview=float4(OUT.OPos.x*0.5+0.5*OUT.OPos.w,0.5*OUT.OPos.w-OUT.OPos.y*0.5,OUT.OPos.w,OUT.OPos.w);
        return OUT;
     }

//--------------
// pixel shader
//--------------
   float4 PS(output IN) : COLOR 
     {
        float3 distort=tex2D(Normalmap,IN.Tex)*2-1;
        distort=normalize(distort)*BumpyNess;
	float3 Texture=tex2D(Base,IN.Tex+(distort*0.1f));
        float2 nuv=IN.posview.xy/IN.posview.z+distort;
        float3 Refract=tex2D(Screen,nuv);
        return float4(Texture*Refract,Alpha);
     }

//--------------
// techniques   
//--------------
    technique Refraction
      {
 	pass p1
      {		
 	VertexShader = compile vs_2_0 VS(); 
 	PixelShader  = compile ps_2_0 PS(); 		
      }
      }

    Sampler[0] = (baseSample);
    AlphaOp[0] = MODULATE;

If applying a vertex shader, then the following are NOT carried out automatically.
   1. The model view matrix is not applied to vertex coordinates.
   2. The projection matrix is not applied to vertex coordinates.
   3. The texture matrices are not applied to texture coordinates.
   4. The normals are not transformed to eye coordinates.
   5. The normals are not rescaled or normalized.
   6. Texture coordinates are not generated automatically.
   7. Per vertex lighting is not performed.
   8. Color material lighting is not performed.
   9. Point size distance attenuation is not performed.

// This is used by 3dsmax to load the correct parser
string ParamID = "0x003";

float Script : STANDARDSGLOBAL <
	string UIWidget = "none";
	string ScriptClass = "object";
	string ScriptOrder = "standard";
	string ScriptOutput = "color";
	string Script = "Technique=Default;";
> = 0.8; // version #


// light direction (view space)
float3 g_LightDir : Direction <  

> = {-0.577, -0.577, 0.577};

float4 g_LightPos : POSITION <  
	string UIName = "Light Position"; 
	string Object = "PointLight";
	string Space = "World";
	int refID = 0;
> = {-0.577, -0.577, 0.577,0.0};


float4 g_LightCol : LIGHTCOLOR
<
	int LightRef = 0;
	string UIWidget = "None";
> = float4(0.0f, 0.0f, 0.0f, 0.0f);

// material reflectivity
float4 k_a  <
	string UIName = "Ambient";
> = float4( 0.0f, 0.0f, 0.0f, 1.0f );    // ambient
	
float4 k_d  <
	string UIName = "Diffuse";
> = float4( 0.47f, 0.47f, 0.47f, 1.0f );    // diffuse
	
float4 k_s  <
	string UIName = "Specular";
> = float4( 1.0f, 1.0f, 1.0f, 1.0f );    // diffuse    // specular

int n<
	string UIName = "Specular Power";
	string UIType = "IntSpinner";
	float UIMin = 0.0f;
	float UIMax = 50.0f;	
>  = 15;

bool g_AlphaVertex <
	string UIName = "Vertex Alpha";
> = true;

bool g_AddVertexColor <
	string UIName = "Add Vertex Color";
> =false;

bool g_UseParallax <
	string UIName = "Normal Map Parallax";
> =false;

float g_BumpScale <
	string UIName = "Bump Amount";
	float UIMin = 0.0f;
	float UIMax = 5.0f;
	float UIStep = 0.01f;
>   = 1.0f;


float g_ParallaxScale <
	string UIName = "Parallax Scale";
	float UIMin = -0.50f;
	float UIMax = 0.5f;
	float UIStep = 0.01f;
>   = 0.02f;
									
float g_ParallaxBias <
	string UIName = "Parallax Bias";
	float UIMin = -0.5f;
	float UIMax = 0.5f;
	float UIStep = 0.01f;
>   = 0.0f;

bool g_AmbientOccEnable <
	string UIName = "Ambient Occlusion Enable";
> = false;

texture g_AmbientOccTexture < 
	string UIName = "Ambient Occlusion";
	int Texcoord = 4;
	int MapChannel = 1;
>;

bool g_TopDiffuseEnable <
	string UIName = "Top Diffuse Color Enable";
> = false;

texture g_TopTexture : DiffuseMap< 
	string UIName = "Top Diffuse Map ";
	int Texcoord = 0;
	int MapChannel = 1;
>;

bool g_BottomDiffuseEnable <
	string UIName = "Bottom Diffuse Color Enable";
> = false;

texture g_BottomTexture < 
	string UIName = "Bottom Diffuse";
	int Texcoord = 5;
	int MapChannel = 1;
>;

bool g_SpecularEnable <
	string UIName = "Specular  Enable";
> = false;

texture g_SpecularTexture < 
	string UIName = "Specular";
	int Texcoord = 6;
	int MapChannel = 1;
>;

bool g_NormalEnable <
	string UIName = "Normal Enable";
> = false;

texture g_NormalTexture < 
	string UIName = "Normal";
	int Texcoord = 7;
	int MapChannel = 1;
>;

bool g_ReflectionEnable <
	string UIName = "Reflection Enable";
> = false;

texture g_ReflectionTexture < 
	string UIName = "Reflection";
	string ResourceType = "CUBE";
>;
float g_ReflectAmount <
	string UIName = "Reflection Amount";
	float UIMin = 0.0f;
	float UIMax = 2.0f;
	float UIStep = 0.01f;
>   = 1.0f;


sampler2D g_AmbientOccSampler = sampler_state
{
	Texture = <g_AmbientOccTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};


sampler2D g_TopSampler = sampler_state
{
	Texture = <g_TopTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};
	
sampler2D g_BottomSampler = sampler_state
{
	Texture = <g_BottomTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler2D g_SpecularSampler = sampler_state
{
	Texture = <g_SpecularTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler2D g_NormalSampler = sampler_state
{
	Texture = <g_NormalTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

samplerCUBE g_ReflectionSampler = sampler_state
{
	Texture = <g_ReflectionTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};



// transformations
float4x4 World      : 		WORLD;
float4x4 WorldI		:		WORLDI;
float4x4 View       : 		VIEW;
float4x4 ViewI		:		VIEWI;
float4x4 Projection : 		PROJECTION;
float4x4 WorldViewProj : 	WORLDVIEWPROJ;
float4x4 WorldView : 		WORLDVIEW;

int texcoord1 : Texcoord
<
	int Texcoord = 1;
	int MapChannel = 0;
	string UIWidget = "None";
>;

int texcoord2 : Texcoord
<
	int Texcoord = 2;
	int MapChannel = -2;
	string UIWidget = "None";
>;

int texcoord3 : Texcoord
<
	int Texcoord = 3;
	int MapChannel = -1;
	string UIWidget = "None";
>;


float3 NormalCalc(float3 mapNorm, float BumpScale)
{
	float3 v = {0.5f,0.5f,1.0f};
	mapNorm = lerp(v, mapNorm, BumpScale );
	mapNorm = ( mapNorm * 2.0f ) - 1.0f;
	return mapNorm;
}


struct VSIn
{
	float4 Position		: POSITION;
	float3 Normal		: NORMAL;
	float3 Tangent		: TANGENT;
	float3 BiNormal		: BINORMAL;
	float2 UV0		: TEXCOORD0;	
	float3 Colour		: TEXCOORD1;
	float3 Alpha		: TEXCOORD2;
	float3 Illum		: TEXCOORD3;
	float3 UV1		: TEXCOORD4;
	float3 UV2		: TEXCOORD5;
	float3 UV3		: TEXCOORD6;
	float3 UV4		: TEXCOORD7;

};


struct VSOut
{
	float4 Position		: POSITION;
   	float4 UV0		: TEXCOORD0;
   	float3 LightDir		: TEXCOORD1;
   	float3 Normal		: TEXCOORD2;
   	float3 ViewDir		: TEXCOORD3;
	float4 UV1		: TEXCOORD4;
	float2 UV2		: TEXCOORD5;
	float2 UV3		: TEXCOORD6;
	float2 UV4		: TEXCOORD7;
   	
};

struct PSIn
{
   	float4 UV0		: TEXCOORD0;
   	float3 LightDir		: TEXCOORD1;
   	float3 Normal		: TEXCOORD2;
   	float3 ViewDir		: TEXCOORD3;
	float4 UV1		: TEXCOORD4;
	float2 UV2		: TEXCOORD5;
	float2 UV3		: TEXCOORD6;
	float2 UV4		: TEXCOORD7;

};

struct PSOut
{
	float4 Colour		: COLOR;
};


VSOut VS(VSIn vsIn) 
{
	VSOut vsOut;                                                                                                                                                                                                                                                                                                                                   
   	vsOut.Position = mul(vsIn.Position, WorldViewProj);
   	float4 colour;
   	colour.rgb = vsIn.Colour * vsIn.Illum;
   	colour.a = vsIn.Alpha.x;
   	
   	vsOut.UV0.z = colour.r;
   	vsOut.UV0.a = colour.g;
   	
   	vsOut.UV1.z = colour.b;
   	vsOut.UV1.a = colour.a;
   	

	vsOut.Normal = vsIn.Normal;
	float4 g_CamPos = mul(ViewI[3],WorldI);
	float3 ViewDir = g_CamPos.xyz - vsIn.Position.xyz;
	float4 lightPos = mul(g_LightPos, WorldI);
	float3 lightVec = (lightPos.xyz - vsIn.Position.xyz);
	if(g_NormalEnable)
	{
		float3x3 objToTangent;

		objToTangent[0] = vsIn.BiNormal;
		objToTangent[1] = vsIn.Tangent;
		objToTangent[2] = vsIn.Normal;
		
		vsOut.LightDir = mul(objToTangent, lightVec);
		vsOut.ViewDir = mul(objToTangent, ViewDir);
		
	}
	else
	{
		vsOut.LightDir = lightVec;
		vsOut.ViewDir = ViewDir;
	}
	
   	vsOut.UV0.xy = vsIn.UV0.xy;
   	vsOut.UV1.xy = vsIn.UV1.xy;
   	vsOut.UV2 = vsIn.UV2;
   	vsOut.UV3 = vsIn.UV3;
   	vsOut.UV4 = vsIn.UV4;
	return vsOut;
}

PSOut PS( PSIn psIn )
{
	PSOut psOut;
	float3 BottomCol = k_d.rgb; 
	float4 TopCol = k_d; 
	float3 LightCol = float3(1.0,1.0,1.0);
	float3 Normal = psIn.Normal;
	float3 LightDir = normalize(psIn.LightDir); 
	float3 ViewDir = normalize(psIn.ViewDir);
	float3 Ambient = k_a.rgb;
	float3 SpecLevel = float3(1.0,1.0,1.0);
	float3 RefelctContrib=float3(1,1,1);
	float Alpha; 
	
	float2 normalUV = psIn.UV4;
	float2 diffuseUV = psIn.UV0;
	
	float4 newCol;
	float4 vertColour = float4(psIn.UV0.z,psIn.UV0.w,psIn.UV1.z,psIn.UV1.w);
	
	if(g_UseParallax && g_NormalEnable)
	{
		float height = tex2D(g_NormalSampler, psIn.UV4 ).a;
		float Altitude = height + g_ParallaxBias; 
		normalUV  = Altitude * g_ParallaxScale*ViewDir;
		normalUV +=  psIn.UV4;		
		diffuseUV = normalUV;	
	}
		
	
	if(g_AmbientOccEnable)
		Ambient *= tex2D(g_AmbientOccSampler, psIn.UV1);


	if(g_TopDiffuseEnable)
		TopCol = tex2D(g_TopSampler, diffuseUV );
	
	if(g_BottomDiffuseEnable)
		BottomCol = tex2D(g_BottomSampler, psIn.UV2);
	

	if(g_AlphaVertex)
		Alpha = vertColour.a;
	else
		Alpha = TopCol.a;
		

	if(g_NormalEnable)
		Normal = NormalCalc(tex2D(g_NormalSampler, normalUV).xyz, g_BumpScale);
		
	if(g_SpecularEnable)
		SpecLevel = tex2D(g_SpecularSampler, psIn.UV3).xyz;


	newCol.rgb = TopCol * Alpha;
	newCol.rgb += BottomCol * (1.0f - Alpha);
	if(g_AddVertexColor)
		newCol.rgb *= vertColour.rgb;
		
	psOut.Colour.rgb = (Ambient + (g_LightCol * saturate(dot(Normal, LightDir)))) * newCol.rgb;		

	if(g_ReflectionEnable)
	{
		float3 CUV = normalize( reflect( ViewDir, Normal).xzy);
		CUV.y = -CUV.y;
		float4 env = texCUBE(g_ReflectionSampler, CUV);
		env *=g_ReflectAmount;
		env *= SpecLevel.r;
		psOut.Colour.rgb += env;
	
	}
	

	float3 H = normalize(LightDir + ViewDir);
	float Specular = pow(saturate(dot(Normal, H)), n);
	psOut.Colour.rgb += (k_s.rgb * Specular) * SpecLevel.rgb;

	psOut.Colour.a = 1.0f;
	return psOut;
}


technique Default
<
	string script = "Pass=p0;";
> 
{
    pass p0 <
		string script = "Draw=Geometry;";
    >
    {		
		AlphaBlendEnable	= TRUE;
		DestBlend		= InvSrcAlpha;  
		SrcBlend		= SrcAlpha;
		VertexShader	= compile vs_1_1 VS();
		PixelShader		= compile ps_2_0 PS();
    }
}

float3 Ambient:COLOR
float3 LightPosition1
float3 LightPosition2
float3 LightColor1:COLOR
float3 LightColor2:COLOR
float LightStrength1
float LightStrength2
float LightRange1
float LightRange2
float LightContrast1
float LightContrast2
float Skin
float Translucent
float TranslucentContrast
float SkinScatter
float3 Outline:COLOR
float OutlineContrast
float SpecularStrength
float SpecularPower
float SpecularScatter
float Alpha

  // Note a boolean function - returning true or false
  if((bResult=bMyfunction()){ Do something };

  if((bResult=bMyFunction)==true){
    printf("It worked");
  }else{
    printf("It failed");
  };
  printf("bResult:%i",bResult);