#include <allegro.h>
#include "alleggl.h"

volatile int chrono = 0;

void the_timer(void) {
	chrono++;
} END_OF_FUNCTION(the_timer);


int poly_coords[12] = {150, 400,   200, 400,   225, 425,   200, 450,   175, 450,   175, 425};


/* Some common colours */
#define CYAN makecol(0,255,255)
#define BLACK makecol(0,0,0)
int main()
{
	float rotate = 0;
	BITMAP *save_bmp;
	BITMAP *sub_screen, *sub_screen2, *vid_bitmap, *mem_bitmap, *vid_bitmap2,
	       *trans_mem_bitmap, *trans_vid_bitmap, *trans_vid_bitmap2,
	       *large_vid_bitmap, *proxy_vid_bitmap, *vid_pattern;
	RLE_SPRITE *rle_sprite, *trans_rle_sprite;
	int keypress;
	int frame_count = 0, frame_count_time = 0;
	int x, y;
	float fps_rate = 0.0;

	allegro_init();
	install_allegro_gl();
	install_timer();

	allegro_gl_set(AGL_DOUBLEBUFFER, 1);
	allegro_gl_set(AGL_WINDOWED, TRUE);
	allegro_gl_set(AGL_COLOR_DEPTH, 32);
	allegro_gl_set(AGL_SUGGEST, AGL_DOUBLEBUFFER | AGL_WINDOWED
	             | AGL_COLOR_DEPTH);

	if(set_gfx_mode(GFX_OPENGL, 640, 480, 0, 0)<0) {
		allegro_message ("Error setting OpenGL graphics mode:\n%s\n"
		                 "Allegro GL error : %s\n",
		                 allegro_error, allegro_gl_error);
		exit(0);
	}

	/* Needed because of a bug. */
	allegro_gl_set_allegro_mode();
	allegro_gl_unset_allegro_mode();

	save_bmp = create_bitmap (640, 480);
	ASSERT (save_bmp);

	sub_screen  = create_sub_bitmap(screen, 320, 0, 128, 96);
	sub_screen2 = create_sub_bitmap(screen, 448, 0, 128, 96);
	ASSERT(sub_screen);
	ASSERT(sub_screen2);

	vid_bitmap = create_video_bitmap(50, 50);
	clear_to_color(vid_bitmap, makecol(255,0,255));
	rect(vid_bitmap, 10, 10, 39, 39, makecol(255, 255, 255));
	rectfill(vid_bitmap, 12, 12, 37, 37, makecol(255, 0, 0));
	triangle(vid_bitmap, 9, 9, 46, 3, 0, 16, makecol(0, 255, 0));

	mem_bitmap = create_bitmap(50, 50);
	clear(mem_bitmap);
	blit(vid_bitmap, mem_bitmap, 25, 25, 10, 10, 50, 50);

	vid_pattern = create_video_bitmap(32, 32);
	clear_bitmap(vid_pattern);
	blit(vid_bitmap, vid_pattern, 0, 0, 0, 0, 32, 32);

	TRACE("Starting main loop\n");
	save_bitmap("dumbtest.bmp", mem_bitmap, NULL);

	rle_sprite = get_rle_sprite(mem_bitmap);

	vid_bitmap2 = create_video_bitmap(64, 64);
	clear_to_color(vid_bitmap2, makecol(255,0,255));
	blit(mem_bitmap, vid_bitmap2, 0, 0, 10, 10, 50, 50);

	trans_mem_bitmap = create_bitmap_ex(32, mem_bitmap->w, mem_bitmap->h);
	for (y = 0; y < mem_bitmap->h; ++y) {
		for (x = 0; x < mem_bitmap->w; ++x) {
			int col = getpixel(mem_bitmap, x, y);
			putpixel(trans_mem_bitmap, x, y, makeacol32(getr(col), getg(col), getb(col), y*4));
		}
	}

	allegro_gl_set_video_bitmap_color_depth(32);

	trans_vid_bitmap2 = create_video_bitmap(64, 64);
	clear_bitmap(trans_vid_bitmap2);
	blit(trans_mem_bitmap, trans_vid_bitmap2, 0, 0, 10, 10, 50, 50);

	trans_vid_bitmap = create_video_bitmap(50, 50);
	clear_to_color(trans_mem_bitmap, makeacol32(255, 0, 255, 127));
	rect(trans_mem_bitmap, 10, 10, 39, 39, makeacol32(255, 255, 255, 127));
	rectfill(trans_mem_bitmap, 12, 12, 37, 37, makeacol32(255, 0, 0, 192));
	triangle(trans_mem_bitmap, 9, 9, 46, 3, 0, 16, makeacol32(0, 255, 0, 192));
	blit(trans_mem_bitmap, trans_vid_bitmap, 0, 0, 0, 0, 50, 50);

	trans_rle_sprite = get_rle_sprite(trans_mem_bitmap);

	allegro_gl_set_video_bitmap_color_depth(-1);

	large_vid_bitmap = create_video_bitmap(120, 120);
	clear_to_color(large_vid_bitmap, BLACK);
	rect(large_vid_bitmap, 0, 0, large_vid_bitmap->w-1, large_vid_bitmap->h-1, makecol(255, 255, 0));
	line(large_vid_bitmap, 0, 0, large_vid_bitmap->w, 30, makecol(255, 0, 0));
	line(large_vid_bitmap, large_vid_bitmap->w, 0, 0, large_vid_bitmap->h, makecol(255, 0, 0));
	
	proxy_vid_bitmap = create_video_bitmap(100, 100);
	clear_to_color(proxy_vid_bitmap, CYAN);
	line(proxy_vid_bitmap, 0, 0, proxy_vid_bitmap->w, proxy_vid_bitmap->h, makecol(255, 0, 0));

	/* memory -> video */
	blit(mem_bitmap, proxy_vid_bitmap, 0, 0, 5, 5, mem_bitmap->w, mem_bitmap->h);

	set_alpha_blender();
	/* memory -> video trans */
	draw_trans_sprite(proxy_vid_bitmap, trans_mem_bitmap, mem_bitmap->w, 5);
	/* video -> video trans */
	draw_trans_sprite(proxy_vid_bitmap, trans_vid_bitmap, 5, mem_bitmap->h);

{	/* textured 3d polygon -> video bitmap */
	V3D_f v1, v2, v3, v4;
	v1.x = 50; v1.y = 50; v1.u = 0; v1.v = 0;
	v2.x = 98; v2.y = 50; v2.u = 70; v2.v = 0;
	v3.x = 98; v3.y = 98; v3.u = 70; v3.v = 70;
	v4.x = 50; v4.y = 98; v4.u = 0; v4.v = 70;
	quad3d_f(proxy_vid_bitmap, POLYTYPE_ATEX, vid_pattern, &v1, &v2, &v3, &v4);
}

    /* video -> video */
	draw_sprite(large_vid_bitmap, proxy_vid_bitmap, 5, 5);

	textout_ex(large_vid_bitmap, font, "some text", 15, 35, -1, -1);

	install_keyboard();

	LOCK_VARIABLE(chrono);
	LOCK_FUNCTION(the_timer);

	install_int(the_timer, 5);

	/* Setup OpenGL like we want */
	glEnable(GL_TEXTURE_2D);


	do {
		if (keypressed())
			keypress = readkey();
		else
			keypress = 0;

		rotate+=1.0;
		if(rotate>360.0) rotate=0;

		glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

		glPushMatrix();
		glRotatef(45, 1, 0, 0);
		glRotatef(rotate, 0.0, 1.0, 0.0);
		glBegin(GL_QUADS);
			glColor3f(1.0, 0.0, 1.0);
			glVertex3f(0.1, 0.1, 0.1);
			glVertex3f(0.1, -0.1, 0.1);
			glVertex3f(-0.1, -0.1, 0.1);
			glVertex3f(-0.1, 0.1, 0.1);
			glColor3f(1.0, 0.0, 0.0);
			glVertex3f(0.1, 0.1, -0.1);
			glVertex3f(0.1, -0.1, -0.1);
			glVertex3f(-0.1, -0.1, -0.1);
			glVertex3f(-0.1, 0.1, -0.1);
			glColor3f(0.0, 1.0, 0.0);
			glVertex3f(0.1, 0.1, 0.1);
			glVertex3f(0.1, -0.1, 0.1);
			glVertex3f(0.1, -0.1, -0.1);
			glVertex3f(0.1, 0.1, -0.1);
		glEnd();
		glPopMatrix();

		frame_count++;

		if (frame_count >= 20) {
			if (chrono - frame_count_time)
				fps_rate = frame_count * 200.0 / (chrono - frame_count_time);
			else
				fps_rate = frame_count * 200.0;
			frame_count_time = chrono;
			frame_count = 0;
		}

		allegro_gl_set_allegro_mode();
		line(screen, 0, 0, 640, 480, makecol(0xff, 0, 0xff));
		triangle(screen, 115, 21, 150, 350, 5, 90, makecol(0xff, 0, 0));
		triangle(screen, 145, 21, 190, 350, 45, 90, makecol(0, 0, 0xff));
		triangle(screen, 205, 21, 240, 350, 95, 90, makecol(0, 0xff, 0xff));
		triangle(screen, 245, 21, 290, 350, 145, 90, makecol(0xff, 0xff, 0));
		rect(screen, 0, 0, 639, 479, makecol(0xff, 0xbf, 0x00));
		putpixel(screen, 0, 0, makecol(0xff, 0xff, 0xff));
		putpixel(screen, 639, 0, makecol(0xff, 0xff, 0xff));
		putpixel(screen, 0, 479, makecol(0xff, 0xff, 0xff));
		putpixel(screen, 639, 479, makecol(0xff, 0xff, 0xff));
		putpixel(screen, 0, 478, makecol(0xff, 0xff, 0xff));
		putpixel(screen, 639, 478, makecol(0xff, 0xff, 0xff));
		rectfill(screen, 16, 300, 256, 420, makecol(0xff, 0xff, 0xff));

		textout_ex(screen, font, "Partially cut off text", -3, 450,
		        makecol(255,255,255), -1);	
		textout_ex(screen, font, "Hello World!", 70, 330, BLACK, -1);
		textprintf_ex(screen, font, 70, 350, makecol(0, 0, 0), -1,
		           "FPS: %.2f", fps_rate);

		/* Now here's the interesting part. This section of code tests
		 * the various blit combinations supported by AllegroGL. That is:
		 *                 screen -> sub-bitmap of screen
		 *   sub-bitmap of screen -> sub-bitmap of screen
		 *                 screen -> screen
		 *           video bitmap -> screen
		 *                 screen -> memory bitmap
		 *          memory bitmap -> screen
		 *             rle sprite -> screen
		 *
		 *   Other combinations are tested either at the init.
		 */

		blit (screen, sub_screen, 256, 192, 0, 0, 128, 96);
		blit (sub_screen, sub_screen2, 0, 0, 0, 0, 128, 96);
		blit (screen, screen, 0, 0, 400, 150, 90, 90);
		blit (vid_bitmap, screen, 0, 0, 0, 0, 50, 50);
		blit (vid_bitmap2, screen, 0, 0, 50, 0, 50, 50);
		blit (screen, mem_bitmap, 0, 0, 0, 0, 50, 50);
		blit (mem_bitmap, screen, 0, 0, 100, 0, 50, 50);

		masked_blit (vid_bitmap, screen, 0, 0, 0, 50, 50, 50);
		masked_blit (vid_bitmap2, screen, 0, 0, 50, 50, 50, 50);
		masked_blit (mem_bitmap, screen, 0, 0, 100, 50, 50, 50);

		draw_sprite(screen, vid_bitmap, 0, 100);
		draw_sprite(screen, vid_bitmap2, 50, 100);
		draw_sprite(screen, mem_bitmap, 100, 100);
		draw_rle_sprite(screen, rle_sprite, 150, 100);

		set_alpha_blender();
		draw_trans_sprite(screen, trans_vid_bitmap, 0, 150);
		draw_trans_sprite(screen, trans_vid_bitmap2, 50, 150);
		draw_trans_sprite(screen, trans_mem_bitmap, 100, 150);
		draw_trans_rle_sprite(screen, trans_rle_sprite, 150, 150);

		pivot_scaled_sprite(screen, vid_bitmap, 0, 200, 0, 0, itofix(6), ftofix(1.1));
		pivot_scaled_sprite(screen, vid_bitmap2, 50, 200, 0, 0, itofix(6), ftofix(1.1));
		pivot_scaled_sprite(screen, mem_bitmap, 100, 200, 0, 0, itofix(6), ftofix(1.1));

		/* Write the captions for each image */
		textout_ex(screen, font, "blit", 200, 25, CYAN, BLACK);
		textout_ex(screen, font, "masked_blit", 200, 75, CYAN, BLACK);
		textout_ex(screen, font, "draw_sprite", 200, 125, CYAN, BLACK);
		textout_ex(screen, font, "draw_trans_sprite", 200, 175, CYAN, BLACK);
		textout_ex(screen, font, "pivot_scaled_sprite", 200, 225, CYAN, BLACK);
		textout_centre_ex(screen, font, "vid", 25, 275, CYAN, BLACK);
		textout_centre_ex(screen, font, "NPOT", 25, 285, CYAN, BLACK);
		textout_centre_ex(screen, font, "vid", 75, 275, CYAN, BLACK);
		textout_centre_ex(screen, font, "POT", 75, 275, CYAN, BLACK);
		textout_centre_ex(screen, font, "mem",125, 275, CYAN, BLACK);
		textout_centre_ex(screen, font, "rle",175, 275, CYAN, BLACK);

		drawing_mode(DRAW_MODE_SOLID, 0, 0, 0);
		rectfill(screen, 250, 400, 300, 450, CYAN);
		drawing_mode(DRAW_MODE_XOR, NULL, 0, 0);
		rect(screen, 270, 420, 280, 430, CYAN);
		solid_mode();
		
		polygon(screen, 6, poly_coords, CYAN);
		drawing_mode(DRAW_MODE_TRANS, 0, 0, 0);
		set_trans_blender(305, 255, 305, 128);
		rectfill(screen, 170, 400, 200, 450, BLACK);

		drawing_mode(DRAW_MODE_COPY_PATTERN, vid_pattern, 50, 50);
		triangle(screen, 320, 350, 430, 350, 320, 480, 0);
		rectfill(screen, 400, 400, 450, 450, 0);
		solid_mode();

		/* video -> screen stertching */
		stretch_blit(large_vid_bitmap, screen, 0, 0, large_vid_bitmap->w, large_vid_bitmap->h,
		             460, 350, large_vid_bitmap->w+50, large_vid_bitmap->h);

		allegro_gl_unset_allegro_mode();

		if ((keypress & 0xdf) == 'S')
			blit (screen, save_bmp, 0, 0, 0, 0, 640, 480);

		glFlush();
		allegro_gl_flip();

		if ((keypress & 0xdf) == 'S') {
		  save_bitmap ("screen.bmp", save_bmp, desktop_palette);
		}

		rest(2);

	}while(!key[KEY_ESC]);

	allegro_gl_set_allegro_mode();
	glDrawBuffer(GL_FRONT);
	glReadBuffer(GL_FRONT);

	textout_ex(screen, font, "Press any key to exit...", 0, 470,
	        makecol(255, 255, 255), -1);

	/* check the dialog saved the background OK */
	readkey();

	destroy_bitmap(save_bmp);
	destroy_bitmap(sub_screen);
	destroy_bitmap(sub_screen2);
	destroy_bitmap(mem_bitmap);
	destroy_bitmap(vid_bitmap);
	destroy_bitmap(vid_bitmap2);
	destroy_bitmap(trans_mem_bitmap);
	destroy_bitmap(trans_vid_bitmap);
	destroy_bitmap(trans_vid_bitmap2);
	destroy_bitmap(proxy_vid_bitmap);
	destroy_bitmap(large_vid_bitmap);
	destroy_bitmap(vid_pattern);
	destroy_rle_sprite(rle_sprite);
	destroy_rle_sprite(trans_rle_sprite);
	return 0;
}

END_OF_MAIN()

