--- /dev/null
+/***************************************************************************
+* 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);
+}
--- /dev/null
+/***************************************************************************
+* 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
--- /dev/null
+/***************************************************************************
+* 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_
--- /dev/null
+/***************************************************************************
+* 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;
+ }
+}
--- /dev/null
+/***************************************************************************
+ * 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
--- /dev/null
+/***************************************************************************
+* 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>
+};
--- /dev/null
+/***************************************************************************
+* 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_
--- /dev/null
+/***************************************************************************
+* 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_
--- /dev/null
+/***************************************************************************
+ * 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);
+ }
+ }
+}
--- /dev/null
+/***************************************************************************
+* 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)
+ );
+ }
+ }
+ }
+ }
+}
--- /dev/null
+/***************************************************************************
+* 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);
+ }
+ }
+ }
+}
--- /dev/null
+/***************************************************************************
+* 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;
+ }
+ }
+}
notaz.gp2x.de / pcsx_rearmed.git / commitdiff