/************************************************
 *												*
 *	   	    SINGLE SPRITE DISPLAY CODE  		*
 *		  ==============================		*
 *												*
 *		   	 Written by Steven Lewis	    	*
 *												*
 *		  	     Downloaded from: 	 			*
 *		  	   Steve's Yaroze Site				*
 *	 http://www.netyaroze-europe.com/~slewis/	*
 *												*
 *					 e-mail:					*
 *	stevenlewis@birminghamhome.freeserve.co.uk	*
 *												*
 *	This code displays 4, 8, or 16-bit sprites	*
 *												*
 ************************************************/
 

// ----------------------------- HEADER FILES -----------------------------------

#include <libps.h>		// Should be used in all Yaroze programs 
#include "pad.h"		// File for PlayStation joypad reading routines

// ------------------------------------------------------------------------------


// ----------------------------- DEFINITIONS ------------------------------------

#define SCREEN_WIDTH	(320)		// Sets the width of the screen to be 320 pixels
#define SCREEN_HEIGHT	(256)		// Sets the height of the screen to be 256 pixels

#define SPRITE_COUNT	(1+1)		/* 	Sets the total number of sprites as the number of
										sprites in this program plus 1, with the plus 1
										being so the Ordering Table PACKET area has plenty
										of room  */

#define TIM_ADDRESS		(0x80100000)	/* 	The location at which the TIM file sprite will 
											be loaded into the PlayStations memory.
											This value will also have to be placed into 
											the batch file which runs this program */
											
#define OT_LENGTH		(1)			/*  Sets the length of the Ordering Table equal to 1.
										Subsequently, as there is only one sprite, there is 
										no need for an Ordering Table length larger than 
										this because one sprite does not need to go infront, 
										or behind, any other object on screen */
										
// -----------------------------------------------------------------------------


// -------------------- ORDERING TABLE RELATED VARIABLES -----------------------

GsOT		WorldOT[2];				/*  Sets the header for the Ordering Table to be an
										array of two elements, thus we are creating two headers.
										The reason for needing two is because we are 
										using the Double Buffering technique to display
										our sprite. We need one Ordering table to display
										the on screen sprite, and another to draw correctly
										to the off screen area.  Thus we need one header for 
										each of our two ordering tables */

GsOT_TAG	OTTags[2][1<<OT_LENGTH];	/* 	Sets the size of the body or our Odering Tables.
											Again there are two, one for each Ordering table */
										
PACKET		GpuPacketArea[2][SPRITE_COUNT*sizeof(GsSPRITE)];	/*  Sets the size of the
																	primitive work are for
																	the Ordering Table, it is
																	where are the sprites are
																	put into their correct
																	layering order. Needs to
																	be at least the size of
																	the total number of
																	sprites. Again two are
																	set up here.	*/
																	
int activeBuffer;	/*	Variable used to store the number of the Double Buffering Frame
						currently in use	*/ 
																	
// ------------------------------------------------------------------------------


// ----------------------- SPRITE INFORMATION HANDLER ---------------------------

GsSPRITE	sprite;			// Holds all of the information needed about our sprite

// ------------------------------------------------------------------------------


// ---------------------- CONTROLLER RELATED VARIABLES --------------------------

volatile u_char *pad1Buff, *pad2Buff;		// Used for storing pad infomation

// ------------------------------------------------------------------------------


// --------------------------- PROTOTYPE FUNCTIONS ------------------------------

void InitSprite();		// Sets up the sprite

static u_long ReadPads(long);

static long CheckPads();

// ------------------------------------------------------------------------------


// ------------------------------- MAIN FUNCTION --------------------------------

void main()
{
	int i;			// Variable which is used to initialise the Ordering Tables later
	
	SetVideoMode(MODE_PAL);		// Change MODE_PAL to MODE_NTSC if required
	
	GsInitGraph(SCREEN_WIDTH,SCREEN_HEIGHT,4,0,0);		/*  This command sets up the graphics
															system on the Yaroze. Until this
															statement is called no graphical
															functions can be used. The command
															used on the left has set up a
															non-interlaced mode.  */
															
	GsDefDispBuff(0,0,0,SCREEN_HEIGHT);					/*	This sets up the areas used in the
															Frame Buffer for Double Buffering.
															The first two coordinates(0,0) are
															the top left x and y values of 
														   	buffer 1, and the second two
															coordinates are the top left x and
															y values of buffer 2. This places
															buffer 2 directly under buffer 1 */
															
	// The following is an 'if' loop to correct the PAL screen display
	if(SCREEN_HEIGHT==256)
	{
		GsDISPENV.screen.h = SCREEN_HEIGHT;		// Makes PAL display less 'letterboxed'
	}
															
	// The following is a 'for' loop used to initialise the Ordering Tables
	for(i=0;i<2;i++)
	{	
		WorldOT[i].length = OT_LENGTH;	// Sets the length of the Ordering Tables
	
		WorldOT[i].org = OTTags[i];		/*	Points the headers of the Ordering Tables
											to their bodies, so to speak  */
	}
	
	InitSprite();		// Calls the Initiate Sprite function, found after this main function
	
	GetPadBuf( &pad1Buff, &pad2Buff);	// Sets the address' of the controller buffers
	
	// The following is the main 'while' loop of the entire program
	while((CheckPads())!=99)
	{
		activeBuffer = GsGetActiveBuff();		// Checks which buffer is currently being used
		
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuffer]);	/*	Sets the work area for which
																	our sprite can be drawn
																	to */
																	
		GsClearOt(0,0,&WorldOT[activeBuffer]);	// Clears the Ordering table
		
		GsSortFastSprite(&sprite,&WorldOT[activeBuffer],0);	/*	This registers our sprite
																	into the Ordering Table */
																	
		DrawSync(0);		/*	This makes the loop wait for any current drawing to the
								Frame Buffer to finish */
		
		VSync(0);			/*	This makes the loop wait for the PlayStation screen to finish 
								drawing the previous image	*/
								
		GsSwapDispBuff();	/*  Swaps the buffer which has just been drawn on screen with the
								buffer that has been drawn in the PlayStations
								graphics memory */
								
		GsSortClear(0,0,0,&WorldOT[activeBuffer]);		/*	Sorts whatever is in the buffer 
															about to be drawn to thescreen into  
															order. In otherwords the Ordering 
															Table is sorted.  */
		GsDrawOt(&WorldOT[activeBuffer]);	// Draws the current off screen buffer to the screen
	} 
	
}

// ------------------------------------------------------------------------------


// ------------------------------ Other Functions -------------------------------

void InitSprite()
{
	RECT	rect;		/*	Structure which defines a rectangular area around our sprite.
							Used to store our TIM file into the Frame Buffer	*/
	
	GsIMAGE	tim_info;	//	Holds all of the information about our TIM file
	
	GsGetTimInfo((u_long *)(TIM_ADDRESS+4),&tim_info);	/*	This takes the information about
															the TIM file from the actual TIM
															image and stores it in the variable
															called 'tim_info'	*/
															
	// The following five lines load the Image from the TIM file into the Frame Buffer
	rect.x = tim_info.px;		// x position in Frame Buffer
	rect.y = tim_info.py;		// y position in Frame Buffer
	rect.w = tim_info.pw;		// width of the image
	rect.h = tim_info.ph;		// height of the image
	LoadImage(&rect, tim_info.pixel);	// Loads all of the above into the Frame Buffer
	
	// The following 'if' loop checks to see whether the image has a Colour Look Up Table (CLUT)
	if((tim_info.pmode>>3)&0x01)
	{
		// If the image does have a CLUT then it too is also loaded into the Frame Buffer
		rect.x = tim_info.cx;		// x position in Frame Buffer
		rect.y = tim_info.cy;		// y position in Frame Buffer
		rect.w = tim_info.cw;		// width of the CLUT
		rect.h = tim_info.ch;		// height of the CLUT
		LoadImage(&rect, tim_info.clut);	// Loads all of the above into the Frame Buffer
	}
	
	/*  The following 'switch' statement checks to see what type of Sprite is in the TIM file, 
		be it 4 bit, 8 bit, or 16 bit, and sets the sprite structure accordingly	*/
	switch(tim_info.pmode)
	{
		// If the image is 4 bit with a CLUT
		case 0x08:	sprite.attribute = 0x00000000;
					sprite.w = tim_info.pw*4;
					sprite.tpage = GetTPage(0,0,tim_info.px,tim_info.py);
					break;		// Statement to break from the switch statement
		
		// If the image is 8 bit with a CLUT
		case 0x09:	sprite.attribute = 0x01000000;
					sprite.w = tim_info.pw*2;
					sprite.tpage = GetTPage(1,0,tim_info.px,tim_info.py);
					break;
					
		// If the image is 16 bit
		default:	sprite.attribute = 0x02000000;
					sprite.w = tim_info.pw;
					sprite.tpage = GetTPage(2,0,tim_info.px,tim_info.py);
					break;
	}
	
	/*  The following lines are a continuation of the above sprite structure statements, but
		these are not dependent on the type of sprite that is being displayed, they work for
		all sprites, unlike the above	*/
	
	if(tim_info.pmode==0x02)	// If loop to check if the sprite is 16 bit so it can center it properly
	{
		sprite.x = ((SCREEN_WIDTH/2)-(tim_info.pw/2));	// Sets the x screen position of the sprite
	}
	else
	{
		sprite.x = ((SCREEN_WIDTH/2)-(tim_info.pw));	// Sets the x screen position of the sprite  
	}	
	
	sprite.y = ((SCREEN_HEIGHT/2)-(tim_info.ph/2));	// Sets the y screen position of the sprite  
	
	sprite.h = tim_info.ph;			// Sets the height of the sprite on screen
	
	sprite.u = 0;		// Sets the texture page offset of the sprite along the x axis
	
	sprite.v = 0;		// Sets the texture page offset of the sprite along the y axis
	
	sprite.cx = tim_info.cx;		// Sets the x position of the CLUT, if any
	
	sprite.cy = tim_info.cy;		// Sets the y position of the CLUT, if any
	
	sprite.r = 128;		// Used to apply brightness to the sprite, 128 is normal
	
	sprite.g = 128;		// Used to apply brightness to the sprite, 128 is normal
	
	sprite.b = 128;		// Used to apply brightness to the sprite, 128 is normal
	
	sprite.mx = sprite.w/2;	// Sets the center point of the sprite for use with rotation etc
	
	sprite.my = sprite.h/2;	// Sets the center point of the sprite for use with rotation etc
	
	sprite.scalex = 4096;		// Sets sprite scaling to default, x axis
	
	sprite.scaley = 4096;		// Sets sprite scaling to default, y axis
	
	sprite.rotate = 0;			// Sets rotation to off
	
	DrawSync(0);	// Waits for the LoadImage() function to finish before continuing
	
	printf("Hello Anna!");		/* 	Sends confirmation to the PC monitor when the sprite
									has been loaded		*/
	
}

// ---------------------------------------------------------------------------


// ----------------------- Pad Reading Function ------------------------------

static u_long ReadPads(long id)
{
	// This function reads the pads and returns the current pad value
	return(~(*(pad1Buff+3) | *(pad1Buff+2)<<8 | *(pad2Buff+3)<<16 | *(pad2Buff+2)<<24));
}

// ---------------------------------------------------------------------------

static long CheckPads()
{
	// This checks the status of the pads to see if a button has been pressed
	u_long padd = ReadPads(1);
	
	/* 	The following 'if' loop checks to see if the select button has been pressed and
		if it has, the value 99 is returned to main() where the call to this fuction was made */
	if(padd & PADselect)
	{
		return(99);
	}
}