Sorry your browser is not supported!

float4 __tex2D_flip_v(sampler2D samp, float2 uv)
{
	return tex2D(samp, float2(uv.x, 1.0-uv.y));
}

float4 __tex2D_flip_v(sampler2D samp, float2 uv, float2 ddu, float2 ddv)
{
	return tex2D(samp, float2(uv.x, 1.0-uv.y), ddu, ddv);
}

float4 __tex2D_flip_v(sampler2D samp, float2 uv)
{
	return tex2D(samp, float2(uv.x, uv.y));
}

float4 __tex2D_flip_v(sampler2D samp, float2 uv, float2 ddu, float2 ddv)
{
	return tex2D(samp, float2(uv.x, uv.y), ddu, ddv);
}

sync mask 2^1

sync mask 0x00000006

sync mask 2^2 + 2^5

sync mask 0x00000024

sync mask 36

sync mask %100100

<do something>
sync mask <various cameras>
<do various things>
sync
<do more things>
sync mask 2^0
<do more things again>
sync

//===================================================
// Reflective/Refractive Water 
// By EVOLVED
//====================================================

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

//--------------
// tweaks
//--------------
   float WaterBump = 0.02f;
   float FresPow = 25.0f;
   float2 WaterScale = { 4.0f , 4.0f};
   float2 Speed1 = {-0.04,0.04};
   float2 Speed2 = {0.05,-0.05};
   float3 RefractColor = { 1.1f , 1.1f, 1.1f};
   float3 ReflectColor = { 1.25f , 1.25f, 1.25f};
float3 WaterColor = {.4f,.35f,.2f};
float Reflective = 0.5f;
bool Over=1;

//--------------
// Textures
//--------------
   texture WaterRefractTX <string Name=""; >;	
   sampler2D WaterRefract=sampler_state
     {
	Texture = <WaterRefractTX>;
	ADDRESSU = CLAMP;
   	ADDRESSV = CLAMP;
   	ADDRESSW = CLAMP;
	MagFilter = None;
	MinFilter = None;
	MipFilter = None;
     };
   texture WaterReflectTX <string Name=""; >;	
   sampler2D WaterReflect=sampler_state
     {
	Texture = <WaterReflectTX>;
	ADDRESSU = CLAMP;
   	ADDRESSV = CLAMP;
   	ADDRESSW = CLAMP;
	MagFilter = None;
	MinFilter = None;
	MipFilter = None;
     };
   texture WaterbumpTX <string Name=""; >; 
   sampler2D Waterbump=sampler_state 
     {
	Texture = <WaterbumpTX>;
	MagFilter = Linear;	
	MinFilter = Point;
	MipFilter = None;
     };
   texture FresnelTX <string Name=""; >;	
   sampler2D Fresnel=sampler_state
     {
	Texture = <FresnelTX>;
	MagFilter = Linear;	
	MinFilter = Point;
	MipFilter = None;
   	ADDRESSU = CLAMP;
   	ADDRESSV = CLAMP;
   	ADDRESSW = CLAMP;
     };
   texture WaterMaskTX <string Name=""; >;	
   sampler2D WaterMask=sampler_state
     {
	Texture = <WaterMaskTX>;
   	ADDRESSU = CLAMP;
   	ADDRESSV = CLAMP;
   	ADDRESSW = CLAMP;
     };

//--------------
// structs 
//--------------
   struct input
     {
 	float4 Pos:POSITION; 
 	float2 UV:TEXCOORD; 
     };
   struct output
     {
 	float4 OPos:POSITION;  
	float2 Tex0:TEXCOORD0;
 	float2 Tex1:TEXCOORD1; 
 	float2 Tex2:TEXCOORD2; 
	float2 ViewVec:TEXCOORD3;  
    	float4 RefrProj:TEXCOORD4;
    	float4 ReflProj:TEXCOORD5;
     };

//--------------
// vertex shader
//--------------
   output VS(input IN) 
     {
 	output OUT;
	OUT.OPos=mul(IN.Pos,WorldVP); 
	OUT.Tex0=IN.UV;
	OUT.Tex1=IN.UV*WaterScale+(time*Speed1);
	OUT.Tex2=IN.UV*WaterScale*4+(time*Speed2);
	float3 WPos=mul(IN.Pos,World);  
	float3 VP=ViewInv[3].xyz-WPos;
 	OUT.ViewVec=0.5f+(-VP.xz/((VP.y+5)*FresPow))*0.5;
	OUT.RefrProj=float4(OUT.OPos.x*0.5+0.5*OUT.OPos.w,0.5*OUT.OPos.w-OUT.OPos.y*0.5,OUT.OPos.w,OUT.OPos.w);
  	OUT.ReflProj=float4(OUT.OPos.x*0.5+0.5*OUT.OPos.w,0.5*OUT.OPos.w+OUT.OPos.y*0.5,OUT.OPos.w,OUT.OPos.w);
	return OUT;
    }

//--------------
// pixel shader
//--------------
   float4 ReflRefr(output IN) : COLOR 
    {
    	float4 Distort = tex2D(Waterbump,IN.Tex1);
        Distort=Distort+tex2D(Waterbump,IN.Tex2)-1;
  	Distort=Distort*(IN.RefrProj.z*WaterBump);
    	float3 Refraction=tex2Dproj(WaterRefract,IN.RefrProj+Distort)*RefractColor;
	float3 Reflection=tex2Dproj(WaterReflect,IN.ReflProj+Distort)*ReflectColor;
	float Fresnel=tex2D(Fresnel,IN.ViewVec).x;
    	float3 Water=lerp(Reflection,Refraction,Fresnel);
	return float4(Water,1);
    } 
   float4 Refr(output IN) : COLOR 
    {
    	float4 Distort = tex2D(Waterbump,IN.Tex1);
        Distort=Distort+tex2D(Waterbump,IN.Tex2)-1;
  	Distort=Distort*(IN.RefrProj.z*WaterBump);
    	float3 Refraction=tex2Dproj(WaterRefract,IN.RefrProj+Distort)*RefractColor;
	return float4(Refraction,1);
    } 
   float4 Dirt(output IN) : COLOR 
    {
	float Mask=tex2D(WaterMask,IN.Tex0).x;
    	float4 Distort=tex2D(Waterbump,IN.Tex1);
    	Distort=Distort+tex2D(Waterbump,IN.Tex2)-1;
	Distort=Distort*(IN.RefrProj.z*WaterBump)*Mask;
	float Fresnel=tex2D(Fresnel,IN.ViewVec).x;
	float3 Water;
	if (Over){
		float3 Reflection=tex2Dproj(WaterReflect,IN.ReflProj+Distort);
    		Water=lerp(Color,Reflection,(1-Fresnel)*Reflective);
    }else{
		float3 Reflection=tex2Dproj(WaterReflect,IN.RefrProj+Distort);
    		Water=lerp(Color,Reflection,Fresnel*Reflective);
    }
	return float4(Water,Mask);
    }

//--------------
// techniques   
//--------------
  technique ReflectRefract
   {
    pass p1
     {		
      VertexShader = compile vs_1_1 VS(); 
      PixelShader  = compile ps_2_0 ReflRefr(); 		
     }
    }
  technique Refract
   {
    pass p1
     {		
      VertexShader = compile vs_1_1 VS(); 
      PixelShader  = compile ps_2_0 Refr(); 		
     }
    }
  technique DirtWater
   {
    pass p1
     {		
      VertexShader = compile vs_1_1 VS(); 
      PixelShader  = compile ps_2_0 Dirt(); 		
     }
    }

float3 WaterColor = {.4f,.35f,.2f};

    		Water=lerp(Color,Reflection,(1-Fresnel)*Reflective);

    		Water=lerp(Color,Reflection,Fresnel*Reflective);

matrix WorldViewProjection	: WorldViewProjection;

float4 LightPosition		: LightPosition;
float4 PlanetPosition		: PlanetPosition;
float  PlanetRadius			: PlanetRadius;

texture DiffuseTX		<string Name="" ;>;
sampler2D DiffuseSampler = sampler_state
{
	texture = <DiffuseTX>;
};

struct VertexInput
{
	float4 Position		: POSITION;
	float2 UV0			: TEXCOORD0;
};
struct VertexOutput
{
	float4 Position		: POSITION;
	float2 UV0			: TEXCOORD0;
};

VertexOutput VertexShader(VertexInput IN)
{
	VertexOutput OUT;
	OUT.Position	= mul(IN.Position, WorldViewProjection);
	OUT.UV0			= IN.UV0;
	return OUT;
}

float4 PixelShader(VertexOutput IN)  : COLOR
{
	// Grab texture pixel colour
	float4 DiffuseMap	= tex2D(DiffuseSampler , IN.UV0 );
	
	// Find distance from pixel to light
	float4 Px_Dist_L 	= IN.Position - LightPosition;
	
	// Find distance from planet to light
	float4 Pl_Dist_L 	= PlanetPosition - LightPosition;
	
	// Find difference ratio
	float4 Ratio		= Px_Dist_L / Pl_Dist_L;
	
	// Find new position based on ratio/planet positon
	float4 NPx			= mul(PlanetPosition, Ratio);
	
	// Find distance between pixel and new point
	float4 SDist		= IN.Position - NPx;
	
	// Distance is less than radius?
	if ( SDist.w < PlanetRadius )
	{
		// Darken RGB
		DiffuseMap.rgb *= 0.0;
		return DiffuseMap;
	}
	else
	{
		return DiffuseMap;
	}
}

technique Rings
{
	pass p1
	{		
		vertexShader = compile vs_1_1 VertexShader();
		pixelShader  = compile ps_1_1 PixelShader();
	}
}

matrix WorldViewProjection	: WorldViewProjection;

float4 LightPosition		= { 100.0, 0.0, 0.0, 1.0};  // **GG
float4 PlanetPosition		= { 100.0, 0.0, 0.0, 1.0};  // **GG
float  PlanetRadius			= 10.0;             // **GG

texture DiffuseTX		<string ResourceName="" ;>; // **GG
sampler2D DiffuseSampler = sampler_state
{
	texture = <DiffuseTX>;
};

struct VertexInput
{
	float4 Position		: POSITION;
	float2 UV0			: TEXCOORD0;
};
struct VertexOutput
{
	float4 Position		: POSITION;
	float2 UV0		: TEXCOORD0;
	float4 sPos             : TEXCOORD1;   // **GG
};

VertexOutput VertexShader(VertexInput IN)
{
	VertexOutput OUT;
	float4 tempPos = mul(IN.Position, WorldViewProjection);  // **GG
	OUT.Position	= tempPos;  // **GG
	OUT.sPos        = tempPos;  // **GG
	OUT.UV0			= IN.UV0;
	return OUT;
}

float4 PixelShader(VertexOutput IN)  : COLOR
{
	// Grab texture pixel colour
	float4 DiffuseMap	= tex2D(DiffuseSampler , IN.UV0 );
	
	// Find distance from pixel to light
	float4 Px_Dist_L 	= IN.sPos - LightPosition;  // **GG
	
	// Find distance from planet to light
	float4 Pl_Dist_L 	= PlanetPosition - LightPosition;
	
	// Find difference ratio
	float4 Ratio		= Px_Dist_L / Pl_Dist_L;
	
	// Find new position based on ratio/planet positon
	float4 NPx			= mul(PlanetPosition, Ratio);
	
	// Find distance between pixel and new point
	float4 SDist		= IN.sPos - NPx;   // **GG
	
	// Distance is less than radius?
	if ( SDist.w < PlanetRadius )
	{
		// Darken RGB
		DiffuseMap.rgb *= 0.0;
		return DiffuseMap;
	}
	else
	{
		return DiffuseMap;
	}
}

technique Rings
{
	pass p1
	{		
		vertexShader = compile vs_1_1 VertexShader();
		pixelShader  = compile ps_2_0 PixelShader();  // **GG
	}
}

  //--------------------------------
  // NormalMapping
  //--------------------------------
  // By Evolved
  // http://www.vector3r.com/
  //--------------------------------

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

  //-----------------
  // tweaks
  //-----------------
   float4 LightPosition = {150.0f, 150.0f, 0.0f, 1.0f};    
   float4 LightColor = {1.0f, 1.0f, 1.0f, 1.0f};    
   float LightRange = 250.0f;    
   float4 Ambient = {0.1f, 0.1f, 0.1f, 1.0f};     
   float U = 1.0f; 
   float V = 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;
	MagFilter = Linear;	
	MinFilter = Point;
	MipFilter = None;
    };

  //-----------------
  // 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*float2(U,V);
	float3 WNor=mul(IN.Normal,World); WNor=normalize(WNor);
	float3 Wtan=mul(IN.Tangent,World); Wtan=normalize(Wtan);
	float3 Wbin=mul(IN.Binormal,World); Wbin=normalize(Wbin);
	float3 WPos=mul(IN.Pos,World);  
	float3x3 TBN={-Wtan,Wbin,WNor}; TBN=transpose(TBN);
	float3 LightPos=LightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	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(NormalMap,LightV)); 
	float Specular=saturate(dot(reflect(-View,NormalMap),LightV));
	Specular=Specular*Specular; Specular=Specular*Specular;
	Specular=Specular*Specular;
	float4 DiffuseLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float4 Light=DiffuseLight*LightColor;
	return Texture*(((Normal+Specular)*Light)+Ambient);
     }

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

// Find distance from pixel to light
float Px_Dist_L 	= IN.sPos - LightPosition;  // **GG

// Find distance from planet to light
float Pl_Dist_L 	= PlanetPosition - LightPosition;

// Find difference ratio
float Ratio		= Px_Dist_L / Pl_Dist_L;

DiffuseMap.rgb *= Px_Dist_L - Pl_Dist_L;
return DiffuseMap;

DiffuseMap.rgb *= Ratio;
return DiffuseMap;

// Find distance from pixel to light
float Px_Dist_L 	= IN.sPos - LightPosition;  // **GG

// Find distance from planet to light
float Pl_Dist_L 	= PlanetPosition - LightPosition;

// Find difference ratio
float Ratio		= Px_Dist_L / Pl_Dist_L;

// Find distance from pixel to light
float Px_Dist_L 	= IN.sPos.x - LightPosition.x;  // **GG

// Find distance from planet to light
float Pl_Dist_L 	= PlanetPosition.x - LightPosition.x;

// Find difference ratio
float Ratio		= Px_Dist_L / Pl_Dist_L;

// Find distance from pixel to light
float Px_Dist_L 	= length(IN.sPos.xyz - LightPosition.xyz);  // **GG - squared :)

matrix WorldViewProjection	: WorldViewProjection;
matrix World				: World;

float4 Pl_Minus_Cam			= {3.0, 0.0, 0.0, 1.0};	// Planet XYZ - Camera XYZ
float4 LightPosition		= {1.0, 0.0, 0.0, 1.0};	// Light XYZ
float4 Pl_Minus_L			= {2.0, 0.0, 0.0, 1.0};	// Planet XYZ - Light XYZ
float  PlanetRadius			= 500.0;				// Radius of planet
float  Pl_Dist_L			= 5.0;					// Distance between Planet and Light
float  PenubraWidth			= 10.0;					// Width of the planetary penumbra
float  OneDivPenubra		= 0.1;					// 1 / PenubraWidth

texture DiffuseTX		<string ResourceName="" ;>;
sampler2D DiffuseSampler = sampler_state
{
	texture = <DiffuseTX>;
};

struct VertexInput
{
	float4 Position			: POSITION;
	float2 UV0				: TEXCOORD0;
};
struct VertexOutput
{
	float4 Position			: POSITION;
	float2 UV0				: TEXCOORD0;
	float4 PixelPosition	: TEXCOORD1;
};

VertexOutput VertexShader(VertexInput IN)
{
	VertexOutput OUT;
	OUT.Position		= mul(IN.Position, WorldViewProjection);
	OUT.PixelPosition	= mul(IN.Position, World);
	OUT.UV0				= IN.UV0;
	return OUT;
}

float4 PixelShader(VertexOutput IN) : COLOR
{
	// Grab texture pixel colour
	float4 DiffuseMap	= tex2D(DiffuseSampler , IN.UV0);
	
	// Find distance from pixel to light
	float Px_Dist_L 	= length(IN.PixelPosition.xyz - LightPosition.xyz);
	
	// Is the pixel behind the planet?
	if (Pl_Dist_L < Px_Dist_L)
	{
		// Find difference ratio
		float Ratio	= Px_Dist_L / Pl_Dist_L;
		
		// Find new position based on ratio/planet positon
		float3 NPx	= LightPosition.xyz + Pl_Minus_L.xyz * Ratio;
		
		// Find distance between pixel and new point
		float SDist	= length(IN.PixelPosition.xyz - NPx.xyz);
		
		// Projected distance is less than radius?
		if (SDist < PlanetRadius)
		{
			// Fade from penubra to umbra
			float Over		= PenubraWidth - (PlanetRadius - SDist);
			DiffuseMap.rgb *= clamp(Over * OneDivPenubra, 0.0, 1.0);
		}
	}
	return DiffuseMap;
}

technique Rings
{
	pass p1
	{
		vertexShader = compile vs_1_1 VertexShader();
		pixelShader  = compile ps_2_0 PixelShader();
	}
}

float4 colour = tex2D(baseSample, In.UV);
clip(dot(colour.rgb, 1.0.xxx) - 0.001);