/*======================*\
Motion Blurring tutorial
		by Tom
\*======================*/

#include <libps.h>
#include "MyPad.h"

#define OT_LENGTH		2
#define PACKETMAX		2048
#define PACKETMAX2		(PACKETMAX*24)
#define SCREEN_WIDTH	320
#define SCREEN_HEIGHT	256

#define SPRITE_ADDRESS 0x80090000

GsOT		WorldOT[2];	
GsOT_TAG	OTTags[2][1<<OT_LENGTH];
static PACKET packetArea[2][PACKETMAX2];
volatile u_char *bb0, *bb1;


void main(void);
void InitGame(void);
static u_long ReadPad(void);
void ProperInitialiseTexture(long TIMdata, GsIMAGE *imageInfo);
void SetUpSprite(GsSPRITE *sprite, GsIMAGE *image);

void main(void) {
	int activeBuff, j;
	u_long pad;
	GsSPRITE spriteHandler;
	GsSPRITE leftSprite, rightSprite;
	RECT rect;
	GsIMAGE imageHandler;
	long rotate = 0, scale = ONE, x = 160, y = 128, i;
	u_long row[160];
	
	InitGame();

	// Set up the test sprite in a function to make things look nicer
	SetUpSprite(&spriteHandler, &imageHandler);
	
	// As the screen is 320*256 and the maximum size of a sprite is
	// 256*256, two sprites are used, one for a 256*256 area on the
	// left of the screen and one for a 64*256 arena on the right of
	// the screen.
	// The two sprites have a (0.5 forground) + (0.5 background)
	// transparency/
	rightSprite.attribute	= leftSprite.attribute	= (1<<25)+(1<<30);
	rightSprite.x			= leftSprite.x			= 160;
	rightSprite.y			= leftSprite.y			= 128;
	rightSprite.h			= leftSprite.h			= 256;
	rightSprite.u			= leftSprite.u			= 0;
	rightSprite.v			= leftSprite.v			= 0;
	rightSprite.my			= leftSprite.my			= 128;
	rightSprite.scalex		= leftSprite.scalex		= ONE;
	rightSprite.scaley		= leftSprite.scaley		= ONE;
	rightSprite.rotate		= leftSprite.rotate		= 0;

	leftSprite.w	= 256;
	rightSprite.w	= 64;
	rightSprite.mx	= -96;
	leftSprite.mx	= 160;
	
	// As the blue value of the screen sprites is higher the the other
	// two, the trail left will be blue.
	leftSprite.r = rightSprite.r = 80;
	leftSprite.g = rightSprite.g = 80;
	leftSprite.b = rightSprite.b = 100;

	// Clear both screen buffers as otherwise the last screen displayed
	// will fade away (which sometimes looks nice, but most of the time
	// looks really bad).
	activeBuff = GsGetActiveBuff();
	GsSetWorkBase((PACKET *)packetArea[activeBuff]);
	GsClearOt(0, 0, &WorldOT[activeBuff]);
	DrawSync(0);
	GsSwapDispBuff();
	GsSortClear(0, 0, 0, &WorldOT[activeBuff]);
	GsDrawOt(&WorldOT[activeBuff]);
	
	activeBuff = GsGetActiveBuff();
	GsSetWorkBase((PACKET *)packetArea[activeBuff]);
	GsClearOt(0, 0, &WorldOT[activeBuff]);
	DrawSync(0);
	GsSwapDispBuff();
	GsSortClear(0, 0, 0, &WorldOT[activeBuff]);
	GsDrawOt(&WorldOT[activeBuff]);
	
	// Set the semi transparency bit for every pixel in the screen
	// buffers a row at a time.
	setRECT(&rect, 0, 0, 320, 1);
	for (j=0; j<512; j++) {
		rect.y = j;
		StoreImage(&rect, row);				// Load row into memory
		DrawSync(0);
		for (i=0; i<160; i++)
			row[i] |= (1<<15) + (1<<31);	// Set the STP bit
		LoadImage(&rect, row);
		DrawSync(0);
	}

	do {
		pad = ReadPad();
		activeBuff = GsGetActiveBuff();
		GsSetWorkBase((PACKET *)packetArea[activeBuff]);
		GsClearOt(0, 0, &WorldOT[activeBuff]);
		
		// This is all the same as in the sprite tutorial 2		
		if (pad & PADLleft)
			x-=4;
		if (pad & PADLright)
			x+=4;
		if (pad & PADLdown)
			y+=4;
		if (pad & PADLup)
			y-=4;
		
		if (pad & PADLX)
			scale -= 128;
		if (pad & PADLT)
			scale += 128;
		
		if (pad & PADLS)
			rotate -= 8*ONE;
		if (pad & PADLO)
			rotate += 8*ONE;
			
		spriteHandler.rotate = rotate;
		spriteHandler.scalex = scale;
		spriteHandler.scaley = scale;
		
		for (i=-3; i<4; i++) {
			spriteHandler.x = x;
			spriteHandler.y = y + i*32;
			GsSortSprite(&spriteHandler, &WorldOT[activeBuff], 1);
		}
		
		// OK. This bit gets the texture page of the previous screen
		// that was drawn (I think) and the screen is drawn over the
		// current screen using (0.5 fore) + (0.5 back) transparency.
		// Motion blurring has now been achieved!
		leftSprite.tpage = GetTPage(2,0,0,activeBuff<<8);
		rightSprite.tpage = GetTPage(2,0,256,activeBuff<<8);
		GsSortSprite(&leftSprite, &WorldOT[activeBuff], 0);
		GsSortSprite(&rightSprite, &WorldOT[activeBuff], 0);

		// Notice that GsSortClear() is not called
		DrawSync(0);
		VSync(0);
		GsSwapDispBuff();
		GsDrawOt(&WorldOT[activeBuff]);
	} while ((pad != PADLstart+PADLselect) && (pad != PADRselect+PADRstart));
}




void InitGame(void) {
	int i;
	
	SetVideoMode(MODE_PAL);
	GsInitGraph(SCREEN_WIDTH, SCREEN_HEIGHT, GsINTER|GsOFSGPU, 1, 0);
	GsDefDispBuff(0, 0, 0, SCREEN_HEIGHT);
	GsDISPENV.screen.h = 255;
	
	GetPadBuf(&bb0, &bb1);
	
	for (i = 0; i < 2; i++) {
		WorldOT[i].length = OT_LENGTH;
		WorldOT[i].org = OTTags[i];
		GsClearOt(0,0,&WorldOT[i]);
	}
}


// Generic sprite initialiser
void ProperInitialiseTexture(long TIMdata, GsIMAGE *imageInfo) {
	RECT rect;		// Frame buffer rectangular area

	// +4 because we need to skip head of TIM file
	// Put TIM data into GsIMAGE structure
	GsGetTimInfo((u_long *)(TIMdata+4), imageInfo);

	// define the area of the frame buffer to load the sprite into
	rect.x = imageInfo->px;
	rect.y = imageInfo->py;
	rect.w = imageInfo->pw;
	rect.h = imageInfo->ph;
	
	// Using rect data, load the pixel data held in the TIM file onto
	// the frame buffer
	LoadImage(&rect, imageInfo->pixel);
	// Wait for loading to finish
	DrawSync(0);

	// If image needs a CLUT, load it up 
	// (pmode: 8 or 9 ==> texture is 4-bit or 8-bit)
	if ((imageInfo->pmode>>3) & 0x01) {
		// define the area of the frame buffer to load the palette onto
		rect.x = imageInfo->cx;	
		rect.y = imageInfo->cy;	
		rect.w = imageInfo->cw;	
		rect.h = imageInfo->ch;	

		// Using rect data, load the palette onto the frame buffer
		LoadImage(&rect, imageInfo->clut);
		// wait for loading to finish
		DrawSync(0);
	}

}


void SetUpSprite(GsSPRITE *sprite, GsIMAGE *image) {
	ProperInitialiseTexture(SPRITE_ADDRESS, image);
	
	sprite->x = 160;
	sprite->y = 128;
	
	switch(image->pmode) {
		case(8):
			sprite->w = image->pw * 4;
			sprite->attribute = 0;		// 4 bit image
			break;
		case(9):
			sprite->w = image->pw * 2;
			sprite->attribute = 1<<24;	// 8 bit image
			break;
		case(2):
			sprite->w = image->pw;
			sprite->attribute = 2<<24;	// 16 bit image
			break;
		default:
			printf("Sorry, image bit depth '%d' is not supported (is the image 24 bit?)\n", image->pmode);
			exit(0);
			break;
	}
	
	sprite->h = image->ph;	
	sprite->u = image->px % 64;
	sprite->v = image->py % 256;
	sprite->cx = image->cx;
	sprite->cy = image->cy;
	sprite->r = 128;
	sprite->g = 128;
	sprite->b = 128;
	sprite->mx = 32;
	sprite->my = 16;
	sprite->tpage = GetTPage(image->pmode & 7, 0, image->px, image->py);
}


u_long ReadPad(void) {
	return(~(*(bb0+3) | *(bb0+2) << 8 | *(bb1+3) << 16 | *(bb1+2) << 24));
}