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

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

#include "Config.h"

void F3DEX2_Mtx( u32 w0, u32 w1 )
{
    gSPMatrix( w1, _SHIFTR( w0, 0, 8 ) ^ G_MTX_PUSH );
}

void F3DEX2_MoveMem( u32 w0, u32 w1 )
{
#ifdef __TRIBUFFER_OPT
    gSPFlushTriangles();
#endif
    switch (_SHIFTR( w0, 0, 8 ))
    {
        case F3DEX2_MV_VIEWPORT:
            gSPViewport( w1 );
            break;

        case G_MV_MATRIX:
            gSPForceMatrix( w1 );
            RSP.PC[RSP.PCi] += 8;             // force matrix takes two commands
            break;

        case G_MV_LIGHT:
            u32 offset = _SHIFTR( w0, 8, 8 ) << 3;
            if (offset >= 48)
            {
                gSPLight( w1, (offset - 24) / 24);
            }
            break;
    }
}

void F3DEX2_Vtx( u32 w0, u32 w1 )
{
    u32 n = _SHIFTR( w0, 12, 8 );

    gSPVertex( w1, n, _SHIFTR( w0, 1, 7 ) - n );
}

void F3DEX2_Reserved1( u32 w0, u32 w1 )
{
}

void F3DEX2_Tri1( u32 w0, u32 w1 )
{
    gSP1Triangle( _SHIFTR( w0, 17, 7 ),
                  _SHIFTR( w0, 9, 7 ),
                  _SHIFTR( w0, 1, 7 ));
}

void F3DEX2_PopMtx( u32 w0, u32 w1 )
{
    gSPPopMatrixN( 0, w1 >> 6 );
}

void F3DEX2_MoveWord( u32 w0, u32 w1 )
{
    switch (_SHIFTR( w0, 16, 8 ))
    {
        case G_MW_FORCEMTX:
            // Handled in movemem
            break;
        case G_MW_MATRIX:
            gSPInsertMatrix( _SHIFTR( w0, 0, 16 ), w1 );
            break;
        case G_MW_NUMLIGHT:
            gSPNumLights( w1 / 24 );
            break;
        case G_MW_CLIP:
            gSPClipRatio( w1 );
            break;
        case G_MW_SEGMENT:
            gSPSegment( _SHIFTR( w0, 0, 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:
            gSPLightColor((_SHIFTR( w0, 0, 16 ) / 24) + 1, w1 );
            break;
        case G_MW_PERSPNORM:
            gSPPerspNormalize( w1 );
            break;
    }
}

void F3DEX2_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, 1, 7 ) );
}

void F3DEX2_SetOtherMode_H( u32 w0, u32 w1 )
{
    switch (32 - _SHIFTR( w0, 8, 8 ) - (_SHIFTR( w0, 0, 8 ) + 1))
    {
        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 length = _SHIFTR( w0, 0, 8 ) + 1;
            u32 shift = 32 - _SHIFTR( w0, 8, 8 ) - length;
            u32 mask = ((1 << length) - 1) << shift;

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

            gDP.changed |= CHANGED_CYCLETYPE;
            break;
    }
}

void F3DEX2_SetOtherMode_L( u32 w0, u32 w1 )
{
    switch (32 - _SHIFTR( w0, 8, 8 ) - (_SHIFTR( w0, 0, 8 ) + 1))
    {
        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 length = _SHIFTR( w0, 0, 8 ) + 1;
            u32 shift = 32 - _SHIFTR( w0, 8, 8 ) - length;
            u32 mask = ((1 << length) - 1) << shift;

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

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

void F3DEX2_GeometryMode( u32 w0, u32 w1 )
{
    gSPGeometryMode( ~_SHIFTR( w0, 0, 24 ), w1 );
}

void F3DEX2_DMAIO( u32 w0, u32 w1 )
{
}

void F3DEX2_Special_1( u32 w0, u32 w1 )
{
}

void F3DEX2_Special_2( u32 w0, u32 w1 )
{
}

void F3DEX2_Special_3( u32 w0, u32 w1 )
{
}

void F3DEX2_Quad( u32 w0, u32 w1 )
{
    gSP2Triangles( _SHIFTR( w0, 17, 7 ),
                   _SHIFTR( w0, 9, 7 ),
                   _SHIFTR( w0, 1, 7 ),
                   0,
                   _SHIFTR( w1, 17, 7 ),
                   _SHIFTR( w1, 9, 7 ),
                   _SHIFTR( w1, 1, 7 ),
                   0 );
}

void F3DEX2_Init()
{
    // Set GeometryMode flags
    GBI_InitFlags( F3DEX2 );

    GBI.PCStackSize = 18;

    // GBI Command                      Command Value               Command Function
    GBI_SetGBI( G_RDPHALF_2,            F3DEX2_RDPHALF_2,           F3D_RDPHalf_2 );
    GBI_SetGBI( G_SETOTHERMODE_H,       F3DEX2_SETOTHERMODE_H,      F3DEX2_SetOtherMode_H );
    GBI_SetGBI( G_SETOTHERMODE_L,       F3DEX2_SETOTHERMODE_L,      F3DEX2_SetOtherMode_L );
    GBI_SetGBI( G_RDPHALF_1,            F3DEX2_RDPHALF_1,           F3D_RDPHalf_1 );
    GBI_SetGBI( G_SPNOOP,               F3DEX2_SPNOOP,              F3D_SPNoOp );
    GBI_SetGBI( G_ENDDL,                F3DEX2_ENDDL,               F3D_EndDL );
    GBI_SetGBI( G_DL,                   F3DEX2_DL,                  F3D_DList );
    GBI_SetGBI( G_LOAD_UCODE,           F3DEX2_LOAD_UCODE,          F3DEX_Load_uCode );
    GBI_SetGBI( G_MOVEMEM,              F3DEX2_MOVEMEM,             F3DEX2_MoveMem );
    GBI_SetGBI( G_MOVEWORD,             F3DEX2_MOVEWORD,            F3DEX2_MoveWord );
    GBI_SetGBI( G_MTX,                  F3DEX2_MTX,                 F3DEX2_Mtx );
    GBI_SetGBI( G_GEOMETRYMODE,         F3DEX2_GEOMETRYMODE,        F3DEX2_GeometryMode );
    GBI_SetGBI( G_POPMTX,               F3DEX2_POPMTX,              F3DEX2_PopMtx );
    GBI_SetGBI( G_TEXTURE,              F3DEX2_TEXTURE,             F3DEX2_Texture );
    GBI_SetGBI( G_DMA_IO,               F3DEX2_DMA_IO,              F3DEX2_DMAIO );
    GBI_SetGBI( G_SPECIAL_1,            F3DEX2_SPECIAL_1,           F3DEX2_Special_1 );
    GBI_SetGBI( G_SPECIAL_2,            F3DEX2_SPECIAL_2,           F3DEX2_Special_2 );
    GBI_SetGBI( G_SPECIAL_3,            F3DEX2_SPECIAL_3,           F3DEX2_Special_3 );

    GBI_SetGBI( G_VTX,                  F3DEX2_VTX,                 F3DEX2_Vtx );
    GBI_SetGBI( G_MODIFYVTX,            F3DEX2_MODIFYVTX,           F3DEX_ModifyVtx );
    GBI_SetGBI( G_CULLDL,               F3DEX2_CULLDL,              F3DEX_CullDL );
    GBI_SetGBI( G_BRANCH_Z,             F3DEX2_BRANCH_Z,            F3DEX_Branch_Z );
    GBI_SetGBI( G_TRI1,                 F3DEX2_TRI1,                F3DEX2_Tri1 );
    GBI_SetGBI( G_TRI2,                 F3DEX2_TRI2,                F3DEX_Tri2 );
    GBI_SetGBI( G_QUAD,                 F3DEX2_QUAD,                F3DEX2_Quad );
//  GBI_SetGBI( G_LINE3D,               F3DEX2_LINE3D,              F3DEX2_Line3D );
}
Commit	Line	Data
34cf4058	1	#include "gles2N64.h"
	2	#include "Debug.h"
	3	#include "F3D.h"
	4	#include "F3DEX.h"
	5	#include "F3DEX2.h"
	6	#include "N64.h"
	7	#include "RSP.h"
	8	#include "RDP.h"
	9	#include "gSP.h"
	10	#include "gDP.h"
	11	#include "GBI.h"
	12	#include "OpenGL.h"
	13
	14	#include "Config.h"
	15
	16	void F3DEX2_Mtx( u32 w0, u32 w1 )
	17	{
	18	gSPMatrix( w1, _SHIFTR( w0, 0, 8 ) ^ G_MTX_PUSH );
	19	}
	20
	21	void F3DEX2_MoveMem( u32 w0, u32 w1 )
	22	{
	23	#ifdef __TRIBUFFER_OPT
	24	gSPFlushTriangles();
	25	#endif
	26	switch (_SHIFTR( w0, 0, 8 ))
	27	{
	28	case F3DEX2_MV_VIEWPORT:
	29	gSPViewport( w1 );
	30	break;
	31
	32	case G_MV_MATRIX:
	33	gSPForceMatrix( w1 );
	34	RSP.PC[RSP.PCi] += 8; // force matrix takes two commands
	35	break;
	36
	37	case G_MV_LIGHT:
	38	u32 offset = _SHIFTR( w0, 8, 8 ) << 3;
	39	if (offset >= 48)
	40	{
	41	gSPLight( w1, (offset - 24) / 24);
	42	}
	43	break;
	44	}
	45	}
	46
	47	void F3DEX2_Vtx( u32 w0, u32 w1 )
	48	{
	49	u32 n = _SHIFTR( w0, 12, 8 );
	50
	51	gSPVertex( w1, n, _SHIFTR( w0, 1, 7 ) - n );
	52	}
	53
	54	void F3DEX2_Reserved1( u32 w0, u32 w1 )
	55	{
	56	}
	57
	58	void F3DEX2_Tri1( u32 w0, u32 w1 )
	59	{
	60	gSP1Triangle( _SHIFTR( w0, 17, 7 ),
	61	_SHIFTR( w0, 9, 7 ),
	62	_SHIFTR( w0, 1, 7 ));
	63	}
	64
65	void F3DEX2_PopMtx( u32 w0, u32 w1 )
66	{
67	gSPPopMatrixN( 0, w1 >> 6 );
68	}
69
70	void F3DEX2_MoveWord( u32 w0, u32 w1 )
71	{
72	switch (_SHIFTR( w0, 16, 8 ))
73	{
74	case G_MW_FORCEMTX:
75	// Handled in movemem
76	break;
77	case G_MW_MATRIX:
78	gSPInsertMatrix( _SHIFTR( w0, 0, 16 ), w1 );
79	break;
80	case G_MW_NUMLIGHT:
81	gSPNumLights( w1 / 24 );
82	break;
83	case G_MW_CLIP:
84	gSPClipRatio( w1 );
85	break;
86	case G_MW_SEGMENT:
87	gSPSegment( _SHIFTR( w0, 0, 16 ) >> 2, w1 & 0x00FFFFFF );
88	break;
89	case G_MW_FOG:
90	gSPFogFactor( (s16)_SHIFTR( w1, 16, 16 ), (s16)_SHIFTR( w1, 0, 16 ) );
91	break;
92	case G_MW_LIGHTCOL:
93	gSPLightColor((_SHIFTR( w0, 0, 16 ) / 24) + 1, w1 );
94	break;
95	case G_MW_PERSPNORM:
96	gSPPerspNormalize( w1 );
97	break;
98	}
99	}
100
101	void F3DEX2_Texture( u32 w0, u32 w1 )
102	{
103	gSPTexture( _FIXED2FLOAT( _SHIFTR( w1, 16, 16 ), 16 ),
104	_FIXED2FLOAT( _SHIFTR( w1, 0, 16 ), 16 ),
105	_SHIFTR( w0, 11, 3 ),
106	_SHIFTR( w0, 8, 3 ),
107	_SHIFTR( w0, 1, 7 ) );
108	}
109
110	void F3DEX2_SetOtherMode_H( u32 w0, u32 w1 )
111	{
112	switch (32 - _SHIFTR( w0, 8, 8 ) - (_SHIFTR( w0, 0, 8 ) + 1))
113	{
114	case G_MDSFT_PIPELINE:
115	gDPPipelineMode( w1 >> G_MDSFT_PIPELINE );
116	break;
117	case G_MDSFT_CYCLETYPE:
118	gDPSetCycleType( w1 >> G_MDSFT_CYCLETYPE );
119	break;
120	case G_MDSFT_TEXTPERSP:
121	gDPSetTexturePersp( w1 >> G_MDSFT_TEXTPERSP );
122	break;
123	case G_MDSFT_TEXTDETAIL:
124	gDPSetTextureDetail( w1 >> G_MDSFT_TEXTDETAIL );
125	break;
126	case G_MDSFT_TEXTLOD:
127	gDPSetTextureLOD( w1 >> G_MDSFT_TEXTLOD );
128	break;
129	case G_MDSFT_TEXTLUT:
130	gDPSetTextureLUT( w1 >> G_MDSFT_TEXTLUT );
131	break;
132	case G_MDSFT_TEXTFILT:
133	gDPSetTextureFilter( w1 >> G_MDSFT_TEXTFILT );
134	break;
135	case G_MDSFT_TEXTCONV:
136	gDPSetTextureConvert( w1 >> G_MDSFT_TEXTCONV );
137	break;
138	case G_MDSFT_COMBKEY:
139	gDPSetCombineKey( w1 >> G_MDSFT_COMBKEY );
140	break;
141	case G_MDSFT_RGBDITHER:
142	gDPSetColorDither( w1 >> G_MDSFT_RGBDITHER );
143	break;
144	case G_MDSFT_ALPHADITHER:
145	gDPSetAlphaDither( w1 >> G_MDSFT_ALPHADITHER );
146	break;
147	default:
148	u32 length = _SHIFTR( w0, 0, 8 ) + 1;
149	u32 shift = 32 - _SHIFTR( w0, 8, 8 ) - length;
150	u32 mask = ((1 << length) - 1) << shift;
151
152	gDP.otherMode.h &= ~mask;
153	gDP.otherMode.h \|= w1 & mask;
154
155	gDP.changed \|= CHANGED_CYCLETYPE;
156	break;
157	}
158	}
159
160	void F3DEX2_SetOtherMode_L( u32 w0, u32 w1 )
161	{
162	switch (32 - _SHIFTR( w0, 8, 8 ) - (_SHIFTR( w0, 0, 8 ) + 1))
163	{
164	case G_MDSFT_ALPHACOMPARE:
165	gDPSetAlphaCompare( w1 >> G_MDSFT_ALPHACOMPARE );
166	break;
167	case G_MDSFT_ZSRCSEL:
168	gDPSetDepthSource( w1 >> G_MDSFT_ZSRCSEL );
169	break;
170	case G_MDSFT_RENDERMODE:
171	gDPSetRenderMode( w1 & 0xCCCCFFFF, w1 & 0x3333FFFF );
172	break;
173	default:
174	u32 length = _SHIFTR( w0, 0, 8 ) + 1;
175	u32 shift = 32 - _SHIFTR( w0, 8, 8 ) - length;
176	u32 mask = ((1 << length) - 1) << shift;
177
178	gDP.otherMode.l &= ~mask;
179	gDP.otherMode.l \|= w1 & mask;
180
181	gDP.changed \|= CHANGED_RENDERMODE \| CHANGED_ALPHACOMPARE;
182	break;
183	}
184	}
185
186	void F3DEX2_GeometryMode( u32 w0, u32 w1 )
187	{
188	gSPGeometryMode( ~_SHIFTR( w0, 0, 24 ), w1 );
189	}
190
191	void F3DEX2_DMAIO( u32 w0, u32 w1 )
192	{
193	}
194
195	void F3DEX2_Special_1( u32 w0, u32 w1 )
196	{
197	}
198
199	void F3DEX2_Special_2( u32 w0, u32 w1 )
200	{
201	}
202
203	void F3DEX2_Special_3( u32 w0, u32 w1 )
204	{
205	}
206
207	void F3DEX2_Quad( u32 w0, u32 w1 )
208	{
209	gSP2Triangles( _SHIFTR( w0, 17, 7 ),
210	_SHIFTR( w0, 9, 7 ),
211	_SHIFTR( w0, 1, 7 ),
212	0,
213	_SHIFTR( w1, 17, 7 ),
214	_SHIFTR( w1, 9, 7 ),
215	_SHIFTR( w1, 1, 7 ),
216	0 );
217	}
218
219	void F3DEX2_Init()
220	{
221	// Set GeometryMode flags
222	GBI_InitFlags( F3DEX2 );
223
224	GBI.PCStackSize = 18;
225
226	// GBI Command Command Value Command Function
227	GBI_SetGBI( G_RDPHALF_2, F3DEX2_RDPHALF_2, F3D_RDPHalf_2 );
228	GBI_SetGBI( G_SETOTHERMODE_H, F3DEX2_SETOTHERMODE_H, F3DEX2_SetOtherMode_H );
229	GBI_SetGBI( G_SETOTHERMODE_L, F3DEX2_SETOTHERMODE_L, F3DEX2_SetOtherMode_L );
230	GBI_SetGBI( G_RDPHALF_1, F3DEX2_RDPHALF_1, F3D_RDPHalf_1 );
231	GBI_SetGBI( G_SPNOOP, F3DEX2_SPNOOP, F3D_SPNoOp );
232	GBI_SetGBI( G_ENDDL, F3DEX2_ENDDL, F3D_EndDL );
233	GBI_SetGBI( G_DL, F3DEX2_DL, F3D_DList );
234	GBI_SetGBI( G_LOAD_UCODE, F3DEX2_LOAD_UCODE, F3DEX_Load_uCode );
235	GBI_SetGBI( G_MOVEMEM, F3DEX2_MOVEMEM, F3DEX2_MoveMem );
236	GBI_SetGBI( G_MOVEWORD, F3DEX2_MOVEWORD, F3DEX2_MoveWord );
237	GBI_SetGBI( G_MTX, F3DEX2_MTX, F3DEX2_Mtx );
238	GBI_SetGBI( G_GEOMETRYMODE, F3DEX2_GEOMETRYMODE, F3DEX2_GeometryMode );
239	GBI_SetGBI( G_POPMTX, F3DEX2_POPMTX, F3DEX2_PopMtx );
240	GBI_SetGBI( G_TEXTURE, F3DEX2_TEXTURE, F3DEX2_Texture );
241	GBI_SetGBI( G_DMA_IO, F3DEX2_DMA_IO, F3DEX2_DMAIO );
242	GBI_SetGBI( G_SPECIAL_1, F3DEX2_SPECIAL_1, F3DEX2_Special_1 );
243	GBI_SetGBI( G_SPECIAL_2, F3DEX2_SPECIAL_2, F3DEX2_Special_2 );
244	GBI_SetGBI( G_SPECIAL_3, F3DEX2_SPECIAL_3, F3DEX2_Special_3 );
245
246	GBI_SetGBI( G_VTX, F3DEX2_VTX, F3DEX2_Vtx );
247	GBI_SetGBI( G_MODIFYVTX, F3DEX2_MODIFYVTX, F3DEX_ModifyVtx );
248	GBI_SetGBI( G_CULLDL, F3DEX2_CULLDL, F3DEX_CullDL );
249	GBI_SetGBI( G_BRANCH_Z, F3DEX2_BRANCH_Z, F3DEX_Branch_Z );
250	GBI_SetGBI( G_TRI1, F3DEX2_TRI1, F3DEX2_Tri1 );
251	GBI_SetGBI( G_TRI2, F3DEX2_TRI2, F3DEX_Tri2 );
252	GBI_SetGBI( G_QUAD, F3DEX2_QUAD, F3DEX2_Quad );
253	// GBI_SetGBI( G_LINE3D, F3DEX2_LINE3D, F3DEX2_Line3D );
254	}
255