Sorry your browser is not supported!

load effect "effects/final4 switch.fx",cube_eff,1
texture object cmap_portal_obj,0,bluetex  `needs dummy texture on stage 0 for some reason.
set object effect cmap_portal_obj,cube_eff
set cube mapping on cmap_portal_obj, ref1l_tex,ref1r_tex, ref1u_tex,ref1d_tex, ref1_tex,blanktex   `back image is never seen.

// The following lines are variables which are recognised and passed by the 
// application and often referred to as "untweaks".

matrix wvp : WorldViewProjection;

// The following lines are variables which can be set by the application
// (these are usually variables which the user may want to adjust from
// their program).

float4 lightColour = {1.5, 1.5, 1.5, 1.0}; // {red, green, blue, alpha}
float focus = 0.0;	//sent from DBP.	focus from which PIXELS projected (gets close to 1 for close up i think)
float focusb =0.0;	//focus from which VERTICES are projected `2 focii are equal for model 2. different for model 1

float2 dummyuv = {0.0,0.0}; //to sample from unused dummy texture

float vertscalexy = 0.0;
float focusb2 = 0.0;

// The following lines define structures that are used as input and output
// to the vertex and pixel shader functions.

struct VSInput {
float4 Pos  : Position;
};

struct VSOutput {
float4 Pos : Position;
float3 ProjPoint : TEXCOORD0;
};

// The pixel shader does not need an input structure for this example.

struct PSOutput {
float4 Col : Color;
};


// texture stuff

//this is unused. seem to need it to have cubemapping working in DBP U74. 
//i say texture is unused. actually you are required to use it. i multiply by 0.000000000000000000000000000001 and add to final colour.
texture bumpTexture < string ResourceName = ""; >;
sampler2D   bumpSample = sampler_state 
{  texture = <bumpTexture>; };

//the actual texture we want to use:
texture cubeTexture
< string ResourceName = "";
  string Type = "CUBE";
>;

samplerCUBE cubeSample = sampler_state 
{ texture = <cubeTexture>; };



// The vertex shader code:

VSOutput VShader (VSInput In, VSOutput Out)
{  // Transforms the objects model coordinates to
   // screen space coordinates

//move vertices. - so hemisphere of original mesh is spread over only the part you can see.
// means that when you get close to the portal, effectively there is more detail.
	
Out.Pos = In.Pos;		
Out.Pos.z=Out.Pos.z*focusb2- focusb ;			//basically scaling the hemisphere so that the equator goes around		
Out.Pos.xy*=vertscalexy;						//the limit of what you can see of the sphere.
normalize(Out.Pos);							//this line projects that mesh back onto the surface of the sphere.
									//note that the mesh does not appear scaled! think this is because when resize (*0.01)
									//the w component gets scaled too. Not entirely sure why that works but it does.

Out.ProjPoint = Out.Pos;		//get vector that will be used to project onto cube map
Out.ProjPoint.z+=focus;	

Out.Pos = mul(Out.Pos, wvp);	//convert model space mesh data to view space.
Out.Pos.z=max(0.0f,Out.Pos.z);	//to prevent cam clipping! 

   return Out;
};

// The pixel shader code:

PSOutput PShader (VSOutput In,PSOutput Out)
{ 
	float4 dummycol = tex2D(bumpSample , dummyuv);		//need to use 1st texture (dummy) so second will be used as cubemap
	Out.Col = texCUBE(cubeSample,-In.ProjPoint);	//THIS IS THE LINE THAT DOES WHAT WE WANT.
	Out.Col+= 0.00000000000001*dummycol;		//need to use the dummy texture, but don't want to see it's effect!
   	return Out;
};

// The following lines just put this together as a single technique
// with a single pass.

technique simplyOneColour
{  pass p1
   {  VertexShader = compile vs_2_0 VShader();
      PixelShader  = compile  ps_2_0 PShader();
   }
}

//need to have dummy tex, but now am specifying register for the other,
//i needn't sample from it, or even declare a sampler!

texture bumpTexture < string ResourceName = ""; >;		


//the actual texture we want to use:
texture cubeTexture
< string ResourceName = "";
  string Type = "CUBE";
>;

//note use of "register"- this basically tells it to use texture stage 1 from DBP:

samplerCUBE cubeSample:register(s1)  = sampler_state { texture = <cubeTexture>; };        

// The following lines are variables which are recognised and passed by the 
// application and often referred to as "untweaks".

matrix wvp : WorldViewProjection;

// The following lines are variables which can be set by the application
// (these are usually variables which the user may want to adjust from
// their program).

//float4 lightColour = {1.5, 1.5, 1.5, 1.0}; // {red, green, blue, alpha}
float focus = 0.0;	//sent from DBP.	focus from which PIXELS projected (gets close to 1 for close up i think)
float focusb =0.0;	//focus from which VERTICES are projected `2 focii are equal for model 2. different for model 1

float vertscalexy = 0.0;
float focusb2 = 0.0;

// The following lines define structures that are used as input and output
// to the vertex and pixel shader functions.

struct VSInput {
float4 Pos  : Position;
};

struct VSOutput {
float4 Pos : Position;
float3 ProjPoint : TEXCOORD0;
};

// The pixel shader does not need an input structure for this example.

struct PSOutput {
float4 Col : Color;
};


// texture stuff

texture bumpTexture < string ResourceName = ""; > ;		//need to have dummy tex, but now am specifying register for the other, i needn't
										//sample from it, or even declare a sampler!
//the actual texture we want to use:
texture cubeTexture
< string ResourceName = "";
  string Type = "CUBE";
>;

samplerCUBE cubeSample:register(s1)  = sampler_state { texture = <cubeTexture>; };

// The vertex shader code:

VSOutput VShader (VSInput In, VSOutput Out)
{  // Transforms the objects model coordinates to
   // screen space coordinates

//move vertices. - so hemisphere of original mesh is spread over only the part you can see.
// means that when you get close to the portal, effectively there is more detail.
	
Out.Pos = In.Pos;		
Out.Pos.z=Out.Pos.z*focusb2- focusb ;			//basically scaling the hemisphere so that the equator goes around		
Out.Pos.xy*=vertscalexy;						//the limit of what you can see of the sphere.
normalize(Out.Pos);							//this line projects that mesh back onto the surface of the sphere.
									//note that the mesh does not appear scaled! think this is because when resize (*0.01)
									//the w component gets scaled too. Not entirely sure why that works but it does.

Out.ProjPoint = Out.Pos;		//get vector that will be used to project onto cube map
Out.ProjPoint.z+=focus;	

Out.Pos = mul(Out.Pos, wvp);	//convert model space mesh data to view space.
Out.Pos.z=max(0.0f,Out.Pos.z);	//to prevent cam clipping! 

   return Out;
};

// The pixel shader code:

PSOutput PShader (VSOutput In,PSOutput Out)
{ 
	Out.Col = texCUBE(cubeSample,-In.ProjPoint);	
   	return Out;
};

// The following lines just put this together as a single technique
// with a single pass.

technique simplyOneColour
{  pass p1
   {  VertexShader = compile vs_2_0 VShader();
      PixelShader  = compile  ps_2_0 PShader();
   }
}

normalize(Out.Pos);

struct PSOutput{ float4 col : color; };

PSOutput PShader(PSOutput Out)
{ float red = 0.5<1.0 ? 0.0 : 1.0;
  float blue = 0.5<1.0;
  Out.col = float4 ( red, 1.0-red, blue, 1.0 );
  return Out;
}

technique t0
{ pass p0
  { PixelShader  = compile  ps_2_0 PShader();
  }
}

Rem Project: atmosphere and groundbox shader
Rem Created: 29/04/2010 22:14:41

Rem ***** Main Source File *****



`want to make an atmospheric fogging shader.
`because atmosphere tapers off exponentially with altitude, can stick this in too!
`equations come out quite nicely
`will have cool gradual darkening of sky as increase altitude, glow around horizon etc.

`also, hopefully can have infinite tiling of ground plane projected onto skybox lower half.
`may run into problems with /0 error. see how it goes!

`next up? put same shader for other objects, terrain etc.
`allow scaling of sunlight, so sky not blue at night etc
`think about angular distribution of scattering
`add skybox, or sun object.
`terrain.
`can i get skybox drawn before all other objects?
`use of multiple texture levels to reduce tiled effect


set display mode 1280,720,32,1
sync on
sync rate 0
set camera fov 70
autocam off

make object cube 1,100
scale object 1,100,-100,100
`load image "Marble_107_seamless_sample.jpg",1
load image "baked04.JPG",1
texture object 1,1
`load effect "FX/myfx.fx",1,0  `OMFG! it totally works!
`load effect "FX/myfx1.fx",1,0    `with black above horizon. totally works too!
`load effect "FX/myfx2.fx",1,0    `with cam height sent to it
`load effect "FX/myfx3.fx",1,0 `was doing it totally wrong! exp(exp) is not exp(x)exp(y), it's (exp(x))^y (duh)
`load effect "FX/myfx4.fx",1,0 `works!
`load effect "FX/myfx5.fx",1,0 `add colour
`load effect "FX/myfx6.fx",1,0 `use vector for cam pos and pass to shader
load effect "FX/myfx7.fx",1,0 `try to swap co-ords around to get behaviour right
set object effect 1,1

position camera 0,1,0
point camera 0,1,1
set camera range 0.1,1000

camheight#=1.0
`dim campos(3) as float
campos_vec=1
null=make vector4(campos_vec)

`test obj
`make object sphere 2,20
make object box 2,5,0.2,5
position object 2,0,0.1,0  `so bottom is at 0
disable object zdepth 2



   timenow as dword
    timelast as dword
    timediff as dword
    timenow=timer()

   `Start loop
      do

      timelast=timenow
      timenow=timer()
      timediff=timenow-timelast



text 0,0,str$(screen fps())


mx#=wrapvalue(mx#+0.1*mousemovey())
my#=wrapvalue(my#+0.1*mousemovex())
rotate camera mx#,my#,0.0

mc=mouseclick()
move camera (((mc&&1)<<1)-(mc&&2))*0.01*timediff
camheight#=camera position y()
camheight#=camheight#*(1.0+(upkey()-downkey())*0.01)
if camheight#<1.0 then camheight#=1.0
position camera camera position x(),camheight#,camera position z()
position object 1,camera position x(),camheight#,camera position z()

set vector4 campos_vec,camera position x(),camera position y(),camera position z(),0.0


`pass in this info to shader.
`require - cam h , transmittance straight up, transmittance straight down to ground. pos for different colours.
`shader can work out the rest

`set effect constant float 1,"Camheight",camheight# `send camera height to shader.
set effect constant vector 1,"CamPos",campos_vec

`fogging goes as exp(-h) where h is height. take ground as 0
decayconst#=80.0  `length over which atmos decays with altitude
temp#=(2.71^-(camheight#/decayconst#))
up_part#=2.71^-temp# `transmittance to space (straight up)
`down_part#=2.71^(temp#-1.0)
down_part#=0.36788/up_part#   `1/e   `transmittance to ground. (straight down)

`NB that should scale this somehow to taste.
`is finite amount of atmosphere. currently, transmittance to ground goes to 1/e at infinity. in reality
`will want probably less than this, but values not too wacky!

up_part#=up_part#^0.6   `universal scaling factor.
down_part#=down_part#^0.6  `larger means thicker atmos

`ink 0,0
`text 1,11,str$(camheight#)
`text 1,21,str$(up_part#)
`text 1,31,str$(down_part#)
ink rgb(100,255,100),0
text 0,10,"ALTITUDE="+str$(camheight#)
text 0,20,"(BLUE) TRANSMITTANCE SPACE TO CAM ="+str$(up_part#)
text 0,30,"(BLUE) TRANSMITTANCE GROUND TO CAM="+str$(down_part#)

set effect constant float 1,"up_part",up_part#
set effect constant float 1,"down_part",down_part#

sync
loop

matrix wvp : WorldViewProjection;
matrix world : World;


float4 CamPos=0.0; 	//only want 3vec, but DBP doesn't like passing those to shaders. may as well use 4
float up_part=0.0;
float down_part=0.0;

struct VSInput {
float4 Pos  : Position;
float2 UV : TEXCOORD0;
};

struct VSOutput {
float4 Pos : Position;
float2 UV : TEXCOORD0;
float4 wPos : TEXCOORD1;
};

// The pixel shader does not need an input structure for this example.

struct PSOutput { float4 Col : Color; };

// The vertex shader code:

VSOutput VShader (VSInput In, VSOutput Out)
{  // Transforms the objects model coordinates to
   // screen space coordinates
   Out.Pos = mul(In.Pos, wvp);
//   Out.wPos = mul(In.Pos, world);	
Out.wPos = In.Pos;	//it's that simple
   Out.UV = In.UV;			//not using currently
   return Out;
};


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




// The pixel shader code:

PSOutput PShader (VSOutput In,PSOutput Out)
{  // Just outputs the chosen colour without additional processing.
   //Out.Col = lightColour;
	//Out.Col = tex2D(Base,In.UV); 
//Out.Col = tex2Dproj(Base,In.wPos); 	//cool effect but not what we want

float2 newuv=In.wPos.zx;		//this stuff can go in vert shader, with scaling by campos y. also campos xz 2vec?
newuv=-CamPos.y*newuv/In.wPos.y;
newuv[0]=newuv[0]-CamPos.z;	
newuv[1]=newuv[1]-CamPos.x;

//Out.Col = In.wPos.y > 0? 0:tex2D(Base,newuv);

float invsintheta=pow(dot(In.wPos.xyz,In.wPos.xyz),0.5) / abs(In.wPos.y); 			//hyp/opp =sumsq / y
													//should put as texture. can also use dither on texture.
float spacetrans=pow(up_part,invsintheta);
float groundtrans=pow(down_part,invsintheta);

float spacetransrg=pow(spacetrans,0.5);
float groundtransrg=pow(groundtrans,0.5);

//scale things arbitrarily..	- actually do it in DBP.
//groundtrans=pow(groundtrans,2.0);
//spacetrans=pow(spacetrans,2.0);

//float4 spacetransrgb = float4(spacetrans,spacetransrg,spacetransrg,1.0f);	//mars!
//float4 groundtransrgb = float4(groundtrans,groundtransrg,groundtransrg,1.0f);
float4 spacetransrgb = float4(spacetransrg,spacetransrg,spacetrans,1.0f);
float4 groundtransrgb = float4(groundtransrg,groundtransrg,groundtrans,1.0f);



//float4 spacecol=(1.0-spacetrans);								//scalar version (greyscale sky)
//float4 groundcol=(1.0-groundtrans)+groundtrans*tex2D(Base,newuv);

float4 spacecol=(1.0-spacetransrgb);
float4 groundcol=(1.0-groundtransrgb)+groundtransrgb*tex2D(Base,newuv);



Out.Col = In.wPos.y < 0? spacecol:groundcol;


   return Out;
};

// The following lines just put this together as a single technique
// with a single pass.

technique simplyOneColour
{  pass p1
   {  VertexShader = compile vs_2_0 VShader();
      PixelShader  = compile  ps_2_0 PShader();
   }
}

matrix wvp : WorldViewProjection;

// variables for blur vector1

	float transx = 0.01;
	float transy = 0.01;
	float minx = 0.5;
	float maxx = 1.0;
	float miny = 0.5;
	float maxy = 1.0;
	float centralx = 0.75;
	float centraly = 0.75;
        float blend_dist = 0.25;
 float4 step = {0.01,0.01,0.0,0.0};

texture baseTexture < string ResourceName = ""; >;
sampler baseSample = sampler_state
{  Texture = <baseTexture>;
   ADDRESSU = WRAP;
   ADDRESSV = WRAP;
   MIPFILTER = LINEAR;
   MINFILTER = LINEAR;
   MAGFILTER = LINEAR;
};

struct VSInput
{   float4 Pos  : Position; 
    float4 UV   : TEXCOORD0;
};

struct VSOutput 
{ float4 Pos     : Position; 
  float4 UV      : TEXCOORD0;
  float4 Col     : COLOR;
};

struct PSInput
{  float4 Col  : Color;
   float2 UV  : TEXCOORD0;
};

struct PSOutput
{   float4 Col : Color; };

VSOutput VShader (VSInput In, VSOutput Out)
{  // Transforms the objects model coordinates to
   // screen space coordinates
   Out.Pos = mul(In.Pos, wvp);
   return Out;
};


////////////////////////////////////////////////////////////////////////////////

PSOutput PShader ( PSInput In, PSOutput Out)

{ 
   float4 fin = {0.0,0.0,0.0,0.0};

   float4 col = tex2D(baseSample, In.UV );
    fin.x = fin.x + col.x;
    fin.y = fin.y + col.y;
    fin.z = fin.z + col.z;

   if (In.UV.x>minx && In.UV.x<maxx )
   {
   if (In.UV.y>miny && In.UV.y<maxy )
   {

 // this is the line that works if left here but stops working //when moved up

 float4 step = {0.01,0.01,0,0};

   float4 col2 = tex2D(baseSample, float2(In.UV.x-step.x,In.UV.y-step.y) );
    fin.x += col2.x;
    fin.y += col2.y;
    fin.z += col2.z;
   float4 col3 = tex2D(baseSample, float2(In.UV.x+step.x,In.UV.y+step.y) );
    fin.x += col3.x;
    fin.y += col3.y;
    fin.z += col3.z;
   float4 col4 = tex2D(baseSample, float2(In.UV.x-(step.x*2),In.UV.y-(step.y*2)) );
    fin.x += col4.x;
    fin.y += col4.y;
    fin.z += col4.z;
   float4 col5 = tex2D(baseSample, float2(In.UV.x+(step.x*2),In.UV.y+(step.y*2)) );
    fin.x += col5.x;
    fin.y += col5.y;
    fin.z += col5.z;
   float4 col6 = tex2D(baseSample, float2(In.UV.x-(step.x*4),In.UV.y-(step.y*4)) );
    fin.x += col6.x;
    fin.y += col6.y;
    fin.z += col6.z;
   float4 col7 = tex2D(baseSample, float2(In.UV.x+(step.x*4),In.UV.y+(step.y*4)) );
    fin.x += col7.x;
    fin.y += col7.y;
    fin.z += col7.z;
   float4 col8 = tex2D(baseSample, float2(In.UV.x-(step.x*6),In.UV.y-(step.y*6)) );
    fin.x += col8.x;
    fin.y += col8.y;
    fin.z += col8.z;
   float4 col9 = tex2D(baseSample, float2(In.UV.x+(step.x*6),In.UV.y+(step.y*6)) );
    fin.x += col9.x;
    fin.y += col9.y;
    fin.z += col9.z;
   float4 col10 = tex2D(baseSample, float2(In.UV.x-(step.x*3),In.UV.y-(step.y*3)) );
    fin.x += col10.x;
    fin.y += col10.y;
    fin.z += col10.z;

    fin.x = fin.x*0.1;
    fin.y = fin.y*0.1;
    fin.z = fin.z*0.1;

    fin.w = 1.0;
    float dist = sqrt((In.UV.x-centralx)*(In.UV.x-centralx)+(In.UV.y-centraly)*(In.UV.y-centraly));
    if (dist > ( 7.0*blend_dist/8.0) ) 
    {
    fin.w = (-8.0/blend_dist)*(dist-(7.0*blend_dist/8.0))+1.0;
    }
}
}
   Out.Col = fin;
   return Out;

};

/////////////////////////////////////////////////////////////////////////////////


technique myfirstshader1
{  pass p1
   {  VertexShader = compile vs_1_1 VShader();
      PixelShader = compile ps_2_0 PShader();
	}
}

matrix wvp : WorldViewProjection;

// variables for blur vector1

	float minx = 0.5;
	float maxx = 1.0;
	float miny = 0.5;
	float maxy = 1.0;
	float centralx = 0.75;
	float centraly = 0.75;
        float blend_dist = 0.25;

texture baseTexture < string ResourceName = ""; >;
sampler baseSample = sampler_state
{  Texture = <baseTexture>;
   ADDRESSU = WRAP;
   ADDRESSV = WRAP;
   MIPFILTER = LINEAR;
   MINFILTER = LINEAR;
   MAGFILTER = LINEAR;
};

struct VSInput
{   float4 Pos  : Position; 
    float4 UV   : TEXCOORD0;
};

struct VSOutput 
{ float4 Pos     : Position; 
  float4 UV      : TEXCOORD0;
  float4 Col     : COLOR;
};

struct PSInput
{  float4 Col  : Color;
   float2 UV  : TEXCOORD0;
};

struct PSOutput
{   float4 Col : Color; };

VSOutput VShader (VSInput In, VSOutput Out)
{  // Transforms the objects model coordinates to
   // screen space coordinates
   Out.Pos = mul(In.Pos, wvp);
   return Out;
};


////////////////////////////////////////////////////////////////////////////////

PSOutput PShader ( PSInput In, PSOutput Out)

{ 
   float4 fin = {0.0,0.0,0.0,0.0};

   float4 col = tex2D(baseSample, In.UV );
    fin.x = fin.x + col.x;
    fin.y = fin.y + col.y;
    fin.z = fin.z + col.z;

   if (In.UV.x>minx && In.UV.x<maxx )
   {
   if (In.UV.y>miny && In.UV.y<maxy )
   {

  float4 step = {0.01,0.01,0,0};

   float4 col2 = tex2D(baseSample, float2(In.UV.x-step.x,In.UV.y-step.y) );
    fin.x += col2.x;
    fin.y += col2.y;
    fin.z += col2.z;
   float4 col3 = tex2D(baseSample, float2(In.UV.x+step.x,In.UV.y+step.y) );
    fin.x += col3.x;
    fin.y += col3.y;
    fin.z += col3.z;
   float4 col4 = tex2D(baseSample, float2(In.UV.x-(step.x*2),In.UV.y-(step.y*2)) );
    fin.x += col4.x;
    fin.y += col4.y;
    fin.z += col4.z;
   float4 col5 = tex2D(baseSample, float2(In.UV.x+(step.x*2),In.UV.y+(step.y*2)) );
    fin.x += col5.x;
    fin.y += col5.y;
    fin.z += col5.z;
   float4 col6 = tex2D(baseSample, float2(In.UV.x-(step.x*4),In.UV.y-(step.y*4)) );
    fin.x += col6.x;
    fin.y += col6.y;
    fin.z += col6.z;
   float4 col7 = tex2D(baseSample, float2(In.UV.x+(step.x*4),In.UV.y+(step.y*4)) );
    fin.x += col7.x;
    fin.y += col7.y;
    fin.z += col7.z;
   float4 col8 = tex2D(baseSample, float2(In.UV.x-(step.x*6),In.UV.y-(step.y*6)) );
    fin.x += col8.x;
    fin.y += col8.y;
    fin.z += col8.z;
   float4 col9 = tex2D(baseSample, float2(In.UV.x+(step.x*6),In.UV.y+(step.y*6)) );
    fin.x += col9.x;
    fin.y += col9.y;
    fin.z += col9.z;
   float4 col10 = tex2D(baseSample, float2(In.UV.x-(step.x*3),In.UV.y-(step.y*3)) );
    fin.x += col10.x;
    fin.y += col10.y;
    fin.z += col10.z;

    fin.x = fin.x*0.1;
    fin.y = fin.y*0.1;
    fin.z = fin.z*0.1;

    fin.w = 1.0;
    float dist = sqrt((In.UV.x-centralx)*(In.UV.x-centralx)+(In.UV.y-centraly)*(In.UV.y-centraly));
    if (dist > ( 7.0*blend_dist/8.0) ) 
    {
    fin.w = (-8.0/blend_dist)*(dist-(7.0*blend_dist/8.0))+1.0;
    }
}
}
   Out.Col = fin;
   return Out;

};

/////////////////////////////////////////////////////////////////////////////////


technique myfirstshader1
{  pass p1
   {  VertexShader = compile vs_1_1 VShader();
      PixelShader = compile ps_2_0 PShader();
	}
}

    fin.x += col2.x;
    fin.y += col2.y;
    fin.z += col2.z;

    fin.xyz += col2.xyz;

//////////////////////////////////////////////////////
// Geometry Shader
// Sebastian Pauli, May 2010
////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
// 	->	VARIABLES
////////////////////////////////////////////////////////////

float4x4 	WVP 		: WORLDVIEWPROJECTION;

////////////////////////////////////////////////////////////
// 	->	TEXTURES
////////////////////////////////////////////////////////////

texture ModelTexture < string ResourceName = ""; >;
sampler2D textureSampler = sampler_state
{
    	Texture = (ModelTexture);
    	MagFilter = Linear;
    	MinFilter = Linear;
    	AddressU = Wrap;
    	AddressV = Wrap;
};

///////////////////////////////////////////////////////////////
// 	->	STRUCTS
///////////////////////////////////////////////////////////////
struct VertexShaderInput
{
    	float4 Position 		: POSITION0;
    	float2 TextureCoordinate 	: TEXCOORD0;
};

struct VertexShaderOutput
{
    	float4 Position 		: POSITION0;
    	float2 TextureCoordinate 	: TEXCOORD0;
};

//////////////////////////////////////////////////////////////
// 	->	FUNCTIONS
//////////////////////////////////////////////////////////////
VertexShaderOutput VertexShaderFunction( VertexShaderInput input )
{
    	VertexShaderOutput output;

    	output.Position = mul( input.Position, WVP );
    	output.TextureCoordinate = input.TextureCoordinate;

    	return output;
}

float4 PixelShaderFunction( VertexShaderOutput input ) : COLOR0
{
    	float4 textureColor = tex2D( textureSampler, input.TextureCoordinate );

	float4 color = saturate(textureColor);

	return color;
}

/////////////////////////////////////////////////////////////
// 	->	TECHNIQUES
/////////////////////////////////////////////////////////////

technique TransparencyTextured
{
    	pass Pass1
    	{
        	VertexShader = compile 	vs_1_1 	VertexShaderFunction();
        	PixelShader = compile 	ps_1_1 	PixelShaderFunction();
    	}
}