//----------------------------------------------------------------------------------------------------------------

//  FILE:	main.c
//  AUTHOR:	Shaun Gibson  <shaunyg@hotmail.com>
//  FILE-GROUP:	Fading tutorial

//----------------------------------------------------------------------------------------------------------------



#include <libps.h>
#include "pad.h"
#include "main.h"	//includes all of the defines, global variables and procedure definitions




//----------------------------------------------------------------------------------------------------------------

// GLOBALS	//must be included here, the extern versions in the header file take these to use in init.c

//----------------------------------------------------------------------------------------------------------------


GsOT		WorldOT[2];
GsOT_TAG	OT_TAGS[2][1<<OT_LENGTH];	// my ordering table

PACKET		GpuPacketArea[2][24000];
int		output_buffer_index;

GsSPRITE	spotsprite;				//spotlight sprite handler
GsBOXF		box[NUM_BOXES], fadebox, spotblock[4];	//all box handlers (includes objects, the box used
							  //to fade and the boxes used to blank the background
							  //for the spotlight

short		done;
int		fnt_id;
short		fading;				//variables for program execution





//----------------------------------------------------------------------------------------------------------------

// MAIN PROGRAM

//----------------------------------------------------------------------------------------------------------------


main()
{
	Init();
	InitBoxes();
	InitFadeBox();
	InitSpotLight();		//calls all of the initialisation procedures in "init.c"

	PadInit();			//the pad's initialisation procedure (using the pad procedures
					//given by Sony)

	while (!done)			//select sets done to 1, ending the loop
	{
		CheckPad();		//checks if any buttons have been pressed
		switch (fading)		//depending on the state of fading, do one of the following
		{
			case 0:
			{
				FntPrint(fnt_id,
					"~c444SQUARE: FADE TO BLACK\nCIRCLE: FADE TO WHITE\nCROSS: SPOTLIGHT");
				break;
			}
			case 1:
			{
				FntPrint(fnt_id, "~c444FADING TO BLACK");
				Fade();		//procedure which increments the rgb values of the fadebox
				break;
			}
			case 2:
			{
				FntPrint(fnt_id, "~c444FADING TO WHITE");
				Fade();
				break;
			}
			case 3: 
			{
				FntPrint(fnt_id, "~c444SPOTLIGHT:\n PRESS TRIANGLE TO RETURN TO NORMAL");
				SpotLight();	//updates spotblock[] boxes' positions for the spotlight, so only
						//the area in the spotlight is in is shown
				break;
			}
			case 4:
			{
				FntPrint(fnt_id, "~c444FINISHED FADING:\n PRESS TRIANGLE TO RETURN TO NORMAL");
				break;
			}
		}
		Update();	//redraws screen
	}

	ResetGraph(0);		//when done = 1, the graphics system is reset and the program ends
	return(0);
}









void CheckPad(void)
{
	u_long padd = PadRead();	//read the pad buffer



	if ((padd & PADRleft) && (fading == 0))		//if square is pressed start fading to black
	{
		fadebox.attribute = (1<<30) | (1<<29);	//(1<<29) for +1 front -1 back, so the fadebox rgb
							//values are subtracted from the backgrounds,
							//so higher fadebox's rgb values = blacker background

		fading = 1;	//for the switch function in the main loop
	}

	if ((padd & PADRright) && (fading == 0))	//if circle is pressed start fading to white
	{
		fadebox.attribute = (1<<30) | (1<<28);	//(1<<28) for +1 back +1 front, so the rgbs of the
							//fadebox and the background are added together, so the
							//higher fadebox's rgb values, the lighter the screen
		fading = 2;
	}

	if ((padd & PADRdown) && (fading == 0))		//if cross is pressed, initialise the spotlight to
							//centre of the screen
	{
		spotsprite.x = SCREEN_WIDTH / 2 - spotsprite.w / 2;
		spotsprite.y = SCREEN_HEIGHT / 2 - spotsprite.h / 2;
		fading = 3;
	}

	if ((padd & PADRup) && (fading > 2))		//reset back to normal if fading is finished or if
							//spotlight is on
	{
		fading = 0;
		fadebox.r = fadebox.g = fadebox.b = 0;	//re-initialise fadebox's rgb values to 0 (black)
	}



// the following if statements move the spotlight around the screen and limit it to stay fully inside the screen

	if (padd & PADLup)
	{
		spotsprite.y -= 3;
		if (spotsprite.y < 0)
			spotsprite.y = 0;
	}

	if (padd & PADLdown)
	{
		spotsprite.y += 3;
		if (spotsprite.y > (SCREEN_HEIGHT - spotsprite.h))
			spotsprite.y = SCREEN_HEIGHT - spotsprite.h;
	}

	if (padd & PADLleft)
	{
		spotsprite.x -= 3;
		if (spotsprite.x < 0)
			spotsprite.x = 0;
	}

	if (padd & PADLright)
	{
		spotsprite.x += 3;
		if (spotsprite.x > (SCREEN_WIDTH - spotsprite.w))
			spotsprite.x = SCREEN_WIDTH - spotsprite.w;
	}


// ends the program by setting done to 1 so the main loop ends

	if (padd & PADselect)
		done = 1;
}










void Fade(void)
{
	if (fadebox.r == 252)	//r g and b are all the same, so only need to check one of them
	{
		fadebox.r = fadebox.g = fadebox.b = 255;	//r g and b are char values, so they can't go
								//to 256, so this if bit intercepts the attempt
								//as it were
		fading = 4;
	}
	else
	{
		fadebox.r = fadebox.g = fadebox.b += 4;		//increments rgb values by 4
	}
}









void SpotLight(void)	//updates the positions and sizes of the blocking boxes for the spotlight
{
	spotblock[0].x = 0;			//left of spotlight is blanked
	spotblock[0].y = 0;
	spotblock[0].w = spotsprite.x;
	spotblock[0].h = SCREEN_HEIGHT;

	spotblock[1].x = 0;			//top of spotlight is blanked
	spotblock[1].y = 0;
	spotblock[1].w = SCREEN_WIDTH;
	spotblock[1].h = spotsprite.y;

	spotblock[2].x = spotsprite.x + spotsprite.w;		//right of spotlight is blanked
	spotblock[2].y = 0;
	spotblock[2].w = SCREEN_WIDTH - spotblock[2].x;
	spotblock[2].h = SCREEN_HEIGHT;

	spotblock[3].x = 0;					//bottom of spotlight is blanked
	spotblock[3].y = spotsprite.y + spotsprite.h;
	spotblock[3].w = SCREEN_WIDTH;
	spotblock[3].h = SCREEN_HEIGHT - spotblock[3].y;
}









void Update(void)
{
	short a;

	output_buffer_index = GsGetActiveBuff();	//sets the output_buffer_index to handle the current OT

	GsSetWorkBase((PACKET*)GpuPacketArea[output_buffer_index]);	//set work area

	GsClearOt(0, 0, &WorldOT[output_buffer_index]);	//clears the ordering table of previous contents

	for (a = 0; a < NUM_BOXES; a++)
	{
		GsSortBoxFill(&box[a], &WorldOT[output_buffer_index], 1);	//put the backgound objects
										//into the ordering table
	}

	if ((fading == 1) || (fading == 2) || (fading == 4))
	{
		GsSortBoxFill(&fadebox, &WorldOT[output_buffer_index], 0);	//if applicable, put fadebox into
										//the ordering table at the top
										//level (priority 0)
	}

	if (fading == 3)	//if spotlight is on:
	{
		GsSortSprite(&spotsprite, &WorldOT[output_buffer_index], 0);	//put spotlight sprite into OT at
										//priority 0 (top)

		for (a = 0; a < 4; a++)
		{
			GsSortBoxFill(&spotblock[a], &WorldOT[output_buffer_index], 0);	//and also the blocking boxes
		}
	}

	FntFlush(fnt_id);	//display the fonts

	DrawSync(0);
	VSync(0);		//wait for syncronisation so there is no flickering

	GsSwapDispBuff();	//swap the display buffers so the previously drawn screen is now displayed

        GsSortClear(0x20, 0x30, 0x40, &WorldOT[output_buffer_index]);	//set the background colour

	GsDrawOt(&WorldOT[output_buffer_index]);	//draw the ordering table to display buffer
}