From 86aad47b0418b1715a4d223adf8f59aa92619d15 Mon Sep 17 00:00:00 2001 From: notaz Date: Sun, 2 Jan 2011 00:59:02 +0200 Subject: [PATCH] import gpu_unai from PCSX4ALL project --- plugins/gpu_unai/gpu.cpp | 840 ++++++++++++++++++++++++++ plugins/gpu_unai/gpu.h | 87 +++ plugins/gpu_unai/gpu_blit.h | 405 +++++++++++++ plugins/gpu_unai/gpu_command.h | 444 ++++++++++++++ plugins/gpu_unai/gpu_fixedpoint.h | 129 ++++ plugins/gpu_unai/gpu_inner.h | 427 +++++++++++++ plugins/gpu_unai/gpu_inner_blend.h | 141 +++++ plugins/gpu_unai/gpu_inner_light.h | 80 +++ plugins/gpu_unai/gpu_raster_image.h | 203 +++++++ plugins/gpu_unai/gpu_raster_line.h | 255 ++++++++ plugins/gpu_unai/gpu_raster_polygon.h | 837 +++++++++++++++++++++++++ plugins/gpu_unai/gpu_raster_sprite.h | 133 ++++ 12 files changed, 3981 insertions(+) create mode 100644 plugins/gpu_unai/gpu.cpp create mode 100644 plugins/gpu_unai/gpu.h create mode 100644 plugins/gpu_unai/gpu_blit.h create mode 100644 plugins/gpu_unai/gpu_command.h create mode 100644 plugins/gpu_unai/gpu_fixedpoint.h create mode 100644 plugins/gpu_unai/gpu_inner.h create mode 100644 plugins/gpu_unai/gpu_inner_blend.h create mode 100644 plugins/gpu_unai/gpu_inner_light.h create mode 100644 plugins/gpu_unai/gpu_raster_image.h create mode 100644 plugins/gpu_unai/gpu_raster_line.h create mode 100644 plugins/gpu_unai/gpu_raster_polygon.h create mode 100644 plugins/gpu_unai/gpu_raster_sprite.h diff --git a/plugins/gpu_unai/gpu.cpp b/plugins/gpu_unai/gpu.cpp new file mode 100644 index 00000000..ba32d180 --- /dev/null +++ b/plugins/gpu_unai/gpu.cpp @@ -0,0 +1,840 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +#include "gpu.h" +#include "port.h" +#include "profiler.h" +#include "debug.h" + +int skipCount = 2; /* frame skip (0,1,2,3...) */ +int skCount=0; /* internal frame skip */ +int linesInterlace = 0; /* internal lines interlace */ +int linesInterlace_user = 0; /* Lines interlace */ + +bool isSkip=false; /* skip frame (info coming from GPU) */ +bool skipFrame=false; /* skip frame (according to frame skip) */ +bool alt_fps = false; /* Alternative FPS algorithm */ +bool show_fps = false; /* Show FPS statistics */ + +bool isPAL=false; /* PAL video timing */ +bool progressInterlace_flag = false; /* Progressive interlace flag */ +bool progressInterlace = false; /* Progressive interlace option*/ +bool frameLimit = false; /* frames to wait */ +bool light = true; /* lighting */ +bool blend = true; /* blending */ + +bool enableAbbeyHack = false; /* Abe's Odyssey hack */ +u8 BLEND_MODE; +u8 TEXT_MODE; +u8 Masking; + +u16 PixelMSB; +u16 PixelData; + +/////////////////////////////////////////////////////////////////////////////// +// GPU Global data +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Dma Transfers info +s32 px,py; +s32 x_end,y_end; +u16* pvram; + +u32 FrameToRead; +u32 FrameToWrite; + +u32 GP0; +s32 PacketCount; +s32 PacketIndex; + +/////////////////////////////////////////////////////////////////////////////// +// Display status +u32 DisplayArea [6]; + +/////////////////////////////////////////////////////////////////////////////// +// Rasterizer status +u32 TextureWindow [4]; +u32 DrawingArea [4]; +u32 DrawingOffset [2]; + +/////////////////////////////////////////////////////////////////////////////// +// Rasterizer status + +u16* TBA; +u16* CBA; + +/////////////////////////////////////////////////////////////////////////////// +// Inner Loops +s32 u4, du4; +s32 v4, dv4; +s32 r4, dr4; +s32 g4, dg4; +s32 b4, db4; +u32 lInc; +u32 tInc, tMsk; + +GPUPacket PacketBuffer; +u16 GPU_FrameBuffer[FRAME_BUFFER_SIZE/2]; // FRAME_BUFFER_SIZE is defined in bytes +u32 GPU_GP1; + +/////////////////////////////////////////////////////////////////////////////// +// Inner loop driver instanciation file +#include "gpu_inner.h" + +/////////////////////////////////////////////////////////////////////////////// +// GPU Raster Macros +#define GPU_RGB16(rgb) ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3)) + +#define GPU_EXPANDSIGN_POLY(x) (((s32)(x)<<20)>>20) +//#define GPU_EXPANDSIGN_POLY(x) (((s32)(x)<<21)>>21) +#define GPU_EXPANDSIGN_SPRT(x) (((s32)(x)<<21)>>21) + +//#define GPU_TESTRANGE(x) { if((u32)(x+1024) > 2047) return; } +#define GPU_TESTRANGE(x) { if ((x<-1023) || (x>1023)) return; } + +#define GPU_SWAP(a,b,t) {(t)=(a);(a)=(b);(b)=(t);} + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal image drawing functions +#include "gpu_raster_image.h" + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal line drawing functions +#include "gpu_raster_line.h" + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal polygon drawing functions +#include "gpu_raster_polygon.h" + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal sprite drawing functions +#include "gpu_raster_sprite.h" + +/////////////////////////////////////////////////////////////////////////////// +// GPU command buffer execution/store +#include "gpu_command.h" + +/////////////////////////////////////////////////////////////////////////////// +INLINE void gpuReset(void) +{ + GPU_GP1 = 0x14802000; + TextureWindow[0] = 0; + TextureWindow[1] = 0; + TextureWindow[2] = 255; + TextureWindow[3] = 255; + DrawingArea[2] = 256; + DrawingArea[3] = 240; + DisplayArea[2] = 256; + DisplayArea[3] = 240; + DisplayArea[5] = 240; +} + +/////////////////////////////////////////////////////////////////////////////// +bool GPU_init(void) +{ + gpuReset(); + + // s_invTable + for(int i=1;i<=(1<>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> 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>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=1000000) + { + u32 expected_fps=(isPAL?50:60); + sprintf(msg,"FPS=%3d/%2d SPD=%3d%%",((real_fps*(12-skipCount))/12),((expected_fps*(12-skipCount))/12),((real_fps*100)/expected_fps)); + prev=now; + real_fps=0; + } + port_printf(5,5,msg); + } + + // Update frame-skip + if (!alt_fps) + { + // Video frame-skip + skipFrame=skipTable[skipCount][skCount]; + skCount--; if (skCount<0) skCount=11; + isSkip=skipFrame; + } + else + { + // Game frame-skip + if (!isSkip) + { + skipFrame=skipTable[skipCount][skCount]; + skCount--; if (skCount<0) skCount=11; + isSkip=true; + } + } + + pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS); +} diff --git a/plugins/gpu_unai/gpu.h b/plugins/gpu_unai/gpu.h new file mode 100644 index 00000000..18116303 --- /dev/null +++ b/plugins/gpu_unai/gpu.h @@ -0,0 +1,87 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +#ifndef NEW_GPU_H +#define NEW_GPU_H + +/////////////////////////////////////////////////////////////////////////////// +// GPU global definitions +#define FRAME_BUFFER_SIZE (1024*512*2) +#define FRAME_WIDTH 1024 +#define FRAME_HEIGHT 512 +#define FRAME_OFFSET(x,y) (((y)<<10)+(x)) + +#define VIDEO_WIDTH 320 + +typedef char s8; +typedef signed short s16; +typedef signed int s32; +typedef signed long long s64; + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; + +#include "gpu_fixedpoint.h" + +/////////////////////////////////////////////////////////////////////////////// +// Tweaks and Hacks +extern int skipCount; +extern bool enableAbbeyHack; +extern bool show_fps; +extern bool alt_fps; + +/////////////////////////////////////////////////////////////////////////////// +// interlaced rendering +extern int linesInterlace_user; +extern bool progressInterlace; + +extern bool light; +extern bool blend; + +typedef struct { + u32 Version; + u32 GPU_gp1; + u32 Control[256]; + unsigned char FrameBuffer[1024*512*2]; +} GPUFreeze_t; + +struct GPUPacket +{ + union + { + u32 U4[16]; + s32 S4[16]; + u16 U2[32]; + s16 S2[32]; + u8 U1[64]; + s8 S1[64]; + }; +}; + +/////////////////////////////////////////////////////////////////////////////// +// Compile Options + +//#define ENABLE_GPU_NULL_SUPPORT // Enables NullGPU support +//#define ENABLE_GPU_LOG_SUPPORT // Enables gpu logger, very slow only for windows debugging + +/////////////////////////////////////////////////////////////////////////////// +#endif // NEW_GPU_H diff --git a/plugins/gpu_unai/gpu_blit.h b/plugins/gpu_unai/gpu_blit.h new file mode 100644 index 00000000..35cd056e --- /dev/null +++ b/plugins/gpu_unai/gpu_blit.h @@ -0,0 +1,405 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +#ifndef _INNER_BLIT_H_ +#define _INNER_BLIT_H_ + +#ifndef USE_BGR15 +#define RGB24(R,G,B) (((((R)&0xF8)<<8)|(((G)&0xFC)<<3)|(((B)&0xF8)>>3))) +#define RGB16X2(C) (((C)&(0x1f001f<<10))>>10) | (((C)&(0x1f001f<<5))<<1) | (((C)&(0x1f001f<<0))<<11) +#define RGB16(C) (((C)&(0x1f<<10))>>10) | (((C)&(0x1f<<5))<<1) | (((C)&(0x1f<<0))<<11) +#else +#define RGB24(R,G,B) ((((R)&0xF8)>>3)|(((G)&0xF8)<<2)|(((B)&0xF8)<<7)) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// GPU Blitting code with rescale and interlace support. + +INLINE void GPU_BlitWW(const void* src, u16* dst16, u32 isRGB24) +{ + u32 uCount; + if(isRGB24 == 0) + { + #ifndef USE_BGR15 + uCount = 20; + const u32* src32 = (const u32*) src; + u32* dst32 = (u32*)(void*) dst16; + do{ + dst32[0] = RGB16X2(src32[0]); + dst32[1] = RGB16X2(src32[1]); + dst32[2] = RGB16X2(src32[2]); + dst32[3] = RGB16X2(src32[3]); + dst32[4] = RGB16X2(src32[4]); + dst32[5] = RGB16X2(src32[5]); + dst32[6] = RGB16X2(src32[6]); + dst32[7] = RGB16X2(src32[7]); + dst32 += 8; + src32 += 8; + }while(--uCount); + #else + memcpy(dst16,src,640); + #endif + } + else + { + uCount = 20; + const u8* src8 = (const u8*)src; + do{ + dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); + dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); + dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); + dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] ); + dst16[ 4] = RGB24(src8[12], src8[13], src8[14] ); + dst16[ 5] = RGB24(src8[15], src8[16], src8[17] ); + dst16[ 6] = RGB24(src8[18], src8[19], src8[20] ); + dst16[ 7] = RGB24(src8[21], src8[22], src8[23] ); + + dst16[ 8] = RGB24(src8[24], src8[25], src8[26] ); + dst16[ 9] = RGB24(src8[27], src8[28], src8[29] ); + dst16[10] = RGB24(src8[30], src8[31], src8[32] ); + dst16[11] = RGB24(src8[33], src8[34], src8[35] ); + dst16[12] = RGB24(src8[36], src8[37], src8[38] ); + dst16[13] = RGB24(src8[39], src8[40], src8[41] ); + dst16[14] = RGB24(src8[42], src8[43], src8[44] ); + dst16[15] = RGB24(src8[45], src8[46], src8[47] ); + dst16 += 16; + src8 += 48; + }while(--uCount); + } +} + +INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, u32 isRGB24) +{ + u32 uCount; + if(isRGB24 == 0) + { + #ifndef USE_BGR15 + uCount = 32; + const u16* src16 = (const u16*) src; + do{ + dst16[ 0] = RGB16(src16[0]); + dst16[ 1] = RGB16(src16[1]); + dst16[ 2] = RGB16(src16[3]); + dst16[ 3] = RGB16(src16[4]); + dst16[ 4] = RGB16(src16[6]); + dst16[ 5] = RGB16(src16[8]); + dst16[ 6] = RGB16(src16[9]); + dst16[ 7] = RGB16(src16[11]); + dst16[ 8] = RGB16(src16[12]); + dst16[ 9] = RGB16(src16[14]); + dst16 += 10; + src16 += 16; + }while(--uCount); + #else + uCount = 64; + const u16* src16 = (const u16*) src; + do{ + *dst16++ = *src16++; + *dst16++ = *src16; + src16+=2; + *dst16++ = *src16++; + *dst16++ = *src16; + src16+=2; + *dst16++ = *src16; + src16+=2; + }while(--uCount); + #endif + } + else + { + uCount = 32; + const u8* src8 = (const u8*)src; + do{ + dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); + dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); + dst16[ 2] = RGB24(src8[ 9], src8[10], src8[11] ); + dst16[ 3] = RGB24(src8[12], src8[13], src8[14] ); + dst16[ 4] = RGB24(src8[18], src8[19], src8[20] ); + + dst16[ 5] = RGB24(src8[24], src8[25], src8[26] ); + dst16[ 6] = RGB24(src8[27], src8[28], src8[29] ); + dst16[ 7] = RGB24(src8[33], src8[34], src8[35] ); + dst16[ 8] = RGB24(src8[36], src8[37], src8[38] ); + dst16[ 9] = RGB24(src8[42], src8[43], src8[44] ); + + dst16 += 10; + src8 += 48; + }while(--uCount); + } +} + +INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, u32 isRGB24) +{ + u32 uCount; + if(isRGB24 == 0) + { + #ifndef USE_BGR15 + uCount = 32; + const u16* src16 = (const u16*) src; + do{ + dst16[ 0] = RGB16(src16[0]); + dst16[ 1] = RGB16(src16[1]); + dst16[ 2] = RGB16(src16[2]); + dst16[ 3] = RGB16(src16[3]); + dst16[ 4] = RGB16(src16[4]); + dst16[ 5] = RGB16(src16[6]); + dst16[ 6] = RGB16(src16[7]); + dst16[ 7] = RGB16(src16[8]); + dst16[ 8] = RGB16(src16[9]); + dst16[ 9] = RGB16(src16[10]); + dst16 += 10; + src16 += 12; + }while(--uCount); + #else + uCount = 64; + const u16* src16 = (const u16*) src; + do{ + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16; + src16+=2; + }while(--uCount); + #endif + } + else + { + uCount = 32; + const u8* src8 = (const u8*)src; + do{ + dst16[0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); + dst16[1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); + dst16[2] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); + dst16[3] = RGB24(src8[ 9], src8[10], src8[11] ); + dst16[4] = RGB24(src8[12], src8[13], src8[14] ); + dst16[5] = RGB24(src8[18], src8[19], src8[20] ); + dst16[6] = RGB24(src8[21], src8[22], src8[23] ); + dst16[7] = RGB24(src8[24], src8[25], src8[26] ); + dst16[8] = RGB24(src8[27], src8[28], src8[29] ); + dst16[9] = RGB24(src8[30], src8[31], src8[32] ); + dst16 += 10; + src8 += 36; + }while(--uCount); + } +} + +INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, u32 isRGB24, u32 uClip_src) +{ + u32 uCount; + if(isRGB24 == 0) + { + #ifndef USE_BGR15 + uCount = 20; + const u16* src16 = ((const u16*) src) + uClip_src; + do{ + dst16[ 0] = RGB16(src16[0]); + dst16[ 1] = RGB16(src16[1]); + dst16[ 2] = RGB16(src16[2]); + dst16[ 3] = RGB16(src16[3]); + dst16[ 4] = RGB16(src16[4]); + dst16[ 5] = RGB16(src16[5]); + dst16[ 6] = RGB16(src16[6]); + dst16[ 7] = RGB16(src16[7]); + + dst16[ 8] = RGB16(src16[9]); + dst16[ 9] = RGB16(src16[10]); + dst16[10] = RGB16(src16[11]); + dst16[11] = RGB16(src16[12]); + dst16[12] = RGB16(src16[13]); + dst16[13] = RGB16(src16[14]); + dst16[14] = RGB16(src16[15]); + dst16[15] = RGB16(src16[16]); + dst16 += 16; + src16 += 18; + }while(--uCount); + #else + uCount = 40; + const u16* src16 = ((const u16*) src) + uClip_src; + do{ + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16; + src16+=2; + }while(--uCount); + #endif + } + else + { + uCount = 20; + const u8* src8 = (const u8*)src + (uClip_src<<1) + uClip_src; + do{ + dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); + dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); + dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); + dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] ); + dst16[ 4] = RGB24(src8[12], src8[13], src8[14] ); + dst16[ 5] = RGB24(src8[15], src8[16], src8[17] ); + dst16[ 6] = RGB24(src8[18], src8[19], src8[20] ); + dst16[ 7] = RGB24(src8[21], src8[22], src8[23] ); + + dst16[ 8] = RGB24(src8[27], src8[28], src8[29] ); + dst16[ 9] = RGB24(src8[30], src8[31], src8[32] ); + dst16[10] = RGB24(src8[33], src8[34], src8[35] ); + dst16[11] = RGB24(src8[36], src8[37], src8[38] ); + dst16[12] = RGB24(src8[39], src8[40], src8[41] ); + dst16[13] = RGB24(src8[42], src8[43], src8[44] ); + dst16[14] = RGB24(src8[45], src8[46], src8[47] ); + dst16[15] = RGB24(src8[48], src8[49], src8[50] ); + dst16 += 16; + src8 += 54; + }while(--uCount); + } +} + +INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, u32 isRGB24) +{ + u32 uCount; + if(isRGB24 == 0) + { + #ifndef USE_BGR15 + uCount = 32; + const u16* src16 = (const u16*) src; + do{ + dst16[ 0] = RGB16(src16[0]); + dst16[ 1] = RGB16(src16[1]); + dst16[ 2] = dst16[1]; + dst16[ 3] = RGB16(src16[2]); + dst16[ 4] = RGB16(src16[3]); + dst16[ 5] = RGB16(src16[4]); + dst16[ 6] = RGB16(src16[5]); + dst16[ 7] = dst16[6]; + dst16[ 8] = RGB16(src16[6]); + dst16[ 9] = RGB16(src16[7]); + dst16 += 10; + src16 += 8; + }while(--uCount); + #else + uCount = 64; + const u16* src16 = (const u16*) src; + do{ + *dst16++ = *src16++; + *dst16++ = *src16; + *dst16++ = *src16++; + *dst16++ = *src16++; + *dst16++ = *src16++; + }while(--uCount); + #endif + } + else + { + uCount = 32; + const u8* src8 = (const u8*)src; + do{ + dst16[ 0] = RGB24(src8[0], src8[ 1], src8[ 2] ); + dst16[ 1] = RGB24(src8[3], src8[ 4], src8[ 5] ); + dst16[ 2] = dst16[1]; + dst16[ 3] = RGB24(src8[6], src8[ 7], src8[ 8] ); + dst16[ 4] = RGB24(src8[9], src8[10], src8[11] ); + + dst16[ 5] = RGB24(src8[12], src8[13], src8[14] ); + dst16[ 6] = RGB24(src8[15], src8[16], src8[17] ); + dst16[ 7] = dst16[6]; + dst16[ 8] = RGB24(src8[18], src8[19], src8[20] ); + dst16[ 9] = RGB24(src8[21], src8[22], src8[23] ); + dst16 += 10; + src8 += 24; + }while(--uCount); + } +} + + +INLINE void GPU_BlitWS(const void* src, u16* dst16, u32 isRGB24) +{ + u32 uCount; + if(isRGB24 == 0) + { + #ifndef USE_BGR15 + uCount = 20; + const u16* src16 = (const u16*) src; + do{ + dst16[ 0] = RGB16(src16[0]); + dst16[ 1] = RGB16(src16[2]); + dst16[ 2] = RGB16(src16[4]); + dst16[ 3] = RGB16(src16[6]); + + dst16[ 4] = RGB16(src16[8]); + dst16[ 5] = RGB16(src16[10]); + dst16[ 6] = RGB16(src16[12]); + dst16[ 7] = RGB16(src16[14]); + + dst16[ 8] = RGB16(src16[16]); + dst16[ 9] = RGB16(src16[18]); + dst16[10] = RGB16(src16[20]); + dst16[11] = RGB16(src16[22]); + + dst16[12] = RGB16(src16[24]); + dst16[13] = RGB16(src16[26]); + dst16[14] = RGB16(src16[28]); + dst16[15] = RGB16(src16[30]); + + dst16 += 16; + src16 += 32; + }while(--uCount); + #else + uCount = 320; + const u16* src16 = (const u16*) src; + do{ + *dst16++ = *src16; src16+=2; + }while(--uCount); + #endif + } + else + { + uCount = 20; + const u8* src8 = (const u8*) src; + do{ + dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); + dst16[ 1] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); + dst16[ 2] = RGB24(src8[12], src8[13], src8[14] ); + dst16[ 3] = RGB24(src8[18], src8[19], src8[20] ); + + dst16[ 4] = RGB24(src8[24], src8[25], src8[26] ); + dst16[ 5] = RGB24(src8[30], src8[31], src8[32] ); + dst16[ 6] = RGB24(src8[36], src8[37], src8[38] ); + dst16[ 7] = RGB24(src8[42], src8[43], src8[44] ); + + dst16[ 8] = RGB24(src8[48], src8[49], src8[50] ); + dst16[ 9] = RGB24(src8[54], src8[55], src8[56] ); + dst16[10] = RGB24(src8[60], src8[61], src8[62] ); + dst16[11] = RGB24(src8[66], src8[67], src8[68] ); + + dst16[12] = RGB24(src8[72], src8[73], src8[74] ); + dst16[13] = RGB24(src8[78], src8[79], src8[80] ); + dst16[14] = RGB24(src8[84], src8[85], src8[86] ); + dst16[15] = RGB24(src8[90], src8[91], src8[92] ); + + dst16 += 16; + src8 += 96; + }while(--uCount); + } +} + +#endif //_INNER_BLIT_H_ diff --git a/plugins/gpu_unai/gpu_command.h b/plugins/gpu_unai/gpu_command.h new file mode 100644 index 00000000..2dc7f5bf --- /dev/null +++ b/plugins/gpu_unai/gpu_command.h @@ -0,0 +1,444 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +INLINE void gpuSetTexture(u16 tpage) +{ + long tp; + long tx, ty; + GPU_GP1 = (GPU_GP1 & ~0x7FF) | (tpage & 0x7FF); + + TextureWindow[0]&= ~TextureWindow[2]; + TextureWindow[1]&= ~TextureWindow[3]; + + tp = (tpage >> 7) & 3; + tx = (tpage & 0x0F) << 6; + ty = (tpage & 0x10) << 4; + + tx += (TextureWindow[0] >> (2 - tp)); + ty += TextureWindow[1]; + + BLEND_MODE = (((tpage>>5)&0x3) ) << 3; + TEXT_MODE = (((tpage>>7)&0x3) + 1 ) << 5; // +1 el cero no lo usamos + + TBA = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(tx, ty)]; + +} + +/////////////////////////////////////////////////////////////////////////////// +INLINE void gpuSetCLUT(u16 clut) +{ + CBA = &((u16*)GPU_FrameBuffer)[(clut & 0x7FFF) << 4]; +} + +#ifdef ENABLE_GPU_NULL_SUPPORT +#define NULL_GPU() break +#else +#define NULL_GPU() +#endif + +#ifdef ENABLE_GPU_LOG_SUPPORT +#define DO_LOG(expr) printf expr +#else +#define DO_LOG(expr) {} +#endif + +#define Blending (((PRIM&0x2)&&(blend))?(PRIM&0x2):0) +#define Blending_Mode (((PRIM&0x2)&&(blend))?BLEND_MODE:0) +#define Lighting (((~PRIM)&0x1)&&(light)) + +void gpuSendPacketFunction(const int PRIM) +{ + //printf("0x%x\n",PRIM); + + switch (PRIM) + { + case 0x02: + NULL_GPU(); + gpuClearImage(); // prim handles updateLace && skip + DO_LOG(("gpuClearImage(0x%x)\n",PRIM)); + break; + case 0x20: + case 0x21: + case 0x22: + case 0x23: + if (!isSkip) + { + NULL_GPU(); + gpuDrawF3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB]); + DO_LOG(("gpuDrawF3(0x%x)\n",PRIM)); + } + break; + case 0x24: + case 0x25: + case 0x26: + case 0x27: + if (!isSkip) + { + NULL_GPU(); + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (PacketBuffer.U4[4] >> 16); + if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F)) + gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | PixelMSB]); + else + gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | PixelMSB]); + DO_LOG(("gpuDrawFT3(0x%x)\n",PRIM)); + } + break; + case 0x28: + case 0x29: + case 0x2A: + case 0x2B: + if (!isSkip) + { + NULL_GPU(); + const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB]; + //--PacketBuffer.S2[6]; + gpuDrawF3(gpuPolySpanDriver); + PacketBuffer.U4[1] = PacketBuffer.U4[4]; + //--PacketBuffer.S2[2]; + gpuDrawF3(gpuPolySpanDriver); + DO_LOG(("gpuDrawF4(0x%x)\n",PRIM)); + } + break; + case 0x2C: + case 0x2D: + case 0x2E: + case 0x2F: + if (!isSkip) + { + NULL_GPU(); + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (PacketBuffer.U4[4] >> 16); + PP gpuPolySpanDriver; + if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F)) + gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | PixelMSB]; + else + gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | PixelMSB]; + //--PacketBuffer.S2[6]; + gpuDrawFT3(gpuPolySpanDriver); + PacketBuffer.U4[1] = PacketBuffer.U4[7]; + PacketBuffer.U4[2] = PacketBuffer.U4[8]; + //--PacketBuffer.S2[2]; + gpuDrawFT3(gpuPolySpanDriver); + DO_LOG(("gpuDrawFT4(0x%x)\n",PRIM)); + } + break; + case 0x30: + case 0x31: + case 0x32: + case 0x33: + if (!isSkip) + { + NULL_GPU(); + gpuDrawG3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB]); + DO_LOG(("gpuDrawG3(0x%x)\n",PRIM)); + } + break; + case 0x34: + case 0x35: + case 0x36: + case 0x37: + if (!isSkip) + { + NULL_GPU(); + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (PacketBuffer.U4[5] >> 16); + gpuDrawGT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB]); + DO_LOG(("gpuDrawGT3(0x%x)\n",PRIM)); + } + break; + case 0x38: + case 0x39: + case 0x3A: + case 0x3B: + if (!isSkip) + { + NULL_GPU(); + const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB]; + //--PacketBuffer.S2[6]; + gpuDrawG3(gpuPolySpanDriver); + PacketBuffer.U4[0] = PacketBuffer.U4[6]; + PacketBuffer.U4[1] = PacketBuffer.U4[7]; + //--PacketBuffer.S2[2]; + gpuDrawG3(gpuPolySpanDriver); + DO_LOG(("gpuDrawG4(0x%x)\n",PRIM)); + } + break; + case 0x3C: + case 0x3D: + case 0x3E: + case 0x3F: + if (!isSkip) + { + NULL_GPU(); + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (PacketBuffer.U4[5] >> 16); + const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB]; + //--PacketBuffer.S2[6]; + gpuDrawGT3(gpuPolySpanDriver); + PacketBuffer.U4[0] = PacketBuffer.U4[9]; + PacketBuffer.U4[1] = PacketBuffer.U4[10]; + PacketBuffer.U4[2] = PacketBuffer.U4[11]; + //--PacketBuffer.S2[2]; + gpuDrawGT3(gpuPolySpanDriver); + DO_LOG(("gpuDrawGT4(0x%x)\n",PRIM)); + } + break; + case 0x40: + case 0x41: + case 0x42: + case 0x43: + if (!isSkip) + { + NULL_GPU(); + gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]); + DO_LOG(("gpuDrawLF(0x%x)\n",PRIM)); + } + break; + case 0x48: + case 0x49: + case 0x4A: + case 0x4B: + case 0x4C: + case 0x4D: + case 0x4E: + case 0x4F: + if (!isSkip) + { + NULL_GPU(); + gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]); + DO_LOG(("gpuDrawLF(0x%x)\n",PRIM)); + } + if ((PacketBuffer.U4[3] & 0xF000F000) != 0x50005000) + { + PacketBuffer.U4[1] = PacketBuffer.U4[2]; + PacketBuffer.U4[2] = PacketBuffer.U4[3]; + PacketCount = 1; + PacketIndex = 3; + } + break; + case 0x50: + case 0x51: + case 0x52: + case 0x53: + if (!isSkip) + { + NULL_GPU(); + gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]); + DO_LOG(("gpuDrawLG(0x%x)\n",PRIM)); + } + break; + case 0x58: + case 0x59: + case 0x5A: + case 0x5B: + case 0x5C: + case 0x5D: + case 0x5E: + case 0x5F: + if (!isSkip) + { + NULL_GPU(); + gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]); + DO_LOG(("gpuDrawLG(0x%x)\n",PRIM)); + } + if ((PacketBuffer.U4[4] & 0xF000F000) != 0x50005000) + { + PacketBuffer.U1[3 + (2 * 4)] = PacketBuffer.U1[3 + (0 * 4)]; + PacketBuffer.U4[0] = PacketBuffer.U4[2]; + PacketBuffer.U4[1] = PacketBuffer.U4[3]; + PacketBuffer.U4[2] = PacketBuffer.U4[4]; + PacketCount = 2; + PacketIndex = 3; + } + break; + case 0x60: + case 0x61: + case 0x62: + case 0x63: + if (!isSkip) + { + NULL_GPU(); + gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]); + DO_LOG(("gpuDrawT(0x%x)\n",PRIM)); + } + break; + case 0x64: + case 0x65: + case 0x66: + case 0x67: + if (!isSkip) + { + NULL_GPU(); + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (GPU_GP1); + if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F)) + gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7) | PixelMSB]); + else + gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7) | PixelMSB]); + DO_LOG(("gpuDrawS(0x%x)\n",PRIM)); + } + break; + case 0x68: + case 0x69: + case 0x6A: + case 0x6B: + if (!isSkip) + { + NULL_GPU(); + PacketBuffer.U4[2] = 0x00010001; + gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]); + DO_LOG(("gpuDrawT(0x%x)\n",PRIM)); + } + break; + case 0x70: + case 0x71: + case 0x72: + case 0x73: + if (!isSkip) + { + NULL_GPU(); + PacketBuffer.U4[2] = 0x00080008; + gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]); + DO_LOG(("gpuDrawT(0x%x)\n",PRIM)); + } + break; + case 0x74: + case 0x75: + case 0x76: + case 0x77: + if (!isSkip) + { + NULL_GPU(); + PacketBuffer.U4[3] = 0x00080008; + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (GPU_GP1); + if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F)) + gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7) | PixelMSB]); + else + gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7) | PixelMSB]); + DO_LOG(("gpuDrawS(0x%x)\n",PRIM)); + } + break; + case 0x78: + case 0x79: + case 0x7A: + case 0x7B: + if (!isSkip) + { + NULL_GPU(); + PacketBuffer.U4[2] = 0x00100010; + gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]); + DO_LOG(("gpuDrawT(0x%x)\n",PRIM)); + } + break; + case 0x7C: + case 0x7D: + case 0x7E: + case 0x7F: + if (!isSkip) + { + NULL_GPU(); + PacketBuffer.U4[3] = 0x00100010; + gpuSetCLUT (PacketBuffer.U4[2] >> 16); + gpuSetTexture (GPU_GP1); + if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F)) + gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7) | PixelMSB]); + else + gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7) | PixelMSB]); + DO_LOG(("gpuDrawS(0x%x)\n",PRIM)); + } + break; + case 0x80: // vid -> vid + gpuMoveImage(); // prim handles updateLace && skip + DO_LOG(("gpuMoveImage(0x%x)\n",PRIM)); + break; + case 0xA0: // sys ->vid + gpuLoadImage(); // prim handles updateLace && skip + if (alt_fps) isSkip=false; + DO_LOG(("gpuLoadImage(0x%x)\n",PRIM)); + break; + case 0xC0: // vid -> sys + gpuStoreImage(); // prim handles updateLace && skip + DO_LOG(("gpuStoreImage(0x%x)\n",PRIM)); + break; + case 0xE1: + { + const u32 temp = PacketBuffer.U4[0]; + GPU_GP1 = (GPU_GP1 & ~0x000007FF) | (temp & 0x000007FF); + gpuSetTexture(temp); + DO_LOG(("gpuSetTexture(0x%x)\n",PRIM)); + } + break; + case 0xE2: + { + static const u8 TextureMask[32] = { + 255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7, // + 127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7 // + }; + const u32 temp = PacketBuffer.U4[0]; + TextureWindow[0] = ((temp >> 10) & 0x1F) << 3; + TextureWindow[1] = ((temp >> 15) & 0x1F) << 3; + TextureWindow[2] = TextureMask[(temp >> 0) & 0x1F]; + TextureWindow[3] = TextureMask[(temp >> 5) & 0x1F]; + gpuSetTexture(GPU_GP1); + isSkip = false; + DO_LOG(("TextureWindow(0x%x)\n",PRIM)); + } + break; + case 0xE3: + { + const u32 temp = PacketBuffer.U4[0]; + DrawingArea[0] = temp & 0x3FF; + DrawingArea[1] = (temp >> 10) & 0x3FF; + isSkip = false; + DO_LOG(("DrawingArea_Pos(0x%x)\n",PRIM)); + } + break; + case 0xE4: + { + const u32 temp = PacketBuffer.U4[0]; + DrawingArea[2] = (temp & 0x3FF) + 1; + DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1; + isSkip = false; + DO_LOG(("DrawingArea_Size(0x%x)\n",PRIM)); + } + break; + case 0xE5: + { + const u32 temp = PacketBuffer.U4[0]; + DrawingOffset[0] = ((long)temp<<(32-11))>>(32-11); + DrawingOffset[1] = ((long)temp<<(32-22))>>(32-11); + isSkip = false; + DO_LOG(("DrawingOffset(0x%x)\n",PRIM)); + } + break; + case 0xE6: + { + const u32 temp = PacketBuffer.U4[0]; + //GPU_GP1 = (GPU_GP1 & ~0x00001800) | ((temp&3) << 11); + Masking = (temp & 0x2) << 1; + PixelMSB =(temp & 0x1) << 8; + DO_LOG(("SetMask(0x%x)\n",PRIM)); + } + break; + } +} diff --git a/plugins/gpu_unai/gpu_fixedpoint.h b/plugins/gpu_unai/gpu_fixedpoint.h new file mode 100644 index 00000000..03f07d21 --- /dev/null +++ b/plugins/gpu_unai/gpu_fixedpoint.h @@ -0,0 +1,129 @@ +/*************************************************************************** + * Copyright (C) 2010 PCSX4ALL Team * + * Copyright (C) 2010 Unai * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * + ***************************************************************************/ + +#ifndef FIXED_H +#define FIXED_H + +typedef s32 fixed; + +#ifdef GPU_TABLE_10_BITS +#define TABLE_BITS 10 +#else +#define TABLE_BITS 16 +#endif + +#define FIXED_BITS 16 + +#define fixed_ZERO ((fixed)0) +#define fixed_ONE ((fixed)1<>1)) + +// big precision inverse table. +s32 s_invTable[(1<>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 +INLINE T Min2 (const T _a, const T _b) { return (_a<_b)?_a:_b; } + +template +INLINE T Min3 (const T _a, const T _b, const T _c) { return Min2(Min2(_a,_b),_c); } + +/////////////////////////////////////////////////////////////////////////// +template +INLINE T Max2 (const T _a, const T _b) { return (_a>_b)?_a:_b; } + +template +INLINE T Max3 (const T _a, const T _b, const T _c) { return Max2(Max2(_a,_b),_c); } + +/////////////////////////////////////////////////////////////////////////// +#endif //FIXED_H diff --git a/plugins/gpu_unai/gpu_inner.h b/plugins/gpu_unai/gpu_inner.h new file mode 100644 index 00000000..6c18c639 --- /dev/null +++ b/plugins/gpu_unai/gpu_inner.h @@ -0,0 +1,427 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +// Inner loop driver instanciation file + +/////////////////////////////////////////////////////////////////////////////// +// Option Masks +#define L ((CF>>0)&1) +#define B ((CF>>1)&1) +#define M ((CF>>2)&1) +#define BM ((CF>>3)&3) +#define TM ((CF>>5)&3) +#define G ((CF>>7)&1) + +#define AH ((CF>>7)&1) + +#define MB ((CF>>8)&1) + +#include "gpu_inner_blend.h" +#include "gpu_inner_light.h" + +/////////////////////////////////////////////////////////////////////////////// +// GPU Pixel opperations generator +template +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 +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 +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 +INLINE void gpuPolySpanFn(u16 *pDst, u32 count) +{ + if (!TM) + { + // NO TEXTURE + if (!G) + { + // NO GOURAUD + u16 data; + if (L) { u32 lCol=((u32)(b4<< 2)&(0x03ff)) | ((u32)(g4<<13)&(0x07ff<<10)) | ((u32)(r4<<24)&(0x07ff<<21)); gpuLightingRGB(data,lCol); } + else data=PixelData; + if ((!M)&&(!B)) + { + if (MB) { data = data | 0x8000; } + do { *pDst++ = data; } while (--count); + } + else if ((M)&&(!B)) + { + if (MB) { data = data | 0x8000; } + do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count); + } + else + { + u16 uSrc; + u16 uDst; + u32 uMsk; if (BM==0) uMsk=0x7BDE; + do + { + // masking + uDst = *pDst; + if(M) { if (uDst&0x8000) goto endtile; } + uSrc = data; + // blend + if (BM==0) gpuBlending00(uSrc, uDst); + if (BM==1) gpuBlending01(uSrc, uDst); + if (BM==2) gpuBlending02(uSrc, uDst); + if (BM==3) gpuBlending03(uSrc, uDst); + if (MB) { *pDst = uSrc | 0x8000; } + else { *pDst = uSrc; } + endtile: pDst++; + } + while (--count); + } + } + else + { + // GOURAUD + u16 uDst; + u16 uSrc; + u32 linc=lInc; + u32 lCol=((u32)(b4>>14)&(0x03ff)) | ((u32)(g4>>3)&(0x07ff<<10)) | ((u32)(r4<<8)&(0x07ff<<21)); + u32 uMsk; if ((B)&&(BM==0)) uMsk=0x7BDE; + do + { + // masking + if(M) { uDst = *pDst; if (uDst&0x8000) goto endgou; } + // blend + if(B) + { + // light + gpuLightingRGB(uSrc,lCol); + if(!M) { uDst = *pDst; } + if (BM==0) gpuBlending00(uSrc, uDst); + if (BM==1) gpuBlending01(uSrc, uDst); + if (BM==2) gpuBlending02(uSrc, uDst); + if (BM==3) gpuBlending03(uSrc, uDst); + } + else + { + // light + gpuLightingRGB(uSrc,lCol); + } + if (MB) { *pDst = uSrc | 0x8000; } + else { *pDst = uSrc; } + endgou: pDst++; lCol=(lCol+linc); + } + while (--count); + } + } + else + { + // TEXTURE + u16 uDst; + u16 uSrc; + u32 linc; if (L&&G) linc=lInc; + u32 tinc=tInc; + u32 tmsk=tMsk; + u32 tCor = ((u32)( u4<<7)&0x7fff0000) | ((u32)( v4>>9)&0x00007fff); tCor&= tmsk; + const u16* _TBA=TBA; + const u16* _CBA; if (TM!=3) _CBA=CBA; + u32 lCol; + if(L && !G) { lCol = ((u32)(b4<< 2)&(0x03ff)) | ((u32)(g4<<13)&(0x07ff<<10)) | ((u32)(r4<<24)&(0x07ff<<21)); } + else if(L && G) { lCol = ((u32)(b4>>14)&(0x03ff)) | ((u32)(g4>>3)&(0x07ff<<10)) | ((u32)(r4<<8)&(0x07ff<<21)); } + u32 uMsk; if ((B)&&(BM==0)) uMsk=0x7BDE; + do + { + // masking + if(M) { uDst = *pDst; if (uDst&0x8000) goto endpoly; } + // texture + if (TM==1) { u32 tu=(tCor>>23); u32 tv=(tCor<<4)&(0xff<<11); u8 rgb=((u8*)_TBA)[tv+(tu>>1)]; uSrc=_CBA[(rgb>>((tu&1)<<2))&0xf]; if(!uSrc) goto endpoly; } + if (TM==2) { uSrc = _CBA[(((u8*)_TBA)[(tCor>>23)+((tCor<<4)&(0xff<<11))])]; if(!uSrc) goto endpoly; } + if (TM==3) { uSrc = _TBA[(tCor>>23)+((tCor<<3)&(0xff<<10))]; if(!uSrc) goto endpoly; } + // blend + if(B) + { + if (uSrc&0x8000) + { + // light + if(L) gpuLightingTXT(uSrc, lCol); + if(!M) { uDst = *pDst; } + if (BM==0) gpuBlending00(uSrc, uDst); + if (BM==1) gpuBlending01(uSrc, uDst); + if (BM==2) gpuBlending02(uSrc, uDst); + if (BM==3) gpuBlending03(uSrc, uDst); + } + else + { + // light + if(L) gpuLightingTXT(uSrc, lCol); + } + } + else + { + // light + if(L) { gpuLightingTXT(uSrc, lCol); } else if(!MB) { uSrc&= 0x7fff; } + } + if (MB) { *pDst = uSrc | 0x8000; } + else { *pDst = uSrc; } + endpoly: pDst++; + tCor=(tCor+tinc)&tmsk; + if (L&&G) lCol=(lCol+linc); + } + while (--count); + } +} +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Polygon innerloops driver +typedef void (*PP)(u16 *pDst, u32 count); +const PP gpuPolySpanDrivers[512] = +{ + gpuPolySpanFn<0x00>,gpuPolySpanFn<0x01>,gpuPolySpanFn<0x02>,gpuPolySpanFn<0x03>, gpuPolySpanFn<0x04>,gpuPolySpanFn<0x05>,gpuPolySpanFn<0x06>,gpuPolySpanFn<0x07>, NULL,NULL,gpuPolySpanFn<0x0A>,gpuPolySpanFn<0x0B>, NULL,NULL,gpuPolySpanFn<0x0E>,gpuPolySpanFn<0x0F>, + NULL,NULL,gpuPolySpanFn<0x12>,gpuPolySpanFn<0x13>, NULL,NULL,gpuPolySpanFn<0x16>,gpuPolySpanFn<0x17>, NULL,NULL,gpuPolySpanFn<0x1A>,gpuPolySpanFn<0x1B>, NULL,NULL,gpuPolySpanFn<0x1E>,gpuPolySpanFn<0x1F>, + gpuPolySpanFn<0x20>,gpuPolySpanFn<0x21>,gpuPolySpanFn<0x22>,gpuPolySpanFn<0x23>, gpuPolySpanFn<0x24>,gpuPolySpanFn<0x25>,gpuPolySpanFn<0x26>,gpuPolySpanFn<0x27>, NULL,NULL,gpuPolySpanFn<0x2A>,gpuPolySpanFn<0x2B>, NULL,NULL,gpuPolySpanFn<0x2E>,gpuPolySpanFn<0x2F>, + NULL,NULL,gpuPolySpanFn<0x32>,gpuPolySpanFn<0x33>, NULL,NULL,gpuPolySpanFn<0x36>,gpuPolySpanFn<0x37>, NULL,NULL,gpuPolySpanFn<0x3A>,gpuPolySpanFn<0x3B>, NULL,NULL,gpuPolySpanFn<0x3E>,gpuPolySpanFn<0x3F>, + gpuPolySpanFn<0x40>,gpuPolySpanFn<0x41>,gpuPolySpanFn<0x42>,gpuPolySpanFn<0x43>, gpuPolySpanFn<0x44>,gpuPolySpanFn<0x45>,gpuPolySpanFn<0x46>,gpuPolySpanFn<0x47>, NULL,NULL,gpuPolySpanFn<0x4A>,gpuPolySpanFn<0x4B>, NULL,NULL,gpuPolySpanFn<0x4E>,gpuPolySpanFn<0x4F>, + NULL,NULL,gpuPolySpanFn<0x52>,gpuPolySpanFn<0x53>, NULL,NULL,gpuPolySpanFn<0x56>,gpuPolySpanFn<0x57>, NULL,NULL,gpuPolySpanFn<0x5A>,gpuPolySpanFn<0x5B>, NULL,NULL,gpuPolySpanFn<0x5E>,gpuPolySpanFn<0x5F>, + gpuPolySpanFn<0x60>,gpuPolySpanFn<0x61>,gpuPolySpanFn<0x62>,gpuPolySpanFn<0x63>, gpuPolySpanFn<0x64>,gpuPolySpanFn<0x65>,gpuPolySpanFn<0x66>,gpuPolySpanFn<0x67>, NULL,NULL,gpuPolySpanFn<0x6A>,gpuPolySpanFn<0x6B>, NULL,NULL,gpuPolySpanFn<0x6E>,gpuPolySpanFn<0x6F>, + NULL,NULL,gpuPolySpanFn<0x72>,gpuPolySpanFn<0x73>, NULL,NULL,gpuPolySpanFn<0x76>,gpuPolySpanFn<0x77>, NULL,NULL,gpuPolySpanFn<0x7A>,gpuPolySpanFn<0x7B>, NULL,NULL,gpuPolySpanFn<0x7E>,gpuPolySpanFn<0x7F>, + + NULL,gpuPolySpanFn<0x81>,NULL,gpuPolySpanFn<0x83>, NULL,gpuPolySpanFn<0x85>,NULL,gpuPolySpanFn<0x87>, NULL,NULL,NULL,gpuPolySpanFn<0x8B>, NULL,NULL,NULL,gpuPolySpanFn<0x8F>, + NULL,NULL,NULL,gpuPolySpanFn<0x93>, NULL,NULL,NULL,gpuPolySpanFn<0x97>, NULL,NULL,NULL,gpuPolySpanFn<0x9B>, NULL,NULL,NULL,gpuPolySpanFn<0x9F>, + NULL,gpuPolySpanFn<0xa1>,NULL,gpuPolySpanFn<0xa3>, NULL,gpuPolySpanFn<0xa5>,NULL,gpuPolySpanFn<0xa7>, NULL,NULL,NULL,gpuPolySpanFn<0xaB>, NULL,NULL,NULL,gpuPolySpanFn<0xaF>, + NULL,NULL,NULL,gpuPolySpanFn<0xb3>, NULL,NULL,NULL,gpuPolySpanFn<0xb7>, NULL,NULL,NULL,gpuPolySpanFn<0xbB>, NULL,NULL,NULL,gpuPolySpanFn<0xbF>, + NULL,gpuPolySpanFn<0xc1>,NULL,gpuPolySpanFn<0xc3>, NULL,gpuPolySpanFn<0xc5>,NULL,gpuPolySpanFn<0xc7>, NULL,NULL,NULL,gpuPolySpanFn<0xcB>, NULL,NULL,NULL,gpuPolySpanFn<0xcF>, + NULL,NULL,NULL,gpuPolySpanFn<0xd3>, NULL,NULL,NULL,gpuPolySpanFn<0xd7>, NULL,NULL,NULL,gpuPolySpanFn<0xdB>, NULL,NULL,NULL,gpuPolySpanFn<0xdF>, + NULL,gpuPolySpanFn<0xe1>,NULL,gpuPolySpanFn<0xe3>, NULL,gpuPolySpanFn<0xe5>,NULL,gpuPolySpanFn<0xe7>, NULL,NULL,NULL,gpuPolySpanFn<0xeB>, NULL,NULL,NULL,gpuPolySpanFn<0xeF>, + NULL,NULL,NULL,gpuPolySpanFn<0xf3>, NULL,NULL,NULL,gpuPolySpanFn<0xf7>, NULL,NULL,NULL,gpuPolySpanFn<0xfB>, NULL,NULL,NULL,gpuPolySpanFn<0xfF>, + + gpuPolySpanFn<0x100>,gpuPolySpanFn<0x101>,gpuPolySpanFn<0x102>,gpuPolySpanFn<0x103>, gpuPolySpanFn<0x104>,gpuPolySpanFn<0x105>,gpuPolySpanFn<0x106>,gpuPolySpanFn<0x107>, NULL,NULL,gpuPolySpanFn<0x10A>,gpuPolySpanFn<0x10B>, NULL,NULL,gpuPolySpanFn<0x10E>,gpuPolySpanFn<0x10F>, + NULL,NULL,gpuPolySpanFn<0x112>,gpuPolySpanFn<0x113>, NULL,NULL,gpuPolySpanFn<0x116>,gpuPolySpanFn<0x117>, NULL,NULL,gpuPolySpanFn<0x11A>,gpuPolySpanFn<0x11B>, NULL,NULL,gpuPolySpanFn<0x11E>,gpuPolySpanFn<0x11F>, + gpuPolySpanFn<0x120>,gpuPolySpanFn<0x121>,gpuPolySpanFn<0x122>,gpuPolySpanFn<0x123>, gpuPolySpanFn<0x124>,gpuPolySpanFn<0x125>,gpuPolySpanFn<0x126>,gpuPolySpanFn<0x127>, NULL,NULL,gpuPolySpanFn<0x12A>,gpuPolySpanFn<0x12B>, NULL,NULL,gpuPolySpanFn<0x12E>,gpuPolySpanFn<0x12F>, + NULL,NULL,gpuPolySpanFn<0x132>,gpuPolySpanFn<0x133>, NULL,NULL,gpuPolySpanFn<0x136>,gpuPolySpanFn<0x137>, NULL,NULL,gpuPolySpanFn<0x13A>,gpuPolySpanFn<0x13B>, NULL,NULL,gpuPolySpanFn<0x13E>,gpuPolySpanFn<0x13F>, + gpuPolySpanFn<0x140>,gpuPolySpanFn<0x141>,gpuPolySpanFn<0x142>,gpuPolySpanFn<0x143>, gpuPolySpanFn<0x144>,gpuPolySpanFn<0x145>,gpuPolySpanFn<0x146>,gpuPolySpanFn<0x147>, NULL,NULL,gpuPolySpanFn<0x14A>,gpuPolySpanFn<0x14B>, NULL,NULL,gpuPolySpanFn<0x14E>,gpuPolySpanFn<0x14F>, + NULL,NULL,gpuPolySpanFn<0x152>,gpuPolySpanFn<0x153>, NULL,NULL,gpuPolySpanFn<0x156>,gpuPolySpanFn<0x157>, NULL,NULL,gpuPolySpanFn<0x15A>,gpuPolySpanFn<0x15B>, NULL,NULL,gpuPolySpanFn<0x15E>,gpuPolySpanFn<0x15F>, + gpuPolySpanFn<0x160>,gpuPolySpanFn<0x161>,gpuPolySpanFn<0x162>,gpuPolySpanFn<0x163>, gpuPolySpanFn<0x164>,gpuPolySpanFn<0x165>,gpuPolySpanFn<0x166>,gpuPolySpanFn<0x167>, NULL,NULL,gpuPolySpanFn<0x16A>,gpuPolySpanFn<0x16B>, NULL,NULL,gpuPolySpanFn<0x16E>,gpuPolySpanFn<0x16F>, + NULL,NULL,gpuPolySpanFn<0x172>,gpuPolySpanFn<0x173>, NULL,NULL,gpuPolySpanFn<0x176>,gpuPolySpanFn<0x177>, NULL,NULL,gpuPolySpanFn<0x17A>,gpuPolySpanFn<0x17B>, NULL,NULL,gpuPolySpanFn<0x17E>,gpuPolySpanFn<0x17F>, + + NULL,gpuPolySpanFn<0x181>,NULL,gpuPolySpanFn<0x183>, NULL,gpuPolySpanFn<0x185>,NULL,gpuPolySpanFn<0x187>, NULL,NULL,NULL,gpuPolySpanFn<0x18B>, NULL,NULL,NULL,gpuPolySpanFn<0x18F>, + NULL,NULL,NULL,gpuPolySpanFn<0x193>, NULL,NULL,NULL,gpuPolySpanFn<0x197>, NULL,NULL,NULL,gpuPolySpanFn<0x19B>, NULL,NULL,NULL,gpuPolySpanFn<0x19F>, + NULL,gpuPolySpanFn<0x1a1>,NULL,gpuPolySpanFn<0x1a3>, NULL,gpuPolySpanFn<0x1a5>,NULL,gpuPolySpanFn<0x1a7>, NULL,NULL,NULL,gpuPolySpanFn<0x1aB>, NULL,NULL,NULL,gpuPolySpanFn<0x1aF>, + NULL,NULL,NULL,gpuPolySpanFn<0x1b3>, NULL,NULL,NULL,gpuPolySpanFn<0x1b7>, NULL,NULL,NULL,gpuPolySpanFn<0x1bB>, NULL,NULL,NULL,gpuPolySpanFn<0x1bF>, + NULL,gpuPolySpanFn<0x1c1>,NULL,gpuPolySpanFn<0x1c3>, NULL,gpuPolySpanFn<0x1c5>,NULL,gpuPolySpanFn<0x1c7>, NULL,NULL,NULL,gpuPolySpanFn<0x1cB>, NULL,NULL,NULL,gpuPolySpanFn<0x1cF>, + NULL,NULL,NULL,gpuPolySpanFn<0x1d3>, NULL,NULL,NULL,gpuPolySpanFn<0x1d7>, NULL,NULL,NULL,gpuPolySpanFn<0x1dB>, NULL,NULL,NULL,gpuPolySpanFn<0x1dF>, + NULL,gpuPolySpanFn<0x1e1>,NULL,gpuPolySpanFn<0x1e3>, NULL,gpuPolySpanFn<0x1e5>,NULL,gpuPolySpanFn<0x1e7>, NULL,NULL,NULL,gpuPolySpanFn<0x1eB>, NULL,NULL,NULL,gpuPolySpanFn<0x1eF>, + NULL,NULL,NULL,gpuPolySpanFn<0x1f3>, NULL,NULL,NULL,gpuPolySpanFn<0x1f7>, NULL,NULL,NULL,gpuPolySpanFn<0x1fB>, NULL,NULL,NULL,gpuPolySpanFn<0x1fF> +}; diff --git a/plugins/gpu_unai/gpu_inner_blend.h b/plugins/gpu_unai/gpu_inner_blend.h new file mode 100644 index 00000000..20977eac --- /dev/null +++ b/plugins/gpu_unai/gpu_inner_blend.h @@ -0,0 +1,141 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +#ifndef _OP_BLEND_H_ +#define _OP_BLEND_H_ + +// GPU Blending operations functions + +#ifdef __arm__ +#define gpuBlending00(uSrc,uDst) \ +{ \ + asm ("and %[src], %[src], %[msk] " : [src] "=r" (uSrc) : "0" (uSrc), [msk] "r" (uMsk) ); \ + asm ("and %[dst], %[dst], %[msk] " : [dst] "=r" (uDst) : "0" (uDst), [msk] "r" (uMsk) ); \ + asm ("add %[src], %[dst], %[src] " : [src] "=r" (uSrc) : [dst] "r" (uDst), "0" (uSrc) ); \ + asm ("mov %[src], %[src], lsr #1 " : [src] "=r" (uSrc) : "0" (uSrc) ); \ +} +#else +#define gpuBlending00(uSrc,uDst) \ +{ \ + uSrc = (((uDst & uMsk) + (uSrc & uMsk)) >> 1); \ +} +#endif + +// 1.0 x Back + 1.0 x Forward +#ifdef __arm__ +#define gpuBlending01(uSrc,uDst) \ +{ \ + u16 st,dt,out; \ + asm ("and %[dt], %[dst], #0x7C00 " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x7C00 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("add %[out], %[dt], %[st] " : [out] "=r" (out) : [dt] "r" (dt), [st] "r" (st) ); \ + asm ("cmp %[out], #0x7C00 " : : [out] "r" (out) : "cc" ); \ + asm ("movhi %[out], #0x7C00 " : [out] "=r" (out) : "0" (out) ); \ + asm ("and %[dt], %[dst], #0x03E0 " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x03E0 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("add %[dt], %[dt], %[st] " : [dt] "=r" (dt) : "0" (dt), [st] "r" (st) ); \ + asm ("cmp %[dt], #0x03E0 " : : [dt] "r" (dt) : "cc" ); \ + asm ("movhi %[dt], #0x03E0 " : [dt] "=r" (dt) : "0" (dt) ); \ + asm ("orr %[out], %[out], %[dt] " : [out] "=r" (out) : "0" (out), [dt] "r" (dt) ); \ + asm ("and %[dt], %[dst], #0x001F " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x001F " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("add %[dt], %[dt], %[st] " : [dt] "=r" (dt) : "0" (dt), [st] "r" (st) ); \ + asm ("cmp %[dt], #0x001F " : : [dt] "r" (dt) : "cc" ); \ + asm ("movhi %[dt], #0x001F " : [dt] "=r" (dt) : "0" (dt) ); \ + asm ("orr %[uSrc], %[out], %[dt] " : [uSrc] "=r" (uSrc) : [out] "r" (out), [dt] "r" (dt) ); \ +} +#else +#define gpuBlending01(uSrc,uDst) \ +{ \ + u16 rr, gg, bb; \ + bb = (uDst & 0x7C00) + (uSrc & 0x7C00); if (bb > 0x7C00) bb = 0x7C00; \ + gg = (uDst & 0x03E0) + (uSrc & 0x03E0); if (gg > 0x03E0) gg = 0x03E0; bb |= gg; \ + rr = (uDst & 0x001F) + (uSrc & 0x001F); if (rr > 0x001F) rr = 0x001F; bb |= rr; \ + uSrc = bb; \ +} +#endif + +// 1.0 x Back - 1.0 x Forward */ +#ifdef __arm__ +#define gpuBlending02(uSrc,uDst) \ +{ \ + u16 st,dt,out; \ + asm ("and %[dt], %[dst], #0x7C00 " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x7C00 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("subs %[out], %[dt], %[st] " : [out] "=r" (out) : [dt] "r" (dt), [st] "r" (st) : "cc" ); \ + asm ("movmi %[out], #0x0000 " : [out] "=r" (out) : "0" (out) ); \ + asm ("and %[dt], %[dst], #0x03E0 " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x03E0 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("subs %[dt], %[dt], %[st] " : [dt] "=r" (dt) : "0" (dt), [st] "r" (st) : "cc" ); \ + asm ("orrpl %[out], %[out], %[dt] " : [out] "=r" (out) : "0" (out), [dt] "r" (dt) ); \ + asm ("and %[dt], %[dst], #0x001F " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x001F " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("subs %[dt], %[dt], %[st] " : [dt] "=r" (dt) : "0" (dt), [st] "r" (st) : "cc" ); \ + asm ("orrpl %[out], %[out], %[dt] " : [out] "=r" (out) : "0" (out), [dt] "r" (dt) ); \ + asm ("mov %[uSrc], %[out]" : [uSrc] "=r" (uSrc) : [out] "r" (out) ); \ +} +#else +#define gpuBlending02(uSrc,uDst) \ +{ \ + s32 rr, gg, bb; \ + bb = (uDst & 0x7C00) - (uSrc & 0x7C00); if (bb < 0) bb = 0; \ + gg = (uDst & 0x03E0) - (uSrc & 0x03E0); if (gg > 0) bb |= gg; \ + rr = (uDst & 0x001F) - (uSrc & 0x001F); if (rr > 0) bb |= rr; \ + uSrc = bb; \ +} +#endif + +// 1.0 x Back + 0.25 x Forward */ +#ifdef __arm__ +#define gpuBlending03(uSrc,uDst) \ +{ \ + u16 st,dt,out; \ + asm ("mov %[src], %[src], lsr #2 " : [src] "=r" (uSrc) : "0" (uSrc) ); \ + asm ("and %[dt], %[dst], #0x7C00 " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x1C00 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("add %[out], %[dt], %[st] " : [out] "=r" (out) : [dt] "r" (dt), [st] "r" (st) ); \ + asm ("cmp %[out], #0x7C00 " : : [out] "r" (out) : "cc" ); \ + asm ("movhi %[out], #0x7C00 " : [out] "=r" (out) : "0" (out) ); \ + asm ("and %[dt], %[dst], #0x03E0 " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x00E0 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("add %[dt], %[dt], %[st] " : [dt] "=r" (dt) : "0" (dt), [st] "r" (st) ); \ + asm ("cmp %[dt], #0x03E0 " : : [dt] "r" (dt) : "cc" ); \ + asm ("movhi %[dt], #0x03E0 " : [dt] "=r" (dt) : "0" (dt) ); \ + asm ("orr %[out], %[out], %[dt] " : [out] "=r" (out) : "0" (out), [dt] "r" (dt) ); \ + asm ("and %[dt], %[dst], #0x001F " : [dt] "=r" (dt) : [dst] "r" (uDst) ); \ + asm ("and %[st], %[src], #0x0007 " : [st] "=r" (st) : [src] "r" (uSrc) ); \ + asm ("add %[dt], %[dt], %[st] " : [dt] "=r" (dt) : "0" (dt), [st] "r" (st) ); \ + asm ("cmp %[dt], #0x001F " : : [dt] "r" (dt) : "cc" ); \ + asm ("movhi %[dt], #0x001F " : [dt] "=r" (dt) : "0" (dt) ); \ + asm ("orr %[uSrc], %[out], %[dt] " : [uSrc] "=r" (uSrc) : [out] "r" (out), [dt] "r" (dt) ); \ +} +#else +#define gpuBlending03(uSrc,uDst) \ +{ \ + u16 rr, gg, bb; \ + uSrc >>= 2; \ + bb = (uDst & 0x7C00) + (uSrc & 0x1C00); if (bb > 0x7C00) bb = 0x7C00; \ + gg = (uDst & 0x03E0) + (uSrc & 0x00E0); if (gg > 0x03E0) gg = 0x03E0; bb |= gg; \ + rr = (uDst & 0x001F) + (uSrc & 0x0007); if (rr > 0x001F) rr = 0x001F; bb |= rr; \ + uSrc = bb; \ +} +#endif + +#endif //_OP_BLEND_H_ diff --git a/plugins/gpu_unai/gpu_inner_light.h b/plugins/gpu_unai/gpu_inner_light.h new file mode 100644 index 00000000..b9e48bc7 --- /dev/null +++ b/plugins/gpu_unai/gpu_inner_light.h @@ -0,0 +1,80 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +#ifndef _OP_LIGHT_H_ +#define _OP_LIGHT_H_ + +// GPU color operations for lighting calculations + +#ifdef __arm__ +#define gpuLightingRGB(uSrc,lCol) \ +{ \ + u32 cb,cg; \ + asm ("and %[cb], %[lCol], #0x7C00/32 " : [cb] "=r" (cb) : [lCol] "r" (lCol) ); \ + asm ("and %[cg], %[lCol], #0x03E0*2048 " : [cg] "=r" (cg) : [lCol] "r" (lCol) ); \ + asm ("mov %[res], %[lCol], lsr #27 " : [res] "=r" (uSrc) : [lCol] "r" (lCol) ); \ + asm ("orr %[res], %[res], %[cb], lsl #5 " : [res] "=r" (uSrc) : "0" (uSrc), [cb] "r" (cb) ); \ + asm ("orr %[res], %[res], %[cg], lsr #11 " : [res] "=r" (uSrc) : "0" (uSrc), [cg] "r" (cg) ); \ +} +#else +#define gpuLightingRGB(uSrc,lCol) uSrc=((lCol<<5)&0x7C00) | ((lCol>>11)&0x3E0) | (lCol>>27) +#endif + +INLINE void gpuLightingTXT(u16 &uSrc, u32 &lCol) +{ + // Pixelops Table + static const u8 _gpuLitT[32*32] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, + 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, + 0, 0, 0, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,11,11, + 0, 0, 0, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9,10,10,10,11,11,12,12,13,13, + 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15, + 0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 9, 9,10,10,11,11,12,12,13,14,14,15,15,16,16,17, + 0, 0, 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 7, 8, 8, 9,10,10,11,11,12,13,13,14,15,15,16,16,17,18,18,19, + 0, 0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,19,20,21, + 0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9,10,11,12,12,13,14,15,15,16,17,18,18,19,20,21,21,22,23, + 0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 8, 9,10,11,12,13,13,14,15,16,17,17,18,19,20,21,21,22,23,24,25, + 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9,10,11,12,13,14,14,15,16,17,18,19,20,21,21,22,23,24,25,26,27, + 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,31, + 0, 1, 2, 3, 4, 5, 6, 7, 9,10,11,12,13,14,15,16,18,19,20,21,22,23,24,25,27,28,29,30,31,31,31,31, + 0, 1, 2, 3, 4, 5, 7, 8, 9,10,11,13,14,15,16,17,19,20,21,22,23,24,26,27,28,29,30,31,31,31,31,31, + 0, 1, 2, 3, 5, 6, 7, 8,10,11,12,13,15,16,17,18,20,21,22,23,25,26,27,28,30,31,31,31,31,31,31,31, + 0, 1, 2, 3, 5, 6, 7, 9,10,11,13,14,15,17,18,19,21,22,23,24,26,27,28,30,31,31,31,31,31,31,31,31, + 0, 1, 2, 4, 5, 6, 8, 9,11,12,13,15,16,17,19,20,22,23,24,26,27,28,30,31,31,31,31,31,31,31,31,31, + 0, 1, 2, 4, 5, 7, 8,10,11,12,14,15,17,18,20,21,23,24,25,27,28,30,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 4, 6, 7, 9,10,12,13,15,16,18,19,21,22,24,25,27,28,30,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 4, 6, 7, 9,10,12,14,15,17,18,20,21,23,25,26,28,29,31,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 4, 6, 8, 9,11,13,14,16,17,19,21,22,24,26,27,29,30,31,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 5, 6, 8,10,11,13,15,16,18,20,21,23,25,27,28,30,31,31,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 5, 7, 8,10,12,14,15,17,19,21,22,24,26,28,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 5, 7, 9,10,12,14,16,18,19,21,23,25,27,29,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 5, 7, 9,11,13,15,16,18,20,22,24,26,28,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31, + 0, 1, 3, 5, 7, 9,11,13,15,17,19,21,23,25,27,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31 + }; + uSrc = (_gpuLitT[((uSrc&0x7C00)>>5)|((lCol>>5)&0x1f)]<<10)|(_gpuLitT[(uSrc&0x03E0)|((lCol>>16)&0x1f)]<<5)|(_gpuLitT[((uSrc&0x001F)<<5)|(lCol>>27)]); +} + +#endif //_OP_LIGHT_H_ diff --git a/plugins/gpu_unai/gpu_raster_image.h b/plugins/gpu_unai/gpu_raster_image.h new file mode 100644 index 00000000..7984b18d --- /dev/null +++ b/plugins/gpu_unai/gpu_raster_image.h @@ -0,0 +1,203 @@ +/*************************************************************************** + * Copyright (C) 2010 PCSX4ALL Team * + * Copyright (C) 2010 Unai * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * + ***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +INLINE void gpuLoadImage(void) +{ + u16 x0, y0, w0, h0; + x0 = PacketBuffer.U2[2] & 1023; + y0 = PacketBuffer.U2[3] & 511; + w0 = PacketBuffer.U2[4]; + h0 = PacketBuffer.U2[5]; + + if ((y0 + h0) > FRAME_HEIGHT) + { + h0 = FRAME_HEIGHT - y0; + } + + FrameToWrite = ((w0)&&(h0)); + + px = 0; + py = 0; + x_end = w0; + y_end = h0; + pvram = &((u16*)GPU_FrameBuffer)[x0+(y0*1024)]; + + GPU_GP1 |= 0x08000000; +} + +/////////////////////////////////////////////////////////////////////////////// +INLINE void gpuStoreImage(void) +{ + u16 x0, y0, w0, h0; + x0 = PacketBuffer.U2[2] & 1023; + y0 = PacketBuffer.U2[3] & 511; + w0 = PacketBuffer.U2[4]; + h0 = PacketBuffer.U2[5]; + + if ((y0 + h0) > FRAME_HEIGHT) + { + h0 = FRAME_HEIGHT - y0; + } + FrameToRead = ((w0)&&(h0)); + + px = 0; + py = 0; + x_end = w0; + y_end = h0; + pvram = &((u16*)GPU_FrameBuffer)[x0+(y0*1024)]; + + GPU_GP1 |= 0x08000000; +} + +INLINE void gpuMoveImage(void) +{ + u32 x0, y0, x1, y1; + s32 w0, h0; + x0 = PacketBuffer.U2[2] & 1023; + y0 = PacketBuffer.U2[3] & 511; + x1 = PacketBuffer.U2[4] & 1023; + y1 = PacketBuffer.U2[5] & 511; + w0 = PacketBuffer.U2[6]; + h0 = PacketBuffer.U2[7]; + + if( (x0==x1) && (y0==y1) ) return; + if ((w0<=0) || (h0<=0)) return; + + if (((y0+h0)>512)||((x0+w0)>1024)||((y1+h0)>512)||((x1+w0)>1024)) + { + u16 *psxVuw=GPU_FrameBuffer; + u32 i,j; + for(j=0;j>1); + lpDst += ((FRAME_OFFSET(x1, y1))>>1); + if (w0&1) + { + x1 = (FRAME_WIDTH - w0 +1)>>1; + w0>>=1; + if (!w0) { + do { + *((u16*)lpDst) = *((u16*)lpSrc); + lpDst += x1; + lpSrc += x1; + } while (--h0); + } else + do { + x0=w0; + do { *lpDst++ = *lpSrc++; } while (--x0); + *((u16*)lpDst) = *((u16*)lpSrc); + lpDst += x1; + lpSrc += x1; + } while (--h0); + } + else + { + x1 = (FRAME_WIDTH - w0)>>1; + w0>>=1; + do { + x0=w0; + do { *lpDst++ = *lpSrc++; } while (--x0); + lpDst += x1; + lpSrc += x1; + } while (--h0); + } + } +} + +INLINE void gpuClearImage(void) +{ + s32 x0, y0, w0, h0; + x0 = PacketBuffer.S2[2]; + y0 = PacketBuffer.S2[3]; + w0 = PacketBuffer.S2[4] & 0x3ff; + h0 = PacketBuffer.S2[5] & 0x3ff; + + w0 += x0; + if (x0 < 0) x0 = 0; + if (w0 > FRAME_WIDTH) w0 = FRAME_WIDTH; + w0 -= x0; + if (w0 <= 0) return; + h0 += y0; + if (y0 < 0) y0 = 0; + if (h0 > FRAME_HEIGHT) h0 = FRAME_HEIGHT; + h0 -= y0; + if (h0 <= 0) return; + + if (x0&1) + { + u16* pixel = (u16*)GPU_FrameBuffer + FRAME_OFFSET(x0, y0); + u16 rgb = GPU_RGB16(PacketBuffer.S4[0]); + y0 = FRAME_WIDTH - w0; + do { + x0=w0; + do { *pixel++ = rgb; } while (--x0); + pixel += y0; + } while (--h0); + } + else + { + u32* pixel = (u32*)(void*)GPU_FrameBuffer + ((FRAME_OFFSET(x0, y0))>>1); + u32 rgb = GPU_RGB16(PacketBuffer.S4[0]); + rgb |= (rgb<<16); + if (w0&1) + { + y0 = (FRAME_WIDTH - w0 +1)>>1; + w0>>=1; + do { + x0=w0; + do { *pixel++ = rgb; } while (--x0); + *((u16*)pixel) = (u16)rgb; + pixel += y0; + } while (--h0); + } + else + { + y0 = (FRAME_WIDTH - w0)>>1; + w0>>=1; + do { + x0=w0; + do { *pixel++ = rgb; } while (--x0); + pixel += y0; + } while (--h0); + } + } +} diff --git a/plugins/gpu_unai/gpu_raster_line.h b/plugins/gpu_unai/gpu_raster_line.h new file mode 100644 index 00000000..6d66c7d1 --- /dev/null +++ b/plugins/gpu_unai/gpu_raster_line.h @@ -0,0 +1,255 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal line drawing functions + +#define GPU_DIGITS 16 +#define GPU_DIGITSC (GPU_DIGITS+3) + +INLINE long GPU_DIV(long rs, long rt) +{ + return rt ? (rs / rt) : (0); +} + +/////////////////////////////////////////////////////////////////////////////// +void gpuDrawLF(const PD gpuPixelDriver) +{ + s32 temp; + s32 xmin, xmax; + s32 ymin, ymax; + s32 x0, x1, dx; + s32 y0, y1, dy; + + x0 = PacketBuffer.S2[2] + DrawingOffset[0]; GPU_TESTRANGE(x0); + y0 = PacketBuffer.S2[3] + DrawingOffset[1]; GPU_TESTRANGE(y0); + x1 = PacketBuffer.S2[4] + DrawingOffset[0]; GPU_TESTRANGE(x1); + y1 = PacketBuffer.S2[5] + DrawingOffset[1]; GPU_TESTRANGE(y1); + + xmin = DrawingArea[0]; xmax = DrawingArea[2]; + ymin = DrawingArea[1]; ymax = DrawingArea[3]; + const u16 pixeldata = GPU_RGB16(PacketBuffer.U4[0]); + + dy = (y1 - y0); + if (dy < 0) dy = -dy; + dx = (x1 - x0); + if (dx < 0) dx = -dx; + if (dx > dy) { + if (x0 > x1) { + GPU_SWAP(x0, x1, temp); + GPU_SWAP(y0, y1, temp); + } + y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx); + y0 <<= GPU_DIGITS; + temp = xmin - x0; + if (temp > 0) { + x0 = xmin; + y0 += (y1 * temp); + } + if (x1 > xmax) x1 = xmax; + x1 -= x0; + if (x1 < 0) x1 = 0; + + const int li=linesInterlace; + for (; x1; x1--) { + temp = y0 >> GPU_DIGITS; + if( 0 == (temp&li) ) { + if ((u32) (temp - ymin) < (u32) (ymax - ymin)) { + gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, temp)],pixeldata); + } + } + x0++; + y0 += y1; + } + } else if (dy) { + if (y0 > y1) { + GPU_SWAP(x0, x1, temp); + GPU_SWAP(y0, y1, temp); + } + x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy); + x0 <<= GPU_DIGITS; + temp = ymin - y0; + if (temp > 0) { + y0 = ymin; + x0 += (x1 * temp); + } + if (y1 > ymax) y1 = ymax; + y1 -= y0; + if (y1 < 0) y1 = 0; + + const int li=linesInterlace; + for (; y1; y1--) { + if( 0 == (y0&li) ) { + temp = x0 >> GPU_DIGITS; + if ((u32) (temp - xmin) < (u32) (xmax - xmin)) { + gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(temp, y0)],pixeldata); + } + } + y0++; + x0 += x1; + } + + } else { + if( 0 == (y0&linesInterlace) ) { + if ((u32) (x0 - xmin) < (u32) (xmax - xmin)) { + if ((u32) (y0 - ymin) < (u32) (ymax - ymin)) { + gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)],pixeldata); + } + } + } + } +} + +/*---------------------------------------------------------------------- +GF +----------------------------------------------------------------------*/ + +/////////////////////////////////////////////////////////////////////////////// +void gpuDrawLG(const PD gpuPixelDriver) +{ + s32 temp; + s32 xmin, xmax; + s32 ymin, ymax; + s32 x0, x1, dx; + s32 y0, y1, dy; + s32 r0, r1; + s32 g0, g1; + s32 b0, b1; + + x0 = PacketBuffer.S2[2] + DrawingOffset[0]; GPU_TESTRANGE(x0); + y0 = PacketBuffer.S2[3] + DrawingOffset[1]; GPU_TESTRANGE(y0); + x1 = PacketBuffer.S2[6] + DrawingOffset[0]; GPU_TESTRANGE(x1); + y1 = PacketBuffer.S2[7] + DrawingOffset[1]; GPU_TESTRANGE(y1); + + r0 = PacketBuffer.U1[0]; g0 = PacketBuffer.U1[1]; b0 = PacketBuffer.U1[2]; + r1 = PacketBuffer.U1[8]; g1 = PacketBuffer.U1[9]; b1 = PacketBuffer.U1[10]; + + xmin = DrawingArea[0]; xmax = DrawingArea[2]; + ymin = DrawingArea[1]; ymax = DrawingArea[3]; + + dy = (y1 - y0); + if (dy < 0) + dy = -dy; + dx = (x1 - x0); + if (dx < 0) + dx = -dx; + if (dx > dy) { + if (x0 > x1) { + GPU_SWAP(x0, x1, temp); + GPU_SWAP(y0, y1, temp); + GPU_SWAP(r0, r1, temp); + GPU_SWAP(g0, g1, temp); + GPU_SWAP(b0, b1, temp); + } + y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx); + r1 = GPU_DIV((r1 - r0) << GPU_DIGITS, dx); + g1 = GPU_DIV((g1 - g0) << GPU_DIGITS, dx); + b1 = GPU_DIV((b1 - b0) << GPU_DIGITS, dx); + y0 <<= GPU_DIGITS; + r0 <<= GPU_DIGITS; + g0 <<= GPU_DIGITS; + b0 <<= GPU_DIGITS; + temp = xmin - x0; + if (temp > 0) { + x0 = xmin; + y0 += (y1 * temp); + r0 += (r1 * temp); + g0 += (g1 * temp); + b0 += (b1 * temp); + } + if (x1 > xmax) x1 = xmax; + x1 -= x0; + if (x1 < 0) x1 = 0; + + const int li=linesInterlace; + for (; x1; x1--) { + temp = y0 >> GPU_DIGITS; + if( 0 == (temp&li) ) { + if ((u32) (temp - ymin) < (u32) (ymax - ymin)) { + gpuPixelDriver ( + &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, temp)], + (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F) + ); + } + } + x0++; + y0 += y1; + r0 += r1; + g0 += g1; + b0 += b1; + } + } else if (dy) { + if (y0 > y1) { + GPU_SWAP(x0, x1, temp); + GPU_SWAP(y0, y1, temp); + GPU_SWAP(r0, r1, temp); + GPU_SWAP(g0, g1, temp); + GPU_SWAP(b0, b1, temp); + } + x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy); + r1 = GPU_DIV((r1 - r0) << GPU_DIGITS, dy); + g1 = GPU_DIV((g1 - g0) << GPU_DIGITS, dy); + b1 = GPU_DIV((b1 - b0) << GPU_DIGITS, dy); + x0 <<= GPU_DIGITS; + r0 <<= GPU_DIGITS; + g0 <<= GPU_DIGITS; + b0 <<= GPU_DIGITS; + temp = ymin - y0; + if (temp > 0) { + y0 = ymin; + x0 += (x1 * temp); + r0 += (r1 * temp); + g0 += (g1 * temp); + b0 += (b1 * temp); + } + if (y1 > ymax) y1 = ymax; + y1 -= y0; + if (y1 < 0) y1 = 0; + + const int li=linesInterlace; + for (; y1; y1--) { + if( 0 == (y0&li) ) { + temp = x0 >> GPU_DIGITS; + if ((u32) (temp - xmin) < (u32) (xmax - xmin)) { + gpuPixelDriver ( + &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(temp, y0)], + (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F) + ); + } + } + y0++; + x0 += x1; + r0 += r1; + g0 += g1; + b0 += b1; + } + } else { + if( 0 == (y0&linesInterlace) ) { + if ((u32) (x0 - xmin) < (u32) (xmax - xmin)) { + if ((u32) (y0 - ymin) < (u32) (ymax - ymin)) { + gpuPixelDriver ( + &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)], + (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F) + ); + } + } + } + } +} diff --git a/plugins/gpu_unai/gpu_raster_polygon.h b/plugins/gpu_unai/gpu_raster_polygon.h new file mode 100644 index 00000000..5d370f88 --- /dev/null +++ b/plugins/gpu_unai/gpu_raster_polygon.h @@ -0,0 +1,837 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal polygon drawing functions + +/////////////////////////////////////////////////////////////////////////////// +void gpuDrawF3(const PP gpuPolySpanDriver) +{ + const int li=linesInterlace; + s32 temp; + s32 xa, xb, xmin, xmax; + s32 ya, yb, ymin, ymax; + s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx; + s32 y0, y1, y2; + + x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2]); GPU_TESTRANGE(x0); + y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3]); GPU_TESTRANGE(y0); + x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[4]); GPU_TESTRANGE(x1); + y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[5]); GPU_TESTRANGE(y1); + x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6]); GPU_TESTRANGE(x2); + y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7]); GPU_TESTRANGE(y2); + + x0 += DrawingOffset[0]; x1 += DrawingOffset[0]; x2 += DrawingOffset[0]; + y0 += DrawingOffset[1]; y1 += DrawingOffset[1]; y2 += DrawingOffset[1]; + + xmin = DrawingArea[0]; xmax = DrawingArea[2]; + ymin = DrawingArea[1]; ymax = DrawingArea[3]; + + { + int rx0 = Max2(xmin,Min3(x0,x1,x2)); + int ry0 = Max2(ymin,Min3(y0,y1,y2)); + int rx1 = Min2(xmax,Max3(x0,x1,x2)); + int ry1 = Min2(ymax,Max3(y0,y1,y2)); + if( rx0>=rx1 || ry0>=ry1) return; + } + + PixelData = GPU_RGB16(PacketBuffer.U4[0]); + + if (y0 >= y1) + { + if( y0!=y1 || x0>x1 ) + { + GPU_SWAP(x0, x1, temp); + GPU_SWAP(y0, y1, temp); + } + } + if (y1 >= y2) + { + if( y1!=y2 || x1>x2 ) + { + GPU_SWAP(x1, x2, temp); + GPU_SWAP(y1, y2, temp); + } + } + if (y0 >= y1) + { + if( y0!=y1 || x0>x1 ) + { + GPU_SWAP(x0, x1, temp); + GPU_SWAP(y0, y1, temp); + } + } + + ya = y2 - y0; + yb = y2 - y1; + dx =(x2 - x1) * ya - (x2 - x0) * yb; + + for (s32 loop0 = 2; loop0; --loop0) + { + if (loop0 == 2) + { + ya = y0; + yb = y1; + x3 = i2x(x0); + x4 = y0!=y1 ? x3 : i2x(x1); + if (dx < 0) + { + dx3 = xLoDivx((x2 - x0), (y2 - y0)); + dx4 = xLoDivx((x1 - x0), (y1 - y0)); + } + else + { + dx3 = xLoDivx((x1 - x0), (y1 - y0)); + dx4 = xLoDivx((x2 - x0), (y2 - y0)); + } + } + else + { + ya = y1; + yb = y2; + if (dx < 0) + { + x4 = i2x(x1); + x3 = i2x(x0) + (dx3 * (y1 - y0)); + dx4 = xLoDivx((x2 - x1), (y2 - y1)); + } + else + { + x3 = i2x(x1); + x4 = i2x(x0) + (dx4 * (y1 - y0)); + dx3 = xLoDivx((x2 - x1), (y2 - y1)); + } + } + + temp = ymin - ya; + if (temp > 0) + { + ya = ymin; + x3 += dx3*temp; + x4 += dx4*temp; + } + if (yb > ymax) yb = ymax; + if (ya>=yb) continue; + + x3+= fixed_HALF; + x4+= fixed_HALF; + + u16* PixelBase = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)]; + + if (!progressInterlace) + { + for(;yaxmax) || (xb xmax) xb = xmax; + xb-=xa; + if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb); + } + } + else + { + bool flag=progressInterlace_flag; + for(;yaxmax) || (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(;yaxmax) || (xb 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(;yaxmax) || (xb 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(;yaxmax) || (xb 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(;yaxmax) || (xb 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(;yaxmax) || (xb 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(;yaxmax) || (xb 0) + { + xa = xmin; + u4 = u3 + du4*temp; v4 = v3 + dv4*temp; + r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp; + } + else + { + u4 = u3; v4 = v3; + r4 = r3; g4 = g3; b4 = b3; + } + if(xb > xmax) xb = xmax; + xb-=xa; + if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb); + } + } + } +} diff --git a/plugins/gpu_unai/gpu_raster_sprite.h b/plugins/gpu_unai/gpu_raster_sprite.h new file mode 100644 index 00000000..041fcbdc --- /dev/null +++ b/plugins/gpu_unai/gpu_raster_sprite.h @@ -0,0 +1,133 @@ +/*************************************************************************** +* Copyright (C) 2010 PCSX4ALL Team * +* Copyright (C) 2010 Unai * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * +***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +// GPU internal sprite drawing functions + +/////////////////////////////////////////////////////////////////////////////// +void gpuDrawS(const PS gpuSpriteSpanDriver) +{ + s32 x0, x1; + s32 y0, y1; + s32 u0; + s32 v0; + + x1 = x0 = GPU_EXPANDSIGN_SPRT(PacketBuffer.S2[2]) + DrawingOffset[0]; + y1 = y0 = GPU_EXPANDSIGN_SPRT(PacketBuffer.S2[3]) + DrawingOffset[1]; + x1+= PacketBuffer.S2[6]; + y1+= PacketBuffer.S2[7]; + + { + s32 xmin, xmax; + s32 ymin, ymax; + xmin = DrawingArea[0]; xmax = DrawingArea[2]; + ymin = DrawingArea[1]; ymax = DrawingArea[3]; + + { + int rx0 = Max2(xmin,Min2(x0,x1)); + int ry0 = Max2(ymin,Min2(y0,y1)); + int rx1 = Min2(xmax,Max2(x0,x1)); + int ry1 = Min2(ymax,Max2(y0,y1)); + if( rx0>=rx1 || ry0>=ry1) return; + } + + u0 = PacketBuffer.U1[8]; + v0 = PacketBuffer.U1[9]; + + r4 = s32(PacketBuffer.U1[0]); + g4 = s32(PacketBuffer.U1[1]); + b4 = s32(PacketBuffer.U1[2]); + + { + s32 temp; + temp = ymin - y0; + if (temp > 0) { y0 = ymin; v0 += temp; } + if (y1 > ymax) y1 = ymax; + if (y1 <= y0) return; + + temp = xmin - x0; + if (temp > 0) { x0 = xmin; u0 += temp; } + if (x1 > xmax) x1 = xmax; + x1 -= x0; + if (x1 <= 0) return; + } + } + + { + u16 *Pixel = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)]; + const int li=linesInterlace; + const u32 masku=TextureWindow[2]; + const u32 maskv=TextureWindow[3]; + + for (;y0=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