/*===================================================================*
 * Production Title:  Background Handling Demo		 			     *
 *-------------------------------------------------------------------*
 * Date Started....: 30/08/98   * Code......:  Andy Partington 	 *
 * Last Updated....: 02/08/98   *              Kung-Fu Coders(tm)  *
 *=================================================================*
 * Info:  This is a demo of how to use the Yaroze library calls to *
 *			 display backgrounds.  The code's messy, but it works!    *
 *=================================================================*/

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

#define ScrWidth 320
#define ScrHeight 256

#define OT_LENGTH 4
#define sprNo (4-1)

#define BG_ADDR 0x8009a000


/*==============================*
 *		Function Prototypes		  *
 *==============================*/
	u_long PadRead();

 /*=============================*
  *	Global Structures			  *
  *=============================*/

	GsOT WorldOT[2];
	GsOT_TAG OTTags[2][1<<OT_LENGTH];
	PACKET GpuPacketArea[2][sprNo*sizeof(GsSPRITE)];

	GsIMAGE BGImg;											//Your graphics will live here
	GsBG BGHandler;										//Background handling structure
	GsMAP BGMap;											//Defines map sizes and points to map and GsCELL data
	GsCELL blockCells[16];								//Cells which make up the blocks
	u_long BGWorkArea[(((320/16+1)*(256/16+1+1)*6+4)*2+2)];

	u_short myMapData[5][5]={                            //The map that will be tiled
							{ 0xffff,0xffff,2,0xffff,0xffff},  //  all over the screen
							{ 0xffff,5,6,7,0xffff},
							{ 8,9,10,11,12},
							{ 0xffff,13,14,15,0xffff},
							{0xffff,0xffff,0,0xffff,0xffff}
						 };

	RECT rect;
	int activeBuffer;
	volatile u_char *pad0,*pad1;
	u_long padStatus;

/*=====================================================*
 *			Main program execution routine			   	 *
 *=====================================================*/

int main()
{
	int x,y,index;			  				//some work vars....

	SetVideoMode(MODE_PAL);
	GsInitGraph(ScrWidth,ScrHeight,4,0,0);
	GsDefDispBuff(0,0,0,ScrHeight);

	// Set up ordering tables for the work and display screens

	for (x=0;x<2;x++)
	{
		WorldOT[x].length=OT_LENGTH;
		WorldOT[x].org=OTTags[x];
	}

	/*----------------------------------------------------*
	 * Initialise GsIMAGE struct and load image into VRAM *
	 *----------------------------------------------------*/

	GsGetTimInfo((u_long*)BG_ADDR+1,&BGImg);	//+1 longword (ie 4 bytes)
												// to skip the TIM header
	rect.x=BGImg.px;
	rect.y=BGImg.py;
	rect.w=BGImg.pw;
	rect.h=BGImg.ph;
	LoadImage(&rect,BGImg.pixel);			//Transfer pixel data to VRAM

	rect.x=BGImg.cx;
	rect.y=BGImg.cy;						//Transfer CLUT to VRAM
	rect.w=BGImg.cw;
	rect.h=BGImg.ch;
	LoadImage(&rect,BGImg.clut);

	/*-----------------------------------------------------*
	 * Initialise background 							   *
	 *-----------------------------------------------------*/

	index=0;

	// Set up the array of GsCELLs so we can tell which block is
   // which in the GsIMAGE structure

	for (y=0;y<4;y++)
	{
		for(x=0;x<4;x++)
		{
			blockCells[index].u=x<<4;			//X offset of block in texture page (ie set at every 16 pixels)
			blockCells[index].v=y<<4;			//Y offset of block in texture page
			blockCells[index].cba=GetClut(BGImg.cx,BGImg.cy);	//CLUT ID number
			blockCells[index].flag=0;			//inversion information
			blockCells[index].tpage=GetTPage(BGImg.pmode,0,BGImg.px,BGImg.py);			//texture page ID
			index++;
		}
	}

	//Attach the map to the GsMAP structure and define the sizes of
	//	the blocks and the map

	BGMap.cellw=16;                       //Cell width and height
	BGMap.cellh=16;                       //(ignored!)
	BGMap.ncellw=5;								//width of map (cells)
	BGMap.ncellh=5;								//height of map (cells)
	BGMap.base=blockCells;						//pointer to cell array
	BGMap.index=(u_short*)myMapData;		  	//pointer to map data

	//Create a GsBG object to control the map

	BGHandler.map=&BGMap;
	BGHandler.attribute=BGImg.pmode<<24;		//shift pmode left 24 bits to set
															//image type
	BGHandler.x=0;
	BGHandler.y=0;
	BGHandler.w=64;
	BGHandler.h=64;
	BGHandler.scrollx=0;
	BGHandler.scrolly=0;
	BGHandler.r=0;
	BGHandler.g=0;
	BGHandler.b=0;
	BGHandler.mx=0;
	BGHandler.my=0;
	BGHandler.scalex=ONE;
	BGHandler.scaley=ONE;
	BGHandler.rotate=0;

	GsInitFixBg16(&BGHandler,BGWorkArea);		//Initialises whatever handles backgrounds -
															// Only call once.


	/*=======================================================================*/

	GetPadBuf(&pad0,&pad1);

	while (!(padStatus & PADselect))
	{

		activeBuffer=GsGetActiveBuff();
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuffer]);
		GsClearOt(0,0,&WorldOT[activeBuffer]);

		GsSortFixBg16(&BGHandler,BGWorkArea,&WorldOT[activeBuffer],(1<<OT_LENGTH-1));

		BGHandler.scrollx++;										//Scroll along the x axis
		BGHandler.scrolly++;                            //same with the y axis

		DrawSync(0);
		VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activeBuffer]);
		GsDrawOt(&WorldOT[activeBuffer]);

		padStatus=PadRead();
	}

	return (0);
}


u_long PadRead()
{
	return (~(*(pad0+3) | *(pad0+2)<<8 | *(pad1+3)<<16 | *(pad1+2)<<24));
}