/************************************************
 *												*
 *	Display a single 8-bit sprite				*
 *												*
 *	Author: ScoTT Campbell						*
 *	Date:	8/10/98								*
 *												*
 *	www.netyaroze-europe.com/~escotia			*
 *												*
 *	E-mail:	escotia@escotia.freeserve.co.uk		*
 *												*
 *	Please mail me about any BUGS etc.			*
 *												*
 ************************************************/


#include <libps.h>	// Header for NY functions. Must be included in all programs
#include "screen.h"
#include "pad.h"



/***************************** Sprite related definitions ****************************/

#define SPRITE_ADDRESS	(0x80090000)			// Address TIM file will be loaded into main memory

#define AMOUNT_SPRITES		(1)					// Only displaying 1 sprite
#define AMOUNT_PRIMITIVES	(AMOUNT_SPRITES + 1)// Include space for a clear command

GsSPRITE	sprite;								// Sprite handler

/*************************************************************************************/



/************************* Ordering Table related definitions ************************/
 
#define OT_LENGTH		(1)						// For 1<<OT_LENGTH depth levels


/* Need two of everything because we are double buffering. One for each buffer */ 

GsOT	 worldOT[2];							// OT headers

GsOT_TAG otElements[2][1<<OT_LENGTH];			// Body of OT's

PACKET	 packetArray[2][AMOUNT_PRIMITIVES * 24]; // PACKETS are space for drawing commands

/*************************************************************************************/



/************************** Controller related definitions ***************************/

volatile unsigned char *pad1Buffer, *pad2Buffer;	// Space for PSX to store pad info

/*************************************************************************************/




/******************************** Function Prototypes ********************************/

void InitGraphics();
/* Set up the PSX graphics system ready to display */

void InitWorldOTs();
/* Set up the OTs ready to use */

void InitControllers();
/* Set up the controllers ready to use */

void InitSprite(GsSPRITE* spritePtr, unsigned long int spriteAddress, int xPosition, int yPosition);
/* Set up the sprite ready to display */

unsigned long int ReadPads();
/* Read from the controllers */

/*************************************************************************************/



int main()
{
	int activeBuffer;
	
	InitGraphics();										// Set up the screen and screen buffers
	
	InitWorldOTs();										// Set up the OTs ready to use

	InitControllers();									// Set up the controllers ready to use
	
	InitSprite(&sprite, SPRITE_ADDRESS, SCREEN_WIDTH/2, SCREEN_HEIGHT/2);	// Load the sprite into the frame buffer and set up sprite handler


	while( !(ReadPads() & PAD1_SELECT) )				// See if user wants to quit
	{
		activeBuffer = GsGetActiveBuff();				// Find out which buffer to create drawing commands for
	
		GsSetWorkBase((PACKET*)packetArray[activeBuffer]);// Initialise the space for our drawing commands

		GsClearOt(0, 0, &worldOT[activeBuffer]);		// Clear OT ready to use

		GsSortSprite(&sprite, &worldOT[activeBuffer], 0);// Insert sprite drawing command into OT
	
		DrawSync(0);									// Wait for drawing of other buffer to stop

		VSync(0);										// Wait for screen to stop drawing

		GsSwapDispBuff();								// Start displaying other buffer

		GsSortClear(0, 0, 0, &worldOT[activeBuffer]);	// Insert a screen clear command into the OT
	
		GsDrawOt(&worldOT[activeBuffer]);				// Draw OT into buffer activeBuffer

	}

	return 0;

}/* main */


/*********************************** Local functions *********************************/


void InitGraphics()
/* Sets up the graphics mode to 16-bit, no dithering, GPU offset and the macros chosen in screen.h */
{

	SetVideoMode(VIDEO_MODE);						// PAL or NTSC - defined in screen.h
	
	GsInitGraph(SCREEN_WIDTH, SCREEN_HEIGHT,4,0,0);	// Set up non-interlace
	GsDefDispBuff(0,0,0,SCREEN_HEIGHT);				// Define double buffers

	if(SCREEN_HEIGHT == 256)
		GsDISPENV.screen.h = SCREEN_HEIGHT;			// Fix 256 line bug which makes bottom 16 lines dissapear

}/* InitGraphics */



void InitWorldOTs()
{
	int i;

	/* Initialise OT's */
	for(i=0; i<2; i++)
	{
		worldOT[i].org = otElements[i];				// Point header to array of OT_TAGs
		worldOT[i].length = OT_LENGTH;				// Length must be correctly set otherwise memory problems occur
		GsClearOt(0, 0, &worldOT[i]);				// Clear the OTs ready to use
	}

}/* InitWorldOTs */



void InitControllers()
// Set addresses of controllers' buffers
{
	GetPadBuf(&pad1Buffer, &pad2Buffer);

}/* InitControllers */



void InitSprite(GsSPRITE* spritePtr, unsigned long int spriteAddress, int xPosition, int yPosition)
{
	RECT rect;
	GsIMAGE timData;
	
	// Get info at Sprite_Address and put into timData
	GsGetTimInfo((unsigned long*)(spriteAddress+4), &timData);
	
	// Load sprite into frame buffer
	rect.x = timData.px;
	rect.y = timData.py;
	rect.w = timData.pw;
	rect.h = timData.ph;
	LoadImage(&rect, timData.pixel);

	// Load sprites CLUT into frame buffer
	rect.x = timData.cx;
	rect.y = timData.cy;
	rect.w = timData.cw;
	rect.h = timData.ch;
	LoadImage(&rect, timData.clut);

	// Assign values to the sprite handler
	spritePtr->attribute = (unsigned long int) (timData.pmode << 24);	// Set sprite to correct display mode
	spritePtr->attribute &= 0x03000000;									// Set all other attribute bits to zero

	
	spritePtr->w = (timData.pw * 2);							// 8-bit clut so rendered as twice actual width
	spritePtr->h = (timData.ph);								// Set sprites height
	spritePtr->mx = spritePtr->w/2;								// Set display point to center of sprite
	spritePtr->my = spritePtr->h/2;								// "
	spritePtr->x = xPosition;									// Set screen display position	
	spritePtr->y = yPosition;									// Set screen display position
	spritePtr->tpage = GetTPage(1, 0, timData.px, timData.py);	// Get VRAM TPage number where sprite is stored
	spritePtr->u = 0;											// No offset within the TPage
	spritePtr->v = 0;											// "
	spritePtr->cx = timData.cx;									// Attach CLUT to handler
	spritePtr->cy = timData.cy;									// "
	spritePtr->r = 128;											//
	spritePtr->g = 128;											// Set brightness to normal
	spritePtr->b = 128;											//
	spritePtr->scalex = ONE;									// Set size in X to 1:1
	spritePtr->scaley = ONE;									// Set size in Y to 1:1
	spritePtr->rotate = 0;										// No rotation
	
	DrawSync(0);

}/* InitSprite */



unsigned long int ReadPads()
// SONY function
// Read from controllers
{
	return (~(*(pad1Buffer+3) | *(pad1Buffer+2) << 8 | *(pad2Buffer+3) << 16 | *(pad2Buffer+2) << 24));

}/* ReadPads */


/*************************************************************************************/