diff --git a/plugins/GSnull/CMakeLists.txt b/plugins/GSnull/CMakeLists.txt index 7f92b56ff3..a702e3d706 100644 --- a/plugins/GSnull/CMakeLists.txt +++ b/plugins/GSnull/CMakeLists.txt @@ -41,7 +41,8 @@ endif(CMAKE_BUILD_TYPE STREQUAL Release) # GSnull sources set(GSnullSources GifTransfer.cpp - GS.cpp) + GS.cpp + Registers.cpp) # GSnull headers set(GSnullHeaders diff --git a/plugins/GSnull/GS.cpp b/plugins/GSnull/GS.cpp index 1749b2d473..3b6ffe2cc7 100644 --- a/plugins/GSnull/GS.cpp +++ b/plugins/GSnull/GS.cpp @@ -49,6 +49,10 @@ GSVars gs; #endif void (*GSirq)(); +extern void ResetRegs(); +extern void SetMultithreaded(); +extern void SetFrameSkip(bool skip); +extern void InitPath(); EXPORT_C_(u32) PS2EgetLibType() { @@ -163,7 +167,11 @@ EXPORT_C_(s32) GSopen(void *pDsp, char *Title, int multithread) //assert( GSirq != NULL ); err = GSOpenWindow(pDsp, Title); + gs.MultiThreaded = multithread; + ResetRegs(); + SetMultithreaded(); + InitPath(); SysPrintf("Opening GSnull\n"); return err; } @@ -175,6 +183,11 @@ EXPORT_C_(s32) GSopen2( void *pDsp, u32 flags ) GSOpenWindow2(pDsp, flags); + gs.MultiThreaded = true; + + ResetRegs(); + SetMultithreaded(); + InitPath(); SysPrintf("Opening GSnull (2)\n"); return 0; } @@ -265,6 +278,7 @@ EXPORT_C_(void) GSsetGameCRC(int crc, int gameoptions) // controls frame skipping in the GS, if this routine isn't present, frame skipping won't be done EXPORT_C_(void) GSsetFrameSkip(int frameskip) { + SetFrameSkip(frameskip != 0); SysPrintf("Frameskip set to %d.\n", frameskip); } diff --git a/plugins/GSnull/GS.h b/plugins/GSnull/GS.h index 4ae5cfc9bd..b64328577f 100644 --- a/plugins/GSnull/GS.h +++ b/plugins/GSnull/GS.h @@ -37,12 +37,6 @@ typedef struct _keyEvent keyEvent; #include "GifTransfer.h" #include "null/GSnull.h" -/*#ifdef _MSC_VER -#define EXPORT_C_(type) extern "C" __declspec(dllexport) type CALLBACK -#else -#define EXPORT_C_(type) extern "C" type -#endif*/ - #ifdef _MSC_VER #define EXPORT_C_(type) extern "C" type CALLBACK #else @@ -66,6 +60,9 @@ typedef struct u32 imageTransfer; int MultiThreaded; int nPath3Hack; + + GIFReg regs; + GIFCTXTReg ctxt_regs[2]; } GSVars; extern GSVars gs; diff --git a/plugins/GSnull/GifTransfer.cpp b/plugins/GSnull/GifTransfer.cpp index 0060ceb980..3c940c93df 100644 --- a/plugins/GSnull/GifTransfer.cpp +++ b/plugins/GSnull/GifTransfer.cpp @@ -224,3 +224,9 @@ EXPORT_C_(void) GSgifTransfer(const u32 *pMem, u32 size) _GSgifTransfer<3>(const_cast(pMem), size); #endif } + +void InitPath() +{ + gs.path[0].mode = gs.path[1].mode = gs.path[2].mode = gs.path[3].mode = 0; +} + diff --git a/plugins/GSnull/GifTransfer.h b/plugins/GSnull/GifTransfer.h index db064f4740..9fbaff5e52 100644 --- a/plugins/GSnull/GifTransfer.h +++ b/plugins/GSnull/GifTransfer.h @@ -124,7 +124,7 @@ extern void _GSgifPacket(pathInfo *path, const u32 *pMem); extern void _GSgifRegList(pathInfo *path, const u32 *pMem); template extern void _GSgifTransfer(const u32 *pMem, u32 size); -/*extern GIFRegHandler g_GIFPackedRegHandlers[]; +extern GIFRegHandler g_GIFPackedRegHandlers[]; extern GIFRegHandler g_GIFRegHandlers[]; -extern void InitPath();*/ +/*extern void InitPath();*/ #endif // GIFTRANSFER_H_INCLUDED diff --git a/plugins/GSnull/Linux/GSnull.cbp b/plugins/GSnull/Linux/GSnull.cbp index 7bf155e1bf..2d9a09231e 100644 --- a/plugins/GSnull/Linux/GSnull.cbp +++ b/plugins/GSnull/Linux/GSnull.cbp @@ -59,6 +59,7 @@ + diff --git a/plugins/GSnull/Registers.cpp b/plugins/GSnull/Registers.cpp new file mode 100644 index 0000000000..e9df5d80d5 --- /dev/null +++ b/plugins/GSnull/Registers.cpp @@ -0,0 +1,546 @@ +/* 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 g_GIFPackedRegHandlers[16]; +GIFRegHandler g_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 +void __gifCall GIFPackedRegHandlerTEX0(const u32* data) +{ + GIFRegHandlerTEX0(data); +} + +template +void __gifCall GIFPackedRegHandlerCLAMP(const u32* data) +{ + GIFRegHandlerCLAMP(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); + + g_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 +void __gifCall GIFRegHandlerTEX0(const u32* data) +{ + GIFRegTEX0* r = (GIFRegTEX0*)(data); + gs.ctxt_regs[i].TEX0._u64 = r->_u64; +} + +template +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 +void __fastcall GIFRegHandlerTEX1(const u32* data) +{ + GIFRegTEX1* r = (GIFRegTEX1*)(data); + gs.ctxt_regs[i].TEX1._u64 = r->_u64; +} + +template +void __gifCall GIFRegHandlerTEX2(const u32* data) +{ + GIFRegTEX2* r = (GIFRegTEX2*)(data); + gs.ctxt_regs[i].TEX2._u64 = r->_u64; +} + +template +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 +void __gifCall GIFRegHandlerMIPTBP1(const u32* data) +{ + GIFRegMIPTBP1* r = (GIFRegMIPTBP1*)(data); + gs.ctxt_regs[i].MIPTBP1._u64 = r->_u64; +} + +template +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 +void __gifCall GIFRegHandlerSCISSOR(const u32* data) +{ + GIFRegSCISSOR* r = (GIFRegSCISSOR*)(data); + gs.ctxt_regs[i].SCISSOR._u64 = r->_u64; +} + +template +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 +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 +void __gifCall GIFRegHandlerFBA(const u32* data) +{ + GIFRegFBA* r = (GIFRegFBA*)(data); + gs.ctxt_regs[i].FBA._u64 = r->_u64; +} + +template +void __gifCall GIFRegHandlerFRAME(const u32* data) +{ + GIFRegFRAME* r = (GIFRegFRAME*)(data); + gs.ctxt_regs[i].FRAME._u64 = r->_u64; +} + +template +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) + { + g_GIFRegHandlers[GIF_A_D_REG_SIGNAL] = &GIFRegHandlerNull; + g_GIFRegHandlers[GIF_A_D_REG_FINISH] = &GIFRegHandlerNull; + g_GIFRegHandlers[GIF_A_D_REG_LABEL] = &GIFRegHandlerNull; + } + else + { + g_GIFRegHandlers[GIF_A_D_REG_SIGNAL] = &GIFRegHandlerSIGNAL; + g_GIFRegHandlers[GIF_A_D_REG_FINISH] = &GIFRegHandlerFINISH; + g_GIFRegHandlers[GIF_A_D_REG_LABEL] = &GIFRegHandlerLABEL; + } +} + +void ResetRegs() +{ + for (int i = 0; i < 16; i++) + { + g_GIFPackedRegHandlers[i] = &GIFPackedRegHandlerNull; + } + + g_GIFPackedRegHandlers[GIF_REG_PRIM] = &GIFPackedRegHandlerPRIM; + g_GIFPackedRegHandlers[GIF_REG_RGBA] = &GIFPackedRegHandlerRGBA; + g_GIFPackedRegHandlers[GIF_REG_STQ] = &GIFPackedRegHandlerSTQ; + g_GIFPackedRegHandlers[GIF_REG_UV] = &GIFPackedRegHandlerUV; + g_GIFPackedRegHandlers[GIF_REG_XYZF2] = &GIFPackedRegHandlerXYZF2; + g_GIFPackedRegHandlers[GIF_REG_XYZ2] = &GIFPackedRegHandlerXYZ2; + g_GIFPackedRegHandlers[GIF_REG_TEX0_1] = &GIFPackedRegHandlerTEX0<0>; + g_GIFPackedRegHandlers[GIF_REG_TEX0_2] = &GIFPackedRegHandlerTEX0<1>; + g_GIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GIFPackedRegHandlerCLAMP<0>; + g_GIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GIFPackedRegHandlerCLAMP<1>; + g_GIFPackedRegHandlers[GIF_REG_FOG] = &GIFPackedRegHandlerFOG; + g_GIFPackedRegHandlers[GIF_REG_XYZF3] = &GIFPackedRegHandlerXYZF3; + g_GIFPackedRegHandlers[GIF_REG_XYZ3] = &GIFPackedRegHandlerXYZ3; + g_GIFPackedRegHandlers[GIF_REG_A_D] = &GIFPackedRegHandlerA_D; + g_GIFPackedRegHandlers[GIF_REG_NOP] = &GIFPackedRegHandlerNOP; + + for (int i = 0; i < 256; i++) + { + g_GIFRegHandlers[i] = &GIFPackedRegHandlerNull; + } + + g_GIFRegHandlers[GIF_A_D_REG_PRIM] = &GIFRegHandlerPRIM; + g_GIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GIFRegHandlerRGBAQ; + g_GIFRegHandlers[GIF_A_D_REG_ST] = &GIFRegHandlerST; + g_GIFRegHandlers[GIF_A_D_REG_UV] = &GIFRegHandlerUV; + g_GIFRegHandlers[GIF_A_D_REG_XYZF2] = &GIFRegHandlerXYZF2; + g_GIFRegHandlers[GIF_A_D_REG_XYZ2] = &GIFRegHandlerXYZ2; + g_GIFRegHandlers[GIF_A_D_REG_TEX0_1] = &GIFRegHandlerTEX0<0>; + g_GIFRegHandlers[GIF_A_D_REG_TEX0_2] = &GIFRegHandlerTEX0<1>; + g_GIFRegHandlers[GIF_A_D_REG_CLAMP_1] = &GIFRegHandlerCLAMP<0>; + g_GIFRegHandlers[GIF_A_D_REG_CLAMP_2] = &GIFRegHandlerCLAMP<1>; + g_GIFRegHandlers[GIF_A_D_REG_FOG] = &GIFRegHandlerFOG; + g_GIFRegHandlers[GIF_A_D_REG_XYZF3] = &GIFRegHandlerXYZF3; + g_GIFRegHandlers[GIF_A_D_REG_XYZ3] = &GIFRegHandlerXYZ3; + g_GIFRegHandlers[GIF_A_D_REG_NOP] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_TEX1_1] = &GIFRegHandlerTEX1<0>; + g_GIFRegHandlers[GIF_A_D_REG_TEX1_2] = &GIFRegHandlerTEX1<1>; + g_GIFRegHandlers[GIF_A_D_REG_TEX2_1] = &GIFRegHandlerTEX2<0>; + g_GIFRegHandlers[GIF_A_D_REG_TEX2_2] = &GIFRegHandlerTEX2<1>; + g_GIFRegHandlers[GIF_A_D_REG_XYOFFSET_1] = &GIFRegHandlerXYOFFSET<0>; + g_GIFRegHandlers[GIF_A_D_REG_XYOFFSET_2] = &GIFRegHandlerXYOFFSET<1>; + g_GIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GIFRegHandlerPRMODECONT; + g_GIFRegHandlers[GIF_A_D_REG_PRMODE] = &GIFRegHandlerPRMODE; + g_GIFRegHandlers[GIF_A_D_REG_TEXCLUT] = &GIFRegHandlerTEXCLUT; + g_GIFRegHandlers[GIF_A_D_REG_SCANMSK] = &GIFRegHandlerSCANMSK; + g_GIFRegHandlers[GIF_A_D_REG_MIPTBP1_1] = &GIFRegHandlerMIPTBP1<0>; + g_GIFRegHandlers[GIF_A_D_REG_MIPTBP1_2] = &GIFRegHandlerMIPTBP1<1>; + g_GIFRegHandlers[GIF_A_D_REG_MIPTBP2_1] = &GIFRegHandlerMIPTBP2<0>; + g_GIFRegHandlers[GIF_A_D_REG_MIPTBP2_2] = &GIFRegHandlerMIPTBP2<1>; + g_GIFRegHandlers[GIF_A_D_REG_TEXA] = &GIFRegHandlerTEXA; + g_GIFRegHandlers[GIF_A_D_REG_FOGCOL] = &GIFRegHandlerFOGCOL; + g_GIFRegHandlers[GIF_A_D_REG_TEXFLUSH] = &GIFRegHandlerTEXFLUSH; + g_GIFRegHandlers[GIF_A_D_REG_SCISSOR_1] = &GIFRegHandlerSCISSOR<0>; + g_GIFRegHandlers[GIF_A_D_REG_SCISSOR_2] = &GIFRegHandlerSCISSOR<1>; + g_GIFRegHandlers[GIF_A_D_REG_ALPHA_1] = &GIFRegHandlerALPHA<0>; + g_GIFRegHandlers[GIF_A_D_REG_ALPHA_2] = &GIFRegHandlerALPHA<1>; + g_GIFRegHandlers[GIF_A_D_REG_DIMX] = &GIFRegHandlerDIMX; + g_GIFRegHandlers[GIF_A_D_REG_DTHE] = &GIFRegHandlerDTHE; + g_GIFRegHandlers[GIF_A_D_REG_COLCLAMP] = &GIFRegHandlerCOLCLAMP; + g_GIFRegHandlers[GIF_A_D_REG_TEST_1] = &GIFRegHandlerTEST<0>; + g_GIFRegHandlers[GIF_A_D_REG_TEST_2] = &GIFRegHandlerTEST<1>; + g_GIFRegHandlers[GIF_A_D_REG_PABE] = &GIFRegHandlerPABE; + g_GIFRegHandlers[GIF_A_D_REG_FBA_1] = &GIFRegHandlerFBA<0>; + g_GIFRegHandlers[GIF_A_D_REG_FBA_2] = &GIFRegHandlerFBA<1>; + g_GIFRegHandlers[GIF_A_D_REG_FRAME_1] = &GIFRegHandlerFRAME<0>; + g_GIFRegHandlers[GIF_A_D_REG_FRAME_2] = &GIFRegHandlerFRAME<1>; + g_GIFRegHandlers[GIF_A_D_REG_ZBUF_1] = &GIFRegHandlerZBUF<0>; + g_GIFRegHandlers[GIF_A_D_REG_ZBUF_2] = &GIFRegHandlerZBUF<1>; + g_GIFRegHandlers[GIF_A_D_REG_BITBLTBUF] = &GIFRegHandlerBITBLTBUF; + g_GIFRegHandlers[GIF_A_D_REG_TRXPOS] = &GIFRegHandlerTRXPOS; + g_GIFRegHandlers[GIF_A_D_REG_TRXREG] = &GIFRegHandlerTRXREG; + g_GIFRegHandlers[GIF_A_D_REG_TRXDIR] = &GIFRegHandlerTRXDIR; + g_GIFRegHandlers[GIF_A_D_REG_HWREG] = &GIFRegHandlerHWREG; + SetMultithreaded(); +} + +void SetFrameSkip(bool skip) +{ + if (skip) + { + g_GIFPackedRegHandlers[GIF_REG_PRIM] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_RGBA] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_STQ] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_UV] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_XYZF2] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_XYZ2] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_FOG] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_XYZF3] = &GIFPackedRegHandlerNOP; + g_GIFPackedRegHandlers[GIF_REG_XYZ3] = &GIFPackedRegHandlerNOP; + + g_GIFRegHandlers[GIF_A_D_REG_PRIM] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_ST] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_UV] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_XYZF2] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_XYZ2] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_XYZF3] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_XYZ3] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GIFRegHandlerNOP; + g_GIFRegHandlers[GIF_A_D_REG_PRMODE] = &GIFRegHandlerNOP; + } + else + { + g_GIFPackedRegHandlers[GIF_REG_PRIM] = &GIFPackedRegHandlerPRIM; + g_GIFPackedRegHandlers[GIF_REG_RGBA] = &GIFPackedRegHandlerRGBA; + g_GIFPackedRegHandlers[GIF_REG_STQ] = &GIFPackedRegHandlerSTQ; + g_GIFPackedRegHandlers[GIF_REG_UV] = &GIFPackedRegHandlerUV; + g_GIFPackedRegHandlers[GIF_REG_XYZF2] = &GIFPackedRegHandlerXYZF2; + g_GIFPackedRegHandlers[GIF_REG_XYZ2] = &GIFPackedRegHandlerXYZ2; + g_GIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GIFPackedRegHandlerCLAMP<0>; + g_GIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GIFPackedRegHandlerCLAMP<1>; + g_GIFPackedRegHandlers[GIF_REG_FOG] = &GIFPackedRegHandlerFOG; + g_GIFPackedRegHandlers[GIF_REG_XYZF3] = &GIFPackedRegHandlerXYZF3; + g_GIFPackedRegHandlers[GIF_REG_XYZ3] = &GIFPackedRegHandlerXYZ3; + + g_GIFRegHandlers[GIF_A_D_REG_PRIM] = &GIFRegHandlerPRIM; + g_GIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GIFRegHandlerRGBAQ; + g_GIFRegHandlers[GIF_A_D_REG_ST] = &GIFRegHandlerST; + g_GIFRegHandlers[GIF_A_D_REG_UV] = &GIFRegHandlerUV; + g_GIFRegHandlers[GIF_A_D_REG_XYZF2] = &GIFRegHandlerXYZF2; + g_GIFRegHandlers[GIF_A_D_REG_XYZ2] = &GIFRegHandlerXYZ2; + g_GIFRegHandlers[GIF_A_D_REG_XYZF3] = &GIFRegHandlerXYZF3; + g_GIFRegHandlers[GIF_A_D_REG_XYZ3] = &GIFRegHandlerXYZ3; + g_GIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GIFRegHandlerPRMODECONT; + g_GIFRegHandlers[GIF_A_D_REG_PRMODE] = &GIFRegHandlerPRMODE; + } +} diff --git a/plugins/GSnull/Registers.h b/plugins/GSnull/Registers.h index 60d13e089a..bb60cf085a 100644 --- a/plugins/GSnull/Registers.h +++ b/plugins/GSnull/Registers.h @@ -18,11 +18,6 @@ // These enums & structures are copied from GSdx, which got them from sp2dev 0.4.0. -// In fact, after looking at both ZeroGS and GSdx, and seeing how similar this section is on both, -// I'm just going to blatantly copy most of GS.h here and localize. - -// And if this is kept close enough to GSdx's code, if should make porting GSdx to Linux a bit easier... - // sp2dev is Copyright (C) 2002 Terratron Technologies Inc. All Rights Reserved. // http://window.terratron.com/~sosman/ps2linux/ // @@ -30,6 +25,9 @@ // http://www.gabest.org // +#ifndef __REGISTERS_H__ +#define __REGISTERS_H__ + #ifdef __cplusplus extern "C" { @@ -42,7 +40,6 @@ extern "C" #endif #include "emmintrin.h" -//#include "GifTransfer.h" #pragma pack(push, 1) @@ -128,7 +125,7 @@ enum GIF_A_D_REG // In case we want to change to/from __fastcall for GIF register handlers: #define __gifCall __fastcall -/*typedef void __gifCall FnType_GIFRegHandler(const u32* data); +typedef void __gifCall FnType_GIFRegHandler(const u32* data); typedef FnType_GIFRegHandler* GIFRegHandler; extern FnType_GIFRegHandler GIFPackedRegHandlerNull; @@ -143,10 +140,13 @@ extern FnType_GIFRegHandler GIFPackedRegHandlerNOP; // These are unimplemented, and fall back on the non-packed versions. extern FnType_GIFRegHandler GIFPackedRegHandlerPRIM; -extern FnType_GIFRegHandler GIFPackedRegHandlerTEX0_1; -extern FnType_GIFRegHandler GIFPackedRegHandlerTEX0_2; -extern FnType_GIFRegHandler GIFPackedRegHandlerCLAMP_1; -extern FnType_GIFRegHandler GIFPackedRegHandlerCLAMP_2; + +template +extern FnType_GIFRegHandler GIFPackedRegHandlerTEX0; + +template +extern FnType_GIFRegHandler GIFPackedRegHandlerCLAMP; + extern FnType_GIFRegHandler GIFPackedRegHandlerXYZF3; extern FnType_GIFRegHandler GIFPackedRegHandlerXYZ3; @@ -157,47 +157,56 @@ extern FnType_GIFRegHandler GIFRegHandlerST; extern FnType_GIFRegHandler GIFRegHandlerUV; extern FnType_GIFRegHandler GIFRegHandlerXYZF2; extern FnType_GIFRegHandler GIFRegHandlerXYZ2; -extern FnType_GIFRegHandler GIFRegHandlerTEX0_1; -extern FnType_GIFRegHandler GIFRegHandlerTEX0_2; -extern FnType_GIFRegHandler GIFRegHandlerCLAMP_1; -extern FnType_GIFRegHandler GIFRegHandlerCLAMP_2; + +template +extern FnType_GIFRegHandler GIFRegHandlerTEX0; + +template +extern FnType_GIFRegHandler GIFRegHandlerCLAMP; + extern FnType_GIFRegHandler GIFRegHandlerFOG; extern FnType_GIFRegHandler GIFRegHandlerXYZF3; extern FnType_GIFRegHandler GIFRegHandlerXYZ3; extern FnType_GIFRegHandler GIFRegHandlerNOP; -extern FnType_GIFRegHandler GIFRegHandlerTEX1_1; -extern FnType_GIFRegHandler GIFRegHandlerTEX1_2; -extern FnType_GIFRegHandler GIFRegHandlerTEX2_1; -extern FnType_GIFRegHandler GIFRegHandlerTEX2_2; -extern FnType_GIFRegHandler GIFRegHandlerXYOFFSET_1; -extern FnType_GIFRegHandler GIFRegHandlerXYOFFSET_2; + +template +extern FnType_GIFRegHandler GIFRegHandlerTEX1; + +template +extern FnType_GIFRegHandler GIFRegHandlerTEX2; + +template +extern FnType_GIFRegHandler GIFRegHandlerXYOFFSET; + extern FnType_GIFRegHandler GIFRegHandlerPRMODECONT; extern FnType_GIFRegHandler GIFRegHandlerPRMODE; extern FnType_GIFRegHandler GIFRegHandlerTEXCLUT; extern FnType_GIFRegHandler GIFRegHandlerSCANMSK; -extern FnType_GIFRegHandler GIFRegHandlerMIPTBP1_1; -extern FnType_GIFRegHandler GIFRegHandlerMIPTBP1_2; -extern FnType_GIFRegHandler GIFRegHandlerMIPTBP2_1; -extern FnType_GIFRegHandler GIFRegHandlerMIPTBP2_2; +template +extern FnType_GIFRegHandler GIFRegHandlerMIPTBP1; +template +extern FnType_GIFRegHandler GIFRegHandlerMIPTBP2; extern FnType_GIFRegHandler GIFRegHandlerTEXA; extern FnType_GIFRegHandler GIFRegHandlerFOGCOL; extern FnType_GIFRegHandler GIFRegHandlerTEXFLUSH; -extern FnType_GIFRegHandler GIFRegHandlerSCISSOR_1; -extern FnType_GIFRegHandler GIFRegHandlerSCISSOR_2; -extern FnType_GIFRegHandler GIFRegHandlerALPHA_1; -extern FnType_GIFRegHandler GIFRegHandlerALPHA_2; + +template +extern FnType_GIFRegHandler GIFRegHandlerSCISSOR; +template +extern FnType_GIFRegHandler GIFRegHandlerALPHA; + extern FnType_GIFRegHandler GIFRegHandlerDIMX; extern FnType_GIFRegHandler GIFRegHandlerDTHE; extern FnType_GIFRegHandler GIFRegHandlerCOLCLAMP; -extern FnType_GIFRegHandler GIFRegHandlerTEST_1; -extern FnType_GIFRegHandler GIFRegHandlerTEST_2; +template +extern FnType_GIFRegHandler GIFRegHandlerTEST; extern FnType_GIFRegHandler GIFRegHandlerPABE; -extern FnType_GIFRegHandler GIFRegHandlerFBA_1; -extern FnType_GIFRegHandler GIFRegHandlerFBA_2; -extern FnType_GIFRegHandler GIFRegHandlerFRAME_1; -extern FnType_GIFRegHandler GIFRegHandlerFRAME_2; -extern FnType_GIFRegHandler GIFRegHandlerZBUF_1; -extern FnType_GIFRegHandler GIFRegHandlerZBUF_2; +template +extern FnType_GIFRegHandler GIFRegHandlerFBA; +template +extern FnType_GIFRegHandler GIFRegHandlerFRAME; +template +extern FnType_GIFRegHandler GIFRegHandlerZBUF; extern FnType_GIFRegHandler GIFRegHandlerBITBLTBUF; extern FnType_GIFRegHandler GIFRegHandlerTRXPOS; extern FnType_GIFRegHandler GIFRegHandlerTRXREG; @@ -205,7 +214,7 @@ extern FnType_GIFRegHandler GIFRegHandlerTRXDIR; extern FnType_GIFRegHandler GIFRegHandlerHWREG; extern FnType_GIFRegHandler GIFRegHandlerSIGNAL; extern FnType_GIFRegHandler GIFRegHandlerFINISH; -extern FnType_GIFRegHandler GIFRegHandlerLABEL;*/ +extern FnType_GIFRegHandler GIFRegHandlerLABEL; enum GS_PRIM { @@ -1053,6 +1062,22 @@ REG64_SET(GIFReg) GIFRegZBUF ZBUF; REG_SET_END +REG64_SET(GIFCTXTReg) + GIFRegTEX0 TEX0; + GIFRegCLAMP CLAMP; + GIFRegTEX1 TEX1; + GIFRegTEX2 TEX2; + GIFRegXYOFFSET XYOFFSET; + GIFRegMIPTBP1 MIPTBP1; + GIFRegMIPTBP2 MIPTBP2; + GIFRegSCISSOR SCISSOR; + GIFRegALPHA ALPHA; + GIFRegTEST TEST; + GIFRegFBA FBA; + GIFRegFRAME FRAME; + GIFRegZBUF ZBUF; +REG_SET_END + // GIFPacked REG128_(GIFPacked, PRIM) @@ -1212,4 +1237,5 @@ struct GSPrivRegSet }; #pragma pack(pop) +#endif diff --git a/plugins/GSnull/Windows/GSnull.vcxproj b/plugins/GSnull/Windows/GSnull.vcxproj index 3a1f101944..e26ba20db6 100644 --- a/plugins/GSnull/Windows/GSnull.vcxproj +++ b/plugins/GSnull/Windows/GSnull.vcxproj @@ -74,6 +74,7 @@ + true true diff --git a/plugins/GSnull/Windows/GSnull_vc2008.vcproj b/plugins/GSnull/Windows/GSnull_vc2008.vcproj index edb38f86ce..bff4bbf56e 100644 --- a/plugins/GSnull/Windows/GSnull_vc2008.vcproj +++ b/plugins/GSnull/Windows/GSnull_vc2008.vcproj @@ -160,6 +160,10 @@ RelativePath="..\GS.cpp" > + +