/**************************************************************************
 *                                                                        *
 *               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: teapot.c,v $
        $Revision: 1.1.1.1 $
        $Date: 2002/05/02 03:27:09 $
 *---------------------------------------------------------------------*/

/*
 * File:	teapot.c
 * Creator:	hsa@sgi.com
 * Create Date:	Sun Jun  4 18:40:31 PDT 1995
 *
 * VERY simple app, draws a teapot, demonstrating simple lighting and
 * texturing.
 *
 */

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

#include "teapot.h"
#include "controller.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 segments are
 * in ROM.
 */
extern char _staticSegmentRomStart[], _staticSegmentRomEnd[];
extern char _staticSegmentStart[];

extern char _static_augSegmentRomStart[], _static_augSegmentRomEnd[];
extern char _static_augSegmentStart[];

/*
 * 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)];

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;

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

/*
 * necessary for RSP tasks:
 */
u64 dram_stack[SP_DRAM_STACK_SIZE64];
u64 rdp_output_len;
u64 rdp_output[4096*16];

/*
 * 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 */
    &(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 for arguments, to control test cases
 */
static int	rdp_DRAM_io = 0;
static int	debugflag = 0;
static int	do_texture = 1;
static int      draw_buffer = 0;
static void	*cfb_ptrs[2];
static float	theta = 0.0;
static int	count = 0;
static u64	ramrombuf[RAMROM_MSG_SIZE/sizeof(u64)];
    
static void	draw_teapot(Dynamic *);
static void	draw_setting(Dynamic *);

float	shadowScaleX = 2.7;
float	shadowScaleZ = 2.7;
float	shadowTranslateX = -40.0;
float	shadowTranslateZ =  50.0;

OSPiHandle	*handler;

boot(void)
{
    int i, *pr;
    char *ap;
    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 the options */
    ap = (char *)argbuf;
    while (*ap != '\0') {
	while (*ap == ' ')
	    ap++;
	if ( *ap == '-' && *(ap+1) == 'd') {
	    debugflag = 1;
	    ap += 2;
	} else if ( *ap == '-' && *(ap+1) == 't') {
	    do_texture = 1;
	    ap += 2;
	} else if ( *ap == '-' && *(ap+1) == 'r') {
	    rdp_DRAM_io = 1;
	    ap += 2;
	}
    }
    
    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]);
    
    /*
     * 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,
		   rmonStack+RMON_STACKSIZE/sizeof(u64), OS_PRIORITY_RMON);
    osStartThread(&rmonThread);
    
    /*
     * at this point, AND NOT BEFORE, we can now do an
     * rmonPrintf()
     */
    
    /*
     * 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)
{
    int		i, j;
    OSTask	*tlistp;
    Dynamic	*dynamicp;
    char	*staticSegment;
    u32		clearcolor;
    u16		perspNorm;
    
    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);
    
    /*
     * Load in the static segments
     */
    staticSegment = _staticSegmentStart;

    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);
    
    staticSegment = _codeSegmentEnd;

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

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

    /*
     * Main game loop
     */
    while (1) {
	
	/*
	 * Read controller
	 */
	readController();

	/*
	 * 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);
	gDPSetDepthImage(glistp++, OS_K0_TO_PHYSICAL(zbuffer));
	
	/*
	 * clear z, z = max z, dz = 0
	 */
	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
	 * doing this as a static display list is a little messier, due
	 * to cfb pointer conversion...
	 */
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_FILL);
	/*
	 * clear color, cvg = FULL or 1
	 */
	gDPSetColorImage(glistp++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WD, 
			 OS_K0_TO_PHYSICAL(cfb_ptrs[draw_buffer]));
	clearcolor = ((GPACK_RGBA5551(0, 0, 0, 1) << 16) |
		      (GPACK_RGBA5551(0, 0, 0, 1)));
	gDPSetFillColor(glistp++, clearcolor);
	gDPFillRectangle(glistp++, 0, 0, SCREEN_WD-1, SCREEN_HT-1);
	gDPPipeSync(glistp++);
	gDPSetCycleType(glistp++, G_CYC_1CYCLE);
	
	/* end of standard display list part. */
	
	
	/*
	 * Viewing parameters are common for all objects in this frame:
	 */
	guPerspective(&dynamicp->projection, &perspNorm,
		      33, 320.0/240.0, 100, 2000, 1.0);
#ifdef USE_HIGHLIGHT
	guLookAtHilite(&dynamicp->viewing, 
		       &(dynamicp->lookat[0]), &(dynamicp->hilite[0]),
		       50, 100, 400,
		       0, 0, 0,
		       0, 1, 0,
		       100.0, 0.0, 0.0, /* light direction */
		       100.0, 0.0, 0.0, /* not used */
		       32, 32);	/* texture width */
#else
	guLookAt(&dynamicp->viewing, 
		 50, 100, 400,
		 0, 0, 0,
		 0, 1, 0);
#endif
	
	
	draw_setting(dynamicp);

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

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

	/*
	 * choose which ucode to run:
	 */
	if (rdp_DRAM_io) {
	    /* re-direct output to DRAM: */
		tlistp->t.ucode = (u64 *) gspFast3D_dramTextStart;
		tlistp->t.ucode_data = (u64 *) gspFast3D_dramDataStart; 
	} 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();
	
	/* unwrap this macro for debugging:
	 *
	 *	osSpTaskStart(tlistp);
	 * becomes:
	 *	osSpTaskLoad(tlistp);
	 *	osSpTaskStartGo(tlistp);
	 */
	osSpTaskStart(tlistp);
	
	/* wait for SP completion */
	(void)osRecvMesg(&rspMessageQ, &dummyMessage, OS_MESG_BLOCK);

	if (rdp_DRAM_io) {
	    /*
	     * Send the DP display list to the DP:
	     */
	    guParseRdpDL(&(rdp_output[0]), (u32)rdp_output_len, 0);

	    (void)osDpSetNextBuffer(&(rdp_output[0]),rdp_output_len);
	    (void)osRecvMesg(&rdpMessageQ, &dummyMessage, OS_MESG_BLOCK);
	}

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

	/* 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;

	theta += 1.0;

    }

    for(;;);   
}


static void
draw_teapot(Dynamic *dynamicp)
{
    float posx, posy, posz;

    posx = -550.0 + count*(8.3333) + 100.*cosf(count*0.314159);
    posy = -1000.0 + count*(16.666) - 100.*sinf(count*0.314159);
    posz = -2000.0 + count*(33.333);
#ifdef USE_HIGHLIGHT
    gSPLookAt(glistp++, &(dynamicp->lookat[0]));
#endif

    guRotate(&dynamicp->teapot_rotate, theta, 0.0, 1.0, 0.0);
    guTranslate(&dynamicp->teapot_trans, posx, posy, posz);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->teapot_trans)),
	      G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->teapot_rotate)),
	      G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH);
    gSPDisplayList(glistp++, teapot_setup_dl);
    gSPDisplayList(glistp++, teapot_geom_dl);

#ifdef USE_HIGHLIGHT
    gDPSetHilite1Tile(glistp++, G_TX_RENDERTILE, dynamicp->hilite, 32, 32);
#endif

}

static void
draw_setting(Dynamic *dynamicp)
{

    int			i, j;
    int			jtex, jimg;
    int			offsetx, offsety;
    static int		offset = 0;
    unsigned short	*ptr;
    u16			perspNorm;
    u32			*dummy;

    guPerspective(&dynamicp->projectionBG,&perspNorm,
    	      33, 1, 10, 5000, 1.0);

    gSPPerspNormalize(glistp++, perspNorm);

    guLookAt (&dynamicp->viewingBG, 0, 0, 54, 0, 0, 0, 0, 1, 0);

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

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->projectionBG)),
	  G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->viewingBG)),
	  G_MTX_PROJECTION|G_MTX_MUL|G_MTX_NOPUSH);
    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dynamicp->identity)),
    	G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);

    gSPDisplayList(glistp++, setting_setup_dl);

    if (count == (0 - offset)) ptr = tv2_00;
    if (count == (1 - offset)) ptr = tv2_01;
    if (count == (2 - offset)) ptr = tv2_02;
    if (count == (3 - offset)) ptr = tv2_03;
    if (count == (4 - offset)) ptr = tv2_04;
    if (count == (5 - offset)) ptr = tv2_05;
    if (count == (6 - offset)) ptr = tv2_06;
    if (count == (7 - offset)) ptr = tv2_07;
    if (count == (8 - offset)) ptr = tv2_08;
    if (count == (9 - offset)) ptr = tv2_09;

    if (count == (10 - offset)) ptr = tv2_10;
    if (count == (11 - offset)) ptr = tv2_11;
    if (count == (12 - offset)) ptr = tv2_12;
    if (count == (13 - offset)) ptr = tv2_13;
    if (count == (14 - offset)) ptr = tv2_14;
    if (count == (15 - offset)) ptr = tv2_15;
    if (count == (16 - offset)) ptr = tv2_16;
    if (count == (17 - offset)) ptr = tv2_17;
    if (count == (18 - offset)) ptr = tv2_18;
    if (count == (19 - offset)) ptr = tv2_19;

    if (count == (20 - offset)) ptr = tv2_20;
    if (count == (21 - offset)) ptr = tv2_21;
    if (count == (22 - offset)) ptr = tv2_22;
    if (count == (23 - offset)) ptr = tv2_23;
    if (count == (24 - offset)) ptr = tv2_24;
    if (count == (25 - offset)) ptr = tv2_25;
    if (count == (26 - offset)) ptr = tv2_26;
    if (count == (27 - offset)) ptr = tv2_27;
    if (count == (28 - offset)) ptr = tv2_28;
    if (count == (29 - offset)) ptr = tv2_29;

    if (count == (30 - offset)) ptr = tv2_30;
    if (count == (31 - offset)) ptr = tv2_31;
    if (count == (32 - offset)) ptr = tv2_32;
    if (count == (33 - offset)) ptr = tv2_33;
    if (count == (34 - offset)) ptr = tv2_34;
    if (count == (35 - offset)) ptr = tv2_35;
    if (count == (36 - offset)) ptr = tv2_36;
    if (count == (37 - offset)) ptr = tv2_37;
    if (count == (38 - offset)) ptr = tv2_38;
    if (count == (39 - offset)) ptr = tv2_39;

    if (count == (40 - offset)) ptr = tv2_40;
    if (count == (41 - offset)) ptr = tv2_41;
    if (count == (42 - offset)) ptr = tv2_42;
    if (count == (43 - offset)) ptr = tv2_43;
    if (count == (44 - offset)) ptr = tv2_44;
    if (count == (45 - offset)) ptr = tv2_45;
    if (count == (46 - offset)) ptr = tv2_46;
    if (count == (47 - offset)) ptr = tv2_47;
    if (count == (48 - offset)) ptr = tv2_48;
    if (count == (49 - offset)) ptr = tv2_49;

    if (count == (50 - offset)) ptr = tv2_50;
    if (count == (51 - offset)) ptr = tv2_51;
    if (count == (52 - offset)) ptr = tv2_52;
    if (count == (53 - offset)) ptr = tv2_53;
    if (count == (54 - offset)) ptr = tv2_54;
    if (count == (55 - offset)) ptr = tv2_55;
    if (count == (56 - offset)) ptr = tv2_56;
    if (count == (57 - offset)) ptr = tv2_57;
    if (count == (58 - offset)) ptr = tv2_58;
    if (count == (59 - offset)) ptr = tv2_59;

    offsetx = (IMG_WD - TEX_WD)/2;
    offsety = (IMG_HT - TEX_HT)/2;
    jtex = 0;
    for (j = 0; j < TEX_HT; j++) {
	jimg = (offsety + j)*IMG_WD + offsetx;
        for (i = 0; i < TEX_WD; i++) {
	    dynamicp->texture[jtex] = ptr[jimg];
	    jtex++;
	    jimg++;
	}
    }
    dummy = (u32*) OS_K0_TO_PHYSICAL(&(dynamicp->texture));

    /* load the textures in 4 tiled pieces */
    /* overlap the edges to accomodate bilinear interpolation */
    gDPLoadTextureTile (glistp++, dummy,
	G_IM_FMT_RGBA, G_IM_SIZ_16b, TEX_WD, TEX_HT,
	0, 0, TEX_WD/2 - 1, TEX_HT/2 - 1, 0,
	G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR,
	G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
    gDPTileSync(glistp++);
    gDPSetTileSize(glistp++, G_TX_RENDERTILE, 0, 0,
	(TEX_WD/2 - 1) << 2, (TEX_HT/2 - 1) << 2);

    gSPDisplayList(glistp++, setting_geom_a_dl);

    gDPLoadTextureTile (glistp++, dummy,
	G_IM_FMT_RGBA, G_IM_SIZ_16b, TEX_WD, TEX_HT,
	TEX_WD/2 - 1, 0, TEX_WD - 2, TEX_HT/2 - 1, 0,
	G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR,
	G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);

    gSPDisplayList(glistp++, setting_geom_b_dl);

    gDPLoadTextureTile (glistp++, dummy,
	G_IM_FMT_RGBA, G_IM_SIZ_16b, TEX_WD, TEX_HT,
	0, TEX_HT/2 - 1, TEX_WD/2 - 1, TEX_HT - 2, 0,
	G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR,
	G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);

    gSPDisplayList(glistp++, setting_geom_c_dl);

    gDPLoadTextureTile (glistp++, dummy,
	G_IM_FMT_RGBA, G_IM_SIZ_16b, TEX_WD, TEX_HT,
	TEX_WD/2 - 1, TEX_HT/2 - 1, TEX_WD - 2, TEX_HT - 2, 0,
	G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR,
	G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);

    gSPDisplayList(glistp++, setting_geom_d_dl);

    count++;
    if (count > 59) count = 0;
    
}