asm => hlsl..... projection shader

	texture mtlSkin1;		//projector
	texture entSkin1;    //colormap 
	matrix matWorldViewProj; 
	matrix matWorld;
	matrix matMtl;
	
	technique projector
	{
		
		pass p0 //projector
		{
			
			//load matrices
			//VertexShaderConstant[0] = <matWorld>; 	//World Matrix
			VertexShaderConstant[8] = <matWorldViewProj>;
			VertexShaderConstant[95] = <matMtl>;	
			
			//range constant
			VertexShaderConstant[33] = {0.01f, 0.5f, 0.05f, 0.0f};
			
			Texture[0]  = <mtlSkin1>; //projection tex
			Texture[1]  = <entSkin1>; //projection tex
			
			AddressU[0] = Clamp;  // don't wrap around edges
			AddressV[0] = Clamp;
			AddressU[1] = Clamp;  // don't wrap around edges
			AddressV[1] = Clamp;
			
			zWriteEnable=true; // enables writing to the z-buffer
			
			VertexShader=
			
			asm
			{
				vs_1_1

				dcl_position v0     
				dcl_normal v3       
				dcl_texcoord0 v7    
				dcl_texcoord1 v8  
				
				; position in clip space
				m4x4 oPos, v0, c8
				
				; position in texture projection space
				m4x4 r10,v0,c95
				
				; Divide each component by the range value
				mul r10, r10, c33.x
				
				; multiply with 0.5 and add 0.5
				mad r10, r10, c33.yyyy, c33.yyyy
				
				; map the x and y components into the first texture
				mov oT0.xy, r10.xy
				
				mov oT1.xy, v7.xy;  color
				
			};
			
			PixelShader= 
			asm
			{
				
				ps_1_1
				
				tex t0 
				tex t1
				
				mov r0,t0 
				mul r0,r0,t1	
			};
		}
		
	}

//--------------------------------------------------------------
//                    Texture Projection Shader
//
//                            by zSteam
// -------------------------------------------------------------

float4x4 matWorldViewProj;
float4x4 matMtl;

float4 range = {0.01f, 0.5f, 0.05f, 0.0f};
float tps;

struct VS_OUTPUT
{
	float4 oPos   : POSITION;
	float2 Tex0   : TEXCOORD0;
	float2 Tex1   : TEXCOORD1;
};

VS_OUTPUT mainVS( float4 oPos : POSITION, float2 Tex0 : TEXCOORD0, float2 Tex1 : TEXCOORD1 )
{
	VS_OUTPUT Out = (VS_OUTPUT) 0; 

	Out.oPos = mul(oPos, matWorldViewProj);
				
	tps = mul(oPos, matMtl);
	tps = tps * range.x;
	tps = (tps * range.yyyy) + range.yyyy;
				
	Out.Tex0.xy = tps.xy;
	Out.Tex1.xy = Tex0.xy;

	return Out;
}

texture entSkin1;
texture mtlSkin1;

sampler ColorMapSampler = sampler_state
{
	Texture = <entSkin1>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;   
	AddressU  = Clamp; // don't wrap around edges
	AddressV  = Clamp; // don't wrap around edges
};

sampler ProjTex = sampler_state
{
	Texture = <mtlSkin1>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;   
	AddressU  = Clamp; // don't wrap around edges
	AddressV  = Clamp; // don't wrap around edges
};

float4 mainPS(float2 Tex : TEXCOORD0) : COLOR
{
	Color = ColorMapSampler * ProjTex;
	return Color;
}

technique projector
{
	pass p0
	{
		zWriteEnable=true;
		VertexShader = compile vs_1_1 mainVS();
		PixelShader = compile ps_1_1 mainPS();
	}
}

...
struct VS_OUTPUT
{
	float4 oPos	: POSITION;
	float2 oTex0	: TEXCOORD0;
	float2 oTex1	: TEXCOORD1;
};

VS_OUTPUT mainVS( float4 Pos : POSITION, float2 Tex : TEXCOORD0 )
{
	VS_OUTPUT Out = (VS_OUTPUT) 0; 

	Out.oPos = mul(Pos, matWorldViewProj);
				
	tps = mul(Pos, matMtl);
	tps = tps * range.x;
	tps = (tps * range.yyyy) + range.yyyy;
				
	Out.oTex0.xy = tps.xy;
	Out.oTex1.xy = Tex.xy;

	return Out;
}

...

float4 mainPS(float4 Color: COLOR) : COLOR
{
	Color = ColorMapSampler * ProjTex;
	return Color;
}
...

//--------------------------------------------------------------
//		Texture Projection Shader HLSL
//
//			© by zSteam
//
//		date: 19.10.2007
// -------------------------------------------------------------

float4x4 matWorldViewProj;
float4x4 matMtl;

struct VS_OUTPUT
{
	float4 oPos	: POSITION;
	float2 oTex0	: TEXCOORD0;
	float2 oTex1	: TEXCOORD1;
};

VS_OUTPUT mainVS( float4 Pos : POSITION, float2 Tex : TEXCOORD0 )
{
	float2 tps;

	VS_OUTPUT Out = (VS_OUTPUT) 0; 

	Out.oPos = mul(Pos, matWorldViewProj);
				
	tps = mul(Pos, matMtl) * 0.01f;
	tps = (tps * 0.5f) + 0.5f;

	Out.oTex0.xy = tps.xy;
	Out.oTex1.xy = Tex.xy;

	return Out;
}

texture entSkin1;
texture mtlSkin1;

sampler ColorMapSampler = sampler_state
{
	Texture = <entSkin1>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;   
};

sampler ProjTex = sampler_state
{
	Texture = <mtlSkin1>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;   
	AddressU  = Clamp; // don't wrap around edges
	AddressV  = Clamp; // don't wrap around edges
};

float4 mainPS(float2 Tex0 : TEXCOORD0, float2 Tex1 : TEXCOORD1 ) : COLOR
{
	float4 base = tex2D(ColorMapSampler, Tex1);
	float4 proj = tex2D(ProjTex, Tex0)*4;

	return (base*proj);
}

technique projector
{
	pass p1
	{
		VertexShader = compile vs_1_1 mainVS();
		PixelShader = compile ps_1_1 mainPS();
	}
}

technique fallback { pass one { } }
  

Quote:

---

You named the inputs the same as the outputs, change that.

---