Sorry your browser is not supported!

texture stageFrame < string Name=""; >;	
sampler2D samplerFrame = sampler_state { texture = <stageFrame>; };

texture targetPos : RENDERCOLORTARGET < string Name=""; int width = 800; int height = 600; >;
sampler samplerPos = sampler_state { texture = <targetPos>; };

texture targetNormals : RENDERCOLORTARGET < string Name=""; int width = 800; int height = 600; >;
sampler samplerNormals = sampler_state { texture = <targetNormals>; };

technique Technique
{
	pass passPos
	<
		string RenderColorTarget = "targetPos";
	>
	{
		VertexShader = compile vs_2_0 VS_Scene();
		PixelShader  = compile ps_2_0 PS_Scene_Pos();
	}
	pass passNormals
	<
		string RenderColorTarget = "targetNormals";
	>
	{
		VertexShader = compile vs_2_0 VS_Scene();
		PixelShader  = compile ps_2_0 PS_Scene_Normals();
	}
	pass passFinal
	<
		string RenderColorTarget = "";
	>
	{
		ZEnable = False;
		VertexShader = compile vs_2_0 VS_Quad();
		PixelShader  = compile ps_2_0 PS_Quad();	
	}
}

// Shader Test Project

// includes
#include "DarkGDK.h"
#include "Util.h"

// main entry point
void DarkGDK ( void )
{
	// screen setup
	dbSetWindowTitle( "Shader Test" );
	dbSetDisplayModeAntialias( 800, 600, 32, 0, 0, 0 );
	dbSetWindowPosition( 0, 0 );
	dbSyncOn();
	dbSyncRate( 0 );
	dbBackdropOn();
	dbSetDir( "Media" );

	// text setup
	dbInk( dbRGB( 255, 0, 0 ), 0 );
	dbSetTextFont( "Arial" );
	dbSetTextSize( 18 );
	dbSetTextToBold();

	// camera setup
	dbAutoCamOff();
	int CAM_USER = 0;
	dbPositionCamera( CAM_USER, -50, 50, -50 );
	dbPointCamera( CAM_USER, 0, 0, 0 );
	int CAM_QUAD = 1;
	dbMakeCamera( CAM_QUAD );
	int QuadImage = GetFreeImageID();
	dbSetCameraToImage( CAM_QUAD, QuadImage, dbScreenWidth(), dbScreenHeight() );

	// shader setup
	int SceneShader = GetFreeEffectID();
	dbLoadEffect( "scene.fx", SceneShader, 0 );
	int PostShader = GetFreeEffectID();
	dbLoadEffect( "post.fx", PostShader, 0 );
	int Vector4 = 1;
	dbMakeVector4( Vector4 );
	dbSetVector4( Vector4, 1.0f / dbScreenWidth(), 1.0f / dbScreenHeight(), 0, 0 );
	dbSetEffectConstantVector( PostShader, "InvViewSize", Vector4 );

	// shader errors
	dbPerformChecklistForEffectErrors();
	if ( dbChecklistQuantity() > 0 ) ReportError( "Shader Error:\n" + string( dbChecklistString( 1 ) ), 0 );

	// screen quad
	int Quad = GetFreeObjectID();
	dbMakeObjectPlane( Quad, 4, 3 );
	dbTextureObject( Quad, 0, QuadImage );
	dbLockObjectOn( Quad );
	dbSetObjectEffect( Quad, PostShader );
	SetObjectMask( Quad, CAM( CAM_USER ) );

	// scene setup
	int Floor = GetFreeObjectID();
	dbMakeObjectBox( Floor, 100, 2, 100 );
	dbPositionObject( Floor, 0, -10, 0 );
	int Sphere = GetFreeObjectID();
	dbMakeObjectSphere( Sphere, 18 );
	dbPositionObject( Sphere, 0, 10, 0 );
	int Box = GetFreeObjectID();
	dbMakeObjectBox( Box, 20, 10, 20 );
	dbPositionObject( Box, 0, -4, 0 );

	// apply scene shader
	dbSetObjectEffect( Floor, SceneShader );
	dbSetObjectEffect( Sphere, SceneShader );
	dbSetObjectEffect( Box, SceneShader );

	// main loop
	while ( LoopGDK() )
	{
		// camera control
		dbPrint( "WASD: Move" );
		dbPrint( "Right Mouse: Rotate" );
		float CamSpeed = 0.3f;
		if ( dbKeyState( DIK_W ) ) dbMoveCamera( CAM_USER, CamSpeed );
		if ( dbKeyState( DIK_S ) ) dbMoveCamera( CAM_USER, -CamSpeed );
		if ( dbKeyState( DIK_A ) ) dbMoveCameraLeft( CAM_USER, CamSpeed );
		if ( dbKeyState( DIK_D ) ) dbMoveCameraRight( CAM_USER, CamSpeed );
		int MouseMoveX = dbMouseMoveX(),
			MouseMoveY = dbMouseMoveY();
		if ( dbMouseClick() == 2 )
		{
			dbYRotateCamera( CAM_USER, dbWrapValue( dbCameraAngleY( CAM_USER ) + ( MouseMoveX * CamSpeed ) ) );
			dbXRotateCamera( CAM_USER, dbWrapValue( dbCameraAngleX( CAM_USER ) + ( MouseMoveY * CamSpeed ) ) );
		}

		// shader input
		dbPrint( "Space: Change Scene Technique" );
		if ( dbSpaceKey() )
		{
			dbSetEffectTechnique( SceneShader, "ScenePos" );
		}
		else
		{
			dbSetEffectTechnique( SceneShader, "SceneNormals" );
		}

		// update quad cam
		dbPrint( "Shift: Hide Quad" );
		if ( dbShiftKey() )
		{
			dbHideObject( Quad );
		}
		else
		{
			dbShowObject( Quad );
			dbPositionCamera( CAM_QUAD, dbCameraPositionX( CAM_USER ), dbCameraPositionY( CAM_USER ), dbCameraPositionZ( CAM_USER ) );
			dbRotateCamera( CAM_QUAD, dbCameraAngleX( CAM_USER ), dbCameraAngleY( CAM_USER ), dbCameraAngleZ( CAM_USER ) );
		}

		// update quad
		dbPrint( "Return: Change Quad Technique" );
		if ( dbReturnKey() )
		{
			dbSetEffectTechnique( PostShader, "Normals" );
		}
		else
		{
			dbSetEffectTechnique( PostShader, "Quad" );
		}

		// output
		dbSetCursor( 0, 32 );
		string fps = "FPS: " + Str( dbScreenFPS() );
		dbPrint( (char*)fps.c_str() );

		// update screen
		dbSync();
	}

	// return to windows
	return;
}

//------------------------------------------------
  // NormalMapping with Specular mask and Emissive 
  //------------------------------------------------
  // By Evolved
  // http://www.vector3r.com/
  // Modified by Revenant_Chaos
  //--------------------------------

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

  //-----------------
  // tweaks
  //-----------------
   float4 Ambient   = {0.0f, 0.0f, 0.0f, 0.0f};    
   float4 LightPosition_1 = {150.0f, 0.0f, 150.0f, 1.0f};    
   float4 LightColor_1 = {1.0f, 1.0f, 1.0f, 1.0f};    
   float  LightRange_1 = 800.0f;    
   float U = 1.0f; 
   float V = 1.0f; 
   float SpecularPow = 16.0f; 	
   float EmissPower = 1.0f;
   float SpecBright = 1.0f;

  //-----------------
  // Textures
  //-----------------
   texture BaseTX 
    <
	string Name="";
    >;	
   sampler2D Base = sampler_state 
    {
 	texture = <BaseTX>;
    };
   texture NormalTX
    <
	string Name="";
    >;	
   sampler2D Normal = sampler_state 
    {
 	texture = <NormalTX>;
    };
   texture SpecTX
    <
	string Name="";
    >;	
   sampler2D SpecMap = sampler_state 
    {
 	texture = <SpecTX>;
    };
   texture EmissiveTX
    <
	string Name="";
    >;	
   sampler2D EmissiveMap = sampler_state 
    {
 	texture = <EmissiveTX>;
    };
  //-----------------
  // 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);
	OUT.LightVec=0;
	OUT.Attenuation=0; 
 	OUT.ViewVec=0; 
	return OUT;
     }
   output VS_L1(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_1-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_1; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	return OUT;
     }

  //-----------------
  // pixel shader
  //-----------------
   float4 PS(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.Tex); 
	float4 Emissive=tex2D(EmissiveMap,IN.Tex); 
	return (Texture*Ambient)+Emissive;
     }
   float4 PS_L1(output IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.Tex);
	float4 SpecTex=tex2D(SpecMap,IN.Tex); 
	float4 Emissive=tex2D(EmissiveMap,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float3 View=normalize(IN.ViewVec);
	float Normal=saturate(dot(NormalMap,LightV)); 
	float Specular=saturate(dot(reflect(-View,NormalMap),LightV));
	Specular=pow(Specular,SpecularPow)*(SpecTex*SpecBright);
	float4 DiffuseLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float4 Light=DiffuseLight*LightColor_1;
	return (Texture*(((Normal+Specular)*Light)+Ambient))+(Emissive*EmissPower);
     }
 
  //-----------------
  // techniques   
  //-----------------
   technique Ambient
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 	
      }
      }
   technique Light1
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
      }

//------------------------------------------------
  // ParallaxMapping with Specular mask and Emissive 
  //------------------------------------------------
  // By Evolved
  // http://www.evolved-software.com/
  // Modified by Revenant_Chaos (Again)
  //------------------------------------------

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

  //-----------------
  // tweaks
  //-----------------
   float4 Ambient   = {0.0f, 0.0f, 0.0f, 0.0f};    
   float4 LightPosition_1 = {150.0f, 0.0f, 150.0f, 1.0f};    
   float4 LightColor_1 = {1.0f, 1.0f, 1.0f, 1.0f};    
   float  LightRange_1 = 800.0f;    
   float U = 1.0f; 
   float V = 1.0f; 
   float SpecularPow = 16.0f; 	
   float EmissPower = 1.0f;
   float SpecBright = 1.0f;

   float Heightvec = 0.03;
   float BiasHeight = 0.1;

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

   texture SpecTX
    <
	string Name="";
    >;	
   sampler2D SpecMap = sampler_state 
    {
 	texture = <SpecTX>;
    };
   texture EmissiveTX
    <
	string Name="";
    >;	
   sampler2D EmissiveMap = sampler_state 
    {
 	texture = <EmissiveTX>;
    };
  //-----------------
  // 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);
	OUT.LightVec=0;
	OUT.Attenuation=0; 

	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 ViewPos=ViewInv[3].xyz-WPos;
 	OUT.ViewVec=mul(ViewPos,TBN); 
	return OUT;
     }
   output VS_L1(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_1-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-LightPos/LightRange_1; 
 	OUT.ViewVec=mul(ViewPos,TBN); 
	return OUT;
     }

  //-----------------
  // pixel shader
  //-----------------
   float4 PS(output IN)  : COLOR
     {

	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv); 
	float4 Emissive=tex2D(EmissiveMap,NewUv); 
	return (Texture*Ambient)+Emissive;
     }
   float4 PS_L1(output IN)  : COLOR
     {
	float3 View=normalize(IN.ViewVec);
	float HeightTex=tex2D(Height,IN.Tex).x+BiasHeight; 
	float2 NewUv=(Heightvec*HeightTex-0.02)*View+IN.Tex; 
	float4 Texture=tex2D(Base,NewUv);
	float4 SpecTex=tex2D(SpecMap,NewUv); 
	float4 Emissive=tex2D(EmissiveMap,NewUv); 
	float3 NormalMap=tex2D(Normal,NewUv)*2-1; 
	NormalMap=normalize(NormalMap);
	float3 LightV=normalize(IN.LightVec);  	
	float Normal=saturate(dot(NormalMap,LightV)); 
	float Specular=saturate(dot(reflect(-View,NormalMap),LightV));
	Specular=pow(Specular,SpecularPow)*(SpecTex*SpecBright);
	float4 DiffuseLight=1-saturate(dot(IN.Attenuation,IN.Attenuation));
	float4 Light=DiffuseLight*LightColor_1;
	return (Texture*(((Normal+Specular)*Light)+Ambient))+(Emissive*EmissPower);
     }
 
  //-----------------
  // techniques   
  //-----------------
   technique Ambient
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS(); 
 	pixelShader  = compile ps_2_0 PS(); 	
      }
      }
   technique Light1
      {
 	pass p1
      {		
 	vertexShader = compile vs_2_0 VS_L1(); 
 	pixelShader  = compile ps_2_0 PS_L1(); 	
      }
      }

// variables
float4x4	VP			: VIEWPROJECTION,
			W			: WORLD,
			V			: VIEW,
			P			: PROJECTION,
			WVP			: WORLDVIEWPROJECTION,
			WV			: WORLDVIEW;
			//LightV,
			//LightP;

float		MaxDepth	= 160,
			DepthBias	= 0.003;

// samplers
texture textureDiffuse < string ResourceName = ""; >;
sampler samplerDiffuse = sampler_state { texture = <textureDiffuse>; };

texture targetDepth : RENDERCOLORTARGET < string ResourceName = ""; int width = 512; int height = 512; >;
sampler samplerDepth = sampler_state { texture = <targetDepth>; };

// light structs
struct light_vs_in
{
	float4	pos			: POSITION;
};
struct light_vs_out
{
	float4	pos			: POSITION;
	float	depth		: TEXCOORD0;
};
struct light_ps_in
{
	float	depth		: TEXCOORD0;
};
struct light_ps_out
{
	float4	color		: COLOR0;
};

// scene structs
struct scene_vs_in
{
	float4	pos			: POSITION;
	float2	uv			: TEXCOORD0;
};
struct scene_vs_out
{
	float4	pos			: POSITION;
	float2	uv			: TEXCOORD0;
	float4	spos		: TEXCOORD1;
};
struct scene_ps_in
{
	float2	uv			: TEXCOORD0;
	float4	spos		: TEXCOORD1;
};
struct scene_ps_out
{
	float4	color		: COLOR0;
};

// light functions
light_vs_out VS_Light( light_vs_in input )
{
	light_vs_out output = (light_vs_out)0;
	
	// transformation
	//output.pos = mul( input.pos, W );
	//output.pos = mul( output.pos, LightV );
	//output.pos = mul( output.pos, LightP );
	
	output.pos = mul( input.pos, W );
	output.pos = mul( output.pos, V );
	output.pos = mul( output.pos, P );
	
	//output.pos = mul( input.pos, WVP );
	
	// depth
	output.depth = output.pos.z / MaxDepth;
	
	return output;
}
light_ps_out PS_Light( light_ps_in input )
{
	light_ps_out output = (light_ps_out)0;
	
	output.color = input.depth;
	output.color.a = 1;
	
	return output;
}

// scene functions
scene_vs_out VS_Scene( scene_vs_in input )
{
	scene_vs_out output = (scene_vs_out)0;
	
	// transformation
	float4 wpos = mul( input.pos, W );
	//output.pos = mul( wpos, VP );
	output.pos = mul( input.pos, WVP );
	
	// uv
	output.uv = input.uv;
	
	// sample pos
	//output.spos = mul( wpos, LightV );
	//output.spos = mul( output.spos, LightP );
	
	return output;
}
scene_ps_out PS_Scene( scene_ps_in input )
{
	scene_ps_out output = (scene_ps_out)0;
	
	// diffuse
	float4 diffuse = tex2D( samplerDiffuse, input.uv );
	
	// shadow map
	float shadow = 1;
	float2 proj_coords = 0.5 * input.spos.xy / input.spos.w + float2( 0.5, 0.5 );
	proj_coords.y = 1.0f - proj_coords.y;
	/*if ( (saturate( proj_coords.x ) == proj_coords.x ) && ( saturate( proj_coords.y ) == proj_coords.y ) )
	{    
		float depth = tex2D( samplerLight, proj_coords ).r;
		float d = input.spos.z;

		if ( d - DepthBias > depth && depth < 1 )
		{
			shadow = 0;
		}
		shadow = depth;
	}*/
	shadow = tex2D( samplerDepth, input.uv );
	
	// final composition
	//output.color = diffuse * shadow;
	output.color = 1;//shadow;
	
	return output;
}

// techniques
technique ShadowMapping
{
	pass PassLight
	<
	string RenderColorTarget = "targetDepth";
	>
	{
		VertexShader	= compile 	vs_2_0 	VS_Light();
       	PixelShader		= compile 	ps_2_0 	PS_Light();
	}
	
	pass PassScene
	<
	string RenderColorTarget = "";
	>
	{
		VertexShader	= compile 	vs_2_0 	VS_Scene();
       	PixelShader		= compile 	ps_2_0 	PS_Scene();
	}
}

technique ShadowMapping
{
	pass PassDepth
	<
	string RenderColorTarget = "targetDepth";
	>
	{
	ZEnable = false;
	VertexShader	= compile 	vs_2_0 	VS_Light();
       	PixelShader	= compile 	ps_2_0 	PS_Light();
	}
	
	pass PassScene
	<
	string RenderColorTarget = "";
	>
	{
	ZEnable = true;
	VertexShader	= compile 	vs_2_0 	VS_Scene();
       	PixelShader	= compile 	ps_2_0 	PS_Scene();
	}
}

float		LightAreaSize		= 100,
		LightNearClip		= 400,
		LightFarClip		= 600;

dbMakeMatrix4( MATRIX_P );
dbBuildOrthoLHMatrix4( MATRIX_P, LightAreaSize, LightAreaSize, LightNearClip, LightFarClip );
dbSetEffectConstantMatrix( _shader, "LightP", MATRIX_P );

dbProjectionMatrix4( MATRIX_P );
dbSetEffectConstantMatrix( _shader, "LightP", MATRIX_P );

// render target test

// includes
#include "DarkGDK.h"

// main entry point
void DarkGDK( void )
{
	// setup
	dbSyncOn();
	dbSyncRate( 0 );
	dbSetDisplayMode( 800, 600, 32 );
	dbBackdropOn();
	dbSetDir( "Media" );
	dbSetWindowTitle( "Render Target Test" );
	dbSetWindowPosition( 0, 0 );

	// camera
	dbAutoCamOff();
	dbPositionCamera( 0, 20, 100 );
	dbPointCamera( 0, 20, 0 );

	// shader setup
	dbLoadEffect( "rendertargets.fx", 1, 0 );

	// objects
	dbMakeObjectBox( 10, 100, 2, 100 );
	dbMoveObjectDown( 10, 20 );
	dbMakeObjectSphere( 20, 30 );

	// textures
	dbLoadImage( "ground.jpg", 10 );
	dbTextureObject( 10, 0, 10 );
	dbTextureObject( 20, 0, 10 );

	// apply shader
	dbSetObjectEffect( 10, 1 );
	dbSetObjectEffect( 20, 1 );

	// main loop
	while ( LoopGDK() )
	{
		// control
		dbControlCameraUsingArrowKeys( 0, 1, 1 );

		// update screen		
		dbSync();
	}

	// return to windows
	return;
}

// render targets test shader

// constants, variables
float4x4	WVP		: WORLDVIEWPROJECTION;
			
#define		TARGET_SIZE	512

// samplers
texture diffuse < string ResourceName = ""; >;
sampler samplerDiffuse = sampler_state { texture = <diffuse>; };

texture target : RENDERCOLORTARGET < string ResourceName = ""; int width = TARGET_SIZE; int height = TARGET_SIZE; >;
sampler samplerTarget = sampler_state { texture = <target>; };

// structs
struct vs_in
{
	float4	pos	: POSITION0;
};
struct vs_out
{
	float4	pos	: POSITION0;
};
struct ps_in
{
};
struct ps_out
{
	float4	color	: COLOR0;
};

// functions
vs_out VS_1( vs_in input )
{
	vs_out output = (vs_out)0;
	
	// transformation
	output.pos = mul( input.pos, WVP );
	
	return output;
}
ps_out PS_1( ps_in input )
{
	ps_out output = (ps_out)0;
	
	// red
	output.color = float4( 1, 0, 0, 1 );
	
	return output;
}
ps_out PS_2( ps_in input )
{
	ps_out output = (ps_out)0;
	
	// green
	output.color = float4( 0, 1, 0, 1 );
	
	return output;
}

// techniques
technique Test
{
	// first pass: paint object red and render to target
	pass Pass1
	<
	string RenderColorTarget = "target";
	>
	{
		VertexShader	= compile 	vs_2_0 	VS_1();
       		PixelShader	= compile 	ps_2_0 	PS_1();
	}
	
	// second pass: paint object green and render to screen
	pass Pass2
	<
	string RenderColorTarget = "";
	>
	{
		VertexShader	= compile 	vs_2_0 	VS_1();
       		PixelShader	= compile 	ps_2_0 	PS_2();
	}
}

texture target : RENDERCOLORTARGET < string ResourceName = ""; int width = TARGET_SIZE; int height = TARGET_SIZE; >;

texture target : RENDERCOLORTARGET <  int width = TARGET_SIZE; int height = TARGET_SIZE; >;

output.color = tex2D( samplerTarget, input.uv );

texture target : RENDERCOLORTARGET < string ResourceName = ""; float2 ViewportRatio = { 1.0, 1.0 }; >;

technique t0 // this technique renders correctly
{ pass p0
  < // tell the renderer to send the output to renderTargetImage
    string RenderColorTarget = "renderTargetImage";
  >
  { zenable = false;
    VertexShader = compile vs_2_0 VShader0();
    PixelShader = compile ps_2_0 PShader0();
  }
  pass p1
  < // tell the renderer to send the output to the screen
    string RenderColorTarget = "";
  >
  { zenable = true;
    VertexShader = compile vs_2_0 VShader1();
    PixelShader = compile ps_2_0 PShader1();
  }
}

// techniques
technique Test
{
	// first pass: paint object red and render to target
	pass Pass1
	<
	string RenderColorTarget = "target";
	>
	{
		VertexShader	= compile 	vs_2_0 	VS_1();
       	PixelShader		= compile 	ps_2_0 	PS_1();
	}
	
	// second pass: paint object green and render to screen
	pass Pass2
	<
	string RenderColorTarget = "";
	>
	{
		VertexShader	= compile 	vs_2_0 	VS_1();
       	PixelShader		= compile 	ps_2_0 	PS_2();
	}
}

light_ps_out PS_Light( light_ps_in input )
{
	light_ps_out output = (light_ps_out)0;
	
	output.color = input.depth;
	output.color.a = 1;
	
	return output;
}

// render targets test shader

// constants, variables
float4x4	WVP			: WORLDVIEWPROJECTION,
		W			: WORLD,
		V			: VIEW,
		P			: PROJECTION,
		VP			: VIEWPROJECTION,
		LightV,
		LightP		: PROJECTION;
			
#define		TARGET_SIZE	512

// samplers
texture diffuse < string ResourceName = ""; >;
sampler samplerDiffuse = sampler_state { texture = <diffuse>; };

texture target : RENDERCOLORTARGET < string ResourceName = ""; float2 ViewPortRatio = { 1.0, 1.0 }; >;
sampler samplerTarget = sampler_state { texture = <target>; };

// structs
struct vs_in
{
	float4	pos			: POSITION0;
	float2	uv			: TEXCOORD0;
};
struct vs_out
{
	float4	pos			: POSITION0;
	float2	uv			: TEXCOORD0;
	float	depth		: TEXCOORD1;
	float4	spos		: TEXCOORD2;
};
struct ps_in
{
	float2	uv			: TEXCOORD0;
	float	depth		: TEXCOORD1;
	float4	spos		: TEXCOORD2;
};
struct ps_out
{
	float4	color		: COLOR0;
};

// functions
vs_out VS_1( vs_in input )
{
	vs_out output = (vs_out)0;
	
	// transformation
	output.pos = mul( input.pos, W );
	output.pos = mul( output.pos, mul( LightV, LightP ) );
	
	// uv
	output.uv = input.uv;
	
	// depth
	output.depth = output.pos.z / 100.0f;
	
	return output;
}
vs_out VS_2( vs_in input )
{
	vs_out output = (vs_out)0;
	
	// transformation
	output.pos = mul( input.pos, WVP );
	
	// uv
	output.uv = input.uv;
	
	// sample pos
	output.spos = mul( input.pos, W );
	output.spos = mul( output.spos, mul( LightV, LightP ) );
	
	return output;
}
ps_out PS_1( ps_in input )
{
	ps_out output = (ps_out)0;
	
	// red
	output.color = input.depth;
	
	return output;
}
ps_out PS_2( ps_in input )
{
	ps_out output = (ps_out)0;
		
	float4 shadow = 1;
	float2 proj_coords = 0.5 * input.spos.xy / input.spos.w + float2( 0.5, 0.5 );
	proj_coords.y = 1.0f - proj_coords.y;
	if ( (saturate( proj_coords.x ) == proj_coords.x ) && ( saturate( proj_coords.y ) == proj_coords.y ) )
	{    
		float depth = tex2D( samplerTarget, proj_coords ).r;
		float d = input.spos.z;

		if ( d - 0.01f > depth && depth < 1 )
		{
			shadow = 0;
		}
		shadow = depth;
	}
	
	output.color = shadow;
	
	return output;
}

// techniques
technique Test
{
	// first pass
	pass Pass1
	<
	string RenderColorTarget = "target";
	>
	{
		Zenable = false;
		VertexShader	= compile 	vs_2_0 	VS_1();
       		PixelShader		= compile 	ps_2_0 	PS_1();
	}
	
	// second pass	pass Pass2
	<
	string RenderColorTarget = "";
	>
	{
		Zenable = true;
		VertexShader	= compile 	vs_2_0 	VS_2();
       		PixelShader		= compile 	ps_2_0 	PS_2();
	}
}

float4x4 matrix	= float4x4( 1.0f, 0.0f, 0.0f, 0.0f,
                            0.0f, 1.0f, 0.0f, 0.0f,
                            0.0f, 0.0f, 1.0f, 0.0f,
                            0.0f, 0.0f, 0.0f, 1.0f );

null = make vector4(1)
set vector4 1, -1.0, 0.0, 0.0, 0.0
set effect constant vector 1, "downDir", 1

0 1 2
3 4 5
6 7 8

0 3 6
1 4 7
2 5 8

Out.down = mul(temp, TSM);

Out.down = temp;

float3 n = normalize( input.normal );
float3 b = normalize( input.binormal )     * 100;   // scale by 100
float3 t = normalize( input.tangent )      * 100;
float3x3 TSM = { t, b, n };
TSM = transpose( TSM );

make object sphere 13, 70, 6, 6
make mesh from object 1, 13
for i = 7 to 12
  `make object sphere i, 70
  make object i, 1,1
  `texture object i, 0, 1
  set object effect i, 1
  hide object i
next i

float3 wnormal = mul( input.normal, (float3x3)W ) * float3( 1, 0.1, 1 );