/***************************************************************
	 lib2d.c
	 =======
***************************************************************/
#include <stdio.h>
#include <libps.h>

#include "lib2d.h"

#define MAX_NO_SPRITES (10+1)
#define ORDERING_TABLE_LENGTH (8)
#define MAX_NO_PACKETS  (MAX_NO_SPRITES * sizeof(GsSPRITE))

// We need two Ordering Table Headers, one for each buffer
GsOT othWorld[2];
// And we need Two Ordering Tables, one for each buffer
GsOT_TAG        otWorld[2][1<<ORDERING_TABLE_LENGTH];
//We also allocate memory used for depth sorting, a block for each buffer
PACKET          out_packet[2][MAX_NO_PACKETS];
// This variable keeps track of the current buffer for double buffering
int currentBuffer;

/***************************************************************
	General Routines
***************************************************************/
	
// this function initialises the graphics system
void InitGraphics()
{
	 // Initialise The Graphics System to PAL as opposed to NTSC
	 SetVideoMode(MODE_PAL);
	 // Set the Actual Size of the Video memory
	 GsInitGraph(SCREEN_WIDTH, SCREEN_HEIGHT, GsINTER|GsOFSGPU, 1, 0);
	 // Set the Top Left Coordinates Of The Two Buffers in video memory
	 GsDefDispBuff(0, 0, 0x80, SCREEN_HEIGHT);

    	 // Before we can use the ordering table headers, 
	 // we need to...
    	 // 1. Set them to the right length
	 othWorld[0].length = ORDERING_TABLE_LENGTH;
	 othWorld[1].length = ORDERING_TABLE_LENGTH;
    	 // 2. Associate them with an actual ordering table 
	 othWorld[0].org = otWorld[0];
	 othWorld[1].org = otWorld[1];
	 // 3. initialise the World Ordering Table Headers and Arrays
	 GsClearOt(0,0,&othWorld[0]);
	 GsClearOt(0,0,&othWorld[1]);
}

// This function deals with double buffering and drawing of 3D objects
void RenderPrepare()
{
		//get the current buffer
		currentBuffer=GsGetActiveBuff();
		// set address for GPU scratchpad area
		GsSetWorkBase((PACKET*)out_packet[currentBuffer]);
		// clear the ordering table
		GsClearOt(0, 0, &othWorld[currentBuffer]);
};

void RenderFinish()
{
		// wait for end of drawing
		DrawSync(0);
		// wait for V_BLANK interrupt
		VSync(0);
		// swap double buffers
		GsSwapDispBuff();
		// register clear-command: clear ordering table to blue
		GsSortClear(0, 0x00, 0x20, &othWorld[currentBuffer] );
		// register request to draw ordering table
		GsDrawOt( &othWorld[currentBuffer] );
}

/***************************************************************
	Sprite Routines
***************************************************************/
void SetSpriteInfo( GsSPRITE* pSprite, unsigned long pTIM, int x, int y )
{
	GsIMAGE img;  			// To hold TIM information.
	RECT r;					// To hold TIM sizes.
	Attrib sa;					// Sprite attribute flags.
	int aWidthMul[] = {2,1,0,0};	// Look up table to calculate real width of image.
	int iRealWidth;                   // Calculated real image width.
	
	/* Extract texture info & set up sprite image*/
	GsGetTimInfo( (unsigned long*)(pTIM + 4), &img );
/*printf("ImageInfo for 0x%08lX: pmode=0x%08lX;\n\tpx=%d; py=%d; pw=%d; ph=%d;"
		"pixel=0x%08lX;\n\tcx=%d; cy=%d; cw=%d; ch=%d; clut=0x%08lX\n",
		pTIM, img.pmode, img.px, img.py, img.pw, img.ph,
		img.pixel, img.cx, img.cy, img.cw, img.cx, img.clut );
*/		
	// Load pixel info.
	r.x = img.px;
	r.y = img.py;
	r.w = img.pw;
	r.h = img.ph;
	LoadImage( &r, img.pixel );
//printf("Loading image: x=%d y=%d w=%d h=%d at 0x%08lx\n", r.x,r.y,r.w,r.h,img.pixel);

	// Reported pixel width depends on colour bit depth.
	iRealWidth = img.pw<<(aWidthMul[img.pmode&0x3]);
	
	// Check if there's any clut info to load.	
	if( img.pmode & 0x08 )
	{
		// Load clut info.
		r.x = img.cx;
		r.y = img.cy;
		r.w = img.cw;
		r.h = img.ch;
		LoadImage( &r, img.clut );
//printf("Loading clut: x=%d y=%d w=%d h=%d at 0x%08lx\n", r.x,r.y,r.w,r.h,img.clut);
	}
	DrawSync(0);	/* Allow time for loading to finish */
	
	/* Initialise Sprite */
	sa.LONG = 0;	/* Clear all flags */
	sa.FLAG.Brightness = OFF;
	sa.FLAG.ClutMode = (img.pmode & 0x3);
	sa.FLAG.Rotate = ON;
	sa.FLAG.TransparentRate = 0;
	sa.FLAG.TransparentMode = OPAQUE;
	sa.FLAG.Display = ON;
	pSprite->attribute = sa.LONG;	/* Flags */
	
	pSprite->x = x;         /* Position */
	pSprite->y = y;
	
	pSprite->w = iRealWidth;		/* Size */
	pSprite->h = img.ph;
	
							/* Texture, offset, CLUT */
	pSprite->tpage = GetTPage( (img.pmode & 0x3), 0, img.px, img.py);
	pSprite->u = img.px- ((pSprite->tpage&0xF)*64);
	pSprite->v = (img.py & 0xFF);
	pSprite->cx = img.cx;
	pSprite->cy = img.cy;
	
	pSprite->r = 0x80;		/* Colour */
	pSprite->g = 0x80;
	pSprite->b = 0x80;
	
	pSprite->mx = iRealWidth>>1;	/* Rotation co-ordinates at centre of image*/
	pSprite->my = img.ph>>1;
	pSprite->rotate = 0L;	/* and angle (4096 = 1') */
	
	pSprite->scalex = ONE;	/* Scale (ONE = 2048) */
	pSprite->scaley = ONE;
/*printf("Initialised sprite 0x%08lx: x=%d y=%d w=%d h=%d with 0x%08lx\n"
		"\ttpage=%d u=%d v=%d cx=%d cy=%d\n",
		 pSprite, pSprite->x, pSprite->y, pSprite->w, pSprite->h, pSprite->attribute,
		 pSprite->tpage, pSprite->u, pSprite->v, pSprite->cx, pSprite->cy);
   */
}

void DrawSprite( GsSPRITE* pSprite, int nPriority )
{
	GsSortSprite( pSprite, &othWorld[currentBuffer], nPriority );
}

void LoadTexture( long pTIM )
{
}