Evolved Flashlight + Normalmapping Shader

Author

Message

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 3rd Sep 2012 23:41 Edited at: 3rd Sep 2012 23:42

Link

Hello,
currently i'm porting evolveds DBPro material import of his material edtor to DarkDGK.

http://www.evolved-software.com/materialeditor/materialeditor

But i've got a problem for my project.
If i load up the map with normal mapping shaders, i can't use his flashlight shader :/

Is anybody here who can write HLSL Shader and could combine this 2 shaders?
Would be really great, i've allready tried it, but the object just gets invisible.

NormalMapping.fx:

//====================================================
// NormalMapping
//====================================================
// By EVOLVED
// [URL]www.evolved-software.com[/URL]
//====================================================

//--------------
// un-tweaks
//--------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;    
   matrix ViewInv:ViewInverse; 
   matrix WorldInv:WorldInverse;

//--------------
// tweaks
//--------------
   float3 Ambient={0.1f,0.1f,0.1f};  
   float3 LightPosition={150.0f,150.0f,0.0f};    
   float3 LightColor={1.0f,1.0f,1.0f};    
   float LightRange=200.0f;         
   float4 FogColor={0.8f,0.8f,0.8f,1.0f};
   float FogRange=2500.0f;
   float Alpha=1.0f;

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX <string Name="";>;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture NormalizerTX <string Name = "";>;
   samplerCUBE Normalizer  = sampler_state 
    {
	Texture = <NormalizerTX>;
 	ADDRESSU =  Clamp;
	ADDRESSV =  Clamp;
    };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD; 
	float3 Normal:NORMAL;
 	float3 Tangent:TANGENT;
 	float3 Binormal:BINORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 Tex:TEXCOORD0; 
  	float3 LightVec:TEXCOORD1; 
	float3 Attenuation:TEXCOORD2;
	float3 ViewVec:TEXCOORD3; 
	float Fog:FOG;
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={-IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-(LightPos/LightRange); 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	OUT.Fog=1-saturate(dot(ViewPos/FogRange,ViewPos/FogRange));
	return OUT;
     }

//--------------
// pixel shader
//--------------
   float4 PS(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	float3 LightV=texCUBE(Normalizer,IN.LightVec)*2-1;  	
	float3 View=texCUBE(Normalizer,IN.ViewVec)*2-1;
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=Normal*Normal; Normal=Normal*Normal; Normal=Normal*Normal; 
	Normal=Normal+saturate(dot(NormalMap,LightV)); 
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor;
	return float4(Texture*((Normal*Light)+Ambient),Texture.w*Alpha);
     }

//--------------
// techniques   
//--------------
   technique NormalMapping
      {
 	pass p1
      {		
 	vertexShader = compile vs_1_1 VS(); 
 	pixelShader  = compile ps_1_4 PS();
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;	
      }
      }

+ Code Snippet

//====================================================
// NormalMapping
//====================================================
// By EVOLVED
// [URL]www.evolved-software.com[/URL]
//====================================================

//--------------
// un-tweaks
//--------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;    
   matrix ViewInv:ViewInverse; 
   matrix WorldInv:WorldInverse;

//--------------
// tweaks
//--------------
   float3 Ambient={0.1f,0.1f,0.1f};  
   float3 LightPosition={150.0f,150.0f,0.0f};    
   float3 LightColor={1.0f,1.0f,1.0f};    
   float LightRange=200.0f;         
   float4 FogColor={0.8f,0.8f,0.8f,1.0f};
   float FogRange=2500.0f;
   float Alpha=1.0f;

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX <string Name="";>;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture NormalizerTX <string Name = "";>;
   samplerCUBE Normalizer  = sampler_state 
    {
	Texture = <NormalizerTX>;
 	ADDRESSU =  Clamp;
	ADDRESSV =  Clamp;
    };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD; 
	float3 Normal:NORMAL;
 	float3 Tangent:TANGENT;
 	float3 Binormal:BINORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 Tex:TEXCOORD0; 
  	float3 LightVec:TEXCOORD1; 
	float3 Attenuation:TEXCOORD2;
	float3 ViewVec:TEXCOORD3; 
	float Fog:FOG;
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={-IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-(LightPos/LightRange); 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	OUT.Fog=1-saturate(dot(ViewPos/FogRange,ViewPos/FogRange));
	return OUT;
     }

//--------------
// pixel shader
//--------------
   float4 PS(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	float3 LightV=texCUBE(Normalizer,IN.LightVec)*2-1;  	
	float3 View=texCUBE(Normalizer,IN.ViewVec)*2-1;
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=Normal*Normal; Normal=Normal*Normal; Normal=Normal*Normal; 
	Normal=Normal+saturate(dot(NormalMap,LightV)); 
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor;
	return float4(Texture*((Normal*Light)+Ambient),Texture.w*Alpha);
     }

//--------------
// techniques   
//--------------
   technique NormalMapping
      {
 	pass p1
      {		
 	vertexShader = compile vs_1_1 VS(); 
 	pixelShader  = compile ps_1_4 PS();
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;	
      }
      }

Flashlight.fx:

//====================================================
// Flash Light
//====================================================
// By EVOLVED
// [URL]www.evolved-software.com[/URL]
//====================================================

//--------------
// un-tweaks
//--------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;    
   matrix ViewInv:ViewInverse; 
   matrix ViewMat={0.5,0,0,0.5,0,-0.5,0,0.5,0,0,0.5,0.5,0,0,0,1};

//--------------
// tweaks
//--------------
   float4 LightPosition={150.0f, 150.0f, 0.0f, 1.0f};    
   float LightRange=1000.0f;      
   float BrightNess=1.0f;
   matrix LightProjMatrix;
   float3 LightPosition_1={0.0f, 50.0f, 0.0f};    
   float3 LightColor_1={1.0f, 1.0f, 1.0f};    
   float  LightRange_1=55.0f;    
   float3 LightPosition_2={50.0f, 50.0f, 0.0f}; 
   float3 LightColor_2={1.0f, 0.0f, 0.0f};    
   float  LightRange_2=55.0f; 
   float3 LightPosition_3={100.0f, 50.0f, 0.0f};     
   float3 LightColor_3={0.0f, 1.0f, 0.0f};    
   float  LightRange_3=55.0f; 
   float3 LightPosition_4={150.0f, 50.0f, 0.0f};       
   float3 LightColor_4={0.0f, 0.0f, 1.0f};    
   float  LightRange_4=55.0f;    
   float3 LightPosition_5={0.0f, 50.0f, 50.0f};    
   float3 LightColor_5={1.0f, 1.0f, 1.0f};    
   float  LightRange_5=55.0f;    
   float3 LightPosition_6={50.0f, 50.0f, 50.0f}; 
   float3 LightColor_6={1.0f, 0.0f, 0.0f};    
   float  LightRange_6=55.0f;   
   float4 FogColor={0.4f, 0.36f, 0.3f, 1.0f};
   float FogRange=4000.0f;
   float Alpha=0.0f;

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler Base = sampler_state 
      {
     	texture = <BaseTX>;
      };
   texture LightmapTX <string Name="";>;	
   sampler Lightmap = sampler_state 
      {
 	texture = <LightmapTX>;
      };
   texture ProjetLightTX <string Name = "";>;
   sampler ProjetLight = sampler_state
      {
	Texture = <ProjetLightTX>;
	AddressU=Border;
	AddressV=Border;
	AddressW=Border;
	MagFilter=Linear;	
	MinFilter=Point;
	MipFilter=None;A
      };

//--------------
// structs 
//--------------
   struct Finput
     {
 	float4 Pos:POSITION; 
 	float2 UVA:TEXCOORD0; 
 	float2 UVB:TEXCOORD1; 
	float3 Normal:NORMAL;
     };
   struct Foutput
     {
	float4 OPos:POSITION; 
 	float2 TexA:TEXCOORD0;
   	float2 TexB:TEXCOORD1;
	float3 Attenuation:TEXCOORD2;
	float  Diffuse:TEXCOORD3;
    	float4 Proj:TEXCOORD4;
	float Fog:FOG;
     };
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UVA:TEXCOORD0; 
	float3 Normal:NORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 TexA:TEXCOORD0;  
	float3 Attenuation:TEXCOORD1;
	float Diffuse:TEXCOORD2;
     };
   struct output0
     {
	float4 OPos:POSITION; 
 	float2 TexA:TEXCOORD0;
	float3 Attenuation:TEXCOORD1;
	float Diffuse:TEXCOORD2;
	float3 Attenuation0:TEXCOORD3;
	float Diffuse0:TEXCOORD4;
     };

//--------------
// vertex shader
//--------------
   Foutput VS(Finput IN) 
     {
 	Foutput OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	OUT.TexB=IN.UVB;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition-WPos; 
	OUT.Attenuation=-LightPos/LightRange;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
       	OUT.Proj=mul(ViewMat,mul(float4(LightPos,1),LightProjMatrix));
	float3 ViewPos=ViewInv[3].xyz-WPos;
 	OUT.Fog=1-saturate(dot(ViewPos/FogRange,ViewPos/FogRange));
	return OUT;
     }
   output VS_L1(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_1-WPos; 
	OUT.Attenuation=-LightPos/LightRange_1;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output0 VS_L2(input IN) 
     {
 	output0 OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_1-WPos; 
	OUT.Attenuation=-LightPos/LightRange_1;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	LightPos=LightPosition_2-WPos; 
	OUT.Attenuation0=-LightPos/LightRange_2;
 	OUT.Diffuse0=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output VS_L3(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_3-WPos; 
	OUT.Attenuation=-LightPos/LightRange_3;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output0 VS_L4(input IN) 
     {
 	output0 OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_3-WPos; 
	OUT.Attenuation=-LightPos/LightRange_3;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	LightPos=LightPosition_4-WPos; 
	OUT.Attenuation0=-LightPos/LightRange_4;
 	OUT.Diffuse0=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output VS_L5(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_5-WPos; 
	OUT.Attenuation=-LightPos/LightRange_5;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output0 VS_L6(input IN) 
     {
 	output0 OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_5-WPos; 
	OUT.Attenuation=-LightPos/LightRange_5;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	LightPos=LightPosition_6-WPos; 
	OUT.Attenuation0=-LightPos/LightRange_6;
 	OUT.Diffuse0=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }

//--------------
// pixel shader
//--------------
    float4 PS(Foutput IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
 	float3 LightM=tex2D(Lightmap,IN.TexB);
        LightM +=LightM;
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	PixelLight=(PixelLight*IN.Diffuse)*BrightNess;
 	float3 FlashLight=tex2Dproj(ProjetLight,IN.Proj)*PixelLight;
	return float4(Texture*(LightM+FlashLight),Texture.w*Alpha);
     }
    float4 PS_L1(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_1*IN.Diffuse;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L2(output0 IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_1*IN.Diffuse;
	PixelLight=1-saturate(dot(IN.Attenuation0,IN.Attenuation0));
	Light=Light+PixelLight*LightColor_2*IN.Diffuse0;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L3(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA); 
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_3*IN.Diffuse;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L4(output0 IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_3*IN.Diffuse;
	PixelLight=1-saturate(dot(IN.Attenuation0,IN.Attenuation0));
	Light=Light+PixelLight*LightColor_4*IN.Diffuse0;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L5(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA); 
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_5*IN.Diffuse;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L6(output0 IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_5*IN.Diffuse;
	PixelLight=1-saturate(dot(IN.Attenuation0,IN.Attenuation0));
	Light=Light+PixelLight*LightColor_6*IN.Diffuse0;
	return float4(Texture*Light,Texture.w*Alpha);
     }

//--------------
// techniques   
//--------------
   technique Light0
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
      }
   technique Light1
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One; 	
      }
      }
   technique Light2
      {
 	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;	
      }
      }
   technique Light3
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS();
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;	 	
      }
	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light4
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 	
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
  technique Light5
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 	
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light6
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 	
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L6(); 
 	pixelShader  = compile ps_2_0 PS_L6();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }

+ Code Snippet

//====================================================
// Flash Light
//====================================================
// By EVOLVED
// [URL]www.evolved-software.com[/URL]
//====================================================

//--------------
// un-tweaks
//--------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;    
   matrix ViewInv:ViewInverse; 
   matrix ViewMat={0.5,0,0,0.5,0,-0.5,0,0.5,0,0,0.5,0.5,0,0,0,1};

//--------------
// tweaks
//--------------
   float4 LightPosition={150.0f, 150.0f, 0.0f, 1.0f};    
   float LightRange=1000.0f;      
   float BrightNess=1.0f;
   matrix LightProjMatrix;
   float3 LightPosition_1={0.0f, 50.0f, 0.0f};    
   float3 LightColor_1={1.0f, 1.0f, 1.0f};    
   float  LightRange_1=55.0f;    
   float3 LightPosition_2={50.0f, 50.0f, 0.0f}; 
   float3 LightColor_2={1.0f, 0.0f, 0.0f};    
   float  LightRange_2=55.0f; 
   float3 LightPosition_3={100.0f, 50.0f, 0.0f};     
   float3 LightColor_3={0.0f, 1.0f, 0.0f};    
   float  LightRange_3=55.0f; 
   float3 LightPosition_4={150.0f, 50.0f, 0.0f};       
   float3 LightColor_4={0.0f, 0.0f, 1.0f};    
   float  LightRange_4=55.0f;    
   float3 LightPosition_5={0.0f, 50.0f, 50.0f};    
   float3 LightColor_5={1.0f, 1.0f, 1.0f};    
   float  LightRange_5=55.0f;    
   float3 LightPosition_6={50.0f, 50.0f, 50.0f}; 
   float3 LightColor_6={1.0f, 0.0f, 0.0f};    
   float  LightRange_6=55.0f;   
   float4 FogColor={0.4f, 0.36f, 0.3f, 1.0f};
   float FogRange=4000.0f;
   float Alpha=0.0f;

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler Base = sampler_state 
      {
     	texture = <BaseTX>;
      };
   texture LightmapTX <string Name="";>;	
   sampler Lightmap = sampler_state 
      {
 	texture = <LightmapTX>;
      };
   texture ProjetLightTX <string Name = "";>;
   sampler ProjetLight = sampler_state
      {
	Texture = <ProjetLightTX>;
	AddressU=Border;
	AddressV=Border;
	AddressW=Border;
	MagFilter=Linear;	
	MinFilter=Point;
	MipFilter=None;A
      };

//--------------
// structs 
//--------------
   struct Finput
     {
 	float4 Pos:POSITION; 
 	float2 UVA:TEXCOORD0; 
 	float2 UVB:TEXCOORD1; 
	float3 Normal:NORMAL;
     };
   struct Foutput
     {
	float4 OPos:POSITION; 
 	float2 TexA:TEXCOORD0;
   	float2 TexB:TEXCOORD1;
	float3 Attenuation:TEXCOORD2;
	float  Diffuse:TEXCOORD3;
    	float4 Proj:TEXCOORD4;
	float Fog:FOG;
     };
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UVA:TEXCOORD0; 
	float3 Normal:NORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 TexA:TEXCOORD0;  
	float3 Attenuation:TEXCOORD1;
	float Diffuse:TEXCOORD2;
     };
   struct output0
     {
	float4 OPos:POSITION; 
 	float2 TexA:TEXCOORD0;
	float3 Attenuation:TEXCOORD1;
	float Diffuse:TEXCOORD2;
	float3 Attenuation0:TEXCOORD3;
	float Diffuse0:TEXCOORD4;
     };

//--------------
// vertex shader
//--------------
   Foutput VS(Finput IN) 
     {
 	Foutput OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	OUT.TexB=IN.UVB;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition-WPos; 
	OUT.Attenuation=-LightPos/LightRange;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
       	OUT.Proj=mul(ViewMat,mul(float4(LightPos,1),LightProjMatrix));
	float3 ViewPos=ViewInv[3].xyz-WPos;
 	OUT.Fog=1-saturate(dot(ViewPos/FogRange,ViewPos/FogRange));
	return OUT;
     }
   output VS_L1(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_1-WPos; 
	OUT.Attenuation=-LightPos/LightRange_1;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output0 VS_L2(input IN) 
     {
 	output0 OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_1-WPos; 
	OUT.Attenuation=-LightPos/LightRange_1;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	LightPos=LightPosition_2-WPos; 
	OUT.Attenuation0=-LightPos/LightRange_2;
 	OUT.Diffuse0=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output VS_L3(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_3-WPos; 
	OUT.Attenuation=-LightPos/LightRange_3;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output0 VS_L4(input IN) 
     {
 	output0 OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_3-WPos; 
	OUT.Attenuation=-LightPos/LightRange_3;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	LightPos=LightPosition_4-WPos; 
	OUT.Attenuation0=-LightPos/LightRange_4;
 	OUT.Diffuse0=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output VS_L5(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_5-WPos; 
	OUT.Attenuation=-LightPos/LightRange_5;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }
   output0 VS_L6(input IN) 
     {
 	output0 OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.TexA=IN.UVA;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  
	float3 LightPos=LightPosition_5-WPos; 
	OUT.Attenuation=-LightPos/LightRange_5;
 	OUT.Diffuse=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	LightPos=LightPosition_6-WPos; 
	OUT.Attenuation0=-LightPos/LightRange_6;
 	OUT.Diffuse0=saturate(0.05f+mul(Wnor,LightPos)*0.05f); 
	return OUT;
     }

//--------------
// pixel shader
//--------------
    float4 PS(Foutput IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
 	float3 LightM=tex2D(Lightmap,IN.TexB);
        LightM +=LightM;
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	PixelLight=(PixelLight*IN.Diffuse)*BrightNess;
 	float3 FlashLight=tex2Dproj(ProjetLight,IN.Proj)*PixelLight;
	return float4(Texture*(LightM+FlashLight),Texture.w*Alpha);
     }
    float4 PS_L1(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_1*IN.Diffuse;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L2(output0 IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_1*IN.Diffuse;
	PixelLight=1-saturate(dot(IN.Attenuation0,IN.Attenuation0));
	Light=Light+PixelLight*LightColor_2*IN.Diffuse0;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L3(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA); 
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_3*IN.Diffuse;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L4(output0 IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_3*IN.Diffuse;
	PixelLight=1-saturate(dot(IN.Attenuation0,IN.Attenuation0));
	Light=Light+PixelLight*LightColor_4*IN.Diffuse0;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L5(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA); 
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_5*IN.Diffuse;
	return float4(Texture*Light,Texture.w*Alpha);
     }
    float4 PS_L6(output0 IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.TexA);
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_5*IN.Diffuse;
	PixelLight=1-saturate(dot(IN.Attenuation0,IN.Attenuation0));
	Light=Light+PixelLight*LightColor_6*IN.Diffuse0;
	return float4(Texture*Light,Texture.w*Alpha);
     }

//--------------
// techniques   
//--------------
   technique Light0
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
      }
   technique Light1
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One; 	
      }
      }
   technique Light2
      {
 	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;	
      }
      }
   technique Light3
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS();
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;	 	
      }
	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light4
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 	
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
  technique Light5
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 	
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light6
      {
  	pass p0
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	FOGCOLOR=(FogColor); 
	FOGENABLE=TRUE;		
      }
	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2(); 	
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L6(); 
 	pixelShader  = compile ps_2_0 PS_L6();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 4th Sep 2012 18:21

Link

Evolved has a multi-light normal mapping fx. It can handle 6 lights and 1 flashlight. You can modify the code to handle as many lights as you want, but if you go too high, it will be slow. Most of the time I only use 2 or 3 lights at a time and it works great.

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 5th Sep 2012 16:56

Link

Where? Can you send me a link?

Would be awesome!

(i'm only using 4 lights + flashlight), but i need that in combination with normal mapping, thats the problem

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 5th Sep 2012 16:59

Link

http://www.evolved-software.com/shaders/bumpmapping

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 5th Sep 2012 17:03

Link

If i want to use the flashlight shader, i have to add the flashlight shader to a surface.
If i do that, i can't use the normal mapping shader on the same surface.

Or did i misunderstand something?

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 5th Sep 2012 18:37

Link

//====================================================
// Normal Mapping 2.0
//====================================================
// By EVOLVED
// www.evolved-software.com
//====================================================

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

//--------------
// un-tweaks
//--------------
   float3 Ambient={0.0f,0.0f,0.0f};    
   float3 LightPosition_1={0.0f,50.0f,0.0f};    
   float3 LightColor_1={1.0f,1.0f,1.0f};    
   float LightRange_1=55.0f;    
   float3 LightPosition_2={50.0f,50.0f,0.0f}; 
   float3 LightColor_2={1.0f,0.0f,0.0f};    
   float LightRange_2=55.0f; 
   float3 LightPosition_3= {100.0f,50.0f,0.0f};     
   float3 LightColor_3={0.0f,1.0f,0.0f};    
   float LightRange_3=55.0f; 
   float3 LightPosition_4={150.0f,50.0f,0.0f};       
   float3 LightColor_4={0.0f,0.0f,1.0f};    
   float LightRange_4=55.0f;    
   float3 LightPosition_5={0.0f,50.0f,50.0f};    
   float3 LightColor_5={1.0f,1.0f,1.0f};    
   float LightRange_5=55.0f;    
   float3 LightPosition_6={50.0f,50.0f,50.0f}; 
   float3 LightColor_6={1.0f,0.0f,0.0f};    
   float LightRange_6=55.0f;  
   float3 FLightPosition={150.0f,150.0f,0.0f};      
   float FLightRange=1000.0f;
   float3x3 FLightAngle;  
   float BrightNess=1.0f;
   float SpecularPow=16.0f; 
   float Alpha=0.5f;
  	
//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX <string Name="";>;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture CubeLightTX  <string Name = "";>;
   sampler CubeLight = sampler_state
      {
	Texture = <CubeLightTX>;
      };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD; 
	float3 Normal:NORMAL;
 	float3 Tangent:TANGENT;
 	float3 Binormal:BINORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 Tex:TEXCOORD0; 
  	float3 LightVec:TEXCOORD1; 
	float3 Attenuation:TEXCOORD2;
	float3 ViewVec:TEXCOORD3; 
	float3 CubeLight:TEXCOORD4; 
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	OUT.LightVec=0;
	OUT.Attenuation=0; 
 	OUT.ViewVec=0; 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L1(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_1-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_1; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0; 
	return OUT;
     }
   output VS_L2(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_2-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_2; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0; 
	return OUT;
     }
   output VS_L3(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_3-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_3; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L4(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_4-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_4; 
 	OUT.ViewVec=mul(ViewPos,TBN);
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L5(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_5-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_5; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L6(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_6-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_6; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_FL(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=FLightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/FLightRange; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	OUT.CubeLight=mul(FLightAngle,-LightPos); 
	return OUT;
     }

//--------------
// pixel shader
//--------------
   float4 PS(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	return float4(Texture*Ambient,Alpha);
     }
   float4 PS_L1(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_1;
	return float4(Texture*((Normal*Light)+Ambient),Alpha);
     }
   float4 PS_L2(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_2;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L3(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_3;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L4(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_4;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L5(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_5;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L6(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_6;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_FL(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*texCUBE(CubeLight,IN.CubeLight)*BrightNess;
	return float4(Texture*(Normal*Light),Alpha);
     }

//--------------
// techniques   
//--------------
   technique Ambient
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 	
      }
      }
   technique Light1
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
      }
   technique Light2
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light3
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light4
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light5
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light6
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p6
      {		
 	vertexShader = compile vs_2_0 VS_L6(); 
 	pixelShader  = compile ps_2_0 PS_L6();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Ambient_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 	
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
  technique Light1_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light2_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light3_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light4_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light5_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light6_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p6
      {		
 	vertexShader = compile vs_2_0 VS_L6(); 
 	pixelShader  = compile ps_2_0 PS_L6();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }

+ Code Snippet

//====================================================
// Normal Mapping 2.0
//====================================================
// By EVOLVED
// www.evolved-software.com
//====================================================

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

//--------------
// un-tweaks
//--------------
   float3 Ambient={0.0f,0.0f,0.0f};    
   float3 LightPosition_1={0.0f,50.0f,0.0f};    
   float3 LightColor_1={1.0f,1.0f,1.0f};    
   float LightRange_1=55.0f;    
   float3 LightPosition_2={50.0f,50.0f,0.0f}; 
   float3 LightColor_2={1.0f,0.0f,0.0f};    
   float LightRange_2=55.0f; 
   float3 LightPosition_3= {100.0f,50.0f,0.0f};     
   float3 LightColor_3={0.0f,1.0f,0.0f};    
   float LightRange_3=55.0f; 
   float3 LightPosition_4={150.0f,50.0f,0.0f};       
   float3 LightColor_4={0.0f,0.0f,1.0f};    
   float LightRange_4=55.0f;    
   float3 LightPosition_5={0.0f,50.0f,50.0f};    
   float3 LightColor_5={1.0f,1.0f,1.0f};    
   float LightRange_5=55.0f;    
   float3 LightPosition_6={50.0f,50.0f,50.0f}; 
   float3 LightColor_6={1.0f,0.0f,0.0f};    
   float LightRange_6=55.0f;  
   float3 FLightPosition={150.0f,150.0f,0.0f};      
   float FLightRange=1000.0f;
   float3x3 FLightAngle;  
   float BrightNess=1.0f;
   float SpecularPow=16.0f; 
   float Alpha=0.5f;
  	
//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX <string Name="";>;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture CubeLightTX  <string Name = "";>;
   sampler CubeLight = sampler_state
      {
	Texture = <CubeLightTX>;
      };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD; 
	float3 Normal:NORMAL;
 	float3 Tangent:TANGENT;
 	float3 Binormal:BINORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 Tex:TEXCOORD0; 
  	float3 LightVec:TEXCOORD1; 
	float3 Attenuation:TEXCOORD2;
	float3 ViewVec:TEXCOORD3; 
	float3 CubeLight:TEXCOORD4; 
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	OUT.LightVec=0;
	OUT.Attenuation=0; 
 	OUT.ViewVec=0; 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L1(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_1-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_1; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0; 
	return OUT;
     }
   output VS_L2(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_2-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_2; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0; 
	return OUT;
     }
   output VS_L3(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_3-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_3; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L4(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_4-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_4; 
 	OUT.ViewVec=mul(ViewPos,TBN);
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L5(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_5-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_5; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_L6(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=LightPosition_6-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_6; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
 	OUT.CubeLight=0;
	return OUT;
     }
   output VS_FL(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World); 
	float3 LightPos=FLightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/FLightRange; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	OUT.CubeLight=mul(FLightAngle,-LightPos); 
	return OUT;
     }

//--------------
// pixel shader
//--------------
   float4 PS(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	return float4(Texture*Ambient,Alpha);
     }
   float4 PS_L1(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_1;
	return float4(Texture*((Normal*Light)+Ambient),Alpha);
     }
   float4 PS_L2(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_2;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L3(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_3;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L4(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_4;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L5(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_5;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_L6(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*LightColor_6;
	return float4(Texture*(Normal*Light),Alpha);
     }
   float4 PS_FL(output IN)  : COLOR
     {
	float3 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(reflect(-View,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV));
	float PixelLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float3 Light=PixelLight*texCUBE(CubeLight,IN.CubeLight)*BrightNess;
	return float4(Texture*(Normal*Light),Alpha);
     }

//--------------
// techniques   
//--------------
   technique Ambient
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 	
      }
      }
   technique Light1
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
      }
   technique Light2
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light3
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light4
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light5
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light6
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p6
      {		
 	vertexShader = compile vs_2_0 VS_L6(); 
 	pixelShader  = compile ps_2_0 PS_L6();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Ambient_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 	
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
  technique Light1_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light2_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light3_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light4_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light5_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }
   technique Light6_FL
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
 	pass p2
      {		
 	vertexShader = compile vs_2_0 VS_L2(); 
 	pixelShader  = compile ps_2_0 PS_L2();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p3
      {		
 	vertexShader = compile vs_2_0 VS_L3(); 
 	pixelShader  = compile ps_2_0 PS_L3();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p4
      {		
 	vertexShader = compile vs_2_0 VS_L4(); 
 	pixelShader  = compile ps_2_0 PS_L4();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p5
      {		
 	vertexShader = compile vs_2_0 VS_L5(); 
 	pixelShader  = compile ps_2_0 PS_L5();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass p6
      {		
 	vertexShader = compile vs_2_0 VS_L6(); 
 	pixelShader  = compile ps_2_0 PS_L6();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
 	pass pFL
      {		
 	vertexShader = compile vs_2_0 VS_FL(); 
 	pixelShader  = compile ps_2_0 PS_FL();
	AlphaBlendEnable = True;
 	SrcBlend = One;
 	DestBlend = One;
      }
      }

There are 6 point lights and 1 flashlight possible with the way it's written. Take a look at the code. You don't need anything more than this unless you want more lights. In your game, you will have to specify the light positions for the point lights and the flashlight. I've never used the flashlight portion of this, but from the code it looks like it just points straight out from the camera in the direction the camera is looking. I assume you know how to use an fx. If not, let me know, and I'll try to explain.

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 5th Sep 2012 19:09

Link

Ahhh i got the old NM Shader, that's 2.0 with the flashlight included!
Alright, thank you very much!

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 5th Sep 2012 19:48

Link

No problem. Remember, you can cut down the number of lights or make more passes to accomodate more lights.

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 6th Sep 2012 15:43 Edited at: 6th Sep 2012 16:58

Link

Hm wierd, on the site is just the old shader, and your posted shader code doesn't work :/

e/ Well, it is working, but reall weird. Is there an example for the 2.0 flashlight shader?

Edit2: Ah okay, it's working different now.

new one:
float3 FLightPosition={150.0f,150.0f,0.0f};
float FLightRange=1000.0f;
float3x3 FLightAngle;

old one:
matrix LightProjMatrix;

edit3: No Clue how to use it. How do i pass a float3x3?

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 6th Sep 2012 17:56

Link

Not sure, never used the FL. Did you try changing it to a matrix and sending FLightAngle as a matrix?

Quote: "void dbSetEffectConstantMatrix ( int effectID, string constantName, Matrix4* matrix4 )
"

This is the command in 2.0, but I think it's similar to the one in 1.0.... The "Matrix4" is a 2.0 structure, so 1.0 will have an integer as a reference number refering to a db matrix type. I hope someone with 1.0 is reading this so they can help out. I completely got rid of 1.0 when I converted to 2.0.

It's possible the float3x3 is synonimous with a matrix because a rotation matrix only used 3x3 of the 4x4 in a normal matrix.... What's the worst that could happen? You try to use it as a matrix and your computer bursts into flames, causing a massive fire that destroys your neighborhood.....

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 6th Sep 2012 18:33

Link

NormalMaps + Lights is working.
But the Flashlight isn't :<
Tried it with a matrix, doesn't work.

Could you try it? Would be really great.
Here you'll get Flashlight 1
http://www.evolved-software.com/shaders/lighting

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 6th Sep 2012 22:01

Link

I don't even have 1.0. It wouldn't help you if I did and it was successful......
Looked at what you sent me. You're not useing what I sent you. You're using another .fx. I've never used the one you sent the link to.
DBP adds some of the .fx parameters for you, but I don't know if it adds the view matrix as a rotation matrix. To be safe, send each of these parameters each frame:

Quote: " matrix WorldVP:WorldViewProjection;
matrix World:World;
matrix ViewInv:ViewInverse;
matrix ViewMat={0.5,0,0,0.5,0,-0.5,0,0.5,0,0,0.5,0.5,0,0,0,1};
"

I'm pretty sure DBP sends the "WorldViewProjection" each frame, but I am not sure it sends the "ViewInverse" or the "World" (which may actually be set to "identity" if sent). So you will have to at least send the "ViewInverse" to make the flashlight work. It won't hurt to send them all (except the "World") once per frame. The "World" matrix is used for each of the objects in the scene, so I'm certain it is sent by DBP regardless. The "ViewMat" is the View Matrix and I'm sure it's sent as well. I would start out by sending all but the "World" first and cut them down from there. I hope it works, because I don't have 1.0 and I have stopped using 2.0 also in favor of pure DX/C++. I have used Evolved's "Multipass Lighting" fx with DX/C++ and it works, but I discovered what I described earlier, that DBP sends info to an fx automatically, but it may not send all the info an fx needs for something like the flashlight. If it sounds like I'm rambling, I'm sorry. I've been "out with the guys" if you know what I mean, and I'm not even sure of what I'm typing.....

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 7th Sep 2012 06:48 Edited at: 7th Sep 2012 06:50

Link

I linked you the old flashlight example to show you how the old one worked. I'm using the FX you posted above. (Normal Mapping 2.0, not the old Flashlight)

Well, i'm doing it like this atm:

+ Code Snippet

	dbSetEffectConstantFloat(Shader_ID,"BrightNess",Brightness);

	//Move Flash Light to camera pos / Rotate cubic light
	if(Brightness>0.0)
	{
		dbSetVector4(1,dbCameraPositionX()-10,dbCameraPositionY()-10,dbCameraPositionZ()-10);
		dbSetEffectConstantVector(Shader_ID,"FLightPosition",1);
		angX=dbCurveAngle(dbCameraAngleX(),angX,4);
		angY=dbCurveAngle(dbCameraAngleY(),angY,4);
        dbRotateXMatrix4(3,(angX)/57.3);
        dbRotateYMatrix4(4,(angY)/57.3);
		dbMultiplyMatrix4(3,3,4);
		dbSetVector3(2,0,0,1);
		dbTransformNormalsVector3(2,2,3);
		dbSetVector3(5,0,0,0);
		dbSetVector3(6,dbXVector3(2),dbYVector3(2),dbZVector3(2));
		dbSetVector3(7,0,1,0);
		dbBuildLookAtLHMatrix4(3,5,6,7);
		dbBuildFovLHMatrix4(4,1,1,1,5000);
		dbMultiplyMatrix4(3,3,4);
		dbSetEffectConstantMatrix(Shader_ID,"FLightAngle",3);

but it doesn't work.
I don't know how to send that "ViewInverse", i don't even know what that is

Sorry.

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 7th Sep 2012 12:10

Link

Sorry. I don't have 1.0 with me and downloading from where I am would take a few days. Yea, the internet here is SLOOOOOOOW. Look through the documentation for something like "view matrix". You should find a command that will copy the info from DX's view matrix for the camera to a DBP matrix4 (the math "matrix" not the terrain "matrix"). There should also be something like dbInverseMatrix4(..) in the docs as well, so search for that.

There's no reason to use

Quote: "dbSetVector4(1,dbCameraPositionX()-10,dbCameraPositionY()-10,dbCameraPositionZ()-10);"

with -10 on each of the position values. Just take out the -10.
I'm assuming that this part:

+ Code Snippet

 		angX=dbCurveAngle(dbCameraAngleX(),angX,4);
		angY=dbCurveAngle(dbCameraAngleY(),angY,4);
        dbRotateXMatrix4(3,(angX)/57.3);
        dbRotateYMatrix4(4,(angY)/57.3);
		dbMultiplyMatrix4(3,3,4);
		dbSetVector3(2,0,0,1);
		dbTransformNormalsVector3(2,2,3);
		dbSetVector3(5,0,0,0);
		dbSetVector3(6,dbXVector3(2),dbYVector3(2),dbZVector3(2));
		dbSetVector3(7,0,1,0);
		dbBuildLookAtLHMatrix4(3,5,6,7);
		dbBuildFovLHMatrix4(4,1,1,1,5000);
		dbMultiplyMatrix4(3,3,4);

is to get the angle for the flashlight..... Right? You should be able to take out all of this if you find the "dbGetViewMatrix" (or whatever the command is. I don't think you will have to use the inverse matrix because, as I mentioned earlier, DBP fills in most of the info for you. I only mentioned it because I wasn't sure if it did. I think if you send the view matrix to "FLightAngle", it will work.

Another way to test the flashlight is to put it at a static position and make an identity matrix to put into "FLightAngle". Be sure that a wall is directly behind the flashlight's position (in the +Z direction) because the default "direction" for an identity matrix is looking directly down the Z axis in the positive direction. Go ahead and set the brightness for your flashlight to something you are sure to see.

One more thing. You are setting "dbSetEffectTechnique(..)" to something with "FL" in it like "Ambient_FL" or "Light1_FL", right? If you don't set the technique, it will default to the first one in the list.

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 7th Sep 2012 12:59 Edited at: 7th Sep 2012 13:09

Link

Okay, "dbSetEffectTechnique(..)" fixed the Problem, had forgotten this

fixed the Angle with ViewMatrix & InverseMatrix.

Dude, thank you sooooo much for your help!
Really, thank you

Good job.

edit/ Just one small problem left.
I've got on the edges of the "ViewMatrix" small white lines. Barely to see. You know why?

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 7th Sep 2012 15:53

Link

Quote: "I've got on the edges of the "ViewMatrix" small white lines"

Can you show me? I don't have a clue what you mean.....

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 7th Sep 2012 16:23 Edited at: 7th Sep 2012 16:26

Link

(Click to get the full size)

and here i changed the view, to see it better. The Edges of the (matrix?) are white.

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 8th Sep 2012 02:30

Link

I think I know what this is. It uses cubic lighting and the edges of the image have artifacts. Take a look at the image and make sure it's not .jpg. If it is, make your own and use .png or something better than .jpg for the flashlight image.

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 8th Sep 2012 08:24

Link

Allready checked that, it's not that

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 8th Sep 2012 09:40

Link

Try your flashlight in a completely darkened room. Also, are you using cubic lighting for the rest of it as well?

The fastest code is the code never written.

Back to top

Profile PM Email Website

Gunslinger

17

Years of Service

User Offline

Joined: 29th May 2007

Location:

Posted: 9th Sep 2012 11:12

Link

Think so, yes. Same shader.

Back to top

Profile PM

Hawkblood

14

Years of Service

User Offline

Joined: 5th Dec 2009

Location:

Posted: 10th Sep 2012 16:49

Link

Did you try a completely dark room with 1 flashlight? I am thinking it might be a bleed-over from the other lights.

The fastest code is the code never written.

Back to top

Profile PM Email Website

Sorry your browser is not supported!

Dark GDK / Evolved Flashlight + Normalmapping Shader