/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1995, Silicon Graphics, Inc.               *
 *                                                                        *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *                                                                        *
 *************************************************************************/

/*---------------------------------------------------------------------*
        Copyright (C) 1998 Nintendo. (Originated by SGI)
        
        $RCSfile: fill.c,v $
        $Revision: 1.1.1.1 $
        $Date: 2002/05/02 03:27:09 $
 *---------------------------------------------------------------------*/

/*
 * File:	fill.c
 *
 */

#include <ultra64.h>
#include <PR/ramrom.h>	/* needed for argument passing into the app */
#include <assert.h>
#include <os.h>

#include "controller.h"
#include "fill.h"
#include "static.h"
#include "timer.h"

#include "mario-small.h"


/*
 * Symbol genererated by "makerom" to indicate the end of the code segment
 * in virtual (and physical) memory
 */
extern char _codeSegmentEnd[];

/*
 * Symbols generated by "makerom" to tell us where the static segment is
 * in ROM.
 */

/*
 * Stacks for the threads as well as message queues for synchronization
 * This stack is ridiculously large, and could also be reclaimed once
 * the main thread is started.
 */
u64	bootStack[STACKSIZE/sizeof(u64)];

static void	idle(void *);
static void	main(void *);

static OSThread	idleThread;
static u64	idleThreadStack[STACKSIZE/sizeof(u64)];

static OSThread	mainThread;
static u64	mainThreadStack[STACKSIZE/sizeof(u64)];

static OSThread	rmonThread;
static u64      rmonStack[RMON_STACKSIZE/sizeof(u64)];

/* this number (the depth of the message queue) needs to be equal
 * to the maximum number of possible overlapping PI requests.
 * For this app, 1 or 2 is probably plenty, other apps might
 * require a lot more.
 */
#define NUM_PI_MSGS     8

static OSMesg PiMessages[NUM_PI_MSGS];
static OSMesgQueue PiMessageQ;

OSMesgQueue     dmaMessageQ, rspMessageQ, rdpMessageQ, retraceMessageQ;
OSMesg          dmaMessageBuf, rspMessageBuf, rdpMessageBuf, retraceMessageBuf;
OSMesg          dummyMessage;
OSIoMesg        dmaIOMessageBuf;

OSMesg		dummyMesg;
OSTask		*tlistp;
Dynamic		*dynamicp;

/*
 *  Command line options
 */
int				BlankVideo			=  0;
int				XlateTri			=  0;
int             PrintStatsEn     	=  1;
int             DoShade             =  1;
int             Do8bit              =  0;
int				DumpGbi 			=  0;
int				DumpRdp 			=  0;
int				AlignTri 			=  0;

int             ActiveController;
int             ControllerInput     =  1;
int             UseAAMode           =  0;
int             UseZMode            =  0;
int             DoClrClr            =  1;
int             SelfScaleTimer      =  1;
int             ClipRatio           =  1;
int             TimerTicks          =  7;

/* for special test only */
int             UseTextureMode      =  0;
int             Use2CycleMode       =  1;

int				ActiveVert = 0;
float			TriDx = 0.0;
float			TriDy = 0.0;
float			TriArea;
float			TriWidth;
float			TriHeight;
float			BoxTx, BoxTy, BoxLx, BoxLy;
float			TriAspectRatio;

int				TriNx = 1;
int				TriNy = 1;
int				TriNz = 1;

float			TriDeltaXYPos = DELTAXY_POS;

int				TriSortOrder;

float           TimePerFrame        =  0;
float           TicksPerFrame       =  0;
float           TicksPerSec;

OSTime          t1, t2;

static u32 		PerfCounters[4], SavePerfCounters[4];


/*
 * Dynamic data.
 */
Dynamic dynamic;

/*
 * necessary for RSP tasks:
 */
u64 dram_stack[SP_DRAM_STACK_SIZE64];	/* used for matrix stack */
    
/*
 * Task descriptor.
 */
OSTask	tlist =
{
    M_GFXTASK,			/* task type */
    OS_TASK_DP_WAIT,		/* task flags */
    NULL,			/* boot ucode pointer (fill in later) */
    0,				/* boot ucode size (fill in later) */
    NULL,			/* task ucode pointer (fill in later) */
    SP_UCODE_SIZE,		/* task ucode size */
    NULL,			/* task ucode data pointer (fill in later) */
    SP_UCODE_DATA_SIZE,		/* task ucode data size */
    &(dram_stack[0]),		/* task dram stack pointer */
    SP_DRAM_STACK_SIZE8,	/* task dram stack size */
    &(rdp_output[0]), 	/* task output buffer ptr (not always used) */
    &rdp_output_len,	/* task output buffer size ptr */
    NULL,			/* task data pointer (fill in later) */
    0,				/* task data size (fill in later) */
    NULL,			/* task yield buffer ptr (not used here) */
    0				/* task yield buffer size (not used here) */
};

Gfx		*glistp;	/* global for test case procs */
    
/*
 * global variables
 */

int      draw_buffer        = 0;

void    *cfb_ptrs[2];

void parse_args(char *);

OSPiHandle	*handler;

void boot(void)
{
    int i;
    u32 *argp;
    u32 argbuf[16];

    /* notice that you can't call rmonPrintf() until you set
     * up the rmon thread.
     */
    
    osInitialize();

    handler = osCartRomInit();

    argp = (u32 *)RAMROM_APP_WRITE_ADDR;
    for (i=0; i<sizeof(argbuf)/4; i++, argp++) 
      {
	osEPiReadIo(handler, (u32)argp, &argbuf[i]); /* Assume no DMA */
      }

    parse_args((char *) argbuf);

    osCreateThread(&idleThread, 1, idle, (void *)0,
		   idleThreadStack+STACKSIZE/sizeof(u64), 10);
    osStartThread(&idleThread);

    /* never reached */
}

/*
 *  To do memory alignment test, gload -a "-x -w" and translate tri across
 *  memory, noting time as you go.
 */
void parse_args(char *argstring)
{
  int		argc = 1;
  char	*arglist[32], **argv = arglist;	/* max 32 args */
  char	*ptr;

  if (argstring == NULL || argstring[0] == '\0')
    return;

  /* re-organize argstring to be like main(argv,argc) */

  ptr = argstring;
  while (*ptr != '\0') {
    while (*ptr != '\0' && (*ptr == ' ')) 
      {
	*ptr = '\0';
	ptr++;
      }
    if (*ptr != '\0')
      arglist[argc++] = ptr;
    while (*ptr != '\0' && (*ptr != ' ')) 
      {
	ptr++;
      }
  }

  /* process the arguments: */
  while ((argc > 1) && (argv[1][0] == '-')) 
    {
      switch(argv[1][1]) 
	{
	case 'a':
	  AlignTri = 1;
	  break;

	case 'b':
	  BlankVideo = 1;
	  break;

	case 'c':
	  DoClrClr = 0;
	  break;

	case 'd':
	  DoShade = 0;
	  break;

	case 'g':
	  DumpGbi = 1;
	  break;

	case 'p':
	  PrintStatsEn = 0;
	  break;

	case 'r':
	  DumpRdp = 1;
	  PrintStatsEn = 0;
	  break;

	case 's':
	  SelfScaleTimer = 0;
	  break;

	case 't':
	  UseTextureMode = 1;
	  break;

	case 'x':
	  XlateTri = 1;
	  break;

	default:
	  break;
	}
      
      argc--;
      argv++;
    }
}


static void idle(void *arg)
{
  /* Initialize video */
  osCreateViManager(OS_PRIORITY_VIMGR);
  
  if (UseAAMode) {
    if(BlankVideo) {
	  osViModeNtscLan1.fldRegs[0].vStart = 0;
	  osViModeNtscLan1.fldRegs[1].vStart = 0;
    }
    osViSetMode(&osViModeNtscLan1);
  }
  else {
    if(BlankVideo) {
	  osViModeNtscLpn1.fldRegs[0].vStart = 0;
	  osViModeNtscLpn1.fldRegs[1].vStart = 0;
    }
    osViSetMode(&osViModeNtscLpn1);
  }
 
#ifdef JUNK
  osViSetSpecialFeatures(OS_VI_DITHER_FILTER_ON);
#endif /* JUNK */

  /*
   *  Prevent VI from accessing DRAM
   */

  /*
   * Start PI Mgr for access to cartridge
   */
  osCreatePiManager((OSPri)OS_PRIORITY_PIMGR, &PiMessageQ, PiMessages, 
		    NUM_PI_MSGS);
  
  /*
   * Start RMON for debugging & data xfer (make sure to start 
   * PI Mgr first)
   */
  osCreateThread(&rmonThread, 0, rmonMain, (void *)0,
		 (void *)(rmonStack+RMON_STACKSIZE/8), 
		 (OSPri) OS_PRIORITY_RMON );
  osStartThread(&rmonThread);
  
  /*
   * at this point, AND NOT BEFORE, we can now do an
   * rmonPrintf()
   */
  
  /*
   * Create main thread
   */
  osCreateThread(&mainThread, 3, main, arg,
		 mainThreadStack+STACKSIZE/sizeof(u64), 10);
  
  osStartThread(&mainThread);
  
  /*
   * Become the idle thread
   */
  osSetThreadPri(0, 0);
  
  for (;;);
}

void CreateMessageQueues(void)
{
  osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, 1);
  
  osCreateMesgQueue(&rspMessageQ, &rspMessageBuf, 1);
  osSetEventMesg(OS_EVENT_SP, &rspMessageQ, dummyMessage);
  
  osCreateMesgQueue(&rdpMessageQ, &rdpMessageBuf, 1);
  osSetEventMesg(OS_EVENT_DP, &rdpMessageQ, dummyMessage);
  
  osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
  osViSetEvent(&retraceMessageQ, dummyMessage, 1);  
}

void SetupSegments(void)
{
  /* Tell RCP where each segment is */

  gSPSegment(glistp++, 0, 0x0);   
}

void CreateTaskStructure(void)
{
  /* Build graphics task */

  tlistp->t.ucode_boot = (u64 *) rspbootTextStart;
  tlistp->t.ucode_boot_size = (u32)rspbootTextEnd - (u32)rspbootTextStart;

  /* choose which ucode to run */

  tlistp->t.ucode      = (u64 *) gspFast3D_dramTextStart;
  tlistp->t.ucode_data = (u64 *) gspFast3D_dramDataStart;
  
  /* initial display list: */
  tlistp->t.data_ptr = (u64 *) dynamicp->glist;
}

static void SwapViBuffer(void)
{
  /* setup to swap buffers */
  osViSwapBuffer(cfb_ptrs[draw_buffer]); 
  
  /* Make sure there isn't an old retrace in queue */
  if (MQ_IS_FULL(&retraceMessageQ))
    (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
  
  /* Wait for Vertical retrace to finish swap buffers */
  (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
  draw_buffer ^= 1;
}


static void SetupViewing(void)
{
    guOrtho(&dynamicp->projection,
        0, SCREEN_WD,
        0, SCREEN_HT, -1, -1000, 1.0);

    gSPMatrix(glistp++, K0_TO_PHYS(&(dynamicp->projection)),
          G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);

    guRotate(&dynamicp->identity, 0.0, 0.0, 0.0, 1.0);

    gSPMatrix(glistp++, K0_TO_PHYS(&(dynamicp->identity)),
          G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
}

unsigned int xseed = (7789<<16)+13399;	

unsigned int xrand(void)
{
    unsigned int x;
    
    x = (xseed<<2) + 2;
    
    x *= (x+1);
    x = x >> 2;

    xseed = x;

    return( x );
}

float frand(void)
{
  return((xrand()%32767) / 32768.0);
}

static void SetRenderMode(void)
{
  if (UseAAMode && UseZMode)
    {
      gSPSetGeometryMode(glistp++, G_ZBUFFER);
      gDPSetRenderMode(glistp++, 
		       G_RM_AA_ZB_OPA_SURF, 
		       G_RM_AA_ZB_OPA_SURF2);      
    }
  else if (!UseAAMode && UseZMode)
    {
      gSPSetGeometryMode(glistp++, G_ZBUFFER);
      gDPSetRenderMode(glistp++, 
		       G_RM_ZB_OPA_SURF , 
		       G_RM_ZB_OPA_SURF2);      
    }
  else if (UseAAMode && !UseZMode)
    {
      gSPClearGeometryMode(glistp++, G_ZBUFFER);
      gDPSetRenderMode(glistp++, 
		       G_RM_AA_OPA_SURF, 
		       G_RM_AA_OPA_SURF2);      
    }
  else
    {
      gSPClearGeometryMode(glistp++, G_ZBUFFER);
      gDPSetRenderMode(glistp++, 
		       G_RM_OPA_SURF, 
		       G_RM_OPA_SURF2);      
    }  
}

static void SetClipRation(void)
{
  switch (ClipRatio)    
    {
    case 1:
      gSPClipRatio(glistp++, FRUSTRATIO_1);
      break;
    case 2:
      gSPClipRatio(glistp++, FRUSTRATIO_2);
      break;
    case 3:
      gSPClipRatio(glistp++, FRUSTRATIO_3);
      break;
    case 4:
      gSPClipRatio(glistp++, FRUSTRATIO_4);
      break;
    case 5:
      gSPClipRatio(glistp++, FRUSTRATIO_5);
      break;
    case 6:
      gSPClipRatio(glistp++, FRUSTRATIO_6);
      break;
    }    
}

static void doPolyFuncs(void)
{
	int i;
	float tz, startz;
  	void makeTriList(int, float, float);
  	void makeTexRectList(float, float);

  	/* Setup display modes antialiased in 1 cycle */
  	SetRenderMode();
  	SetupViewing();
  if (UseTextureMode) {
	makeTexRectList(TriDx, TriDy);
  } else {
	if(XlateTri) {
		makeTriList(4, TriDx, TriDy);
    }
	else
		makeTriList(ActiveVert, TriDx, TriDy);
  }

	if(TriSortOrder) {
		tz = -DELTA_Z;
		startz = TriNz * DELTA_Z;
	} else {
		tz = DELTA_Z;
		startz = 0.0;
	}

	guTranslate(&dynamicp->viewing, TriDeltaXYPos, TriDeltaXYPos, tz);
	guTranslate(&dynamicp->start, 0, 0, startz);

    gSPMatrix(glistp++, K0_TO_PHYS(&(dynamicp->start)),
       	G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);

  if (UseTextureMode) {
		gDPPipeSync(glistp++);
		gDPSetTexturePersp(glistp++, G_TP_NONE);
		gDPSetCycleType(glistp++, G_CYC_COPY);
		gDPLoadTextureBlock(glistp++, mario_small, G_IM_FMT_RGBA, G_IM_SIZ_16b,
            32, 32, 0,
            G_TX_WRAP | G_TX_MIRROR, G_TX_WRAP | G_TX_MIRROR,
            5, 5, G_TX_NOLOD, G_TX_NOLOD);

  		gSPDisplayList(glistp++, dynamicp->trilist);  

  } else {
	/* loop on Z delta here */
	for(i = 0; i < TriNz; i++) {
  		gSPDisplayList(glistp++, dynamicp->trilist);  
#ifdef JUNK
    	gSPMatrix(glistp++, K0_TO_PHYS(&(dynamicp->viewing)),
          	G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
#endif /* JUNK */
	}
  }
}

#define G_CC_MYNOISE	NOISE, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE

static void InitDisplayLists(void)
{
  /* pointers to build the display list */
  glistp = dynamicp->glist;
  
  SetupSegments();
  
  /* Initialize RDP state */
  gSPDisplayList(glistp++, rdpinit_dl);
  
  /* Initialize RSP state */
  gSPDisplayList(glistp++, rspinit_dl);  

  if(!DoShade) {
	gSPClearGeometryMode(glistp++, G_SHADING_SMOOTH | G_SHADE);
	gDPSetCombineMode(glistp++, G_CC_MYNOISE, G_CC_MYNOISE);
	gDPSetPrimColor(glistp++, 0, 0, 255, 255, 0, 255);
  }

  if (UseTextureMode)
    {
      gSPTexture(glistp++, 0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON);
      gDPSetCombineMode(glistp++, G_CC_DECALRGB, G_CC_DECALRGB);
      gDPSetTextureFilter(glistp++, G_TF_BILERP);
    }  
}

static void ClearFrameBuffer(void)
{
  /* Clear color framebuffer */

  gDPPipeSync(glistp++);
  gDPSetCycleType(glistp++, G_CYC_FILL);

  if(!Do8bit) {
    gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
		   OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
  } else {
    gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_8b, SCREEN_WD, 
		   OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
  }

  if(DoClrClr) {
    gDPSetFillColor(glistp++, GPACK_RGBA5551(64,0,64,1) << 16 | 
		  GPACK_RGBA5551(64,0,64,1));
  
    gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);
  }
 
  gDPPipeSync(glistp++);
  if(Use2CycleMode) {
  	gDPSetCycleType(glistp++, G_CYC_2CYCLE);  
  } else {
  	gDPSetCycleType(glistp++, G_CYC_1CYCLE);  
  }
}

static void ClearZBuffer (void)
{
  gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 
		   SCREEN_WD, OS_K0_TO_PHYSICAL(zbuffer));

  gDPPipeSync(glistp++);

  gDPSetCycleType(glistp++, G_CYC_FILL);

  gDPSetFillColor(glistp++, 
		  GPACK_ZDZ(G_MAXFBZ, 0) << 16 | GPACK_ZDZ(G_MAXFBZ, 0));

  gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);

  gDPPipeSync(glistp++);
}

static void CleanupAndSendDisplayList(void)
{
  gDPFullSync(glistp++);
  gSPEndDisplayList(glistp++);

  assert((glistp-dynamicp->glist) < GLIST_LEN);
	
  tlistp->t.data_size = (u32)((glistp - dynamicp->glist) * sizeof(Gfx));
	
  /* Write back dirty cache lines that need to be read by the RCP */
  osWritebackDCache(&dynamic, sizeof(dynamic));
	
  /* start up the RSP task */
  CreateTaskStructure();

  if(DumpGbi) {
	guParseGbiDL(tlistp->t.data_ptr, tlistp->t.data_size, GU_PARSEGBI_ALLMTX);
	DumpGbi--;
  }

  osSpTaskStart(tlistp);
  (void)osRecvMesg(&rspMessageQ, NULL, OS_MESG_BLOCK);

  assert(rdp_output_len < RDPLIST_LEN);

  if(DumpRdp) {
	guParseRdpDL(&(mario_small[0]),(u32)(32*32*2),GU_PARSERDP_DUMPONLY);
	rmonPrintf("---\n");
	guParseRdpDL(&(rdp_output[0]),(u32)rdp_output_len,GU_PARSERDP_DUMPONLY);
	DumpRdp--;
  }

  t1 = osGetTime(); 
  osDpSetStatus(DPC_CLR_CLOCK_CTR | DPC_CLR_CMD_CTR |
				  DPC_CLR_PIPE_CTR | DPC_CLR_TMEM_CTR);

  osDpSetNextBuffer(&(rdp_output[0]), (u32)rdp_output_len);

  (void)osRecvMesg(&rdpMessageQ, NULL, OS_MESG_BLOCK);

  osDpGetCounters(PerfCounters);
  t2 = osGetTime();
}

static void PrintStatNumbers(int DisplayListLength)
{
  float avgspanlen = 0, bgfill = 0, pixfill, t;

 
  if(DoClrClr)
  	bgfill = 320*240;

  if(UseZMode)
	bgfill += 320*240;

  rmonPrintf("AA %3s ZB %3s\n", 
		 UseAAMode ? "on" : "off",
	     UseZMode  ? "on" : "off");
  rmonPrintf("Color Buffer Clear: %s\n", DoClrClr ? "yes" : "no");
  rmonPrintf("Sort Order: %s\n", TriSortOrder ? "Back to Front" :
		"Front to Back");
  rmonPrintf("Texture %3s\n", UseTextureMode ? "on" : "off");
  
  rmonPrintf("\nTriangle Area       -> {%8.2f} \n", TriArea);
 
  rmonPrintf("Number of Spans     -> {%8.2f} \n", TriHeight);

  if(TriHeight) avgspanlen = TriArea / TriHeight;
  rmonPrintf("Average Span Length -> {%8.2f} \n", avgspanlen);
  rmonPrintf("Aspect Ratio (X/Y)  -> {%8.2f}\n", TriAspectRatio); 
  rmonPrintf("Number of Triangles (x,y,z,total) %d, %d, %d, %d\n", 
	TriNx, TriNy, TriNz, TriNx * TriNy * TriNz);      

  t = 1000.0 * TicksPerFrame / TicksPerSec;

  rmonPrintf("\nTicksPerSec    = %f\n", TicksPerSec);
  rmonPrintf("TicksPerFrame  = %f\n", TicksPerFrame);
  rmonPrintf("TimePerFrame   = %f msec (%s)\n", 
		t, (t < (1000.0/60.0)) ? "under" : "over");

  pixfill = bgfill + TriArea*TriNx*TriNy*TriNz;

  rmonPrintf("\nActual Pixels Filled:     %14.2f pixels/frame\n", pixfill);
  rmonPrintf("Actual Pixels Filled:     %14.2f pixels/sec\n", pixfill*60);

#ifdef JUNK
  rmonPrintf("Full Frame Pixels Filled: %14.2f pixels/sec\n", 
		 1000.0 / t * pixfill);
#endif /* JUNK */

  rmonPrintf("\nPC[0] (clk count)  = %08x\n", SavePerfCounters[0]);
  rmonPrintf("PC[1] (input busy) = %08x\n", SavePerfCounters[1]);
  rmonPrintf("PC[2] (pipe busy)  = %08x\n", SavePerfCounters[2]);
  rmonPrintf("PC[3] (tmem loads) = %08x\n", SavePerfCounters[3]);
}

static void PrintController0Instructions(void)
{
  rmonPrintf("----------------------------------------------------------  \n");
  rmonPrintf("stick        -> move vert x,y                        \n");
  rmonPrintf("Up Pad       -> increase tris in y                   \n");
  rmonPrintf("Down Pad     -> decrease tris in y                   \n");
  rmonPrintf("Right Pad    -> increase tris in x                   \n");
  rmonPrintf("Left Pad     -> decrease tris in x                   \n");
  rmonPrintf("A Button     -> toggle anti-aliasing                 \n");
  rmonPrintf("B Button     -> toggle zbuffering                    \n");
  rmonPrintf("Arrow Right  -> toggle color buf clear               \n");
  rmonPrintf("Arrow Left   -> toggle sort order                    \n");
  rmonPrintf("Arrow Up     -> increase delta xy                    \n");
  rmonPrintf("Arrow Down   -> decrease delta xy                    \n");
  rmonPrintf("Right        -> increase tris in z                   \n");
  rmonPrintf("Left         -> decrease tris in z                   \n");
  rmonPrintf("Trigger      -> select vert                          \n");
  rmonPrintf("START button -> reset parameters                     \n");
}


static void PrintStats(int DisplayListLength)
{
  rmonPrintf("%c%c%c%c%c%c\n", 27, 91, 72, 27, 91, 74);
  PrintStatNumbers(DisplayListLength);

  PrintController0Instructions();
  ControllerInput = 0;
}


static void doPoly(void *arg)
{
  int i;

  extern void initTri(int align);

  /* Main game loop */
 
  ActiveController = initControllers();
  if(AlignTri)
  	initTri(1);
  else
  	initTri(0);

  while (1) 
    {
      int DisplayListLength;

      osContStartReadData(&controllerMsgQ);
      
      ReadController();

      InitDisplayLists();
      if (UseZMode) 
		ClearZBuffer(); 
      ClearFrameBuffer();      

      doPolyFuncs(); 
      CleanupAndSendDisplayList();	

      DisplayListLength = glistp - dynamicp->glist;

      TimePerFrame = 1000.0 * (float) (t2 - t1) / ((OSTime) (TicksPerSec));
	  TicksPerFrame = (float) (t2 - t1);
      
	  for(i = 0; i < 4; i++)
		SavePerfCounters[i] = PerfCounters[i];

      /* Now write out timer bar */

      InitDisplayLists();
      WriteTimerBar();
      CleanupAndSendDisplayList();		

	  if(PrintStatsEn) {
      	if (ControllerInput) 
			PrintStats(DisplayListLength);
	  }

      SwapViBuffer();
    }
}

static void ComputeClockSpeed(void)
{
  u32 count0, count1;

  osRecvMesg(&retraceMessageQ, 0, OS_MESG_BLOCK);
  count0 = osGetCount();
  osRecvMesg(&retraceMessageQ, 0, OS_MESG_BLOCK);
  count1 = osGetCount();

  TicksPerSec = ((osTvType == 0) ? 50.0 : 60.0) * (count1 - count0);
}


static void main(void *arg)
{
  tlistp = &tlist;
  dynamicp = &dynamic;
  cfb_ptrs[0] = cfb_16_a; 
  cfb_ptrs[1] = cfb_16_b; 

  CreateMessageQueues();

  ComputeClockSpeed();

  doPoly(arg);
}