/*============================*\
Very simple sprite demonstration
			by Tom
\*============================*/

// Include the standard header
#include <libps.h>
// Include the pad definitions
#include "MyPad.h"

// Standard #defines for all my progs

// Length of the ordering table. If you increase
// this value, you can do more levels of depth sorting
#define OT_LENGTH		2

// Maximum number of graphics packets you can sort.
// I'm still not 100% certain about the way this
// works, if your program doesn't work, try increasing
// this value
#define PACKETMAX		2048
#define PACKETMAX2		(PACKETMAX*24)

// Screen resolution
#define SCREEN_WIDTH	320
#define SCREEN_HEIGHT	256

// Address of where the TIM file has been loaded
#define SPRITE_ADDRESS 0x80090000

// Ordering table (one for each screen buffer)
GsOT		WorldOT[2];	
GsOT_TAG	OTTags[2][1<<OT_LENGTH];
static PACKET packetArea[2][PACKETMAX2];
volatile u_char *bb0, *bb1;


// Function definitions
void main(void);
void InitGame(void);
static u_long ReadPad(void);
void ProperInitialiseTexture(long TIMdata, GsIMAGE *imageInfo);


void main(void) {
	int activeBuff;				// Holds the number of the active screen buffer (0 or 1)
	u_long pad;					// Holds pad information
	GsSPRITE spriteHandler;		// Handler for sprite structure
	GsIMAGE imageHandler;		// Handler for image structure
	
	// The sprite handler is used to display the sprite on the screen
	// and the image handler is used to transfer the TIM file onto the
	// frame buffer

	// Set up the game
	InitGame();

	// Load the sprite onto the frame buffer and put the information
	// into the image handler
	ProperInitialiseTexture(SPRITE_ADDRESS, &imageHandler);
	
	// Set up all the sprite variables
	spriteHandler.x = 160;								// display
	spriteHandler.y = 128;								// coordinates
	
	// set up the sprite width and type
	// because the frame buffer uses 16 bits to represent 1 pixel...
	// a 4 bit image holds 4 pixels per pixel on the frame buffer,
	// a 8 bit image holds 2 and
	// a 16 bit image holds 1
	//
	// by the way, the values of 'pmode' on page 30 of the
	// manual are wrong. (One error of many)
	// It's just occured to me that maybe bit 8 is set if the
	// image has a palette?
	switch(imageHandler.pmode) {
		case(8):
			spriteHandler.w = imageHandler.pw * 4;
			spriteHandler.attribute = 0;		// 4 bit image
			break;
		case(9):
			spriteHandler.w = imageHandler.pw * 2;
			spriteHandler.attribute = 1<<24;	// 8 bit image
			break;
		case(2):
			spriteHandler.w = imageHandler.pw;
			spriteHandler.attribute = 2<<24;	// 16 bit image
			break;
		default:
			printf("Sorry, image bit depth '%d' is not supported (is the image 24 bit?)\n", imageHandler.pmode);
			exit(0);
			break;
	}
	
	spriteHandler.h = imageHandler.ph;
	
	spriteHandler.u = imageHandler.px % 64;				// offset from top left
	spriteHandler.v = imageHandler.py % 256;			// of texture page
	
	spriteHandler.cx = imageHandler.cx;					// palette coordinates
	spriteHandler.cy = imageHandler.cy;					// in frame buffer
	
	spriteHandler.r = 128;								// rgb values of the
	spriteHandler.g = 128;								// sprite. (Used to tint
	spriteHandler.b = 128;								// the sprite)
	
	spriteHandler.mx = 32;								// define rotation and
	spriteHandler.my = 16;								// scaling coordinates
	
	spriteHandler.scalex = ONE;							// scaling factors
	spriteHandler.scaley = ONE;							// ONE = 4096
	
	spriteHandler.rotate = 0;							// sprite rotation
	
	// get the texture page number
	spriteHandler.tpage = GetTPage(imageHandler.pmode & 7, 0, imageHandler.px, imageHandler.py);
	
	do {
		pad = ReadPad();									// get the pad status
		activeBuff = GsGetActiveBuff();						// get the active screen buffer

		GsSetWorkBase((PACKET *)packetArea[activeBuff]);	// set the area for NY to store
															// drawing info

		GsClearOt(0, 0, &WorldOT[activeBuff]);				// clear the ordering table
		
		
		// Draw Here
		GsSortSprite(&spriteHandler, &WorldOT[activeBuff], 0);
		
		DrawSync(0);		// wait for all the drawing to be done
		VSync(0);			// wait for a vertical sync
		GsSwapDispBuff();	// swap the screen buffers that are displayed
		
		GsSortClear(0, 0, 0, &WorldOT[activeBuff]);	// clear the screen
		GsDrawOt(&WorldOT[activeBuff]);				// draw it all
		
		// loop until start & select are held down
	} while ((pad != PADLstart+PADLselect) && (pad != PADRselect+PADRstart));
}




void InitGame(void) {
	int i;
	
	// set the video mode to PAL
	SetVideoMode(MODE_PAL);
	
	// tell the NY about how to set up the graphics
	GsInitGraph(SCREEN_WIDTH, SCREEN_HEIGHT, GsINTER|GsOFSGPU, 1, 0);
	
	// define the 2 screen buffers
	GsDefDispBuff(0, 0, 0, SCREEN_HEIGHT);
	
	// for some reason, if you're running in PAL mode, you need to change
	// the screen height to 255
	GsDISPENV.screen.h = 255;
	
	// set up the pad handling variables
	GetPadBuf(&bb0, &bb1);
	
	// set up the ordering tables
	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);
	}

}


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