Sorry your browser is not supported!

////////////////////////////////
//       PS 2.0 Matrix        //
//                            //
// By Carlos(Darkcoder)Wilkes //
//      Darkcoder.co.uk       //
////////////////////////////////

//////////////////////////////
//     Engine Matrices      //
//////////////////////////////
	matrix WorldViewProjection	: WorldViewProjection;

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	float  One_Div_XTiles	= 1.0;
	float  One_Div_YTiles	= 1.0;
	float  Size_Div_XTiles	= 256.0;
	float  Size_Div_YTiles	= 256.0;
	
//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	texture TileTX		<string ResourceName = "" ;>;
	sampler2D TileSampler = sampler_state
	{
		texture = <TileTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = None;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture DiffuseTX		<string ResourceName = "" ;>;
	sampler2D DiffuseSampler = sampler_state
	{
		texture = <DiffuseTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};

//////////////////////////////
//         Structs          //
//////////////////////////////
	struct Matrix_Input
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};
	struct Matrix_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};

//////////////////////////////
//     Vertex Shaders       //
//////////////////////////////
	Matrix_Output VS_Matrix(Matrix_Input IN)
	{
		Matrix_Output OUT;
		
		OUT.Position	= mul( IN.Position, WorldViewProjection );
		OUT.UV0			= IN.UV0;
		OUT.UV1			= IN.UV1;
		OUT.Diffuse		= IN.Diffuse;
		return OUT;
	}

//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_Matrix(Matrix_Output IN) : COLOR
	{
		float2 TileMap		 = tex2D( TileSampler	,IN.UV0 );
		
		float2 UV			 = IN.UV1 * float2( One_Div_XTiles, One_Div_YTiles );
		UV					+= TileMap * Size_Div_XTiles;
		
		float4 DiffuseMap	 = tex2D( DiffuseSampler, UV );
		DiffuseMap.rgb		*= IN.Diffuse;
		
		return DiffuseMap;
	}

//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique Matrix
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_Matrix();
			pixelShader			= compile ps_2_0 PS_Matrix();
		}
	}

Function RT_Plane_Update( ObjectID As Dword , CameraID As Dword )
    
    // Orient the Render Target plane to the designated camera
    Position Object ObjectID , Camera Position X(CameraID) , Camera Position Y(CameraID) , Camera Position Z(CameraID)
    Set Object To Camera Orientation ObjectID
    
EndFunction

Function RT_Plane_Create( ObjectID As Dword , ImageID As Dword )
    
    Local RTWidth       As Float
    Local RTHeight      As Float
    Local RTDepth       As Float
    Local PixelWidth    As Float
    
    // Grab view size data
    Pick Screen 0 , 0 , 100.0
    RTWidth     = Get Pick Vector X()
    RTHeight    = Get Pick Vector Y()
    RTDepth     = Get Pick Vector Z()
    PixelWidth  = Get Pick Vector Y() / ( Screen Height() * 0.5 )
    
    // Make and setup RT plane
    Make Object Plain ObjectID , 200.0 , 200.0
    Set Object Light  ObjectID , 0
    Texture Object    ObjectID , ImageID
    
    // Scale and offset to screen
    Scale Limb  ObjectID , 0 , RTWidth , RTHeight , 100.0
    Offset Limb ObjectID , 0 , PixelWidth * 0.5 , PixelWidth * 0.5 , RTDepth
    
EndFunction

BaseMap.rgb *= IN.Diffuse / 100 * LightInt; // Percentage of lightning

////////////////////////////////
// PS 2.0 Texture Blend Shader//
//                            //
// By Carlos(Darkcoder)Wilkes //
//      Darkcoder.co.uk       //
////////////////////////////////

//////////////////////////////
//     Engine Matrices      //
//////////////////////////////
	matrix WorldViewProjection	: WorldViewProjection;
	matrix World				: World;

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	float3 LightPos;
	
//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	texture LayerMap1TX		<string ResourceName = "" ;>;
	sampler2D LayerMap1Sampler = sampler_state
	{
		texture = <LayerMap1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture LayerMap2TX		<string ResourceName = "" ;>;
	sampler2D LayerMap2Sampler = sampler_state
	{
		texture = <LayerMap2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture BaseTX		<string ResourceName = "" ;>;
	sampler2D BaseSampler = sampler_state
	{
		texture = <BaseTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer1TX		<string ResourceName = "" ;>;
	sampler2D Layer1Sampler = sampler_state
	{
		texture = <Layer1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer2TX		<string ResourceName = "" ;>;
	sampler2D Layer2Sampler = sampler_state
	{
		texture = <Layer2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer3TX		<string ResourceName = "" ;>;
	sampler2D Layer3Sampler = sampler_state
	{
		texture = <Layer3TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer4TX		<string ResourceName = "" ;>;
	sampler2D Layer4Sampler = sampler_state
	{
		texture = <Layer4TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer5TX		<string ResourceName = "" ;>;
	sampler2D Layer5Sampler = sampler_state
	{
		texture = <Layer5TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
//////////////////////////////
//         Structs          //
//////////////////////////////
	struct TextureBlend_Input
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float3 Normal		: NORMAL;
	};
	struct TextureBlend_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};

//////////////////////////////
//     Vertex Shaders       //
//////////////////////////////
	TextureBlend_Output VS_TextureBlend(TextureBlend_Input IN)
	{
		TextureBlend_Output OUT;
		
		OUT.Position	= mul( IN.Position, WorldViewProjection );
		OUT.UV0			= IN.UV0;
		OUT.UV1			= IN.UV1;
		float3	Normal	= mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir= normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector
		
		OUT.Diffuse		=  dot( Normal, LightDir ); // Calc lighting
		return OUT;
	}

//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_TextureBlend(TextureBlend_Output IN) : COLOR
	{
		
		float3 LayerMap1Map	= tex2D( LayerMap1Sampler	,IN.UV0 ); // *NOTE* The first 2 textures are used to sample the opacity, for each of the 5
		float3 LayerMap2Map	= tex2D( LayerMap2Sampler	,IN.UV0 ); //        additional texture stages, much like the vertex blend uses vertex UV data.
		
		float4 BaseMap		= tex2D( BaseSampler	,IN.UV1 );
		float3 Layer1Map	= tex2D( Layer1Sampler	,IN.UV1 );
		float3 Layer2Map	= tex2D( Layer2Sampler	,IN.UV1 );
		float3 Layer3Map	= tex2D( Layer3Sampler	,IN.UV1 );
		float3 Layer4Map	= tex2D( Layer4Sampler	,IN.UV1 );
		float3 Layer5Map	= tex2D( Layer5Sampler	,IN.UV1 );
		
		BaseMap.rgb = lerp( BaseMap.rgb, Layer1Map, LayerMap1Map.r ); // *NOTE* As with the vertex blend shader you don't need to use Lerp, you can
		BaseMap.rgb = lerp( BaseMap.rgb, Layer2Map, LayerMap1Map.g ); //        use a texture lookup blend quite easily, especially since the 
		BaseMap.rgb = lerp( BaseMap.rgb, Layer3Map, LayerMap1Map.b ); //        Layer2Map has both the G and A channels free.
		BaseMap.rgb = lerp( BaseMap.rgb, Layer4Map, LayerMap2Map.r );
		BaseMap.rgb = lerp( BaseMap.rgb, Layer5Map, LayerMap2Map.g );
		
		BaseMap.rgb *= IN.Diffuse; // Multiply colour by diffuse to get shading!
		
		return BaseMap;
	}
	
//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique TextureBlend
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_TextureBlend();
			pixelShader			= compile ps_2_0 PS_TextureBlend();
		}
	}

//**************************************************************//
//  Effect File exported by RenderMonkey 1.6
//
//  - Although many improvements were made to RenderMonkey FX  
//    file export, there are still situations that may cause   
//    compilation problems once the file is exported, such as  
//    occasional naming conflicts for methods, since FX format 
//    does not support any notions of name spaces. You need to 
//    try to create workspaces in such a way as to minimize    
//    potential naming conflicts on export.                    
//    
//  - Note that to minimize resulting name collisions in the FX 
//    file, RenderMonkey will mangle names for passes, shaders  
//    and function names as necessary to reduce name conflicts. 
//**************************************************************//

//--------------------------------------------------------------//
// NormalMapFilter
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// Single Pass
//--------------------------------------------------------------//
string NormalMapFilter_Single_Pass_ScreenAlignedQuad : ModelData = "..\..\..\..\AMD\RenderMonkey 1.81\Examples\Media\Models\ScreenAlignedQuad.3ds";

struct VS_OUTPUT {
   float4 Pos: POSITION;
   float2 texCoord: TEXCOORD;
};

VS_OUTPUT NormalMapFilter_Single_Pass_Vertex_Shader_main(float4 Pos: POSITION){
   VS_OUTPUT Out;

   // Clean up inaccuracies
   Pos.xy = sign(Pos.xy);

   Out.Pos = float4(Pos.xy, 0, 1);
   // Image-space
   Out.texCoord.x = 0.5 * (1 + Pos.x);
   Out.texCoord.y = 0.5 * (1 - Pos.y);

   return Out;
}







float TextureSize
<
   string UIName = "TextureSize";
   string UIWidget = "Numeric";
   bool UIVisible =  false;
   float UIMin = 0.00;
   float UIMax = 512.00;
> = float( 512.00 );
float4 lightness
<
   string UIName = "lightness";
   string UIWidget = "Direction";
   bool UIVisible =  false;
   float4 UIMin = float4( -10.00, -10.00, -10.00, -10.00 );
   float4 UIMax = float4( 10.00, 10.00, 10.00, 10.00 );
   bool Normalize =  false;
> = float4( 0.30, 0.59, 0.11, 0.00 );
texture BaseMap_Tex
<
   string ResourceName = "..\..\..\..\AMD\RenderMonkey 1.81\Examples\Media\Textures\Wood.dds";
>;
sampler BaseMap = sampler_state
{
   Texture = (BaseMap_Tex);
   ADDRESSU = CLAMP;
   ADDRESSV = CLAMP;
   MAGFILTER = LINEAR;
   MINFILTER = LINEAR;
   MIPFILTER = LINEAR;
};
// The Sobel filter extracts the first order derivates of the image,
// that is, the slope. The slope in X and Y directon allows us to
// given a heightmap evaluate the normal for each pixel. This is
// the same this as ATI's NormalMapGenerator application does,
// except this is in hardware.
//
// These are the filter kernels:
//
//  SobelX       SobelY
//  1  0 -1      1  2  1
//  2  0 -2      0  0  0
//  1  0 -1     -1 -2 -1

float4 NormalMapFilter_Single_Pass_Pixel_Shader_main(float2 texCoord: TEXCOORD) : COLOR {
   float off = 1.0 / TextureSize;

   // Take all neighbor samples
   float4 s00 = tex2D(BaseMap, texCoord + float2(-off, -off));
   float4 s01 = tex2D(BaseMap, texCoord + float2( 0,   -off));
   float4 s02 = tex2D(BaseMap, texCoord + float2( off, -off));

   float4 s10 = tex2D(BaseMap, texCoord + float2(-off,  0));
   float4 s12 = tex2D(BaseMap, texCoord + float2( off,  0));

   float4 s20 = tex2D(BaseMap, texCoord + float2(-off,  off));
   float4 s21 = tex2D(BaseMap, texCoord + float2( 0,    off));
   float4 s22 = tex2D(BaseMap, texCoord + float2( off,  off));

   // Slope in X direction
   float4 sobelX = s00 + 2 * s10 + s20 - s02 - 2 * s12 - s22;
   // Slope in Y direction
   float4 sobelY = s00 + 2 * s01 + s02 - s20 - 2 * s21 - s22;

   // Weight the slope in all channels, we use grayscale as height
   float sx = dot(sobelX, lightness);
   float sy = dot(sobelY, lightness);

   // Compose the normal
   float3 normal = normalize(float3(sx, sy, 1));

   // Pack [-1, 1] into [0, 1]
   return float4(normal * 0.5 + 0.5, 1);
}


//--------------------------------------------------------------//
// Technique Section for NormalMapFilter
//--------------------------------------------------------------//
technique NormalMapFilter
{
   pass Single_Pass
   {
      CULLMODE = NONE;

      VertexShader = compile vs_1_1 NormalMapFilter_Single_Pass_Vertex_Shader_main();
      PixelShader = compile ps_2_0 NormalMapFilter_Single_Pass_Pixel_Shader_main();
   }

}

		float3	Normal	 = mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir = normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector
		
		OUT.Diffuse		=  dot( Normal, LightDir ); // Calc lighting

		OUT.Diffuse		=  IN.Diffuse; 

struct TextureBlend_Input
{
	float4 Position		: POSITION;
	float2 UV0		: TEXCOORD0;
	float2 UV1		: TEXCOORD1;
	float3 Normal		: NORMAL;
};

////////////////////////////////
// PS 2.0 Texture Blend Shader//
//                            //
// By Carlos(Darkcoder)Wilkes //
//      Darkcoder.co.uk       //
////////////////////////////////

//////////////////////////////
//     Engine Matrices      //
//////////////////////////////
	matrix WorldViewProjection	: WorldViewProjection;
	matrix World				: World;

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	float3 LightPos;
	
//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	texture LayerMap1TX		<string ResourceName = "" ;>;
	sampler2D LayerMap1Sampler = sampler_state
	{
		texture = <LayerMap1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture LayerMap2TX		<string ResourceName = "" ;>;
	sampler2D LayerMap2Sampler = sampler_state
	{
		texture = <LayerMap2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture BaseTX		<string ResourceName = "" ;>;
	sampler2D BaseSampler = sampler_state
	{
		texture = <BaseTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer1TX		<string ResourceName = "" ;>;
	sampler2D Layer1Sampler = sampler_state
	{
		texture = <Layer1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer2TX		<string ResourceName = "" ;>;
	sampler2D Layer2Sampler = sampler_state
	{
		texture = <Layer2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer3TX		<string ResourceName = "" ;>;
	sampler2D Layer3Sampler = sampler_state
	{
		texture = <Layer3TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer4TX		<string ResourceName = "" ;>;
	sampler2D Layer4Sampler = sampler_state
	{
		texture = <Layer4TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer5TX		<string ResourceName = "" ;>;
	sampler2D Layer5Sampler = sampler_state
	{
		texture = <Layer5TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
//////////////////////////////
//         Structs          //
//////////////////////////////
	struct TextureBlend_Input
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float3 Normal		: NORMAL;
	};
	struct TextureBlend_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};

//////////////////////////////
//     Vertex Shaders       //
//////////////////////////////
	TextureBlend_Output VS_TextureBlend(TextureBlend_Input IN)
	{
		TextureBlend_Output OUT;
		
		OUT.Position	= mul( IN.Position, WorldViewProjection );
		OUT.UV0			= IN.UV0;
		OUT.UV1			= IN.UV1;
		float3	Normal	= mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir= normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector
		
		OUT.Diffuse		=  dot( Normal, LightDir ); // Calc lighting
		return OUT;
	}

//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_TextureBlend(TextureBlend_Output IN) : COLOR
	{
		
		float3 LayerMap1Map	= tex2D( LayerMap1Sampler	,IN.UV0 ); // *NOTE* The first 2 textures are used to sample the opacity, for each of the 5
		float3 LayerMap2Map	= tex2D( LayerMap2Sampler	,IN.UV0 ); //        additional texture stages, much like the vertex blend uses vertex UV data.
		
		float4 BaseMap		= tex2D( BaseSampler	,IN.UV1 );
		float3 Layer1Map	= tex2D( Layer1Sampler	,IN.UV1 );
		float3 Layer2Map	= tex2D( Layer2Sampler	,IN.UV1 );
		float3 Layer3Map	= tex2D( Layer3Sampler	,IN.UV1 );
		float3 Layer4Map	= tex2D( Layer4Sampler	,IN.UV1 );
		float3 Layer5Map	= tex2D( Layer5Sampler	,IN.UV1 );
		
		BaseMap.rgb = lerp( BaseMap.rgb, Layer1Map, LayerMap1Map.r ); // *NOTE* As with the vertex blend shader you don't need to use Lerp, you can
		BaseMap.rgb = lerp( BaseMap.rgb, Layer2Map, LayerMap1Map.g ); //        use a texture lookup blend quite easily, especially since the 
		BaseMap.rgb = lerp( BaseMap.rgb, Layer3Map, LayerMap1Map.b ); //        Layer2Map has both the G and A channels free.
		BaseMap.rgb = lerp( BaseMap.rgb, Layer4Map, LayerMap2Map.r );
		BaseMap.rgb = lerp( BaseMap.rgb, Layer5Map, LayerMap2Map.g );
		
		BaseMap.rgb *= IN.Diffuse; // Multiply colour by diffuse to get shading!
		
		return BaseMap;
	}
	
//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique TextureBlend
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_TextureBlend();
			pixelShader			= compile ps_2_0 PS_TextureBlend();
		}
	}

		float3	Normal	= mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir= normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector
		
		OUT.Diffuse		=  dot( Normal, LightDir ); // Calc lighting

		float3	Normal	= mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir= normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector

float3	Normal	= mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir= normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector
		
		OUT.Diffuse		=  dot( Normal, LightDir ); // Calc lighting

////////////////////////////////
// PS 2.0 Texture Blend Shader//
//                            //
// By Carlos(Darkcoder)Wilkes //
//      Darkcoder.co.uk       //
////////////////////////////////

//////////////////////////////
//     Engine Matrices      //
//////////////////////////////
	matrix WorldViewProjection	: WorldViewProjection;

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	
//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	texture LayerMap1TX		<string ResourceName = "" ;>;
	sampler2D LayerMap1Sampler = sampler_state
	{
		texture = <LayerMap1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture LayerMap2TX		<string ResourceName = "" ;>;
	sampler2D LayerMap2Sampler = sampler_state
	{
		texture = <LayerMap2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture BaseTX		<string ResourceName = "" ;>;
	sampler2D BaseSampler = sampler_state
	{
		texture = <BaseTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer1TX		<string ResourceName = "" ;>;
	sampler2D Layer1Sampler = sampler_state
	{
		texture = <Layer1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer2TX		<string ResourceName = "" ;>;
	sampler2D Layer2Sampler = sampler_state
	{
		texture = <Layer2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer3TX		<string ResourceName = "" ;>;
	sampler2D Layer3Sampler = sampler_state
	{
		texture = <Layer3TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer4TX		<string ResourceName = "" ;>;
	sampler2D Layer4Sampler = sampler_state
	{
		texture = <Layer4TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer5TX		<string ResourceName = "" ;>;
	sampler2D Layer5Sampler = sampler_state
	{
		texture = <Layer5TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
//////////////////////////////
//         Structs          //
//////////////////////////////
	struct TextureBlend_Input
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};
	struct TextureBlend_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};

//////////////////////////////
//     Vertex Shaders       //
//////////////////////////////
	TextureBlend_Output VS_TextureBlend(TextureBlend_Input IN)
	{
		TextureBlend_Output OUT;
		
		OUT.Position	= mul( IN.Position, WorldViewProjection );
		OUT.UV0			= IN.UV0;
		OUT.UV1			= IN.UV1;
		OUT.Diffuse		= IN.Diffuse;
		return OUT;
	}

//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_TextureBlend(TextureBlend_Output IN) : COLOR
	{
		
		float3 LayerMap1Map	= tex2D( LayerMap1Sampler	,IN.UV0 ); // *NOTE* The first 2 textures are used to sample the opacity, for each of the 5
		float3 LayerMap2Map	= tex2D( LayerMap2Sampler	,IN.UV0 ); //        additional texture stages, much like the vertex blend uses vertex UV data.
		
		float4 BaseMap		= tex2D( BaseSampler	,IN.UV1 );
		float3 Layer1Map	= tex2D( Layer1Sampler	,IN.UV1 );
		float3 Layer2Map	= tex2D( Layer2Sampler	,IN.UV1 );
		float3 Layer3Map	= tex2D( Layer3Sampler	,IN.UV1 );
		float3 Layer4Map	= tex2D( Layer4Sampler	,IN.UV1 );
		float3 Layer5Map	= tex2D( Layer5Sampler	,IN.UV1 );
		
		BaseMap.rgb = lerp( BaseMap.rgb, Layer1Map, LayerMap1Map.r ); // *NOTE* As with the vertex blend shader you don't need to use Lerp, you can
		BaseMap.rgb = lerp( BaseMap.rgb, Layer2Map, LayerMap1Map.g ); //        use a texture lookup blend quite easily, especially since the 
		BaseMap.rgb = lerp( BaseMap.rgb, Layer3Map, LayerMap1Map.b ); //        Layer2Map has both the G and A channels free.
		BaseMap.rgb = lerp( BaseMap.rgb, Layer4Map, LayerMap2Map.r );
		BaseMap.rgb = lerp( BaseMap.rgb, Layer5Map, LayerMap2Map.g );
		
		BaseMap.rgb *= IN.Diffuse; // Multiply colour by diffuse to get shading!
		
		return BaseMap;
	}
	
//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique TextureBlend
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_TextureBlend();
			pixelShader			= compile ps_2_0 PS_TextureBlend();
		}
	}

////////////////////////////////
// PS 2.0 Texture Blend Shader//
//                            //
// By Carlos(Darkcoder)Wilkes //
//      Darkcoder.co.uk       //
////////////////////////////////

//////////////////////////////
//     Engine Matrices      //
//////////////////////////////
	matrix WorldViewProjection	: WorldViewProjection;

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	
//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	texture LayerMap1TX		<string ResourceName = "" ;>;
	sampler2D LayerMap1Sampler = sampler_state
	{
		texture = <LayerMap1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture LayerMap2TX		<string ResourceName = "" ;>;
	sampler2D LayerMap2Sampler = sampler_state
	{
		texture = <LayerMap2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture BaseTX		<string ResourceName = "" ;>;
	sampler2D BaseSampler = sampler_state
	{
		texture = <BaseTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer1TX		<string ResourceName = "" ;>;
	sampler2D Layer1Sampler = sampler_state
	{
		texture = <Layer1TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer2TX		<string ResourceName = "" ;>;
	sampler2D Layer2Sampler = sampler_state
	{
		texture = <Layer2TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer3TX		<string ResourceName = "" ;>;
	sampler2D Layer3Sampler = sampler_state
	{
		texture = <Layer3TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer4TX		<string ResourceName = "" ;>;
	sampler2D Layer4Sampler = sampler_state
	{
		texture = <Layer4TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
	texture Layer5TX		<string ResourceName = "" ;>;
	sampler2D Layer5Sampler = sampler_state
	{
		texture = <Layer5TX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
//////////////////////////////
//         Structs          //
//////////////////////////////
	struct TextureBlend_Input
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};
	struct TextureBlend_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};

//////////////////////////////
//     Vertex Shaders       //
//////////////////////////////
	TextureBlend_Output VS_TextureBlend(TextureBlend_Input IN)
	{
		TextureBlend_Output OUT;
		
		OUT.Position	= mul( IN.Position, WorldViewProjection );
		OUT.UV0			= IN.UV0;
		OUT.UV1			= IN.UV1;
		float3	Normal	= mul( IN.Normal, World ); // Transform normal to world space
		float3	LightDir= normalize( LightPos - mul( IN.Position, World ) ); // Find the light direction vector
		OUT.Diffuse		= IN.Diffuse;
		return OUT;
	}

//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_TextureBlend(TextureBlend_Output IN) : COLOR
	{
		
		float3 LayerMap1Map	= tex2D( LayerMap1Sampler	,IN.UV0 ); // *NOTE* The first 2 textures are used to sample the opacity, for each of the 5
		float3 LayerMap2Map	= tex2D( LayerMap2Sampler	,IN.UV0 ); //        additional texture stages, much like the vertex blend uses vertex UV data.
		
		float4 BaseMap		= tex2D( BaseSampler	,IN.UV1 );
		float3 Layer1Map	= tex2D( Layer1Sampler	,IN.UV1 );
		float3 Layer2Map	= tex2D( Layer2Sampler	,IN.UV1 );
		float3 Layer3Map	= tex2D( Layer3Sampler	,IN.UV1 );
		float3 Layer4Map	= tex2D( Layer4Sampler	,IN.UV1 );
		float3 Layer5Map	= tex2D( Layer5Sampler	,IN.UV1 );
		
		BaseMap.rgb = lerp( BaseMap.rgb, Layer1Map, LayerMap1Map.r ); // *NOTE* As with the vertex blend shader you don't need to use Lerp, you can
		BaseMap.rgb = lerp( BaseMap.rgb, Layer2Map, LayerMap1Map.g ); //        use a texture lookup blend quite easily, especially since the 
		BaseMap.rgb = lerp( BaseMap.rgb, Layer3Map, LayerMap1Map.b ); //        Layer2Map has both the G and A channels free.
		BaseMap.rgb = lerp( BaseMap.rgb, Layer4Map, LayerMap2Map.r );
		BaseMap.rgb = lerp( BaseMap.rgb, Layer5Map, LayerMap2Map.g );
		
		BaseMap.rgb *= IN.Diffuse; // Multiply colour by diffuse to get shading!
		
		return BaseMap;
	}
	
//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique TextureBlend
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_TextureBlend();
			pixelShader			= compile ps_2_0 PS_TextureBlend();
		}
	}