Sorry your browser is not supported!

//
// Bubble
//

matrix worldi : WorldIT;
matrix wvp : WorldViewProjection;
matrix mworld : World;
matrix viewInv : ViewIT;
float4 lightPos : Position < string UIPosition = "Light Position"; >;
float ticks : Time;

string XFile = "sphere.x";
texture colorTexture < string Name = "images/water_001.bmp"; >;

pixelshader pNIL;

struct VS_INPUT
{
    float3 Position     : POSITION;
    float4 UV           : TEXCOORD0;
    float3 Normal       : NORMAL;
};

struct VS_OUTPUT
{
    float4 HPosition    : POSITION;
    float4 TexCoord0    : TEXCOORD0;
    float4 diffCol      : COLOR0;
    float4 specCol      : COLOR1;
};

float4 ambiColor={0.2f, 0.2f, 0.2f, 1.0f};
float4 surfColor={0.8f, 0.8f, 0.8f, 0.5f};
float4 liteColor={1.0f, 1.0f, 1.0f, 1.0f};
float specExpon=22.0;
float horizontal=0.2;
float vertical=3.0;
float timeScale=0.005;

VS_OUTPUT VShade(VS_INPUT IN)
{
    VS_OUTPUT   OUT;

    // world normal
    float3 worldNormal = mul(IN.Normal, mworld).xyz;
    worldNormal = normalize(worldNormal);
    float timeNow = ((ticks/100.0)/timeScale);

    //build float4
    float4 tempPos;
    tempPos.xyz = IN.Position.xyz;
    tempPos.w   = 1.0;

    float iny = tempPos.y * vertical + timeNow;
    float wiggleX = sin(iny) * horizontal;
    float wiggleY = cos(iny) * horizontal; // deriv
    worldNormal.y = worldNormal.y + wiggleY;
    worldNormal = normalize(worldNormal);
    tempPos.x = tempPos.x + wiggleX;

    //compute worldspace position
    float3 worldSpacePos = mul(tempPos,mworld).xyz;
    float3 LightVec = normalize(lightPos - worldSpacePos);
    float ldn = dot(LightVec,worldNormal);

    float diffComp = max(0,ldn);
    float4 diffContrib = surfColor * ( diffComp * liteColor + ambiColor);
    OUT.diffCol = diffContrib;
    OUT.diffCol.w = 1.0;
    OUT.TexCoord0 = IN.UV;

    float3 EyePos = viewInv[3].xyz;
    float3 vertToEye = normalize(EyePos - worldSpacePos);
    float3 halfAngle = normalize(vertToEye + LightVec);

    float hdn = pow(max(0,dot(halfAngle,worldNormal)),specExpon);
    OUT.specCol = hdn * liteColor;

    // transform into homogeneous-clip space
    OUT.HPosition = mul(tempPos, wvp);

    return OUT;
}

uniform sampler   sampler0 = 
sampler_state 
{
    texture = <colorTexture>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
    AddressW = Wrap;
};

struct PS_INPUT
{
    float4 TexCoord0    : TEXCOORD0;
    float4 diffCol      : COLOR0;
    float4 specCol      : COLOR1;
};

struct pixelOutput
{
  float4 col : COLOR;
};

pixelOutput MrWigglePS_t(PS_INPUT IN)
{
    // Lookup the colorMap texture
    pixelOutput OUT; 
    float4 result = IN.diffCol * tex2D( sampler0, IN.TexCoord0) + IN.specCol;
    OUT.col = result;
    return OUT;
}

//////////////////////////////////////
// Techniques specs follow
//////////////////////////////////////
technique t0
{
    pass p0
    {
        VertexShader = compile vs_2_0 VShade();
        PixelShader = compile ps_1_1 MrWigglePS_t();

        // Z-buffering not to be used
        ZEnable      = false;
        ZWriteEnable = false;
        CullMode     = CW;

        // enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = SRCALPHA;
        DestBlend        = INVSRCALPHA;

        MinFilter[0] = Linear;
        MagFilter[0] = Linear;
        MipFilter[0] = Linear;
    }
    pass p1
    {
        VertexShader = compile vs_2_0 VShade();
        PixelShader = compile ps_1_1 MrWigglePS_t();

        // Z-buffering not to be used
        ZEnable      = false;
        ZWriteEnable = false;
        CullMode     = CCW;

        // enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = SRCALPHA;
        DestBlend        = INVSRCALPHA;

        MinFilter[0] = Linear;
        MagFilter[0] = Linear;
        MipFilter[0] = Linear;
    }
}

// Green Gandalf's simple reflection shader
// Created 25 October 2006.

matrix wvp    : WorldViewProjection;
matrix mw     : World;
float3 eyePos : CameraPosition;


float reflectRatio = 0.8;

texture BaseTexture < string ResourceName = "lead.jpg"; >;

sampler2D   BaseSample = sampler_state 
{  texture = <BaseTexture>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
   ADDRESSU = WRAP;
   ADDRESSV = WRAP;
  };

texture EnvironmentTexture
 < string Type = "cube"; string ResourceName = "SnowGG.dds"; >;

sampler EnvironmentSample = sampler_state
{  Texture = (EnvironmentTexture);
   MAGFILTER = LINEAR;
   MINFILTER = LINEAR;
   MIPFILTER = LINEAR;
   ADDRESSU = WRAP;
   ADDRESSV = WRAP;
   ADDRESSW = WRAP;
};

struct VSInput1
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
  float3 Normal: NORMAL;
};

struct VSInput2
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
};

struct VSOutput1
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
  float3 Normal: TEXCOORD1;
  float3 View:   TEXCOORD2;
};
struct VSOutput2
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
  float3 Dir:    TEXCOORD3;
};

struct PSInput1
{ float2 UV:     TEXCOORD0;
  float3 Normal: TEXCOORD1;
  float3 View:   TEXCOORD2;
};

struct PSInput2
{ float2 UV:     TEXCOORD0;
  float3 Dir:    TEXCOORD3;
};

struct PSOutput { float4 Colour: COLOR; };

VSOutput1 VShader1(VSInput1 In, VSOutput1 Out)
{ Out.Pos = mul(In.Pos, wvp);
  Out.UV = In.UV;
  Out.Normal = normalize(mul(In.Normal, mw));
  float4 temp = mul(In.Pos, mw);
  Out.View = normalize(eyePos - temp.xyz);
  return Out;
}

VSOutput2 VShader2(VSInput2 In, VSOutput2 Out)
{ Out.Pos = mul(In.Pos, wvp);
  Out.UV = In.UV;
  float4 temp = mul(In.Pos, mw);
  Out.Dir = temp.xyz;
  return Out;
}

PSOutput PShader1(PSInput1 In, PSOutput Out)
{ float3 reflectDir = reflect(-In.View, In.Normal);
  float4 reflectionColour = texCUBE(EnvironmentSample, reflectDir);
  float4 baseColour = tex2D(BaseSample, In.UV);
  Out.Colour = lerp(baseColour, reflectionColour, reflectRatio);
  return Out;
}
 
PSOutput PShader2(PSInput2 In, PSOutput Out)
{ Out.Colour = texCUBE(EnvironmentSample, In.Dir);
  return Out;
}

technique Reflect
{ pass one
  { VertexShader = compile vs_2_0 VShader1();
    PixelShader  = compile ps_2_0 PShader1();
  }
}

technique Environment
{ pass one
  { VertexShader = compile vs_2_0 VShader2();
    PixelShader  = compile ps_2_0 PShader2();
  }
}

matrix worldi : WorldIT;
matrix wvp : WorldViewProjection;
matrix mworld : World;
matrix viewInv : ViewIT;
float3 eyePos : CameraPosition;
float4 lightPos : Position < string UIPosition = "Light Position"; >;
float ticks : Time;
float reflectRatio = 0.8;

string XFile = "sphere.x";
texture colorTexture < string Name = "images/water_001.bmp"; >;
texture BaseTexture < string ResourceName = "lead.jpg"; >;

sampler2D   BaseSample = sampler_state 
{  texture = <BaseTexture>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
   ADDRESSU = WRAP;
   ADDRESSV = WRAP;
  };

texture EnvironmentTexture
 < string Type = "cube"; string ResourceName = "SnowGG.dds"; >;

sampler EnvironmentSample = sampler_state
{  Texture = (EnvironmentTexture);
   MAGFILTER = LINEAR;
   MINFILTER = LINEAR;
   MIPFILTER = LINEAR;
   ADDRESSU = WRAP;
   ADDRESSV = WRAP;
   ADDRESSW = WRAP;
};

struct VSInput1
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
  float3 Normal: NORMAL;
};

struct VSInput2
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
};

struct VSOutput1
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
  float3 Normal: TEXCOORD1;
  float3 View:   TEXCOORD2;
};
struct VSOutput2
{ float4 Pos:    POSITION;
  float2 UV:     TEXCOORD0;
  float3 Dir:    TEXCOORD3;
};

struct VS_INPUT
{
    float3 Position     : POSITION;
    float4 UV           : TEXCOORD0;
    float3 Normal       : NORMAL;
};

struct VS_OUTPUT
{
    float4 HPosition    : POSITION;
    float4 TexCoord0    : TEXCOORD0;
    float4 diffCol      : COLOR0;
    float4 specCol      : COLOR1;
};

float4 ambiColor={0.2f, 0.2f, 0.2f, 1.0f};
float4 surfColor={0.8f, 0.8f, 0.8f, 0.5f};
float4 liteColor={1.0f, 1.0f, 1.0f, 1.0f};
float specExpon=22.0;
float horizontal=0.2;
float vertical=3.0;
float timeScale=0.005;

VS_OUTPUT VShade(VS_INPUT IN)
{
    VS_OUTPUT   OUT;

    // world normal
    float3 worldNormal = mul(IN.Normal, mworld).xyz;
    worldNormal = normalize(worldNormal);
    float timeNow = ((ticks/100.0)/timeScale);

    //build float4
    float4 tempPos;
    tempPos.xyz = IN.Position.xyz;
    tempPos.w   = 1.0;

    float iny = tempPos.y * vertical + timeNow;
    float wiggleX = sin(iny) * horizontal;
    float wiggleY = cos(iny) * horizontal; // deriv
    worldNormal.y = worldNormal.y + wiggleY;
    worldNormal = normalize(worldNormal);
    tempPos.x = tempPos.x + wiggleX;

    //compute worldspace position
    float3 worldSpacePos = mul(tempPos,mworld).xyz;
    float3 LightVec = normalize(lightPos - worldSpacePos);
    float ldn = dot(LightVec,worldNormal);

    float diffComp = max(0,ldn);
    float4 diffContrib = surfColor * ( diffComp * liteColor + ambiColor);
    OUT.diffCol = diffContrib;
    OUT.diffCol.w = 1.0;
    OUT.TexCoord0 = IN.UV;

    float3 EyePos = viewInv[3].xyz;
    float3 vertToEye = normalize(EyePos - worldSpacePos);
    float3 halfAngle = normalize(vertToEye + LightVec);

    float hdn = pow(max(0,dot(halfAngle,worldNormal)),specExpon);
    OUT.specCol = hdn * liteColor;

    // transform into homogeneous-clip space
    OUT.HPosition = mul(tempPos, wvp);

    return OUT;
}

uniform sampler   sampler0 = 
sampler_state 
{
    texture = <colorTexture>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
    AddressW = Wrap;
};

struct PSInput1
{ float2 UV:     TEXCOORD0;
  float3 Normal: TEXCOORD1;
  float3 View:   TEXCOORD2;
};

struct PSInput2
{ float2 UV:     TEXCOORD0;
  float3 Dir:    TEXCOORD3;
};

struct PSOutput { float4 Colour: COLOR; };

VSOutput1 VShader1(VSInput1 In, VSOutput1 Out)
{ Out.Pos = mul(In.Pos, wvp);
  Out.UV = In.UV;
  Out.Normal = normalize(mul(In.Normal, mw));
  float4 temp = mul(In.Pos, mw);
  Out.View = normalize(eyePos - temp.xyz);
  return Out;
}

VSOutput2 VShader2(VSInput2 In, VSOutput2 Out)
{ Out.Pos = mul(In.Pos, wvp);
  Out.UV = In.UV;
  float4 temp = mul(In.Pos, mw);
  Out.Dir = temp.xyz;
  return Out;
}

PSOutput PShader1(PSInput1 In, PSOutput Out)
{ float3 reflectDir = reflect(-In.View, In.Normal);
  float4 reflectionColour = texCUBE(EnvironmentSample, reflectDir);
  float4 baseColour = tex2D(BaseSample, In.UV);
  Out.Colour = lerp(baseColour, reflectionColour, reflectRatio);
  return Out;
}
 
PSOutput PShader2(PSInput2 In, PSOutput Out)
{ Out.Colour = texCUBE(EnvironmentSample, In.Dir);
  return Out;
}

struct PS_INPUT
{
    float4 TexCoord0    : TEXCOORD0;
    float4 diffCol      : COLOR0;
    float4 specCol      : COLOR1;
};

struct pixelOutput
{
  float4 col : COLOR;
};

pixelOutput MrWigglePS_t(PS_INPUT IN)
{
    // Lookup the colorMap texture
    pixelOutput OUT; 
    float4 result = IN.diffCol * tex2D( sampler0, IN.TexCoord0) + IN.specCol;
    OUT.col = result;
    return OUT;
}

//////////////////////////////////////
// Techniques specs follow
//////////////////////////////////////
technique t0
{
    pass p0
    {
        VertexShader = compile vs_2_0 VShade();
        PixelShader = compile ps_1_1 MrWigglePS_t();

        // Z-buffering not to be used
        ZEnable      = false;
        ZWriteEnable = false;
        CullMode     = CW;

        // enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = SRCALPHA;
        DestBlend        = INVSRCALPHA;

        MinFilter[0] = Linear;
        MagFilter[0] = Linear;
        MipFilter[0] = Linear;
    }
    pass p1
    {
        VertexShader = compile vs_2_0 VShade();
        PixelShader = compile ps_1_1 MrWigglePS_t();

        // Z-buffering not to be used
        ZEnable      = false;
        ZWriteEnable = false;
        CullMode     = CCW;

        // enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = SRCALPHA;
        DestBlend        = INVSRCALPHA;

        MinFilter[0] = Linear;
        MagFilter[0] = Linear;
        MipFilter[0] = Linear;
    }
}

technique Reflect
{ pass one
  { VertexShader = compile vs_2_0 VShader1();
    PixelShader  = compile ps_2_0 PShader1();
  }
}

technique Environment
{ pass one
  { VertexShader = compile vs_2_0 VShader2();
    PixelShader  = compile ps_2_0 PShader2();
  }
}

//====================================================
// Depth Of Field
//====================================================

//tweaks
   float DOF_NereFocus = 50.0f;
   float DOF_FarFocus = 200.0f;

//structs 
   struct IN_DOF
     {
      float4 Pos:POSITION;
     };
   struct OUT_DOF
     {
      float4 OPos:POSITION; 
      float  Depth:TEXCOORD1;
     };

//vertex shader
   OUT_DOF VS_DOF(IN_DOF IN)
     {
       OUT_DOF OUT;
       OUT.OPos = mul(IN.Pos,WorldVP); 
       OUT.Depth = OUT.OPos.z; 
       return OUT;
     }

//pixel shader
   float4 PS_DOF(OUT_DOF IN) : COLOR
     {
       float CloseDepth=saturate(1-(IN.Depth/DOF_NereFocus));	
       float FarDepth=CloseDepth+saturate((-DOF_NereFocus+IN.Depth)/DOF_FarFocus);	
       return FarDepth;
     }

// techniques   
    technique CamDepth
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_DOF(); 
 	pixelShader  = compile ps_2_0 PS_DOF();	
      }
      }

//====================================================

float hue = 0;

// texture sampler - uses texture stage 0 of object

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

struct PSInput {  float2 UV : TEXCOORD0; };

struct PSOutput {  float4 Col : COLOR; };



void RGBtoHSV( float r, float g, float b, out float h, out float s, out float v )
{
	float min1, max1, delta;
	min1 = min( r, g );
	min1 = min(min1,b);
	max1 = max( r, g);
	max1 = max(max1,b);
	
	v = max1;				// v
	delta = max1 - min1;
	
	if( max1 != 0 )
		s = delta / max1;		// s
	else {
		// r = g = b = 0		// s = 0, v is undefined
		s = 0;
		h = -1;
		
	}
	if( r == max1 )
		h = ( g - b ) / delta;		// between yellow & magenta
	else if( g == max1 )
		h = 2 + ( b - r ) / delta;	// between cyan & yellow
	else
		h = 4 + ( r - g ) / delta;	// between magenta & cyan
	h *= 60;				// degrees
	if( h < 0 )
		h += 360;
	return;
}

void HSVtoRGB( out float r, out float g, out float b, float h, float s, float v )
{
	int i;
	float f, p, q, t;

	if( s == 0 ) {
		// achromatic (grey)
		r = g = b = v;
	}

	h /= 60;			// sector 0 to 5
	i = floor( h );
	f = h - i;			// factorial part of h
	p = v * ( 1 - s );
	q = v * ( 1 - s * f );
	t = v * ( 1 - s * ( 1 - f ) );

	if (i = 0) {
		r = v;
		g = t;
		b = p;
		} 
	else if (i = 1) {
		r = q;
		g = v;
		b = p;
		}
	else if (i = 2){
		r = p;
		g = v;
		b = t;
		}
	else if (i = 3){
		r = p;
		g = q;
		b = v;
		}
	else if (i = 4){
		r = t;
		g = p;
		b = v;
		}
	else{		// case 5:
		r = v;
		g = p;
		b = q;
		}
	return;
}



PSOutput PShaderHue(PSInput In, PSOutput Out)
{  
   float4 colour = tex2D(baseSample, In.UV);
   float r,g,b,h,s,v;
   r = colour.r;
   g = colour.g;
   b = colour.b;
   RGBtoHSV(r,g,b,h,s,v);
   HSVtoRGB(r,g,b,h+hue,s,v);
   colour.r = r;
   colour.g = g;
   colour.b = b;
   Out.Col = colour;
   //HSVtoRGB( out float r, out float g, out float b, float h, float s, float v
   //RGBtoHSV( float r, float g, float b, out float h, out float s, out float v )
   return Out;
}

technique fadeToColour
{  pass p0
   {  PixelShader  = compile ps_2_0 PShaderHue();
   }
}

make object cube 1, 10
load image "blue.png",1
texture object 1,1

load effect "timshsv.fx", 1, 0
set object effect 1, 1

do
    if shiftkey()
        hueshift# = wrapvalue(hueshift#+0.1)
        text 20,20, str$(hueshift#)
        set effect constant float 1,"hue",hueshift#
    endif
     yshift# = wrapvalue(yshift#+0.1)
    xshift# = wrapvalue(xshift#+0.1)
    yrotate object 1, 45
    xrotate object 1,xshift#
    yrotate object 1,yshift#
    sync
loop

// Green Gandalf's hue cycling shader
//
// As "hue" cycles through 0 to 360, the colours cycle through
// colours in the sequence red, yellow, green, cyan, blue,
// magenta, and back to red.

// Created 24 January 2007.

float hue = 0.0;  // this must be supplied by the application

float4 scale = {0.0, 0.333333, 0.666667, 0.00277778};

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

struct PSInput {  float2 UV : TEXCOORD0; };

struct PSOutput { float4 Col : COLOR; };

PSOutput PShader(PSInput In, PSOutput Out)
{  float3 C = tex2D(baseSample, In.UV);
   float lower = min(C.r, min(C.g, C.b));
   float range = max(C.r, max(C.g, C.b)) - lower;
   Out.Col = range * saturate(abs(frac(-hue * scale.a + scale) - 0.5) * 6.0 - 1.0) + lower;
   return Out;
}

technique rainbowColours
{  pass p1
   {  PixelShader = compile ps_2_0 PShader();
   }
}

// Green Gandalf's hue cycling shader
//
// As "hue" cycles through 0 to 360, the colours cycle through
// colours in the sequence red, yellow, green, cyan, blue,
// magenta, and back to red.

// Created 24 January 2007.

float hue = 0.0;  // this must be supplied by the application

float4 scale = {0.0, 0.333333, 0.666667, 0.00277778};

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

struct PSInput {  float2 UV : TEXCOORD0; };

struct PSOutput { float4 Col : COLOR; };

void RGBtoHSV( float r, float g, float b, out float h, out float s, out float v )
{
	float min1, max1, delta;
	min1 = min( r, g );
	min1 = min(min1,b);
	max1 = max( r, g);
	max1 = max(max1,b);
	
	v = max1;				// v
	delta = max1 - min1;
	
	if( max1 != 0 )
		s = delta / max1;		// s
	else {
		// r = g = b = 0		// s = 0, v is undefined
		s = 0;
		h = -1;
		
	}
	if( r == max1 )
		h = ( g - b ) / delta;		// between yellow & magenta
	else if( g == max1 )
		h = 2 + ( b - r ) / delta;	// between cyan & yellow
	else
		h = 4 + ( r - g ) / delta;	// between magenta & cyan
	h *= 60;				// degrees
	if( h < 0 )
		h += 360;
	return;
}










PSOutput PShader(PSInput In, PSOutput Out)
{  float3 C = tex2D(baseSample, In.UV);
   float lower = min(C.r, min(C.g, C.b));
   float range = max(C.r, max(C.g, C.b)) - lower;
   float newh,s,v;
   
   RGBtoHSV(C.r, C.g, C.b,newh,s,v);
   
   Out.Col = range * saturate(abs(frac(-(newh + hue) * scale.a + scale) - 0.5) * 6.0 - 1.0) + lower;
   return Out;
}

technique rainbowColours
{  pass p1
   {  PixelShader = compile ps_2_0 PShader();
   }
}

scalerdir = 1
if shiftkey()
scaler# = scaler# + 0.001 * scalerdir
gscaler# = scaler# * 0.3333
bscaler# = scaler# * 0.66667
if scaler# > 1.0
   scalerdir = -1
   scaler# = 1.0
endif
if scaler# < 0.0
   scalerdir = 1
   scaler# = 0.0
endif
set vector4 1,0,gscaler#,bscaler#,0.00277778   purposefully put this comment so it will error here -- what is the last number?, am i using the scale wrong?  I'm confused!  it does make it grayscale though if i set the r g and b to 0 and leave 00277778 there...
set effect constant vector 1,"scale",1
endif

Out.Col = range * saturate(abs(frac(-(newh + hue) * scale.a + scale) - 0.5) * 6.0 - 1.0) + lower

-(newh + hue) * scale.a + scale

float4 color = {1.0, 1.0, 0, 1.0};
float4 MyFirstPixelShader() : Color
{
	return (color);
}
technique MyFirstTechnique
{
	pass MyFirstPass
	{ 
	pixelshader = compile ps_1_1 MyFirstPixelShader();
	}
}

float4 light = {0,0,0,0}
float4 MyFirstVertexShader() : light
{
   return light
}

vertexshader = compile ps_1_1 MyFirstVertexShader();

float4x4 wvp : WorldViewProjection;

// your pixel shader works fine - outputs yellow
float4 color = {1.0, 1.0, 0, 1.0};
float4 MyFirstPixelShader() : Color
{
	return color;
}

// a vertex shader MUST output the vertex position in screen coordinates
// - but it can output other things like lighting as well

float4 MyFirstVertexShader(float4 Pos : position) : position
{  float4 myPos = mul(Pos, wvp);
   return myPos;
}

technique MyFirstTechnique
{
	pass MyFirstPass
	{vertexshader = compile vs_1_1 MyFirstVertexShader();  //NB vs not ps here
 
	pixelshader = compile ps_1_1 MyFirstPixelShader();
	}
}

float4x4 wvp : WorldViewProjection;

// a vertex shader MUST output the vertex position in screen coordinates
// - but it can output other things like lighting as well,
// the following example adds blue light to the object by interpolating it
// it with the yellow colour according to the
// average of the object's U and V coordinates of each pixel

// for convenience, I've put the input and output variables of the vertex
// shader into two structures:

struct VSInput  // struct is a keyword, VSInput is a name I've chosen
{  float4 Pos : Position;
   float2 UV  : Texcoord0;
};

struct VSOutput
{  float4 myPos : Position;
   float2 myUV  : Texcoord0;
};

VSOutput MyFirstVertexShader(VSInput In, VSOutput Out)
{  Out.myPos = mul(In.Pos, wvp);
   Out.myUV = In.UV;
   return Out;
}

float4 color = {1.0, 1.0, 0, 1.0};   // yellow
float4 light = {0.0, 0.0, 1.0, 1.0}; // blue

float4 MyFirstPixelShader(float2 UV  : Texcoord0) : Color
{  // calculate average of the UV coords
   float average = (UV.x + UV.y) * 0.5;
   // use "lerp" function to interpolate between the two colours
   return lerp(color, light, average);
}

technique MyFirstTechnique
{
	pass MyFirstPass
	{vertexshader = compile vs_1_1 MyFirstVertexShader();
 
	pixelshader = compile ps_1_1 MyFirstPixelShader();
	}
}

sampler baseSample = sampler_state
{  Texture = <baseTexture>;
   ADDRESSU = CLAMP;
   ADDRESSV = CLAMP;
   MIPFILTER = LINEAR;
   MINFILTER = LINEAR;
   MAGFILTER = LINEAR;
};

sampler baseSample = sampler_state
{  Texture = <baseTexture>;
   ADDRESSU = CLAMP;
   ADDRESSV = CLAMP;
   MIPFILTER = LINEAR;
   MINFILTER = LINEAR;
   MAGFILTER = LINEAR;
};

float4 Colour = tex2D(baseSample, In.UV);