/****************************************************
 *													*
 *	     	TEXTURE PAGE ANIMATION TEST 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 loads in one TIM file and, by			*
 *	changing the U and V values of the image,		*
 *	creates an amazing(!) two-framed animation.		*
 *	Pressing left on the joyapd in port 1 reveals	*
 *	this epic piece of coding. The reason behind	*
 * 	this code is just to highlight the				*
 *	techniques involved in using this process		*
 *	to create an animation. Alterations can			*
 *	easily be made to this code to produce more		*
 *	advanced animations consisting of many more		*
 *	frames, but I could only be bothered to put		*
 *	in two.  Please note that if you decide to		*
 *	use this code with an image of your own, you	*
 *	will need to make a note of the width of your	*
 *	TIM file.  The one used in this example (which	*
 *	took a whole minute to draw) is 100 pixels		*
 *	wide, and in the code below you will see		*
 *	reference to this value being halved when left	*
 *  is pressed on the joypad. You will need to		*
 *	alter this value to suit whatever width your 	*
 *	image is. Also of note is that as far as I am	*
 *  aware every sprite needs to be taken from an	*
 *  area of exactly the same size. For example, in 	*
 *  this code the images are located in TIM file	*
 *  areas of 50 pixels by 200 pixels.  If another	*
 *  frame was added, it would need to be in another	*
 *  area of this size.  This is due to the way the	*
 *  this animation method works, the TIM file is	*
 *  broken up into sections of a certain size and	*
 *  whatever is contained within that section is	*
 *  displayed. Got that?  Good!	And can I once		*
 *  again apologise for the quality of the sprites.	*
 *  I will try harder next time :)					*
 *													*
 ****************************************************/
 
// --------------
// HEADER FILES
// --------------

#include <libps.h>
#include <pad.h>


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

#define SPRITE_COUNT	(2)		// Set the total number of sprites

#define TIM_ADDRESS	(0x80094000)	// Memory location of the single TIM file

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

#define SPRITETPAGEX	(100)	// Sets the width of the TIM file
#define SPRITETPAGEY	(200)	// Sets the height of the TIM file

// -------------------------
// SPRITE STRUCTURE POINTER
// -------------------------

GsSPRITE	sprite;		// Sets a structure to load the TIM into


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

#define OT_LENGTH	(1)		// Sets the length of the Ordering Table

GsOT		WorldOT[2];		// Sets two OT headers
GsOT_TAG	OTTags[2][1<<OT_LENGTH];	// Sets two 'bodies' for the OT
PACKET		GpuPacketArea[2][SPRITE_COUNT*sizeof(GsSPRITE)];	// Space for drawing the OT

int activeBuffer;		// Variable for storing the number of the active display buffer


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

volatile u_char *padBuffer, *pad2Buffer;		// Pointer to buffer where the PSX can store pad info

u_long padCheck;	// Variable used to store whether or not the pad is being used.


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

static u_long ReadPad(long);		// Function for reading PlayStation pad 1
static long InitPad();				// Function for setting up PlayStation pad 1
void InitSprites();					// Function for loading in the TIM file



// ---------------------------------
// GLOBAL SCREEN POSITION VARIABLES
// ---------------------------------

int screenPositionx,screenPositiony;	// Sets the screen position of the sprites



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

void main()
{
	int i;		// Variable used for Initialising the OT below
	
	// Set up the PlayStation graphics mode
	SetVideoMode(MODE_PAL);		// Sets PSX to use PAL display
	
	GsInitGraph(SCREEN_WIDTH,SCREEN_HEIGHT,4,0,0);	// Set up a non-interlaced graphics mode
	
	GsDefDispBuff(0,0,0,SCREEN_HEIGHT);		// Define the Double Buffering positions
	
	if(SCREEN_HEIGHT==256)
		GsDISPENV.screen.h = SCREEN_HEIGHT;		// Slightly fixes PAL letterbox problem
		
	
	// Initialise the OT
	for(i=0;i<2;i++)
	{
		WorldOT[i].length = OT_LENGTH;	// Sets the length of each OT
		WorldOT[i].org = OTTags[i];		// Joins the header of each OT to its body
	}
	
	screenPositionx=100;	// Screen x Position of sprite
	screenPositiony=50;		// Screen y Position of sprite
	
	InitSprites();		// Calls the InitSprite() function
		
	GetPadBuf(&padBuffer,&pad2Buffer);		// Sets the address of the joypad buffers
	
	
	// Main program loop
	while((InitPad()) != 99)
	{
		if(padCheck & PADLleft)		// If statement to see if left is pressed on joypad 1
		{
			sprite.u+=(SPRITETPAGEX/2);		/* Increases the sprite.u textrue page value by the width
											   of the TIM file divided by two. This is because the TIM
											   file is 100 pixels wide, and is split up into two 50
											   pixel sprites. The first of these sprites starts at the
											   pixel value 0, and the second starts at 50. When left is
											   pressed, as is the case in this loop, the image positioned
											   at 50 is shown.  The sprite.u value is used for the width
											   of the sprite. If you wanted to display an image that was
											   positioned under another in the TIM file, the sprite.v value
											   would need to be altered.	*/
											  
			
			if(sprite.u>(100/2))	// Keeps the texture page value at 50 while left is pressed.
				sprite.u=(100/2);
		}
			
				
		if(!(padCheck & PADLleft))	
			sprite.u=0;				/* If left is not pressed then the original image is displayed on screen.
									   This is the image that starts at the pixels value 0.	*/
			
			
		activeBuffer = GsGetActiveBuff();		// Finds out which buffer is active
		
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuffer]);	// Initialises the drawing environment for the OT's
		
		GsClearOt(0,0,&WorldOT[activeBuffer]);	// Clears the OT
		
		GsSortFastSprite(&sprite,&WorldOT[activeBuffer],0);	// Draws tim image into the OT
		
		DrawSync(0);		// Waits for the above to finish before continuing
		
		VSync(0);		// Waits for Vertical retrace to finish before continuing
		
		GsSwapDispBuff();	// Swaps the display buffers - active becomes inactive etc.
		
		GsSortClear(0,0,0,&WorldOT[activeBuffer]);	// Sorts the OT
		
		GsDrawOt(&WorldOT[activeBuffer]);		// Draws the OT
	}
}


// ------------------------------------------
// FUNCTION TO LOAD THE TIM FILE INTO MEMORY
// ------------------------------------------

void InitSprites()
{
	RECT rect;		// Creates a rectangular structure to put around the sprite
	GsIMAGE	tim_info;	// Creates a structure for holding all relevant TIM file info
	
	GsGetTimInfo((u_long *)(TIM_ADDRESS+4),&tim_info);	// Gets all relevant TIM file info
	
	// Load image into the frame buffer
	rect.x = tim_info.px;		// x position of image
	rect.y = tim_info.py;		// y position of image
	rect.w = tim_info.pw;		// width of image
	rect.h = tim_info.ph;		// height of image
	LoadImage(&rect,tim_info.pixel);		// Loads all of the above into the frame buffer
	
	// Load the CLUT into the Frame Buffer - If there is one
	if((tim_info.pmode>>3) & 0x01)
	{
		rect.x = tim_info.cx;		// x position of CLUT
		rect.y = tim_info.cy;		// y position of CLUT
		rect.w = tim_info.cw;		// width of CLUT
		rect.h = tim_info.ch;		// height of CLUT
		LoadImage(&rect,tim_info.clut);			// Loads all of the above into the frame buffer
	}
	
	// Switch statement to load the structure of the image
	switch(tim_info.pmode)
	{
		// If the image is 4-bit
		case 0x08:	sprite.attribute = 0x00000000;	// Sets the sprites properties
					sprite.w = (tim_info.pw*4)/2;	/* Sets the width of the visible image. Note the
													   fact that it is divided by two. This is because
													   there are two seperate sprites contained within
													   TIM file and only one is required to be displayed
													   at once. Subsequently the width of the sprite
													   is set as being half of the total TIM file
													   width.	*/
					sprite.tpage = GetTPage(0,0,tim_info.px,tim_info.py);	// Texture page info
					break;	// Leaves the switch statement
					
		// If the image is 8-bit
		case 0x09:	sprite.attribute = 0x01000000;
					sprite.w = (tim_info.pw*2)/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/2;
					sprite.tpage = GetTPage(2,0,tim_info.px,tim_info.py);
					break;
	}
	
	sprite.x = screenPositionx;		// x screen position of sprite
	sprite.y = screenPositiony;		// y screen position of sprite
	
	sprite.h = tim_info.ph;			// width of the sprite
	
	sprite.u = 0;			// x texture page value
	sprite.v = 0;			// y texture page value
	
	sprite.cx = tim_info.cx;			// CLUT x position for sprite
	sprite.cy = tim_info.cy;			// CLUT y position for sprite
	
	sprite.r = 128;		// Applies a red tint to the sprite - 128 is normal
	sprite.g = 128;		// Applies a green tint to the sprite - 128 is normal
	sprite.b = 128;		// Applies a blue tint to the sprite - 128 is normal
	
	sprite.mx = (sprite.w/2);	// Sets x value for the center of the sprite
	sprite.my = (sprite.h/2);	// Sets y value for the center of the sprite
	
	sprite.scalex = ONE;	// Sets x axis scale ratio - ONE = a 1:1 ratio
	sprite.scaley = ONE;	// Sets y axis scale ratio - ONE = a 1:1 ratio
	
	sprite.rotate = 0;		// Sets the rotation of the sprite to 'off'
}


// ---------------------
// PAD READING FUNCTION
// ---------------------

static u_long ReadPad(long)
{
	return(~(*(padBuffer+3)|*(padBuffer+2)<<8));	// Pad reading information
}


// ------------------------------------
// FUNCTION TO INITIATE THE PSX JOYPAD
// ------------------------------------

static long InitPad()
{
	padCheck = ReadPad(1);		// If the pad is used the previous function is called
	
	if(padCheck & PADselect)	// If statement to see if 'Select' is pressed on the joypad
		return(99);
}