Texture TargetMap;

sampler2D SrcColor = sampler_state
{ 
	texture = <TargetMap>; 
	MinFilter = linear;
   MagFilter = linear;
   MipFilter = linear;
   AddressU = Clamp;
   AddressV = Clamp;	
};

float4 FillAlpha( float2 texCoord : TEXCOORD0 ) : COLOR0
{
	float4 color;

	color = tex2D(SrcColor, texCoord);
	color.a = 0;
	color.rgb = 1;
	return color;
}

technique PostProcess 
{
	pass p1 
	{
		AlphaBlendEnable = false;	
		VertexShader = null;
		PixelShader = compile ps_1_0 FillAlpha();
	}
}


MATERIAL* MatObjFillAlpha =
{	
	effect ="FillAlpha.fx";		
}

View.bmap = bmap_for_entity(my, 1);
bmap_process (View.bmap, NULL, MatObjFillAlpha);

Texture TargetMap;
sampler2D g_samSrcColor = sampler_state { texture = <TargetMap>; MipFilter = Linear;	};

float4 vecViewPort;

float4 postprocessing_emboss( float2 Tex : TEXCOORD0 ) : COLOR0 
{
   float4 Color = float4(0.5,0.5,0.5,1.0);
	Color -= tex2D( g_samSrcColor, Tex.xy-vecViewPort.zw)*2.0f;
	Color += tex2D( g_samSrcColor, Tex.xy+vecViewPort.zw)*2.0f;	
	Color.rgb = (Color.r+Color.g+Color.b)/3.0f;
	Color.a = 0.2; 
	return Color;
}

technique PostProcess 
{
	pass p1 
	{
		AlphaBlendEnable = true;
		VertexShader = null;
		PixelShader = compile ps_2_0 postprocessing_emboss();
	}
}

float4 postprocessing_negative( float2 Tex : TEXCOORD0 ) : COLOR0 
{
   //you have the color of the texture but not the alpha!
   float3 Color = 1. - tex2D( g_samSrcColor, Tex.xy).xyz;
   
   //you set the alpha by number (1) that means your texture doesn't have transparent parts.
   return float4(Color,1.);
}

float4 postprocessing_negative( float2 Tex : TEXCOORD0 ) : COLOR0 
{
	//you have the color and alpha of the texture.
	float4 Color = tex2D( g_samSrcColor, Tex.xy);
	
	//now you change colors, but not touch the alpha.
	Color.xyz=1. - tex2D( g_samSrcColor, Tex.xy).xyz;
	
	return Color;
}

///////////////////////////////
#include <acknex.h>
#include <default.c>
#define PRAGMA_PATH "%EXE_DIR%\templates\images";
#define PRAGMA_PATH "%EXE_DIR%\samples";

//bumpmap for wave
BMAP* bump_map="rock.tga";
MATERIAL* test_mat =
{
	skin1=bump_map;
	
	effect="
	texture TargetMap;
	texture mtlSkin1;
	sampler2D Map1 = sampler_state
	{
		Texture = <TargetMap>;
	};
	sampler2D BumpSampler = sampler_state
	{
		Texture = <mtlSkin1>;
	};
	float4 vecTime;
	float4 PIXEL_S(float2 Tex:TEXCOORD0 ):COLOR
	{
		float2 BumpText = tex2D(BumpSampler, float2(Tex.x,Tex.y-0.1*0.1*vecTime.w)).rg*2-1;
		Tex += BumpText*(0.01f);
		float4 color = tex2D(Map1,Tex);
		return color;
	}
	technique testtech
	{
		pass p1
		{
			PixelShader = compile ps_2_0 PIXEL_S();
		}
	}";
}


//sourcemap
BMAP* lite_c_logo="logo_800.jpg";

//panelmap (targetmap)
BMAP* panelmap="logo_800.jpg";
PANEL* testpan =
{
	bmap=panelmap;
	flags=SHOW;
}

function main()
{
	fps_max=75;
	video_mode=9;
	video_screen=2;
	video_set(800,600,32,2);
	wait(3);
	
	//Need this. Otherwise vecTime doesn't work.
	level_load("");
	
	//convert rock.tga to normalmap
	bmap_to_normals(bump_map,10);
	
	while(1)
	{
		//render lite-c logo on the panelmap with shader
		bmap_process(testpan.bmap,lite_c_logo,test_mat);
		
		//render panelmap on the panelmap? This will not work.
		//bmap_process(testpan.bmap,testpan.bmap,test_mat);
		
				
		//This will not work either.
		//bmap_process(testpan.bmap,NULL,test_mat);
		
		wait(1);
	}
}

///////////////////////////////
#include <acknex.h>
#include <default.c>
#define PRAGMA_PATH "%EXE_DIR%\templates\images";
#define PRAGMA_PATH "%EXE_DIR%\samples";

//sourcemap
BMAP* lite_c_logo="logo_800.jpg";

//bumpmap for wave
BMAP* bump_map="rock.tga";
MATERIAL* test_mat =
{
	skin1=bump_map;
	skin2=lite_c_logo;
	
	effect="
	float4 vecSkill1;
	
	texture mtlSkin1;
	sampler2D BumpSampler = sampler_state
	{
		Texture = <mtlSkin1>;
		AddressU = Wrap;
		AddressV = Wrap;
	};
	texture mtlSkin2;
	sampler2D SourceSampler = sampler_state
	{
		Texture = <mtlSkin2>;
		AddressU = Clamp;
		AddressV = Clamp;
	};
	float4 vecTime;
	float4 PIXEL_S(float2 pos:VPOS ):COLOR // VPOS gives the pixel coords instead of normalized ones
	{
		float2 Tex = (pos + 0.5f) / vecSkill1.xy;
		float2 BumpText = tex2D(BumpSampler, float2(Tex.x,Tex.y-0.1*0.1*vecTime.w)).rg*2-1;
		Tex += BumpText*(0.01f);
		float4 color = tex2D(SourceSampler,Tex);
		return color;
	}
	technique testtech
	{
		pass p1
		{
			PixelShader = compile ps_3_0 PIXEL_S();
		}
	}
	";
}


//panelmap (targetmap)
BMAP* panelmap="#800x600x24";
PANEL* testpan =
{
	bmap=panelmap;
	flags=SHOW;
}

VIEW *viewtest = {
	bmap = panelmap;
	size_x = 800;
	size_y = 600;
	material = test_mat;
	flags = PROCESS_TARGET | SHOW;
}

function main()
{
	fps_max=75;
	video_mode=9;
	video_screen=2;
	video_set(800,600,32,2);
	wait(3);
	
	//Need this. Otherwise vecTime doesn't work.
	level_load("");
	
	//convert rock.tga to normalmap
	bmap_to_normals(bump_map,10);
	
	// Need this to get the real size of the bitmap
	bmap_lock(lite_c_logo, 0);
	bmap_unlock(lite_c_logo);
	test_mat->skill1 = floatv(lite_c_logo.finalwidth);
	test_mat->skill2 = floatv(lite_c_logo.finalheight);
}

///////////////////////////////
#include <acknex.h>
#include <default.c>
#include <mtlView.c>
#define PRAGMA_PATH "%EXE_DIR%\templates\images";
#define PRAGMA_PATH "%EXE_DIR%\samples";
FONT* testfont = font_create("Arial#40");

//material to clear the fx canvas
MATERIAL* MatObjFillAlpha =
{	
	effect="
	Texture TargetMap;

	sampler2D SrcColor = sampler_state
	{ 
		texture = <TargetMap>; 
		MinFilter = linear;
		MagFilter = linear;
		MipFilter = linear;
		AddressU = Clamp;
		AddressV = Clamp;	
	};

	float4 FillAlpha( float2 texCoord : TEXCOORD0 ) : COLOR0
	{
		float4 color;

		color = tex2D(SrcColor, texCoord);
		color.a = 0;
		color.rgb = 1;
		return color;
	}

	technique PostProcess 
	{
		pass p1 
		{
			AlphaBlendEnable = false;	
			VertexShader = null;
			PixelShader = compile ps_1_0 FillAlpha();
		}
	}
	";
}

//bumpmap for wave effect
BMAP* bump_map="rock.tga";

//material for wave effect
MATERIAL* test_mat =
{
	skin1=bump_map;
	
	effect="
	texture TargetMap;
	texture mtlSkin1;
	sampler2D Map1 = sampler_state
	{
		Texture = <TargetMap>;
	};
	sampler2D BumpSampler = sampler_state
	{
		Texture = <mtlSkin1>;
	};
	float4 vecTime;
	float4 PIXEL_S(float2 Tex:TEXCOORD0 ):COLOR
	{
		float2 BumpText = tex2D(BumpSampler, float2(Tex.x,Tex.y-0.1*0.1*vecTime.w)).rg*2-1;
		Tex += BumpText*(0.01f);
		float4 color = tex2D(Map1,Tex);
		return color;
	}
	technique testtech
	{
		pass p1
		{
			PixelShader = compile ps_2_0 PIXEL_S();
		}
	}";
}

//BMAPS
BMAP* lite_c_logo="logo_800.jpg";
BMAP* invent="invent.pcx";

//PRIMARY PANELS
PANEL* testpanA;
PANEL* testpanB;
PANEL* testpanC;

//PRIMARY PANEL BLUEPRINTS FOR PANEL CREATION
//ALSO USED FOR FX PANELS TO CLONE PANELS/ELEMENTS
STRING* testpanAstr = 
"
bmap=lite_c_logo;
digits(20,20,\"ID 1\",*,0,0);
button(40, 40, invent, invent, invent, NULL, NULL, NULL);
pos_x=0;
pos_y=0;
size_x=800;
size_y=600;
red=128;
green=128;
blue=128;
layer=0;
flags=LIGHT;
";

STRING* testpanBstr = 
"
bmap=lite_c_logo;
digits(20,20,\"ID 2\",*,0,0);
digits(20,40,\"ID 2\",*,0,0);
pos_x=100;
pos_y=100;
size_x=400;
size_y=200;
red=128;
green=128;
blue=128;
layer=1;
flags=LIGHT;
";

STRING* testpanCstr = 
"
bmap=lite_c_logo;
digits(20,20,\"ID 3\",*,0,0);
pos_x=350;
pos_y=150;
size_x=350;
size_y=250;
red=128;
green=128;
blue=128;
layer=2;
flags=LIGHT;
";

//EVO2D PANEL SHADER

//fx_ids
int fx_id[100];

//Remove any Fx from any panel that uses the fx_id
void remove_fx(int fx_ids)
{
	fx_id[fx_ids] = false;
}

//Apply Fx to a panel
void fx_shader(int fx_ids, PANEL* target_panel, STRING* clone_str, MATERIAL* add_mtl, int fx_transparency, int fx_layer)
{
	if(fx_ids<0){fx_ids=0;}
	if(fx_ids>99){fx_ids=99;}
	fx_id[fx_ids] = true;
	PANEL* targetpan = pan_create ( clone_str, fx_layer );
	PANEL* destpan = pan_create ( "", fx_layer );
	targetpan.alpha = fx_transparency;
	layer_sort(target_panel, fx_layer);
	layer_sort(targetpan, fx_layer);
	layer_sort(destpan, fx_layer);
	set(targetpan,SHOW | LIGHT);
	set(destpan, SHOW );
	targetpan.target_map = bmap_createblack ( screen_size.x, screen_size.y, 32 );
	destpan.bmap = bmap_createblack ( screen_size.x, screen_size.y, 32 );
	while ( fx_id[fx_ids] )
	{
		bmap_process ( destpan.bmap, targetpan.target_map, MatObjFillAlpha );
		bmap_process ( destpan.bmap, targetpan.target_map, add_mtl );
		vec_set(targetpan.blue, target_panel.blue);
		destpan.pos_x = target_panel.pos_x;
		destpan.pos_y = target_panel.pos_y;
		destpan.size_x = target_panel.size_x;
		destpan.size_y = target_panel.size_y;
		targetpan.pos_x=destpan.pos_x-target_panel.pos_x;
		targetpan.pos_y=destpan.pos_y-target_panel.pos_y;
		targetpan.size_x=target_panel.size_x;
		targetpan.size_y=target_panel.size_y;
		wait(1);
	}
	safe_remove(targetpan.target_map);
	safe_remove(destpan.bmap);
	safe_remove(targetpan);
	safe_remove(destpan);
}

//EVO2D FX Test
function main()
{
	fps_max=60;
	vec_set(screen_color,vector(1,1,1));
	vec_set(sky_color,vector(0,0,0));
	video_mode=9;
	video_screen=2;
	video_set(800,600,32,2);
	wait(3);
	
	//Create primary panels from string data
	testpanA = pan_create ( testpanAstr, 0 );
	testpanB = pan_create ( testpanBstr, 1 );
	testpanC = pan_create ( testpanCstr, 2 );
	wait(1);
	
	//Need this. Otherwise vecTime doesn't work.
	level_load("");
	
	//convert rock.tga to normalmap
	bmap_to_normals(bump_map,10);
	
	//Example
	//Plays through adding and removing material effect panels
	//If fx have the same ID, they will be removed at the same time when calling remove_fx(ID);
	//If fx have different IDs, only that fx ID will be removed when calling remove_fx(ID);
	wait(-2);
	fx_shader(0, testpanA, testpanAstr, test_mat, 100, 0);
	wait(-2); 
	fx_shader(0, testpanB, testpanBstr, mtl_erode, 100, 1);
	wait(-2);
	fx_shader(0, testpanC, testpanCstr, mtl_sharpen2, 100, 2);
	wait(-2);
	remove_fx(0);
	wait(-2);
	fx_shader(0, testpanA, testpanAstr, mtl_sepia, 100, 0);
	wait(-2); 
	fx_shader(0, testpanB, testpanBstr, mtl_monochrome, 100, 1);
	wait(-2);
	fx_shader(0, testpanC, testpanCstr, mtl_negative, 100, 2);
	wait(-2);
	remove_fx(0);
	wait(-2);
	fx_shader(0, testpanA, testpanAstr, mtl_emboss, 100, 0);
	wait(-2); 
	fx_shader(0, testpanB, testpanBstr, mtl_laplace, 100, 1);
	wait(-2);
	fx_shader(0, testpanC, testpanCstr, mtl_lens, 100, 2);
	wait(-2);
	remove_fx(0);
	wait(-2);
	
	fx_shader(0, testpanA, testpanAstr, test_mat, 100, 0);
	
	while(!key_esc){wait(1);}
	sys_exit("exit");
}