static.c 81.9 KB

Raw Blame History Permalink


/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1994, 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.  *
 *                                                                        *
 *************************************************************************/

/*
 * File:	static.c
 * Creator:	hsa@sgi.com
 * Create Date:	Fri Oct 14 11:53:47 PDT 1994
 *
 *
 * This file holds tiny display list segments that are 'static' data.
 * If you feel the urge to modify a test, see the comment at
 * the top of main.c for details.
 *
 */

#include <mbi.h>
#include "rdpverif.h"

/*
 * Test conventions:
 *
 * Data variable names can be about anything, as long as they are unique
 * and consistent in the table entry.
 *
 * In order to get around compiler weirdness, the table of tests
 * is in rdpverif.c, and the Gfx lists must be extern'd in rdpverif.h
 *
 * Your test case display list must end with gsSPEndDisplayList(),
 * otherwise there are length hassles.
 *
 * Your test case should set any special mode you want (texture, zbuff,
 * etc.) and also turn it off when you are done, so as not to affect
 * other tests.
 *
 */

/*
 * Test -1, default frame. Used as a placeholder.
 *
 * Simple square (4 triangles), each vertex a different color.
 *
 * Wed Oct  5 22:12:43 PDT 1994
 *
 */
static Vtx place_vtx[5] =  {
        {        -40,  40, 0, 0, 0, 0, 0, 0, 0xff, 0xff		},
        {         40,  40, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff	},
        {         40, -40, 0, 0, 0, 0, 0, 0xff, 0, 0xff		},
        {        -40, -40, 0, 0, 0, 0, 0xff, 0, 0, 0xff		},
        {          0,   0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff	},
};

Gfx placebo_dl[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsSPVertex(&place_vtx, 5, 0),
    gsSP1Triangle(0, 4, 1, 0),
    gsSP1Triangle(1, 4, 2, 0),
    gsSP1Triangle(2, 4, 3, 0),
    gsSP1Triangle(3, 4, 0, 0),
    gsSPEndDisplayList(),
};
/* end of case -1 */

/*
 * Test 0, Frame 0:
 *
 * Simple square (4 triangles), each vertex a different color.
 *
 * Wed Oct  5 22:12:43 PDT 1994
 *
 */
static Vtx q0[5] =  {
        {        -40,  40, 0, 0, 0, 0, 0, 0, 0xff, 0xff		},
        {         40,  40, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff	},
        {         40, -40, 0, 0, 0, 0, 0, 0xff, 0, 0xff		},
        {        -40, -40, 0, 0, 0, 0, 0xff, 0, 0, 0xff		},
        {          0,   0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff	},
};

Gfx square0[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPClearGeometryMode(G_CULL_BACK),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsSPVertex(&q0, 5, 0),
#if 0
    /* two triangle case: */
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
#endif
    /* four triangle case: */
    gsSP1Triangle(0, 4, 1, 0),
    gsSP1Triangle(1, 4, 2, 0),
    gsSP1Triangle(2, 4, 3, 0),
    gsSP1Triangle(3, 4, 0, 0),
    gsSPEndDisplayList(),
};
/* end of case 0 */


/*
 * Test 2, Frame 2:
 *
 * Zbuffered triangles
 *
 */
#define Z1	-200	/* In distance */
#define Z2	-180	/* closer */
/*#define Z1	0 /**/
/*#define Z2	0 /**/

static Vtx tris[] = {
/*    x,    y,	    z,	flag,	s,	t,	r,	g,	b,	a */

    { -40,  34,     Z1, 0,	0,	0,	0xff,	0,	0,	0xff },	  /* R */
    {  30,   0,	    Z2, 0,	0,	0,	0,	0,	0xff,	0xff },	  /* B */
    { -40, -34,     Z1, 0,	0,	0,	0,	0xff,	0,	0xff },	  /* G */

    {  35,   24,    Z1, 0,	0,	0,	0,	0,	0xff,	0xff },	  /* B */
    {  35,  -24,    Z1, 0,	0,	0,	0,	0xff,	0,	0xff },	  /* G */
    { -20,   0,	    Z2, 0,	0,	0,	0xff,	0,	0,	0xff },	  /* R */
};

Gfx triangles[MAX_STATIC_GFX_SIZE] = {
    { gsSPClearGeometryMode(0xffffffff) },
    { gsSPSetGeometryMode(G_SHADE | G_SHADING_SMOOTH | G_ZBUFFER) },
    { gsDPSetRenderMode(G_RM_ZB_OPA_SURF, G_RM_ZB_OPA_SURF2) },
    { gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE) },
    { gsSPVertex(&tris, sizeof(tris)/sizeof(tris[0]), 0) },
    { gsSP1Triangle(0, 1, 2, 0) },
    { gsSP1Triangle(3, 4, 5, 0) },
    { gsSPEndDisplayList() }
};

Gfx fogtriangles[MAX_STATIC_GFX_SIZE] = {
    { gsDPSetFogColor(128, 128, 128, 128) },
    { gsDPSetCycleType(G_CYC_2CYCLE) },
    { gsSPClearGeometryMode(0xffffffff) },
    { gsSPSetGeometryMode(G_SHADE | G_SHADING_SMOOTH | G_ZBUFFER) },
    { gsDPSetRenderMode(G_RM_FOG_PRIM_A, G_RM_ZB_OPA_SURF2) },
    { gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE) },
    { gsSPVertex(&tris, sizeof(tris)/sizeof(tris[0]), 0) },
    { gsSP1Triangle(0, 1, 2, 0) },
    { gsSP1Triangle(3, 4, 5, 0) },
    { gsSPEndDisplayList() }
};
/* end of case 2 */


/*
 * Test 4, Frame 4:
 *
 *
 * Mon Oct 10 1994
 *
 */
static Vtx trivtx10[5] =  {
        {        -40,  40, 0, 0, 0, 0, 0, 0, 0xff, 0xff		},
        {         40,  40, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff	},
        {         40, -40, 0, 0, 0, 0, 0, 0xff, 0, 0xff		},
        {        -40, -40, 0, 0, 0, 0, 0xff, 0, 0, 0xff		},
        {          0,   0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff	},
};

Gfx triangle4[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsSPVertex(&trivtx10, 5, 0),
    gsSP1Triangle(0, 4, 1, 0),
    gsSP1Triangle(1, 4, 2, 0),
    gsSP1Triangle(2, 4, 3, 0),
    gsSP1Triangle(3, 4, 0, 0),
    gsSPEndDisplayList(),
};
/* end of case shade_acc2 */

/*
 * Test 5, Frame 5:
 *
 * Simple square (2 triangles), each vertex a different color.
 * Tests accurate integer pixel positioning.
 *
 * Wed Oct 12 11:27:23 PDT 1994
 *
 */
static Vtx q5[5] =  {
        {        120, 160, 0, 0, 0, 0, 0, 0, 0xff, 0xff       },
        {        200, 160, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff },
        {        200,  80, 0, 0, 0, 0, 0, 0xff, 0, 0xff       },
        {        120,  80, 0, 0, 0, 0, 0xff, 0, 0, 0xff       },
        {          0,   0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff },
};

Gfx square5[10] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPClearGeometryMode(G_CULL_BACK),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsSPVertex(&q5, 5, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
    gsSPEndDisplayList(),
};
/* end of case 5 */

/*
 * Test 6, Frame 6:
 *
 * Some degenerate triangles.
 *
 */
static Vtx q6[12] =  {
    /* null triangle, all one point (RED) */
        {        120, 160, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {        120, 160, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {        120, 160, 0, 0, 0, 0, 0xff, 0, 0, 0xff  },

    /* null triangle, all one line (GREEN) */
        {        126, 170, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        120, 170, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        120, 170, 0, 0, 0, 0, 0, 0xff, 0, 0xff },

    /* small triangle, (BLUE) */
        {        120, 180, 0, 0, 0, 0, 0, 0, 0xff, 0xff },
        {        121, 180, 0, 0, 0, 0, 0, 0, 0xff, 0xff },
        {        120, 181, 0, 0, 0, 0, 0, 0, 0xff, 0xff },

    /* small triangle, (WHITE) */
        {        120, 190, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff },
        {        122, 190, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff },
        {        120, 192, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff },
};

Gfx square6[32] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPClearGeometryMode(G_CULL_BACK),
    gsSPClearGeometryMode(G_CULL_FRONT),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsSPVertex(&q6, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9, 10, 11, 0),
    gsSPEndDisplayList(),
};
/* end of case 6 */


/*
 * Test 7, Frame 7:
 *
 * Test all possible edge-types next to each other:
 *
 *	HH, HM, HL, LM, LL, MM
 *
 * The RED-BLUE diagonal is the joining edge; if this transition
 * isn't smooth, we have a problem with rasterization/attribute
 * adjustments.
 *
 * Thu Oct 13 20:54:49 PDT 1994
 *
 */
static Vtx q7a[12] =  {
    /* high edge next to high edge: */
        {         30,  20, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {         80,  30, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        100, 100, 0, 0, 0, 0, 0, 0, 0xff, 0xff  },
        {         10,  80, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff  },

    /* high edge next to mid edge: */
        {        120,  20, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {        180,  40, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        200,  70, 0, 0, 0, 0, 0, 0, 0xff, 0xff  },
        {        130, 110, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff  },

    /* high edge next to low edge: */
        {        220, 100, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {        260,  10, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        280,  60, 0, 0, 0, 0, 0, 0, 0xff, 0xff  },
        {        310,  80, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff  },
};

/* two groups of vertices, don't overflow points buffer */
static Vtx q7b[12] =  {
    /* low edge next to mid edge: */
        {         40, 200, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {         10, 130, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {         80, 170, 0, 0, 0, 0, 0, 0, 0xff, 0xff  },
        {        100, 230, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff  },

    /* low edge next to low edge: */
        {        150, 230, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {        110, 130, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        160, 190, 0, 0, 0, 0, 0, 0, 0xff, 0xff  },
        {        200, 140, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff  },

    /* mid edge next to mid edge: */
        {        290, 130, 0, 0, 0, 0, 0xff, 0, 0, 0xff },
        {        220, 230, 0, 0, 0, 0, 0, 0xff, 0, 0xff },
        {        270, 200, 0, 0, 0, 0, 0, 0, 0xff, 0xff  },
        {        310, 230, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff  },

};

Gfx square7[32] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPClearGeometryMode(G_CULL_BACK),
    gsSPClearGeometryMode(G_CULL_FRONT),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsSPVertex(&q7a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
    gsSP1Triangle(4, 5, 6, 0),
    gsSP1Triangle(4, 6, 7, 0),
    gsSP1Triangle(8, 9, 10, 0),
    gsSP1Triangle(8, 10, 11, 0),

    gsSPVertex(&q7b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(0, 2, 3, 0),
    gsSP1Triangle(4, 5, 6, 0),
    gsSP1Triangle(4, 6, 7, 0),
    gsSP1Triangle(8, 9, 10, 0),
    gsSP1Triangle(8, 10, 11, 0),

    gsSPEndDisplayList(),
};
/* end of case 7 */


/*
 * Test 10, Frame 10:
 *
 *
 * Mon Oct 10 1994
 *
 * A number of triangles which draw off-screen, many with
 * vertices near the 2K boundary of the drawing space.
 * THIS TEST TAKES A WHILE TO RUN
 *
 */

/* 2vtx in, 1vtx out, flat insde edge */
static Vtx trivtx10a[12] =  {
        {         20, 112, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20, 128, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        -20, 120, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300, 112, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        300, 128, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        340, 120, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        168, 220, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        152, 220, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        160, 260, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        168,  20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        152,  20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        160, -20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 2vtx in, 1vtx max, flat insde edge */
static Vtx trivtx10b[12] =  {
        {         20,  132, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20,  148, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,  140, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,  132, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        300,  148, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,  140, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        188,  220, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        172,  220, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        180, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        188,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        172,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        180,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 2vtx in, 1vtx max, leftmajor top/bot; high out left/right */
static Vtx trivtx10c[12] =  {
        {         20,   92, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         30,  108, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,   70, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,   92, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        290,  108, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,   70, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        148,  220, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        132,  210, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        140, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        148,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        132,   30, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        140,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 2vtx in, 1vtx max, rightmajor top/bot; low out left/right */
static Vtx trivtx10d[12] =  {
        {         30,  152, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20,  168, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,  190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        290,  152, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        300,  168, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,  190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        208,  210, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        192,  220, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        200, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        208,   30, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        192,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        200,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* all in,  like a */
static Vtx trivtx10e[12] =  {
        {         60, 112, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         60, 128, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         45, 120, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        260, 112, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        260, 128, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        280, 120, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        168, 180, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        152, 180, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        160, 200, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        168,  60, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        152,  60, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        160,  45, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* all in,  like b */
static Vtx trivtx10f[12] =  {
        {         60, 132, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         60, 148, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         45, 140, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        260, 132, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        260, 148, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        280, 140, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        188, 180, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        172, 180, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        180, 200, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        188,  60, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        172,  60, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        180,  45, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* all in,  like c */
static Vtx trivtx10g[12] =  {
        {         60,  92, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         65, 108, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         45,  70, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        260,  92, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        255, 108, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        280,  70, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        148, 180, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        132, 170, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        140, 200, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        148,  60, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        132,  70, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        140,  45, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* all in,  like d */
static Vtx trivtx10h[12] =  {
        {         65, 152, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         60, 168, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         45, 190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        255, 152, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        260, 168, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        280, 190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        208, 170, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        192, 180, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        200, 200, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        208,  70, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        192,  60, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        200,  45, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* upper corner from sides */
static Vtx trivtx10i[12] =  {
        {         30,   88, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20,   85, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,   88, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        310,   85, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         30,   52, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20,   68, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -1045,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,   52, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        310,   68, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       1045,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* lower corner from sides */
static Vtx trivtx10j[12] =  {
        {         30,  192, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20,  195, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,  192, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        310,  195, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         30,  228, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         20,  212, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -1046, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,  228, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        310,  212, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       1046, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* upped corner from top */
static Vtx trivtx10k[12] =  {
        {         82,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        108,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,-1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        112,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        128,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        212,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        228,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        232,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        258,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,-1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* lower corner from bot */
static Vtx trivtx10l[12] =  {
        {         82,  220, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        108,  215, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000, 1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        112,  215, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        128,  220, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        212,  220, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        228,  215, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        232,  215, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        258,  220, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000, 1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};


Gfx triangle10[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetRenderMode(G_RM_AA_OPA_SURF,G_RM_AA_OPA_SURF2),
    gsDPSetRenderMode(0x0C084148,0),


    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

/*
    gsSPVertex(&trivtx10e, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10f, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10g, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10h, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),
*/

    gsSPEndDisplayList(),
};
/* end of case 10 */

/*
 * Test 11, Frame 11:
 *
 *
 * Tue Oct 18 1994
 *
 * Draws a number of triangles.  Each triangle has 1 vertex in the
 * screen (in the scissor box) and 2 vertices off screen (near the
 * 2k boundary).
 * THIS TEST TAKES A WHILE TO RUN
 *
 */

/* 1vtx in, 2vtx out, flat outside edge */
static Vtx trivtx11a[12] =  {
        {         20, 112, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        -20, 128, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        -20, 120, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300, 112, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        340, 128, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        340, 120, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        168, 220, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        152, 260, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        160, 260, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        168,  20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        152, -20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        160, -20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 1vtx in, 2vtx max, flat outside edge */
static Vtx trivtx11b[12] =  {
        {         60,  132, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      -2000,  148, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,  140, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        260,  132, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,  148, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,  140, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        188,  180, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        172, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        180, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        188,   60, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        172,-2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        180,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 1vtx in, 1 out, 1 max, leftmajor top/bot; high out left/right */
static Vtx trivtx11c[12] =  {
        {       -800,   92, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         30,  108, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,   70, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {       1120,   92, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        290,  108, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,   70, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        148, 1040, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        132,  210, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        140, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        148, -800, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        132,   30, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        140,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 1vtx in, 1 out, 1 max, rightmajor top/bot; low out left/right */
static Vtx trivtx11d[12] =  {
        {         30,  152, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       -800,  168, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,  190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        290,  152, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       1120,  168, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,  190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        208,  210, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        192, 1040, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        200, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        208,   30, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        192, -800, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {        200,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* upper corner from sides */
static Vtx trivtx11i[12] =  {
        {         30,   88, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      -2000,   85, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,   88, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,   85, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         30,   52, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      -2000,-2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -1045,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,   52, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,-2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       1045,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* lower corner from sides */
static Vtx trivtx11j[12] =  {
        {         30,  192, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      -2000,  195, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,  192, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,  195, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000, 2044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         30,  228, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      -2000, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -1046, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        300,  228, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       1046, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* upped corner from top */
static Vtx trivtx11k[12] =  {
        {      -2000,-2000, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        108,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,-1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        112,   30, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        128,-2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        212,-2000, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        228,   30, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        232,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,-2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,-1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* lower corner from bot */
static Vtx trivtx11l[12] =  {
        {      -2000, 2000, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        108,  215, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000, 1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        112,  215, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        128, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        212, 2000, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {        228,  215, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        232,  215, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000, 1044, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};


Gfx triangle11[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx11k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx11d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),


/*    gsDPSetScissor(G_SC_NON_INTERLACE, 10,10,310,230),
**/

    gsSPEndDisplayList(),
};
/* end of case 11 */

/*
 * Test 12, Frame 12:
 *
 *
 * wed Oct 19 1994
 *
 * Draws some triangles with all 3 vertices near the 2K
 * drawing boundary (opposite boundaries so the triangles
 * are visible on the screen) and some with one vertex
 * inthe screen and 2 vertices at opposite 2K boundaries
 * (so they are vivible on screen).
 *
 */

/* all out, edge to edge */
static Vtx trivtx12a[12] =  {
        {      -2000,   10, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      -2000,   30, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {       2000,   20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {       2000,   40, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,   60, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,   50, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         10,-2000, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         30,-2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         20, 2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         40, 2000, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         60, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         50,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 2 out edge to edge */
static Vtx trivtx12b[12] =  {
        {        160,   70, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,   80, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,   80, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        160,  100, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,   90, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,   90, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {         70,  120, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         80, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         80,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        100,  120, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {         90, 2000, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {         90,-2000, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* 2 out edge to edge */
static Vtx trivtx12c[6] =  {
        {        160,  150, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,  160, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,  170, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {        160,  180, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {       2000,  200, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      -2000,  190, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

Gfx triangle12[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx12a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx12b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx12c, 6, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),

    gsSPEndDisplayList(),
};
/* end of case 12 */

/*
 * Test 13, Frame 13:
 *
 *
 * wed Oct 19 1994
 * Scissoring - uses data from test 10
 *
 * The same triangles as in test 10 but with a scissor box
 * which removes about 10 pixels from around the edge of the screen
 *
 */
Gfx triangle13[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetRenderMode(0x0C084148,0),

    gsDPSetScissor(G_SC_NON_INTERLACE, 10,10,310,230),

    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPEndDisplayList(),
};
/* end of case 13 */

/*
 * Test 14, Frame 14:
 *
 *
 * wed Oct 19 1994
 * 640x480 screensize (uses data from test 10)
 *
 * Draws the triangles from test 10 but on a bigger screen.
 * to use this test with the RDP CSIM use the options:
 *    -W 640 -H 480
 *
 */
Gfx triangle14[MAX_STATIC_GFX_SIZE] = {
    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPEndDisplayList(),
};

Gfx hires_image_test[] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(0x0C084148,0),
    gsDPSetCycleType(G_CYC_FILL),
    /*
    gsDPSetColorImage(5, G_IM_SIZ_16b, 640, cfb_16_a),
    */
    gsDPPipeSync(),
    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 640, cfb_16_a),
    gsDPSetCycleType(G_CYC_1CYCLE),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,640,480),
    gsSPDisplayList(triangle14),

#ifdef OTHER_SCISSORS
    /*
     * use scissoring to lower number of clocks to complete sim
     */
    gsDPSetScissor(G_SC_NON_INTERLACE, 635,0,640,480),
    gsSPDisplayList(triangle14),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,480,5),
    gsSPDisplayList(triangle14),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,475,1023,480),
    gsSPDisplayList(triangle14),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,5,480),
    gsSPDisplayList(triangle14),

    gsDPSetScissor(G_SC_NON_INTERLACE, 315,0,320,480),
    gsSPDisplayList(triangle14),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,233,640,240),
    gsSPDisplayList(triangle14),
#endif
    gsSPEndDisplayList(),
};
/* end of case 14 */

/*
 * Test 15, Frame 15:
 *
 *
 * wed Oct 19 1994
 * 1024x1024 screensize (uses data from test 10)
 *
 * Draws the triangles from test 10 but on a bigger screen.
 * to use this test with the RDP CSIM use the options:
 *    -W 1024 -H 1024
 *
 */
Gfx triangle15[MAX_STATIC_GFX_SIZE] = {
    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPEndDisplayList(),
};

Gfx big_image_test[] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(0x0C084148,0),
    gsDPSetCycleType(G_CYC_FILL),
    gsDPSetColorImage(5, G_IM_SIZ_16b, 1024, cfb_16_a),
    gsDPPipeSync(),
    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1024, cfb_16_a),
    gsDPSetCycleType(G_CYC_1CYCLE),
    /*
     * use scissoring to lower number of clocks to complete sim
     */
    gsDPSetScissor(G_SC_NON_INTERLACE, 1018,0,1023,1023),
    gsSPDisplayList(triangle15),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,1023,5),
    gsSPDisplayList(triangle15),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,1018,1023,1023),
    gsSPDisplayList(triangle15),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,5,1023),
    gsSPDisplayList(triangle15),

    gsDPSetScissor(G_SC_NON_INTERLACE, 512,0,517,1023),
    gsSPDisplayList(triangle15),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,513,1023,518),
    gsSPDisplayList(triangle15),

    gsSPEndDisplayList(),
};


/* end of case 15 */

/*
 * Test 16, Frame 16:
 *
 *
 * wed Oct 19 1994
 *
 * Draw 8 identical triangles with the scissor box scissoring each
 * at a different subpixel location.
 *
 */

/* up facing triangles */
static Vtx trivtx16a[15] =  {
        {      10,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      15,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      20,   15, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      25,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      30,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      35,   15, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      40,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      45,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      50,   15, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      55,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      60,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      65,   15, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      70,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      75,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      80,   15, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* down facing triangles */
static Vtx trivtx16b[15] =  {
        {      10,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      15,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      20,   20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      25,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      30,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      35,   20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      40,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      45,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      50,   20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      55,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      60,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      65,   20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {      70,   20, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      75,   25, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      80,   20, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* right facing triangles */
static Vtx trivtx16c[15] =  {
        {      90,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {      90,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     100,   13, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     110,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     110,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     120,   13, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     130,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     130,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     140,   13, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     150,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     150,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     160,   13, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     170,   15, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     170,   10, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     180,   13, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

/* right facing triangles */
static Vtx trivtx16d[15] =  {
        {     100,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     100,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {      90,   23, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     120,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     120,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     110,   23, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     140,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     140,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     130,   23, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     160,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     160,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     150,   23, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
        {     180,   25, 0, 0, 0, 0, 0xff, 0x00, 0x00, 0xff	},
        {     180,   20, 0, 0, 0, 0, 0x00, 0xff, 0x00, 0xff	},
        {     170,   23, 0, 0, 0, 0, 0x00, 0x00, 0xff, 0xff	},
};

Gfx triangle16[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetRenderMode(0x0C084148,0),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,320,240),

    gsSPVertex(&trivtx16a, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,11.00,320,14.75),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,11.25,320,14.50),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,11.50,320,14.25),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,11.75,320,14.00),
    gsSP1Triangle(12,13,14, 0),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,320,240),

    gsSPVertex(&trivtx16b, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,21.00,320,24.75),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,21.25,320,24.50),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,21.50,320,24.25),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,21.75,320,24.00),
    gsSP1Triangle(12,13,14, 0),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,320,240),

    gsSPVertex(&trivtx16c, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 111.00,0,119.75,240),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 131.25,0,139.50,240),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 151.50,0,159.25,240),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 171.75,0,179.00,240),
    gsSP1Triangle(12,13,14, 0),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,320,240),

    gsSPVertex(&trivtx16d, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 111.00,0,119.75,240),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 131.25,0,139.50,240),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 151.50,0,159.25,240),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetScissor(G_SC_NON_INTERLACE, 171.75,0,179.00,240),
    gsSP1Triangle(12,13,14, 0),

    gsSPEndDisplayList(),
};
/* end of case 16 */

/*
 * Test 17, Frame 17:
 *
 *
 * wed Oct 19 1994
 *
 * The intention of this case is to test interlace mode.
 * Right now the .rdp file must be modified to turn
 * interlacing on.  (How to turn interlacing on from
 * the gsDPSetScissor macro???)
 *
 */
Gfx triangle17[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetRenderMode(0x0C084148,0),

    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,320,240),

    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPEndDisplayList(),
};
/* end of case 17 */

/*
 * Test 18, Frame 18:
 *
 *
 * wed Oct 19 1994
 * with pixel size=16:
 * different cycle types.  Uses data from test 16
 *
 * try different cycle types with 16 bit pixels on 8 triangles.
 *
 */
Gfx triangle18[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, cfb_16_a),
    gsDPSetFillColor(GPACK_RGBA5551(0,0,0,1) << 16 | GPACK_RGBA5551(0,0,0,1)),
    gsDPPipeSync(),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx16a, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetCycleType(0),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetCycleType(1),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetCycleType(2),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetCycleType(3),
    gsSP1Triangle(12,13,14, 0),

    gsSPEndDisplayList(),
};
/* end of case 18 */

/*
 * Test 19, Frame 19:
 *
 *
 * wed Oct 19 1994
 * with pixel size=32:
 * different cycle types.  Uses data from test 16
 *
 * try different cycle types with 32 bit pixels on 8 triangles.
 *
 */
Gfx triangle19[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_32b, 320, cfb_16_a),
    gsDPSetFillColor(0xffffffff),
    gsDPPipeSync(),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx16a, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetCycleType(0),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetCycleType(1),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetCycleType(2),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetCycleType(3),
    gsSP1Triangle(12,13,14, 0),

    gsSPEndDisplayList(),
};
/* end of case 19 */

/*
 * Test 20, Frame 20:
 *
 *
 * wed Oct 19 1994
 * with pixel size=8:
 * different cycle types.  Uses data from test 16
 *
 * try different cycle types with 8 bit pixels on 8 triangles.
 *
 */
Gfx triangle20[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_8b, 320, cfb_16_a),
    gsDPSetFillColor(0xffffffff),
    gsDPPipeSync(),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx16a, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetCycleType(0),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetCycleType(1),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetCycleType(2),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetCycleType(3),
    gsSP1Triangle(12,13,14, 0),

    gsSPEndDisplayList(),
};
/* end of case 20 */

/*
 * Test 21, Frame 21:
 *
 *
 * wed Oct 19 1994
 * with pixel size=4:
 * different cycle types.  Uses data from test 16
 *
 * try different cycle types with 4 bit pixels on 8 triangles.
 *
 */
Gfx triangle21[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_4b, 320, cfb_16_a),
    gsDPSetFillColor(0xffffffff),
    gsDPPipeSync(),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx16a, 15, 0),
    gsSP1Triangle( 0, 1, 2, 0),
    gsDPSetCycleType(0),
    gsSP1Triangle( 3, 4, 5, 0),
    gsDPSetCycleType(1),
    gsSP1Triangle( 6, 7, 8, 0),
    gsDPSetCycleType(2),
    gsSP1Triangle( 9,10,11, 0),
    gsDPSetCycleType(3),
    gsSP1Triangle(12,13,14, 0),

    gsSPEndDisplayList(),
};
/* end of case 21 */

/*
 * Test 22, Frame 22:
 *
 *
 * Used for odd interlacing test
 *
 */
Gfx triangle22[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),


/*
    gsDPPipeSync(),
    gsDPSetCycleType(G_CYC_FILL),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, cfb_16_a),
    gsDPPipeSync(),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, cfb_16_a),
    gsDPSetCycleType(G_CYC_1CYCLE),
*/


    gsDPSetScissor(G_SC_ODD_INTERLACE, 0,0,320,240),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPEndDisplayList(),
};
/* end of case 22 */

/*
 * Test 23, Frame 23:
 *
 *
 * Used for even interlacing test
 *
 */
Gfx triangle23[MAX_STATIC_GFX_SIZE] = {
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),


    gsDPPipeSync(),
    gsDPSetCycleType(G_CYC_FILL),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, cfb_16_a),
    gsDPPipeSync(),

    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, cfb_16_a),
    gsDPSetCycleType(G_CYC_1CYCLE),


    gsDPSetScissor(G_SC_EVEN_INTERLACE, 0,0,320,240),

    gsDPSetRenderMode(0x0C084148,0),

    gsSPVertex(&trivtx10j, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10k, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10l, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10i, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10a, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10b, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10c, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPVertex(&trivtx10d, 12, 0),
    gsSP1Triangle(0, 1, 2, 0),
    gsSP1Triangle(3, 4, 5, 0),
    gsSP1Triangle(6, 7, 8, 0),
    gsSP1Triangle(9,10,11, 0),

    gsSPEndDisplayList(),
};
/* end of case 23 */

/*
 * Test 24, Frame 24:
 *
 *
 * not used yet
 *
 */
Gfx triangle24[MAX_STATIC_GFX_SIZE] = {
    gsSPEndDisplayList(),
};
/* end of case 24 */

/*
 * Test 25, Frame 25:
 *
 *
 * not used yet
 *
 */
Gfx triangle25[MAX_STATIC_GFX_SIZE] = {
    gsSPEndDisplayList(),
};
/* end of case 25 */

/*
 * Test 30, Frame 30:
 *
 * A 2K poly skull centered.
 * Fri Nov 25 11:19:06 PST 1994
 *
 */
#include "skull_vtx.h"

Gfx skull_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),

#include "skull_tri.h"

    gsSPEndDisplayList(),
};
/* end of case 30 */

/*
 * Test 31, Frame 31:
 *
 * A 1K poly VW centered.
 * Fri Nov 25 11:19:25 PST 1994
 *
 */
#if 1
#include "vw_vtx.h"
#endif

Gfx vw_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPClearGeometryMode(G_CULL_BACK),
    gsSPClearGeometryMode(G_CULL_FRONT),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),

#if 1
#include "vw_tri.h"
#endif

    gsSPEndDisplayList(),
};
/* end of case 31 */

/*
 * Test 32, Frame 32:
 *
 * A 3K poly cow centered.
 * Fri Nov 25 11:46:29 PST 1994
 *
 */
#if 1
#include "cow_vtx.h"
#endif

Gfx cow_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),

#if 1
#include "cow_tri.h"
#endif

    gsSPEndDisplayList(),
};
/* end of case 32 */

/* Test 33 uses the above data... */

/*
 * Test 34, Frame 34:
 *
 * A 500 polygon paperclip. Tests thin polygons.
 * Sat Nov 26 14:43:20 PST 1994
 *
 */
#include "clip_vtx.h"

Gfx clip_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),

#include "clip_tri.h"

    gsSPEndDisplayList(),
};
/* end of case 34 */

/*
 * Test 35, Frame 35:
 *
 * A 3K polygon rocking chair.
 * Mon Nov 28 14:46:01 PST 1994
 *
 */
#include "chair_vtx.h"

Gfx chair_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),

#include "chair_tri.h"

    gsSPEndDisplayList(),
};

#define FLOOR_R	205
#define FLOOR_G	183
#define FLOOR_B	158
#define FLOOR_Y	0
static Vtx chair_floor_vtx[5] =  {
        {   -300, FLOOR_Y,  300, 0, 0, 0, FLOOR_R, FLOOR_G, FLOOR_B, 0xff },
        {    300, FLOOR_Y,  300, 0, 0, 0, FLOOR_R, FLOOR_G, FLOOR_B, 0xff },
        {    300, FLOOR_Y, -300, 0, 0, 0, FLOOR_R, FLOOR_G, FLOOR_B, 0xff },
        {   -300, FLOOR_Y, -300, 0, 0, 0, FLOOR_R, FLOOR_G, FLOOR_B, 0xff },
        {      0, FLOOR_Y,    0, 0, 0, 0, FLOOR_R, FLOOR_G, FLOOR_B, 0xff },
};

Gfx chair_floor_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),
    gsSPVertex(&chair_floor_vtx, 5, 0),
    gsSP1Triangle(0, 1, 4, 0),
    gsSP1Triangle(1, 2, 4, 0),
    gsSP1Triangle(2, 3, 4, 0),
    gsSP1Triangle(3, 0, 4, 0),
    gsSPEndDisplayList(),
};

/* end of case 35 */

/*
 * Test 36, Frame 36:
 *
 * A 4K B-25
 * Wed Nov 30 17:31:04 PST 1994
 *
 */
#if 0
#include "b25_vtx.h"
#endif

Gfx b25_dl[] = {
    gsDPPipeSync(),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsDPSetCombineMode (G_CC_SHADE, G_CC_SHADE),
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),

#if 0
#include "b25_tri.h"
#endif

    gsSPEndDisplayList(),
};
/* end of case 36 */


/*
 * Test 40 Frame 40
 *
 * Try toggling as many nodes internal to the RDP as possible
 * using RDP commands.
 *
 *
 *
 */

#include "IA16Noise.h"
#include "Qsim_prims.h"

#define G_QSIM_BLEND	AA_EN | IM_RD | CVG_DST_CLAMP | CVG_X_ALPHA |           \
			ALPHA_CVG_SEL | FORCE_BL | ZMODE_OPA |                  \
			GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_IN, G_BL_1MA)

#define G_QSIM_BLEND2	AA_EN | IM_RD | CVG_DST_CLAMP | CVG_X_ALPHA |           \
			ALPHA_CVG_SEL | FORCE_BL | ZMODE_OPA |                  \
			GBL_c2(G_BL_CLR_IN, G_BL_A_SHADE, G_BL_CLR_IN, G_BL_1MA)

/* vertices for different types of triangles */
static Vtx test_qsim_v0[] =  {
        {   0, 0,  0, 0, 0x0000, 0xaa00, 0xaa, 0x55, 0xcc, 0x00 },
        {   2, 3,  4, 0, 0xaa00, 0x0000, 0x55, 0xaa, 0x33, 0xff },
        {   4, 2,  3, 0, 0x00aa, 0x00aa, 0x00, 0x00, 0x00, 0xaa },
};

static Vtx test_qsim_v1[] =  {
        {    900,  900,  1000, 0, 0x1111, 0xffff, 0x55, 0x66, 0xff, 0xff },
        {    902,  903,  1004, 0, 0x0000, 0x2302, 0x22, 0x99, 0xcc, 0x18 },
        {    904,  902,  1003, 0, 0xffff, 0x11aa, 0x44, 0x11, 0x12, 0x44 },
};

static Vtx test_qsim_v2[] =  {
        {    900, 0,  0, 0, 0xdead, 0xdada, 0xff, 0xff, 0xff, 0xff },
        {    902, 3,  4, 0, 0xbeef, 0xfeed, 0x55, 0xaa, 0x33, 0x55 },
        {    904, 2,  3, 0, 0xbaba, 0xeeaa, 0x00, 0x00, 0x00, 0xaa },
};

static Vtx test_qsim_v3[] =  {
        {   0,  900,  0, 0, 0xcaca, 0xaa00, 0xaa, 0x55, 0xcc, 0x00 },
        {   2,  903,  4, 0, 0xeaac, 0x0000, 0x55, 0xaa, 0x33, 0xff },
        {   4,  902,  3, 0, 0x00aa, 0x00aa, 0x00, 0x00, 0x00, 0xaa },
};

static Vtx test_qsim_v4[] =  {
        {   0, 0,   900, 0, 0x0000, 0xaa00, 0xaa, 0x55, 0xcc, 0x00 },
        {   2, 3,   904, 0, 0xaa00, 0x0000, 0x55, 0xaa, 0x33, 0xff },
        {   4, 2,   903, 0, 0x00aa, 0x00aa, 0x00, 0x00, 0x00, 0xaa },
};

static Vtx test_qsim_v5[] =  {
        {    900, 0,   900, 0, 0x0000, 0xaa00, 0xaa, 0x55, 0xcc, 0x00 },
        {    902, 3,   904, 0, 0xaa00, 0x0000, 0x55, 0xaa, 0x33, 0xff },
        {    904, 2,   903, 0, 0x00aa, 0x00aa, 0x00, 0x00, 0x00, 0xaa },
};

static Vtx test_qsim_v6[] =  {
        {   0,  900,   900, 0, 0x0000, 0xaa00, 0xaa, 0x55, 0xcc, 0x00 },
        {   2,  903,   904, 0, 0xaa00, 0x0000, 0x55, 0xaa, 0x33, 0xff },
        {   4,  902,   903, 0, 0x00aa, 0x00aa, 0x00, 0x00, 0x00, 0xaa },
};

static Vtx test_qsim_v7[] =  {
        {    900, 0,  0, 0, 0x0000, 0xaa00, 0xaa, 0x55, 0xcc, 0x00 },
        {    902, 3,  4, 0, 0xaa00, 0x0000, 0x55, 0xaa, 0x33, 0xff },
        {    904, 2,  3, 0, 0x00aa, 0x00aa, 0x00, 0x00, 0x00, 0xaa },
};


/*
 *  Qsim display list, designed to toggle as many internal nodes in the
 *  RDP as possible.
 */

Gfx qsim_test[] = {
    /* fill 1024x1024 screen */
    gsDPPipeSync(),
    gsSPClearGeometryMode(G_CULL_BACK),
    gsDPSetCycleType(G_CYC_FILL),
    gsDPSetColorImage(5, G_IM_SIZ_32b, 1024, cfb_16_a),
    gsDPPipeSync(),

    /* use maximum screen size for coordinate range */
    /* gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1024, cfb_16_a), */
    gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_32b, 1024, cfb_16_a),
    gsDPSetScissor(G_SC_NON_INTERLACE, 0,0,1023,1023),

    /* set rendering modes */
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
    gsDPSetTextureLOD(G_TL_TILE),
    gsDPSetColorDither(G_CD_ENABLE),
    gsDPSetCombineKey(G_CK_KEY),
    gsDPSetTextureFilter(G_TF_BILERP),
    gsDPSetTextureConvert(G_TC_FILTCONV),
    gsDPSetCombineLERP (TEXEL0, TEXEL1, LOD_FRACTION, TEXEL0,
			TEXEL0, TEXEL1, LOD_FRACTION, TEXEL0,
			NOISE, COMBINED, SHADE_ALPHA, SHADE,
			1, COMBINED, SHADE, COMBINED),

    gsDPSetPrimColor(150, 205, 255, 0, 255, 228),
    gsDPSetFogColor(39, 171, 255, 180),
    gsDPSetEnvColor(255, 14, 52, 156),
    gsDPSetKeyR(134, 87, 211),
    gsDPSetKeyGB(54, 21, 148, 237, 214, 90),
    gsDPSetConvert(45, 114, 250, 77, 66, 69),

    gsDPPipeSync(),
    gsDPSetRenderMode(G_QSIM_BLEND, G_QSIM_BLEND2),
    gsDPSetTile(3, 2, 16, 0, 1, 0, 0, 5, 0, 0, 6, 0),

    /* Load Noise texture, 32x64 IA */
    gsDPLoadTextureBlock(IA16Noise, G_IM_FMT_IA, G_IM_SIZ_16b, 32, 64, 0,
                         G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR,
                         5, 6, G_TX_NOLOD, G_TX_NOLOD),

    /*
     *  do a triangle to get steppers going, they will continue to
     *  step until next primitive.  Use this fact to check attribute
     *  muxes.
     */
#ifdef ALLOW_RDPBLOCK
    gsSPRDPBlock(&qsim_p0, sizeof(qsim_p0)),
#endif

    /* set registered values */
    gsDPPipeSync(),
    gsDPSetPrimColor(0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55),
    gsDPSetBlendColor(0x55, 0xaa, 0x55, 0xaa),
    gsDPSetFogColor(0xcc, 0x33, 0xcc, 0x33),
    gsDPSetFillColor(0xa5a5a5a5),
    gsDPSetEnvColor(0x55, 0xaa, 0x55, 0xaa),
    gsDPSetKeyR(0x33, 0xcc, 0x333),
    gsDPSetKeyGB(0xaa, 0x55, 0xaaa, 0x55, 0xaa, 0x555),
    gsDPSetConvert(0x155, 0x1aa, 0x155, 0x1aa, 0x155, 0x1aa),

    /* roll through each mux select one time, invert pattern in combiner */
    /* a/b mux */
    gsDPSetCombineLERP(	COMBINED,	0,		1,		0,
			COMBINED,	0,		LOD_FRACTION,	0,
			1,		COMBINED,	1,		0,
			1,		COMBINED,	PRIM_LOD_FRAC,	0),
    gsDPSetCombineLERP(	TEXEL0,		0,		1,		0,
			TEXEL0,         0,              LOD_FRACTION,   0,
			1,		TEXEL0,		1,		0,
			1,              TEXEL0,         PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	TEXEL1,		0,		1,		0,
			TEXEL1,         0,              LOD_FRACTION,   0,
			1,		TEXEL1,		1,		0,
			1,              TEXEL1,         PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	PRIMITIVE,	0,		1,		0,
			PRIMITIVE,      0,              LOD_FRACTION,   0,
			1,		PRIMITIVE,	1,		0,
			1,              PRIMITIVE,      PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	SHADE,		0,		1,		0,
			SHADE,          0,              LOD_FRACTION,   0,
			1,		SHADE,		1,		0,
			1,              SHADE,          PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	ENVIRONMENT,	0,		1,		0,
			ENVIRONMENT,    0,              LOD_FRACTION,   0,
			1,		ENVIRONMENT,	1,		0,
			1,              ENVIRONMENT,    PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	1,		0,		1,		0,
			1,          	0,              LOD_FRACTION,   0,
			1,		CENTER,		1,		0,
			1,		0,		PRIM_LOD_FRAC,	0),
    gsDPSetCombineLERP(	NOISE,		0,		1,		0,
			1,		0,		LOD_FRACTION,	0,
			1,		K4,		1,		0,
			1,              0,              PRIM_LOD_FRAC,  1),
    gsDPSetCombineLERP(	1,           	0, 		1,		0,
			1,              0,              LOD_FRACTION,	0,
			1,		0,		1,		0,
			1,              0,              PRIM_LOD_FRAC,	0),

    /* c rgb mux, c & d alpha mux */
    gsDPSetCombineLERP(	1, 		0, 		COMBINED,        0,
			1,		0,		COMBINED,	 0,
			NOISE, 		0,		COMBINED,        0,
			1,		0,		TEXEL0,	 	 0),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL0,          0,
			1,		0,              LOD_FRACTION,    0,
			NOISE, 		0,		TEXEL0,          0,
			1,              0,         	PRIMITIVE,   	 0),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL1,          0,
			1,         	0,              SHADE,    	 0,
			NOISE,		0,		TEXEL1,          0,
			1,              0,         	ENVIRONMENT,   	 0),
    gsDPSetCombineLERP(	1, 		0, 		PRIMITIVE,       0,
			1,      	0,              LOD_FRACTION,    0,
			NOISE,		0,		PRIMITIVE,       0,
			1,              0,      	PRIM_LOD_FRAC,   0),
    gsDPSetCombineLERP(	1, 		0, 		SHADE,           0,
			1,          	0,              0,    		 0,
			NOISE, 		0,		SHADE,           0,
			1,              0,          	0,   		 COMBINED),
    gsDPSetCombineLERP(	1, 		0, 		ENVIRONMENT,     0,
			ENVIRONMENT,    0,              0,    		 0,
			NOISE,		0,		ENVIRONMENT,     0,
			1,              ENVIRONMENT,    0,   		 TEXEL0),
    gsDPSetCombineLERP(	1, 		0, 		SCALE,           0,
			1,          	0,              0,    		 0,
			NOISE, 		0,		SCALE,           0,
			1,		0,		0,	 	 TEXEL1),
    gsDPSetCombineLERP(	1, 		0, 		COMBINED_ALPHA,  0,
			1,		0,		0,	 	 0,
			NOISE,		0,		COMBINED_ALPHA,  0,
			1,              0,              0,   		 PRIMITIVE),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL0_ALPHA,    0,
			1,		0,		0,	 	 0,
			NOISE,		0,		TEXEL0_ALPHA,    0,
			1,		COMBINED,	0,	 	 SHADE),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL1_ALPHA,	 0,
			TEXEL0,         0,              0,    		 0,
			NOISE,		0,		TEXEL1_ALPHA,    0,
			1,              TEXEL0,         0,   		 ENVIRONMENT),
    gsDPSetCombineLERP(	1, 		0, 		PRIMITIVE_ALPHA, 0,
			TEXEL1,         0,              0,    		 0,
			NOISE,		0,		PRIMITIVE_ALPHA, 0,
			1,              TEXEL1,         0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		SHADE_ALPHA,     0,
			PRIMITIVE,      0,              0,    		 1,
			NOISE,		0,		SHADE_ALPHA,     0,
			1,              PRIMITIVE,      0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		ENV_ALPHA,       0,
			SHADE,          0,              0,    		 1,
			NOISE,		0,		ENV_ALPHA,       0,
			1,              SHADE,          0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		LOD_FRACTION,    0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE,		0,		LOD_FRACTION,    0,
			1,              ENVIRONMENT,    0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		PRIM_LOD_FRAC,   0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE,		0,		PRIM_LOD_FRAC,   0,
			1,              ENVIRONMENT,    0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		K5,              0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE,		0, 		K5,              0,
			1,              ENVIRONMENT,    0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		0,               0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE, 		0,		0,		 0,
			1,              ENVIRONMENT,    0,   		 1),

    /* d mux */
    gsDPSetCombineLERP(	0,		0,		1,		COMBINED,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		COMBINED,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		TEXEL0,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		TEXEL0,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		TEXEL1,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		TEXEL1,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		PRIMITIVE,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		PRIMITIVE,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		SHADE,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		SHADE,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		ENVIRONMENT,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		ENVIRONMENT,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		CENTER,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		CENTER,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		K4,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		K4,
			1,              TEXEL0,    	0,   		TEXEL0),

    /*
     *  do another primitive.  Needed to advance counters for primitive
     *  color buffer.  Set render mode for maximum randomness. Invert
     *  pattern loaded into attribute registers.
     */
    gsDPPipeSync(),
    gsDPSetPrimColor(150, 205, 255, 0, 255, 228),
    gsDPSetFogColor(39, 171, 255, 180),
    gsDPSetEnvColor(255, 14, 52, 156),
    gsDPSetKeyR(134, 87, 211),
    gsDPSetKeyGB(54, 21, 148, 237, 214, 90),
    gsDPSetConvert(45, 114, 250, 77, 66, 69),

    gsDPSetRenderMode(G_QSIM_BLEND, G_QSIM_BLEND2),
    gsDPSetTile(3, 2, 16, 0, 1, 0, 0, 5, 0, 0, 6, 0),

    /* make noise get replicated on lsb's and bias around 0.5
       this ensures a better spread of random  values */
    gsDPSetPrimColor(0x80, 0x80, 0x80, 0x80, 0x80, 0x49),
    gsDPSetConvert(0x0aa, 0x055, 0x0aa, 0x055, 0x0aa, 0x049),

    gsDPSetCombineLERP(	NOISE,		0,		K5,		PRIMITIVE,
			1,		0,		PRIMITIVE,	TEXEL0,
			1,		COMBINED,	SHADE,		0,
			1,		COMBINED,	PRIM_LOD_FRAC,	0 ),

#ifdef ALLOW_RDPBLOCK
    gsSPRDPBlock(&qsim_p1, sizeof(qsim_p1)),
#endif

    gsDPPipeSync(),
    gsDPSetPrimColor(0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa),
    gsDPSetBlendColor(0xaa, 0x55, 0xaa, 0x55),
    gsDPSetFogColor(0x33, 0xcc, 0x33, 0xcc),
    gsDPSetFillColor(0x5a5a5a5a),
    gsDPSetEnvColor(0xaa, 0x55, 0xaa, 0x55),
    gsDPSetKeyR(0xcc, 0x33, 0xccc),
    gsDPSetKeyGB(0x55, 0xaa, 0x555, 0xaa, 0x55, 0xaaa),
    gsDPSetConvert(0x0aa, 0x055, 0x0aa, 0x055, 0x0aa, 0x055),

    /* make noise get replicated on lsb's and bias around 0.5
       this ensures a better spread of random  values */
    gsDPSetPrimColor(0x80, 0x80, 0x80, 0x80, 0x80, 0x49),
    gsDPSetConvert(0x0aa, 0x055, 0x0aa, 0x055, 0x0aa, 0x049),

    gsDPSetCombineLERP(	NOISE,		0,		K5,		PRIMITIVE,
			1,		0,		PRIMITIVE,	TEXEL0,
			1,		COMBINED,	SHADE,		0,
			1,		COMBINED,	PRIM_LOD_FRAC,	0 ),

    /* make edge walker/steppers go through large range of numbers */
#ifdef ALLOW_RDPBLOCK
    gsSPRDPBlock(&qsim_p2, sizeof(qsim_p2)),
#endif

    /* roll through each mux select one time, invert pattern in combiner */
    /* a/b mux */
    gsDPSetCombineLERP(	COMBINED,	0,		1,		0,
			COMBINED,	0,		LOD_FRACTION,	0,
			1,		COMBINED,	1,		0,
			1,		COMBINED,	PRIM_LOD_FRAC,	0),
    gsDPSetCombineLERP(	TEXEL0,		0,		1,		0,
			TEXEL0,         0,              LOD_FRACTION,   0,
			1,		TEXEL0,		1,		0,
			1,              TEXEL0,         PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	TEXEL1,		0,		1,		0,
			TEXEL1,         0,              LOD_FRACTION,   0,
			1,		TEXEL1,		1,		0,
			1,              TEXEL1,         PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	PRIMITIVE,	0,		1,		0,
			PRIMITIVE,      0,              LOD_FRACTION,   0,
			1,		PRIMITIVE,	1,		0,
			1,              PRIMITIVE,      PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	SHADE,		0,		1,		0,
			SHADE,          0,              LOD_FRACTION,   0,
			1,		SHADE,		1,		0,
			1,              SHADE,          PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	ENVIRONMENT,	0,		1,		0,
			ENVIRONMENT,    0,              LOD_FRACTION,   0,
			1,		ENVIRONMENT,	1,		0,
			1,              ENVIRONMENT,    PRIM_LOD_FRAC,  0),
    gsDPSetCombineLERP(	1,		0,		1,		0,
			1,          	0,              LOD_FRACTION,   0,
			1,		CENTER,		1,		0,
			1,		0,		PRIM_LOD_FRAC,	0),
    gsDPSetCombineLERP(	NOISE,		0,		1,		0,
			1,		0,		LOD_FRACTION,	0,
			1,		K4,		1,		0,
			1,              0,              PRIM_LOD_FRAC,  1),
    gsDPSetCombineLERP(	1,           	0, 		1,		0,
			1,              0,              LOD_FRACTION,	0,
			1,		0,		1,		0,
			1,              0,              PRIM_LOD_FRAC,	0),

    /* c rgb mux, c & d alpha mux */
    gsDPSetCombineLERP(	1, 		0, 		COMBINED,        0,
			1,		0,		COMBINED,	 0,
			NOISE, 		0,		COMBINED,        0,
			1,		0,		TEXEL0,	 	 0),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL0,          0,
			1,		0,              LOD_FRACTION,    0,
			NOISE, 		0,		TEXEL0,          0,
			1,              0,         	PRIMITIVE,   	 0),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL1,          0,
			1,         	0,              SHADE,    	 0,
			NOISE,		0,		TEXEL1,          0,
			1,              0,         	ENVIRONMENT,   	 0),
    gsDPSetCombineLERP(	1, 		0, 		PRIMITIVE,       0,
			1,      	0,              LOD_FRACTION,    0,
			NOISE,		0,		PRIMITIVE,       0,
			1,              0,      	PRIM_LOD_FRAC,   0),
    gsDPSetCombineLERP(	1, 		0, 		SHADE,           0,
			1,          	0,              0,    		 0,
			NOISE, 		0,		SHADE,           0,
			1,              0,          	0,   		 COMBINED),
    gsDPSetCombineLERP(	1, 		0, 		ENVIRONMENT,     0,
			ENVIRONMENT,    0,              0,    		 0,
			NOISE,		0,		ENVIRONMENT,     0,
			1,              ENVIRONMENT,    0,   		 TEXEL0),
    gsDPSetCombineLERP(	1, 		0, 		SCALE,           0,
			1,          	0,              0,    		 0,
			NOISE, 		0,		SCALE,           0,
			1,		0,		0,	 	 TEXEL1),
    gsDPSetCombineLERP(	1, 		0, 		COMBINED_ALPHA,  0,
			1,		0,		0,	 	 0,
			NOISE,		0,		COMBINED_ALPHA,  0,
			1,              0,              0,   		 PRIMITIVE),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL0_ALPHA,    0,
			1,		0,		0,	 	 0,
			NOISE,		0,		TEXEL0_ALPHA,    0,
			1,		COMBINED,	0,	 	 SHADE),
    gsDPSetCombineLERP(	1, 		0, 		TEXEL1_ALPHA,	 0,
			TEXEL0,         0,              0,    		 0,
			NOISE,		0,		TEXEL1_ALPHA,    0,
			1,              TEXEL0,         0,   		 ENVIRONMENT),
    gsDPSetCombineLERP(	1, 		0, 		PRIMITIVE_ALPHA, 0,
			TEXEL1,         0,              0,    		 0,
			NOISE,		0,		PRIMITIVE_ALPHA, 0,
			1,              TEXEL1,         0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		SHADE_ALPHA,     0,
			PRIMITIVE,      0,              0,    		 1,
			NOISE,		0,		SHADE_ALPHA,     0,
			1,              PRIMITIVE,      0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		ENV_ALPHA,       0,
			SHADE,          0,              0,    		 1,
			NOISE,		0,		ENV_ALPHA,       0,
			1,              SHADE,          0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		LOD_FRACTION,    0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE,		0,		LOD_FRACTION,    0,
			1,              ENVIRONMENT,    0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		PRIM_LOD_FRAC,   0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE,		0,		PRIM_LOD_FRAC,   0,
			1,              ENVIRONMENT,    0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		K5,              0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE,		0, 		K5,              0,
			1,              ENVIRONMENT,    0,   		 1),
    gsDPSetCombineLERP(	1, 		0, 		0,               0,
			ENVIRONMENT,    0,              0,    		 1,
			NOISE, 		0,		0,		 0,
			1,              ENVIRONMENT,    0,   		 1),

    /* d mux */
    gsDPSetCombineLERP(	0,		0,		1,		COMBINED,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		COMBINED,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		TEXEL0,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		TEXEL0,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		TEXEL1,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		TEXEL1,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		PRIMITIVE,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		PRIMITIVE,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		SHADE,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		SHADE,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		ENVIRONMENT,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		ENVIRONMENT,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		CENTER,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		CENTER,
			1,              TEXEL0,    	0,   		TEXEL0),
    gsDPSetCombineLERP(	0,		0,		1,		K4,
			1,              SHADE,          0,   		SHADE,
			1, 		0, 		0, 		K4,
			1,              TEXEL0,    	0,   		TEXEL0),

    gsDPPipeSync(),


    /* do small prims, one of each type to test decoders */
    gsSPSetGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
    gsSPVertex(&test_qsim_v0, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPClearGeometryMode(G_SHADE),
    gsSPVertex(&test_qsim_v1, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPSetGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_OFF),
    gsSPVertex(&test_qsim_v2, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPClearGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_OFF),
    gsSPVertex(&test_qsim_v3, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPClearGeometryMode(G_ZBUFFER),
    gsSPSetGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
    gsSPVertex(&test_qsim_v4, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPClearGeometryMode(G_SHADE),
    gsSPVertex(&test_qsim_v5, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPSetGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_OFF),
    gsSPVertex(&test_qsim_v6, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),

    gsDPPipeSync(),
    gsSPClearGeometryMode(G_SHADE),
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_OFF),
    gsSPVertex(&test_qsim_v7, 3, 0),
    gsSP1Triangle(0, 1, 2, 0),


    /* do many small prims at random locations */


    gsSPEndDisplayList(),
};
/* end of case 40 */

/*
 * ADD TEST CASE:
 * Put data and display list for the new case above here:
 *
 * The Gfx display list must be extern'd in rdpverif.h, then
 * added to the 'testList' table in rdpverif.c
 *
 */