/************************************************
 *												*
 *		SCROLLING BACKGROUND DEMONSTRATION		*
 *	   ====================================		*
 *												*
 *			 Written by Steven Lewis			*
 *												*
 *				 Downloaded From:				*
 *   http://www.netyaroze-europe.com/~slewis/   *
 *												*
 *					 e-mail:					*
 *  stevenlewis@birminghamhome.freeserve.co.uk	*
 *												*
 *	This program loads in two 160*256 TIM files	*
 *	and turns them into a scrolling background	*
 *		which loops until select is pressed		*
 ************************************************/
 
 
 // ---------------
 // HEADER FILES
 // ---------------

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


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

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

#define TIM_ADDRESS1	(0x80094000)	// States where the first TIM is located in memory
#define TIM_ADDRESS2	(0x800a4000)	// States where the second TIM file is located

#define NO_OF_BACKGROUND_IMAGES	(2)	// Sets the number of images on screen at one time


// ---------------------------
// 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 OT 'bodies'
PACKET		GpuPacketArea[2][NO_OF_BACKGROUND_IMAGES*sizeof(GsSPRITE)];	/* 	Sets the GPU packet
																			work area	*/


// -------------------
// GLOBAL VARIABLES
// -------------------

int activeBuffer;	// Stores the value of the active Double Buffer
short scrollCounter = 0;	// A counter used for scrolling the screen
int i, checkNo;	/* 'i' is used for a variety of initialisation tasks in the main function
					checkNo is used for setting the correct screen position of the background
					images	*/


// ----------------------------------
// INITIALISE THE SPRITE STRUCTURE
// ----------------------------------

GsSPRITE sprite[NO_OF_BACKGROUND_IMAGES];	/*  A structure used for holding infromation about
												each sprite	*/



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

volatile u_char *pad1Buffer, *pad2Buffer;	// Two pinters to buffers where pad info is stored                                                     
int padCheck;	// Global variable which checks for the pad being used


// ----------------------
// PHROTOTYPE FUNCTIONS
// ----------------------

void InitBG(GsSPRITE* sprite, long spriteAddress);	// Loads in the background

static u_long ReadPads(long);	// Reads what is being pressed on the joypads

static long InitPads();	// Initialises the joypads ready for use



// ------------------
// MAIN() FUNCTION
// ------------------

void main()
{
	int i;	// working variable
	
	u_long currentSpriteAddress;	// A varible for storing a sprite address
	
	GsInitGraph(SCREEN_WIDTH,SCREEN_HEIGHT,4,0,0);	// Initialises the graphics system
	
	GsDefDispBuff(0,0,0,SCREEN_HEIGHT);	// Sets up the double buffers
	
	
	SetVideoMode(MODE_PAL);	// Sets the video mode to PAL

	
	GetPadBuf(&pad1Buffer, &pad2Buffer);	// Sets the address of the joypad buffers
	
	if(SCREEN_HEIGHT==256)	// Helps to improve the PAL letterbox problem
		GsDISPENV.screen.h = SCREEN_HEIGHT;	

	FntLoad(960,256);	// Loads a PlayStation font into memory
	
	FntOpen(20,200,SCREEN_WIDTH,50,0,256);	// Sets up the display parameters for the font

	// Set up the Ordering Table
	for(i=0;i<2;i++)
	{
		WorldOT[i].length = OT_LENGTH;	// Sets the length of the OT
		WorldOT[i].org = OTTags[i];		// Connects the header of each OT to its 'body'
	}
	
	checkNo = 0;	// Initialise the varible
	
	// Loads the background into the frame buffer - only needs to be done once	
	for(i=0;i<2;i++)
	{
		if(i==0)	// Sets the memory address for first part of the background
		{
			currentSpriteAddress = TIM_ADDRESS1;
			checkNo = 1;
		}
		
		if(i==1)	// Sets the memory address for the second part of the background
		{
			currentSpriteAddress = TIM_ADDRESS2;
			checkNo = 2;
		}
		
		InitBG(&sprite[i],currentSpriteAddress);	// Loads the backgounds	
	}	
	
	// Main loop of the program - keeps going until select is pressed
	while((InitPads()) != 99)	
	{
		FntPrint("~c900SCROLLING BACKGROUND DEMONSTRATION"); // Prints text onto the PSX screen
		
		activeBuffer = GsGetActiveBuff();	// Finds out which buffer is currently active
		
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuffer]);	/*	Sets the work space for
																	drawing the OT	*/
		
		GsClearOt(0,0,&WorldOT[activeBuffer]);	// Clears the OT ready to use
		
		FntFlush(-1);	// Sends the previous 'FntPrint' text into the OT
		
		// Scrolling code
		
		scrollCounter -= 1;	// Subtracts one from the scroll counter each time this loop is run
		
		if(scrollCounter <= -SCREEN_WIDTH)
			scrollCounter = 0; 	// Resets the scroll counter when it exceeds -320
		
		
		
		// Draw the Background
		
		sprite[0].x = scrollCounter;	// Sets background 1 screen position
		GsSortFastSprite(&sprite[0], &WorldOT[activeBuffer], 0);	// draws background 1
		
		
		sprite[1].x = scrollCounter + (SCREEN_WIDTH/2);	/* 	Sets background 2 to be drawn
															at background 1 position + 160	*/
		GsSortFastSprite(&sprite[1], &WorldOT[activeBuffer], 0);	// draws background 2
		
		
		sprite[0].x = scrollCounter + SCREEN_WIDTH;		/*	Sets background 1 to be drawn
															again at background 1 position+320*/
		GsSortFastSprite(&sprite[0], &WorldOT[activeBuffer], 0);	// draws background 1 again
		
		
		sprite[1].x = scrollCounter + SCREEN_WIDTH + (SCREEN_WIDTH/2);	/* 	Sets background 2 to
																			drawn again at
																			background 1 position
																			+320+160	*/
		GsSortFastSprite(&sprite[1], &WorldOT[activeBuffer], 0);	// draws background 2
		
		
		
		DrawSync(0);	// Waits for the above to be finished before continuing
		
		VSync(0);	// Waits for the television vertical retrace to finish before continuing
		
		GsSwapDispBuff();	// Swaps the active buffer with the non-active buffer 
		
		GsSortClear(0,0,0,&WorldOT[activeBuffer]);	// Sorts the OT
		
		GsDrawOt(&WorldOT[activeBuffer]);	// Draws the OT to the active buffer
	}
}



// ---------------------------------
// INITIALISE THE SPRITE FUNCTION
// ---------------------------------

void InitBG(GsSPRITE* sprite, long spriteAddress)	// Runs this function for each image
{
	GsIMAGE tim_info;	// Sets a structure for storing the relevent TIM info
	RECT	rect;	// Draws a rectangular structure around the images
	
	GsGetTimInfo((u_long *)(spriteAddress + 4), &tim_info);	// Gets TIM file info
	
	// Load pixel data 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 CLUT data into the frame buffer - if there is one to load
	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 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
	}
	
	// switch statement which sets image data depending on the type of image 
	switch(tim_info.pmode)	
	{
		// If the image is 4-bit
		case 0x08:	sprite->attribute = 0x00000000;	// Sets the image attribute
					sprite->w = tim_info.pw*4;	// Sets the width of the image
					sprite->tpage = GetTPage(0,0,tim_info.px,tim_info.py);	// Texture page	info
					break;	// breaks from the loop
		
		// If the image is 8-bit			
		case 0x09:	sprite->attribute = 0x01000000;	// Sets the image attribute
					sprite->w = tim_info.pw*2;	// Sets the width of the image
					sprite->tpage = GetTPage(1,0,tim_info.px,tim_info.py);	// Texture page info
					break;	// breaks from the loop
				
		// If the image is 16-bit			
		default:	sprite->attribute = 0x02000000;	// Sets the image attribute
					sprite->w = tim_info.pw;	// Sets the width of the image
					sprite->tpage = GetTPage(2,0,tim_info.px,tim_info.py);	// Texture page info
					break;	// breaks from the loop
	}
	
	if(checkNo==1)	// Sets the correct x position on screen for each image
		sprite->x = 0;	// Image 1 x screen position
	else
		sprite->x = 160;	// Image 2 x screen position
		
	
	sprite->y = 0;	// y screen position
	
	sprite->h = tim_info.ph;	// height of the image
	
	sprite->u = 0;	// Texture page offset - x axis
	sprite->v = 0;	// Texture page offset - y axis
	
	sprite->cx = tim_info.cx;	// Clut x axis position
	sprite->cy = tim_info.cy;	// Clut y axis position
	
	sprite->r = 128;	// Provides red screen tint - 128=normal
	sprite->g = 128;	// Provides green screen tint - 128=normal
	sprite->b = 128;	// Provides blue screen tint - 128=mormal
	
	sprite->mx = 0;		// Sets the center position of each image - x axis
	sprite->my = 0;		// Sets the center position of each image - y axis
	
	sprite->scalex = ONE;	// Sets the scale ratio to 1:1 - x axis
	sprite->scaley = ONE;	// Sets the scale ratio to 1:1 - y axis
	sprite->rotate = 0;		// Sets image rotation to off
	
	DrawSync(0);	// Waits for all of the above to finish before continuing
	
	printf("BACKGROUND %d LOADED\n",i);	/* 	Prints text to the PC screen saying which image has
											been loaded	*/
	
	i++;	/* 	Increments the i variable so the above text displays the appropriate number on
				the next pass through	*/
}


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

static u_long ReadPads(long)	// Reads what is being entered on the pads
{
	return(~(*(pad1Buffer+3)|*(pad1Buffer+2)<<8|*(pad2Buffer+3)<<16|*(pad2Buffer+2)<<24));
}


// -----------------------------
// FUNCTION TO SET UP THE PADS
// -----------------------------

static long InitPads()	// Sets up the pads ready to use
{
	padCheck = ReadPads(1);	// calls the above function of a button is pressed
	
	if(padCheck & PADselect)
		return(99);	// returns the value 99 to break out of the main loop 
}