/*
=============================================================================
  
  File: STARS.C
  Author: Radouan Khechane (rad@cyberdude.com)
  Date: 21st December 1998
  Description: Simulates a starfield on the Net Yaroze PlayStation

  Copyright (c) 1998 by Radouan Khechane.

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

/*
====================
  I N C L U D E S
====================
*/
#include <libps.h>                     // PlayStation library
#include "pad.h"                       // joypad header file

/* 
====================
   D E F I N E S
====================
*/
#define OT_LENGTH      (1)             // length of Ordering Table
#define SCREEN_WIDTH   (320)           // screen x resolution
#define SCREEN_HEIGHT  (240)           // screen y resolution

#define STARS_MAX      (100)           // number of stars

/*
====================
S T R U C T U R E S
====================
*/
typedef struct
{
    int x, y;           // position of star
    int z;              // depth of star used to determine colour and speed
    int velocity;       // speed
    int colour;         // colour
} star_t;

/*
====================
   G L O B A L S
====================
*/
GsOT      OT_Header[2];                // Ordering Table Headers
GsOT_TAG  OT_Tag[2][1<<OT_LENGTH];     // Ordering Tables
PACKET    GpuPacketArea[2][STARS_MAX * sizeof(GsLINE)]; // GPU packet area
int       activeBuffer;                // double buffer index

star_t star[STARS_MAX];  // stars in starfield
GsLINE star_ot;          // star used for drawing (defined as line of length 1)

u_long PADstatus = 0;    // state of controller pad

int i;    // index variable

/* 
====================
P R O T O T Y P E S
====================
*/
void InitGraphics (void);
void InitStarfield (void);
void MoveStarfield (void);
void DrawStarfield (void);
void DrawScreen (void);

/* 
====================
     M A I N
====================
*/
int main (void)
{
    // initialise graphics
    InitGraphics();
    // set up the controller pad
    PadInit();
    // initialise & setup starfield
    InitStarfield();

    // while 'select & start' not pressed
    while (!((PADstatus & PADselect) && (PADstatus & PADstart)))
    {
        PADstatus = PadRead(1);    // read status of controller pad 1
        MoveStarfield();
        DrawScreen();
    }

    ResetGraph(3);  // cancel current drawing and flush command queue

    return (0);
}

/*
====================
 F U N C T I O N S
====================
*/

/*
================
 InitGraphics()
================
*/
void InitGraphics (void)
{
    int index;    // index variable

    // declare current video signalling system
    SetVideoMode(MODE_PAL);

    // initialise graphics system
    GsInitGraph(SCREEN_WIDTH, SCREEN_HEIGHT, GsOFSGPU|GsNONINTER, 1, 0);
    // define double buffer
    GsDefDispBuff(0, 0, 0, SCREEN_HEIGHT);

    // set up the ordering table headers
    for (index = 0; index < 2; index++)
    {
        // set to OT length
        OT_Header[index].length = OT_LENGTH;
        // set to OT location
        OT_Header[index].org = OT_Tag[index];
    }
}

/*
================
 InitStarfield()
initialise and setup the starfield
================
*/
void InitStarfield (void)
{
    // initialise OT star
    star_ot.attribute = 0;
    star_ot.x0 = star_ot.x1 = 0;
    star_ot.y0 = star_ot.y1 = 0;
    star_ot.r = star_ot.g = star_ot.b = 0;

    // setup stars
    for (i = 0; i < STARS_MAX; i++)
    {
        // place star randomly in starfield
        star[i].x = rand() % SCREEN_WIDTH;
        star[i].y = rand() % SCREEN_HEIGHT;
        // determine star depth
        star[i].z = rand() % 3;
        // set velocity & colour using stars depth (z)
        switch (star[i].z)
        {
            case 0 : star[i].velocity = 3;  // fast
                     star[i].colour = 250;  // bright
                     break;
            case 1 : star[i].velocity = 2;
                     star[i].colour = 175;
                     break;
            case 2 : star[i].velocity = 1;  // slow
                     star[i].colour = 100;  // dark
        }
    }
}

/*
================
 MoveStarfield()
moves the stars in the starfield
================
*/
void MoveStarfield (void)
{
    for (i = 0; i < STARS_MAX; i++)
    {
        // move star horizontally left to right
        star[i].x += star[i].velocity;
        // if star off screen then wrap around to other side
        if (star[i].x >= SCREEN_WIDTH) star[i].x -= SCREEN_WIDTH;
    }
}

/*
================
 DrawStarfield()
draws the stars in the starfield
================
*/
void DrawStarfield (void)
{
    // register stars into the odering table
    for (i = 0; i < STARS_MAX; i++)
    {
        // position
        star_ot.x0 = star_ot.x1 = star[i].x;
        star_ot.y0 = star_ot.y1 = star[i].y;
        // colour
        star_ot.r = star_ot.g = star_ot.b = star[i].colour;
        // register
        GsSortLine(&star_ot, &OT_Header[activeBuffer], 1);
    }
}

/*
================
 DrawScreen()
================
*/
void DrawScreen (void)
{

    // get drawing buffer number
    activeBuffer = GsGetActiveBuff();

    // set drawing command storage address
    GsSetWorkBase((PACKET*)GpuPacketArea[activeBuffer]);

    // initialise odering table
    GsClearOt(0, 0, &OT_Header[activeBuffer]);

    DrawStarfield();

    // wait for completion of all drawing
    DrawSync(0);
    // wait for vertical retrace
    VSync(0);

    // swap double buffers (display and drawing buffer)
    GsSwapDispBuff();

    // register clear (screen) command
    GsSortClear(0x0, 0x0, 0x0, &OT_Header[activeBuffer]);
    // register request to draw ordering table
    GsDrawOt(&OT_Header[activeBuffer]);
}