/*
 * Copyright 1995, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
 *
 */

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

/*
 * File:	gtdemo.c
 * Creator:	hsa@sgi.com
 * Create Date:	Tue Oct 31 14:17:25 PST 1995
 *
 * This program demonstrates:
 *
 * 	- use of multiple graphics RCP tasks
 * 	- use of the turbo graphics code
 *	- host centroid sort for visibility determination
 *	- hierarchical character animation and complex host
 *	  matrix manipulations using floating point gu routines.
 *
 */

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

#include "gtdemo.h"
#include "controller.h"
#include "turbo.h"
#include "character.h"
#include "timer.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.
 */
extern char _staticSegmentRomStart[], _staticSegmentRomEnd[];
char	*staticSegment;

/*
 * Stacks for the threads as well as message queues for synchronization
 */
u64	bootStack[STACKSIZE/sizeof(u64)];

static void	idle(void *);
static void	mainproc(void *);

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

static OSThread	mainThread;
static u64	mainThreadStack[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;

/*
 * Dynamic segment in code space. Needs OS_K0_TO_PHYSICAL()...
 */
Dynamic dynamic;

/*
 * necessary for RSP tasks:
 */
u64 dram_stack[SP_DRAM_STACK_SIZE64];

/*
 * must be in BSS, not on the stack for this to work:
 */
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 */
    NULL,			/* task output buffer ptr (not always used) */
    NULL,			/* 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 for arguments, to control test cases
 */
static int	debugflag = 0;
static int      draw_buffer = 0;
static void	*cfb_ptrs[2];
static u64	ramrombuf[RAMROM_MSG_SIZE/sizeof(u64)];
    
static void	setup_view(Dynamic *dynamicp);
extern void	draw_floor(Dynamic *);

int	controllerSlot;
u32	frame_count;


OSPiHandle	*handler;

boot(void)
{

#ifdef DEBUG
    int i, *pr;
    char *ap;
    u32 *argp;
    u32 argbuf[16];
#endif

    /* notice that you can't call osSyncPrintf() until you set
     * up an idle thread.
     */
    
    osInitialize();

    handler = osCartRomInit();

#ifdef DEBUG
    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 the options */
    ap = (char *)argbuf;
    while (*ap != '\0') {
	while (*ap == ' ')
	    ap++;
	if ( *ap == '-' && *(ap+1) == 'd') {
	    debugflag = 1;
	    ap += 2;
	}
    }
#endif
    
    osCreateThread(&idleThread, 1, idle, (void *)0,
		   idleThreadStack+STACKSIZE/sizeof(u64), 10);
    osStartThread(&idleThread);

    /* never reached */
}

static void
idle(void *arg)
{
    /* Initialize video */
    osCreateViManager(OS_PRIORITY_VIMGR);
    osViSetMode(&osViModeTable[OS_VI_NTSC_LAN1]);
    osViSetSpecialFeatures(OS_VI_GAMMA_ON|OS_VI_GAMMA_DITHER_ON|OS_VI_DIVOT_ON|OS_VI_DITHER_FILTER_ON);
    
    /*
     * Start PI Mgr for access to cartridge
     */
    osCreatePiManager((OSPri)OS_PRIORITY_PIMGR, &PiMessageQ, PiMessages, 
		      NUM_PI_MSGS);
    
    /*
     * at this point, AND NOT BEFORE, we can now do an
     * osSyncPrintf()
     */
    
    /*
     * Create main thread
     */
    osCreateThread(&mainThread, 3, mainproc, arg,
		   mainThreadStack+STACKSIZE/sizeof(u64), 10);
    
    if (!debugflag)
	osStartThread(&mainThread);

    /*
     * Become the idle thread
     */
    osSetThreadPri( 0, 0 );
    for (;;);
}



/*
 * This is the main routine of the app.
 */
static void
mainproc(void *arg)
{
    OSTask	*tlistp;
    Dynamic	*dynamicp;
    
    cfb_ptrs[0] = &(cfb_16_a[0]);
    cfb_ptrs[1] = &(cfb_16_b[0]);

    /*
     * Setup the message queues
     */
    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);
    
    /* Stick the static segment right after the code/data segment */
    staticSegment = _codeSegmentEnd;

    dmaIOMessageBuf.hdr.pri      = OS_MESG_PRI_NORMAL;
    dmaIOMessageBuf.hdr.retQueue = &dmaMessageQ;
    dmaIOMessageBuf.dramAddr     = staticSegment;
    dmaIOMessageBuf.devAddr      = (u32)_staticSegmentRomStart;
    dmaIOMessageBuf.size         = _staticSegmentRomEnd-_staticSegmentRomStart;

    osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
    
    /* Wait for DMA to finish */
    (void)osRecvMesg(&dmaMessageQ, &dummyMessage, OS_MESG_BLOCK);
    
    /* Initialize controller */
    controllerSlot = initControllers();

    /* Initialize timers. */
    TimerInit();

#ifdef DEBUG
    /* print helpful info to the screen: */
    osSyncPrintf("\nControls:\n\n");
    osSyncPrintf("\tjoystick:\tmove man around.\n");
    osSyncPrintf("\tarrow left:\tpunch left.\n");
    osSyncPrintf("\tarrow right:\tpunch right.\n");
    osSyncPrintf("\tA:\t\tselect a different man.\n");
    osSyncPrintf("\tB:\t\ttoggle sorting/z-buffering.\n");
    osSyncPrintf("\t+ up:\t\tmove eye in.\n");
    osSyncPrintf("\t+ down:\t\tmove eye out.\n");

    osSyncPrintf("\nTimer Bars:\t(each green tick is 60Hz)\n\n");
    osSyncPrintf("\tdark blue:\tbackground CPU time.\n");
    osSyncPrintf("\tlight blue:\tbackground RCP time.\n");
    osSyncPrintf("\tdark red:\tforeground CPU time.\n");
    osSyncPrintf("\tlight red:\tforeground RCP time.\n");
    osSyncPrintf("\n");
#endif

    /* Main game loop */
    while (1) {
	
	bg_cpu_start = osGetTime();

	readController(controllerSlot);

	/* which guy do we control? */
	dynamic.char_control = which_char;

	if (do_reset) {
	    dynamic.char_control = 0;
	    dynamic.free_node = 0;
	    dynamic.characters[0] = create_character(&dynamic, 0, 60, 0);
	    dynamic.characters[1] = create_character(&dynamic, 80, 60, -20);
	    dynamic.characters[2] = create_character(&dynamic, -80, 60, 20);
	    dynamic.characters[3] = create_character(&dynamic, 40, 60, -120);
	    do_reset = FALSE;
	}

	/* pointers to build the display list. */
	tlistp = &tlist;
	dynamicp = &dynamic;
	glistp = &(dynamicp->glist[0]);
	
	/* Tell RCP where each segment is */
	gSPSegment(glistp++, 0, 0x0);	/* K0 (physical) address segment */
	gSPSegment(glistp++, STATIC_SEGMENT,
		   osVirtualToPhysical(staticSegment));
	
	gSPDisplayList(glistp++, rdpinit_dl);
	gSPDisplayList(glistp++, rspinit_dl);

	
	if (do_turbo_z) {
	    /*
	     * clear z, z = max z, dz = 0
	     */
	    gDPSetDepthImage(glistp++, OS_K0_TO_PHYSICAL(zbuffer));
	    gDPSetCycleType(glistp++, G_CYC_FILL);
	    gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD,
			     OS_K0_TO_PHYSICAL(zbuffer));
	    gDPSetFillColor(glistp++, (GPACK_ZDZ(G_MAXFBZ,0) << 16 | 
				       GPACK_ZDZ(G_MAXFBZ,0)));
	    gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);
	}

	/* Clear framebuffer */
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_FILL);
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
			 OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
	gDPSetFillColor(glistp++, 
			((GPACK_RGBA5551(100, 100, 200, 1) << 16) |
			 (GPACK_RGBA5551(100, 100, 200, 1))));
	gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_1CYCLE);
	/* end of standard display list part. */

	setup_view(dynamicp);
	
	draw_floor(dynamicp);

	/* all done with the background for this frame. */
	gDPFullSync(glistp++);
	gSPEndDisplayList(glistp++);
	
	/* Build background graphics task: */
	tlistp->t.ucode_boot = (u64 *) rspbootTextStart;
	tlistp->t.ucode_boot_size = ((int)rspbootTextEnd - 
				     (int)rspbootTextStart);

	if (use_fifo_ucode) {
	    tlistp->t.ucode = (u64 *) gspFast3D_fifoTextStart;
	    tlistp->t.ucode_data = (u64 *) gspFast3D_fifoDataStart;
	    tlistp->t.output_buff = rdp_output;
	    tlistp->t.output_buff_size = (u64 *) ((int)rdp_output + 
						  (int)(0x400 << 3));
	} else {
	    /* RSP output over XBUS to RDP: */
	    tlistp->t.ucode = (u64 *) gspFast3DTextStart;
	    tlistp->t.ucode_data = (u64 *) gspFast3DDataStart;
	}

	/* initial display list: */
	tlistp->t.data_ptr = (u64 *) dynamicp->glist;
	tlistp->t.data_size = ((int)(glistp - dynamicp->glist) *
			       sizeof (Gfx));

	/*
	 * Can just flush 16KB and forget about each individual pieces
	 * of data to flush.
	 */
	osWritebackDCacheAll();
	osSpTaskLoad(tlistp);
	bg_cpu_end = osGetTime();
	bg_rcp_start = osGetTime();
	osSpTaskStartGo(tlistp);
	
	/* compute turbo work while we wait for RCP to draw */
	turbo_compute(dynamicp);

	/* wait for DP completion */
	(void)osRecvMesg(&rdpMessageQ, &dummyMessage, OS_MESG_BLOCK);
	bg_rcp_end = osGetTime();

	/* do turbo stuff here: */
	turbo_draw(dynamicp, staticSegment);

	/* wait for DP completion */
	(void)osRecvMesg(&rdpMessageQ, &dummyMessage, OS_MESG_BLOCK);
	fg_rcp_end = osGetTime();

	/* setup to swap buffers */
	osViSwapBuffer(cfb_ptrs[draw_buffer]);

	/* Make sure there isn't an old retrace in queue 
	 * (assumes queue has a depth of 1) 
	 */
	if (MQ_IS_FULL(&retraceMessageQ))
	    (void)osRecvMesg(&retraceMessageQ, &dummyMessage, OS_MESG_BLOCK);
	
	/* Wait for Vertical retrace to finish swap buffers */
	(void)osRecvMesg(&retraceMessageQ, &dummyMessage, OS_MESG_BLOCK);
	draw_buffer ^= 1;

	frame_count++;
	TimerFinish();
    }
}


static void
setup_view(Dynamic *dynamicp)
{
    float		cost, sint, x, y, z;

    cost = cosf(world_theta);
    sint = sinf(world_theta);

    /*
     * Viewing parameters are common for all objects in this frame:
     */
    guPerspectiveF(dynamicp->projection, &dynamicp->perspNorm,
		  33, 320.0/240.0, 100, 2000, 1.0);
    x = sint*view_dist;
    y = (400.0/5.0);
    z = cost*view_dist;
    guLookAtF(dynamicp->viewing, 
	     x, y, z,
	     0, 40, 0,
	     0, 1, 0);

    guMtxF2L(dynamicp->projection, &dynamicp->projectionL);
    guMtxF2L(dynamicp->viewing, &dynamicp->viewingL);
	
    gSPMatrix(glistp++, &dynamicp->projectionL,
	      G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPMatrix(glistp++, &dynamicp->viewingL,
	      G_MTX_PROJECTION|G_MTX_MUL|G_MTX_NOPUSH);
    gSPPerspNormalize(glistp++, dynamicp->perspNorm);

    if (do_view_rotate) {
	world_theta += view_rotate_inc;
	if (world_theta > 6.28) {
	    world_theta -= 6.28;
	}
    }
}