mirror of https://github.com/PCSX2/pcsx2.git
547 lines
16 KiB
C++
547 lines
16 KiB
C++
/* GSnull
|
|
* Copyright (C) 2004-2009 PCSX2 Team
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "GS.h"
|
|
#include "Registers.h"
|
|
|
|
GIFRegHandler GIFPackedRegHandlers[16];
|
|
GIFRegHandler GIFRegHandlers[256];
|
|
|
|
// For now, I'm just rigging this up to store all the register information coming in, without doing
|
|
// any of the normal processing.
|
|
|
|
void __gifCall GIFPackedRegHandlerNull(const u32* data)
|
|
{
|
|
}
|
|
|
|
// All these just call their non-packed equivalent.
|
|
void __gifCall GIFPackedRegHandlerPRIM(const u32* data) { GIFRegHandlerPRIM(data); }
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFPackedRegHandlerTEX0(const u32* data)
|
|
{
|
|
GIFRegHandlerTEX0<i>(data);
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFPackedRegHandlerCLAMP(const u32* data)
|
|
{
|
|
GIFRegHandlerCLAMP<i>(data);
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerTEX0_1(const u32* data) { GIFRegHandlerTEX0<0>(data); }
|
|
void __gifCall GIFPackedRegHandlerTEX0_2(const u32* data) { GIFRegHandlerTEX0<1>(data); }
|
|
void __gifCall GIFPackedRegHandlerCLAMP_1(const u32* data) { GIFRegHandlerCLAMP<0>(data); }
|
|
void __gifCall GIFPackedRegHandlerCLAMP_2(const u32* data) { GIFRegHandlerCLAMP<1>(data); }
|
|
void __gifCall GIFPackedRegHandlerXYZF3(const u32* data) { GIFRegHandlerXYZF3(data); }
|
|
void __gifCall GIFPackedRegHandlerXYZ3(const u32* data) { GIFRegHandlerXYZ3(data); }
|
|
|
|
void __gifCall GIFPackedRegHandlerRGBA(const u32* data)
|
|
{
|
|
GIFPackedRGBA* r = (GIFPackedRGBA*)(data);
|
|
gs.regs.RGBAQ.R = r->R;
|
|
gs.regs.RGBAQ.G = r->G;
|
|
gs.regs.RGBAQ.B = r->B;
|
|
gs.regs.RGBAQ.A = r->A;
|
|
gs.regs.RGBAQ.Q = gs.q;
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerSTQ(const u32* data)
|
|
{
|
|
GIFPackedSTQ* r = (GIFPackedSTQ*)(data);
|
|
gs.regs.ST.S = r->S;
|
|
gs.regs.ST.T = r->T;
|
|
gs.q = r->Q;
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerUV(const u32* data)
|
|
{
|
|
GIFPackedUV* r = (GIFPackedUV*)(data);
|
|
gs.regs.UV.U = r->U;
|
|
gs.regs.UV.V = r->V;
|
|
}
|
|
|
|
void __gifCall KickVertex(bool adc)
|
|
{
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerXYZF2(const u32* data)
|
|
{
|
|
GIFPackedXYZF2* r = (GIFPackedXYZF2*)(data);
|
|
gs.regs.XYZ.X = r->X;
|
|
gs.regs.XYZ.Y = r->Y;
|
|
gs.regs.XYZ.Z = r->Z;
|
|
gs.regs.FOG.F = r->F;
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerXYZ2(const u32* data)
|
|
{
|
|
GIFPackedXYZ2* r = (GIFPackedXYZ2*)(data);
|
|
gs.regs.XYZ.X = r->X;
|
|
gs.regs.XYZ.Y = r->Y;
|
|
gs.regs.XYZ.Z = r->Z;
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerFOG(const u32* data)
|
|
{
|
|
GIFPackedFOG* r = (GIFPackedFOG*)(data);
|
|
gs.regs.FOG.F = r->F;
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerA_D(const u32* data)
|
|
{
|
|
GIFPackedA_D* r = (GIFPackedA_D*)(data);
|
|
|
|
GIFRegHandlers[r->ADDR](data);
|
|
}
|
|
|
|
void __gifCall GIFPackedRegHandlerNOP(const u32* data)
|
|
{
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerNull(const u32* data)
|
|
{
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerRGBAQ(const u32* data)
|
|
{
|
|
GIFRegRGBAQ* r = (GIFRegRGBAQ*)(data);
|
|
gs.regs.RGBAQ._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerST(const u32* data)
|
|
{
|
|
GIFRegST* r = (GIFRegST*)(data);
|
|
gs.regs.ST._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerUV(const u32* data)
|
|
{
|
|
GIFRegUV* r = (GIFRegUV*)(data);
|
|
gs.regs.UV._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerXYZF2(const u32* data)
|
|
{
|
|
GIFRegXYZF* r = (GIFRegXYZF*)(data);
|
|
gs.regs.XYZF._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerXYZ2(const u32* data)
|
|
{
|
|
GIFRegXYZ* r = (GIFRegXYZ*)(data);
|
|
gs.regs.XYZ._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerTEX0(const u32* data)
|
|
{
|
|
GIFRegTEX0* r = (GIFRegTEX0*)(data);
|
|
gs.ctxt_regs[i].TEX0._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerCLAMP(const u32* data)
|
|
{
|
|
GIFRegCLAMP* r = (GIFRegCLAMP*)(data);
|
|
gs.ctxt_regs[i].CLAMP._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerFOG(const u32* data)
|
|
{
|
|
GIFRegFOG* r = (GIFRegFOG*)(data);
|
|
gs.regs.FOG.F = r->F;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerXYZF3(const u32* data)
|
|
{
|
|
GIFRegXYZF* r = (GIFRegXYZF*)(data);
|
|
gs.regs.XYZF._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerXYZ3(const u32* data)
|
|
{
|
|
GIFRegXYZ* r = (GIFRegXYZ*)(data);
|
|
gs.regs.XYZ._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerNOP(const u32* data)
|
|
{
|
|
}
|
|
|
|
template <u32 i>
|
|
void __fastcall GIFRegHandlerTEX1(const u32* data)
|
|
{
|
|
GIFRegTEX1* r = (GIFRegTEX1*)(data);
|
|
gs.ctxt_regs[i].TEX1._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerTEX2(const u32* data)
|
|
{
|
|
GIFRegTEX2* r = (GIFRegTEX2*)(data);
|
|
gs.ctxt_regs[i].TEX2._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerXYOFFSET(const u32* data)
|
|
{
|
|
GIFRegXYOFFSET* r = (GIFRegXYOFFSET*)(data);
|
|
gs.ctxt_regs[i].XYOFFSET.OFX = r->OFX;
|
|
gs.ctxt_regs[i].XYOFFSET.OFY = r->OFY;
|
|
}
|
|
|
|
// Fill out the vertex queue(prim) and the attributes.
|
|
void __gifCall GIFRegHandlerPRIM(const u32 *data)
|
|
{
|
|
GIFRegPRIM* r = (GIFRegPRIM*)(data);
|
|
gs.regs.PRIM._u64 = r->_u64;
|
|
}
|
|
|
|
// Fill out an alternate set of attributes.
|
|
void __gifCall GIFRegHandlerPRMODE(const u32* data)
|
|
{
|
|
GIFRegPRMODE* r = (GIFRegPRMODE*)(data);
|
|
gs.regs.PRMODE._u64 = r->_u64;
|
|
}
|
|
|
|
// Switch between the primary set of attributes and the secondary.
|
|
void __gifCall GIFRegHandlerPRMODECONT(const u32* data)
|
|
{
|
|
GIFRegPRMODECONT* r = (GIFRegPRMODECONT*)(data);
|
|
gs.regs.PRMODECONT._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerTEXCLUT(const u32* data)
|
|
{
|
|
GIFRegTEXCLUT* r = (GIFRegTEXCLUT*)(data);
|
|
gs.regs.TEXCLUT._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerSCANMSK(const u32* data)
|
|
{
|
|
GIFRegSCANMSK* r = (GIFRegSCANMSK*)(data);
|
|
gs.regs.SCANMSK._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerMIPTBP1(const u32* data)
|
|
{
|
|
GIFRegMIPTBP1* r = (GIFRegMIPTBP1*)(data);
|
|
gs.ctxt_regs[i].MIPTBP1._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerMIPTBP2(const u32* data)
|
|
{
|
|
GIFRegMIPTBP2* r = (GIFRegMIPTBP2*)(data);
|
|
gs.ctxt_regs[i].MIPTBP2._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerTEXA(const u32* data)
|
|
{
|
|
GIFRegTEXA* r = (GIFRegTEXA*)(data);
|
|
gs.regs.TEXA._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerFOGCOL(const u32* data)
|
|
{
|
|
GIFRegFOGCOL* r = (GIFRegFOGCOL*)(data);
|
|
gs.regs.FOGCOL._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerTEXFLUSH(const u32* data)
|
|
{
|
|
GIFRegTEXFLUSH* r = (GIFRegTEXFLUSH*)(data);
|
|
gs.regs.TEXFLUSH._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerSCISSOR(const u32* data)
|
|
{
|
|
GIFRegSCISSOR* r = (GIFRegSCISSOR*)(data);
|
|
gs.ctxt_regs[i].SCISSOR._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerALPHA(const u32* data)
|
|
{
|
|
GIFRegALPHA* r = (GIFRegALPHA*)(data);
|
|
gs.ctxt_regs[i].ALPHA._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerDIMX(const u32* data)
|
|
{
|
|
GIFRegDIMX* r = (GIFRegDIMX*)(data);
|
|
gs.regs.DIMX._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerDTHE(const u32* data)
|
|
{
|
|
GIFRegDTHE* r = (GIFRegDTHE*)(data);
|
|
gs.regs.DTHE._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerCOLCLAMP(const u32* data)
|
|
{
|
|
GIFRegCOLCLAMP* r = (GIFRegCOLCLAMP*)(data);
|
|
gs.regs.COLCLAMP._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerTEST(const u32* data)
|
|
{
|
|
GIFRegTEST* r = (GIFRegTEST*)(data);
|
|
gs.ctxt_regs[i].TEST._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerPABE(const u32* data)
|
|
{
|
|
GIFRegPABE* r = (GIFRegPABE*)(data);
|
|
gs.regs.PABE._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerFBA(const u32* data)
|
|
{
|
|
GIFRegFBA* r = (GIFRegFBA*)(data);
|
|
gs.ctxt_regs[i].FBA._u64 = r->_u64;
|
|
}
|
|
|
|
template<u32 i>
|
|
void __gifCall GIFRegHandlerFRAME(const u32* data)
|
|
{
|
|
GIFRegFRAME* r = (GIFRegFRAME*)(data);
|
|
gs.ctxt_regs[i].FRAME._u64 = r->_u64;
|
|
}
|
|
|
|
template <u32 i>
|
|
void __gifCall GIFRegHandlerZBUF(const u32* data)
|
|
{
|
|
GIFRegZBUF* r = (GIFRegZBUF*)(data);
|
|
gs.ctxt_regs[i].ZBUF._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerBITBLTBUF(const u32* data)
|
|
{
|
|
GIFRegBITBLTBUF* r = (GIFRegBITBLTBUF*)(data);
|
|
gs.regs.BITBLTBUF._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerTRXPOS(const u32* data)
|
|
{
|
|
GIFRegTRXPOS* r = (GIFRegTRXPOS*)(data);
|
|
gs.regs.TRXPOS._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerTRXREG(const u32* data)
|
|
{
|
|
GIFRegTRXREG* r = (GIFRegTRXREG*)(data);
|
|
gs.regs.TRXREG._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerTRXDIR(const u32* data)
|
|
{
|
|
GIFRegTRXDIR* r = (GIFRegTRXDIR*)(data);
|
|
gs.regs.TRXDIR._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerHWREG(const u32* data)
|
|
{
|
|
GIFRegHWREG* r = (GIFRegHWREG*)(data);
|
|
gs.regs.HWREG._u64 = r->_u64;
|
|
}
|
|
|
|
|
|
void __gifCall GIFRegHandlerSIGNAL(const u32* data)
|
|
{
|
|
GIFRegSIGNAL* r = (GIFRegSIGNAL*)(data);
|
|
gs.regs.SIGNAL._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerFINISH(const u32* data)
|
|
{
|
|
GIFRegFINISH* r = (GIFRegFINISH*)(data);
|
|
gs.regs.FINISH._u64 = r->_u64;
|
|
}
|
|
|
|
void __gifCall GIFRegHandlerLABEL(const u32* data)
|
|
{
|
|
GIFRegLABEL* r = (GIFRegLABEL*)(data);
|
|
gs.regs.LABEL._u64 = r->_u64;
|
|
}
|
|
|
|
|
|
void SetMultithreaded()
|
|
{
|
|
// Some older versions of PCSX2 didn't properly set the irq callback to NULL
|
|
// in multithreaded mode (possibly because ZeroGS itself would assert in such
|
|
// cases), and didn't bind them to a dummy callback either. PCSX2 handles all
|
|
// IRQs internally when multithreaded anyway -- so let's ignore them here:
|
|
|
|
if (gs.MultiThreaded)
|
|
{
|
|
GIFRegHandlers[GIF_A_D_REG_SIGNAL] = &GIFRegHandlerNull;
|
|
GIFRegHandlers[GIF_A_D_REG_FINISH] = &GIFRegHandlerNull;
|
|
GIFRegHandlers[GIF_A_D_REG_LABEL] = &GIFRegHandlerNull;
|
|
}
|
|
else
|
|
{
|
|
GIFRegHandlers[GIF_A_D_REG_SIGNAL] = &GIFRegHandlerSIGNAL;
|
|
GIFRegHandlers[GIF_A_D_REG_FINISH] = &GIFRegHandlerFINISH;
|
|
GIFRegHandlers[GIF_A_D_REG_LABEL] = &GIFRegHandlerLABEL;
|
|
}
|
|
}
|
|
|
|
void ResetRegs()
|
|
{
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
GIFPackedRegHandlers[i] = &GIFPackedRegHandlerNull;
|
|
}
|
|
|
|
GIFPackedRegHandlers[GIF_REG_PRIM] = &GIFPackedRegHandlerPRIM;
|
|
GIFPackedRegHandlers[GIF_REG_RGBA] = &GIFPackedRegHandlerRGBA;
|
|
GIFPackedRegHandlers[GIF_REG_STQ] = &GIFPackedRegHandlerSTQ;
|
|
GIFPackedRegHandlers[GIF_REG_UV] = &GIFPackedRegHandlerUV;
|
|
GIFPackedRegHandlers[GIF_REG_XYZF2] = &GIFPackedRegHandlerXYZF2;
|
|
GIFPackedRegHandlers[GIF_REG_XYZ2] = &GIFPackedRegHandlerXYZ2;
|
|
GIFPackedRegHandlers[GIF_REG_TEX0_1] = &GIFPackedRegHandlerTEX0<0>;
|
|
GIFPackedRegHandlers[GIF_REG_TEX0_2] = &GIFPackedRegHandlerTEX0<1>;
|
|
GIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GIFPackedRegHandlerCLAMP<0>;
|
|
GIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GIFPackedRegHandlerCLAMP<1>;
|
|
GIFPackedRegHandlers[GIF_REG_FOG] = &GIFPackedRegHandlerFOG;
|
|
GIFPackedRegHandlers[GIF_REG_XYZF3] = &GIFPackedRegHandlerXYZF3;
|
|
GIFPackedRegHandlers[GIF_REG_XYZ3] = &GIFPackedRegHandlerXYZ3;
|
|
GIFPackedRegHandlers[GIF_REG_A_D] = &GIFPackedRegHandlerA_D;
|
|
GIFPackedRegHandlers[GIF_REG_NOP] = &GIFPackedRegHandlerNOP;
|
|
|
|
for (int i = 0; i < 256; i++)
|
|
{
|
|
GIFRegHandlers[i] = &GIFRegHandlerNull;
|
|
}
|
|
|
|
GIFRegHandlers[GIF_A_D_REG_PRIM] = &GIFRegHandlerPRIM;
|
|
GIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GIFRegHandlerRGBAQ;
|
|
GIFRegHandlers[GIF_A_D_REG_ST] = &GIFRegHandlerST;
|
|
GIFRegHandlers[GIF_A_D_REG_UV] = &GIFRegHandlerUV;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZF2] = &GIFRegHandlerXYZF2;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZ2] = &GIFRegHandlerXYZ2;
|
|
GIFRegHandlers[GIF_A_D_REG_TEX0_1] = &GIFRegHandlerTEX0<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_TEX0_2] = &GIFRegHandlerTEX0<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_CLAMP_1] = &GIFRegHandlerCLAMP<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_CLAMP_2] = &GIFRegHandlerCLAMP<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_FOG] = &GIFRegHandlerFOG;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZF3] = &GIFRegHandlerXYZF3;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZ3] = &GIFRegHandlerXYZ3;
|
|
GIFRegHandlers[GIF_A_D_REG_NOP] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_TEX1_1] = &GIFRegHandlerTEX1<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_TEX1_2] = &GIFRegHandlerTEX1<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_TEX2_1] = &GIFRegHandlerTEX2<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_TEX2_2] = &GIFRegHandlerTEX2<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_XYOFFSET_1] = &GIFRegHandlerXYOFFSET<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_XYOFFSET_2] = &GIFRegHandlerXYOFFSET<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GIFRegHandlerPRMODECONT;
|
|
GIFRegHandlers[GIF_A_D_REG_PRMODE] = &GIFRegHandlerPRMODE;
|
|
GIFRegHandlers[GIF_A_D_REG_TEXCLUT] = &GIFRegHandlerTEXCLUT;
|
|
GIFRegHandlers[GIF_A_D_REG_SCANMSK] = &GIFRegHandlerSCANMSK;
|
|
GIFRegHandlers[GIF_A_D_REG_MIPTBP1_1] = &GIFRegHandlerMIPTBP1<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_MIPTBP1_2] = &GIFRegHandlerMIPTBP1<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_MIPTBP2_1] = &GIFRegHandlerMIPTBP2<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_MIPTBP2_2] = &GIFRegHandlerMIPTBP2<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_TEXA] = &GIFRegHandlerTEXA;
|
|
GIFRegHandlers[GIF_A_D_REG_FOGCOL] = &GIFRegHandlerFOGCOL;
|
|
GIFRegHandlers[GIF_A_D_REG_TEXFLUSH] = &GIFRegHandlerTEXFLUSH;
|
|
GIFRegHandlers[GIF_A_D_REG_SCISSOR_1] = &GIFRegHandlerSCISSOR<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_SCISSOR_2] = &GIFRegHandlerSCISSOR<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_ALPHA_1] = &GIFRegHandlerALPHA<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_ALPHA_2] = &GIFRegHandlerALPHA<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_DIMX] = &GIFRegHandlerDIMX;
|
|
GIFRegHandlers[GIF_A_D_REG_DTHE] = &GIFRegHandlerDTHE;
|
|
GIFRegHandlers[GIF_A_D_REG_COLCLAMP] = &GIFRegHandlerCOLCLAMP;
|
|
GIFRegHandlers[GIF_A_D_REG_TEST_1] = &GIFRegHandlerTEST<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_TEST_2] = &GIFRegHandlerTEST<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_PABE] = &GIFRegHandlerPABE;
|
|
GIFRegHandlers[GIF_A_D_REG_FBA_1] = &GIFRegHandlerFBA<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_FBA_2] = &GIFRegHandlerFBA<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_FRAME_1] = &GIFRegHandlerFRAME<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_FRAME_2] = &GIFRegHandlerFRAME<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_ZBUF_1] = &GIFRegHandlerZBUF<0>;
|
|
GIFRegHandlers[GIF_A_D_REG_ZBUF_2] = &GIFRegHandlerZBUF<1>;
|
|
GIFRegHandlers[GIF_A_D_REG_BITBLTBUF] = &GIFRegHandlerBITBLTBUF;
|
|
GIFRegHandlers[GIF_A_D_REG_TRXPOS] = &GIFRegHandlerTRXPOS;
|
|
GIFRegHandlers[GIF_A_D_REG_TRXREG] = &GIFRegHandlerTRXREG;
|
|
GIFRegHandlers[GIF_A_D_REG_TRXDIR] = &GIFRegHandlerTRXDIR;
|
|
GIFRegHandlers[GIF_A_D_REG_HWREG] = &GIFRegHandlerHWREG;
|
|
SetMultithreaded();
|
|
}
|
|
|
|
void SetFrameSkip(bool skip)
|
|
{
|
|
if (skip)
|
|
{
|
|
GIFPackedRegHandlers[GIF_REG_PRIM] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_RGBA] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_STQ] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_UV] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_XYZF2] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_XYZ2] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_FOG] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_XYZF3] = &GIFPackedRegHandlerNOP;
|
|
GIFPackedRegHandlers[GIF_REG_XYZ3] = &GIFPackedRegHandlerNOP;
|
|
|
|
GIFRegHandlers[GIF_A_D_REG_PRIM] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_ST] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_UV] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZF2] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZ2] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZF3] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZ3] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GIFRegHandlerNOP;
|
|
GIFRegHandlers[GIF_A_D_REG_PRMODE] = &GIFRegHandlerNOP;
|
|
}
|
|
else
|
|
{
|
|
GIFPackedRegHandlers[GIF_REG_PRIM] = &GIFPackedRegHandlerPRIM;
|
|
GIFPackedRegHandlers[GIF_REG_RGBA] = &GIFPackedRegHandlerRGBA;
|
|
GIFPackedRegHandlers[GIF_REG_STQ] = &GIFPackedRegHandlerSTQ;
|
|
GIFPackedRegHandlers[GIF_REG_UV] = &GIFPackedRegHandlerUV;
|
|
GIFPackedRegHandlers[GIF_REG_XYZF2] = &GIFPackedRegHandlerXYZF2;
|
|
GIFPackedRegHandlers[GIF_REG_XYZ2] = &GIFPackedRegHandlerXYZ2;
|
|
GIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GIFPackedRegHandlerCLAMP<0>;
|
|
GIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GIFPackedRegHandlerCLAMP<1>;
|
|
GIFPackedRegHandlers[GIF_REG_FOG] = &GIFPackedRegHandlerFOG;
|
|
GIFPackedRegHandlers[GIF_REG_XYZF3] = &GIFPackedRegHandlerXYZF3;
|
|
GIFPackedRegHandlers[GIF_REG_XYZ3] = &GIFPackedRegHandlerXYZ3;
|
|
|
|
GIFRegHandlers[GIF_A_D_REG_PRIM] = &GIFRegHandlerPRIM;
|
|
GIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GIFRegHandlerRGBAQ;
|
|
GIFRegHandlers[GIF_A_D_REG_ST] = &GIFRegHandlerST;
|
|
GIFRegHandlers[GIF_A_D_REG_UV] = &GIFRegHandlerUV;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZF2] = &GIFRegHandlerXYZF2;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZ2] = &GIFRegHandlerXYZ2;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZF3] = &GIFRegHandlerXYZF3;
|
|
GIFRegHandlers[GIF_A_D_REG_XYZ3] = &GIFRegHandlerXYZ3;
|
|
GIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GIFRegHandlerPRMODECONT;
|
|
GIFRegHandlers[GIF_A_D_REG_PRMODE] = &GIFRegHandlerPRMODE;
|
|
}
|
|
}
|