Combining shaders? - GameCreators Forum

Author

Message

TheComet

18

Years of Service

User Offline

Joined: 18th Oct 2007

Location: I`m under ur bridge eating ur goatz.

Posted: 1st Feb 2012 00:32

Link

Hi

So what happens when I want to have a reflective parallax mapped object? To my knowledge I can't apply 2 shaders (parallax and cube mapping) to a single object... How would I combine the two?

What I need is a shader with the following:

Stage 0 - Base texture
Stage 1 - Normal map
Stage 2 - Bump map
Stage 3 - Emissive map
Stage 4 - Specular map
Stage 5 - Alpha map (controls transparency, black = invisible, white = solid)
Stage 6 - optional cube map

This is the shader that needs to be modified (thanks a lot to revenant chaos for adding the emissive map and multiple lights):

//====================================================
// Parallax mapping w/ Emissive
//====================================================
// By EVOLVED - www.evolved-software.com
// Modified By: Revenant_Chaos
//====================================================

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

//--------------
// tweaks
//--------------
   float3 Ambient={0.2f,0.2f,0.2f};
   float3 LightPosition_1={150.0f,150.0f,0.0f};    
   float3 LightColor_1={1.0f,1.0f,1.0f};    
   float LightRange_1=50.0f;
   float3 LightPosition_2={150.0f,150.0f,0.0f};    
   float3 LightColor_2={1.0f,0.0f,0.0f};    
   float LightRange_2=50.0f;    
   float3 LightPosition_3={150.0f,150.0f,0.0f};    
   float3 LightColor_3={0.0f,1.0f,0.0f};    
   float LightRange_3=50.0f;    
   float3 LightPosition_4={150.0f,150.0f,0.0f};    
   float3 LightColor_4={0.0f,0.0f,1.0f};    
   float LightRange_4=50.0f; 
   float3 LightPosition_5={150.0f,150.0f,0.0f};    
   float3 LightColor_5={1.0f,0.0f,1.0f};    
   float LightRange_5=50.0f;    
   float3 LightPosition_6={150.0f,150.0f,0.0f};    
   float3 LightColor_6={0.0f,1.0f,1.0f};    
   float LightRange_6=50.0f; 
   float SpecularPow=32.0f;  
   float Heightvec=0.03;
   float BiasHeight=0.3;
   float Alpha=1.0f;
   float EmissPower = 1.0f;

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX <string Name="";>;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture HeightTX <string Name="";>;	
   sampler2D Height = sampler_state 
    {
 	texture = <HeightTX>;
    };
   texture EmissiveTX <string Name="";>;	
   sampler2D Emiss = sampler_state 
    {
 	texture = <EmissiveTX>;
    };

//--------------
// 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; 
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	OUT.LightVec=0.0f;
	OUT.Attenuation=0.0f; 
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World);
	float3 ViewPos=ViewInv[3].xyz-WPos;
 	OUT.ViewVec=mul(ViewPos,TBN);  
	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);  
	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);  
	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);  
	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);  
	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);  
	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);  
	return OUT;
     }

//--------------
// pixel shader
//--------------
    float4 PS(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 Emissive=tex2D(Emiss,NewUv).xyz;
	return float4((Texture.xyz*Ambient)+(Emissive*EmissPower),Texture.w*Alpha);
     }
    float4 PS_L1(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 Emissive=tex2D(Emiss,NewUv).xyz;
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*((Normal*Light)+Ambient))+(Emissive*EmissPower),Texture.w*Alpha);
     }
    float4 PS_L2(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L3(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L4(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L5(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L6(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*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;
      }
      }

+ Code Snippet

//====================================================
// Parallax mapping w/ Emissive
//====================================================
// By EVOLVED - www.evolved-software.com
// Modified By: Revenant_Chaos
//====================================================

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

//--------------
// tweaks
//--------------
   float3 Ambient={0.2f,0.2f,0.2f};
   float3 LightPosition_1={150.0f,150.0f,0.0f};    
   float3 LightColor_1={1.0f,1.0f,1.0f};    
   float LightRange_1=50.0f;
   float3 LightPosition_2={150.0f,150.0f,0.0f};    
   float3 LightColor_2={1.0f,0.0f,0.0f};    
   float LightRange_2=50.0f;    
   float3 LightPosition_3={150.0f,150.0f,0.0f};    
   float3 LightColor_3={0.0f,1.0f,0.0f};    
   float LightRange_3=50.0f;    
   float3 LightPosition_4={150.0f,150.0f,0.0f};    
   float3 LightColor_4={0.0f,0.0f,1.0f};    
   float LightRange_4=50.0f; 
   float3 LightPosition_5={150.0f,150.0f,0.0f};    
   float3 LightColor_5={1.0f,0.0f,1.0f};    
   float LightRange_5=50.0f;    
   float3 LightPosition_6={150.0f,150.0f,0.0f};    
   float3 LightColor_6={0.0f,1.0f,1.0f};    
   float LightRange_6=50.0f; 
   float SpecularPow=32.0f;  
   float Heightvec=0.03;
   float BiasHeight=0.3;
   float Alpha=1.0f;
   float EmissPower = 1.0f;

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX <string Name="";>;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture HeightTX <string Name="";>;	
   sampler2D Height = sampler_state 
    {
 	texture = <HeightTX>;
    };
   texture EmissiveTX <string Name="";>;	
   sampler2D Emiss = sampler_state 
    {
 	texture = <EmissiveTX>;
    };

//--------------
// 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; 
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
 	OUT.Tex=IN.UV;
	OUT.LightVec=0.0f;
	OUT.Attenuation=0.0f; 
	float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(IN.Pos,World);
	float3 ViewPos=ViewInv[3].xyz-WPos;
 	OUT.ViewVec=mul(ViewPos,TBN);  
	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);  
	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);  
	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);  
	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);  
	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);  
	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);  
	return OUT;
     }

//--------------
// pixel shader
//--------------
    float4 PS(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 Emissive=tex2D(Emiss,NewUv).xyz;
	return float4((Texture.xyz*Ambient)+(Emissive*EmissPower),Texture.w*Alpha);
     }
    float4 PS_L1(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 Emissive=tex2D(Emiss,NewUv).xyz;
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*((Normal*Light)+Ambient))+(Emissive*EmissPower),Texture.w*Alpha);
     }
    float4 PS_L2(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L3(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L4(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L5(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*Alpha);
     }
    float4 PS_L6(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);
	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.xyz*(Normal*Light),Texture.w*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;
      }
      }

Is this doable, or am I asking too much now?

TheComet

Timeplan : https://docs.google.com/spreadsheet/ccc?key=0AmuAKJolqASndEVYOWMxb3l2OWV0UkV1anRSczZScHc

Back to top

Profile PM Email Website

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 00:59

Link

I once coded a Detail map and normal map based shader using two of Evolved's shaders. There is a limit on how many variables you can create in one shader; something like 32 (correct me if I am wrong), so I had to remove some features to fit the normal map FX code in.

Perhaps your requirement is just plain difficult to do in HLSL 2. If someone doesn't know how to do what you want, you may need to use two sets of limbs to blend two effects.

I remember seeing somewhere, somebody rendered an object twice using fast sync and sync mask. I think it was the water shader.

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 02:17

Link

Quote: "How would I combine the two?"

It's just a matter of understanding the code and making the appropriate changes as in any other programming language. I'll try to find time to look at this tomorrow (unless someone else gets there first).

Quote: "I remember seeing somewhere, somebody rendered an object twice using fast sync and sync mask. I think it was the water shader."

That was probably a completely different problem to do with cameras, clipping planes, etc.

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 03:06

Link

Quote: "I'll try to find time to look at this tomorrow (unless someone else gets there first)."

Looking forward to seeing this.

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 13:33

Link

Here's the first draft.

I've changed only the pixel shader for one light as the others can be changed in exactly the same way. You'll need to adjust your "tweaks" to get sensible results of course.

That shader is rather cumbersome and could be streamlined enormously by using for loops in higher shader versions such as PS2a or PS3.

Back to top

Profile PM Email

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 13:37 Edited at: 1st Feb 2012 13:37

Link

Screenshot from Dark Shader using images from one of EVOLVED's demos.

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 14:24 Edited at: 1st Feb 2012 14:27

Link

Top notch!

I wonder why DarkShader displayed variable count errors the last time I tried this? I will need to learn from this example.

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 15:52

Link

Thanks.

Quote: "I wonder why DarkShader displayed variable count errors the last time I tried this?"

Did you try to cram too many lights into one pass?

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 16:57 Edited at: 1st Feb 2012 17:11

Link

It was light heavy I guess since it contained a normal mapping script. I was just playing around at the time, but will need to do what TheComet is trying; use fewer shaders with more options.

I tend to try to 'detailmap' my objects to make the visuals less repetitive, so I was trying to add a detail texture to all of the other shaders, starting with the normal map shader, which checks for 8 lights if I remember correctly. (If I had it on me I would have attached it; it was a long while ago since I did any FX work).

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 18:48

Link

I'd need to see the shader code before I can be more specific.

Pixel shader instruction count limits are quite tight on PS2 and below which is probably why Evolved coded the present shader that way. One of the shaders that comes with Dark Shader shows a better way if you are able to use a higher shader version such as PS2.x or higher.

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 19:55 Edited at: 1st Feb 2012 19:56

Link

Ok I found it. It does not include comments and is unfinished as I was only playing around at the time; but it works. It was derived from the two Dark Shader samples; it has sliders for adjusting the blending of two textures and the contrast of the normal filter.

string Description = "This shader mixes two textures and applies a normal map using lighting and a contrast setting";
string Thumbnail = "Normal Mapping.png";

//--------------
//Untweakables
//--------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : World;
float4x4 WorldT : WorldTranspose;
float4x4 WorldIT : WorldInverseTranspose;

float4 LightPos[8] : LIGHTPOSITION;
float3 LightColor[8] : LIGHTCOLOR;
float3 AmbientColor : AMBIENTCOLOR;

float3 eyepos : CameraPosition;

//--------------
//Tweakables
//--------------

float detailScale
<
	string UIWidget = "slider";
	float UIMax = 16.0;
	float UIMin = 0.1;
	float UIStep = 0.01;
> = 1.0f;

float detailScale2
<
	string UIWidget = "slider";
	float UIMax = 16.0;
	float UIMin = 0.1;
	float UIStep = 0.01;
> = 2.0f;

float detailBlend
<
	string UIWidget = "slider";
	float UIMax = 3.0;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.1f;

float detailBlend2
<
	string UIWidget = "slider";
	float UIMax = 3.0;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.1f;

float contrast
<
	string UIWidget = "slider";
	float UIMax = 0.5;
	float UIMin = 0.002;
	float UIStep = 0.001;
> = 0.5f;

texture BaseTex
<
	string ResourceName = "";
	string ResourceType = "2D";
>;

sampler BaseSamp = sampler_state
{
	Texture = <BaseTex>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

sampler diffuse_smp = sampler_state 
{
	Texture = <BaseTex>;
	MinFilter = Anisotropic;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

texture NormalMap
<
	string ResourceName = "";
>;

sampler normalmap_smp = sampler_state 
{
	Texture = <NormalMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

// Detail Textures

texture DetailTex : DIFFUSE
<
	string ResourceName = "";
	string ResourceType = "2D";
>;

texture DetailTex2 : DIFFUSE
<
	string ResourceName = "";
	string ResourceType = "2D";
>;

sampler DetailSamp = sampler_state
{
	Texture = <DetailTex>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

sampler DetailSamp2 = sampler_state
{
	Texture = <DetailTex2>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

struct app_in
{
	float4 pos : POSITION;
	float3 normal : NORMAL0;
	float3 tangent : TANGENT0;
	float3 binormal : BINORMAL0;
	float2 uv : TEXCOORD0;
};

struct vs_out
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
	float3 normal : TEXCOORD1;
	float3 tangent : TEXCOORD2;
	float3 binormal : TEXCOORD3;
	float4 wpos : TEXCOORD4;
	// Detail
	float2 uv1 : TEXCOORD5;
	float2 uv2 : TEXCOORD6;
};

vs_out VS( app_in IN )
{
	vs_out OUT;
	
	float4 pos = mul( IN.pos, WorldViewProj );
    OUT.pos = mul( IN.pos, WorldViewProj ); // detail map output
	OUT.wpos = mul( IN.pos, World );
	
	
	//================= UV
	//--------------------------------------	
	// Default
	OUT.uv = IN.uv;
	//--------------------------------------
	// Diagonal texture
	//float2 x = {IN.uv.x + IN.uv.y, IN.uv.y};		
	//OUT.uv = x;
	//--------------------------------------
	// Scroll texture info by interval	
	//float vec1_NoiseX =  min(time % 4, 1);
	//float vec1_NoiseY =  min(time % 4, 1);
	//float2 x = {IN.uv.x + noise(vec1_NoiseX), IN.uv.y - vec1_NoiseY};		
	//OUT.uv = x;	
	//--------------------------------------	
	// Machine work
	//float u = (sin(time) * IN.uv.x)-0.5;
	//float v = (cos(time) * IN.uv.y)-0.5;	
	//float2 uvResult = {u,v};
	//OUT.uv = uvResult;
	//--------------------------------------

float3 normal = normalize(mul(IN.normal.xyz,(float3x3)World ));
	float3 tangent = normalize(mul(IN.tangent.xyz,(float3x3)World ));
	float3 binormal = normalize(mul(IN.binormal.xyz,(float3x3)World ));
	
	//smooth out the tangents and binormals with the normals
	float3 b = normalize(cross( normal,tangent ));
	b *= sign(dot(b,binormal));
	
	float3 t = normalize(cross( normal,b ));
	t *= sign(dot(t,tangent));
	
	float3 t2 = normalize(cross( normal,binormal ));
	t2 *= sign(dot(t2,tangent));
	
	float3 b2 = normalize(cross( normal,t2 ));
	b2 *= sign(dot(b2,binormal));
	
	//pass normal, tangent, and binormal to pixel shader
	OUT.normal = normal;
	OUT.tangent = normalize((t+t2)*0.5);
	OUT.binormal = normalize((b+b2)*0.5);
	
	//calculate vertex position and generate second uv co-ordinate
	// Detail map UV
	OUT.uv1 = IN.uv * detailScale;
	OUT.uv2 = IN.uv * detailScale2;
	
	return OUT;
}

float luminance ( float3 rgb )
{
	return rgb.r*0.3 + rgb.g*0.59 + rgb.b*0.11;
}

float4 PS( vs_out IN, uniform int numLights ) : COLOR
{
	float3 color = AmbientColor;
	
	float3 n = normalize(IN.normal);
	float3 t = normalize(IN.tangent);
	float3 b = normalize(IN.binormal);
	
	//build transpose matrix
	float3x3 TangentSpace = {t,b,n};
	TangentSpace = transpose(TangentSpace);
	
	n = normalize(tex2D(normalmap_smp, IN.uv)*2 - 1);
	
	float3 e = normalize(eyepos - IN.wpos);
	float eyeDist = length(eyepos - IN.wpos);
	
	e = mul(e,TangentSpace);
	
	float4 texColor = tex2D( diffuse_smp, IN.uv );
	float specPow = 2.0;
	//cycle through all lights, number depending on technique chosen
	for ( int i = 0; i < numLights; i++ )
	{
		float range = LightPos[i].w;
		
		if ( range > 0 )
		{
			float3 l = (LightPos[i].xyz - IN.wpos.xyz);
			l = mul(l,TangentSpace);

//calculate attenuation
			float dist = length(l);
			float att = saturate((range-dist) / range );
			
			//calculate diffuse lighting
			l = normalize(l);
			float diffuse = saturate(dot(n,l));
			
			//caculate specular lighting
			float3 h = normalize(l+e);
			
			float spec = pow( saturate(dot(n,h)), specPow)*(1-pow(1-diffuse,10));

// Add extra bump
		   // color += dot(n,h) * (128/specPow)*2;
		    
			//add to final color
			color += ( dot(n,h) * (3) ) + (diffuse * att * LightColor[i]) + (spec * att * LightColor[i] * smoothstep(0.1,0.8,luminance(texColor.xyz)));
			//color += (diffuse * att * LightColor[i]) + (spec * att * LightColor[i] * smoothstep(0.3,0.6,luminance(texColor.xyz)));
					
		    // contrast
			
		}
	}
	
	color *= ((color/0.5)*(contrast*0.7));

return float4(color,1.0) * texColor + 
								( 
								tex2D(BaseSamp,IN.uv) *
								tex2D(DetailSamp2,IN.uv2) *
								(0.1+detailBlend*2) +
								(tex2D(DetailSamp,IN.uv1)*(0.1+(detailBlend2*0.5)))
								   );
}

//choose the technique corresponding to the number of lights in your application
technique PerPixelLighting
{
	pass p0
	{
		VertexShader = compile vs_2_0 VS( );
		PixelShader = compile ps_2_0 PS( 0 );
	}
}

technique DBLight1
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 1 );
	}
}

technique DBLight2
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 2 );
	}
}

technique DBLight3
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 3 );
	}
}

technique DBLight4
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 4 );
	}
}

technique DBLight5
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 5 );
	}
}

technique DBLight6
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 6 );
	}
}

technique DBLight7
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 7 );
	}
}

technique DBLight8
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 8 );
	}
}

+ Code Snippet

string Description = "This shader mixes two textures and applies a normal map using lighting and a contrast setting";
string Thumbnail = "Normal Mapping.png";

//--------------
//Untweakables
//--------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : World;
float4x4 WorldT : WorldTranspose;
float4x4 WorldIT : WorldInverseTranspose;

float4 LightPos[8] : LIGHTPOSITION;
float3 LightColor[8] : LIGHTCOLOR;
float3 AmbientColor : AMBIENTCOLOR;

float3 eyepos : CameraPosition;

//--------------
//Tweakables
//--------------



float detailScale
<
	string UIWidget = "slider";
	float UIMax = 16.0;
	float UIMin = 0.1;
	float UIStep = 0.01;
> = 1.0f;

float detailScale2
<
	string UIWidget = "slider";
	float UIMax = 16.0;
	float UIMin = 0.1;
	float UIStep = 0.01;
> = 2.0f;

float detailBlend
<
	string UIWidget = "slider";
	float UIMax = 3.0;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.1f;

float detailBlend2
<
	string UIWidget = "slider";
	float UIMax = 3.0;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.1f;

float contrast
<
	string UIWidget = "slider";
	float UIMax = 0.5;
	float UIMin = 0.002;
	float UIStep = 0.001;
> = 0.5f;

texture BaseTex
<
	string ResourceName = "";
	string ResourceType = "2D";
>;

sampler BaseSamp = sampler_state
{
	Texture = <BaseTex>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

sampler diffuse_smp = sampler_state 
{
	Texture = <BaseTex>;
	MinFilter = Anisotropic;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

texture NormalMap
<
	string ResourceName = "";
>;

sampler normalmap_smp = sampler_state 
{
	Texture = <NormalMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};


// Detail Textures

texture DetailTex : DIFFUSE
<
	string ResourceName = "";
	string ResourceType = "2D";
>;

texture DetailTex2 : DIFFUSE
<
	string ResourceName = "";
	string ResourceType = "2D";
>;

sampler DetailSamp = sampler_state
{
	Texture = <DetailTex>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

sampler DetailSamp2 = sampler_state
{
	Texture = <DetailTex2>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};



struct app_in
{
	float4 pos : POSITION;
	float3 normal : NORMAL0;
	float3 tangent : TANGENT0;
	float3 binormal : BINORMAL0;
	float2 uv : TEXCOORD0;
};

struct vs_out
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
	float3 normal : TEXCOORD1;
	float3 tangent : TEXCOORD2;
	float3 binormal : TEXCOORD3;
	float4 wpos : TEXCOORD4;
	// Detail
	float2 uv1 : TEXCOORD5;
	float2 uv2 : TEXCOORD6;
};



vs_out VS( app_in IN )
{
	vs_out OUT;
	
	float4 pos = mul( IN.pos, WorldViewProj );
    OUT.pos = mul( IN.pos, WorldViewProj ); // detail map output
	OUT.wpos = mul( IN.pos, World );
	
	
	//================= UV
	//--------------------------------------	
	// Default
	OUT.uv = IN.uv;
	//--------------------------------------
	// Diagonal texture
	//float2 x = {IN.uv.x + IN.uv.y, IN.uv.y};		
	//OUT.uv = x;
	//--------------------------------------
	// Scroll texture info by interval	
	//float vec1_NoiseX =  min(time % 4, 1);
	//float vec1_NoiseY =  min(time % 4, 1);
	//float2 x = {IN.uv.x + noise(vec1_NoiseX), IN.uv.y - vec1_NoiseY};		
	//OUT.uv = x;	
	//--------------------------------------	
	// Machine work
	//float u = (sin(time) * IN.uv.x)-0.5;
	//float v = (cos(time) * IN.uv.y)-0.5;	
	//float2 uvResult = {u,v};
	//OUT.uv = uvResult;
	//--------------------------------------	

		
	float3 normal = normalize(mul(IN.normal.xyz,(float3x3)World ));
	float3 tangent = normalize(mul(IN.tangent.xyz,(float3x3)World ));
	float3 binormal = normalize(mul(IN.binormal.xyz,(float3x3)World ));
	
	//smooth out the tangents and binormals with the normals
	float3 b = normalize(cross( normal,tangent ));
	b *= sign(dot(b,binormal));
	
	float3 t = normalize(cross( normal,b ));
	t *= sign(dot(t,tangent));
	
	float3 t2 = normalize(cross( normal,binormal ));
	t2 *= sign(dot(t2,tangent));
	
	float3 b2 = normalize(cross( normal,t2 ));
	b2 *= sign(dot(b2,binormal));
	
	//pass normal, tangent, and binormal to pixel shader
	OUT.normal = normal;
	OUT.tangent = normalize((t+t2)*0.5);
	OUT.binormal = normalize((b+b2)*0.5);
	
	//calculate vertex position and generate second uv co-ordinate
	// Detail map UV
	OUT.uv1 = IN.uv * detailScale;
	OUT.uv2 = IN.uv * detailScale2;
	
	return OUT;
}

float luminance ( float3 rgb )
{
	return rgb.r*0.3 + rgb.g*0.59 + rgb.b*0.11;
}

float4 PS( vs_out IN, uniform int numLights ) : COLOR
{
	float3 color = AmbientColor;
	
	float3 n = normalize(IN.normal);
	float3 t = normalize(IN.tangent);
	float3 b = normalize(IN.binormal);
	
	//build transpose matrix
	float3x3 TangentSpace = {t,b,n};
	TangentSpace = transpose(TangentSpace);
	
	n = normalize(tex2D(normalmap_smp, IN.uv)*2 - 1);
	
	float3 e = normalize(eyepos - IN.wpos);
	float eyeDist = length(eyepos - IN.wpos);
	
	e = mul(e,TangentSpace);
	
	float4 texColor = tex2D( diffuse_smp, IN.uv );
	float specPow = 2.0;
	//cycle through all lights, number depending on technique chosen
	for ( int i = 0; i < numLights; i++ )
	{
		float range = LightPos[i].w;
		
		if ( range > 0 )
		{
			float3 l = (LightPos[i].xyz - IN.wpos.xyz);
			l = mul(l,TangentSpace);
			

		    
			//calculate attenuation
			float dist = length(l);
			float att = saturate((range-dist) / range );
			
			//calculate diffuse lighting
			l = normalize(l);
			float diffuse = saturate(dot(n,l));
			
			//caculate specular lighting
			float3 h = normalize(l+e);
			
			float spec = pow( saturate(dot(n,h)), specPow)*(1-pow(1-diffuse,10));

			
			// Add extra bump
		   // color += dot(n,h) * (128/specPow)*2;
		    
			//add to final color
			color += ( dot(n,h) * (3) ) + (diffuse * att * LightColor[i]) + (spec * att * LightColor[i] * smoothstep(0.1,0.8,luminance(texColor.xyz)));
			//color += (diffuse * att * LightColor[i]) + (spec * att * LightColor[i] * smoothstep(0.3,0.6,luminance(texColor.xyz)));
					
		    // contrast
			
		}
	}
	
	color *= ((color/0.5)*(contrast*0.7));

	return float4(color,1.0) * texColor + 
								( 
								tex2D(BaseSamp,IN.uv) *
								tex2D(DetailSamp2,IN.uv2) *
								(0.1+detailBlend*2) +
								(tex2D(DetailSamp,IN.uv1)*(0.1+(detailBlend2*0.5)))
								   );
}



//choose the technique corresponding to the number of lights in your application
technique PerPixelLighting
{
	pass p0
	{
		VertexShader = compile vs_2_0 VS( );
		PixelShader = compile ps_2_0 PS( 0 );
	}
}

technique DBLight1
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 1 );
	}
}

technique DBLight2
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 2 );
	}
}

technique DBLight3
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 3 );
	}
}

technique DBLight4
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 4 );
	}
}

technique DBLight5
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 5 );
	}
}

technique DBLight6
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 6 );
	}
}

technique DBLight7
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 7 );
	}
}

technique DBLight8
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 8 );
	}
}

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 20:21 Edited at: 1st Feb 2012 20:21

Link

If it works I guess there's nothing to fix.

Anyway, just had a peek at your shader. I see you're using the method used by the Dark Shader version which uses a single pass. That could be your problem. Here's what the DX9 SDK docs say about instruction counts for PS2:

It seems you are lucky it works at all.

I suspect the actual limit for PS2a depends on your GFX card since your instruction count is far in excess of the guaranteed limit of 96. You might find your problems go away if you can use PS3 instead which has a guaranteed limit of 512 instructions.

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 20:36 Edited at: 1st Feb 2012 20:37

Link

Quote: "If it works I guess there's nothing to fix."

I was intending to add reflection or cube mapping (like TheComet) which is my problem. I settled with normal mapping, due to trying to add reflectivity but being limited by what you say.

Based on your advice I should be able to get it working. Would be nice to see some reflections of shiney surfaces...

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 1st Feb 2012 21:01

Link

Good luck. Just post if you have problems but I think you should be almost there now.

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 1st Feb 2012 21:27

Link

Thanks for the help. I will post up my progress when I attempt the task.

Back to top

Profile PM Email Website

TheComet

18

Years of Service

User Offline

Joined: 18th Oct 2007

Location: I`m under ur bridge eating ur goatz.

Posted: 2nd Feb 2012 17:18

Link

That's amazing GG! Would it be possible to add an emissive, specular, and alpha map as well?

I've been testing the limitations of DBP and I found that DBP will crash if you try to apply the parallax shader to an object with more than 22k polygons. Why could that be?

TheComet

Timeplan : https://docs.google.com/spreadsheet/ccc?key=0AmuAKJolqASndEVYOWMxb3l2OWV0UkV1anRSczZScHc

Back to top

Profile PM Email Website

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 2nd Feb 2012 18:51

Link

Thanks. It already has an emissive map facility.

You can add two more textures (the limit is 8) so yes, you can add specular and alpha maps as well.

However, you might not need to. If some of your maps only need one colour channel and use the same UV coords then you could combine them into a single image. For example, the heightmap could be stored in the red channel, specular in the green channel and so on. You would then just need one texture read instead of three in the shader and you can pick out the channels you need in the shader code.

Back to top

Profile PM Email

MrValentine

AGK Backer

15

Years of Service

User Offline

Joined: 5th Dec 2010

Playing: FFVII

Posted: 3rd Feb 2012 03:23

Link

Im keeping track of this...

I had this question in my head for some time now...

So a silly question... what reasons other than hardware would you not use PS3.0 over PS2.0?

Back to top

Profile PM

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 3rd Feb 2012 12:37

Link

None really - although I do remember reading somewhere (on the nVidia site?) that if you can use a lower shader model then it can run slightly faster. However I don't have any specific evidence of my own to support this and I guess the differences are hard to predict unless you know a lot about the actual machine code produced by the different compilers. I'd be surprised if the differences were more than marginal though. I use PS2 out of habit more than anything else and only resort to PS3 when I need to. PS3 does have a few additional features which can be useful.

I guess shaders are just as subject to code bloat as everything else.

Back to top

Profile PM Email

Sorry your browser is not supported!

DarkBASIC Professional Discussion / Combining shaders?