[mupen64plus-pandora.git] / source / gles2n64 / src / F3D.cpp

#include "gles2N64.h"
#include "Debug.h"
#include "F3D.h"
#include "N64.h"
#include "RSP.h"
#include "RDP.h"
#include "gSP.h"
#include "gDP.h"
#include "GBI.h"
#include "OpenGL.h"
#include "DepthBuffer.h"

#include "Config.h"

void F3D_SPNoOp( u32 w0, u32 w1 )
{
    gSPNoOp();
}

void F3D_Mtx( u32 w0, u32 w1 )
{
    if (_SHIFTR( w0, 0, 16 ) != 64)
    {
//      GBI_DetectUCode(); // Something's wrong
#ifdef DEBUG
    DebugMsg( DEBUG_MEDIUM | DEBUG_HIGH | DEBUG_ERROR, "G_MTX: address = 0x%08X    length = %i    params = 0x%02X\n", w1, _SHIFTR( w0, 0, 16 ), _SHIFTR( w0, 16, 8 ) );
#endif
        return;
    }

    gSPMatrix( w1, _SHIFTR( w0, 16, 8 ) );
}

void F3D_Reserved0( u32 w0, u32 w1 )
{
#ifdef DEBUG
    DebugMsg( DEBUG_MEDIUM | DEBUG_IGNORED | DEBUG_UNKNOWN, "G_RESERVED0: w0=0x%08lX w1=0x%08lX\n", w0, w1 );
#endif
}

void F3D_MoveMem( u32 w0, u32 w1 )
{
#ifdef __TRIBUFFER_OPT
    gSPFlushTriangles();
#endif
    switch (_SHIFTR( w0, 16, 8 ))
    {
        case F3D_MV_VIEWPORT://G_MV_VIEWPORT:
            gSPViewport( w1 );
            break;
        case G_MV_MATRIX_1:
            gSPForceMatrix( w1 );
            // force matrix takes four commands
            RSP.PC[RSP.PCi] += 24;
            break;
        case G_MV_L0:
            gSPLight( w1, LIGHT_1 );
            break;
        case G_MV_L1:
            gSPLight( w1, LIGHT_2 );
            break;
        case G_MV_L2:
            gSPLight( w1, LIGHT_3 );
            break;
        case G_MV_L3:
            gSPLight( w1, LIGHT_4 );
            break;
        case G_MV_L4:
            gSPLight( w1, LIGHT_5 );
            break;
        case G_MV_L5:
            gSPLight( w1, LIGHT_6 );
            break;
        case G_MV_L6:
            gSPLight( w1, LIGHT_7 );
            break;
        case G_MV_L7:
            gSPLight( w1, LIGHT_8 );
            break;
        case G_MV_LOOKATX:
            break;
        case G_MV_LOOKATY:
            break;
    }
}

void F3D_Vtx( u32 w0, u32 w1 )
{
    gSPVertex( w1, _SHIFTR( w0, 20, 4 ) + 1, _SHIFTR( w0, 16, 4 ) );
}

void F3D_Reserved1( u32 w0, u32 w1 )
{
}

void F3D_DList( u32 w0, u32 w1 )
{
    switch (_SHIFTR( w0, 16, 8 ))
    {
        case G_DL_PUSH:
            gSPDisplayList( w1 );
            break;
        case G_DL_NOPUSH:
            gSPBranchList( w1 );
            break;
    }

#ifdef __TRIBUFFER_OPT
    //since PCi can be changed in gSPDisplayList
    gSPFlushTriangles();
#endif
}

void F3D_Reserved2( u32 w0, u32 w1 )
{
}

void F3D_Reserved3( u32 w0, u32 w1 )
{
}

void F3D_Sprite2D_Base( u32 w0, u32 w1 )
{
    //gSPSprite2DBase( w1 );
    RSP.PC[RSP.PCi] += 8;
}


void F3D_Tri1( u32 w0, u32 w1 )
{
    gSP1Triangle( _SHIFTR( w1, 16, 8 ) / 10, _SHIFTR( w1, 8, 8 ) / 10, _SHIFTR( w1, 0, 8 ) / 10);
}

void F3D_CullDL( u32 w0, u32 w1 )
{
    gSPCullDisplayList( _SHIFTR( w0, 0, 24 ) / 40, (w1 / 40) - 1 );
}

void F3D_PopMtx( u32 w0, u32 w1 )
{
    gSPPopMatrix( w1 );
}

void F3D_MoveWord( u32 w0, u32 w1 )
{
    switch (_SHIFTR( w0, 0, 8 ))
    {
        case G_MW_MATRIX:
            gSPInsertMatrix( _SHIFTR( w0, 8, 16 ), w1 );
            break;

        case G_MW_NUMLIGHT:
            gSPNumLights( ((w1 - 0x80000000) >> 5) - 1 );
            break;

        case G_MW_CLIP:
            gSPClipRatio( w1 );
            break;

        case G_MW_SEGMENT:
            gSPSegment( _SHIFTR( w0, 8, 16 ) >> 2, w1 & 0x00FFFFFF );
            break;

        case G_MW_FOG:
            gSPFogFactor( (s16)_SHIFTR( w1, 16, 16 ), (s16)_SHIFTR( w1, 0, 16 ) );
            break;

        case G_MW_LIGHTCOL:
            switch (_SHIFTR( w0, 8, 16 ))
            {
                case F3D_MWO_aLIGHT_1:
                    gSPLightColor( LIGHT_1, w1 );
                    break;
                case F3D_MWO_aLIGHT_2:
                    gSPLightColor( LIGHT_2, w1 );
                    break;
                case F3D_MWO_aLIGHT_3:
                    gSPLightColor( LIGHT_3, w1 );
                    break;
                case F3D_MWO_aLIGHT_4:
                    gSPLightColor( LIGHT_4, w1 );
                    break;
                case F3D_MWO_aLIGHT_5:
                    gSPLightColor( LIGHT_5, w1 );
                    break;
                case F3D_MWO_aLIGHT_6:
                    gSPLightColor( LIGHT_6, w1 );
                    break;
                case F3D_MWO_aLIGHT_7:
                    gSPLightColor( LIGHT_7, w1 );
                    break;
                case F3D_MWO_aLIGHT_8:
                    gSPLightColor( LIGHT_8, w1 );
                    break;
            }
            break;
        case G_MW_POINTS:
            gSPModifyVertex( _SHIFTR( w0, 8, 16 ) / 40, _SHIFTR( w0, 0, 8 ) % 40, w1 );
            break;
        case G_MW_PERSPNORM:
            gSPPerspNormalize( w1 );
            break;
    }
}

void F3D_Texture( u32 w0, u32 w1 )
{
    gSPTexture( _FIXED2FLOAT( _SHIFTR( w1, 16, 16 ), 16 ),
                _FIXED2FLOAT( _SHIFTR( w1, 0, 16 ), 16 ),
                _SHIFTR( w0, 11, 3 ),
                _SHIFTR( w0, 8, 3 ),
                _SHIFTR( w0, 0, 8 ) );
}

void F3D_SetOtherMode_H( u32 w0, u32 w1 )
{
    switch (_SHIFTR( w0, 8, 8 ))
    {
        case G_MDSFT_PIPELINE:
            gDPPipelineMode( w1 >> G_MDSFT_PIPELINE );
            break;
        case G_MDSFT_CYCLETYPE:
            gDPSetCycleType( w1 >> G_MDSFT_CYCLETYPE );
            break;
        case G_MDSFT_TEXTPERSP:
            gDPSetTexturePersp( w1 >> G_MDSFT_TEXTPERSP );
            break;
        case G_MDSFT_TEXTDETAIL:
            gDPSetTextureDetail( w1 >> G_MDSFT_TEXTDETAIL );
            break;
        case G_MDSFT_TEXTLOD:
            gDPSetTextureLOD( w1 >> G_MDSFT_TEXTLOD );
            break;
        case G_MDSFT_TEXTLUT:
            gDPSetTextureLUT( w1 >> G_MDSFT_TEXTLUT );
            break;
        case G_MDSFT_TEXTFILT:
            gDPSetTextureFilter( w1 >> G_MDSFT_TEXTFILT );
            break;
        case G_MDSFT_TEXTCONV:
            gDPSetTextureConvert( w1 >> G_MDSFT_TEXTCONV );
            break;
        case G_MDSFT_COMBKEY:
            gDPSetCombineKey( w1 >> G_MDSFT_COMBKEY );
            break;
        case G_MDSFT_RGBDITHER:
            gDPSetColorDither( w1 >> G_MDSFT_RGBDITHER );
            break;
        case G_MDSFT_ALPHADITHER:
            gDPSetAlphaDither( w1 >> G_MDSFT_ALPHADITHER );
            break;
        default:
            u32 shift = _SHIFTR( w0, 8, 8 );
            u32 length = _SHIFTR( w0, 0, 8 );
            u32 mask = ((1 << length) - 1) << shift;

            gDP.otherMode.h &= ~mask;
            gDP.otherMode.h |= w1 & mask;

            gDP.changed |= CHANGED_CYCLETYPE;
            break;
    }
}

void F3D_SetOtherMode_L( u32 w0, u32 w1 )
{
    switch (_SHIFTR( w0, 8, 8 ))
    {
        case G_MDSFT_ALPHACOMPARE:
            gDPSetAlphaCompare( w1 >> G_MDSFT_ALPHACOMPARE );
            break;
        case G_MDSFT_ZSRCSEL:
            gDPSetDepthSource( w1 >> G_MDSFT_ZSRCSEL );
            break;
        case G_MDSFT_RENDERMODE:
            gDPSetRenderMode( w1 & 0xCCCCFFFF, w1 & 0x3333FFFF );
            break;
        default:
            u32 shift = _SHIFTR( w0, 8, 8 );
            u32 length = _SHIFTR( w0, 0, 8 );
            u32 mask = ((1 << length) - 1) << shift;

            gDP.otherMode.l &= ~mask;
            gDP.otherMode.l |= w1 & mask;

            gDP.changed |= CHANGED_RENDERMODE | CHANGED_ALPHACOMPARE;
            break;
    }
}

void F3D_EndDL( u32 w0, u32 w1 )
{
    gSPEndDisplayList();
}

void F3D_SetGeometryMode( u32 w0, u32 w1 )
{
    gSPSetGeometryMode( w1 );
}

void F3D_ClearGeometryMode( u32 w0, u32 w1 )
{
    gSPClearGeometryMode( w1 );
}

void F3D_Line3D( u32 w0, u32 w1 )
{
    // Hmmm...
}

void F3D_Quad( u32 w0, u32 w1 )
{
    gSP1Quadrangle( _SHIFTR( w1, 24, 8 ) / 10, _SHIFTR( w1, 16, 8 ) / 10, _SHIFTR( w1, 8, 8 ) / 10, _SHIFTR( w1, 0, 8 ) / 10 );
}

void F3D_RDPHalf_1( u32 w0, u32 w1 )
{
    gDP.half_1 = w1;
}

void F3D_RDPHalf_2( u32 w0, u32 w1 )
{
    gDP.half_2 = w1;
}

void F3D_RDPHalf_Cont( u32 w0, u32 w1 )
{
}

void F3D_Tri4( u32 w0, u32 w1 )
{
    gSP4Triangles( _SHIFTR( w0,  0, 4 ), _SHIFTR( w1,  0, 4 ), _SHIFTR( w1,  4, 4 ),
                   _SHIFTR( w0,  4, 4 ), _SHIFTR( w1,  8, 4 ), _SHIFTR( w1, 12, 4 ),
                   _SHIFTR( w0,  8, 4 ), _SHIFTR( w1, 16, 4 ), _SHIFTR( w1, 20, 4 ),
                   _SHIFTR( w0, 12, 4 ), _SHIFTR( w1, 24, 4 ), _SHIFTR( w1, 28, 4 ) );
}

void F3D_Init()
{
    // Set GeometryMode flags
    GBI_InitFlags( F3D );

    GBI.PCStackSize = 10;

    //          GBI Command             Command Value           Command Function
    GBI_SetGBI( G_SPNOOP,               F3D_SPNOOP,             F3D_SPNoOp );
    GBI_SetGBI( G_MTX,                  F3D_MTX,                F3D_Mtx );
    GBI_SetGBI( G_RESERVED0,            F3D_RESERVED0,          F3D_Reserved0 );
    GBI_SetGBI( G_MOVEMEM,              F3D_MOVEMEM,            F3D_MoveMem );
    GBI_SetGBI( G_VTX,                  F3D_VTX,                F3D_Vtx );
    GBI_SetGBI( G_RESERVED1,            F3D_RESERVED1,          F3D_Reserved1 );
    GBI_SetGBI( G_DL,                   F3D_DL,                 F3D_DList );
    GBI_SetGBI( G_RESERVED2,            F3D_RESERVED2,          F3D_Reserved2 );
    GBI_SetGBI( G_RESERVED3,            F3D_RESERVED3,          F3D_Reserved3 );
    GBI_SetGBI( G_SPRITE2D_BASE,        F3D_SPRITE2D_BASE,      F3D_Sprite2D_Base );

    GBI_SetGBI( G_TRI1,                 F3D_TRI1,               F3D_Tri1 );
    GBI_SetGBI( G_CULLDL,               F3D_CULLDL,             F3D_CullDL );
    GBI_SetGBI( G_POPMTX,               F3D_POPMTX,             F3D_PopMtx );
    GBI_SetGBI( G_MOVEWORD,             F3D_MOVEWORD,           F3D_MoveWord );
    GBI_SetGBI( G_TEXTURE,              F3D_TEXTURE,            F3D_Texture );
    GBI_SetGBI( G_SETOTHERMODE_H,       F3D_SETOTHERMODE_H,     F3D_SetOtherMode_H );
    GBI_SetGBI( G_SETOTHERMODE_L,       F3D_SETOTHERMODE_L,     F3D_SetOtherMode_L );
    GBI_SetGBI( G_ENDDL,                F3D_ENDDL,              F3D_EndDL );
    GBI_SetGBI( G_SETGEOMETRYMODE,      F3D_SETGEOMETRYMODE,    F3D_SetGeometryMode );
    GBI_SetGBI( G_CLEARGEOMETRYMODE,    F3D_CLEARGEOMETRYMODE,  F3D_ClearGeometryMode );
    GBI_SetGBI( G_QUAD,                 F3D_QUAD,               F3D_Quad );
    GBI_SetGBI( G_RDPHALF_1,            F3D_RDPHALF_1,          F3D_RDPHalf_1 );
    GBI_SetGBI( G_RDPHALF_2,            F3D_RDPHALF_2,          F3D_RDPHalf_2 );
    GBI_SetGBI( G_RDPHALF_CONT,         F3D_RDPHALF_CONT,       F3D_RDPHalf_Cont );
    GBI_SetGBI( G_TRI4,                 F3D_TRI4,               F3D_Tri4 );

}
Commit	Line	Data
34cf4058	1	#include "gles2N64.h"
	2	#include "Debug.h"
	3	#include "F3D.h"
	4	#include "N64.h"
	5	#include "RSP.h"
	6	#include "RDP.h"
	7	#include "gSP.h"
	8	#include "gDP.h"
	9	#include "GBI.h"
	10	#include "OpenGL.h"
	11	#include "DepthBuffer.h"
	12
	13	#include "Config.h"
	14
	15	void F3D_SPNoOp( u32 w0, u32 w1 )
	16	{
	17	gSPNoOp();
	18	}
	19
	20	void F3D_Mtx( u32 w0, u32 w1 )
	21	{
	22	if (_SHIFTR( w0, 0, 16 ) != 64)
	23	{
	24	// GBI_DetectUCode(); // Something's wrong
	25	#ifdef DEBUG
	26	DebugMsg( DEBUG_MEDIUM \| DEBUG_HIGH \| DEBUG_ERROR, "G_MTX: address = 0x%08X length = %i params = 0x%02X\n", w1, _SHIFTR( w0, 0, 16 ), _SHIFTR( w0, 16, 8 ) );
	27	#endif
	28	return;
	29	}
	30
	31	gSPMatrix( w1, _SHIFTR( w0, 16, 8 ) );
	32	}
	33
	34	void F3D_Reserved0( u32 w0, u32 w1 )
	35	{
	36	#ifdef DEBUG
	37	DebugMsg( DEBUG_MEDIUM \| DEBUG_IGNORED \| DEBUG_UNKNOWN, "G_RESERVED0: w0=0x%08lX w1=0x%08lX\n", w0, w1 );
	38	#endif
	39	}
	40
	41	void F3D_MoveMem( u32 w0, u32 w1 )
	42	{
	43	#ifdef __TRIBUFFER_OPT
	44	gSPFlushTriangles();
	45	#endif
	46	switch (_SHIFTR( w0, 16, 8 ))
	47	{
	48	case F3D_MV_VIEWPORT://G_MV_VIEWPORT:
	49	gSPViewport( w1 );
	50	break;
	51	case G_MV_MATRIX_1:
	52	gSPForceMatrix( w1 );
	53	// force matrix takes four commands
	54	RSP.PC[RSP.PCi] += 24;
	55	break;
	56	case G_MV_L0:
	57	gSPLight( w1, LIGHT_1 );
	58	break;
	59	case G_MV_L1:
	60	gSPLight( w1, LIGHT_2 );
	61	break;
	62	case G_MV_L2:
	63	gSPLight( w1, LIGHT_3 );
	64	break;
65	case G_MV_L3:
66	gSPLight( w1, LIGHT_4 );
67	break;
68	case G_MV_L4:
69	gSPLight( w1, LIGHT_5 );
70	break;
71	case G_MV_L5:
72	gSPLight( w1, LIGHT_6 );
73	break;
74	case G_MV_L6:
75	gSPLight( w1, LIGHT_7 );
76	break;
77	case G_MV_L7:
78	gSPLight( w1, LIGHT_8 );
79	break;
80	case G_MV_LOOKATX:
81	break;
82	case G_MV_LOOKATY:
83	break;
84	}
85	}
86
87	void F3D_Vtx( u32 w0, u32 w1 )
88	{
89	gSPVertex( w1, _SHIFTR( w0, 20, 4 ) + 1, _SHIFTR( w0, 16, 4 ) );
90	}
91
92	void F3D_Reserved1( u32 w0, u32 w1 )
93	{
94	}
95
96	void F3D_DList( u32 w0, u32 w1 )
97	{
98	switch (_SHIFTR( w0, 16, 8 ))
99	{
100	case G_DL_PUSH:
101	gSPDisplayList( w1 );
102	break;
103	case G_DL_NOPUSH:
104	gSPBranchList( w1 );
105	break;
106	}
107
108	#ifdef __TRIBUFFER_OPT
109	//since PCi can be changed in gSPDisplayList
110	gSPFlushTriangles();
111	#endif
112	}
113
114	void F3D_Reserved2( u32 w0, u32 w1 )
115	{
116	}
117
118	void F3D_Reserved3( u32 w0, u32 w1 )
119	{
120	}
121
122	void F3D_Sprite2D_Base( u32 w0, u32 w1 )
123	{
124	//gSPSprite2DBase( w1 );
125	RSP.PC[RSP.PCi] += 8;
126	}
127
128
129	void F3D_Tri1( u32 w0, u32 w1 )
130	{
131	gSP1Triangle( _SHIFTR( w1, 16, 8 ) / 10, _SHIFTR( w1, 8, 8 ) / 10, _SHIFTR( w1, 0, 8 ) / 10);
132	}
133
134	void F3D_CullDL( u32 w0, u32 w1 )
135	{
136	gSPCullDisplayList( _SHIFTR( w0, 0, 24 ) / 40, (w1 / 40) - 1 );
137	}
138
139	void F3D_PopMtx( u32 w0, u32 w1 )
140	{
141	gSPPopMatrix( w1 );
142	}
143
144	void F3D_MoveWord( u32 w0, u32 w1 )
145	{
146	switch (_SHIFTR( w0, 0, 8 ))
147	{
148	case G_MW_MATRIX:
149	gSPInsertMatrix( _SHIFTR( w0, 8, 16 ), w1 );
150	break;
151
152	case G_MW_NUMLIGHT:
153	gSPNumLights( ((w1 - 0x80000000) >> 5) - 1 );
154	break;
155
156	case G_MW_CLIP:
157	gSPClipRatio( w1 );
158	break;
159
160	case G_MW_SEGMENT:
161	gSPSegment( _SHIFTR( w0, 8, 16 ) >> 2, w1 & 0x00FFFFFF );
162	break;
163
164	case G_MW_FOG:
165	gSPFogFactor( (s16)_SHIFTR( w1, 16, 16 ), (s16)_SHIFTR( w1, 0, 16 ) );
166	break;
167
168	case G_MW_LIGHTCOL:
169	switch (_SHIFTR( w0, 8, 16 ))
170	{
171	case F3D_MWO_aLIGHT_1:
172	gSPLightColor( LIGHT_1, w1 );
173	break;
174	case F3D_MWO_aLIGHT_2:
175	gSPLightColor( LIGHT_2, w1 );
176	break;
177	case F3D_MWO_aLIGHT_3:
178	gSPLightColor( LIGHT_3, w1 );
179	break;
180	case F3D_MWO_aLIGHT_4:
181	gSPLightColor( LIGHT_4, w1 );
182	break;
183	case F3D_MWO_aLIGHT_5:
184	gSPLightColor( LIGHT_5, w1 );
185	break;
186	case F3D_MWO_aLIGHT_6:
187	gSPLightColor( LIGHT_6, w1 );
188	break;
189	case F3D_MWO_aLIGHT_7:
190	gSPLightColor( LIGHT_7, w1 );
191	break;
192	case F3D_MWO_aLIGHT_8:
193	gSPLightColor( LIGHT_8, w1 );
194	break;
195	}
196	break;
197	case G_MW_POINTS:
198	gSPModifyVertex( _SHIFTR( w0, 8, 16 ) / 40, _SHIFTR( w0, 0, 8 ) % 40, w1 );
199	break;
200	case G_MW_PERSPNORM:
201	gSPPerspNormalize( w1 );
202	break;
203	}
204	}
205
206	void F3D_Texture( u32 w0, u32 w1 )
207	{
208	gSPTexture( _FIXED2FLOAT( _SHIFTR( w1, 16, 16 ), 16 ),
209	_FIXED2FLOAT( _SHIFTR( w1, 0, 16 ), 16 ),
210	_SHIFTR( w0, 11, 3 ),
211	_SHIFTR( w0, 8, 3 ),
212	_SHIFTR( w0, 0, 8 ) );
213	}
214
215	void F3D_SetOtherMode_H( u32 w0, u32 w1 )
216	{
217	switch (_SHIFTR( w0, 8, 8 ))
218	{
219	case G_MDSFT_PIPELINE:
220	gDPPipelineMode( w1 >> G_MDSFT_PIPELINE );
221	break;
222	case G_MDSFT_CYCLETYPE:
223	gDPSetCycleType( w1 >> G_MDSFT_CYCLETYPE );
224	break;
225	case G_MDSFT_TEXTPERSP:
226	gDPSetTexturePersp( w1 >> G_MDSFT_TEXTPERSP );
227	break;
228	case G_MDSFT_TEXTDETAIL:
229	gDPSetTextureDetail( w1 >> G_MDSFT_TEXTDETAIL );
230	break;
231	case G_MDSFT_TEXTLOD:
232	gDPSetTextureLOD( w1 >> G_MDSFT_TEXTLOD );
233	break;
234	case G_MDSFT_TEXTLUT:
235	gDPSetTextureLUT( w1 >> G_MDSFT_TEXTLUT );
236	break;
237	case G_MDSFT_TEXTFILT:
238	gDPSetTextureFilter( w1 >> G_MDSFT_TEXTFILT );
239	break;
240	case G_MDSFT_TEXTCONV:
241	gDPSetTextureConvert( w1 >> G_MDSFT_TEXTCONV );
242	break;
243	case G_MDSFT_COMBKEY:
244	gDPSetCombineKey( w1 >> G_MDSFT_COMBKEY );
245	break;
246	case G_MDSFT_RGBDITHER:
247	gDPSetColorDither( w1 >> G_MDSFT_RGBDITHER );
248	break;
249	case G_MDSFT_ALPHADITHER:
250	gDPSetAlphaDither( w1 >> G_MDSFT_ALPHADITHER );
251	break;
252	default:
253	u32 shift = _SHIFTR( w0, 8, 8 );
254	u32 length = _SHIFTR( w0, 0, 8 );
255	u32 mask = ((1 << length) - 1) << shift;
256
257	gDP.otherMode.h &= ~mask;
258	gDP.otherMode.h \|= w1 & mask;
259
260	gDP.changed \|= CHANGED_CYCLETYPE;
261	break;
262	}
263	}
264
265	void F3D_SetOtherMode_L( u32 w0, u32 w1 )
266	{
267	switch (_SHIFTR( w0, 8, 8 ))
268	{
269	case G_MDSFT_ALPHACOMPARE:
270	gDPSetAlphaCompare( w1 >> G_MDSFT_ALPHACOMPARE );
271	break;
272	case G_MDSFT_ZSRCSEL:
273	gDPSetDepthSource( w1 >> G_MDSFT_ZSRCSEL );
274	break;
275	case G_MDSFT_RENDERMODE:
276	gDPSetRenderMode( w1 & 0xCCCCFFFF, w1 & 0x3333FFFF );
277	break;
278	default:
279	u32 shift = _SHIFTR( w0, 8, 8 );
280	u32 length = _SHIFTR( w0, 0, 8 );
281	u32 mask = ((1 << length) - 1) << shift;
282
283	gDP.otherMode.l &= ~mask;
284	gDP.otherMode.l \|= w1 & mask;
285
286	gDP.changed \|= CHANGED_RENDERMODE \| CHANGED_ALPHACOMPARE;
287	break;
288	}
289	}
290
291	void F3D_EndDL( u32 w0, u32 w1 )
292	{
293	gSPEndDisplayList();
294	}
295
296	void F3D_SetGeometryMode( u32 w0, u32 w1 )
297	{
298	gSPSetGeometryMode( w1 );
299	}
300
301	void F3D_ClearGeometryMode( u32 w0, u32 w1 )
302	{
303	gSPClearGeometryMode( w1 );
304	}
305
306	void F3D_Line3D( u32 w0, u32 w1 )
307	{
308	// Hmmm...
309	}
310
311	void F3D_Quad( u32 w0, u32 w1 )
312	{
313	gSP1Quadrangle( _SHIFTR( w1, 24, 8 ) / 10, _SHIFTR( w1, 16, 8 ) / 10, _SHIFTR( w1, 8, 8 ) / 10, _SHIFTR( w1, 0, 8 ) / 10 );
314	}
315
316	void F3D_RDPHalf_1( u32 w0, u32 w1 )
317	{
318	gDP.half_1 = w1;
319	}
320
321	void F3D_RDPHalf_2( u32 w0, u32 w1 )
322	{
323	gDP.half_2 = w1;
324	}
325
326	void F3D_RDPHalf_Cont( u32 w0, u32 w1 )
327	{
328	}
329
330	void F3D_Tri4( u32 w0, u32 w1 )
331	{
332	gSP4Triangles( _SHIFTR( w0, 0, 4 ), _SHIFTR( w1, 0, 4 ), _SHIFTR( w1, 4, 4 ),
333	_SHIFTR( w0, 4, 4 ), _SHIFTR( w1, 8, 4 ), _SHIFTR( w1, 12, 4 ),
334	_SHIFTR( w0, 8, 4 ), _SHIFTR( w1, 16, 4 ), _SHIFTR( w1, 20, 4 ),
335	_SHIFTR( w0, 12, 4 ), _SHIFTR( w1, 24, 4 ), _SHIFTR( w1, 28, 4 ) );
336	}
337
338	void F3D_Init()
339	{
340	// Set GeometryMode flags
341	GBI_InitFlags( F3D );
342
343	GBI.PCStackSize = 10;
344
345	// GBI Command Command Value Command Function
346	GBI_SetGBI( G_SPNOOP, F3D_SPNOOP, F3D_SPNoOp );
347	GBI_SetGBI( G_MTX, F3D_MTX, F3D_Mtx );
348	GBI_SetGBI( G_RESERVED0, F3D_RESERVED0, F3D_Reserved0 );
349	GBI_SetGBI( G_MOVEMEM, F3D_MOVEMEM, F3D_MoveMem );
350	GBI_SetGBI( G_VTX, F3D_VTX, F3D_Vtx );
351	GBI_SetGBI( G_RESERVED1, F3D_RESERVED1, F3D_Reserved1 );
352	GBI_SetGBI( G_DL, F3D_DL, F3D_DList );
353	GBI_SetGBI( G_RESERVED2, F3D_RESERVED2, F3D_Reserved2 );
354	GBI_SetGBI( G_RESERVED3, F3D_RESERVED3, F3D_Reserved3 );
355	GBI_SetGBI( G_SPRITE2D_BASE, F3D_SPRITE2D_BASE, F3D_Sprite2D_Base );
356
357	GBI_SetGBI( G_TRI1, F3D_TRI1, F3D_Tri1 );
358	GBI_SetGBI( G_CULLDL, F3D_CULLDL, F3D_CullDL );
359	GBI_SetGBI( G_POPMTX, F3D_POPMTX, F3D_PopMtx );
360	GBI_SetGBI( G_MOVEWORD, F3D_MOVEWORD, F3D_MoveWord );
361	GBI_SetGBI( G_TEXTURE, F3D_TEXTURE, F3D_Texture );
362	GBI_SetGBI( G_SETOTHERMODE_H, F3D_SETOTHERMODE_H, F3D_SetOtherMode_H );
363	GBI_SetGBI( G_SETOTHERMODE_L, F3D_SETOTHERMODE_L, F3D_SetOtherMode_L );
364	GBI_SetGBI( G_ENDDL, F3D_ENDDL, F3D_EndDL );
365	GBI_SetGBI( G_SETGEOMETRYMODE, F3D_SETGEOMETRYMODE, F3D_SetGeometryMode );
366	GBI_SetGBI( G_CLEARGEOMETRYMODE, F3D_CLEARGEOMETRYMODE, F3D_ClearGeometryMode );
367	GBI_SetGBI( G_QUAD, F3D_QUAD, F3D_Quad );
368	GBI_SetGBI( G_RDPHALF_1, F3D_RDPHALF_1, F3D_RDPHalf_1 );
369	GBI_SetGBI( G_RDPHALF_2, F3D_RDPHALF_2, F3D_RDPHalf_2 );
370	GBI_SetGBI( G_RDPHALF_CONT, F3D_RDPHALF_CONT, F3D_RDPHalf_Cont );
371	GBI_SetGBI( G_TRI4, F3D_TRI4, F3D_Tri4 );
372
373	}
374