Sorry your browser is not supported!

// Green Gandalf's Blended Normal Mapping Shader
//
// designed for use with terrain objects
//
//
// Created 7 March 2007, edited 8 March 2007.
//
float4x4 World;
float4x4 View;
float4x4 Projection;


float4 lightDir   = {0.707107f, -0.707107f, 0.0f, 1.0f};
float4 ambiColor  = {0.5f, 0.5f, 0.5f, 1.0f};
float4 lightColor = {1.0f, 1.0f, 1.0f, 1.0f};
float2 UVTiling = {12, 12};
float  vertScale = 0.003; // reciprocal of maximum height of terrain
float contrast = 2.0;  // higher values increase the contrast between textures

texture detailMap1 < string ResourceName = ""; >;
texture detailMap2 < string ResourceName = ""; >;
texture detailMap3 < string ResourceName = ""; >;
texture detailMap4 < string ResourceName = ""; >;
texture normalMap1 < string ResourceName = ""; >;
texture normalMap2 < string ResourceName = ""; >;
texture normalMap3 < string ResourceName = ""; >;
texture normalMap4 < string ResourceName = ""; >;

sampler2D detail1 = sampler_state 
{  texture = <detailMap1>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D detail2 = sampler_state 
{  texture = <detailMap2>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D detail3 = sampler_state 
{  texture = <detailMap3>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};

sampler2D detail4 = sampler_state 
{  texture = <detailMap4>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};

sampler2D nMap1 = sampler_state 
{  texture = <normalMap1>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};

sampler2D nMap2 = sampler_state 
{  texture = <normalMap2>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D nMap3 = sampler_state 
{  texture = <normalMap3>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D nMap4 = sampler_state 
{  texture = <normalMap4>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};

struct VS_INPUT
{   float4 Pos          : POSITION;
    float2 Tex          : TEXCOORD0;
    float3 Normal       : NORMAL; 
    float3 Tangent      : TANGENT;
    float3 Binormal     : BINORMAL;
};




struct VS_OUTPUT
{   float4 Pos				: POSITION;
    float2 Tex				: TEXCOORD0;
    float  Diffuse			: TEXCOORD1;
    float4 Blender			: TEXCOORD2;
	float2 Depth			: TEXCOORD3;
    float3x3 tangentToWorld : TEXCOORD4;
	//float3 Normal			: TEXCOORD5;
};



VS_OUTPUT GGBlendVShader(VS_INPUT In, VS_OUTPUT Out)
{   //float4 tempPos = mul(In.Pos, mw);
    //Out.Pos = mul(In.Pos, wvp);
    
	float4 worldPosition = mul(float4(In.Pos.xyz,1), World);
    float4 viewPosition = mul(worldPosition, View);
    Out.Pos = mul(viewPosition, Projection);
	
    Out.Tex = In.Tex;
    Out.Diffuse  = saturate(dot(normalize(In.Normal), -normalize(lightDir.xyz)));
    
    Out.Depth.x = Out.Pos.z;
    Out.Depth.y = Out.Pos.w;

	// calculate tangent space to world space matrix using the world space tangent,
    // binormal, and normal as basis vectors
    Out.tangentToWorld[0] = mul(In.Tangent, World);
    Out.tangentToWorld[1] = mul(In.Binormal, World);
    Out.tangentToWorld[2] = mul(In.Normal, World);

	//calculate the blend factors
	float2 hn = float2 (In.Pos.y * vertScale, In.Normal.y);
    hn = saturate(0.5.xx + contrast * (hn - 0.5.xx));
    Out.Blender = float4 (hn.x * hn.y, hn.x * (1 - hn.y),
                   (1 - hn.x) * hn.y, (1 - hn.x) * (1 - hn.y));
    // e.g. blends = grass, rock, sand, gravel
    
	
	
	return Out;
}



struct PS_INPUT
{   float2 Tex				: TEXCOORD0;
    float  Diffuse			: TEXCOORD1;
    float4 Blender			: TEXCOORD2;
	float2 Depth			: TEXCOORD3;
    float3x3 tangentToWorld : TEXCOORD4;
	//float3 Normal			: TEXCOORD5;


};

struct PS_OUTPUT
{  
	float4 Color   : COLOR0;
    float4 Normal  : COLOR1;
    float4 Depth   : COLOR2;

};



PS_OUTPUT GGBlendPShader(PS_INPUT In, PS_OUTPUT Out)
{  
   float4 base1 = tex2D(detail1, In.Tex * UVTiling ) * In.Blender.x;
   float4 base2 = tex2D(detail2, In.Tex * UVTiling ) * In.Blender.y;
   float4 base3 = tex2D(detail3, In.Tex * UVTiling ) * In.Blender.z;
   float4 base4 = tex2D(detail4, In.Tex * UVTiling ) * In.Blender.w;

   //float4 detail = tex2D(nMap1,(In.Tex * UVTiling*20));
   float4 base  = (base1 + base2 + base3 + base4);// * (detail*2);
   Out.Color = base * (ambiColor  + In.Diffuse * lightColor  );

    //specular Intensity
	//float4 specularAttributes = tex2D(specularSampler, input.TexCoord);
   // Out.Color.a = specularAttributes.r;  //output the specular color to the alpha channel
    
   // read the normal from the normal map
    
   //float4 normal1 = tex2D(nMap1, In.Tex * UVTiling ) * In.Blender.x;
   //float4 normal2 = tex2D(nMap2, In.Tex * UVTiling ) * In.Blender.y;
   //float4 normal3 = tex2D(nMap3, In.Tex * UVTiling ) * In.Blender.z;
   //float4 normal4 = tex2D(nMap4, In.Tex * UVTiling ) * In.Blender.w;
   
   float4 normal1 = (2 * (tex2D(nMap1,In.Tex * UVTiling))) - 1.0 * In.Blender.x;
   float4 normal2 = (2 * (tex2D(nMap2,In.Tex * UVTiling))) - 1.0 * In.Blender.y;
   float4 normal3 = (2 * (tex2D(nMap3,In.Tex * UVTiling))) - 1.0 * In.Blender.z;
   float4 normal4 = (2 * (tex2D(nMap4,In.Tex * UVTiling))) - 1.0 * In.Blender.w;


   float4 normalFromMap  = (normal1 + normal2 + normal3 + normal4)/4;

    //tranform to [-1,1]
    //normalFromMap = 2.0f * normalFromMap - 1.0f;
    //transform into world space
    normalFromMap = mul(normalFromMap, (In.tangentToWorld[2],1.0));
    //normalize the result
    normalFromMap = normalize(normalFromMap);
    //output the normal, in [0,1] space
	//float4 map =  0.5f * (normalFromMap + 1.0f);

   float3 modelNormal = normalize(In.tangentToWorld[2]);    //transform normal domain
	
	Out.Normal.rgb = modelNormal += normalFromMap.rgb;
		
    //specular Power
    //Out.Normal.a = specularAttributes.a;
	//Out.Normal = 1.0;
    
	Out.Depth = In.Depth.x / In.Depth.y;
	
   return Out;
}


technique t1 // use this for blending only
{   pass p0
    {  
		
		//NORMALIZENORMALS = TRUE;
		VertexShader = compile vs_2_0 GGBlendVShader();
       PixelShader = compile ps_2_0 GGBlendPShader();
    }
}

//====================================================
// Tree Leaf
//====================================================
// By EVOLVED
// www.evolved-software.com
//====================================================

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

//--------------
// un-tweaks
//--------------
   float3 Ambient={0.2f,0.2f,0.2f};    
   float3 LightPosition={200.0f,300.0f,-200.0f};    
   float3 LightColor={1.0f,1.0f,1.0f};    
   float LightRange=600.0f;
   float Alpha=1.0f;
   float4 LeafAnimation={0.5,0.5,0.5,1.0};  	

//--------------
// Textures
//--------------
   texture BaseTX <string Name="";>;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
	MagFilter=Linear;	
	MinFilter=Linear;
	MipFilter=None;
    };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD; 
	float3 Normal:NORMAL;
     };
   struct output
     {
	float4 OPos:POSITION; 
 	float2 Tex:TEXCOORD0; 
  	float3 Light:TEXCOORD1; 
	float Diffuse:TEXCOORD2;
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
    	float4 TempPos=IN.Pos;
    	float3 Incpos=0;
    	Incpos.x=cos(TempPos.x+(time*LeafAnimation.w))*LeafAnimation.x; 
    	Incpos.y=sin(TempPos.y+(time*LeafAnimation.w))*LeafAnimation.y; 
    	Incpos.z=cos(TempPos.z+(time*LeafAnimation.w))*LeafAnimation.z; 
    	TempPos.xyz=TempPos.xyz+Incpos;
	OUT.OPos=mul(TempPos,WorldVP); 
 	OUT.Tex=IN.UV;
	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(TempPos,World);  
	float3 LightPos=LightPosition-WPos; 
	OUT.Light=-LightPos/LightRange;
 	OUT.Diffuse=saturate(0.01f+mul(Wnor,LightPos)*0.01f); 
	return OUT;
     }

//--------------
// pixel shader
//--------------
   float4 PS(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.Tex); 
	float3 Light=(1-saturate(length(IN.Light)))*IN.Diffuse*LightColor;
	return float4(Texture.xyz*(Light+Ambient),Texture.w);
     }
 
//--------------
// techniques   
//--------------
   technique Leaf
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 
	AlphaBlendEnable=TRUE;	
	SrcBlend=SRCALPHA;
	DestBlend=INVSRCALPHA; 	
	AlphaTestEnable=TRUE; 
	AlphaRef=0x000000CF; 
	AlphaFunc=GREATER;
      }
      }

string Description = "This shader scrolls an objects texture over its surface";
string Thumbnail = "ScrollingTexture.png";

float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : World;
float time : time;

float directionX
<
	string UIWidget = "slider";
	float UIMax = 3.0;
	float UIMin = -3.0;
	float UIStep = 0.01;
> = 1.0f;

float directionY
<
	string UIWidget = "slider";
	float UIMax = 3.0;
	float UIMin = -3.0;
	float UIStep = 0.01;
> = 1.0f;

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

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

struct app_in
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

struct vs_out
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

vs_out DefaultVertexShader( app_in IN )
{
	vs_out OUT;
	
	OUT.pos = mul( IN.pos, WorldViewProj );
	//modify uv co-ordinates using the time value
	OUT.uv = IN.uv + float2(directionX,directionY)*time;
	
	return OUT;
}

float4 DefaultPixelShader( vs_out IN ) : COLOR
{
	return tex2D(BaseSamp,IN.uv);
}

technique MyShader
{
	pass p0
	{
		VertexShader = compile vs_1_1 DefaultVertexShader( );
		PixelShader = compile ps_1_1 DefaultPixelShader( );
	}
}

string Description = "This shader scrolls an objects texture in a back-and-forth motion";
string Thumbnail = "ScrollingTexture.png";

float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : World;
float time : time;

float distanceX
<
	string UIWidget = "slider";
	float UIMax = 5.0;
	float UIMin = 0.0;
	float UIStep = 0.1;
> = 1.0f;

float SwaySpeed
<
	string UIWidget = "slider";
	float UIMax = 5.0;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 3.6f;



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

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

struct app_in
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

struct vs_out
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

vs_out DefaultVertexShader( app_in IN )
{
	vs_out OUT;
	
	OUT.pos = mul( IN.pos, WorldViewProj );
	//modify uv co-ordinates using the time value
	OUT.uv = IN.uv + float2(sin(time*SwaySpeed)*distanceX,0.0);
	
	return OUT;
}

float4 DefaultPixelShader( vs_out IN ) : COLOR
{
	return tex2D(BaseSamp,IN.uv);
}

technique MyShader
{
	pass p0
	{
		VertexShader = compile vs_2_0 DefaultVertexShader( );
		PixelShader = compile ps_2_0 DefaultPixelShader( );
	}
}

   float4 normal1 = (2 * (tex2D(nMap1,In.Tex * UVTiling))) - 1.0 * In.Blender.x;
   float4 normal2 = (2 * (tex2D(nMap2,In.Tex * UVTiling))) - 1.0 * In.Blender.y;
   float4 normal3 = (2 * (tex2D(nMap3,In.Tex * UVTiling))) - 1.0 * In.Blender.z;
   float4 normal4 = (2 * (tex2D(nMap4,In.Tex * UVTiling))) - 1.0 * In.Blender.w;
   float4 normalFromMap  = (normal1 + normal2 + normal3 + normal4)/4;
    normalFromMap = mul(normalFromMap, (In.tangentToWorld[2],1.0));
    normalFromMap = normalize(normalFromMap);

   float4 normal4 = (2 * (tex2D(nMap4,In.Tex * UVTiling)) - 1.0) * In.Blender.w;

    normalFromMap = mul(normalFromMap, (In.tangentToWorld[2],1.0));

float4 color = { 1.00, 0.5, 0.00, 1.00 };

float4 MyFirstPixelShader() : COLOR
{

   return ( color );
}

technique MyFirstTechnique
{
   pass MyFirstPass
   {
      PixelShader = compile ps_1_1 MyFirstPixelShader();
   }
}

dbLoadEffect("MyFirstShader.fx",10,0);
	dbMakeObjectCube(1000,2);
	dbSetObjectEffect(1000,10);

      PixelShader = compile ps_1_1 MyFirstPixelShader();

      PixelShader = compile ps_2_0 MyFirstPixelShader();

//--------------------------------
// Directional Light + Cubemap
//--------------------------------

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

//-----------------
// tweaks
//----------------- 
float4 LightColor = {1.0f, 1.0f, 1.0f, 1.0f};
float4 Ambient = {0.2f, 0.2f, 0.2f, 1.0f};     
float U = 1.0f; 
float V = 1.0f; 
float3 DirLightDirection = {0.5f, -0.5f, -0.5f};

//-----------------
//CUBEMAPPING TWEAKS
//-----------------
float ReflectFactor=0.5f;
float4 FogColor={0.58f,0.58f,0.58f,1.0f};
float FogRange=400.0f;
float Alpha=1.0f;


//-----------------
// Textures
//-----------------
texture BaseTX <string Name="";>;	
sampler2D Base = sampler_state 
{
	texture = <BaseTX>;
};

texture cubeMapTX : ENVIRONMENT <string Name = ""; >;
samplerCUBE cubeMap = sampler_state 
{
	Texture = <cubeMapTX>;
};

//-----------------
// structs 
//-----------------
struct input
{
	float4 Pos:POSITION; 
	float2 UV:TEXCOORD; 
	float3 Normal : NORMAL;
};
struct output
{
	float4 OPos:POSITION; 
	float2 Tex:TEXCOORD0;
	
	float3 Ref:TEXCOORD1; 
	float3 Normals:TEXCOORD2; 
	float Fog:FOG;
};

//-----------------
// vertex shader
//-----------------
output VS(input IN) 
{
	output OUT;

	OUT.OPos=mul(IN.Pos,WorldVP); 
	OUT.Tex=IN.UV*float2(U,V);

	float3 Wnor=mul(IN.Normal,World); Wnor=normalize(Wnor);
	float3 WPos=mul(IN.Pos,World);  

	float3 View = WPos-ViewInv[3].xyz; 
	OUT.Ref=reflect(View,Wnor); 
	OUT.Normals=Wnor;
	OUT.Fog=1-saturate(dot(View/FogRange,View/FogRange));

	return OUT;
}

//-----------------
// pixel shader
//-----------------
float4 PS(output IN)  : COLOR
{
	float4 Texture=tex2D(Base,IN.Tex);
	
	float3 Cube=texCUBE(cubeMap,IN.Ref);
	
	float Light=saturate(dot(-DirLightDirection,IN.Normals));
	
	return float4(lerp(Texture,Cube,ReflectFactor)*((Light*LightColor)+Ambient),Texture.w*Alpha);
}

//-----------------
// techniques   
//-----------------
technique CubicLighting
{
	pass p1
	{		
		vertexShader = compile vs_1_1 VS(); 
		pixelShader  = compile ps_2_0 PS(); 

		FOGCOLOR=(FogColor); 
		FOGENABLE=TRUE;		
	}
}

  Texture.rgb *= ((Light*LightColor)+Ambient).rgb;
  return float4(lerp(Texture.rgb,Cube,ReflectFactor),Texture.w*Alpha);

(Light*LightColor)+Ambient

(Light*LightColor)+(PositionalLight*PositionalLightColor)+Ambient

float3 PositionalLightDirection = WPos - PointLightPosition;

float Specular=saturate(dot(reflect(-View,NormalMap),LightV));
Specular=pow(Specular,SpecularPow);
..
return Texture*(((Normal+Specular)*Light)+Ambient);

float Specular=saturate(dot(reflect(-View,NormalMap),LightV));
Specular=pow(Specular,SpecularPow)*(SpecTex*SpecBright);
..
return Texture*(((Normal+Specular)*Light)+Ambient)+(Emissive*EmissPower);

string Description = "A model shader from FPSCreator, including normal mapping and specular highlights. Requires a boned weighted model";
string Thumbnail = "BumpBone.png";

float4x4 WorldIT : WorldInverseTranspose;
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : World;
float4 eyepos : CameraPosition;

float4x4 boneMatrix[32] : BoneMatrixPalette;

/************* Variables **************/

float4 FixedLightSource
<
    string UIWidget = "Fixed Light Source";
> = {100.0f, 0.0f, -100.0f, 0.0f};

float4 SurfColor : Diffuse
<
    string UIName =  "Surface Color";
    string UIWidget = "Color Picker";
> = {1.0f, 1.0f, 1.0f, 1.0f};

float SpecExpon : Power
<
    string UIWidget = "slider";
    float UIMin = 1.0;
    float UIMax = 128.0;
    float UIStep = 1.0;
    string UIName =  "specular power";
> = 50.0;

float Alphavalue : AlphaOverride
<
    string UIName =  "Alpha Override";
> = 0.5f;

/************* TEXTURES **************/

texture colorTexture : DiffuseMap
<
    string Name = "default_color.dds";
    string type = "2D";
>;

texture normalTexture : DiffuseMap
<
    string Name = "default_bump_normal.dds";
    string type = "2D";
>;

texture specularMap : ReflectMap
<
	string Name = "default_mask.dds";
    string type = "2D";
>;

texture noiseMap : ReflectMap
<
	string Name = "default_mask.dds";
    string type = "2D";
>;

sampler2D colorSampler = sampler_state
{
	Texture = <colorTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler2D normalSampler = sampler_state
{
	Texture = <normalTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler2D reflectSampler = sampler_state
{
	Texture = <specularMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler2D noiseSampler = sampler_state
{
	Texture = <noiseMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

/************* DATA STRUCTS **************/

struct appdata {
    float3 Position	: POSITION;
    float4 UV		: TEXCOORD0;
    float4 Normal	: NORMAL;
    float4 Tangent	: TANGENT0;
    float4 Binormal	: BINORMAL0;
    float4 Blendweight	: TEXCOORD1;
    float4 Blendindices	: TEXCOORD2;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    float4 TexCoord	: TEXCOORD0;
    float3 LightVec	: TEXCOORD1;
    float3 WorldNormal	: TEXCOORD2;
    float3 WorldEyeVec	: TEXCOORD3;
    float3 WorldTangent	: TEXCOORD4;
    float3 WorldBinorm	: TEXCOORD5;
    float Depth		: TEXCOORD6;
};

/*********** vertex shader ******/

vertexOutput mainVS(appdata IN)
{
	//smooth tangents/binormals
    float3 normal = normalize(IN.Normal);
    float3 binormal = normalize(cross(normal,normalize(IN.Tangent)));
    float3 tangent = normalize(cross(binormal,normal));
    
    vertexOutput OUT;
    float3 netPosition = 0, netNormal = 0, netTangent = 0, netBinormal = 0;
    
    //calculate vertex position from bone matrices
    for (int i = 0; i < 4; i++)
    {
     float index = IN.Blendindices[i];
     float3x4 model = float3x4(boneMatrix[index][0], boneMatrix[index][1], boneMatrix[index][2]);
     float3 vec3 = mul(model,float4(IN.Position, 1));
     vec3 = vec3 + boneMatrix[index][3].xyz;
     float3x3 rotate = float3x3(model[0].xyz, model[1].xyz, model[2].xyz); 
     
     float3 norm3 = mul(rotate, normal);
     float3 tangent3 = mul(rotate, tangent);
     float3 binormal3 = mul(rotate, binormal);
     
     netPosition += vec3 * IN.Blendweight[i];
     netNormal += norm3 * IN.Blendweight[i];
     netTangent += tangent3 * IN.Blendweight[i];
     netBinormal += binormal3 * IN.Blendweight[i];
    }
    
    float4 tempPos = float4(netPosition,1.0);
    OUT.HPosition = mul(tempPos, WorldViewProj);
    OUT.TexCoord = IN.UV;
    
    OUT.WorldNormal = normalize(mul(netNormal, World).xyz);
    OUT.WorldTangent = normalize(mul(netTangent, World).xyz);
    OUT.WorldBinorm = normalize(mul(netBinormal, World).xyz);
    
    //create tangent space matrix
    float3x3 TSM = { OUT.WorldTangent,OUT.WorldBinorm,OUT.WorldNormal };
    TSM = transpose( TSM );
    
	//transform everything to tangent space in VS
	float3 worldSpacePos = mul(tempPos, World).xyz;
    OUT.LightVec = mul(normalize(FixedLightSource - worldSpacePos),TSM);
    
	OUT.WorldNormal = mul(OUT.WorldNormal, TSM );    
    OUT.WorldEyeVec = mul(normalize(eyepos - worldSpacePos),TSM);
    
    OUT.Depth = (abs(worldSpacePos.z-(eyepos.z+60)) / 20.0);
    return OUT;
}

/********* pixel shader ********/

float4 mainPS(vertexOutput IN) : COLOR
{
    float4 height = (tex2D(normalSampler,IN.TexCoord.xy).w) * 0.01 - 0.005;
    float3 Vn = normalize(IN.WorldEyeVec);
    
    //view vec already in tangent space from VS    
    float2 baseuv = IN.TexCoord.xy;
    baseuv = baseuv + (Vn.xy*height);
    
    //sharpen base texture with basic edge detect
    float4 base = tex2D(colorSampler,baseuv);
    base = base + tex2D(colorSampler,baseuv+float2(0.0002,0.0002));
    base = base - tex2D(colorSampler,baseuv-float2(0.0002,0.0002));
    
    //multiply by some noise
    base = base * (1 - tex2D(noiseSampler,baseuv*2).b*0.1);// + tex2D(reflectSampler,baseuv)*0.5;
    
    //get normal
    float3 normal = tex2D(normalSampler,baseuv).rgb*2 - 1;
    normal = normal + (tex2D(noiseSampler,baseuv*3)*2-1)*0.025;	//test normal with noise
    normal = normalize(normal);
    
    float3 Ln = normalize(IN.LightVec);
    
    float3 Hn = normalize(Vn + Ln);
    float4 lighting = lit(dot(Ln,normal),dot(Hn,normal),SpecExpon);
    
    //multiply spec by some noise to reduce plastic look
    float spec = lighting.z*tex2D(reflectSampler,baseuv).r * (tex2D(noiseSampler,baseuv*3).b+0.3)*1.3;
    float diff = lighting.y;

    float4 result = diff*base*SurfColor + spec;
    result.w=base.w * Alphavalue;

    return result;
}

/****** technique *******/

technique dx9textured
{
	pass p0 
	{		
	    // lighting
        Lighting       = FALSE;
        SpecularEnable = FALSE;
	    FogEnable      = FALSE;

		VertexShader = compile vs_2_0 mainVS();
		ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;
		PixelShader = compile ps_2_0 mainPS();
	}
}

set effect constant vector element

set effect constant matrix