import gpu_unai from PCSX4ALL project

diff --git a/plugins/gpu_unai/gpu.cpp b/plugins/gpu_unai/gpu.cpp
new file mode 100644 (file)
index 0000000..ba32d18
--- /dev/null
+++ b/plugins/gpu_unai/gpu.cpp
@@ -0,0 +1,840 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+#include "gpu.h"
+#include "port.h"
+#include "profiler.h"
+#include "debug.h"
+
+int skipCount = 2; /* frame skip (0,1,2,3...) */
+int skCount=0; /* internal frame skip */
+int linesInterlace = 0;  /* internal lines interlace */
+int linesInterlace_user = 0; /* Lines interlace */
+
+bool isSkip=false; /* skip frame (info coming from GPU) */
+bool skipFrame=false; /* skip frame (according to frame skip) */
+bool alt_fps = false; /* Alternative FPS algorithm */
+bool show_fps = false; /* Show FPS statistics */
+
+bool isPAL=false; /* PAL video timing */
+bool progressInterlace_flag = false; /* Progressive interlace flag */
+bool progressInterlace = false; /* Progressive interlace option*/
+bool frameLimit = false; /* frames to wait */
+bool light = true; /* lighting */
+bool blend = true; /* blending */
+
+bool enableAbbeyHack = false; /* Abe's Odyssey hack */
+u8 BLEND_MODE;
+u8 TEXT_MODE;
+u8 Masking;
+
+u16 PixelMSB;
+u16 PixelData;
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Global data
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+//  Dma Transfers info
+s32            px,py;
+s32            x_end,y_end;
+u16*  pvram;
+
+u32 FrameToRead;
+u32 FrameToWrite;
+
+u32 GP0;
+s32 PacketCount;
+s32 PacketIndex;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Display status
+u32 DisplayArea   [6];
+
+///////////////////////////////////////////////////////////////////////////////
+//  Rasterizer status
+u32 TextureWindow [4];
+u32 DrawingArea   [4];
+u32 DrawingOffset [2];
+
+///////////////////////////////////////////////////////////////////////////////
+//  Rasterizer status
+
+u16* TBA;
+u16* CBA;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Inner Loops
+s32   u4, du4;
+s32   v4, dv4;
+s32   r4, dr4;
+s32   g4, dg4;
+s32   b4, db4;
+u32   lInc;
+u32   tInc, tMsk;
+
+GPUPacket PacketBuffer;
+u16   GPU_FrameBuffer[FRAME_BUFFER_SIZE/2];    // FRAME_BUFFER_SIZE is defined in bytes
+u32   GPU_GP1;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Inner loop driver instanciation file
+#include "gpu_inner.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Raster Macros
+#define        GPU_RGB16(rgb)        ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))
+
+#define GPU_EXPANDSIGN_POLY(x)  (((s32)(x)<<20)>>20)
+//#define GPU_EXPANDSIGN_POLY(x)  (((s32)(x)<<21)>>21)
+#define GPU_EXPANDSIGN_SPRT(x)  (((s32)(x)<<21)>>21)
+
+//#define      GPU_TESTRANGE(x)      { if((u32)(x+1024) > 2047) return; }
+#define        GPU_TESTRANGE(x)      { if ((x<-1023) || (x>1023)) return; }
+
+#define        GPU_SWAP(a,b,t) {(t)=(a);(a)=(b);(b)=(t);}
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal image drawing functions
+#include "gpu_raster_image.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal line drawing functions
+#include "gpu_raster_line.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal polygon drawing functions
+#include "gpu_raster_polygon.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal sprite drawing functions
+#include "gpu_raster_sprite.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU command buffer execution/store
+#include "gpu_command.h"
+
+///////////////////////////////////////////////////////////////////////////////
+INLINE void gpuReset(void)
+{
+       GPU_GP1 = 0x14802000;
+       TextureWindow[0] = 0;
+       TextureWindow[1] = 0;
+       TextureWindow[2] = 255;
+       TextureWindow[3] = 255;
+       DrawingArea[2] = 256;
+       DrawingArea[3] = 240;
+       DisplayArea[2] = 256;
+       DisplayArea[3] = 240;
+       DisplayArea[5] = 240;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+bool  GPU_init(void)
+{
+       gpuReset();
+       
+       // s_invTable
+       for(int i=1;i<=(1<<TABLE_BITS);++i)
+       {
+               double v = 1.0 / double(i);
+               #ifdef GPU_TABLE_10_BITS
+               v *= double(0xffffffff>>1);
+               #else
+               v *= double(0x80000000);
+               #endif
+               s_invTable[i-1]=s32(v);
+       }
+       return (0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_shutdown(void)
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////
+long  GPU_freeze(unsigned int bWrite, GPUFreeze_t* p2)
+{
+       if (!p2) return (0);
+       if (p2->Version != 1) return (0);
+
+       if (bWrite)
+       {
+               p2->GPU_gp1 = GPU_GP1;
+               memcpy(p2->FrameBuffer, (u16*)GPU_FrameBuffer, FRAME_BUFFER_SIZE);
+               return (1);
+       }
+       else
+       {
+               GPU_GP1 = p2->GPU_gp1;
+               memcpy((u16*)GPU_FrameBuffer, p2->FrameBuffer, FRAME_BUFFER_SIZE);
+               return (1);
+       }
+       return (0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU DMA comunication
+
+///////////////////////////////////////////////////////////////////////////////
+u8 PacketSize[256] =
+{
+       0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              0-15
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              16-31
+       3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, //              32-47
+       5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11,     //      48-63
+       2, 2, 2, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, //              64-79
+       3, 3, 3, 3, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, //              80-95
+       2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, //              96-111
+       1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, //              112-127
+       3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              128-
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              144
+       2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              160
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+       2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  //
+};
+
+///////////////////////////////////////////////////////////////////////////////
+INLINE void gpuSendPacket()
+{
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_sendPacket++;
+#endif
+       gpuSendPacketFunction(PacketBuffer.U4[0]>>24);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+INLINE void gpuCheckPacket(u32 uData)
+{
+       if (PacketCount)
+       {
+               PacketBuffer.U4[PacketIndex++] = uData;
+               --PacketCount;
+       }
+       else
+       {
+               PacketBuffer.U4[0] = uData;
+               PacketCount = PacketSize[uData >> 24];
+               PacketIndex = 1;
+       }
+       if (!PacketCount) gpuSendPacket();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_writeDataMem(u32* dmaAddress, s32 dmaCount)
+{
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_writeDataMem++;
+#endif
+       pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       u32 data;
+       const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
+       GPU_GP1 &= ~0x14000000;
+
+       while (dmaCount) 
+       {
+               if (FrameToWrite) 
+               {
+                       while (dmaCount--) 
+                       {
+                               data = *dmaAddress++;
+                               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+                               pvram[px] = data;
+                               if (++px>=x_end) 
+                               {
+                                       px = 0;
+                                       pvram += 1024;
+                                       if (++py>=y_end) 
+                                       {
+                                               FrameToWrite = 0;
+                                               GPU_GP1 &= ~0x08000000;
+                                               break;
+                                       }
+                               }
+                               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+                               pvram[px] = data>>16;
+                               if (++px>=x_end) 
+                               {
+                                       px = 0;
+                                       pvram += 1024;
+                                       if (++py>=y_end) 
+                                       {
+                                               FrameToWrite = 0;
+                                               GPU_GP1 &= ~0x08000000;
+                                               break;
+                                       }
+                               }
+                       }
+               }
+               else
+               {
+                       data = *dmaAddress++;
+                       dmaCount--;
+                       gpuCheckPacket(data);
+               }
+       }
+
+       GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
+}
+
+u32 *lUsedAddr[3];
+INLINE int CheckForEndlessLoop(u32 *laddr)
+{
+       if(laddr==lUsedAddr[1]) return 1;
+       if(laddr==lUsedAddr[2]) return 1;
+
+       if(laddr<lUsedAddr[0]) lUsedAddr[1]=laddr;
+       else                   lUsedAddr[2]=laddr;
+       lUsedAddr[0]=laddr;
+       return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_dmaChain(u32* baseAddr, u32 dmaVAddr)
+{
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_dmaChain++;
+#endif
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       u32 data, *address, count, offset;
+       unsigned int DMACommandCounter = 0;
+
+       GPU_GP1 &= ~0x14000000;
+       lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=(u32*)0x1fffff;
+       dmaVAddr &= 0x001FFFFF;
+       while (dmaVAddr != 0x1FFFFF)
+       {
+               address = (baseAddr + (dmaVAddr >> 2));
+               if(DMACommandCounter++ > 2000000) break;
+               if(CheckForEndlessLoop(address)) break;
+               data = *address++;
+               count = (data >> 24);
+               offset = data & 0x001FFFFF;
+               if (dmaVAddr != offset) dmaVAddr = offset;
+               else dmaVAddr = 0x1FFFFF;
+
+               if(count>0) GPU_writeDataMem(address,count);
+       }
+       GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_writeData(u32 data)
+{
+       const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_writeData++;
+#endif
+       pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       GPU_GP1 &= ~0x14000000;
+
+       if (FrameToWrite)
+       {
+               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+               pvram[px]=(u16)data;
+               if (++px>=x_end)
+               {
+                       px = 0;
+                       pvram += 1024;
+                       if (++py>=y_end) 
+                       {
+                               FrameToWrite = 0;
+                               GPU_GP1 &= ~0x08000000;
+                       }
+               }
+               if (FrameToWrite)
+               {
+                       if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+                       pvram[px]=data>>16;
+                       if (++px>=x_end)
+                       {
+                               px = 0;
+                               pvram += 1024;
+                               if (++py>=y_end) 
+                               {
+                                       FrameToWrite = 0;
+                                       GPU_GP1 &= ~0x08000000;
+                               }
+                       }
+               }
+       }
+       else
+       {
+               gpuCheckPacket(data);
+       }
+       GPU_GP1 |= 0x14000000;
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
+
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_readDataMem(u32* dmaAddress, s32 dmaCount)
+{
+       const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_readDataMem++;
+#endif
+       if(!FrameToRead) return;
+
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       GPU_GP1 &= ~0x14000000;
+       do 
+       {
+               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+               // lower 16 bit
+               u32 data = (unsigned long)pvram[px];
+
+               if (++px>=x_end) 
+               {
+                       px = 0;
+                       pvram += 1024;
+               }
+
+               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+               // higher 16 bit (always, even if it's an odd width)
+               data |= (unsigned long)(pvram[px])<<16;
+               
+               *dmaAddress++ = data;
+
+               if (++px>=x_end) 
+               {
+                       px = 0;
+                       pvram += 1024;
+                       if (++py>=y_end) 
+                       {
+                               FrameToRead = 0;
+                               GPU_GP1 &= ~0x08000000;
+                               break;
+                       }
+               }
+       } while (--dmaCount);
+
+       GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+u32  GPU_readData(void)
+{
+       const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_readData++;
+#endif
+       pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_READ);
+       GPU_GP1 &= ~0x14000000;
+       if (FrameToRead)
+       {
+               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+               GP0 = pvram[px];
+               if (++px>=x_end)
+               {
+                       px = 0;
+                       pvram += 1024;
+                       if (++py>=y_end) 
+                       {
+                               FrameToRead = 0;
+                               GPU_GP1 &= ~0x08000000;
+                       }
+               }
+               if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+               GP0 |= pvram[px]<<16;
+               if (++px>=x_end)
+               {
+                       px = 0;
+                       pvram +=1024;
+                       if (++py>=y_end) 
+                       {
+                               FrameToRead = 0;
+                               GPU_GP1 &= ~0x08000000;
+                       }
+               }
+
+       }
+       GPU_GP1 |= 0x14000000;
+
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_READ);
+       pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
+       return (GP0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+u32     GPU_readStatus(void)
+{
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_readStatus++;
+#endif
+       return GPU_GP1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_writeStatus(u32 data)
+{
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_writeStatus++;
+#endif
+       pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       switch (data >> 24) {
+       case 0x00:
+               gpuReset();
+               break;
+       case 0x01:
+               GPU_GP1 &= ~0x08000000;
+               PacketCount = FrameToRead = FrameToWrite = 0;
+               break;
+       case 0x02:
+               GPU_GP1 &= ~0x08000000;
+               PacketCount = FrameToRead = FrameToWrite = 0;
+               break;
+       case 0x03:
+               GPU_GP1 = (GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
+               break;
+       case 0x04:
+               if (data == 0x04000000)
+               PacketCount = 0;
+               GPU_GP1 = (GPU_GP1 & ~0x60000000) | ((data & 3) << 29);
+               break;
+       case 0x05:
+               DisplayArea[0] = (data & 0x000003FF); //(short)(data & 0x3ff);
+               DisplayArea[1] = ((data & 0x0007FC00)>>10); //(data & 0x000FFC00) >> 10; //(short)((data>>10)&0x1ff);
+               break;
+       case 0x07:
+               DisplayArea[4] = data & 0x000003FF; //(short)(data & 0x3ff);
+               DisplayArea[5] = (data & 0x000FFC00) >> 10; //(short)((data>>10) & 0x3ff);
+               break;
+       case 0x08:
+               {
+                       GPU_GP1 = (GPU_GP1 & ~0x007F0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
+                       static u32 HorizontalResolution[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
+                       DisplayArea[2] = HorizontalResolution[(GPU_GP1 >> 16) & 7];
+                       static u32 VerticalResolution[4] = { 240, 480, 256, 480 };
+                       DisplayArea[3] = VerticalResolution[(GPU_GP1 >> 19) & 3];
+                       isPAL = (data & 0x08) ? true : false; // if 1 - PAL mode, else NTSC
+               }
+               break;
+       case 0x10:
+               switch (data & 0xffff) {
+               case 0:
+               case 1:
+               case 3:
+                       GP0 = (DrawingArea[1] << 10) | DrawingArea[0];
+                       break;
+               case 4:
+                       GP0 = ((DrawingArea[3]-1) << 10) | (DrawingArea[2]-1);
+                       break;
+               case 6:
+               case 5:
+                       GP0 = (DrawingOffset[1] << 11) | DrawingOffset[0];
+                       break;
+               case 7:
+                       GP0 = 2;
+                       break;
+               default:
+                       GP0 = 0;
+               }
+               break;
+       }
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+       pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
+}
+
+// Blitting functions
+#include "gpu_blit.h"
+
+INLINE void gpuVideoOutput(void)
+{
+       static s16 old_res_horz, old_res_vert, old_rgb24;
+       s16 h0, x0, y0, w0, h1;
+
+       x0 = DisplayArea[0];
+       y0 = DisplayArea[1];
+
+       w0 = DisplayArea[2];
+       h0 = DisplayArea[3];  // video mode
+
+       h1 = DisplayArea[5] - DisplayArea[4]; // display needed
+       if (h0 == 480) h1 = Min2(h1*2,480);
+
+       u16* dest_screen16 = SCREEN;
+       u16* src_screen16  = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0,y0)];
+       u32 isRGB24 = (GPU_GP1 & 0x00200000 ? 32 : 0);
+
+       /* Clear the screen if resolution changed to prevent interlacing and clipping to clash */
+       if( (w0 != old_res_horz || h1 != old_res_vert || (s16)isRGB24 != old_rgb24) )
+       {
+               // Update old resolution
+               old_res_horz = w0;
+               old_res_vert = h1;
+               old_rgb24 = (s16)isRGB24;
+               // Finally, clear the screen for this special case
+               video_clear();
+       }
+
+       //  Height centering
+       int sizeShift = 1;
+       if(h0==256) h0 = 240; else if(h0==480) sizeShift = 2;
+       if(h1>h0) { src_screen16 += ((h1-h0)>>sizeShift)*1024; h1 = h0; }
+       else if(h1<h0) dest_screen16 += ((h0-h1)>>sizeShift)*VIDEO_WIDTH;
+
+       /* Main blitter */
+       int incY = (h0==480) ? 2 : 1;
+       h0=(h0==480 ? 2048 : 1024);
+
+       if (!progressInterlace)
+       {
+               const int li=linesInterlace;
+               switch ( w0 )
+               {
+                       case 256:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if( 0 == (y0&li) ) GPU_BlitWWDWW(       src_screen16,   dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 368:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if( 0 == (y0&li) ) GPU_BlitWWWWWWWWS(   src_screen16,   dest_screen16, isRGB24, 4);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 320:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if( 0 == (y0&li) ) GPU_BlitWW(  src_screen16,   dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 384:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if( 0 == (y0&li) ) GPU_BlitWWWWWS(      src_screen16,   dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 512:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if( 0 == (y0&li) ) GPU_BlitWWSWWSWS(    src_screen16, dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 640:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if( 0 == (y0&li) ) GPU_BlitWS(  src_screen16, dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+               }
+       }
+       else
+       {
+               const int li=linesInterlace;
+               bool flag=progressInterlace_flag; /* progressive interlace */
+               switch ( w0 )
+               {
+                       case 256:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if(( 0 == (y0&li) ) && (flag=!flag)) GPU_BlitWWDWW(     src_screen16,   dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 368:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if(( 0 == (y0&li) ) && (flag=!flag)) GPU_BlitWWWWWWWWS( src_screen16,   dest_screen16, isRGB24, 4);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 320:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if(( 0 == (y0&li) ) && (flag=!flag)) GPU_BlitWW(        src_screen16,   dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 384:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if(( 0 == (y0&li) ) && (flag=!flag)) GPU_BlitWWWWWS(    src_screen16,   dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 512:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if(( 0 == (y0&li) ) && (flag=!flag)) GPU_BlitWWSWWSWS(  src_screen16, dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+                       case 640:
+                               for(int y1=y0+h1; y0<y1; y0+=incY)
+                               {
+                                       if(( 0 == (y0&li) ) && (flag=!flag)) GPU_BlitWS(        src_screen16, dest_screen16, isRGB24);
+                                       dest_screen16 += VIDEO_WIDTH;
+                                       src_screen16  += h0;
+                               }
+                               break;
+               }
+               progressInterlace_flag=!flag;
+       }
+       video_flip();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void  GPU_updateLace(void)
+{
+#ifdef  ENABLE_GPU_LOG_SUPPORT
+       fprintf(stdout,"GPU_updateLace()\n");
+#endif
+#ifdef DEBUG_ANALYSIS
+       dbg_anacnt_GPU_updateLace++;
+#endif
+       pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS);
+#ifdef PROFILER_PCSX4ALL
+       pcsx4all_prof_frames++;
+#endif
+#ifdef DEBUG_FRAME
+       if(isdbg_frame())
+       {
+               static int passed=0;
+               if (!passed) dbg_enable();
+               else pcsx4all_exit();
+               passed++;
+       }
+#endif
+
+       // Frame skip table
+       static const unsigned char skipTable[12][12] =
+       {
+               { 0,0,0,0,0,0,0,0,0,0,0,0 },
+               { 0,0,0,0,0,0,0,0,0,0,0,1 },
+               { 0,0,0,0,0,1,0,0,0,0,0,1 },
+               { 0,0,0,1,0,0,0,1,0,0,0,1 },
+               { 0,0,1,0,0,1,0,0,1,0,0,1 },
+               { 0,1,0,0,1,0,1,0,0,1,0,1 },
+               { 0,1,0,1,0,1,0,1,0,1,0,1 },
+               { 0,1,0,1,1,0,1,0,1,1,0,1 },
+               { 0,1,1,0,1,1,0,1,1,0,1,1 },
+               { 0,1,1,1,0,1,1,1,0,1,1,1 },
+               { 0,1,1,1,1,1,0,1,1,1,1,1 },
+               { 0,1,1,1,1,1,1,1,1,1,1,1 }
+       };
+       
+       // Interlace bit toggle
+       GPU_GP1 ^= 0x80000000;
+
+       // Update display
+       if ((!skipFrame) && (!isSkip) && (!(((GPU_GP1&0x08000000))||((GPU_GP1&0x00800000)))))
+       {
+               gpuVideoOutput(); // Display updated
+
+               if (DisplayArea[3] == 480)
+               {
+                       if (linesInterlace_user) linesInterlace = 3; // 1/4 of lines
+                       else linesInterlace = 1; // if 480 we only need half of lines
+               }
+               else if (linesInterlace != linesInterlace_user)
+               {
+                       linesInterlace = linesInterlace_user; // resolution changed from 480 to lower one
+                       video_clear();
+               }
+
+               // Limit FPS
+               if (frameLimit)
+               {
+                       static unsigned next=get_ticks();
+                       unsigned now=get_ticks();
+                       if (!skipFrame)
+                       {
+                               if (now<next) wait_ticks(next-now);
+                       }
+                       next+=(isPAL?(1000000/50):((unsigned)(1000000.0/59.94)));
+               }
+       }
+
+       // Show FPS statistics
+       if (show_fps)
+       {
+               static u32 real_fps=0;
+               static u32 prev=get_ticks();
+               static char msg[24]="FPS=000/00 SPD=000%";
+               u32 now=get_ticks();
+               real_fps++;
+               if ((now-prev)>=1000000)
+               {
+                       u32 expected_fps=(isPAL?50:60);
+                       sprintf(msg,"FPS=%3d/%2d SPD=%3d%%",((real_fps*(12-skipCount))/12),((expected_fps*(12-skipCount))/12),((real_fps*100)/expected_fps));
+                       prev=now;
+                       real_fps=0;
+               }
+               port_printf(5,5,msg);
+       }
+
+       // Update frame-skip
+       if (!alt_fps)
+       {
+               // Video frame-skip
+               skipFrame=skipTable[skipCount][skCount];
+               skCount--; if (skCount<0) skCount=11;
+               isSkip=skipFrame;
+       }
+       else
+       {
+               // Game frame-skip
+               if (!isSkip)
+               {
+                       skipFrame=skipTable[skipCount][skCount];
+                       skCount--; if (skCount<0) skCount=11;
+                       isSkip=true;
+               }
+       }
+
+       pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS);
+}

diff --git a/plugins/gpu_unai/gpu.h b/plugins/gpu_unai/gpu.h
new file mode 100644 (file)
index 0000000..1811630
--- /dev/null
+++ b/plugins/gpu_unai/gpu.h
@@ -0,0 +1,87 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+#ifndef NEW_GPU_H
+#define NEW_GPU_H
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU global definitions
+#define        FRAME_BUFFER_SIZE       (1024*512*2)
+#define        FRAME_WIDTH                       1024
+#define        FRAME_HEIGHT              512
+#define        FRAME_OFFSET(x,y)       (((y)<<10)+(x))
+
+#define VIDEO_WIDTH 320
+
+typedef char                           s8;
+typedef signed short           s16;
+typedef signed int                     s32;
+typedef signed long long       s64;
+
+typedef unsigned char          u8;
+typedef unsigned short         u16;
+typedef unsigned int           u32;
+typedef unsigned long long     u64;
+
+#include "gpu_fixedpoint.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//  Tweaks and Hacks
+extern  int  skipCount;
+extern  bool enableAbbeyHack;
+extern  bool show_fps;
+extern  bool alt_fps;
+
+///////////////////////////////////////////////////////////////////////////////
+//  interlaced rendering
+extern  int linesInterlace_user;
+extern  bool progressInterlace;
+
+extern  bool light;
+extern  bool blend;
+
+typedef struct {
+       u32 Version;
+       u32 GPU_gp1;
+       u32 Control[256];
+       unsigned char FrameBuffer[1024*512*2];
+} GPUFreeze_t;
+
+struct  GPUPacket
+{
+       union
+       {
+               u32 U4[16];
+               s32 S4[16];
+               u16 U2[32];
+               s16 S2[32];
+               u8  U1[64];
+               s8  S1[64];
+       };
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Compile Options
+
+//#define ENABLE_GPU_NULL_SUPPORT   // Enables NullGPU support
+//#define ENABLE_GPU_LOG_SUPPORT    // Enables gpu logger, very slow only for windows debugging
+
+///////////////////////////////////////////////////////////////////////////////
+#endif  // NEW_GPU_H

diff --git a/plugins/gpu_unai/gpu_blit.h b/plugins/gpu_unai/gpu_blit.h
new file mode 100644 (file)
index 0000000..35cd056
--- /dev/null
+++ b/plugins/gpu_unai/gpu_blit.h
@@ -0,0 +1,405 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+#ifndef _INNER_BLIT_H_
+#define _INNER_BLIT_H_
+
+#ifndef USE_BGR15
+#define RGB24(R,G,B)   (((((R)&0xF8)<<8)|(((G)&0xFC)<<3)|(((B)&0xF8)>>3)))
+#define RGB16X2(C)      (((C)&(0x1f001f<<10))>>10) | (((C)&(0x1f001f<<5))<<1) | (((C)&(0x1f001f<<0))<<11)
+#define RGB16(C)               (((C)&(0x1f<<10))>>10) | (((C)&(0x1f<<5))<<1) | (((C)&(0x1f<<0))<<11)
+#else
+#define RGB24(R,G,B)   ((((R)&0xF8)>>3)|(((G)&0xF8)<<2)|(((B)&0xF8)<<7))
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Blitting code with rescale and interlace support.
+
+INLINE void GPU_BlitWW(const void* src, u16* dst16, u32 isRGB24)
+{
+       u32 uCount;
+       if(isRGB24 == 0)
+       {
+               #ifndef USE_BGR15
+                       uCount = 20;
+                       const u32* src32 = (const u32*) src; 
+                       u32* dst32 = (u32*)(void*) dst16;
+                       do{
+                               dst32[0] = RGB16X2(src32[0]);
+                               dst32[1] = RGB16X2(src32[1]);
+                               dst32[2] = RGB16X2(src32[2]);
+                               dst32[3] = RGB16X2(src32[3]);
+                               dst32[4] = RGB16X2(src32[4]);
+                               dst32[5] = RGB16X2(src32[5]);
+                               dst32[6] = RGB16X2(src32[6]);
+                               dst32[7] = RGB16X2(src32[7]);
+                               dst32 += 8;
+                               src32 += 8;
+                       }while(--uCount);
+               #else
+                       memcpy(dst16,src,640);
+               #endif
+       }
+       else
+       {
+               uCount = 20;
+               const u8* src8 = (const u8*)src;
+               do{
+                       dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
+                       dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
+                       dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
+                       dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] );
+                       dst16[ 4] = RGB24(src8[12], src8[13], src8[14] );
+                       dst16[ 5] = RGB24(src8[15], src8[16], src8[17] );
+                       dst16[ 6] = RGB24(src8[18], src8[19], src8[20] );
+                       dst16[ 7] = RGB24(src8[21], src8[22], src8[23] );
+
+                       dst16[ 8] = RGB24(src8[24], src8[25], src8[26] );
+                       dst16[ 9] = RGB24(src8[27], src8[28], src8[29] );
+                       dst16[10] = RGB24(src8[30], src8[31], src8[32] );
+                       dst16[11] = RGB24(src8[33], src8[34], src8[35] );
+                       dst16[12] = RGB24(src8[36], src8[37], src8[38] );
+                       dst16[13] = RGB24(src8[39], src8[40], src8[41] );
+                       dst16[14] = RGB24(src8[42], src8[43], src8[44] );
+                       dst16[15] = RGB24(src8[45], src8[46], src8[47] );
+                       dst16 += 16;
+                       src8  += 48;
+               }while(--uCount);
+       }
+}
+
+INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, u32 isRGB24)
+{
+       u32 uCount;
+       if(isRGB24 == 0)
+       {
+               #ifndef USE_BGR15
+                       uCount = 32;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               dst16[ 0] = RGB16(src16[0]);
+                               dst16[ 1] = RGB16(src16[1]);
+                               dst16[ 2] = RGB16(src16[3]);
+                               dst16[ 3] = RGB16(src16[4]);
+                               dst16[ 4] = RGB16(src16[6]);
+                               dst16[ 5] = RGB16(src16[8]);
+                               dst16[ 6] = RGB16(src16[9]);
+                               dst16[ 7] = RGB16(src16[11]);
+                               dst16[ 8] = RGB16(src16[12]);
+                               dst16[ 9] = RGB16(src16[14]);
+                               dst16 += 10;
+                               src16 += 16;
+                       }while(--uCount);
+               #else
+                       uCount = 64;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16;
+                               src16+=2;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16;
+                               src16+=2;
+                               *dst16++ = *src16;
+                               src16+=2;
+                       }while(--uCount);
+               #endif
+       }
+       else
+       {
+               uCount = 32;
+               const u8* src8 = (const u8*)src;
+               do{
+                       dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
+                       dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
+                       dst16[ 2] = RGB24(src8[ 9], src8[10], src8[11] );
+                       dst16[ 3] = RGB24(src8[12], src8[13], src8[14] );
+                       dst16[ 4] = RGB24(src8[18], src8[19], src8[20] );
+
+                       dst16[ 5] = RGB24(src8[24], src8[25], src8[26] );
+                       dst16[ 6] = RGB24(src8[27], src8[28], src8[29] );
+                       dst16[ 7] = RGB24(src8[33], src8[34], src8[35] );
+                       dst16[ 8] = RGB24(src8[36], src8[37], src8[38] );
+                       dst16[ 9] = RGB24(src8[42], src8[43], src8[44] );
+
+                       dst16 += 10;
+                       src8  += 48;
+               }while(--uCount);
+       }
+}
+
+INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, u32 isRGB24)
+{
+       u32 uCount;
+       if(isRGB24 == 0)
+       {
+               #ifndef USE_BGR15
+                       uCount = 32;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               dst16[ 0] = RGB16(src16[0]);
+                               dst16[ 1] = RGB16(src16[1]);
+                               dst16[ 2] = RGB16(src16[2]);
+                               dst16[ 3] = RGB16(src16[3]);
+                               dst16[ 4] = RGB16(src16[4]);
+                               dst16[ 5] = RGB16(src16[6]);
+                               dst16[ 6] = RGB16(src16[7]);
+                               dst16[ 7] = RGB16(src16[8]);
+                               dst16[ 8] = RGB16(src16[9]);
+                               dst16[ 9] = RGB16(src16[10]);
+                               dst16 += 10;
+                               src16 += 12;
+                       }while(--uCount);
+               #else
+                       uCount = 64;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16;
+                               src16+=2;
+                       }while(--uCount);
+               #endif
+       }
+       else
+       {
+               uCount = 32;
+               const u8* src8 = (const u8*)src;
+               do{
+                       dst16[0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
+                       dst16[1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
+                       dst16[2] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
+                       dst16[3] = RGB24(src8[ 9], src8[10], src8[11] );
+                       dst16[4] = RGB24(src8[12], src8[13], src8[14] );
+                       dst16[5] = RGB24(src8[18], src8[19], src8[20] );
+                       dst16[6] = RGB24(src8[21], src8[22], src8[23] );
+                       dst16[7] = RGB24(src8[24], src8[25], src8[26] );
+                       dst16[8] = RGB24(src8[27], src8[28], src8[29] );
+                       dst16[9] = RGB24(src8[30], src8[31], src8[32] );
+                       dst16 += 10;
+                       src8  += 36;
+               }while(--uCount);
+       }
+}
+
+INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, u32 isRGB24, u32 uClip_src)
+{
+       u32 uCount;
+       if(isRGB24 == 0)
+       {
+               #ifndef USE_BGR15
+                       uCount = 20;
+                       const u16* src16 = ((const u16*) src) + uClip_src; 
+                       do{
+                               dst16[ 0] = RGB16(src16[0]);
+                               dst16[ 1] = RGB16(src16[1]);
+                               dst16[ 2] = RGB16(src16[2]);
+                               dst16[ 3] = RGB16(src16[3]);
+                               dst16[ 4] = RGB16(src16[4]);
+                               dst16[ 5] = RGB16(src16[5]);
+                               dst16[ 6] = RGB16(src16[6]);
+                               dst16[ 7] = RGB16(src16[7]);
+
+                               dst16[ 8] = RGB16(src16[9]);
+                               dst16[ 9] = RGB16(src16[10]);
+                               dst16[10] = RGB16(src16[11]);
+                               dst16[11] = RGB16(src16[12]);
+                               dst16[12] = RGB16(src16[13]);
+                               dst16[13] = RGB16(src16[14]);
+                               dst16[14] = RGB16(src16[15]);
+                               dst16[15] = RGB16(src16[16]);
+                               dst16 += 16;
+                               src16 += 18;
+                       }while(--uCount);
+               #else
+                       uCount = 40;
+                       const u16* src16 = ((const u16*) src) + uClip_src; 
+                       do{
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16;
+                               src16+=2;
+                       }while(--uCount);
+               #endif
+       }
+       else
+       {
+               uCount = 20;
+               const u8* src8 = (const u8*)src + (uClip_src<<1) + uClip_src;
+               do{
+                       dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
+                       dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
+                       dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
+                       dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] );
+                       dst16[ 4] = RGB24(src8[12], src8[13], src8[14] );
+                       dst16[ 5] = RGB24(src8[15], src8[16], src8[17] );
+                       dst16[ 6] = RGB24(src8[18], src8[19], src8[20] );
+                       dst16[ 7] = RGB24(src8[21], src8[22], src8[23] );
+
+                       dst16[ 8] = RGB24(src8[27], src8[28], src8[29] );
+                       dst16[ 9] = RGB24(src8[30], src8[31], src8[32] );
+                       dst16[10] = RGB24(src8[33], src8[34], src8[35] );
+                       dst16[11] = RGB24(src8[36], src8[37], src8[38] );
+                       dst16[12] = RGB24(src8[39], src8[40], src8[41] );
+                       dst16[13] = RGB24(src8[42], src8[43], src8[44] );
+                       dst16[14] = RGB24(src8[45], src8[46], src8[47] );
+                       dst16[15] = RGB24(src8[48], src8[49], src8[50] );
+                       dst16 += 16;
+                       src8  += 54;
+               }while(--uCount);
+       }
+}
+
+INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, u32 isRGB24)
+{
+       u32 uCount;
+       if(isRGB24 == 0)
+       {
+               #ifndef USE_BGR15
+                       uCount = 32;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               dst16[ 0] = RGB16(src16[0]);
+                               dst16[ 1] = RGB16(src16[1]);
+                               dst16[ 2] = dst16[1];
+                               dst16[ 3] = RGB16(src16[2]);
+                               dst16[ 4] = RGB16(src16[3]);
+                               dst16[ 5] = RGB16(src16[4]);
+                               dst16[ 6] = RGB16(src16[5]);
+                               dst16[ 7] = dst16[6];
+                               dst16[ 8] = RGB16(src16[6]);
+                               dst16[ 9] = RGB16(src16[7]);
+                               dst16 += 10;
+                               src16 +=  8;
+                       }while(--uCount);
+               #else
+                       uCount = 64;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                               *dst16++ = *src16++;
+                       }while(--uCount);
+               #endif
+       }
+       else
+       {
+               uCount = 32;
+               const u8* src8 = (const u8*)src;
+               do{
+                       dst16[ 0] = RGB24(src8[0], src8[ 1], src8[ 2] );
+                       dst16[ 1] = RGB24(src8[3], src8[ 4], src8[ 5] );
+                       dst16[ 2] = dst16[1];
+                       dst16[ 3] = RGB24(src8[6], src8[ 7], src8[ 8] );
+                       dst16[ 4] = RGB24(src8[9], src8[10], src8[11] );
+
+                       dst16[ 5] = RGB24(src8[12], src8[13], src8[14] );
+                       dst16[ 6] = RGB24(src8[15], src8[16], src8[17] );
+                       dst16[ 7] = dst16[6];
+                       dst16[ 8] = RGB24(src8[18], src8[19], src8[20] );
+                       dst16[ 9] = RGB24(src8[21], src8[22], src8[23] );
+                       dst16 += 10;
+                       src8  += 24;
+               }while(--uCount);
+       }
+}
+
+
+INLINE void GPU_BlitWS(const void* src, u16* dst16, u32 isRGB24)
+{
+       u32 uCount;
+       if(isRGB24 == 0)
+       {
+               #ifndef USE_BGR15
+                       uCount = 20;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               dst16[ 0] = RGB16(src16[0]);
+                               dst16[ 1] = RGB16(src16[2]);
+                               dst16[ 2] = RGB16(src16[4]);
+                               dst16[ 3] = RGB16(src16[6]);
+
+                               dst16[ 4] = RGB16(src16[8]);
+                               dst16[ 5] = RGB16(src16[10]);
+                               dst16[ 6] = RGB16(src16[12]);
+                               dst16[ 7] = RGB16(src16[14]);
+
+                               dst16[ 8] = RGB16(src16[16]);
+                               dst16[ 9] = RGB16(src16[18]);
+                               dst16[10] = RGB16(src16[20]);
+                               dst16[11] = RGB16(src16[22]);
+
+                               dst16[12] = RGB16(src16[24]);
+                               dst16[13] = RGB16(src16[26]);
+                               dst16[14] = RGB16(src16[28]);
+                               dst16[15] = RGB16(src16[30]);
+
+                               dst16 += 16;
+                               src16 += 32;
+                       }while(--uCount);
+               #else
+                       uCount = 320;
+                       const u16* src16 = (const u16*) src; 
+                       do{
+                               *dst16++ = *src16; src16+=2;
+                       }while(--uCount);
+               #endif
+       }
+       else
+       {
+               uCount = 20;
+               const u8* src8 = (const u8*) src; 
+               do{
+                       dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
+                       dst16[ 1] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
+                       dst16[ 2] = RGB24(src8[12], src8[13], src8[14] );
+                       dst16[ 3] = RGB24(src8[18], src8[19], src8[20] );
+
+                       dst16[ 4] = RGB24(src8[24], src8[25], src8[26] );
+                       dst16[ 5] = RGB24(src8[30], src8[31], src8[32] );
+                       dst16[ 6] = RGB24(src8[36], src8[37], src8[38] );
+                       dst16[ 7] = RGB24(src8[42], src8[43], src8[44] );
+
+                       dst16[ 8] = RGB24(src8[48], src8[49], src8[50] );
+                       dst16[ 9] = RGB24(src8[54], src8[55], src8[56] );
+                       dst16[10] = RGB24(src8[60], src8[61], src8[62] );
+                       dst16[11] = RGB24(src8[66], src8[67], src8[68] );
+
+                       dst16[12] = RGB24(src8[72], src8[73], src8[74] );
+                       dst16[13] = RGB24(src8[78], src8[79], src8[80] );
+                       dst16[14] = RGB24(src8[84], src8[85], src8[86] );
+                       dst16[15] = RGB24(src8[90], src8[91], src8[92] );
+
+                       dst16 += 16;
+                       src8  += 96;
+               }while(--uCount);
+       }
+}
+
+#endif //_INNER_BLIT_H_

diff --git a/plugins/gpu_unai/gpu_command.h b/plugins/gpu_unai/gpu_command.h
new file mode 100644 (file)
index 0000000..2dc7f5b
--- /dev/null
+++ b/plugins/gpu_unai/gpu_command.h
@@ -0,0 +1,444 @@
+/***************************************************************************
+*   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)
+{
+       long tp;
+       long tx, ty;
+       GPU_GP1 = (GPU_GP1 & ~0x7FF) | (tpage & 0x7FF);
+
+       TextureWindow[0]&= ~TextureWindow[2];
+       TextureWindow[1]&= ~TextureWindow[3];
+
+       tp = (tpage >> 7) & 3;
+       tx = (tpage & 0x0F) << 6;
+       ty = (tpage & 0x10) << 4;
+
+       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:
+               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
+                       if (alt_fps) isSkip=false;
+                       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] = ((long)temp<<(32-11))>>(32-11);
+                               DrawingOffset[1] = ((long)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;
+       }
+}

diff --git a/plugins/gpu_unai/gpu_fixedpoint.h b/plugins/gpu_unai/gpu_fixedpoint.h
new file mode 100644 (file)
index 0000000..03f07d2
--- /dev/null
+++ b/plugins/gpu_unai/gpu_fixedpoint.h
@@ -0,0 +1,129 @@
+/***************************************************************************
+ *   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.           *
+ ***************************************************************************/
+
+#ifndef FIXED_H
+#define FIXED_H
+
+typedef s32 fixed;
+
+#ifdef GPU_TABLE_10_BITS
+#define TABLE_BITS 10
+#else
+#define TABLE_BITS 16
+#endif
+
+#define FIXED_BITS 16
+
+#define fixed_ZERO ((fixed)0)
+#define fixed_ONE  ((fixed)1<<FIXED_BITS)
+#define fixed_TWO  ((fixed)2<<FIXED_BITS)
+#define fixed_HALF ((fixed)((1<<FIXED_BITS)>>1))
+
+//  big precision inverse table.
+s32 s_invTable[(1<<TABLE_BITS)];
+
+INLINE  fixed i2x(const int   _x) { return  ((_x)<<FIXED_BITS); }
+INLINE  fixed x2i(const fixed _x) { return  ((_x)>>FIXED_BITS); }
+
+/*
+INLINE u32 Log2(u32 _a)
+{
+  u32 c = 0; // result of log2(v) will go here
+  if (_a & 0xFFFF0000) { _a >>= 16; c |= 16;  }
+  if (_a & 0xFF00) { _a >>= 8; c |= 8;  }
+  if (_a & 0xF0) { _a >>= 4; c |= 4;  }
+  if (_a & 0xC) { _a >>= 2; c |= 2;  }
+  if (_a & 0x2) { _a >>= 1; c |= 1;  }
+  return c;
+}
+*/
+
+#ifdef __arm__
+INLINE u32 Log2(u32 x) { u32 res; asm("clz %0,%1" : "=r" (res) : "r" (x)); return 32-res; }
+#else
+INLINE u32 Log2(u32 x) { u32 i = 0; for ( ; x > 0; ++i, x >>= 1); return i - 1; }
+#endif
+
+#ifdef GPU_TABLE_10_BITS
+INLINE  void  xInv (const fixed _b, s32& iFactor_, s32& iShift_)
+{
+    u32 uD   = (_b<0) ? -_b : _b ;
+    u32 uLog = Log2(uD);
+    uLog = uLog>(TABLE_BITS-1) ? uLog-(TABLE_BITS-1) : 0;
+    u32 uDen = uD>>uLog;
+    iFactor_ = s_invTable[uDen];
+    iFactor_ = (_b<0) ? -iFactor_ :iFactor_;
+    iShift_  = 15+uLog;
+}
+#else
+INLINE  void  xInv (const fixed _b, s32& iFactor_, s32& iShift_)
+{
+  u32 uD = (_b<0) ? -_b : _b;
+  if(uD>1)
+  {
+       u32 uLog = Log2(uD);
+    uLog = uLog>(TABLE_BITS-1) ? uLog-(TABLE_BITS-1) : 0;
+    u32 uDen = (uD>>uLog)-1;
+    iFactor_ = s_invTable[uDen];
+    iFactor_ = (_b<0) ? -iFactor_ :iFactor_;
+    iShift_  = 15+uLog;
+  }
+  else
+  {
+    iFactor_=_b;
+    iShift_ = 0;
+  }
+}
+#endif
+
+INLINE  fixed xInvMulx  (const fixed _a, const s32 _iFact, const s32 _iShift)
+{
+       #ifdef __arm__
+               s64 res;
+               asm ("smull %Q0, %R0, %1, %2" : "=&r" (res) : "r"(_a) , "r"(_iFact));
+               return fixed(res>>_iShift);
+       #else
+               return fixed( ((s64)(_a)*(s64)(_iFact))>>(_iShift) );
+       #endif
+}
+
+INLINE  fixed xLoDivx   (const fixed _a, const fixed _b)
+{
+  s32 iFact, iShift;
+  xInv(_b, iFact, iShift);
+  return xInvMulx(_a, iFact, iShift);
+}
+
+///////////////////////////////////////////////////////////////////////////
+template<typename T>
+INLINE  T Min2 (const T _a, const T _b)             { return (_a<_b)?_a:_b; }
+
+template<typename T>
+INLINE  T Min3 (const T _a, const T _b, const T _c) { return  Min2(Min2(_a,_b),_c); }
+
+///////////////////////////////////////////////////////////////////////////
+template<typename T>
+INLINE  T Max2 (const T _a, const T _b)             { return  (_a>_b)?_a:_b; }
+
+template<typename T>
+INLINE  T Max3 (const T _a, const T _b, const T _c) { return  Max2(Max2(_a,_b),_c); }
+
+///////////////////////////////////////////////////////////////////////////
+#endif  //FIXED_H

diff --git a/plugins/gpu_unai/gpu_inner.h b/plugins/gpu_unai/gpu_inner.h
new file mode 100644 (file)
index 0000000..6c18c63
--- /dev/null
+++ b/plugins/gpu_unai/gpu_inner.h
@@ -0,0 +1,427 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//  Inner loop driver instanciation file
+
+///////////////////////////////////////////////////////////////////////////////
+//  Option Masks
+#define   L ((CF>>0)&1)
+#define   B ((CF>>1)&1)
+#define   M ((CF>>2)&1)
+#define  BM ((CF>>3)&3)
+#define  TM ((CF>>5)&3)
+#define   G ((CF>>7)&1)
+
+#define  AH ((CF>>7)&1)
+
+#define  MB ((CF>>8)&1)
+
+#include "gpu_inner_blend.h"
+#include "gpu_inner_light.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Pixel opperations generator
+template<const int CF>
+INLINE void gpuPixelFn(u16 *pixel,const u16 data)
+{
+       if ((!M)&&(!B))
+       {
+               if(MB) { *pixel = data | 0x8000; }
+               else   { *pixel = data; }
+       }
+       else if ((M)&&(!B))
+       {
+               if (!(*pixel&0x8000))
+               {
+                       if(MB) { *pixel = data | 0x8000; }
+                       else   { *pixel = data; }
+               }
+       }
+       else
+       {
+               u16 uDst = *pixel;
+               if(M) { if (uDst&0x8000) return; }
+               u16 uSrc = data;
+               u32 uMsk; if (BM==0) uMsk=0x7BDE;
+               if (BM==0) gpuBlending00(uSrc, uDst);
+               if (BM==1) gpuBlending01(uSrc, uDst);
+               if (BM==2) gpuBlending02(uSrc, uDst);
+               if (BM==3) gpuBlending03(uSrc, uDst);
+               if(MB) { *pixel = uSrc | 0x8000; }
+               else   { *pixel = uSrc; }
+       }
+}
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+//  Pixel drawing drivers, for lines (only blending)
+typedef void (*PD)(u16 *pixel,const u16 data);
+const PD  gpuPixelDrivers[32] =   //  We only generate pixel op for MASKING/BLEND_ENABLE/BLEND_MODE
+{ 
+       gpuPixelFn<0x00<<1>,gpuPixelFn<0x01<<1>,gpuPixelFn<0x02<<1>,gpuPixelFn<0x03<<1>,  
+       NULL,gpuPixelFn<0x05<<1>,NULL,gpuPixelFn<0x07<<1>,
+       NULL,gpuPixelFn<0x09<<1>,NULL,gpuPixelFn<0x0B<<1>,
+       NULL,gpuPixelFn<0x0D<<1>,NULL,gpuPixelFn<0x0F<<1>,
+
+       gpuPixelFn<(0x00<<1)|256>,gpuPixelFn<(0x01<<1)|256>,gpuPixelFn<(0x02<<1)|256>,gpuPixelFn<(0x03<<1)|256>,  
+       NULL,gpuPixelFn<(0x05<<1)|256>,NULL,gpuPixelFn<(0x07<<1)|256>,
+       NULL,gpuPixelFn<(0x09<<1)|256>,NULL,gpuPixelFn<(0x0B<<1)|256>,
+       NULL,gpuPixelFn<(0x0D<<1)|256>,NULL,gpuPixelFn<(0x0F<<1)|256>
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Tiles innerloops generator
+
+template<const int CF>
+INLINE void  gpuTileSpanFn(u16 *pDst, u32 count, u16 data)
+{
+       if ((!M)&&(!B))
+       {
+               if (MB) { data = data | 0x8000; }
+               do { *pDst++ = data; } while (--count);
+       }
+       else if ((M)&&(!B))
+       {
+               if (MB) { data = data | 0x8000; }
+               do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count);
+       }
+       else
+       {
+               u16 uSrc;
+               u16 uDst;
+               u32 uMsk; if (BM==0) uMsk=0x7BDE;
+               do
+               {
+                       //  MASKING
+                       uDst = *pDst;
+                       if(M) { if (uDst&0x8000) goto endtile;  }
+                       uSrc = data;
+
+                       //  BLEND
+                       if (BM==0) gpuBlending00(uSrc, uDst);
+                       if (BM==1) gpuBlending01(uSrc, uDst);
+                       if (BM==2) gpuBlending02(uSrc, uDst);
+                       if (BM==3) gpuBlending03(uSrc, uDst);
+
+                       if (MB) { *pDst = uSrc | 0x8000; }
+                       else    { *pDst = uSrc; }
+                       endtile: pDst++;
+               }
+               while (--count);
+       }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Tiles innerloops driver
+typedef void (*PT)(u16 *pDst, u32 count, u16 data);
+const PT gpuTileSpanDrivers[64] = 
+{
+       gpuTileSpanFn<0x00>,NULL,gpuTileSpanFn<0x02>,NULL,  gpuTileSpanFn<0x04>,NULL,gpuTileSpanFn<0x06>,NULL,  NULL,NULL,gpuTileSpanFn<0x0A>,NULL,  NULL,NULL,gpuTileSpanFn<0x0E>,NULL,
+       NULL,NULL,gpuTileSpanFn<0x12>,NULL,  NULL,NULL,gpuTileSpanFn<0x16>,NULL,  NULL,NULL,gpuTileSpanFn<0x1A>,NULL,  NULL,NULL,gpuTileSpanFn<0x1E>,NULL,
+
+       gpuTileSpanFn<0x100>,NULL,gpuTileSpanFn<0x102>,NULL,  gpuTileSpanFn<0x104>,NULL,gpuTileSpanFn<0x106>,NULL,  NULL,NULL,gpuTileSpanFn<0x10A>,NULL,  NULL,NULL,gpuTileSpanFn<0x10E>,NULL,
+       NULL,NULL,gpuTileSpanFn<0x112>,NULL,  NULL,NULL,gpuTileSpanFn<0x116>,NULL,  NULL,NULL,gpuTileSpanFn<0x11A>,NULL,  NULL,NULL,gpuTileSpanFn<0x11E>,NULL,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Sprites innerloops generator
+
+template<const int CF>
+INLINE void  gpuSpriteSpanFn(u16 *pDst, u32 count, u32 u0, const u32 mask)
+{
+       u16 uSrc;
+       u16 uDst;
+       const u16* pTxt = TBA+(u0&~0x1ff); u0=u0&0x1ff;
+       const u16 *_CBA; if(TM!=3) _CBA=CBA;
+       u32 lCol; if(L)  { lCol = ((u32)(b4<< 2)&(0x03ff)) | ((u32)(g4<<13)&(0x07ff<<10)) | ((u32)(r4<<24)&(0x07ff<<21));  }
+       u8 rgb; if (TM==1) rgb = ((u8*)pTxt)[u0>>1];
+       u32 uMsk; if ((B)&&(BM==0)) uMsk=0x7BDE;
+
+       do
+       {
+               //  MASKING
+               if(M)   { uDst = *pDst;   if (uDst&0x8000) { u0=(u0+1)&mask; goto endsprite; }  }
+
+               //  TEXTURE MAPPING
+               if (TM==1) { if (!(u0&1)) rgb = ((u8*)pTxt)[u0>>1]; uSrc = _CBA[(rgb>>((u0&1)<<2))&0xf]; u0=(u0+1)&mask; }
+               if (TM==2) { uSrc = _CBA[((u8*)pTxt)[u0]]; u0=(u0+1)&mask; }
+               if (TM==3) { uSrc = pTxt[u0]; u0=(u0+1)&mask; }
+               if(!AH) { if (!uSrc) goto endsprite; }
+
+               //  BLEND
+               if(B)
+               {
+                       if(uSrc&0x8000)
+                       {
+                               //  LIGHTING CALCULATIONS
+                               if(L)  { gpuLightingTXT(uSrc, lCol);   }
+
+                               if(!M)    { uDst = *pDst; }
+                               if (BM==0) gpuBlending00(uSrc, uDst);
+                               if (BM==1) gpuBlending01(uSrc, uDst);
+                               if (BM==2) gpuBlending02(uSrc, uDst);
+                               if (BM==3) gpuBlending03(uSrc, uDst);
+                       }
+                       else
+                       {
+                               //  LIGHTING CALCULATIONS
+                               if(L)  { gpuLightingTXT(uSrc, lCol); }
+                       }
+               }
+               else
+               {
+                       //  LIGHTING CALCULATIONS
+                       if(L)  { gpuLightingTXT(uSrc, lCol);   } else
+                       { if(!MB) uSrc&= 0x7fff;               }
+               }
+
+               if (MB) { *pDst = uSrc | 0x8000; }
+               else    { *pDst = uSrc; }
+               
+               endsprite: pDst++;
+       }
+       while (--count);
+}
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+//  Sprite innerloops driver
+typedef void (*PS)(u16 *pDst, u32 count, u32 u0, const u32 mask);
+const PS gpuSpriteSpanDrivers[512] = 
+{
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       gpuSpriteSpanFn<0x20>,gpuSpriteSpanFn<0x21>,gpuSpriteSpanFn<0x22>,gpuSpriteSpanFn<0x23>,  gpuSpriteSpanFn<0x24>,gpuSpriteSpanFn<0x25>,gpuSpriteSpanFn<0x26>,gpuSpriteSpanFn<0x27>,  NULL,NULL,gpuSpriteSpanFn<0x2A>,gpuSpriteSpanFn<0x2B>,  NULL,NULL,gpuSpriteSpanFn<0x2E>,gpuSpriteSpanFn<0x2F>,
+       NULL,NULL,gpuSpriteSpanFn<0x32>,gpuSpriteSpanFn<0x33>,  NULL,NULL,gpuSpriteSpanFn<0x36>,gpuSpriteSpanFn<0x37>,  NULL,NULL,gpuSpriteSpanFn<0x3A>,gpuSpriteSpanFn<0x3B>,  NULL,NULL,gpuSpriteSpanFn<0x3E>,gpuSpriteSpanFn<0x3F>,
+       gpuSpriteSpanFn<0x40>,gpuSpriteSpanFn<0x41>,gpuSpriteSpanFn<0x42>,gpuSpriteSpanFn<0x43>,  gpuSpriteSpanFn<0x44>,gpuSpriteSpanFn<0x45>,gpuSpriteSpanFn<0x46>,gpuSpriteSpanFn<0x47>,  NULL,NULL,gpuSpriteSpanFn<0x4A>,gpuSpriteSpanFn<0x4B>,  NULL,NULL,gpuSpriteSpanFn<0x4E>,gpuSpriteSpanFn<0x4F>,
+       NULL,NULL,gpuSpriteSpanFn<0x52>,gpuSpriteSpanFn<0x53>,  NULL,NULL,gpuSpriteSpanFn<0x56>,gpuSpriteSpanFn<0x57>,  NULL,NULL,gpuSpriteSpanFn<0x5A>,gpuSpriteSpanFn<0x5B>,  NULL,NULL,gpuSpriteSpanFn<0x5E>,gpuSpriteSpanFn<0x5F>,
+       gpuSpriteSpanFn<0x60>,gpuSpriteSpanFn<0x61>,gpuSpriteSpanFn<0x62>,gpuSpriteSpanFn<0x63>,  gpuSpriteSpanFn<0x64>,gpuSpriteSpanFn<0x65>,gpuSpriteSpanFn<0x66>,gpuSpriteSpanFn<0x67>,  NULL,NULL,gpuSpriteSpanFn<0x6A>,gpuSpriteSpanFn<0x6B>,  NULL,NULL,gpuSpriteSpanFn<0x6E>,gpuSpriteSpanFn<0x6F>,
+       NULL,NULL,gpuSpriteSpanFn<0x72>,gpuSpriteSpanFn<0x73>,  NULL,NULL,gpuSpriteSpanFn<0x76>,gpuSpriteSpanFn<0x77>,  NULL,NULL,gpuSpriteSpanFn<0x7A>,gpuSpriteSpanFn<0x7B>,  NULL,NULL,gpuSpriteSpanFn<0x7E>,gpuSpriteSpanFn<0x7F>,
+
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       gpuSpriteSpanFn<0xa0>,gpuSpriteSpanFn<0xa1>,gpuSpriteSpanFn<0xa2>,gpuSpriteSpanFn<0xa3>,  gpuSpriteSpanFn<0xa4>,gpuSpriteSpanFn<0xa5>,gpuSpriteSpanFn<0xa6>,gpuSpriteSpanFn<0xa7>,  NULL,NULL,gpuSpriteSpanFn<0xaA>,gpuSpriteSpanFn<0xaB>,  NULL,NULL,gpuSpriteSpanFn<0xaE>,gpuSpriteSpanFn<0xaF>,
+       NULL,NULL,gpuSpriteSpanFn<0xb2>,gpuSpriteSpanFn<0xb3>,  NULL,NULL,gpuSpriteSpanFn<0xb6>,gpuSpriteSpanFn<0xb7>,  NULL,NULL,gpuSpriteSpanFn<0xbA>,gpuSpriteSpanFn<0xbB>,  NULL,NULL,gpuSpriteSpanFn<0xbE>,gpuSpriteSpanFn<0xbF>,
+       gpuSpriteSpanFn<0xc0>,gpuSpriteSpanFn<0xc1>,gpuSpriteSpanFn<0xc2>,gpuSpriteSpanFn<0xc3>,  gpuSpriteSpanFn<0xc4>,gpuSpriteSpanFn<0xc5>,gpuSpriteSpanFn<0xc6>,gpuSpriteSpanFn<0xc7>,  NULL,NULL,gpuSpriteSpanFn<0xcA>,gpuSpriteSpanFn<0xcB>,  NULL,NULL,gpuSpriteSpanFn<0xcE>,gpuSpriteSpanFn<0xcF>,
+       NULL,NULL,gpuSpriteSpanFn<0xd2>,gpuSpriteSpanFn<0xd3>,  NULL,NULL,gpuSpriteSpanFn<0xd6>,gpuSpriteSpanFn<0xd7>,  NULL,NULL,gpuSpriteSpanFn<0xdA>,gpuSpriteSpanFn<0xdB>,  NULL,NULL,gpuSpriteSpanFn<0xdE>,gpuSpriteSpanFn<0xdF>,
+       gpuSpriteSpanFn<0xe0>,gpuSpriteSpanFn<0xe1>,gpuSpriteSpanFn<0xe2>,gpuSpriteSpanFn<0xe3>,  gpuSpriteSpanFn<0xe4>,gpuSpriteSpanFn<0xe5>,gpuSpriteSpanFn<0xe6>,gpuSpriteSpanFn<0xe7>,  NULL,NULL,gpuSpriteSpanFn<0xeA>,gpuSpriteSpanFn<0xeB>,  NULL,NULL,gpuSpriteSpanFn<0xeE>,gpuSpriteSpanFn<0xeF>,
+       NULL,NULL,gpuSpriteSpanFn<0xf2>,gpuSpriteSpanFn<0xf3>,  NULL,NULL,gpuSpriteSpanFn<0xf6>,gpuSpriteSpanFn<0xf7>,  NULL,NULL,gpuSpriteSpanFn<0xfA>,gpuSpriteSpanFn<0xfB>,  NULL,NULL,gpuSpriteSpanFn<0xfE>,gpuSpriteSpanFn<0xfF>,
+
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       gpuSpriteSpanFn<0x120>,gpuSpriteSpanFn<0x121>,gpuSpriteSpanFn<0x122>,gpuSpriteSpanFn<0x123>,  gpuSpriteSpanFn<0x124>,gpuSpriteSpanFn<0x125>,gpuSpriteSpanFn<0x126>,gpuSpriteSpanFn<0x127>,  NULL,NULL,gpuSpriteSpanFn<0x12A>,gpuSpriteSpanFn<0x12B>,  NULL,NULL,gpuSpriteSpanFn<0x12E>,gpuSpriteSpanFn<0x12F>,
+       NULL,NULL,gpuSpriteSpanFn<0x132>,gpuSpriteSpanFn<0x133>,  NULL,NULL,gpuSpriteSpanFn<0x136>,gpuSpriteSpanFn<0x137>,  NULL,NULL,gpuSpriteSpanFn<0x13A>,gpuSpriteSpanFn<0x13B>,  NULL,NULL,gpuSpriteSpanFn<0x13E>,gpuSpriteSpanFn<0x13F>,
+       gpuSpriteSpanFn<0x140>,gpuSpriteSpanFn<0x141>,gpuSpriteSpanFn<0x142>,gpuSpriteSpanFn<0x143>,  gpuSpriteSpanFn<0x144>,gpuSpriteSpanFn<0x145>,gpuSpriteSpanFn<0x146>,gpuSpriteSpanFn<0x147>,  NULL,NULL,gpuSpriteSpanFn<0x14A>,gpuSpriteSpanFn<0x14B>,  NULL,NULL,gpuSpriteSpanFn<0x14E>,gpuSpriteSpanFn<0x14F>,
+       NULL,NULL,gpuSpriteSpanFn<0x152>,gpuSpriteSpanFn<0x153>,  NULL,NULL,gpuSpriteSpanFn<0x156>,gpuSpriteSpanFn<0x157>,  NULL,NULL,gpuSpriteSpanFn<0x15A>,gpuSpriteSpanFn<0x15B>,  NULL,NULL,gpuSpriteSpanFn<0x15E>,gpuSpriteSpanFn<0x15F>,
+       gpuSpriteSpanFn<0x160>,gpuSpriteSpanFn<0x161>,gpuSpriteSpanFn<0x162>,gpuSpriteSpanFn<0x163>,  gpuSpriteSpanFn<0x164>,gpuSpriteSpanFn<0x165>,gpuSpriteSpanFn<0x166>,gpuSpriteSpanFn<0x167>,  NULL,NULL,gpuSpriteSpanFn<0x16A>,gpuSpriteSpanFn<0x16B>,  NULL,NULL,gpuSpriteSpanFn<0x16E>,gpuSpriteSpanFn<0x16F>,
+       NULL,NULL,gpuSpriteSpanFn<0x172>,gpuSpriteSpanFn<0x173>,  NULL,NULL,gpuSpriteSpanFn<0x176>,gpuSpriteSpanFn<0x177>,  NULL,NULL,gpuSpriteSpanFn<0x17A>,gpuSpriteSpanFn<0x17B>,  NULL,NULL,gpuSpriteSpanFn<0x17E>,gpuSpriteSpanFn<0x17F>,
+                                                                                                                                                                                                                                                                                                                                                                                      
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+       gpuSpriteSpanFn<0x1a0>,gpuSpriteSpanFn<0x1a1>,gpuSpriteSpanFn<0x1a2>,gpuSpriteSpanFn<0x1a3>,  gpuSpriteSpanFn<0x1a4>,gpuSpriteSpanFn<0x1a5>,gpuSpriteSpanFn<0x1a6>,gpuSpriteSpanFn<0x1a7>,  NULL,NULL,gpuSpriteSpanFn<0x1aA>,gpuSpriteSpanFn<0x1aB>,  NULL,NULL,gpuSpriteSpanFn<0x1aE>,gpuSpriteSpanFn<0x1aF>,
+       NULL,NULL,gpuSpriteSpanFn<0x1b2>,gpuSpriteSpanFn<0x1b3>,  NULL,NULL,gpuSpriteSpanFn<0x1b6>,gpuSpriteSpanFn<0x1b7>,  NULL,NULL,gpuSpriteSpanFn<0x1bA>,gpuSpriteSpanFn<0x1bB>,  NULL,NULL,gpuSpriteSpanFn<0x1bE>,gpuSpriteSpanFn<0x1bF>,
+       gpuSpriteSpanFn<0x1c0>,gpuSpriteSpanFn<0x1c1>,gpuSpriteSpanFn<0x1c2>,gpuSpriteSpanFn<0x1c3>,  gpuSpriteSpanFn<0x1c4>,gpuSpriteSpanFn<0x1c5>,gpuSpriteSpanFn<0x1c6>,gpuSpriteSpanFn<0x1c7>,  NULL,NULL,gpuSpriteSpanFn<0x1cA>,gpuSpriteSpanFn<0x1cB>,  NULL,NULL,gpuSpriteSpanFn<0x1cE>,gpuSpriteSpanFn<0x1cF>,
+       NULL,NULL,gpuSpriteSpanFn<0x1d2>,gpuSpriteSpanFn<0x1d3>,  NULL,NULL,gpuSpriteSpanFn<0x1d6>,gpuSpriteSpanFn<0x1d7>,  NULL,NULL,gpuSpriteSpanFn<0x1dA>,gpuSpriteSpanFn<0x1dB>,  NULL,NULL,gpuSpriteSpanFn<0x1dE>,gpuSpriteSpanFn<0x1dF>,
+       gpuSpriteSpanFn<0x1e0>,gpuSpriteSpanFn<0x1e1>,gpuSpriteSpanFn<0x1e2>,gpuSpriteSpanFn<0x1e3>,  gpuSpriteSpanFn<0x1e4>,gpuSpriteSpanFn<0x1e5>,gpuSpriteSpanFn<0x1e6>,gpuSpriteSpanFn<0x1e7>,  NULL,NULL,gpuSpriteSpanFn<0x1eA>,gpuSpriteSpanFn<0x1eB>,  NULL,NULL,gpuSpriteSpanFn<0x1eE>,gpuSpriteSpanFn<0x1eF>,
+       NULL,NULL,gpuSpriteSpanFn<0x1f2>,gpuSpriteSpanFn<0x1f3>,  NULL,NULL,gpuSpriteSpanFn<0x1f6>,gpuSpriteSpanFn<0x1f7>,  NULL,NULL,gpuSpriteSpanFn<0x1fA>,gpuSpriteSpanFn<0x1fB>,  NULL,NULL,gpuSpriteSpanFn<0x1fE>,gpuSpriteSpanFn<0x1fF>
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU Polygon innerloops generator
+template<const int CF>
+INLINE void  gpuPolySpanFn(u16 *pDst, u32 count)
+{
+       if (!TM)
+       {       
+               // NO TEXTURE
+               if (!G)
+               {
+                       // NO GOURAUD
+                       u16 data;
+                       if (L) { u32 lCol=((u32)(b4<< 2)&(0x03ff)) | ((u32)(g4<<13)&(0x07ff<<10)) | ((u32)(r4<<24)&(0x07ff<<21)); gpuLightingRGB(data,lCol); }
+                       else data=PixelData;
+                       if ((!M)&&(!B))
+                       {
+                               if (MB) { data = data | 0x8000; }
+                               do { *pDst++ = data; } while (--count);
+                       }
+                       else if ((M)&&(!B))
+                       {
+                               if (MB) { data = data | 0x8000; }
+                               do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count);
+                       }
+                       else
+                       {
+                               u16 uSrc;
+                               u16 uDst;
+                               u32 uMsk; if (BM==0) uMsk=0x7BDE;
+                               do
+                               {
+                                       //  masking
+                                       uDst = *pDst;
+                                       if(M) { if (uDst&0x8000) goto endtile;  }
+                                       uSrc = data;
+                                       //  blend
+                                       if (BM==0) gpuBlending00(uSrc, uDst);
+                                       if (BM==1) gpuBlending01(uSrc, uDst);
+                                       if (BM==2) gpuBlending02(uSrc, uDst);
+                                       if (BM==3) gpuBlending03(uSrc, uDst);
+                                       if (MB) { *pDst = uSrc | 0x8000; }
+                                       else    { *pDst = uSrc; }
+                                       endtile: pDst++;
+                               }
+                               while (--count);
+                       }
+               }
+               else
+               {
+                       // GOURAUD
+                       u16 uDst;
+                       u16 uSrc;
+                       u32 linc=lInc;
+                       u32 lCol=((u32)(b4>>14)&(0x03ff)) | ((u32)(g4>>3)&(0x07ff<<10)) | ((u32)(r4<<8)&(0x07ff<<21));
+                       u32 uMsk; if ((B)&&(BM==0)) uMsk=0x7BDE;
+                       do
+                       {
+                               //  masking
+                               if(M) { uDst = *pDst;  if (uDst&0x8000) goto endgou;  }
+                               //  blend
+                               if(B)
+                               {
+                                       //  light
+                                       gpuLightingRGB(uSrc,lCol);
+                                       if(!M)    { uDst = *pDst; }
+                                       if (BM==0) gpuBlending00(uSrc, uDst);
+                                       if (BM==1) gpuBlending01(uSrc, uDst);
+                                       if (BM==2) gpuBlending02(uSrc, uDst);
+                                       if (BM==3) gpuBlending03(uSrc, uDst);
+                               }
+                               else
+                               {
+                                       //  light
+                                       gpuLightingRGB(uSrc,lCol);
+                               }
+                               if (MB) { *pDst = uSrc | 0x8000; }
+                               else    { *pDst = uSrc; }
+                               endgou: pDst++; lCol=(lCol+linc);
+                       }
+                       while (--count);
+               }
+       }
+       else
+       {
+               // TEXTURE
+               u16 uDst;
+               u16 uSrc;
+               u32 linc; if (L&&G) linc=lInc;
+               u32 tinc=tInc;
+               u32 tmsk=tMsk;
+               u32 tCor = ((u32)( u4<<7)&0x7fff0000) | ((u32)( v4>>9)&0x00007fff); tCor&= tmsk;
+               const u16* _TBA=TBA;
+               const u16* _CBA; if (TM!=3) _CBA=CBA;
+               u32 lCol;
+               if(L && !G) { lCol = ((u32)(b4<< 2)&(0x03ff)) | ((u32)(g4<<13)&(0x07ff<<10)) | ((u32)(r4<<24)&(0x07ff<<21)); }
+               else if(L && G) { lCol = ((u32)(b4>>14)&(0x03ff)) | ((u32)(g4>>3)&(0x07ff<<10)) | ((u32)(r4<<8)&(0x07ff<<21));  }
+               u32 uMsk; if ((B)&&(BM==0)) uMsk=0x7BDE;
+               do
+               {
+                       //  masking
+                       if(M) { uDst = *pDst;  if (uDst&0x8000) goto endpoly;  }
+                       //  texture
+                       if (TM==1) { u32 tu=(tCor>>23); u32 tv=(tCor<<4)&(0xff<<11); u8 rgb=((u8*)_TBA)[tv+(tu>>1)]; uSrc=_CBA[(rgb>>((tu&1)<<2))&0xf]; if(!uSrc) goto endpoly; }
+                       if (TM==2) { uSrc = _CBA[(((u8*)_TBA)[(tCor>>23)+((tCor<<4)&(0xff<<11))])]; if(!uSrc)  goto endpoly; }
+                       if (TM==3) { uSrc = _TBA[(tCor>>23)+((tCor<<3)&(0xff<<10))]; if(!uSrc)  goto endpoly; }
+                       //  blend
+                       if(B)
+                       {
+                               if (uSrc&0x8000)
+                               {
+                                       //  light
+                                       if(L) gpuLightingTXT(uSrc, lCol);
+                                       if(!M)    { uDst = *pDst; }
+                                       if (BM==0) gpuBlending00(uSrc, uDst);
+                                       if (BM==1) gpuBlending01(uSrc, uDst);
+                                       if (BM==2) gpuBlending02(uSrc, uDst);
+                                       if (BM==3) gpuBlending03(uSrc, uDst);
+                               }
+                               else
+                               {
+                                       // light
+                                       if(L) gpuLightingTXT(uSrc, lCol);
+                               }
+                       }
+                       else
+                       {
+                               //  light
+                               if(L)  { gpuLightingTXT(uSrc, lCol); } else if(!MB) { uSrc&= 0x7fff; }
+                       }
+                       if (MB) { *pDst = uSrc | 0x8000; }
+                       else    { *pDst = uSrc; }
+                       endpoly: pDst++;
+                       tCor=(tCor+tinc)&tmsk;
+                       if (L&&G) lCol=(lCol+linc);
+               }
+               while (--count);
+       }
+}
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+//  Polygon innerloops driver
+typedef void (*PP)(u16 *pDst, u32 count);
+const PP gpuPolySpanDrivers[512] =
+{
+       gpuPolySpanFn<0x00>,gpuPolySpanFn<0x01>,gpuPolySpanFn<0x02>,gpuPolySpanFn<0x03>,  gpuPolySpanFn<0x04>,gpuPolySpanFn<0x05>,gpuPolySpanFn<0x06>,gpuPolySpanFn<0x07>,  NULL,NULL,gpuPolySpanFn<0x0A>,gpuPolySpanFn<0x0B>,  NULL,NULL,gpuPolySpanFn<0x0E>,gpuPolySpanFn<0x0F>,
+       NULL,NULL,gpuPolySpanFn<0x12>,gpuPolySpanFn<0x13>,  NULL,NULL,gpuPolySpanFn<0x16>,gpuPolySpanFn<0x17>,  NULL,NULL,gpuPolySpanFn<0x1A>,gpuPolySpanFn<0x1B>,  NULL,NULL,gpuPolySpanFn<0x1E>,gpuPolySpanFn<0x1F>,
+       gpuPolySpanFn<0x20>,gpuPolySpanFn<0x21>,gpuPolySpanFn<0x22>,gpuPolySpanFn<0x23>,  gpuPolySpanFn<0x24>,gpuPolySpanFn<0x25>,gpuPolySpanFn<0x26>,gpuPolySpanFn<0x27>,  NULL,NULL,gpuPolySpanFn<0x2A>,gpuPolySpanFn<0x2B>,  NULL,NULL,gpuPolySpanFn<0x2E>,gpuPolySpanFn<0x2F>,
+       NULL,NULL,gpuPolySpanFn<0x32>,gpuPolySpanFn<0x33>,  NULL,NULL,gpuPolySpanFn<0x36>,gpuPolySpanFn<0x37>,  NULL,NULL,gpuPolySpanFn<0x3A>,gpuPolySpanFn<0x3B>,  NULL,NULL,gpuPolySpanFn<0x3E>,gpuPolySpanFn<0x3F>,
+       gpuPolySpanFn<0x40>,gpuPolySpanFn<0x41>,gpuPolySpanFn<0x42>,gpuPolySpanFn<0x43>,  gpuPolySpanFn<0x44>,gpuPolySpanFn<0x45>,gpuPolySpanFn<0x46>,gpuPolySpanFn<0x47>,  NULL,NULL,gpuPolySpanFn<0x4A>,gpuPolySpanFn<0x4B>,  NULL,NULL,gpuPolySpanFn<0x4E>,gpuPolySpanFn<0x4F>,
+       NULL,NULL,gpuPolySpanFn<0x52>,gpuPolySpanFn<0x53>,  NULL,NULL,gpuPolySpanFn<0x56>,gpuPolySpanFn<0x57>,  NULL,NULL,gpuPolySpanFn<0x5A>,gpuPolySpanFn<0x5B>,  NULL,NULL,gpuPolySpanFn<0x5E>,gpuPolySpanFn<0x5F>,
+       gpuPolySpanFn<0x60>,gpuPolySpanFn<0x61>,gpuPolySpanFn<0x62>,gpuPolySpanFn<0x63>,  gpuPolySpanFn<0x64>,gpuPolySpanFn<0x65>,gpuPolySpanFn<0x66>,gpuPolySpanFn<0x67>,  NULL,NULL,gpuPolySpanFn<0x6A>,gpuPolySpanFn<0x6B>,  NULL,NULL,gpuPolySpanFn<0x6E>,gpuPolySpanFn<0x6F>,
+       NULL,NULL,gpuPolySpanFn<0x72>,gpuPolySpanFn<0x73>,  NULL,NULL,gpuPolySpanFn<0x76>,gpuPolySpanFn<0x77>,  NULL,NULL,gpuPolySpanFn<0x7A>,gpuPolySpanFn<0x7B>,  NULL,NULL,gpuPolySpanFn<0x7E>,gpuPolySpanFn<0x7F>,
+
+       NULL,gpuPolySpanFn<0x81>,NULL,gpuPolySpanFn<0x83>,  NULL,gpuPolySpanFn<0x85>,NULL,gpuPolySpanFn<0x87>,  NULL,NULL,NULL,gpuPolySpanFn<0x8B>,  NULL,NULL,NULL,gpuPolySpanFn<0x8F>,
+       NULL,NULL,NULL,gpuPolySpanFn<0x93>,  NULL,NULL,NULL,gpuPolySpanFn<0x97>,  NULL,NULL,NULL,gpuPolySpanFn<0x9B>,  NULL,NULL,NULL,gpuPolySpanFn<0x9F>,
+       NULL,gpuPolySpanFn<0xa1>,NULL,gpuPolySpanFn<0xa3>,  NULL,gpuPolySpanFn<0xa5>,NULL,gpuPolySpanFn<0xa7>,  NULL,NULL,NULL,gpuPolySpanFn<0xaB>,  NULL,NULL,NULL,gpuPolySpanFn<0xaF>,
+       NULL,NULL,NULL,gpuPolySpanFn<0xb3>,  NULL,NULL,NULL,gpuPolySpanFn<0xb7>,  NULL,NULL,NULL,gpuPolySpanFn<0xbB>,  NULL,NULL,NULL,gpuPolySpanFn<0xbF>,
+       NULL,gpuPolySpanFn<0xc1>,NULL,gpuPolySpanFn<0xc3>,  NULL,gpuPolySpanFn<0xc5>,NULL,gpuPolySpanFn<0xc7>,  NULL,NULL,NULL,gpuPolySpanFn<0xcB>,  NULL,NULL,NULL,gpuPolySpanFn<0xcF>,
+       NULL,NULL,NULL,gpuPolySpanFn<0xd3>,  NULL,NULL,NULL,gpuPolySpanFn<0xd7>,  NULL,NULL,NULL,gpuPolySpanFn<0xdB>,  NULL,NULL,NULL,gpuPolySpanFn<0xdF>,
+       NULL,gpuPolySpanFn<0xe1>,NULL,gpuPolySpanFn<0xe3>,  NULL,gpuPolySpanFn<0xe5>,NULL,gpuPolySpanFn<0xe7>,  NULL,NULL,NULL,gpuPolySpanFn<0xeB>,  NULL,NULL,NULL,gpuPolySpanFn<0xeF>,
+       NULL,NULL,NULL,gpuPolySpanFn<0xf3>,  NULL,NULL,NULL,gpuPolySpanFn<0xf7>,  NULL,NULL,NULL,gpuPolySpanFn<0xfB>,  NULL,NULL,NULL,gpuPolySpanFn<0xfF>,
+
+       gpuPolySpanFn<0x100>,gpuPolySpanFn<0x101>,gpuPolySpanFn<0x102>,gpuPolySpanFn<0x103>,  gpuPolySpanFn<0x104>,gpuPolySpanFn<0x105>,gpuPolySpanFn<0x106>,gpuPolySpanFn<0x107>,  NULL,NULL,gpuPolySpanFn<0x10A>,gpuPolySpanFn<0x10B>,  NULL,NULL,gpuPolySpanFn<0x10E>,gpuPolySpanFn<0x10F>,
+       NULL,NULL,gpuPolySpanFn<0x112>,gpuPolySpanFn<0x113>,  NULL,NULL,gpuPolySpanFn<0x116>,gpuPolySpanFn<0x117>,  NULL,NULL,gpuPolySpanFn<0x11A>,gpuPolySpanFn<0x11B>,  NULL,NULL,gpuPolySpanFn<0x11E>,gpuPolySpanFn<0x11F>,
+       gpuPolySpanFn<0x120>,gpuPolySpanFn<0x121>,gpuPolySpanFn<0x122>,gpuPolySpanFn<0x123>,  gpuPolySpanFn<0x124>,gpuPolySpanFn<0x125>,gpuPolySpanFn<0x126>,gpuPolySpanFn<0x127>,  NULL,NULL,gpuPolySpanFn<0x12A>,gpuPolySpanFn<0x12B>,  NULL,NULL,gpuPolySpanFn<0x12E>,gpuPolySpanFn<0x12F>,
+       NULL,NULL,gpuPolySpanFn<0x132>,gpuPolySpanFn<0x133>,  NULL,NULL,gpuPolySpanFn<0x136>,gpuPolySpanFn<0x137>,  NULL,NULL,gpuPolySpanFn<0x13A>,gpuPolySpanFn<0x13B>,  NULL,NULL,gpuPolySpanFn<0x13E>,gpuPolySpanFn<0x13F>,
+       gpuPolySpanFn<0x140>,gpuPolySpanFn<0x141>,gpuPolySpanFn<0x142>,gpuPolySpanFn<0x143>,  gpuPolySpanFn<0x144>,gpuPolySpanFn<0x145>,gpuPolySpanFn<0x146>,gpuPolySpanFn<0x147>,  NULL,NULL,gpuPolySpanFn<0x14A>,gpuPolySpanFn<0x14B>,  NULL,NULL,gpuPolySpanFn<0x14E>,gpuPolySpanFn<0x14F>,
+       NULL,NULL,gpuPolySpanFn<0x152>,gpuPolySpanFn<0x153>,  NULL,NULL,gpuPolySpanFn<0x156>,gpuPolySpanFn<0x157>,  NULL,NULL,gpuPolySpanFn<0x15A>,gpuPolySpanFn<0x15B>,  NULL,NULL,gpuPolySpanFn<0x15E>,gpuPolySpanFn<0x15F>,
+       gpuPolySpanFn<0x160>,gpuPolySpanFn<0x161>,gpuPolySpanFn<0x162>,gpuPolySpanFn<0x163>,  gpuPolySpanFn<0x164>,gpuPolySpanFn<0x165>,gpuPolySpanFn<0x166>,gpuPolySpanFn<0x167>,  NULL,NULL,gpuPolySpanFn<0x16A>,gpuPolySpanFn<0x16B>,  NULL,NULL,gpuPolySpanFn<0x16E>,gpuPolySpanFn<0x16F>,
+       NULL,NULL,gpuPolySpanFn<0x172>,gpuPolySpanFn<0x173>,  NULL,NULL,gpuPolySpanFn<0x176>,gpuPolySpanFn<0x177>,  NULL,NULL,gpuPolySpanFn<0x17A>,gpuPolySpanFn<0x17B>,  NULL,NULL,gpuPolySpanFn<0x17E>,gpuPolySpanFn<0x17F>,
+                                                                                                                                                                                                                                                                                                                                                                                      
+       NULL,gpuPolySpanFn<0x181>,NULL,gpuPolySpanFn<0x183>,  NULL,gpuPolySpanFn<0x185>,NULL,gpuPolySpanFn<0x187>,  NULL,NULL,NULL,gpuPolySpanFn<0x18B>,  NULL,NULL,NULL,gpuPolySpanFn<0x18F>,
+       NULL,NULL,NULL,gpuPolySpanFn<0x193>,  NULL,NULL,NULL,gpuPolySpanFn<0x197>,  NULL,NULL,NULL,gpuPolySpanFn<0x19B>,  NULL,NULL,NULL,gpuPolySpanFn<0x19F>,
+       NULL,gpuPolySpanFn<0x1a1>,NULL,gpuPolySpanFn<0x1a3>,  NULL,gpuPolySpanFn<0x1a5>,NULL,gpuPolySpanFn<0x1a7>,  NULL,NULL,NULL,gpuPolySpanFn<0x1aB>,  NULL,NULL,NULL,gpuPolySpanFn<0x1aF>,
+       NULL,NULL,NULL,gpuPolySpanFn<0x1b3>,  NULL,NULL,NULL,gpuPolySpanFn<0x1b7>,  NULL,NULL,NULL,gpuPolySpanFn<0x1bB>,  NULL,NULL,NULL,gpuPolySpanFn<0x1bF>,
+       NULL,gpuPolySpanFn<0x1c1>,NULL,gpuPolySpanFn<0x1c3>,  NULL,gpuPolySpanFn<0x1c5>,NULL,gpuPolySpanFn<0x1c7>,  NULL,NULL,NULL,gpuPolySpanFn<0x1cB>,  NULL,NULL,NULL,gpuPolySpanFn<0x1cF>,
+       NULL,NULL,NULL,gpuPolySpanFn<0x1d3>,  NULL,NULL,NULL,gpuPolySpanFn<0x1d7>,  NULL,NULL,NULL,gpuPolySpanFn<0x1dB>,  NULL,NULL,NULL,gpuPolySpanFn<0x1dF>,
+       NULL,gpuPolySpanFn<0x1e1>,NULL,gpuPolySpanFn<0x1e3>,  NULL,gpuPolySpanFn<0x1e5>,NULL,gpuPolySpanFn<0x1e7>,  NULL,NULL,NULL,gpuPolySpanFn<0x1eB>,  NULL,NULL,NULL,gpuPolySpanFn<0x1eF>,
+       NULL,NULL,NULL,gpuPolySpanFn<0x1f3>,  NULL,NULL,NULL,gpuPolySpanFn<0x1f7>,  NULL,NULL,NULL,gpuPolySpanFn<0x1fB>,  NULL,NULL,NULL,gpuPolySpanFn<0x1fF>
+};

diff --git a/plugins/gpu_unai/gpu_inner_blend.h b/plugins/gpu_unai/gpu_inner_blend.h
new file mode 100644 (file)
index 0000000..20977ea
--- /dev/null
+++ b/plugins/gpu_unai/gpu_inner_blend.h
@@ -0,0 +1,141 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+#ifndef _OP_BLEND_H_
+#define _OP_BLEND_H_
+
+//  GPU Blending operations functions
+
+#ifdef __arm__
+#define gpuBlending00(uSrc,uDst) \
+{ \
+       asm ("and  %[src], %[src], %[msk]  " : [src] "=r" (uSrc) : "0" (uSrc), [msk] "r" (uMsk)                  ); \
+       asm ("and  %[dst], %[dst], %[msk]  " : [dst] "=r" (uDst) : "0" (uDst), [msk] "r" (uMsk)                  ); \
+       asm ("add  %[src], %[dst], %[src]  " : [src] "=r" (uSrc) :             [dst] "r" (uDst), "0" (uSrc)      ); \
+       asm ("mov  %[src], %[src], lsr #1  " : [src] "=r" (uSrc) : "0" (uSrc)                                    ); \
+}
+#else
+#define gpuBlending00(uSrc,uDst) \
+{ \
+       uSrc = (((uDst & uMsk) + (uSrc & uMsk)) >> 1); \
+}
+#endif
+
+//     1.0 x Back + 1.0 x Forward
+#ifdef __arm__
+#define gpuBlending01(uSrc,uDst) \
+{ \
+       u16 st,dt,out; \
+       asm ("and    %[dt],  %[dst],   #0x7C00  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+       asm ("and    %[st],  %[src],   #0x7C00  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+       asm ("add    %[out], %[dt],    %[st]    " : [out] "=r" (out)  :             [dt]  "r" (dt),   [st]  "r" (st)    ); \
+       asm ("cmp    %[out], #0x7C00            " :                   :             [out] "r" (out) : "cc"              ); \
+       asm ("movhi  %[out], #0x7C00            " : [out] "=r" (out)  : "0" (out)                                       ); \
+       asm ("and    %[dt],  %[dst],   #0x03E0  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+       asm ("and    %[st],  %[src],   #0x03E0  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+       asm ("add    %[dt],  %[dt],    %[st]    " : [dt]  "=r" (dt)   : "0" (dt),   [st]  "r" (st)                      ); \
+       asm ("cmp    %[dt],  #0x03E0            " :                   :             [dt]  "r" (dt) : "cc"               ); \
+       asm ("movhi  %[dt],  #0x03E0            " : [dt]  "=r" (dt)   : "0" (dt)                                        ); \
+       asm ("orr    %[out], %[out],   %[dt]    " : [out] "=r" (out)  : "0" (out),  [dt]  "r" (dt)                      ); \
+       asm ("and    %[dt],  %[dst],   #0x001F  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+       asm ("and    %[st],  %[src],   #0x001F  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+       asm ("add    %[dt],  %[dt],    %[st]    " : [dt]  "=r" (dt)   : "0" (dt),   [st]  "r" (st)                      ); \
+       asm ("cmp    %[dt],  #0x001F            " :                   :             [dt]  "r" (dt) : "cc"               ); \
+       asm ("movhi  %[dt],  #0x001F            " : [dt]  "=r" (dt)   : "0" (dt)                                        ); \
+       asm ("orr    %[uSrc], %[out],   %[dt]   " : [uSrc] "=r" (uSrc)  : [out] "r" (out),  [dt]  "r" (dt)              ); \
+}
+#else
+#define gpuBlending01(uSrc,uDst) \
+{ \
+       u16 rr, gg, bb; \
+       bb = (uDst & 0x7C00) + (uSrc & 0x7C00);   if (bb > 0x7C00)  bb = 0x7C00; \
+       gg = (uDst & 0x03E0) + (uSrc & 0x03E0);   if (gg > 0x03E0)  gg = 0x03E0;  bb |= gg; \
+       rr = (uDst & 0x001F) + (uSrc & 0x001F);   if (rr > 0x001F)  rr = 0x001F;  bb |= rr; \
+       uSrc = bb; \
+}
+#endif
+
+//     1.0 x Back - 1.0 x Forward      */
+#ifdef __arm__
+#define gpuBlending02(uSrc,uDst) \
+{ \
+       u16 st,dt,out; \
+       asm ("and    %[dt],  %[dst],   #0x7C00  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+       asm ("and    %[st],  %[src],   #0x7C00  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+       asm ("subs   %[out], %[dt],    %[st]    " : [out] "=r" (out)  : [dt]  "r" (dt),   [st]  "r" (st) : "cc"         ); \
+       asm ("movmi  %[out], #0x0000            " : [out] "=r" (out)  : "0" (out)                                       ); \
+       asm ("and    %[dt],  %[dst],   #0x03E0  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+       asm ("and    %[st],  %[src],   #0x03E0  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+       asm ("subs   %[dt],  %[dt],    %[st]    " : [dt]  "=r" (dt)   : "0" (dt),   [st]  "r" (st) : "cc"               ); \
+       asm ("orrpl  %[out], %[out],   %[dt]    " : [out] "=r" (out)  : "0" (out),  [dt]  "r" (dt)                      ); \
+       asm ("and    %[dt],  %[dst],   #0x001F  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+       asm ("and    %[st],  %[src],   #0x001F  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+       asm ("subs   %[dt],  %[dt],    %[st]    " : [dt]  "=r" (dt)   : "0" (dt),   [st]  "r" (st) : "cc"               ); \
+       asm ("orrpl  %[out], %[out],   %[dt]    " : [out] "=r" (out)  : "0" (out),  [dt]  "r" (dt)                      ); \
+       asm ("mov %[uSrc], %[out]" : [uSrc] "=r" (uSrc) : [out] "r" (out) ); \
+}
+#else
+#define gpuBlending02(uSrc,uDst) \
+{ \
+       s32 rr, gg, bb; \
+       bb = (uDst & 0x7C00) - (uSrc & 0x7C00);   if (bb < 0)  bb  =  0; \
+       gg = (uDst & 0x03E0) - (uSrc & 0x03E0);   if (gg > 0)  bb |= gg; \
+       rr = (uDst & 0x001F) - (uSrc & 0x001F);   if (rr > 0)  bb |= rr; \
+       uSrc = bb; \
+}
+#endif
+
+//     1.0 x Back + 0.25 x Forward     */
+#ifdef __arm__
+#define gpuBlending03(uSrc,uDst) \
+{ \
+               u16 st,dt,out; \
+               asm ("mov    %[src], %[src],   lsr #2   " : [src] "=r" (uSrc) : "0" (uSrc)                                      ); \
+               asm ("and    %[dt],  %[dst],   #0x7C00  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+               asm ("and    %[st],  %[src],   #0x1C00  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+               asm ("add    %[out], %[dt],    %[st]    " : [out] "=r" (out)  :             [dt]  "r" (dt),   [st]  "r" (st)    ); \
+               asm ("cmp    %[out], #0x7C00            " :                   :             [out] "r" (out) : "cc"              ); \
+               asm ("movhi  %[out], #0x7C00            " : [out] "=r" (out)  : "0" (out)                                       ); \
+               asm ("and    %[dt],  %[dst],   #0x03E0  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+               asm ("and    %[st],  %[src],   #0x00E0  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+               asm ("add    %[dt],  %[dt],    %[st]    " : [dt]  "=r" (dt)   : "0" (dt),   [st]  "r" (st)                      ); \
+               asm ("cmp    %[dt],  #0x03E0            " :                   :             [dt]  "r" (dt) : "cc"               ); \
+               asm ("movhi  %[dt],  #0x03E0            " : [dt]  "=r" (dt)   : "0" (dt)                                        ); \
+               asm ("orr    %[out], %[out],   %[dt]    " : [out] "=r" (out)  : "0" (out),  [dt]  "r" (dt)                      ); \
+               asm ("and    %[dt],  %[dst],   #0x001F  " : [dt]  "=r" (dt)   :             [dst] "r" (uDst)                    ); \
+               asm ("and    %[st],  %[src],   #0x0007  " : [st]  "=r" (st)   :             [src] "r" (uSrc)                    ); \
+               asm ("add    %[dt],  %[dt],    %[st]    " : [dt]  "=r" (dt)   : "0" (dt),   [st]  "r" (st)                      ); \
+               asm ("cmp    %[dt],  #0x001F            " :                   :             [dt]  "r" (dt) : "cc"               ); \
+               asm ("movhi  %[dt],  #0x001F            " : [dt]  "=r" (dt)   : "0" (dt)                                        ); \
+               asm ("orr    %[uSrc], %[out],   %[dt]   " : [uSrc] "=r" (uSrc)  : [out] "r" (out),  [dt]  "r" (dt)              ); \
+}
+#else
+#define gpuBlending03(uSrc,uDst) \
+{ \
+       u16 rr, gg, bb; \
+       uSrc >>= 2; \
+       bb = (uDst & 0x7C00) + (uSrc & 0x1C00);   if (bb > 0x7C00)  bb = 0x7C00; \
+       gg = (uDst & 0x03E0) + (uSrc & 0x00E0);   if (gg > 0x03E0)  gg = 0x03E0;  bb |= gg; \
+       rr = (uDst & 0x001F) + (uSrc & 0x0007);   if (rr > 0x001F)  rr = 0x001F;  bb |= rr; \
+       uSrc = bb; \
+}
+#endif
+
+#endif  //_OP_BLEND_H_

diff --git a/plugins/gpu_unai/gpu_inner_light.h b/plugins/gpu_unai/gpu_inner_light.h
new file mode 100644 (file)
index 0000000..b9e48bc
--- /dev/null
+++ b/plugins/gpu_unai/gpu_inner_light.h
@@ -0,0 +1,80 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+#ifndef _OP_LIGHT_H_
+#define _OP_LIGHT_H_
+
+//  GPU color operations for lighting calculations
+
+#ifdef __arm__
+#define gpuLightingRGB(uSrc,lCol) \
+{ \
+       u32 cb,cg; \
+       asm ("and %[cb],  %[lCol], #0x7C00/32       " : [cb]   "=r" (cb)   : [lCol] "r" (lCol) ); \
+       asm ("and %[cg],  %[lCol], #0x03E0*2048     " : [cg]   "=r" (cg)   : [lCol] "r" (lCol) ); \
+       asm ("mov %[res], %[lCol],          lsr #27 " : [res]  "=r" (uSrc)  : [lCol] "r" (lCol) ); \
+       asm ("orr %[res], %[res], %[cb],    lsl #5  " : [res]  "=r" (uSrc)  : "0" (uSrc), [cb] "r" (cb) ); \
+       asm ("orr %[res], %[res], %[cg],    lsr #11 " : [res]  "=r" (uSrc)  : "0" (uSrc), [cg] "r" (cg) ); \
+}
+#else
+#define gpuLightingRGB(uSrc,lCol) uSrc=((lCol<<5)&0x7C00) | ((lCol>>11)&0x3E0) | (lCol>>27)
+#endif
+
+INLINE void gpuLightingTXT(u16 &uSrc, u32 &lCol)
+{
+       //  Pixelops Table
+       static const u8 _gpuLitT[32*32] = {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+                0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
+                0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
+                0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9,
+                0, 0, 0, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,11,11,
+                0, 0, 0, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9,10,10,10,11,11,12,12,13,13,
+                0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,
+                0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 9, 9,10,10,11,11,12,12,13,14,14,15,15,16,16,17,
+                0, 0, 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 7, 8, 8, 9,10,10,11,11,12,13,13,14,15,15,16,16,17,18,18,19,
+                0, 0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,19,20,21,
+                0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9,10,11,12,12,13,14,15,15,16,17,18,18,19,20,21,21,22,23,
+                0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 8, 9,10,11,12,13,13,14,15,16,17,17,18,19,20,21,21,22,23,24,25,
+                0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9,10,11,12,13,14,14,15,16,17,18,19,20,21,21,22,23,24,25,26,27,
+                0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,31,
+                0, 1, 2, 3, 4, 5, 6, 7, 9,10,11,12,13,14,15,16,18,19,20,21,22,23,24,25,27,28,29,30,31,31,31,31,
+                0, 1, 2, 3, 4, 5, 7, 8, 9,10,11,13,14,15,16,17,19,20,21,22,23,24,26,27,28,29,30,31,31,31,31,31,
+                0, 1, 2, 3, 5, 6, 7, 8,10,11,12,13,15,16,17,18,20,21,22,23,25,26,27,28,30,31,31,31,31,31,31,31,
+                0, 1, 2, 3, 5, 6, 7, 9,10,11,13,14,15,17,18,19,21,22,23,24,26,27,28,30,31,31,31,31,31,31,31,31,
+                0, 1, 2, 4, 5, 6, 8, 9,11,12,13,15,16,17,19,20,22,23,24,26,27,28,30,31,31,31,31,31,31,31,31,31,
+                0, 1, 2, 4, 5, 7, 8,10,11,12,14,15,17,18,20,21,23,24,25,27,28,30,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 4, 6, 7, 9,10,12,13,15,16,18,19,21,22,24,25,27,28,30,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 4, 6, 7, 9,10,12,14,15,17,18,20,21,23,25,26,28,29,31,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 4, 6, 8, 9,11,13,14,16,17,19,21,22,24,26,27,29,30,31,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 5, 6, 8,10,11,13,15,16,18,20,21,23,25,27,28,30,31,31,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 5, 7, 8,10,12,14,15,17,19,21,22,24,26,28,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 5, 7, 9,10,12,14,16,18,19,21,23,25,27,29,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 5, 7, 9,11,13,15,16,18,20,22,24,26,28,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,
+                0, 1, 3, 5, 7, 9,11,13,15,17,19,21,23,25,27,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31
+       };
+       uSrc  = (_gpuLitT[((uSrc&0x7C00)>>5)|((lCol>>5)&0x1f)]<<10)|(_gpuLitT[(uSrc&0x03E0)|((lCol>>16)&0x1f)]<<5)|(_gpuLitT[((uSrc&0x001F)<<5)|(lCol>>27)]);
+}
+
+#endif  //_OP_LIGHT_H_

diff --git a/plugins/gpu_unai/gpu_raster_image.h b/plugins/gpu_unai/gpu_raster_image.h
new file mode 100644 (file)
index 0000000..7984b18
--- /dev/null
+++ b/plugins/gpu_unai/gpu_raster_image.h
@@ -0,0 +1,203 @@
+/***************************************************************************
+ *   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 gpuLoadImage(void)
+{
+       u16 x0, y0, w0, h0;
+       x0 = PacketBuffer.U2[2] & 1023;
+       y0 = PacketBuffer.U2[3] & 511;
+       w0 = PacketBuffer.U2[4];
+       h0 = PacketBuffer.U2[5];
+
+       if ((y0 + h0) > FRAME_HEIGHT)
+       {
+               h0 = FRAME_HEIGHT - y0;
+       }
+
+       FrameToWrite = ((w0)&&(h0));
+
+       px = 0;
+       py = 0;
+       x_end = w0;
+       y_end = h0;
+       pvram = &((u16*)GPU_FrameBuffer)[x0+(y0*1024)];
+
+       GPU_GP1 |= 0x08000000;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+INLINE void gpuStoreImage(void)
+{
+       u16 x0, y0, w0, h0;
+       x0 = PacketBuffer.U2[2] & 1023;
+       y0 = PacketBuffer.U2[3] & 511;
+       w0 = PacketBuffer.U2[4];
+       h0 = PacketBuffer.U2[5];
+
+       if ((y0 + h0) > FRAME_HEIGHT)
+       {
+               h0 = FRAME_HEIGHT - y0;
+       }
+       FrameToRead = ((w0)&&(h0));
+
+       px = 0;
+       py = 0;
+       x_end = w0;
+       y_end = h0;
+       pvram = &((u16*)GPU_FrameBuffer)[x0+(y0*1024)];
+       
+       GPU_GP1 |= 0x08000000;
+}
+
+INLINE void gpuMoveImage(void)
+{
+       u32 x0, y0, x1, y1;
+       s32 w0, h0;
+       x0 = PacketBuffer.U2[2] & 1023;
+       y0 = PacketBuffer.U2[3] & 511;
+       x1 = PacketBuffer.U2[4] & 1023;
+       y1 = PacketBuffer.U2[5] & 511;
+       w0 = PacketBuffer.U2[6];
+       h0 = PacketBuffer.U2[7];
+
+       if( (x0==x1) && (y0==y1) ) return;
+       if ((w0<=0) || (h0<=0)) return;
+       
+       if (((y0+h0)>512)||((x0+w0)>1024)||((y1+h0)>512)||((x1+w0)>1024))
+       {
+               u16 *psxVuw=GPU_FrameBuffer;
+               u32 i,j;
+           for(j=0;j<h0;j++)
+                for(i=0;i<w0;i++)
+                 psxVuw [(1024*((y1+j)&511))+((x1+i)&0x3ff)]=
+                  psxVuw[(1024*((y0+j)&511))+((x0+i)&0x3ff)];
+       }
+       else if ((x0&1)||(x1&1))
+       {
+               u16 *lpDst, *lpSrc;
+               lpDst = lpSrc = (u16*)GPU_FrameBuffer;
+               lpSrc += FRAME_OFFSET(x0, y0);
+               lpDst += FRAME_OFFSET(x1, y1);
+               x1 = FRAME_WIDTH - w0;
+               do {
+                       x0=w0;
+                       do { *lpDst++ = *lpSrc++; } while (--x0);
+                       lpDst += x1;
+                       lpSrc += x1;
+               } while (--h0);
+       }
+       else
+       {
+               u32 *lpDst, *lpSrc;
+               lpDst = lpSrc = (u32*)(void*)GPU_FrameBuffer;
+               lpSrc += ((FRAME_OFFSET(x0, y0))>>1);
+               lpDst += ((FRAME_OFFSET(x1, y1))>>1);
+               if (w0&1)
+               {
+                       x1 = (FRAME_WIDTH - w0 +1)>>1;
+                       w0>>=1;
+                       if (!w0) {
+                               do {
+                                       *((u16*)lpDst) = *((u16*)lpSrc);
+                                       lpDst += x1;
+                                       lpSrc += x1;
+                               } while (--h0);
+                       } else
+                       do {
+                               x0=w0;
+                               do { *lpDst++ = *lpSrc++; } while (--x0);
+                               *((u16*)lpDst) = *((u16*)lpSrc);
+                               lpDst += x1;
+                               lpSrc += x1;
+                       } while (--h0);
+               }
+               else
+               {
+                       x1 = (FRAME_WIDTH - w0)>>1;
+                       w0>>=1;
+                       do {
+                               x0=w0;
+                               do { *lpDst++ = *lpSrc++; } while (--x0);
+                               lpDst += x1;
+                               lpSrc += x1;
+                       } while (--h0);
+               }
+       }
+}
+
+INLINE void gpuClearImage(void)
+{
+       s32   x0, y0, w0, h0;
+       x0 = PacketBuffer.S2[2];
+       y0 = PacketBuffer.S2[3];
+       w0 = PacketBuffer.S2[4] & 0x3ff;
+       h0 = PacketBuffer.S2[5] & 0x3ff;
+        
+       w0 += x0;
+       if (x0 < 0) x0 = 0;
+       if (w0 > FRAME_WIDTH) w0 = FRAME_WIDTH;
+       w0 -= x0;
+       if (w0 <= 0) return;
+       h0 += y0;
+       if (y0 < 0) y0 = 0;
+       if (h0 > FRAME_HEIGHT) h0 = FRAME_HEIGHT;
+       h0 -= y0;
+       if (h0 <= 0) return;
+
+       if (x0&1)
+       {
+               u16* pixel = (u16*)GPU_FrameBuffer + FRAME_OFFSET(x0, y0);
+               u16 rgb = GPU_RGB16(PacketBuffer.S4[0]);
+               y0 = FRAME_WIDTH - w0;
+               do {
+                       x0=w0;
+                       do { *pixel++ = rgb; } while (--x0);
+                       pixel += y0;
+               } while (--h0);
+       }
+       else
+       {
+               u32* pixel = (u32*)(void*)GPU_FrameBuffer + ((FRAME_OFFSET(x0, y0))>>1);
+               u32 rgb = GPU_RGB16(PacketBuffer.S4[0]);
+               rgb |= (rgb<<16);
+               if (w0&1)
+               {
+                       y0 = (FRAME_WIDTH - w0 +1)>>1;
+                       w0>>=1;
+                       do {
+                               x0=w0;
+                               do { *pixel++ = rgb; } while (--x0);
+                               *((u16*)pixel) = (u16)rgb;
+                               pixel += y0;
+                       } while (--h0);
+               }
+               else
+               {
+                       y0 = (FRAME_WIDTH - w0)>>1;
+                       w0>>=1;
+                       do {
+                               x0=w0;
+                               do { *pixel++ = rgb; } while (--x0);
+                               pixel += y0;
+                       } while (--h0);
+               }
+       }
+}

diff --git a/plugins/gpu_unai/gpu_raster_line.h b/plugins/gpu_unai/gpu_raster_line.h
new file mode 100644 (file)
index 0000000..6d66c7d
--- /dev/null
+++ b/plugins/gpu_unai/gpu_raster_line.h
@@ -0,0 +1,255 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU internal line drawing functions
+
+#define GPU_DIGITS  16
+#define GPU_DIGITSC (GPU_DIGITS+3)
+
+INLINE long GPU_DIV(long rs, long rt)
+{
+       return rt ? (rs / rt) : (0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void gpuDrawLF(const PD gpuPixelDriver)
+{
+       s32 temp;
+       s32 xmin, xmax;
+       s32 ymin, ymax;
+       s32 x0, x1, dx;
+       s32 y0, y1, dy;
+
+       x0 = PacketBuffer.S2[2] + DrawingOffset[0];     GPU_TESTRANGE(x0);
+       y0 = PacketBuffer.S2[3] + DrawingOffset[1];     GPU_TESTRANGE(y0);
+       x1 = PacketBuffer.S2[4] + DrawingOffset[0];     GPU_TESTRANGE(x1);
+       y1 = PacketBuffer.S2[5] + DrawingOffset[1];     GPU_TESTRANGE(y1);
+
+       xmin = DrawingArea[0];  xmax = DrawingArea[2];
+       ymin = DrawingArea[1];  ymax = DrawingArea[3];
+       const u16 pixeldata = GPU_RGB16(PacketBuffer.U4[0]);
+
+       dy = (y1 - y0);
+       if (dy < 0) dy = -dy;
+       dx = (x1 - x0);
+       if (dx < 0) dx = -dx;
+       if (dx > dy) {
+               if (x0 > x1) {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+               }
+               y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx);
+               y0 <<= GPU_DIGITS;
+               temp = xmin - x0;
+               if (temp > 0) {
+                       x0 = xmin;
+                       y0 += (y1 * temp);
+               }
+               if (x1 > xmax) x1 = xmax;
+               x1 -= x0;
+               if (x1 < 0) x1 = 0;
+
+               const int li=linesInterlace;
+               for (; x1; x1--) {
+                       temp = y0 >> GPU_DIGITS;
+                       if( 0 == (temp&li) )  {
+                               if ((u32) (temp - ymin) < (u32) (ymax - ymin)) {
+                                       gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, temp)],pixeldata);
+                               }
+                       }
+                       x0++;
+                       y0 += y1;
+               }
+       } else if (dy) {
+               if (y0 > y1) {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+               }
+               x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy);
+               x0 <<= GPU_DIGITS;
+               temp = ymin - y0;
+               if (temp > 0) {
+                       y0 = ymin;
+                       x0 += (x1 * temp);
+               }
+               if (y1 > ymax) y1 = ymax;
+               y1 -= y0;
+               if (y1 < 0) y1 = 0;
+               
+               const int li=linesInterlace;
+               for (; y1; y1--) {
+                       if( 0 == (y0&li) )  {
+                               temp = x0 >> GPU_DIGITS;
+                               if ((u32) (temp - xmin) < (u32) (xmax - xmin)) {
+                                       gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(temp, y0)],pixeldata);
+                               }
+                       }
+                       y0++;
+                       x0 += x1;
+               }
+               
+       } else {
+               if( 0 == (y0&linesInterlace) )  {
+                       if ((u32) (x0 - xmin) < (u32) (xmax - xmin)) {
+                               if ((u32) (y0 - ymin) < (u32) (ymax - ymin)) {
+                                       gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)],pixeldata);
+                               }
+                       }
+               }
+       }
+}
+
+/*----------------------------------------------------------------------
+GF
+----------------------------------------------------------------------*/
+
+///////////////////////////////////////////////////////////////////////////////
+void gpuDrawLG(const PD gpuPixelDriver)
+{
+       s32 temp;
+       s32 xmin, xmax;
+       s32 ymin, ymax;
+       s32 x0, x1, dx;
+       s32 y0, y1, dy;
+       s32 r0, r1;
+       s32 g0, g1;
+       s32 b0, b1;
+
+       x0 = PacketBuffer.S2[2] + DrawingOffset[0];     GPU_TESTRANGE(x0);
+       y0 = PacketBuffer.S2[3] + DrawingOffset[1];     GPU_TESTRANGE(y0);
+       x1 = PacketBuffer.S2[6] + DrawingOffset[0];     GPU_TESTRANGE(x1);
+       y1 = PacketBuffer.S2[7] + DrawingOffset[1];     GPU_TESTRANGE(y1);
+
+       r0 = PacketBuffer.U1[0];  g0 = PacketBuffer.U1[1];  b0 = PacketBuffer.U1[2];
+       r1 = PacketBuffer.U1[8];  g1 = PacketBuffer.U1[9];      b1 = PacketBuffer.U1[10];
+
+       xmin = DrawingArea[0];  xmax = DrawingArea[2];
+       ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+       dy = (y1 - y0);
+       if (dy < 0)
+       dy = -dy;
+       dx = (x1 - x0);
+       if (dx < 0)
+       dx = -dx;
+       if (dx > dy) {
+               if (x0 > x1) {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(r0, r1, temp);
+                       GPU_SWAP(g0, g1, temp);
+                       GPU_SWAP(b0, b1, temp);
+               }
+               y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx);
+               r1 = GPU_DIV((r1 - r0) << GPU_DIGITS, dx);
+               g1 = GPU_DIV((g1 - g0) << GPU_DIGITS, dx);
+               b1 = GPU_DIV((b1 - b0) << GPU_DIGITS, dx);
+               y0 <<= GPU_DIGITS;
+               r0 <<= GPU_DIGITS;
+               g0 <<= GPU_DIGITS;
+               b0 <<= GPU_DIGITS;
+               temp = xmin - x0;
+               if (temp > 0) {
+                       x0 = xmin;
+                       y0 += (y1 * temp);
+                       r0 += (r1 * temp);
+                       g0 += (g1 * temp);
+                       b0 += (b1 * temp);
+               }
+               if (x1 > xmax) x1 = xmax;
+               x1 -= x0;
+               if (x1 < 0) x1 = 0;
+               
+               const int li=linesInterlace;
+               for (; x1; x1--) {
+                       temp = y0 >> GPU_DIGITS;
+                       if( 0 == (temp&li) )  {
+                               if ((u32) (temp - ymin) < (u32) (ymax - ymin)) {
+                                       gpuPixelDriver (
+                                               &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, temp)],
+                                               (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F)
+                                       );
+                               }
+                       }
+                       x0++;
+                       y0 += y1;
+                       r0 += r1;
+                       g0 += g1;
+                       b0 += b1;
+               }
+       } else if (dy) {
+               if (y0 > y1) {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(r0, r1, temp);
+                       GPU_SWAP(g0, g1, temp);
+                       GPU_SWAP(b0, b1, temp);
+               }
+               x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy);
+               r1 = GPU_DIV((r1 - r0) << GPU_DIGITS, dy);
+               g1 = GPU_DIV((g1 - g0) << GPU_DIGITS, dy);
+               b1 = GPU_DIV((b1 - b0) << GPU_DIGITS, dy);
+               x0 <<= GPU_DIGITS;
+               r0 <<= GPU_DIGITS;
+               g0 <<= GPU_DIGITS;
+               b0 <<= GPU_DIGITS;
+               temp = ymin - y0;
+               if (temp > 0) {
+                       y0 = ymin;
+                       x0 += (x1 * temp);
+                       r0 += (r1 * temp);
+                       g0 += (g1 * temp);
+                       b0 += (b1 * temp);
+               }
+               if (y1 > ymax) y1 = ymax;
+               y1 -= y0;
+               if (y1 < 0) y1 = 0;
+               
+               const int li=linesInterlace;
+               for (; y1; y1--) {
+                       if( 0 == (y0&li) )  {
+                               temp = x0 >> GPU_DIGITS;
+                               if ((u32) (temp - xmin) < (u32) (xmax - xmin)) {
+                                       gpuPixelDriver (
+                                               &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(temp, y0)],
+                                               (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F)
+                                       );
+                               }
+                       }
+                       y0++;
+                       x0 += x1;
+                       r0 += r1;
+                       g0 += g1;
+                       b0 += b1;
+               }
+       } else {
+               if( 0 == (y0&linesInterlace) )  {
+                       if ((u32) (x0 - xmin) < (u32) (xmax - xmin)) {
+                               if ((u32) (y0 - ymin) < (u32) (ymax - ymin)) {
+                                       gpuPixelDriver (
+                                               &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)],
+                                               (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F)
+                                       );
+                               }
+                       }
+               }
+       }
+}

diff --git a/plugins/gpu_unai/gpu_raster_polygon.h b/plugins/gpu_unai/gpu_raster_polygon.h
new file mode 100644 (file)
index 0000000..5d370f8
--- /dev/null
+++ b/plugins/gpu_unai/gpu_raster_polygon.h
@@ -0,0 +1,837 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU internal polygon drawing functions
+
+///////////////////////////////////////////////////////////////////////////////
+void gpuDrawF3(const PP gpuPolySpanDriver)
+{
+       const int li=linesInterlace;
+       s32 temp;
+       s32 xa, xb, xmin, xmax;
+       s32 ya, yb, ymin, ymax;
+       s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
+       s32 y0, y1, y2;
+
+       x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2]);  GPU_TESTRANGE(x0);
+       y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3]);  GPU_TESTRANGE(y0);
+       x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[4]);  GPU_TESTRANGE(x1);
+       y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[5]);  GPU_TESTRANGE(y1);
+       x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6]);  GPU_TESTRANGE(x2);
+       y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7]);  GPU_TESTRANGE(y2);
+
+       x0 += DrawingOffset[0];   x1 += DrawingOffset[0];   x2 += DrawingOffset[0];
+       y0 += DrawingOffset[1];   y1 += DrawingOffset[1];   y2 += DrawingOffset[1];
+
+       xmin = DrawingArea[0];  xmax = DrawingArea[2];
+       ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+       {
+               int rx0 = Max2(xmin,Min3(x0,x1,x2));
+               int ry0 = Max2(ymin,Min3(y0,y1,y2));
+               int rx1 = Min2(xmax,Max3(x0,x1,x2));
+               int ry1 = Min2(ymax,Max3(y0,y1,y2));
+               if( rx0>=rx1 || ry0>=ry1) return;
+       }
+       
+       PixelData = GPU_RGB16(PacketBuffer.U4[0]);
+
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+               }
+       }
+       if (y1 >= y2)
+       {
+               if( y1!=y2 || x1>x2 )
+               {
+                       GPU_SWAP(x1, x2, temp);
+                       GPU_SWAP(y1, y2, temp);
+               }
+       }
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+               }
+       }
+
+       ya = y2 - y0;
+       yb = y2 - y1;
+       dx =(x2 - x1) * ya - (x2 - x0) * yb;
+
+       for (s32 loop0 = 2; loop0; --loop0)
+       {
+               if (loop0 == 2)
+               {
+                       ya = y0;
+                       yb = y1;
+                       x3 = i2x(x0);
+                       x4 = y0!=y1 ? x3 : i2x(x1);
+                       if (dx < 0)
+                       {
+                               dx3 = xLoDivx((x2 - x0), (y2 - y0));
+                               dx4 = xLoDivx((x1 - x0), (y1 - y0));
+                       }
+                       else
+                       {
+                               dx3 = xLoDivx((x1 - x0), (y1 - y0));
+                               dx4 = xLoDivx((x2 - x0), (y2 - y0));
+                       }
+               }
+               else
+               {
+                       ya = y1;
+                       yb = y2;
+                       if (dx < 0)
+                       {
+                               x4  = i2x(x1);
+                               x3  = i2x(x0) + (dx3 * (y1 - y0));
+                               dx4 = xLoDivx((x2 - x1), (y2 - y1));
+                       }
+                       else
+                       {
+                               x3  = i2x(x1);
+                               x4  = i2x(x0) + (dx4 * (y1 - y0));
+                               dx3 = xLoDivx((x2 - x1), (y2 - y1));
+                       }
+               }
+
+               temp = ymin - ya;
+               if (temp > 0)
+               {
+                       ya  = ymin;
+                       x3 += dx3*temp;
+                       x4 += dx4*temp;
+               }
+               if (yb > ymax) yb = ymax;
+               if (ya>=yb) continue;
+
+               x3+= fixed_HALF;
+               x4+= fixed_HALF;
+
+               u16* PixelBase  = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
+               
+               if (!progressInterlace)
+               {
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4)
+                       {
+                               if (ya&li) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin) ) continue;
+                               if(xa < xmin) xa = xmin;
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+               else
+               {
+                       bool flag=progressInterlace_flag;
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4)
+                       {
+                               if ((ya&li) && (flag=!flag)) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin) ) continue;
+                               if(xa < xmin) xa = xmin;
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+       }
+}
+
+/*----------------------------------------------------------------------
+FT3
+----------------------------------------------------------------------*/
+
+void gpuDrawFT3(const PP gpuPolySpanDriver)
+{
+       const int li=linesInterlace;
+       s32 temp;
+       s32 xa, xb, xmin, xmax;
+       s32 ya, yb, ymin, ymax;
+       s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
+       s32 y0, y1, y2;
+       s32 u0, u1, u2, u3, du3=0;
+       s32 v0, v1, v2, v3, dv3=0;
+
+       x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2] );   GPU_TESTRANGE(x0);
+       y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3] );   GPU_TESTRANGE(y0);
+       x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6] );   GPU_TESTRANGE(x1);
+       y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7] );   GPU_TESTRANGE(y1);
+       x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[10]);   GPU_TESTRANGE(x2);
+       y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[11]);   GPU_TESTRANGE(y2);
+
+       x0 += DrawingOffset[0];   x1 += DrawingOffset[0];   x2 += DrawingOffset[0];
+       y0 += DrawingOffset[1];   y1 += DrawingOffset[1];   y2 += DrawingOffset[1];
+
+       xmin = DrawingArea[0];  xmax = DrawingArea[2];
+       ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+       {
+               int rx0 = Max2(xmin,Min3(x0,x1,x2));
+               int ry0 = Max2(ymin,Min3(y0,y1,y2));
+               int rx1 = Min2(xmax,Max3(x0,x1,x2));
+               int ry1 = Min2(ymax,Max3(y0,y1,y2));
+               if( rx0>=rx1 || ry0>=ry1) return;
+       }
+       
+       u0 = PacketBuffer.U1[8];  v0 = PacketBuffer.U1[9];
+       u1 = PacketBuffer.U1[16]; v1 = PacketBuffer.U1[17];
+       u2 = PacketBuffer.U1[24]; v2 = PacketBuffer.U1[25];
+
+       r4 = s32(PacketBuffer.U1[0]);
+       g4 = s32(PacketBuffer.U1[1]);
+       b4 = s32(PacketBuffer.U1[2]);
+       dr4 = dg4 = db4 = 0;
+
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(u0, u1, temp);
+                       GPU_SWAP(v0, v1, temp);
+               }
+       }
+       if (y1 >= y2)
+       {
+               if( y1!=y2 || x1>x2 )
+               {
+                       GPU_SWAP(x1, x2, temp);
+                       GPU_SWAP(y1, y2, temp);
+                       GPU_SWAP(u1, u2, temp);
+                       GPU_SWAP(v1, v2, temp);
+               }
+       }
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);
+                       GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(u0, u1, temp);
+                       GPU_SWAP(v0, v1, temp);
+               }
+       }
+
+       ya  = y2 - y0;
+       yb  = y2 - y1;
+       dx  = (x2 - x1) * ya - (x2 - x0) * yb;
+       du4 = (u2 - u1) * ya - (u2 - u0) * yb;
+       dv4 = (v2 - v1) * ya - (v2 - v0) * yb;
+
+       s32 iF,iS;
+       xInv( dx, iF, iS);
+       du4 = xInvMulx( du4, iF, iS);
+       dv4 = xInvMulx( dv4, iF, iS);
+       tInc = ((u32)(du4<<7)&0x7fff0000) | ((u32)(dv4>>9)&0x00007fff);
+       tMsk = (TextureWindow[2]<<23) | (TextureWindow[3]<<7) | 0x00ff00ff;
+
+       for (s32 loop0 = 2; loop0; --loop0)
+       {
+               if (loop0 == 2)
+               {
+                       ya = y0;
+                       yb = y1;
+                       u3 = i2x(u0);
+                       v3 = i2x(v0);
+                       x3 = i2x(x0);
+                       x4 = y0!=y1 ? x3 : i2x(x1);
+                       if (dx < 0)
+                       {
+                               xInv( (y2 - y0), iF, iS);
+                               dx3 = xInvMulx( (x2 - x0), iF, iS);
+                               du3 = xInvMulx( (u2 - u0), iF, iS);
+                               dv3 = xInvMulx( (v2 - v0), iF, iS);
+                               dx4 = xLoDivx ( (x1 - x0), (y1 - y0));
+                       }
+                       else
+                       {
+                               xInv( (y1 - y0), iF, iS);
+                               dx3 = xInvMulx( (x1 - x0), iF, iS);
+                               du3 = xInvMulx( (u1 - u0), iF, iS);
+                               dv3 = xInvMulx( (v1 - v0), iF, iS);
+                               dx4 = xLoDivx ( (x2 - x0), (y2 - y0));
+                       }
+               }
+               else
+               {
+                       ya = y1;
+                       yb = y2;
+                       if (dx < 0)
+                       {
+                               temp = y1 - y0;
+                               u3 = i2x(u0) + (du3 * temp);
+                               v3 = i2x(v0) + (dv3 * temp);
+                               x3 = i2x(x0) + (dx3 * temp);
+                               x4 = i2x(x1);
+                               dx4 = xLoDivx((x2 - x1), (y2 - y1));
+                       }
+                       else
+                       {
+                               u3 = i2x(u1);
+                               v3 = i2x(v1);
+                               x3 = i2x(x1);
+                               x4 = i2x(x0) + (dx4 * (y1 - y0));
+                               xInv( (y2 - y1), iF, iS);
+                               dx3 = xInvMulx( (x2 - x1), iF, iS);
+                               du3 = xInvMulx( (u2 - u1), iF, iS);
+                               dv3 = xInvMulx( (v2 - v1), iF, iS);
+                       }
+               }
+
+               temp = ymin - ya;
+               if (temp > 0)
+               {
+                       ya  = ymin;
+                       x3 += dx3*temp;
+                       x4 += dx4*temp;
+                       u3 += du3*temp;
+                       v3 += dv3*temp;
+               }
+               if (yb > ymax) yb = ymax;
+               if (ya>=yb) continue;
+
+               x3+= fixed_HALF;
+               x4+= fixed_HALF;
+               u3+= fixed_HALF;
+               v4+= fixed_HALF;
+
+               u16* PixelBase  = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
+
+               if (!progressInterlace)
+               {
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3)
+                       {
+                               if (ya&li) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin) ) continue;
+
+                               temp = xmin - xa;
+                               if(temp > 0)
+                               {
+                                       xa  = xmin;
+                                       u4 = u3 + du4*temp;
+                                       v4 = v3 + dv4*temp;
+                               }
+                               else
+                               {
+                                       u4 = u3;
+                                       v4 = v3;
+                               }
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+               else
+               {
+                       bool flag=progressInterlace_flag;
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3)
+                       {
+                               if ((ya&li) && (flag=!flag)) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin) ) continue;
+
+                               temp = xmin - xa;
+                               if(temp > 0)
+                               {
+                                       xa  = xmin;
+                                       u4 = u3 + du4*temp;
+                                       v4 = v3 + dv4*temp;
+                               }
+                               else
+                               {
+                                       u4 = u3;
+                                       v4 = v3;
+                               }
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+       }
+}
+
+/*----------------------------------------------------------------------
+G3
+----------------------------------------------------------------------*/
+
+void gpuDrawG3(const PP gpuPolySpanDriver)
+{
+       const int li=linesInterlace;
+       s32 temp;
+       s32 xa, xb, xmin, xmax;
+       s32 ya, yb, ymin, ymax;
+       s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
+       s32 y0, y1, y2;
+       s32 r0, r1, r2, r3, dr3=0;
+       s32 g0, g1, g2, g3, dg3=0;
+       s32 b0, b1, b2, b3, db3=0;
+
+       x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2] );    GPU_TESTRANGE(x0);
+       y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3] );    GPU_TESTRANGE(y0);
+       x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6] );    GPU_TESTRANGE(x1);
+       y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7] );    GPU_TESTRANGE(y1);
+       x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[10]);    GPU_TESTRANGE(x2);
+       y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[11]);    GPU_TESTRANGE(y2);
+
+       x0 += DrawingOffset[0];   x1 += DrawingOffset[0];   x2 += DrawingOffset[0];
+       y0 += DrawingOffset[1];   y1 += DrawingOffset[1];   y2 += DrawingOffset[1];
+
+       xmin = DrawingArea[0];  xmax = DrawingArea[2];
+       ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+       {
+               int rx0 = Max2(xmin,Min3(x0,x1,x2));
+               int ry0 = Max2(ymin,Min3(y0,y1,y2));
+               int rx1 = Min2(xmax,Max3(x0,x1,x2));
+               int ry1 = Min2(ymax,Max3(y0,y1,y2));
+               if( rx0>=rx1 || ry0>=ry1) return;
+       }
+       
+       r0 = PacketBuffer.U1[0];        g0 = PacketBuffer.U1[1];        b0 = PacketBuffer.U1[2];
+       r1 = PacketBuffer.U1[8];        g1 = PacketBuffer.U1[9];        b1 = PacketBuffer.U1[10];
+       r2 = PacketBuffer.U1[16];       g2 = PacketBuffer.U1[17];       b2 = PacketBuffer.U1[18];
+
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);         GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(r0, r1, temp);         GPU_SWAP(g0, g1, temp);         GPU_SWAP(b0, b1, temp);
+               }
+       }
+       if (y1 >= y2)
+       {
+               if( y1!=y2 || x1>x2 )
+               {
+                       GPU_SWAP(x1, x2, temp);         GPU_SWAP(y1, y2, temp);
+                       GPU_SWAP(r1, r2, temp);         GPU_SWAP(g1, g2, temp);   GPU_SWAP(b1, b2, temp);
+               }
+       }
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);         GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(r0, r1, temp);   GPU_SWAP(g0, g1, temp);               GPU_SWAP(b0, b1, temp);
+               }
+       }
+
+       ya  = y2 - y0;
+       yb  = y2 - y1;
+       dx  = (x2 - x1) * ya - (x2 - x0) * yb;
+       dr4 = (r2 - r1) * ya - (r2 - r0) * yb;
+       dg4 = (g2 - g1) * ya - (g2 - g0) * yb;
+       db4 = (b2 - b1) * ya - (b2 - b0) * yb;
+
+       s32 iF,iS;
+       xInv(            dx, iF, iS);
+       dr4 = xInvMulx( dr4, iF, iS);
+       dg4 = xInvMulx( dg4, iF, iS);
+       db4 = xInvMulx( db4, iF, iS);
+       u32 dr = (u32)(dr4<< 8)&(0xffffffff<<21);   if(dr4<0) dr+= 1<<21;
+       u32 dg = (u32)(dg4>> 3)&(0xffffffff<<10);   if(dg4<0) dg+= 1<<10;
+       u32 db = (u32)(db4>>14)&(0xffffffff    );   if(db4<0) db+= 1<< 0;
+       lInc = db + dg + dr;
+
+       for (s32 loop0 = 2; loop0; --loop0)
+       {
+               if (loop0 == 2)
+               {
+                       ya = y0;
+                       yb = y1;
+                       r3 = i2x(r0);
+                       g3 = i2x(g0);
+                       b3 = i2x(b0);
+                       x3 = i2x(x0);
+                       x4 = y0!=y1 ? x3 : i2x(x1);
+                       if (dx < 0)
+                       {
+                               xInv(           (y2 - y0), iF, iS);
+                               dx3 = xInvMulx( (x2 - x0), iF, iS);
+                               dr3 = xInvMulx( (r2 - r0), iF, iS);
+                               dg3 = xInvMulx( (g2 - g0), iF, iS);
+                               db3 = xInvMulx( (b2 - b0), iF, iS);
+                               dx4 = xLoDivx ( (x1 - x0), (y1 - y0));
+                       }
+                       else
+                       {
+                               xInv(           (y1 - y0), iF, iS);
+                               dx3 = xInvMulx( (x1 - x0), iF, iS);
+                               dr3 = xInvMulx( (r1 - r0), iF, iS);
+                               dg3 = xInvMulx( (g1 - g0), iF, iS);
+                               db3 = xInvMulx( (b1 - b0), iF, iS);
+                               dx4 = xLoDivx ( (x2 - x0), (y2 - y0));
+                       }
+               }
+               else
+               {
+                       ya = y1;
+                       yb = y2;
+                       if (dx < 0)
+                       {
+                               temp = y1 - y0;
+                               r3  = i2x(r0) + (dr3 * temp);
+                               g3  = i2x(g0) + (dg3 * temp);
+                               b3  = i2x(b0) + (db3 * temp);
+                               x3  = i2x(x0) + (dx3 * temp);
+                               x4  = i2x(x1);
+                               dx4 = xLoDivx((x2 - x1), (y2 - y1));
+                       }
+                       else
+                       {
+                               r3 = i2x(r1);
+                               g3 = i2x(g1);
+                               b3 = i2x(b1);
+                               x3 = i2x(x1);
+                               x4 = i2x(x0) + (dx4 * (y1 - y0));
+
+                               xInv(           (y2 - y1), iF, iS);
+                               dx3 = xInvMulx( (x2 - x1), iF, iS);
+                               dr3 = xInvMulx( (r2 - r1), iF, iS);
+                               dg3 = xInvMulx( (g2 - g1), iF, iS);
+                               db3 = xInvMulx( (b2 - b1), iF, iS);
+                       }
+               }
+
+               temp = ymin - ya;
+               if (temp > 0)
+               {
+                       ya  = ymin;
+                       x3 += dx3*temp;   x4 += dx4*temp;
+                       r3 += dr3*temp;   g3 += dg3*temp;   b3 += db3*temp;
+               }
+               if (yb > ymax) yb = ymax;
+               if (ya>=yb) continue;
+
+               x3+= fixed_HALF;  x4+= fixed_HALF;
+               r3+= fixed_HALF;  g3+= fixed_HALF;  b3+= fixed_HALF;
+
+               u16* PixelBase  = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
+               
+               if (!progressInterlace)
+               {
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, r3+=dr3, g3+=dg3, b3+=db3)
+                       {
+                               if (ya&li) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin) ) continue;
+
+                               temp = xmin - xa;
+                               if(temp > 0)
+                               {
+                                       xa  = xmin;
+                                       r4 = r3 + dr4*temp;   g4 = g3 + dg4*temp;   b4 = b3 + db4*temp;
+                               }
+                               else
+                               {
+                                       r4 = r3;  g4 = g3;  b4 = b3;
+                               }
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+               else
+               {
+                       bool flag=progressInterlace_flag;
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, r3+=dr3, g3+=dg3, b3+=db3)
+                       {
+                               if ((ya&li) && (flag=!flag)) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin) ) continue;
+
+                               temp = xmin - xa;
+                               if(temp > 0)
+                               {
+                                       xa  = xmin;
+                                       r4 = r3 + dr4*temp;   g4 = g3 + dg4*temp;   b4 = b3 + db4*temp;
+                               }
+                               else
+                               {
+                                       r4 = r3;  g4 = g3;  b4 = b3;
+                               }
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+       }
+}
+
+/*----------------------------------------------------------------------
+GT3
+----------------------------------------------------------------------*/
+
+void gpuDrawGT3(const PP gpuPolySpanDriver)
+{
+       const int li=linesInterlace;
+       s32 temp;
+       s32 xa, xb, xmin, xmax;
+       s32 ya, yb, ymin, ymax;
+       s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
+       s32 y0, y1, y2;
+       s32 u0, u1, u2, u3, du3=0;
+       s32 v0, v1, v2, v3, dv3=0;
+       s32 r0, r1, r2, r3, dr3=0;
+       s32 g0, g1, g2, g3, dg3=0;
+       s32 b0, b1, b2, b3, db3=0;
+
+       x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2] );   GPU_TESTRANGE(x0);
+       y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3] );   GPU_TESTRANGE(y0);
+       x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[8] );   GPU_TESTRANGE(x1);
+       y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[9] );   GPU_TESTRANGE(y1);
+       x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[14]);   GPU_TESTRANGE(x2);
+       y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[15]);   GPU_TESTRANGE(y2);
+
+       x0 += DrawingOffset[0];   x1 += DrawingOffset[0];   x2 += DrawingOffset[0];
+       y0 += DrawingOffset[1];   y1 += DrawingOffset[1];   y2 += DrawingOffset[1];
+
+       xmin = DrawingArea[0];  xmax = DrawingArea[2];
+       ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+       {
+               int rx0 = Max2(xmin,Min3(x0,x1,x2));
+               int ry0 = Max2(ymin,Min3(y0,y1,y2));
+               int rx1 = Min2(xmax,Max3(x0,x1,x2));
+               int ry1 = Min2(ymax,Max3(y0,y1,y2));
+               if( rx0>=rx1 || ry0>=ry1) return;
+       }
+
+       r0 = PacketBuffer.U1[0];        g0 = PacketBuffer.U1[1];        b0 = PacketBuffer.U1[2];
+       u0 = PacketBuffer.U1[8];        v0 = PacketBuffer.U1[9];
+       r1 = PacketBuffer.U1[12];       g1 = PacketBuffer.U1[13];       b1 = PacketBuffer.U1[14];
+       u1 = PacketBuffer.U1[20];       v1 = PacketBuffer.U1[21];
+       r2 = PacketBuffer.U1[24];       g2 = PacketBuffer.U1[25];       b2 = PacketBuffer.U1[26];
+       u2 = PacketBuffer.U1[32];       v2 = PacketBuffer.U1[33];
+
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);         GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(u0, u1, temp);         GPU_SWAP(v0, v1, temp);
+                       GPU_SWAP(r0, r1, temp);         GPU_SWAP(g0, g1, temp);   GPU_SWAP(b0, b1, temp);
+               }
+       }
+       if (y1 >= y2)
+       {
+               if( y1!=y2 || x1>x2 )
+               {
+                       GPU_SWAP(x1, x2, temp);         GPU_SWAP(y1, y2, temp);
+                       GPU_SWAP(u1, u2, temp);         GPU_SWAP(v1, v2, temp);
+                       GPU_SWAP(r1, r2, temp);   GPU_SWAP(g1, g2, temp);               GPU_SWAP(b1, b2, temp);
+               }
+       }
+       if (y0 >= y1)
+       {
+               if( y0!=y1 || x0>x1 )
+               {
+                       GPU_SWAP(x0, x1, temp);         GPU_SWAP(y0, y1, temp);
+                       GPU_SWAP(u0, u1, temp);         GPU_SWAP(v0, v1, temp);
+                       GPU_SWAP(r0, r1, temp);         GPU_SWAP(g0, g1, temp);         GPU_SWAP(b0, b1, temp);
+               }
+       }
+
+       ya  = y2 - y0;
+       yb  = y2 - y1;
+       dx  = (x2 - x1) * ya - (x2 - x0) * yb;
+       du4 = (u2 - u1) * ya - (u2 - u0) * yb;
+       dv4 = (v2 - v1) * ya - (v2 - v0) * yb;
+       dr4 = (r2 - r1) * ya - (r2 - r0) * yb;
+       dg4 = (g2 - g1) * ya - (g2 - g0) * yb;
+       db4 = (b2 - b1) * ya - (b2 - b0) * yb;
+
+       s32 iF,iS;
+
+       xInv(            dx, iF, iS);
+       du4 = xInvMulx( du4, iF, iS);
+       dv4 = xInvMulx( dv4, iF, iS);
+       dr4 = xInvMulx( dr4, iF, iS);
+       dg4 = xInvMulx( dg4, iF, iS);
+       db4 = xInvMulx( db4, iF, iS);
+       u32 dr = (u32)(dr4<< 8)&(0xffffffff<<21);   if(dr4<0) dr+= 1<<21;
+       u32 dg = (u32)(dg4>> 3)&(0xffffffff<<10);   if(dg4<0) dg+= 1<<10;
+       u32 db = (u32)(db4>>14)&(0xffffffff    );   if(db4<0) db+= 1<< 0;
+       lInc = db + dg + dr;
+       tInc = ((u32)(du4<<7)&0x7fff0000) | ((u32)(dv4>>9)&0x00007fff);
+       tMsk = (TextureWindow[2]<<23) | (TextureWindow[3]<<7) | 0x00ff00ff;
+
+       for (s32 loop0 = 2; loop0; --loop0)
+       {
+               if (loop0 == 2)
+               {
+                       ya = y0;
+                       yb = y1;
+                       u3 = i2x(u0);
+                       v3 = i2x(v0);
+                       r3 = i2x(r0);
+                       g3 = i2x(g0);
+                       b3 = i2x(b0);
+                       x3 = i2x(x0);
+                       x4 = y0!=y1 ? x3 : i2x(x1);
+                       if (dx < 0)
+                       {
+                               xInv(           (y2 - y0), iF, iS);
+                               dx3 = xInvMulx( (x2 - x0), iF, iS);
+                               du3 = xInvMulx( (u2 - u0), iF, iS);
+                               dv3 = xInvMulx( (v2 - v0), iF, iS);
+                               dr3 = xInvMulx( (r2 - r0), iF, iS);
+                               dg3 = xInvMulx( (g2 - g0), iF, iS);
+                               db3 = xInvMulx( (b2 - b0), iF, iS);
+                               dx4 = xLoDivx ( (x1 - x0), (y1 - y0));
+                       }
+                       else
+                       {
+                               xInv(           (y1 - y0), iF, iS);
+                               dx3 = xInvMulx( (x1 - x0), iF, iS);
+                               du3 = xInvMulx( (u1 - u0), iF, iS);
+                               dv3 = xInvMulx( (v1 - v0), iF, iS);
+                               dr3 = xInvMulx( (r1 - r0), iF, iS);
+                               dg3 = xInvMulx( (g1 - g0), iF, iS);
+                               db3 = xInvMulx( (b1 - b0), iF, iS);
+                               dx4 = xLoDivx ( (x2 - x0), (y2 - y0));
+                       }
+               }
+               else
+               {
+                       ya = y1;
+                       yb = y2;
+                       if (dx < 0)
+                       {
+                               temp = y1 - y0;
+                               u3  = i2x(u0) + (du3 * temp);
+                               v3  = i2x(v0) + (dv3 * temp);
+                               r3  = i2x(r0) + (dr3 * temp);
+                               g3  = i2x(g0) + (dg3 * temp);
+                               b3  = i2x(b0) + (db3 * temp);
+                               x3  = i2x(x0) + (dx3 * temp);
+                               x4  = i2x(x1);
+                               dx4 = xLoDivx((x2 - x1), (y2 - y1));
+                       }
+                       else
+                       {
+                               u3 = i2x(u1);
+                               v3 = i2x(v1);
+                               r3 = i2x(r1);
+                               g3 = i2x(g1);
+                               b3 = i2x(b1);
+                               x3 = i2x(x1);
+                               x4 = i2x(x0) + (dx4 * (y1 - y0));
+
+                               xInv(           (y2 - y1), iF, iS);
+                               dx3 = xInvMulx( (x2 - x1), iF, iS);
+                               du3 = xInvMulx( (u2 - u1), iF, iS);
+                               dv3 = xInvMulx( (v2 - v1), iF, iS);
+                               dr3 = xInvMulx( (r2 - r1), iF, iS);
+                               dg3 = xInvMulx( (g2 - g1), iF, iS);
+                               db3 = xInvMulx( (b2 - b1), iF, iS);
+                       }
+               }
+
+               temp = ymin - ya;
+               if (temp > 0)
+               {
+                       ya  = ymin;
+                       x3 += dx3*temp;   x4 += dx4*temp;
+                       u3 += du3*temp;   v3 += dv3*temp;
+                       r3 += dr3*temp;   g3 += dg3*temp;   b3 += db3*temp;
+               }
+               if (yb > ymax) yb = ymax;
+               if (ya>=yb) continue;
+
+               x3+= fixed_HALF;  x4+= fixed_HALF;
+               u3+= fixed_HALF;  v4+= fixed_HALF;
+               r3+= fixed_HALF;  g3+= fixed_HALF;  b3+= fixed_HALF;
+               u16* PixelBase  = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
+               
+               if (!progressInterlace)
+               {
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3, r3+=dr3, g3+=dg3,        b3+=db3)
+                       {
+                               if (ya&li) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if( (xa>xmax) || (xb<xmin))     continue;
+
+                               temp = xmin - xa;
+                               if(temp > 0)
+                               {
+                                       xa  = xmin;
+                                       u4 = u3 + du4*temp;   v4 = v3 + dv4*temp;
+                                       r4 = r3 + dr4*temp;   g4 = g3 + dg4*temp;   b4 = b3 + db4*temp;
+                               }
+                               else
+                               {
+                                       u4 = u3;  v4 = v3;
+                                       r4 = r3;  g4 = g3;  b4 = b3;
+                               }
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+               else
+               {
+                       bool flag=progressInterlace_flag;
+                       for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3, r3+=dr3, g3+=dg3,        b3+=db3)
+                       {
+                               if ((ya&li) && (flag=!flag)) continue;
+                               xa = x2i(x3);
+                               xb = x2i(x4);
+                               if ((xa>xmax) || (xb<xmin))     continue;
+
+                               temp = xmin - xa;
+                               if(temp > 0)
+                               {
+                                       xa  = xmin;
+                                       u4 = u3 + du4*temp;   v4 = v3 + dv4*temp;
+                                       r4 = r3 + dr4*temp;   g4 = g3 + dg4*temp;   b4 = b3 + db4*temp;
+                               }
+                               else
+                               {
+                                       u4 = u3;  v4 = v3;
+                                       r4 = r3;  g4 = g3;  b4 = b3;
+                               }
+                               if(xb > xmax) xb = xmax;
+                               xb-=xa;
+                               if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+                       }
+               }
+       }
+}

diff --git a/plugins/gpu_unai/gpu_raster_sprite.h b/plugins/gpu_unai/gpu_raster_sprite.h
new file mode 100644 (file)
index 0000000..041fcbd
--- /dev/null
+++ b/plugins/gpu_unai/gpu_raster_sprite.h
@@ -0,0 +1,133 @@
+/***************************************************************************
+*   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.           *
+***************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//  GPU internal sprite drawing functions
+
+///////////////////////////////////////////////////////////////////////////////
+void gpuDrawS(const PS gpuSpriteSpanDriver)
+{
+       s32 x0, x1;
+       s32 y0, y1;
+       s32 u0;
+       s32 v0;
+
+       x1 = x0 = GPU_EXPANDSIGN_SPRT(PacketBuffer.S2[2]) + DrawingOffset[0];
+       y1 = y0 = GPU_EXPANDSIGN_SPRT(PacketBuffer.S2[3]) + DrawingOffset[1];
+       x1+= PacketBuffer.S2[6];
+       y1+= PacketBuffer.S2[7];
+
+       {
+               s32 xmin, xmax;
+               s32 ymin, ymax;
+               xmin = DrawingArea[0];  xmax = DrawingArea[2];
+               ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+               {
+                       int rx0 = Max2(xmin,Min2(x0,x1));
+                       int ry0 = Max2(ymin,Min2(y0,y1));
+                       int rx1 = Min2(xmax,Max2(x0,x1));
+                       int ry1 = Min2(ymax,Max2(y0,y1));
+                       if( rx0>=rx1 || ry0>=ry1) return;
+               }
+
+               u0 = PacketBuffer.U1[8];
+               v0 = PacketBuffer.U1[9];
+
+               r4 = s32(PacketBuffer.U1[0]);
+               g4 = s32(PacketBuffer.U1[1]);
+               b4 = s32(PacketBuffer.U1[2]);
+
+               {
+                       s32 temp;
+                       temp = ymin - y0;
+                       if (temp > 0) { y0 = ymin; v0 += temp; }
+                       if (y1 > ymax) y1 = ymax;
+                       if (y1 <= y0) return;
+                       
+                       temp = xmin - x0;
+                       if (temp > 0) { x0 = xmin; u0 += temp; }
+                       if (x1 > xmax) x1 = xmax;
+                       x1 -= x0;
+                       if (x1 <= 0) return;
+               }
+       }
+
+       {
+               u16 *Pixel = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)];
+               const int li=linesInterlace;
+               const u32 masku=TextureWindow[2];
+               const u32 maskv=TextureWindow[3];
+
+               for (;y0<y1;++y0) {
+                       if( 0 == (y0&li) ) gpuSpriteSpanDriver(Pixel,x1,FRAME_OFFSET(u0,v0),masku);
+                       Pixel += FRAME_WIDTH;
+                       v0 = (v0+1)&maskv;
+               }
+       }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void gpuDrawT(const PT gpuTileSpanDriver)
+{
+       s32 x0, y0;
+       s32 x1, y1;
+
+       x1 = x0 = GPU_EXPANDSIGN_SPRT(PacketBuffer.S2[2]) + DrawingOffset[0];
+       y1 = y0 = GPU_EXPANDSIGN_SPRT(PacketBuffer.S2[3]) + DrawingOffset[1];
+       x1+= PacketBuffer.S2[4];
+       y1+= PacketBuffer.S2[5];
+
+       {
+               s32 xmin, xmax;
+               s32 ymin, ymax;
+               xmin = DrawingArea[0];  xmax = DrawingArea[2];
+               ymin = DrawingArea[1];  ymax = DrawingArea[3];
+
+               {
+                       int rx0 = Max2(xmin,Min2(x0,x1));
+                       int ry0 = Max2(ymin,Min2(y0,y1));
+                       int rx1 = Min2(xmax,Max2(x0,x1));
+                       int ry1 = Min2(ymax,Max2(y0,y1));
+                       if(rx0>=rx1 || ry0>=ry1) return;
+               }
+
+               if (y0 < ymin) y0 = ymin;
+               if (y1 > ymax) y1 = ymax;
+               if (y1 <= y0) return;
+
+               if (x0 < xmin) x0 = xmin;
+               if (x1 > xmax) x1 = xmax;
+               x1 -= x0;
+               if (x1 <= 0) return;
+       }
+       
+       {
+               u16 *Pixel = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)];
+               const u16 Data = GPU_RGB16(PacketBuffer.U4[0]);
+               const int li=linesInterlace;
+
+               for (; y0<y1; ++y0)
+               {
+                       if( 0 == (y0&li) ) gpuTileSpanDriver(Pixel,x1,Data);
+                       Pixel += FRAME_WIDTH;
+               }
+       }
+}