[pcsx_rearmed.git] / plugins / gpu_unai / gpu_command.h

/***************************************************************************
*   Copyright (C) 2010 PCSX4ALL Team                                      *
*   Copyright (C) 2010 Unai                                               *
*                                                                         *
*   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 02111-1307 USA.           *
***************************************************************************/

///////////////////////////////////////////////////////////////////////////////
INLINE void gpuSetTexture(u16 tpage)
{
	u32 tp;
	u32 tx, ty;
	GPU_GP1 = (GPU_GP1 & ~0x1FF) | (tpage & 0x1FF);

	TextureWindow[0]&= ~TextureWindow[2];
	TextureWindow[1]&= ~TextureWindow[3];

	tp = (tpage >> 7) & 3;
	tx = (tpage & 0x0F) << 6;
	ty = (tpage & 0x10) << 4;
	if (tp == 3) tp = 2;

	tx += (TextureWindow[0] >> (2 - tp));
	ty += TextureWindow[1];
	
	BLEND_MODE  = (((tpage>>5)&0x3)     ) << 3;
	TEXT_MODE   = (((tpage>>7)&0x3) + 1 ) << 5; // +1 el cero no lo usamos

	TBA = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(tx, ty)];

}

///////////////////////////////////////////////////////////////////////////////
INLINE void gpuSetCLUT(u16 clut)
{
	CBA = &((u16*)GPU_FrameBuffer)[(clut & 0x7FFF) << 4];
}

#ifdef  ENABLE_GPU_NULL_SUPPORT
#define NULL_GPU() break
#else
#define NULL_GPU()
#endif

#ifdef  ENABLE_GPU_LOG_SUPPORT
#define DO_LOG(expr) printf expr
#else
#define DO_LOG(expr) {}
#endif

#define Blending (((PRIM&0x2)&&(blend))?(PRIM&0x2):0)
#define Blending_Mode (((PRIM&0x2)&&(blend))?BLEND_MODE:0)
#define Lighting (((~PRIM)&0x1)&&(light))

void gpuSendPacketFunction(const int PRIM)
{
	//printf("0x%x\n",PRIM);

	switch (PRIM)
	{
		case 0x02:
			NULL_GPU();
			gpuClearImage();    //  prim handles updateLace && skip
			DO_LOG(("gpuClearImage(0x%x)\n",PRIM));
			break;
		case 0x20:
		case 0x21:
		case 0x22:
		case 0x23:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawF3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB]);
				DO_LOG(("gpuDrawF3(0x%x)\n",PRIM));
			}
			break;
		case 0x24:
		case 0x25:
		case 0x26:
		case 0x27:
			if (!isSkip)
			{
				NULL_GPU();
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (PacketBuffer.U4[4] >> 16);
				if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
					gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | PixelMSB]);
				else
					gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | PixelMSB]);
				DO_LOG(("gpuDrawFT3(0x%x)\n",PRIM));
			}
			break;
		case 0x28:
		case 0x29:
		case 0x2A:
		case 0x2B:
			if (!isSkip)
			{
				NULL_GPU();
				const PP gpuPolySpanDriver  = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB];
				//--PacketBuffer.S2[6];
				gpuDrawF3(gpuPolySpanDriver);
				PacketBuffer.U4[1] = PacketBuffer.U4[4];
				//--PacketBuffer.S2[2];
				gpuDrawF3(gpuPolySpanDriver);
				DO_LOG(("gpuDrawF4(0x%x)\n",PRIM));
			}
			break;
		case 0x2C:
		case 0x2D:
		case 0x2E:
		case 0x2F:
			if (!isSkip)
			{
				NULL_GPU();
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (PacketBuffer.U4[4] >> 16);
				PP gpuPolySpanDriver;
				if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
					gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | PixelMSB];
				else
					gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | PixelMSB];
				//--PacketBuffer.S2[6];
				gpuDrawFT3(gpuPolySpanDriver);
				PacketBuffer.U4[1] = PacketBuffer.U4[7];
				PacketBuffer.U4[2] = PacketBuffer.U4[8];
				//--PacketBuffer.S2[2];
				gpuDrawFT3(gpuPolySpanDriver);
				DO_LOG(("gpuDrawFT4(0x%x)\n",PRIM));
			}
			break;
		case 0x30:
		case 0x31:
		case 0x32:
		case 0x33:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawG3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB]);
				DO_LOG(("gpuDrawG3(0x%x)\n",PRIM));
			}
			break;
		case 0x34:
		case 0x35:
		case 0x36:
		case 0x37:
			if (!isSkip)
			{
				NULL_GPU();
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (PacketBuffer.U4[5] >> 16);
				gpuDrawGT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB]);
				DO_LOG(("gpuDrawGT3(0x%x)\n",PRIM));
			}
			break;
		case 0x38:
		case 0x39:
		case 0x3A:
		case 0x3B:
			if (!isSkip)
			{
				NULL_GPU();
				const PP gpuPolySpanDriver  = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB];
				//--PacketBuffer.S2[6];
				gpuDrawG3(gpuPolySpanDriver);
				PacketBuffer.U4[0] = PacketBuffer.U4[6];
				PacketBuffer.U4[1] = PacketBuffer.U4[7];
				//--PacketBuffer.S2[2];
				gpuDrawG3(gpuPolySpanDriver);
				DO_LOG(("gpuDrawG4(0x%x)\n",PRIM));
			}
			break;
		case 0x3C:
		case 0x3D:
		case 0x3E:
		case 0x3F:
			if (!isSkip)
			{
				NULL_GPU();
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (PacketBuffer.U4[5] >> 16);
				const PP gpuPolySpanDriver  = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB];
				//--PacketBuffer.S2[6];
				gpuDrawGT3(gpuPolySpanDriver);
				PacketBuffer.U4[0] = PacketBuffer.U4[9];
				PacketBuffer.U4[1] = PacketBuffer.U4[10];
				PacketBuffer.U4[2] = PacketBuffer.U4[11];
				//--PacketBuffer.S2[2];
				gpuDrawGT3(gpuPolySpanDriver);
				DO_LOG(("gpuDrawGT4(0x%x)\n",PRIM));
			}
			break;
		case 0x40:
		case 0x41:
		case 0x42:
		case 0x43:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
				DO_LOG(("gpuDrawLF(0x%x)\n",PRIM));
			}
			break;
		case 0x48:
		case 0x49:
		case 0x4A:
		case 0x4B:
		case 0x4C:
		case 0x4D:
		case 0x4E:
		case 0x4F:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
				DO_LOG(("gpuDrawLF(0x%x)\n",PRIM));
			}
			if ((PacketBuffer.U4[3] & 0xF000F000) != 0x50005000)
			{
				PacketBuffer.U4[1] = PacketBuffer.U4[2];
				PacketBuffer.U4[2] = PacketBuffer.U4[3];
				PacketCount = 1;
				PacketIndex = 3;
			}
			break;
		case 0x50:
		case 0x51:
		case 0x52:
		case 0x53:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
				DO_LOG(("gpuDrawLG(0x%x)\n",PRIM));
			}
			break;
		case 0x58:
		case 0x59:
		case 0x5A:
		case 0x5B:
		case 0x5C:
		case 0x5D:
		case 0x5E:
		case 0x5F:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
				DO_LOG(("gpuDrawLG(0x%x)\n",PRIM));
			}
			if ((PacketBuffer.U4[4] & 0xF000F000) != 0x50005000)
			{
				PacketBuffer.U1[3 + (2 * 4)] = PacketBuffer.U1[3 + (0 * 4)];
				PacketBuffer.U4[0] = PacketBuffer.U4[2];
				PacketBuffer.U4[1] = PacketBuffer.U4[3];
				PacketBuffer.U4[2] = PacketBuffer.U4[4];
				PacketCount = 2;
				PacketIndex = 3;
			}
			break;
		case 0x60:
		case 0x61:
		case 0x62:
		case 0x63:
			if (!isSkip)
			{
				NULL_GPU();
				gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
				DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
			}
			break;
		case 0x64:
		case 0x65:
		case 0x66:
		case 0x67:
			if (!isSkip)
			{
				NULL_GPU();
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (GPU_GP1);
				if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
					gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7)  | PixelMSB]);
				else
					gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7)  | PixelMSB]);
				DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
			}
			break;
		case 0x68:
		case 0x69:
		case 0x6A:
		case 0x6B:
			if (!isSkip)
			{
				NULL_GPU();
				PacketBuffer.U4[2] = 0x00010001;
				gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
				DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
			}
			break;
		case 0x70:
		case 0x71:
		case 0x72:
		case 0x73:
			if (!isSkip)
			{
				NULL_GPU();
				PacketBuffer.U4[2] = 0x00080008;
				gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
				DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
			}
			break;
		case 0x74:
		case 0x75:
		case 0x76:
		case 0x77:
			if (!isSkip)
			{
				NULL_GPU();
				PacketBuffer.U4[3] = 0x00080008;
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (GPU_GP1);
				if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
					gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7)  | PixelMSB]);
				else
					gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7)  | PixelMSB]);
				DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
			}
			break;
		case 0x78:
		case 0x79:
		case 0x7A:
		case 0x7B:
			if (!isSkip)
			{
				NULL_GPU();
				PacketBuffer.U4[2] = 0x00100010;
				gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
				DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
			}
			break;
		case 0x7C:
		case 0x7D:
#ifdef __arm__
			if ((GPU_GP1 & 0x180) == 0 && (Masking | PixelMSB) == 0)
			{
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (GPU_GP1);
				gpuDrawS16();
				break;
			}
			// fallthrough
#endif
		case 0x7E:
		case 0x7F:
			if (!isSkip)
			{
				NULL_GPU();
				PacketBuffer.U4[3] = 0x00100010;
				gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
				gpuSetTexture (GPU_GP1);
				if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
					gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7)  | PixelMSB]);
				else
					gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7)  | PixelMSB]);
				DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
			}
			break;
		case 0x80:          //  vid -> vid
			gpuMoveImage();   //  prim handles updateLace && skip
			DO_LOG(("gpuMoveImage(0x%x)\n",PRIM));
			break;
		case 0xA0:          //  sys ->vid
			gpuLoadImage();   //  prim handles updateLace && skip
#ifndef isSkip // not a define
			if (alt_fps) isSkip=false;
#endif
			DO_LOG(("gpuLoadImage(0x%x)\n",PRIM));
			break;
		case 0xC0:          //  vid -> sys
			gpuStoreImage();  //  prim handles updateLace && skip
			DO_LOG(("gpuStoreImage(0x%x)\n",PRIM));
			break;
		case 0xE1:
			{
				const u32 temp = PacketBuffer.U4[0];
				GPU_GP1 = (GPU_GP1 & ~0x000007FF) | (temp & 0x000007FF);
				gpuSetTexture(temp);
				DO_LOG(("gpuSetTexture(0x%x)\n",PRIM));
			}
			break;
		case 0xE2:	  
			{
				static const u8  TextureMask[32] = {
					255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7,	//
					127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7	  //
				};
				const u32 temp = PacketBuffer.U4[0];
				TextureWindow[0] = ((temp >> 10) & 0x1F) << 3;
				TextureWindow[1] = ((temp >> 15) & 0x1F) << 3;
				TextureWindow[2] = TextureMask[(temp >> 0) & 0x1F];
				TextureWindow[3] = TextureMask[(temp >> 5) & 0x1F];
				gpuSetTexture(GPU_GP1);
				//isSkip = false;
				DO_LOG(("TextureWindow(0x%x)\n",PRIM));
			}
			break;
		case 0xE3:
			{
				const u32 temp = PacketBuffer.U4[0];
				DrawingArea[0] = temp         & 0x3FF;
				DrawingArea[1] = (temp >> 10) & 0x3FF;
				//isSkip = false;
				DO_LOG(("DrawingArea_Pos(0x%x)\n",PRIM));
			}
			break;
		case 0xE4:
			{
				const u32 temp = PacketBuffer.U4[0];
				DrawingArea[2] = (temp         & 0x3FF) + 1;
				DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1;
				//isSkip = false;
				DO_LOG(("DrawingArea_Size(0x%x)\n",PRIM));
			}
			break;
		case 0xE5:
			{
				const u32 temp = PacketBuffer.U4[0];
				DrawingOffset[0] = ((s32)temp<<(32-11))>>(32-11);
				DrawingOffset[1] = ((s32)temp<<(32-22))>>(32-11);
				//isSkip = false;
				DO_LOG(("DrawingOffset(0x%x)\n",PRIM));
			}
			break;
		case 0xE6:
			{
				const u32 temp = PacketBuffer.U4[0];
				//GPU_GP1 = (GPU_GP1 & ~0x00001800) | ((temp&3) << 11);
				Masking = (temp & 0x2) <<  1;
				PixelMSB =(temp & 0x1) <<  8;
				DO_LOG(("SetMask(0x%x)\n",PRIM));
			}
			break;
	}
}
Commit	Line	Data
86aad47b	1	/***************************************************************************
	2	* Copyright (C) 2010 PCSX4ALL Team *
	3	* Copyright (C) 2010 Unai *
	4	* *
	5	* This program is free software; you can redistribute it and/or modify *
	6	* it under the terms of the GNU General Public License as published by *
	7	* the Free Software Foundation; either version 2 of the License, or *
	8	* (at your option) any later version. *
	9	* *
	10	* This program is distributed in the hope that it will be useful, *
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	13	* GNU General Public License for more details. *
	14	* *
	15	* You should have received a copy of the GNU General Public License *
	16	* along with this program; if not, write to the *
	17	* Free Software Foundation, Inc., *
	18	* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
	19	***************************************************************************/
	20
	21	///////////////////////////////////////////////////////////////////////////////
	22	INLINE void gpuSetTexture(u16 tpage)
	23	{
4144e9ab	24	u32 tp;
	25	u32 tx, ty;
	26	GPU_GP1 = (GPU_GP1 & ~0x1FF) \| (tpage & 0x1FF);
86aad47b	27
	28	TextureWindow[0]&= ~TextureWindow[2];
	29	TextureWindow[1]&= ~TextureWindow[3];
	30
	31	tp = (tpage >> 7) & 3;
	32	tx = (tpage & 0x0F) << 6;
	33	ty = (tpage & 0x10) << 4;
4144e9ab	34	if (tp == 3) tp = 2;
86aad47b	35
	36	tx += (TextureWindow[0] >> (2 - tp));
	37	ty += TextureWindow[1];
	38
	39	BLEND_MODE = (((tpage>>5)&0x3) ) << 3;
	40	TEXT_MODE = (((tpage>>7)&0x3) + 1 ) << 5; // +1 el cero no lo usamos
	41
	42	TBA = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(tx, ty)];
	43
	44	}
	45
	46	///////////////////////////////////////////////////////////////////////////////
	47	INLINE void gpuSetCLUT(u16 clut)
	48	{
	49	CBA = &((u16*)GPU_FrameBuffer)[(clut & 0x7FFF) << 4];
	50	}
	51
	52	#ifdef ENABLE_GPU_NULL_SUPPORT
	53	#define NULL_GPU() break
	54	#else
	55	#define NULL_GPU()
	56	#endif
	57
	58	#ifdef ENABLE_GPU_LOG_SUPPORT
	59	#define DO_LOG(expr) printf expr
	60	#else
	61	#define DO_LOG(expr) {}
	62	#endif
	63
	64	#define Blending (((PRIM&0x2)&&(blend))?(PRIM&0x2):0)
	65	#define Blending_Mode (((PRIM&0x2)&&(blend))?BLEND_MODE:0)
	66	#define Lighting (((~PRIM)&0x1)&&(light))
	67
	68	void gpuSendPacketFunction(const int PRIM)
	69	{
	70	//printf("0x%x\n",PRIM);
	71
	72	switch (PRIM)
	73	{
	74	case 0x02:
	75	NULL_GPU();
	76	gpuClearImage(); // prim handles updateLace && skip
	77	DO_LOG(("gpuClearImage(0x%x)\n",PRIM));
	78	break;
	79	case 0x20:
	80	case 0x21:
	81	case 0x22:
	82	case 0x23:
	83	if (!isSkip)
	84	{
	85	NULL_GPU();
	86	gpuDrawF3(gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| PixelMSB]);
	87	DO_LOG(("gpuDrawF3(0x%x)\n",PRIM));
	88	}
	89	break;
	90	case 0x24:
	91	case 0x25:
	92	case 0x26:
	93	case 0x27:
	94	if (!isSkip)
	95	{
	96	NULL_GPU();
	97	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	98	gpuSetTexture (PacketBuffer.U4[4] >> 16);
99	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
100	gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| PixelMSB]);
101	else
102	gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| PixelMSB]);
103	DO_LOG(("gpuDrawFT3(0x%x)\n",PRIM));
104	}
105	break;
106	case 0x28:
107	case 0x29:
108	case 0x2A:
109	case 0x2B:
110	if (!isSkip)
111	{
112	NULL_GPU();
113	const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| PixelMSB];
114	//--PacketBuffer.S2[6];
115	gpuDrawF3(gpuPolySpanDriver);
116	PacketBuffer.U4[1] = PacketBuffer.U4[4];
117	//--PacketBuffer.S2[2];
118	gpuDrawF3(gpuPolySpanDriver);
119	DO_LOG(("gpuDrawF4(0x%x)\n",PRIM));
120	}
121	break;
122	case 0x2C:
123	case 0x2D:
124	case 0x2E:
125	case 0x2F:
126	if (!isSkip)
127	{
128	NULL_GPU();
129	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
130	gpuSetTexture (PacketBuffer.U4[4] >> 16);
131	PP gpuPolySpanDriver;
132	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
133	gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| PixelMSB];
134	else
135	gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| PixelMSB];
136	//--PacketBuffer.S2[6];
137	gpuDrawFT3(gpuPolySpanDriver);
138	PacketBuffer.U4[1] = PacketBuffer.U4[7];
139	PacketBuffer.U4[2] = PacketBuffer.U4[8];
140	//--PacketBuffer.S2[2];
141	gpuDrawFT3(gpuPolySpanDriver);
142	DO_LOG(("gpuDrawFT4(0x%x)\n",PRIM));
143	}
144	break;
145	case 0x30:
146	case 0x31:
147	case 0x32:
148	case 0x33:
149	if (!isSkip)
150	{
151	NULL_GPU();
152	gpuDrawG3(gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| 129 \| PixelMSB]);
153	DO_LOG(("gpuDrawG3(0x%x)\n",PRIM));
154	}
155	break;
156	case 0x34:
157	case 0x35:
158	case 0x36:
159	case 0x37:
160	if (!isSkip)
161	{
162	NULL_GPU();
163	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
164	gpuSetTexture (PacketBuffer.U4[5] >> 16);
165	gpuDrawGT3(gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| ((Lighting)?129:0) \| PixelMSB]);
166	DO_LOG(("gpuDrawGT3(0x%x)\n",PRIM));
167	}
168	break;
169	case 0x38:
170	case 0x39:
171	case 0x3A:
172	case 0x3B:
173	if (!isSkip)
174	{
175	NULL_GPU();
176	const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| 129 \| PixelMSB];
177	//--PacketBuffer.S2[6];
178	gpuDrawG3(gpuPolySpanDriver);
179	PacketBuffer.U4[0] = PacketBuffer.U4[6];
180	PacketBuffer.U4[1] = PacketBuffer.U4[7];
181	//--PacketBuffer.S2[2];
182	gpuDrawG3(gpuPolySpanDriver);
183	DO_LOG(("gpuDrawG4(0x%x)\n",PRIM));
184	}
185	break;
186	case 0x3C:
187	case 0x3D:
188	case 0x3E:
189	case 0x3F:
190	if (!isSkip)
191	{
192	NULL_GPU();
193	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
194	gpuSetTexture (PacketBuffer.U4[5] >> 16);
195	const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| ((Lighting)?129:0) \| PixelMSB];
196	//--PacketBuffer.S2[6];
197	gpuDrawGT3(gpuPolySpanDriver);
198	PacketBuffer.U4[0] = PacketBuffer.U4[9];
199	PacketBuffer.U4[1] = PacketBuffer.U4[10];
200	PacketBuffer.U4[2] = PacketBuffer.U4[11];
201	//--PacketBuffer.S2[2];
202	gpuDrawGT3(gpuPolySpanDriver);
203	DO_LOG(("gpuDrawGT4(0x%x)\n",PRIM));
204	}
205	break;
206	case 0x40:
207	case 0x41:
208	case 0x42:
209	case 0x43:
210	if (!isSkip)
211	{
212	NULL_GPU();
213	gpuDrawLF(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
214	DO_LOG(("gpuDrawLF(0x%x)\n",PRIM));
215	}
216	break;
217	case 0x48:
218	case 0x49:
219	case 0x4A:
220	case 0x4B:
221	case 0x4C:
222	case 0x4D:
223	case 0x4E:
224	case 0x4F:
225	if (!isSkip)
226	{
227	NULL_GPU();
228	gpuDrawLF(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
229	DO_LOG(("gpuDrawLF(0x%x)\n",PRIM));
230	}
231	if ((PacketBuffer.U4[3] & 0xF000F000) != 0x50005000)
232	{
233	PacketBuffer.U4[1] = PacketBuffer.U4[2];
234	PacketBuffer.U4[2] = PacketBuffer.U4[3];
235	PacketCount = 1;
236	PacketIndex = 3;
237	}
238	break;
239	case 0x50:
240	case 0x51:
241	case 0x52:
242	case 0x53:
243	if (!isSkip)
244	{
245	NULL_GPU();
246	gpuDrawLG(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
247	DO_LOG(("gpuDrawLG(0x%x)\n",PRIM));
248	}
249	break;
250	case 0x58:
251	case 0x59:
252	case 0x5A:
253	case 0x5B:
254	case 0x5C:
255	case 0x5D:
256	case 0x5E:
257	case 0x5F:
258	if (!isSkip)
259	{
260	NULL_GPU();
261	gpuDrawLG(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
262	DO_LOG(("gpuDrawLG(0x%x)\n",PRIM));
263	}
264	if ((PacketBuffer.U4[4] & 0xF000F000) != 0x50005000)
265	{
266	PacketBuffer.U1[3 + (2 * 4)] = PacketBuffer.U1[3 + (0 * 4)];
267	PacketBuffer.U4[0] = PacketBuffer.U4[2];
268	PacketBuffer.U4[1] = PacketBuffer.U4[3];
269	PacketBuffer.U4[2] = PacketBuffer.U4[4];
270	PacketCount = 2;
271	PacketIndex = 3;
272	}
273	break;
274	case 0x60:
275	case 0x61:
276	case 0x62:
277	case 0x63:
278	if (!isSkip)
279	{
280	NULL_GPU();
281	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
282	DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
283	}
284	break;
285	case 0x64:
286	case 0x65:
287	case 0x66:
288	case 0x67:
289	if (!isSkip)
290	{
291	NULL_GPU();
292	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
293	gpuSetTexture (GPU_GP1);
294	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
295	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| (enableAbbeyHack<<7) \| PixelMSB]);
296	else
297	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| (enableAbbeyHack<<7) \| PixelMSB]);
298	DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
299	}
300	break;
301	case 0x68:
302	case 0x69:
303	case 0x6A:
304	case 0x6B:
305	if (!isSkip)
306	{
307	NULL_GPU();
308	PacketBuffer.U4[2] = 0x00010001;
309	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
310	DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
311	}
312	break;
313	case 0x70:
314	case 0x71:
315	case 0x72:
316	case 0x73:
317	if (!isSkip)
318	{
319	NULL_GPU();
320	PacketBuffer.U4[2] = 0x00080008;
321	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
322	DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
323	}
324	break;
325	case 0x74:
326	case 0x75:
327	case 0x76:
328	case 0x77:
329	if (!isSkip)
330	{
331	NULL_GPU();
332	PacketBuffer.U4[3] = 0x00080008;
333	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
334	gpuSetTexture (GPU_GP1);
335	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
336	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| (enableAbbeyHack<<7) \| PixelMSB]);
337	else
338	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| (enableAbbeyHack<<7) \| PixelMSB]);
339	DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
340	}
341	break;
342	case 0x78:
343	case 0x79:
344	case 0x7A:
345	case 0x7B:
346	if (!isSkip)
347	{
348	NULL_GPU();
349	PacketBuffer.U4[2] = 0x00100010;
350	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
351	DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
352	}
353	break;
354	case 0x7C:
355	case 0x7D:
b3db9409	356	#ifdef __arm__
	357	if ((GPU_GP1 & 0x180) == 0 && (Masking \| PixelMSB) == 0)
	358	{
	359	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	360	gpuSetTexture (GPU_GP1);
	361	gpuDrawS16();
	362	break;
	363	}
	364	// fallthrough
	365	#endif
86aad47b	366	case 0x7E:
	367	case 0x7F:
	368	if (!isSkip)
	369	{
	370	NULL_GPU();
	371	PacketBuffer.U4[3] = 0x00100010;
	372	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	373	gpuSetTexture (GPU_GP1);
	374	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
	375	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| (enableAbbeyHack<<7) \| PixelMSB]);
	376	else
	377	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| (enableAbbeyHack<<7) \| PixelMSB]);
	378	DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
	379	}
	380	break;
	381	case 0x80: // vid -> vid
	382	gpuMoveImage(); // prim handles updateLace && skip
	383	DO_LOG(("gpuMoveImage(0x%x)\n",PRIM));
	384	break;
	385	case 0xA0: // sys ->vid
	386	gpuLoadImage(); // prim handles updateLace && skip
89c0de42	387	#ifndef isSkip // not a define
86aad47b	388	if (alt_fps) isSkip=false;
89c0de42	389	#endif
86aad47b	390	DO_LOG(("gpuLoadImage(0x%x)\n",PRIM));
	391	break;
	392	case 0xC0: // vid -> sys
	393	gpuStoreImage(); // prim handles updateLace && skip
	394	DO_LOG(("gpuStoreImage(0x%x)\n",PRIM));
	395	break;
	396	case 0xE1:
	397	{
	398	const u32 temp = PacketBuffer.U4[0];
	399	GPU_GP1 = (GPU_GP1 & ~0x000007FF) \| (temp & 0x000007FF);
	400	gpuSetTexture(temp);
	401	DO_LOG(("gpuSetTexture(0x%x)\n",PRIM));
	402	}
	403	break;
	404	case 0xE2:
	405	{
	406	static const u8 TextureMask[32] = {
	407	255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7, //
	408	127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7 //
	409	};
	410	const u32 temp = PacketBuffer.U4[0];
	411	TextureWindow[0] = ((temp >> 10) & 0x1F) << 3;
	412	TextureWindow[1] = ((temp >> 15) & 0x1F) << 3;
	413	TextureWindow[2] = TextureMask[(temp >> 0) & 0x1F];
	414	TextureWindow[3] = TextureMask[(temp >> 5) & 0x1F];
	415	gpuSetTexture(GPU_GP1);
c006d9e3	416	//isSkip = false;
86aad47b	417	DO_LOG(("TextureWindow(0x%x)\n",PRIM));
	418	}
	419	break;
	420	case 0xE3:
	421	{
	422	const u32 temp = PacketBuffer.U4[0];
	423	DrawingArea[0] = temp & 0x3FF;
	424	DrawingArea[1] = (temp >> 10) & 0x3FF;
c006d9e3	425	//isSkip = false;
86aad47b	426	DO_LOG(("DrawingArea_Pos(0x%x)\n",PRIM));
	427	}
	428	break;
	429	case 0xE4:
	430	{
	431	const u32 temp = PacketBuffer.U4[0];
	432	DrawingArea[2] = (temp & 0x3FF) + 1;
	433	DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1;
c006d9e3	434	//isSkip = false;
86aad47b	435	DO_LOG(("DrawingArea_Size(0x%x)\n",PRIM));
	436	}
	437	break;
	438	case 0xE5:
	439	{
	440	const u32 temp = PacketBuffer.U4[0];
4144e9ab	441	DrawingOffset[0] = ((s32)temp<<(32-11))>>(32-11);
4144e9ab	442	DrawingOffset[1] = ((s32)temp<<(32-22))>>(32-11);
c006d9e3	443	//isSkip = false;
86aad47b	444	DO_LOG(("DrawingOffset(0x%x)\n",PRIM));
	445	}
	446	break;
	447	case 0xE6:
	448	{
	449	const u32 temp = PacketBuffer.U4[0];
	450	//GPU_GP1 = (GPU_GP1 & ~0x00001800) \| ((temp&3) << 11);
	451	Masking = (temp & 0x2) << 1;
	452	PixelMSB =(temp & 0x1) << 8;
	453	DO_LOG(("SetMask(0x%x)\n",PRIM));
	454	}
	455	break;
	456	}
	457	}