Sorry your browser is not supported!

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

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

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	float4 cloudscolor={1,1,1,1};

//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	
	texture BaseTX		<string ResourceName = "" ;>;
	sampler2D BaseSampler = sampler_state
	{
		texture = <BaseTX>;
		MipFilter = Linear;
		MinFilter = Linear;
		MagFilter = Linear;
		AddressU  = Wrap;
		AddressV  = Wrap;
	};
	
//////////////////////////////
//         Structs          //
//////////////////////////////
	struct TextureBlend_Input
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};
	struct TextureBlend_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
		float2 UV1			: TEXCOORD1;
		float  Diffuse		: COLOR;
	};

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

//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_TextureBlend(TextureBlend_Output IN) : COLOR
	{
		
		float4 BaseMap		= tex2D( BaseSampler	,IN.UV0);
		
		BaseMap.rgb *= IN.Diffuse * cloudscolor.rgb;

		return BaseMap;
	}
	
//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique TextureBlend
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_TextureBlend();
			pixelShader			= compile ps_2_0 PS_TextureBlend();
		}
	}

float4 tintColor = {1.0, 0.0, 0.0, 1.0}; // to tint it red

float4 finalColour = lerp(tintedColour, originalColour, brightness);

BaseMap

basemap

matrix wvp : WORLDVIEWPROJECTION

matrix wvp : WorldViewProjection

BaseMap *= FinalColor;

float4 BaseMap = tex2D( BaseSampler ,IN.UV0);
float4 FinalColor = lerp(cloudscolor,BaseMap,0.5);
return FinalColor;

float4 BaseMap = tex2D( BaseSampler ,IN.UV0);
return lerp(cloudscolor, BaseMap, 0.5);

float4 baseMap = tex2D(BaseSampler, In.UV0);
  float brightness = dot(baseMap.rgb, 0.333333333.xxx);
  float4 finalColor = lerp(baseMap * cloudscolor, baseMap, brightness);
  return finalColor;

PSOutput PShader(PSInput In, PSOutput Out)
{ float4 color = tex2D(baseSample, In.UV);
  float brightness = dot(color.rgb, 0.333333333.xxx);
  Out.col = lerp(color * tintColour, color, brightness);
  return Out;
}

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

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

//////////////////////////////
//     Shader Constants     //
//////////////////////////////
	float4 cloudsColor={0,1,0,1.0};
	float Intensity=1;

//////////////////////////////
//     Shader Textures      //
//////////////////////////////
	
	texture BaseTX		<string ResourceName = "" ;>;
	sampler2D BaseSampler = sampler_state
	{
		texture = <BaseTX>;
	};
	
//////////////////////////////
//         Structs          //
//////////////////////////////
	struct TextureTint_Input
	{
		float4 Position		: POSITION;
		float2 UV0		: TEXCOORD0;
	};
	struct TextureTint_Output
	{
		float4 Position		: POSITION;
		float2 UV0			: TEXCOORD0;
	};

//////////////////////////////
//     Vertex Shaders       //
//////////////////////////////
	TextureTint_Output VS_TextureTint(TextureTint_Input IN)
	{
		TextureTint_Output OUT;
		
		OUT.Position	= mul( IN.Position, WorldViewProjection );
		OUT.UV0			= IN.UV0;

		return OUT;
	}


//////////////////////////////
//      Pixel Shaders       //
//////////////////////////////
	float4 PS_TextureTint(TextureTint_Output IN) : COLOR
	{
		
		float4 BaseMap		= tex2D( BaseSampler	,IN.UV0);
		float Intensity = dot(BaseMap.rgb, 0.333333333.xxx);		
		float4 FinalColor = lerp(BaseMap * cloudsColor , BaseMap , Intensity);
		return FinalColor;


	}


//////////////////////////////
//       Techniques         //
//////////////////////////////
	technique TextureTint
	{
		pass p0
		{
			vertexShader		= compile vs_1_1 VS_TextureTint();
			pixelShader		= compile ps_2_0 PS_TextureTint();
		}
	}

// Vee's shader
float2 InvViewSize;
texture myTexture <string Name="";>;

sampler2D myTextureS = sampler_state
{
Texture = <myTexture>;
};

struct output
{
    float4 pos	:POSITION;
    float2 texCoord  :TEXCOORD0;
};

output VS(float4 pos	:POSITION)
{
   output OUT;

OUT.texCoord  =  pos.xy * float2(0.5, -0.5)+ 0.5;
pos.xy  =  pos.xy + float2(-InvViewSize.x, InvViewSize.y);
OUT.pos = pos;
return OUT;
}

float4 PS(output IN) : COLOR
{
//set it up
float4 Colour3 = tex2D(myTextureS, IN.texCoord.xy);
IN.texCoord.x = IN.texCoord.x*1.0;
IN.texCoord.y = IN.texCoord.y*1.0;

// emboss
Colour3.a = 1.0f;
Colour3.rgb = 0.5f;
Colour3 +=tex2D(myTextureS, IN.texCoord - 0.001)*2.0;
Colour3 -=tex2D(myTextureS, IN.texCoord + 0.001)*2.0;
Colour3.rgb =  (Colour3.r + Colour3.g + Colour3.g) /3.0f;

// normal map texture color
Colour3.b = Colour3.b*1.501;
Colour3.r =  Colour3.r*0.7991;
Colour3.g = Colour3.g*0.9191;
Colour3.r /= Colour3.b;
Colour3.b /= Colour3.g;

return Colour3;
}

technique Complete 
{  
	pass simple  
    {		 
	VertexShader = compile vs_1_1 VS(); 
	PixelShader = compile ps_2_0 PS(); 
    }  

}  

//
====================================================
// Environment Bump Mapping
// By EVOLVED
//====================================================

//--------------
// un-tweaks
//--------------
   matrix WorldVP:WorldViewProjection; 
   matrix World:World;   
   matrix ViewInv:ViewInverse; 
 
//--------------
// tweaks
//--------------
   float LerpFactor = 0.75f;
   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 cubeMapTX : ENVIRONMENT
      <
	string Name = ""; 
      >;
   samplerCUBE cubeMap = sampler_state 
      {
	Texture = <cubeMapTX>;
      };
   texture LightMapTX : ENVIRONMENT
      <
	string Name = ""; 
      >;
   sampler2D LightMap = sampler_state 
      {
	Texture = <LightMapTX>;
      };




//--------------
// structs 
//--------------
   struct input
       {
 	float4 Pos:POSITION;
    	float2 UV:TEXCOORD0; 
    	float2 UV2:TEXCOORD1; 
	float3 Normal:NORMAL;
 	float3 Tangent:TANGENT;
 	float3 Binormal:BINORMAL;
       };
   struct output
       {
 	float4 OPos:POSITION; 
    	float2 Tex:TEXCOORD0; 
    	float3 Ref:TEXCOORD1; 
    	float3 Tex1:TEXCOORD2; 
    	float3 Tex2:TEXCOORD3; 
    	float3 Tex3:TEXCOORD4; 
       };

//--------------
// 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); 
	OUT.Ref=WPos-ViewInv[3].xyz;
	OUT.Tex1 = TBN[0];
	OUT.Tex2 = TBN[1];
	OUT.Tex3 = TBN[2];
	return OUT;
    }

//--------------
// pixel shader
//--------------
    float4 PS(output IN)  : COLOR
     {		
  	float3 Base=tex2D(Base,IN.Tex);
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
   	float3 eyevec=IN.Ref ;
    	float3 worldNorm;
    	worldNorm.x=dot(IN.Tex1,NormalMap);
    	worldNorm.y=dot(IN.Tex2,NormalMap);
    	worldNorm.z=dot(IN.Tex3,NormalMap);
    	float3 lookup=reflect(eyevec, worldNorm);
  	float3 Cube=texCUBE(cubeMap,lookup);
	return float4(lerp(Base,Cube,LerpFactor),Alpha);
     }

//--------------
// techniques   
//--------------
    technique Cubemap
      {
 	pass p1
      {		
 	vertexShader = compile vs_1_1 VS(); 
 	pixelShader  = compile ps_1_4 PS();	
      }
      }

//====================================================
// Sky Box
// By EVOLVED
//====================================================

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

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

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION;
 	float2 UV:TEXCOORD;
     };
   struct output
     {
 	float4 OPos:POSITION;
 	float3 View:TEXCOORD0; 
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
    {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
	OUT.View=(mul(IN.Pos,World)-ViewInv[3].xyz);
	return OUT;
    }

//--------------
// pixel shader
//--------------
    float4 PS(output IN)  : COLOR
     {		
	return texCUBE(cubeMap,IN.View);
     }

//--------------
// techniques   
//--------------
    technique Sky
      {
 	pass p1
      {		
 	vertexShader = compile vs_1_0 VS(); 
 	pixelShader  = compile ps_1_0 PS();	
      }
      }

    float4 PS(output IN)  : COLOR
     {		
	return texCUBE(cubeMap,mul(IN.View, (float3x3) rotationMatrix);
     }