pcsx2/plugins/GSnull/Registers.cpp

539 lines
17 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;
}
}