aboutsummaryrefslogtreecommitdiff
path: root/plugins/gpu_unai
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/gpu_unai')
-rw-r--r--plugins/gpu_unai/Makefile5
-rw-r--r--plugins/gpu_unai/README_senquack.txt956
-rw-r--r--plugins/gpu_unai/gpu.cpp1061
-rw-r--r--plugins/gpu_unai/gpu.h99
-rw-r--r--plugins/gpu_unai/gpu_blit.h24
-rw-r--r--plugins/gpu_unai/gpu_command.h667
-rw-r--r--plugins/gpu_unai/gpu_fixedpoint.h107
-rw-r--r--plugins/gpu_unai/gpu_inner.h914
-rw-r--r--plugins/gpu_unai/gpu_inner_blend.h268
-rw-r--r--plugins/gpu_unai/gpu_inner_blend_arm5.h100
-rw-r--r--plugins/gpu_unai/gpu_inner_blend_arm7.h107
-rw-r--r--plugins/gpu_unai/gpu_inner_light.h293
-rw-r--r--plugins/gpu_unai/gpu_inner_quantization.h108
-rw-r--r--plugins/gpu_unai/gpu_raster_image.h98
-rw-r--r--plugins/gpu_unai/gpu_raster_line.h874
-rw-r--r--plugins/gpu_unai/gpu_raster_polygon.h1997
-rw-r--r--plugins/gpu_unai/gpu_raster_sprite.h219
-rw-r--r--plugins/gpu_unai/gpu_unai.h318
-rw-r--r--plugins/gpu_unai/gpulib_if.cpp708
19 files changed, 6158 insertions, 2765 deletions
diff --git a/plugins/gpu_unai/Makefile b/plugins/gpu_unai/Makefile
index 1075ee5..756d19a 100644
--- a/plugins/gpu_unai/Makefile
+++ b/plugins/gpu_unai/Makefile
@@ -1,6 +1,9 @@
CFLAGS += -ggdb -Wall -O3 -ffast-math
CFLAGS += -DREARMED
CFLAGS += -I../../include
+#CFLAGS += -DINLINE="static __inline__"
+#CFLAGS += -Dasm="__asm__ __volatile__"
+CFLAGS += -DUSE_GPULIB=1
include ../../config.mak
@@ -8,7 +11,7 @@ SRC_STANDALONE += gpu.cpp
SRC_GPULIB += gpulib_if.cpp
ifeq "$(ARCH)" "arm"
-SRC += gpu_arm.s
+SRC += gpu_arm.S
endif
#BIN_STANDALONE = gpuPCSX4ALL.so
diff --git a/plugins/gpu_unai/README_senquack.txt b/plugins/gpu_unai/README_senquack.txt
new file mode 100644
index 0000000..cda17fc
--- /dev/null
+++ b/plugins/gpu_unai/README_senquack.txt
@@ -0,0 +1,956 @@
+//NOTE: You can find the set of original Unai poly routines (disabled now)
+// at the bottom end of this file.
+
+//senquack - Original Unai GPU poly routines have been replaced with new
+// ones based on DrHell routines. The original routines suffered from
+// shifted rows, causing many quads to have their first triangle drawn
+// correctly, but the second triangle would randomly have pixels shifted
+// either left or right or entire rows not drawn at all. Furthermore,
+// some times entire triangles seemed to be either missing or only
+// partially drawn (most clearly seen in sky/road textures in NFS3,
+// clock tower in beginning of Castlevania SOTN). Pixel gaps were
+// prevalent.
+//
+// Since DrHell GPU didn't seem to exhibit these artifacts at all, I adapted
+// its routines to GPU Unai (Unai was probably already originally based on it).
+// DrHell uses 22.10 fixed point instead of Unai's 16.16, so gpu_fixedpoint.h
+// required modification as well as gpu_inner.h (where gpuPolySpanFn driver
+// functions are).
+//
+// Originally, I tried to patch up original Unai routines and got as far
+// as fixing the shifted rows, but still had other problem of triangles rendered
+// wrong (black triangular gaps in NFS3 sky, clock tower in Castlevania SOTN).
+// I eventually gave up. Even after rewriting/adapting the routines,
+// however, I still had some random pixel droupouts, specifically in
+// NFS3 sky texture. I discovered that gpu_inner.h gpuPolySpanFn function
+// was taking optimizations to an extreme and packing u/v texture coords
+// into one 32-bit word, reducing their accuracy. Only once they were
+// handled in full-accuracy individual words was that problem fixed.
+//
+// NOTE: I also added support for doing divisions using the FPU, either
+// with normal division or multiplication-by-reciprocal.
+// To use float division, GPU_UNAI_USE_FLOATMATH should be defined.
+// To use float mult-by-reciprocal, GPU_UNAI_USE_FLOAT_DIV_MULTINV
+// can be specified (GPU_UNAI_USE_FLOATMATH must also be specified)
+// To use inaccurate fixed-point mult-by-reciprocal, define
+// GPU_UNAI_USE_INT_DIV_MULTINV. This is the default on older
+// ARM devices like Wiz/Caanoo that have neither integer division
+// in hardware or an FPU. It results in some pixel dropouts,
+// texture glitches, but less than the original GPU UNAI code.
+//
+// If nothing is specified, integer division will be used.
+//
+// NOTE 2: Even with MIPS32R2 having FPU recip.s instruction, and it is
+// used when this platform is detected, I found it not to give any
+// noticeable speedup over normal float division (in fact seemed a tiny
+// tiny bit slower). I also found float division to not provide any
+// noticeable speedups versus integer division on MISP32R2 platform.
+// Granted, the differences were all around .5 FPS or less.
+//
+// TODO:
+// * See if anything can be done about remaining pixel gaps in Gran
+// Turismo car models, track.
+// * Find better way of passing parameters to gpuPolySpanFn functions than
+// through original Unai method of using global variables u4,v4,du4 etc.
+// * Come up with some newer way of drawing rows of pixels than by calling
+// gpuPolySpanFn through function pointer. For every row, at least on
+// MIPS platforms, many registers are having to be pushed/popped from stack
+// on each call, which is strange since MIPS has so many registers.
+// * MIPS MXU/ASM optimized gpuPolySpanFn ?
+
+//////////////////////////////////////////////////////////////////////////
+//senquack - Disabled original Unai poly routines left here for reference:
+// ( from gpu_raster_polygon.h )
+//////////////////////////////////////////////////////////////////////////
+#define GPU_TESTRANGE3() \
+{ \
+ if(x0<0) { if((x1-x0)>CHKMAX_X) return; if((x2-x0)>CHKMAX_X) return; } \
+ if(x1<0) { if((x0-x1)>CHKMAX_X) return; if((x2-x1)>CHKMAX_X) return; } \
+ if(x2<0) { if((x0-x2)>CHKMAX_X) return; if((x1-x2)>CHKMAX_X) return; } \
+ if(y0<0) { if((y1-y0)>CHKMAX_Y) return; if((y2-y0)>CHKMAX_Y) return; } \
+ if(y1<0) { if((y0-y1)>CHKMAX_Y) return; if((y2-y1)>CHKMAX_Y) return; } \
+ if(y2<0) { if((y0-y2)>CHKMAX_Y) return; if((y1-y2)>CHKMAX_Y) return; } \
+}
+
+/*----------------------------------------------------------------------
+F3
+----------------------------------------------------------------------*/
+
+void gpuDrawF3(const PP gpuPolySpanDriver)
+{
+ const int li=linesInterlace;
+ const int pi=(progressInterlace?(linesInterlace+1):0);
+ const int pif=(progressInterlace?(progressInterlace_flag?(linesInterlace+1):0):1);
+ 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(PacketBuffer.S2[2]);
+ y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3]);
+ x1 = GPU_EXPANDSIGN(PacketBuffer.S2[4]);
+ y1 = GPU_EXPANDSIGN(PacketBuffer.S2[5]);
+ x2 = GPU_EXPANDSIGN(PacketBuffer.S2[6]);
+ y2 = GPU_EXPANDSIGN(PacketBuffer.S2[7]);
+
+ GPU_TESTRANGE3();
+
+ 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)];
+
+ for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4)
+ {
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+ xa = x2i(x3);
+ xb = x2i(x4);
+ if( (xa>xmax) || (xb<xmin) ) continue;
+ if(xa < xmin) xa = xmin;
+ if(xb > xmax) xb = xmax;
+ xb-=xa;
+ if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+ }
+ }
+}
+
+/*----------------------------------------------------------------------
+FT3
+----------------------------------------------------------------------*/
+
+void gpuDrawFT3(const PP gpuPolySpanDriver)
+{
+ const int li=linesInterlace;
+ const int pi=(progressInterlace?(linesInterlace+1):0);
+ const int pif=(progressInterlace?(progressInterlace_flag?(linesInterlace+1):0):1);
+ 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(PacketBuffer.S2[2] );
+ y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3] );
+ x1 = GPU_EXPANDSIGN(PacketBuffer.S2[6] );
+ y1 = GPU_EXPANDSIGN(PacketBuffer.S2[7] );
+ x2 = GPU_EXPANDSIGN(PacketBuffer.S2[10]);
+ y2 = GPU_EXPANDSIGN(PacketBuffer.S2[11]);
+
+ GPU_TESTRANGE3();
+
+ 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)];
+
+ for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3)
+ {
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+ xa = x2i(x3);
+ xb = x2i(x4);
+ if( (xa>xmax) || (xb<xmin) ) continue;
+
+ temp = xmin - xa;
+ if(temp > 0)
+ {
+ xa = xmin;
+ u4 = u3 + du4*temp;
+ v4 = v3 + dv4*temp;
+ }
+ else
+ {
+ u4 = u3;
+ v4 = v3;
+ }
+ if(xb > xmax) xb = xmax;
+ xb-=xa;
+ if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+ }
+ }
+}
+
+/*----------------------------------------------------------------------
+G3
+----------------------------------------------------------------------*/
+
+void gpuDrawG3(const PP gpuPolySpanDriver)
+{
+ const int li=linesInterlace;
+ const int pi=(progressInterlace?(linesInterlace+1):0);
+ const int pif=(progressInterlace?(progressInterlace_flag?(linesInterlace+1):0):1);
+ 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(PacketBuffer.S2[2] );
+ y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3] );
+ x1 = GPU_EXPANDSIGN(PacketBuffer.S2[6] );
+ y1 = GPU_EXPANDSIGN(PacketBuffer.S2[7] );
+ x2 = GPU_EXPANDSIGN(PacketBuffer.S2[10]);
+ y2 = GPU_EXPANDSIGN(PacketBuffer.S2[11]);
+
+ GPU_TESTRANGE3();
+
+ 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)];
+
+ for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, r3+=dr3, g3+=dg3, b3+=db3)
+ {
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+ xa = x2i(x3);
+ xb = x2i(x4);
+ if( (xa>xmax) || (xb<xmin) ) continue;
+
+ temp = xmin - xa;
+ if(temp > 0)
+ {
+ xa = xmin;
+ r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
+ }
+ else
+ {
+ r4 = r3; g4 = g3; b4 = b3;
+ }
+ if(xb > xmax) xb = xmax;
+ xb-=xa;
+ if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+ }
+ }
+}
+
+/*----------------------------------------------------------------------
+GT3
+----------------------------------------------------------------------*/
+
+void gpuDrawGT3(const PP gpuPolySpanDriver)
+{
+ const int li=linesInterlace;
+ const int pi=(progressInterlace?(linesInterlace+1):0);
+ const int pif=(progressInterlace?(progressInterlace_flag?(linesInterlace+1):0):1);
+ 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(PacketBuffer.S2[2] );
+ y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3] );
+ x1 = GPU_EXPANDSIGN(PacketBuffer.S2[8] );
+ y1 = GPU_EXPANDSIGN(PacketBuffer.S2[9] );
+ x2 = GPU_EXPANDSIGN(PacketBuffer.S2[14]);
+ y2 = GPU_EXPANDSIGN(PacketBuffer.S2[15]);
+
+ GPU_TESTRANGE3();
+
+ 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)];
+
+ for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3, r3+=dr3, g3+=dg3, b3+=db3)
+ {
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+ xa = x2i(x3);
+ xb = x2i(x4);
+ if( (xa>xmax) || (xb<xmin)) continue;
+
+ temp = xmin - xa;
+ if(temp > 0)
+ {
+ xa = xmin;
+ u4 = u3 + du4*temp; v4 = v3 + dv4*temp;
+ r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
+ }
+ else
+ {
+ u4 = u3; v4 = v3;
+ r4 = r3; g4 = g3; b4 = b3;
+ }
+ if(xb > xmax) xb = xmax;
+ xb-=xa;
+ if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
+ }
+ }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//senquack - Original Unai poly routines left here for reference:
+// ( from gpu_inner.h ) NOTE: this uses 16.16, not 22.10 fixed point
+//////////////////////////////////////////////////////////////////////////
+template<const int CF>
+INLINE void gpuPolySpanFn(u16 *pDst, u32 count)
+{
+ if (!TM)
+ {
+ // NO TEXTURE
+ if (!G)
+ {
+ // NO GOURAUD
+ u16 data;
+ if (L) { u32 lCol=((u32)(b4<< 2)&(0x03ff)) | ((u32)(g4<<13)&(0x07ff<<10)) | ((u32)(r4<<24)&(0x07ff<<21)); gpuLightingRGB(data,lCol); }
+ else data=PixelData;
+ if ((!M)&&(!B))
+ {
+ if (MB) { data = data | 0x8000; }
+ do { *pDst++ = data; } while (--count);
+ }
+ else if ((M)&&(!B))
+ {
+ if (MB) { data = data | 0x8000; }
+ do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count);
+ }
+ else
+ {
+ u16 uSrc;
+ u16 uDst;
+ u32 uMsk; if (BM==0) uMsk=0x7BDE;
+ u32 bMsk; if (BI) bMsk=blit_mask;
+ do
+ {
+ // blit-mask
+ if (BI) { if((bMsk>>((((u32)pDst)>>1)&7))&1) goto endtile; }
+ // 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;
+ u32 bMsk; if (BI) bMsk=blit_mask;
+ do
+ {
+ // blit-mask
+ if (BI) { if((bMsk>>((((u32)pDst)>>1)&7))&1) goto endgou; }
+ // 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;
+ u32 bMsk; if (BI) bMsk=blit_mask;
+ do
+ {
+ // blit-mask
+ if (BI) { if((bMsk>>((((u32)pDst)>>1)&7))&1) goto endpoly; }
+ // 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);
+ }
+}
diff --git a/plugins/gpu_unai/gpu.cpp b/plugins/gpu_unai/gpu.cpp
index 1552bed..c3f7095 100644
--- a/plugins/gpu_unai/gpu.cpp
+++ b/plugins/gpu_unai/gpu.cpp
@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (C) 2010 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
* *
* 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 *
@@ -18,103 +19,43 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
***************************************************************************/
-#include "port.h"
-#include "gpu.h"
-#include "profiler.h"
-#include "debug.h"
+#include <stddef.h>
+#include "plugins.h"
+#include "psxcommon.h"
+//#include "port.h"
+#include "gpu_unai.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 */
+#define VIDEO_WIDTH 320
-bool isSkip = false; /* skip frame (info coming from GPU) */
-bool wasSkip = false;
-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 FrameToRead = false; /* load image in progress */
-bool FrameToWrite = false; /* store image in progress */
-bool fb_dirty = false;
-
-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 GP0;
-s32 PacketCount;
-s32 PacketIndex;
-
-///////////////////////////////////////////////////////////////////////////////
-// Display status
-u32 DisplayArea [6];
-
-///////////////////////////////////////////////////////////////////////////////
-// Rasterizer status
-u32 TextureWindow [4];
-u32 DrawingArea [4];
-u32 DrawingOffset [2];
+#ifdef TIME_IN_MSEC
+#define TPS 1000
+#else
+#define TPS 1000000
+#endif
-///////////////////////////////////////////////////////////////////////////////
-// Rasterizer status
+#define IS_PAL (gpu_unai.GPU_GP1&(0x08<<17))
-u16* TBA;
-u16* CBA;
+//senquack - Original 512KB of guard space seems not to be enough, as Xenogears
+// accesses outside this range and crashes in town intro fight sequence.
+// Increased to 2MB total (double PSX VRAM) and Xenogears no longer
+// crashes, but some textures are still messed up. Also note that alignment min
+// is 16 bytes, needed for pixel-skipping rendering/blitting in high horiz res.
+// Extra 4KB is for guard room at beginning.
+// TODO: Determine cause of out-of-bounds write/reads. <-- Note: this is largely
+// solved by adoption of PCSX Rearmed's 'gpulib' in gpulib_if.cpp, which
+// replaces this file (gpu.cpp)
+//u16 GPU_FrameBuffer[(FRAME_BUFFER_SIZE+512*1024)/2] __attribute__((aligned(32)));
+static u16 GPU_FrameBuffer[(FRAME_BUFFER_SIZE*2 + 4096)/2] __attribute__((aligned(32)));
///////////////////////////////////////////////////////////////////////////////
-// Inner Loops
-s32 u4, du4;
-s32 v4, dv4;
-s32 r4, dr4;
-s32 g4, dg4;
-s32 b4, db4;
-u32 lInc;
-u32 tInc, tMsk;
-
-GPUPacket PacketBuffer;
-// FRAME_BUFFER_SIZE is defined in bytes; 512K is guard memory for out of range reads
-u16 GPU_FrameBuffer[(FRAME_BUFFER_SIZE+512*1024)/2] __attribute__((aligned(2048)));
-u32 GPU_GP1;
+// GPU fixed point math
+#include "gpu_fixedpoint.h"
///////////////////////////////////////////////////////////////////////////////
-// Inner loop driver instanciation file
+// Inner loop driver instantiation file
#include "gpu_inner.h"
///////////////////////////////////////////////////////////////////////////////
-// GPU Raster Macros
-#define GPU_RGB16(rgb) ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))
-
-#define GPU_EXPANDSIGN(x) (((s32)(x)<<21)>>21)
-
-#define CHKMAX_X 1024
-#define CHKMAX_Y 512
-
-#define GPU_SWAP(a,b,t) {(t)=(a);(a)=(b);(b)=(t);}
-
-///////////////////////////////////////////////////////////////////////////////
// GPU internal image drawing functions
#include "gpu_raster_image.h"
@@ -135,72 +76,88 @@ u32 GPU_GP1;
#include "gpu_command.h"
///////////////////////////////////////////////////////////////////////////////
-INLINE void gpuReset(void)
+static 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;
+ memset((void*)&gpu_unai, 0, sizeof(gpu_unai));
+ gpu_unai.vram = (u16*)GPU_FrameBuffer + (4096/2); //4kb guard room in front
+ gpu_unai.GPU_GP1 = 0x14802000;
+ gpu_unai.DrawingArea[2] = 256;
+ gpu_unai.DrawingArea[3] = 240;
+ gpu_unai.DisplayArea[2] = 256;
+ gpu_unai.DisplayArea[3] = 240;
+ gpu_unai.DisplayArea[5] = 240;
+ gpu_unai.TextureWindow[0] = 0;
+ gpu_unai.TextureWindow[1] = 0;
+ gpu_unai.TextureWindow[2] = 255;
+ gpu_unai.TextureWindow[3] = 255;
+ //senquack - new vars must be updated whenever texture window is changed:
+ // (used for polygon-drawing in gpu_inner.h, gpu_raster_polygon.h)
+ const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
+ gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1);
+ gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+
+ // Configuration options
+ gpu_unai.config = gpu_unai_config_ext;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
+ gpu_unai.frameskip.skipCount = gpu_unai.config.frameskip_count;
+
+ SetupLightLUT();
+ SetupDitheringConstants();
}
///////////////////////////////////////////////////////////////////////////////
-bool GPU_init(void)
+long GPU_init(void)
{
gpuReset();
-
+
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
// s_invTable
- for(int i=1;i<=(1<<TABLE_BITS);++i)
+ for(unsigned int i=1;i<=(1<<TABLE_BITS);++i)
{
- double v = 1.0 / double(i);
- #ifdef GPU_TABLE_10_BITS
- v *= double(0xffffffff>>1);
- #else
- v *= double(0x80000000);
- #endif
- s_invTable[i-1]=s32(v);
+ s_invTable[i-1]=0x7fffffff/i;
}
+#endif
+
+ gpu_unai.fb_dirty = true;
+ gpu_unai.dma.last_dma = NULL;
return (0);
}
///////////////////////////////////////////////////////////////////////////////
-void GPU_shutdown(void)
+long GPU_shutdown(void)
{
+ return 0;
}
///////////////////////////////////////////////////////////////////////////////
-long GPU_freeze(unsigned int bWrite, GPUFreeze_t* p2)
+long GPU_freeze(u32 bWrite, GPUFreeze_t* p2)
{
if (!p2) return (0);
- if (p2->Version != 1) return (0);
+ if (p2->ulFreezeVersion != 1) return (0);
if (bWrite)
{
- p2->GPU_gp1 = GPU_GP1;
- memset(p2->Control, 0, sizeof(p2->Control));
+ p2->ulStatus = gpu_unai.GPU_GP1;
+ memset(p2->ulControl, 0, sizeof(p2->ulControl));
// save resolution and registers for P.E.Op.S. compatibility
- p2->Control[3] = (3 << 24) | ((GPU_GP1 >> 23) & 1);
- p2->Control[4] = (4 << 24) | ((GPU_GP1 >> 29) & 3);
- p2->Control[5] = (5 << 24) | (DisplayArea[0] | (DisplayArea[1] << 10));
- p2->Control[6] = (6 << 24) | (2560 << 12);
- p2->Control[7] = (7 << 24) | (DisplayArea[4] | (DisplayArea[5] << 10));
- p2->Control[8] = (8 << 24) | ((GPU_GP1 >> 17) & 0x3f) | ((GPU_GP1 >> 10) & 0x40);
- memcpy(p2->FrameBuffer, (u16*)GPU_FrameBuffer, FRAME_BUFFER_SIZE);
+ p2->ulControl[3] = (3 << 24) | ((gpu_unai.GPU_GP1 >> 23) & 1);
+ p2->ulControl[4] = (4 << 24) | ((gpu_unai.GPU_GP1 >> 29) & 3);
+ p2->ulControl[5] = (5 << 24) | (gpu_unai.DisplayArea[0] | (gpu_unai.DisplayArea[1] << 10));
+ p2->ulControl[6] = (6 << 24) | (2560 << 12);
+ p2->ulControl[7] = (7 << 24) | (gpu_unai.DisplayArea[4] | (gpu_unai.DisplayArea[5] << 10));
+ p2->ulControl[8] = (8 << 24) | ((gpu_unai.GPU_GP1 >> 17) & 0x3f) | ((gpu_unai.GPU_GP1 >> 10) & 0x40);
+ memcpy((void*)p2->psxVRam, (void*)gpu_unai.vram, FRAME_BUFFER_SIZE);
return (1);
}
else
{
- GPU_GP1 = p2->GPU_gp1;
- memcpy((u16*)GPU_FrameBuffer, p2->FrameBuffer, FRAME_BUFFER_SIZE);
- GPU_writeStatus((5 << 24) | p2->Control[5]);
- GPU_writeStatus((7 << 24) | p2->Control[7]);
- GPU_writeStatus((8 << 24) | p2->Control[8]);
- gpuSetTexture(GPU_GP1);
+ extern void GPU_writeStatus(u32 data);
+ gpu_unai.GPU_GP1 = p2->ulStatus;
+ memcpy((void*)gpu_unai.vram, (void*)p2->psxVRam, FRAME_BUFFER_SIZE);
+ GPU_writeStatus((5 << 24) | p2->ulControl[5]);
+ GPU_writeStatus((7 << 24) | p2->ulControl[7]);
+ GPU_writeStatus((8 << 24) | p2->ulControl[8]);
+ gpuSetTexture(gpu_unai.GPU_GP1);
return (1);
}
return (0);
@@ -233,72 +190,69 @@ u8 PacketSize[256] =
///////////////////////////////////////////////////////////////////////////////
INLINE void gpuSendPacket()
{
-#ifdef DEBUG_ANALYSIS
- dbg_anacnt_GPU_sendPacket++;
-#endif
- gpuSendPacketFunction(PacketBuffer.U4[0]>>24);
+ gpuSendPacketFunction(gpu_unai.PacketBuffer.U4[0]>>24);
}
///////////////////////////////////////////////////////////////////////////////
INLINE void gpuCheckPacket(u32 uData)
{
- if (PacketCount)
+ if (gpu_unai.PacketCount)
{
- PacketBuffer.U4[PacketIndex++] = uData;
- --PacketCount;
+ gpu_unai.PacketBuffer.U4[gpu_unai.PacketIndex++] = uData;
+ --gpu_unai.PacketCount;
}
else
{
- PacketBuffer.U4[0] = uData;
- PacketCount = PacketSize[uData >> 24];
- PacketIndex = 1;
+ gpu_unai.PacketBuffer.U4[0] = uData;
+ gpu_unai.PacketCount = PacketSize[uData >> 24];
+ gpu_unai.PacketIndex = 1;
}
- if (!PacketCount) gpuSendPacket();
+ if (!gpu_unai.PacketCount) gpuSendPacket();
}
///////////////////////////////////////////////////////////////////////////////
-void GPU_writeDataMem(u32* dmaAddress, s32 dmaCount)
+void GPU_writeDataMem(u32* dmaAddress, int 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);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeDataMem(%d)\n",dmaCount);
+ #endif
u32 data;
- const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
- GPU_GP1 &= ~0x14000000;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
+ gpu_unai.GPU_GP1 &= ~0x14000000;
while (dmaCount)
{
- if (FrameToWrite)
+ if (gpu_unai.dma.FrameToWrite)
{
while (dmaCount)
{
dmaCount--;
data = *dmaAddress++;
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
- pvram[px] = data;
- if (++px>=x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px] = data;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToWrite = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
break;
}
}
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
- pvram[px] = data>>16;
- if (++px>=x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px] = data>>16;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToWrite = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
break;
}
}
@@ -312,95 +266,100 @@ void GPU_writeDataMem(u32* dmaAddress, s32 dmaCount)
}
}
- GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
- fb_dirty = true;
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
- pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 | 0x14000000) & ~0x60000000;
}
-u32 *lUsedAddr[3];
-INLINE int CheckForEndlessLoop(u32 *laddr)
+long GPU_dmaChain(u32 *rambase, u32 start_addr)
{
- if(laddr==lUsedAddr[1]) return 1;
- if(laddr==lUsedAddr[2]) return 1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_dmaChain(0x%x)\n",start_addr);
+ #endif
- if(laddr<lUsedAddr[0]) lUsedAddr[1]=laddr;
- else lUsedAddr[2]=laddr;
- lUsedAddr[0]=laddr;
- return 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-long GPU_dmaChain(u32* baseAddr, u32 dmaVAddr)
-{
-#ifdef DEBUG_ANALYSIS
- dbg_anacnt_GPU_dmaChain++;
-#endif
- pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
- u32 data, *address, count, offset;
- unsigned int DMACommandCounter = 0;
+ u32 addr, *list;
+ u32 len, count;
long dma_words = 0;
- GPU_GP1 &= ~0x14000000;
- lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=(u32*)0x1fffff;
- dmaVAddr &= 0x001FFFFF;
- while (dmaVAddr != 0x1FFFFF)
+ if (gpu_unai.dma.last_dma) *gpu_unai.dma.last_dma |= 0x800000;
+
+ gpu_unai.GPU_GP1 &= ~0x14000000;
+
+ addr = start_addr & 0xffffff;
+ for (count = 0; addr != 0xffffff; count++)
{
- address = (baseAddr + (dmaVAddr >> 2));
- if(DMACommandCounter++ > 2000000) break;
- if(CheckForEndlessLoop(address)) break;
- data = *address++;
- count = (data >> 24);
- offset = data & 0x001FFFFF;
- if (dmaVAddr != offset) dmaVAddr = offset;
- else dmaVAddr = 0x1FFFFF;
-
- if(count>0) GPU_writeDataMem(address,count);
- dma_words += 1 + count;
+ list = rambase + (addr & 0x1fffff) / 4;
+ len = list[0] >> 24;
+ addr = list[0] & 0xffffff;
+
+ dma_words += 1 + len;
+
+ // add loop detection marker
+ list[0] |= 0x800000;
+
+ if (len) GPU_writeDataMem(list + 1, len);
+
+ if (addr & 0x800000)
+ {
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_dmaChain(LOOP)\n");
+ #endif
+ break;
+ }
}
- GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+
+ // remove loop detection markers
+ addr = start_addr & 0x1fffff;
+ while (count-- > 0)
+ {
+ list = rambase + addr / 4;
+ addr = list[0] & 0x1fffff;
+ list[0] &= ~0x800000;
+ }
+
+ if (gpu_unai.dma.last_dma) *gpu_unai.dma.last_dma &= ~0x800000;
+ gpu_unai.dma.last_dma = rambase + (start_addr & 0x1fffff) / 4;
+
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 | 0x14000000) & ~0x60000000;
return dma_words;
}
///////////////////////////////////////////////////////////////////////////////
-void GPU_writeData(u32 data)
+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;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeData()\n");
+ #endif
+ gpu_unai.GPU_GP1 &= ~0x14000000;
- if (FrameToWrite)
+ if (gpu_unai.dma.FrameToWrite)
{
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
- pvram[px]=(u16)data;
- if (++px>=x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px]=(u16)data;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToWrite = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
}
}
- if (FrameToWrite)
+ if (gpu_unai.dma.FrameToWrite)
{
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
- pvram[px]=data>>16;
- if (++px>=x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.dma.pvram[gpu_unai.dma.px]=data>>16;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToWrite = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.fb_dirty = true;
}
}
}
@@ -409,507 +368,463 @@ void GPU_writeData(u32 data)
{
gpuCheckPacket(data);
}
- GPU_GP1 |= 0x14000000;
- fb_dirty = true;
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
- pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
-
+ gpu_unai.GPU_GP1 |= 0x14000000;
}
///////////////////////////////////////////////////////////////////////////////
-void GPU_readDataMem(u32* dmaAddress, s32 dmaCount)
+void GPU_readDataMem(u32* dmaAddress, int dmaCount)
{
- const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
-#ifdef DEBUG_ANALYSIS
- dbg_anacnt_GPU_readDataMem++;
-#endif
- if(!FrameToRead) return;
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_readDataMem(%d)\n",dmaCount);
+ #endif
+ if(!gpu_unai.dma.FrameToRead) return;
- pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
- GPU_GP1 &= ~0x14000000;
+ gpu_unai.GPU_GP1 &= ~0x14000000;
do
{
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
// lower 16 bit
- u32 data = pvram[px];
+ //senquack - 64-bit fix (from notaz)
+ //u32 data = (unsigned long)gpu_unai.dma.pvram[gpu_unai.dma.px];
+ u32 data = (u32)gpu_unai.dma.pvram[gpu_unai.dma.px];
- if (++px>=x_end)
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
}
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
// higher 16 bit (always, even if it's an odd width)
- data |= (u32)(pvram[px])<<16;
+ //senquack - 64-bit fix (from notaz)
+ //data |= (unsigned long)(gpu_unai.dma.pvram[gpu_unai.dma.px])<<16;
+ data |= (u32)(gpu_unai.dma.pvram[gpu_unai.dma.px])<<16;
*dmaAddress++ = data;
- if (++px>=x_end)
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToRead = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToRead = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
break;
}
}
} while (--dmaCount);
- GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 | 0x14000000) & ~0x60000000;
}
///////////////////////////////////////////////////////////////////////////////
-u32 GPU_readData(void)
+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)
+ const u16 *VIDEO_END = (u16*)gpu_unai.vram+(FRAME_BUFFER_SIZE/2)-1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_readData()\n");
+ #endif
+ gpu_unai.GPU_GP1 &= ~0x14000000;
+ if (gpu_unai.dma.FrameToRead)
{
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
- GP0 = pvram[px];
- if (++px>=x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.GPU_GP0 = gpu_unai.dma.pvram[gpu_unai.dma.px];
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram += 1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToRead = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToRead = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
}
}
- if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
- GP0 |= pvram[px]<<16;
- if (++px>=x_end)
+ if ((&gpu_unai.dma.pvram[gpu_unai.dma.px])>(VIDEO_END)) gpu_unai.dma.pvram-=512*1024;
+ gpu_unai.GPU_GP0 |= gpu_unai.dma.pvram[gpu_unai.dma.px]<<16;
+ if (++gpu_unai.dma.px >= gpu_unai.dma.x_end)
{
- px = 0;
- pvram +=1024;
- if (++py>=y_end)
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.pvram += 1024;
+ if (++gpu_unai.dma.py >= gpu_unai.dma.y_end)
{
- FrameToRead = false;
- GPU_GP1 &= ~0x08000000;
+ gpu_unai.dma.FrameToRead = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
}
}
}
- GPU_GP1 |= 0x14000000;
+ gpu_unai.GPU_GP1 |= 0x14000000;
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_READ);
- pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
- return (GP0);
+ return (gpu_unai.GPU_GP0);
}
///////////////////////////////////////////////////////////////////////////////
-u32 GPU_readStatus(void)
+u32 GPU_readStatus(void)
{
-#ifdef DEBUG_ANALYSIS
- dbg_anacnt_GPU_readStatus++;
-#endif
- return GPU_GP1;
+ return gpu_unai.GPU_GP1;
+}
+
+INLINE void GPU_NoSkip(void)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_NoSkip()\n");
+ #endif
+ gpu_unai.frameskip.wasSkip = gpu_unai.frameskip.isSkip;
+ if (gpu_unai.frameskip.isSkip)
+ {
+ gpu_unai.frameskip.isSkip = false;
+ gpu_unai.frameskip.skipGPU = false;
+ }
+ else
+ {
+ gpu_unai.frameskip.isSkip = gpu_unai.frameskip.skipFrame;
+ gpu_unai.frameskip.skipGPU = gpu_unai.frameskip.skipFrame;
+ }
}
///////////////////////////////////////////////////////////////////////////////
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);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeStatus(%d,%d)\n",data>>24,data & 0xff);
+ #endif
switch (data >> 24) {
case 0x00:
gpuReset();
break;
case 0x01:
- GPU_GP1 &= ~0x08000000;
- PacketCount = 0; FrameToRead = FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.PacketCount = 0;
+ gpu_unai.dma.FrameToRead = gpu_unai.dma.FrameToWrite = false;
break;
case 0x02:
- GPU_GP1 &= ~0x08000000;
- PacketCount = 0; FrameToRead = FrameToWrite = false;
+ gpu_unai.GPU_GP1 &= ~0x08000000;
+ gpu_unai.PacketCount = 0;
+ gpu_unai.dma.FrameToRead = gpu_unai.dma.FrameToWrite = false;
break;
case 0x03:
- GPU_GP1 = (GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
break;
case 0x04:
- if (data == 0x04000000)
- PacketCount = 0;
- GPU_GP1 = (GPU_GP1 & ~0x60000000) | ((data & 3) << 29);
+ if (data == 0x04000000) gpu_unai.PacketCount = 0;
+ gpu_unai.GPU_GP1 = (gpu_unai.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);
- fb_dirty = true;
- wasSkip = isSkip;
- if (isSkip)
- isSkip = false;
- else
- isSkip = skipFrame;
+ // Start of Display Area in VRAM
+ gpu_unai.DisplayArea[0] = data & 0x3ff; // X (0..1023)
+ gpu_unai.DisplayArea[1] = (data >> 10) & 0x1ff; // Y (0..511)
+ GPU_NoSkip();
+ break;
+ case 0x06:
+ // GP1(06h) - Horizontal Display range (on Screen)
+ // 0-11 X1 (260h+0) ;12bit ;\counted in 53.222400MHz units,
+ // 12-23 X2 (260h+320*8) ;12bit ;/relative to HSYNC
+
+ // senquack - gpu_unai completely ignores GP1(0x06) command and
+ // lacks even a place in DisplayArea[] array to store the values.
+ // It seems to have been concerned only with vertical display range
+ // and centering top/bottom. I will not add support here, and
+ // focus instead on the gpulib version (gpulib_if.cpp) which uses
+ // gpulib for its PS1->host framebuffer blitting.
break;
case 0x07:
- DisplayArea[4] = data & 0x000003FF; //(short)(data & 0x3ff);
- DisplayArea[5] = (data & 0x000FFC00) >> 10; //(short)((data>>10) & 0x3ff);
- fb_dirty = true;
+ // GP1(07h) - Vertical Display range (on Screen)
+ // 0-9 Y1 (NTSC=88h-(224/2), (PAL=A3h-(264/2)) ;\scanline numbers on screen,
+ // 10-19 Y2 (NTSC=88h+(224/2), (PAL=A3h+(264/2)) ;/relative to VSYNC
+ // 20-23 Not used (zero)
+ {
+ u32 v1=data & 0x000003FF; //(short)(data & 0x3ff);
+ u32 v2=(data & 0x000FFC00) >> 10; //(short)((data>>10) & 0x3ff);
+ if ((gpu_unai.DisplayArea[4]!=v1)||(gpu_unai.DisplayArea[5]!=v2))
+ {
+ gpu_unai.DisplayArea[4] = v1;
+ gpu_unai.DisplayArea[5] = v2;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"video_clear(CHANGE_Y)\n");
+ #endif
+ video_clear();
+ }
+ }
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
+ static const u32 HorizontalResolution[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
+ static const u32 VerticalResolution[4] = { 240, 480, 256, 480 };
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x007F0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeStatus(RES=%dx%d,BITS=%d,PAL=%d)\n",HorizontalResolution[(gpu_unai.GPU_GP1 >> 16) & 7],
+ VerticalResolution[(gpu_unai.GPU_GP1 >> 19) & 3],(gpu_unai.GPU_GP1&0x00200000?24:15),(IS_PAL?1:0));
+ #endif
+ // Video mode change
+ u32 new_width = HorizontalResolution[(gpu_unai.GPU_GP1 >> 16) & 7];
+ u32 new_height = VerticalResolution[(gpu_unai.GPU_GP1 >> 19) & 3];
+
+ if (gpu_unai.DisplayArea[2] != new_width || gpu_unai.DisplayArea[3] != new_height)
+ {
+ // Update width
+ gpu_unai.DisplayArea[2] = new_width;
+
+ if (PixelSkipEnabled()) {
+ // Set blit_mask for high horizontal resolutions. This allows skipping
+ // rendering pixels that would never get displayed on low-resolution
+ // platforms that use simple pixel-dropping scaler.
+ switch (gpu_unai.DisplayArea[2])
+ {
+ case 512: gpu_unai.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
+ case 640: gpu_unai.blit_mask = 0xaa; break; // GPU_BlitWS
+ default: gpu_unai.blit_mask = 0; break;
+ }
+ } else {
+ gpu_unai.blit_mask = 0;
+ }
+
+ // Update height
+ gpu_unai.DisplayArea[3] = new_height;
+
+ if (LineSkipEnabled()) {
+ // Set rendering line-skip (only render every other line in high-res
+ // 480 vertical mode, or, optionally, force it for all video modes)
+
+ if (gpu_unai.DisplayArea[3] == 480) {
+ if (gpu_unai.config.ilace_force) {
+ gpu_unai.ilace_mask = 3; // Only need 1/4 of lines
+ } else {
+ gpu_unai.ilace_mask = 1; // Only need 1/2 of lines
+ }
+ } else {
+ // Vert resolution changed from 480 to lower one
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
+ }
+ } else {
+ gpu_unai.ilace_mask = 0;
+ }
+
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"video_clear(CHANGE_RES)\n");
+ #endif
+ video_clear();
+ }
+
}
- fb_dirty = true;
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;
+ switch (data & 0xff) {
+ case 2: gpu_unai.GPU_GP0 = gpu_unai.tex_window; break;
+ case 3: gpu_unai.GPU_GP0 = (gpu_unai.DrawingArea[1] << 10) | gpu_unai.DrawingArea[0]; break;
+ case 4: gpu_unai.GPU_GP0 = ((gpu_unai.DrawingArea[3]-1) << 10) | (gpu_unai.DrawingArea[2]-1); break;
+ case 5: case 6: gpu_unai.GPU_GP0 = (((u32)gpu_unai.DrawingOffset[1] & 0x7ff) << 11) | ((u32)gpu_unai.DrawingOffset[0] & 0x7ff); break;
+ case 7: gpu_unai.GPU_GP0 = 2; break;
+ case 8: case 15: gpu_unai.GPU_GP0 = 0xBFC03720; break;
}
break;
}
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
- pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
}
-#ifndef REARMED
-
// Blitting functions
#include "gpu_blit.h"
-INLINE void gpuVideoOutput(void)
+static void gpuVideoOutput(void)
{
- static s16 old_res_horz, old_res_vert, old_rgb24;
- s16 h0, x0, y0, w0, h1;
+ int h0, x0, y0, w0, h1;
- x0 = DisplayArea[0];
- y0 = DisplayArea[1];
+ x0 = gpu_unai.DisplayArea[0];
+ y0 = gpu_unai.DisplayArea[1];
- w0 = DisplayArea[2];
- h0 = DisplayArea[3]; // video mode
+ w0 = gpu_unai.DisplayArea[2];
+ h0 = gpu_unai.DisplayArea[3]; // video mode
- h1 = DisplayArea[5] - DisplayArea[4]; // display needed
+ h1 = gpu_unai.DisplayArea[5] - gpu_unai.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);
+ bool isRGB24 = (gpu_unai.GPU_GP1 & 0x00200000 ? true : false);
+ u16* dst16 = SCREEN;
+ u16* src16 = (u16*)gpu_unai.vram;
- /* 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();
- }
+ // PS1 fb read wraps around (fixes black screen in 'Tobal no. 1')
+ unsigned int src16_offs_msk = 1024*512-1;
+ unsigned int src16_offs = (x0 + y0*1024) & src16_offs_msk;
// Height centering
int sizeShift = 1;
- if(h0==256) h0 = 240; else if(h0==480) sizeShift = 2;
- if(h1>h0) { src_screen16 += ((h1-h0)>>sizeShift)*1024; h1 = h0; }
- else if(h1<h0) dest_screen16 += ((h0-h1)>>sizeShift)*VIDEO_WIDTH;
+ if (h0 == 256) {
+ h0 = 240;
+ } else if (h0 == 480) {
+ sizeShift = 2;
+ }
+ if (h1 > h0) {
+ src16_offs = (src16_offs + (((h1-h0) / 2) * 1024)) & src16_offs_msk;
+ h1 = h0;
+ } else if (h1<h0) {
+ dst16 += ((h0-h1) >> sizeShift) * VIDEO_WIDTH;
+ }
+
/* Main blitter */
int incY = (h0==480) ? 2 : 1;
h0=(h0==480 ? 2048 : 1024);
{
- const int li=linesInterlace;
- bool pi=progressInterlace;
- bool pif=progressInterlace_flag;
+ const int li=gpu_unai.ilace_mask;
+ bool pi = ProgressiveInterlaceEnabled();
+ bool pif = gpu_unai.prog_ilace_flag;
switch ( w0 )
{
case 256:
for(int y1=y0+h1; y0<y1; y0+=incY)
{
- if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWDWW( src_screen16, dest_screen16, isRGB24);
- dest_screen16 += VIDEO_WIDTH;
- src_screen16 += h0;
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWDWW(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
}
break;
case 368:
for(int y1=y0+h1; y0<y1; y0+=incY)
{
- if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWWWWWWWS( src_screen16, dest_screen16, isRGB24, 4);
- dest_screen16 += VIDEO_WIDTH;
- src_screen16 += h0;
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWWWWWWWS(src16 + src16_offs, dst16, isRGB24, 4);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
}
break;
case 320:
+ // Ensure 32-bit alignment for GPU_BlitWW() blitter:
+ src16_offs &= ~1;
for(int y1=y0+h1; y0<y1; y0+=incY)
{
- if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWW( src_screen16, dest_screen16, isRGB24);
- dest_screen16 += VIDEO_WIDTH;
- src_screen16 += h0;
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWW(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
}
break;
case 384:
for(int y1=y0+h1; y0<y1; y0+=incY)
{
- if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWWWWS( src_screen16, dest_screen16, isRGB24);
- dest_screen16 += VIDEO_WIDTH;
- src_screen16 += h0;
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWWWWS(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
}
break;
case 512:
for(int y1=y0+h1; y0<y1; y0+=incY)
{
- if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWSWWSWS( src_screen16, dest_screen16, isRGB24);
- dest_screen16 += VIDEO_WIDTH;
- src_screen16 += h0;
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWSWWSWS(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
}
break;
case 640:
for(int y1=y0+h1; y0<y1; y0+=incY)
{
- if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWS( src_screen16, dest_screen16, isRGB24);
- dest_screen16 += VIDEO_WIDTH;
- src_screen16 += h0;
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWS(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
}
break;
}
- progressInterlace_flag=!progressInterlace_flag;
+ gpu_unai.prog_ilace_flag = !gpu_unai.prog_ilace_flag;
}
video_flip();
}
-///////////////////////////////////////////////////////////////////////////////
-void GPU_updateLace(void)
-{
-#ifdef ENABLE_GPU_LOG_SUPPORT
- fprintf(stdout,"GPU_updateLace()\n");
-#endif
-#ifdef DEBUG_ANALYSIS
- dbg_anacnt_GPU_updateLace++;
-#endif
- pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS);
-#ifdef PROFILER_PCSX4ALL
- pcsx4all_prof_frames++;
-#endif
-#ifdef DEBUG_FRAME
- if(isdbg_frame())
- {
- static int passed=0;
- if (!passed) dbg_enable();
- else pcsx4all_exit();
- passed++;
- }
-#endif
-
- // Frame skip table
- static const unsigned char skipTable[12][12] =
- {
- { 0,0,0,0,0,0,0,0,0,0,0,0 },
- { 0,0,0,0,0,0,0,0,0,0,0,1 },
- { 0,0,0,0,0,1,0,0,0,0,0,1 },
- { 0,0,0,1,0,0,0,1,0,0,0,1 },
- { 0,0,1,0,0,1,0,0,1,0,0,1 },
- { 0,1,0,0,1,0,1,0,0,1,0,1 },
- { 0,1,0,1,0,1,0,1,0,1,0,1 },
- { 0,1,0,1,1,0,1,0,1,1,0,1 },
- { 0,1,1,0,1,1,0,1,1,0,1,1 },
- { 0,1,1,1,0,1,1,1,0,1,1,1 },
- { 0,1,1,1,1,1,0,1,1,1,1,1 },
- { 0,1,1,1,1,1,1,1,1,1,1,1 }
- };
-
- // Interlace bit toggle
- GPU_GP1 ^= 0x80000000;
-
- // Update display
- if ((!skipFrame) && (!isSkip) && (fb_dirty) && (!(((GPU_GP1&0x08000000))||((GPU_GP1&0x00800000)))))
- {
- gpuVideoOutput(); // Display updated
-
- if (DisplayArea[3] == 480)
- {
- if (linesInterlace_user) linesInterlace = 3; // 1/4 of lines
- else linesInterlace = 1; // if 480 we only need half of lines
- }
- else if (linesInterlace != linesInterlace_user)
- {
- linesInterlace = linesInterlace_user; // resolution changed from 480 to lower one
- video_clear();
- }
- }
+// Update frames-skip each second>>3 (8 times per second)
+#define GPU_FRAMESKIP_UPDATE 3
- // Limit FPS
- if (frameLimit)
- {
- static unsigned next=get_ticks();
- if (!skipFrame)
- {
- unsigned now=get_ticks();
- if (now<next) wait_ticks(next-now);
- }
- next+=(isPAL?(1000000/50):((unsigned)(1000000.0/59.94)));
- }
+static void GPU_frameskip (bool show)
+{
+ u32 now=get_ticks(); // current frame
- // Show FPS statistics
- if (show_fps)
+ // Update frameskip
+ if (gpu_unai.frameskip.skipCount==0) gpu_unai.frameskip.skipFrame=false; // frameskip off
+ else if (gpu_unai.frameskip.skipCount==7) { if (show) gpu_unai.frameskip.skipFrame=!gpu_unai.frameskip.skipFrame; } // frameskip medium
+ else if (gpu_unai.frameskip.skipCount==8) gpu_unai.frameskip.skipFrame=true; // frameskip maximum
+ else
{
- static u32 real_fps=0;
- static u32 prev=get_ticks();
- static char msg[32]="FPS=000/00 SPD=000%";
- u32 now=get_ticks();
- real_fps++;
- if ((now-prev)>=1000000)
+ static u32 spd=100; // speed %
+ static u32 frames=0; // frames counter
+ static u32 prev=now; // previous fps calculation
+ frames++;
+ if ((now-prev)>=(TPS>>GPU_FRAMESKIP_UPDATE))
{
- 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));
+ if (IS_PAL) spd=(frames<<1);
+ else spd=((frames*1001)/600);
+ spd<<=GPU_FRAMESKIP_UPDATE;
+ frames=0;
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)
+ switch(gpu_unai.frameskip.skipCount)
{
- skipFrame=skipTable[skipCount][skCount];
- skCount--; if (skCount<0) skCount=11;
- isSkip=true;
+ case 1: if (spd<50) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<50%)
+ case 2: if (spd<60) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<60%)
+ case 3: if (spd<70) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<70%)
+ case 4: if (spd<80) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<80%)
+ case 5: if (spd<90) gpu_unai.frameskip.skipFrame=true; else gpu_unai.frameskip.skipFrame=false; break; // frameskip on (spd<90%)
}
}
- fb_dirty=false;
-
- pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS);
-}
-
-#else
-
-#include "../../frontend/plugin_lib.h"
-
-extern "C" {
-
-static const struct rearmed_cbs *cbs;
-static s16 old_res_horz, old_res_vert, old_rgb24;
-
-static void blit(void)
-{
- u16 *base = (u16 *)GPU_FrameBuffer;
- s16 isRGB24 = (GPU_GP1 & 0x00200000) ? 1 : 0;
- s16 h0, x0, y0, w0, h1;
-
- x0 = DisplayArea[0] & ~1; // alignment needed by blitter
- y0 = DisplayArea[1];
- base += FRAME_OFFSET(x0, y0);
-
- w0 = DisplayArea[2];
- h0 = DisplayArea[3]; // video mode
-
- h1 = DisplayArea[5] - DisplayArea[4]; // display needed
- if (h0 == 480) h1 = Min2(h1*2,480);
-
- if (h1 <= 0)
- return;
-
- if (w0 != old_res_horz || h1 != old_res_vert || isRGB24 != old_rgb24)
- {
- old_res_horz = w0;
- old_res_vert = h1;
- old_rgb24 = (s16)isRGB24;
- cbs->pl_vout_set_mode(w0, h1, w0, h1, isRGB24 ? 24 : 16);
- }
-
- cbs->pl_vout_flip(base, 1024, isRGB24, w0, h1);
}
+///////////////////////////////////////////////////////////////////////////////
void GPU_updateLace(void)
{
// Interlace bit toggle
- GPU_GP1 ^= 0x80000000;
+ gpu_unai.GPU_GP1 ^= 0x80000000;
- if (!fb_dirty || (GPU_GP1&0x08800000))
- return;
-
- if (!wasSkip) {
- blit();
- fb_dirty = false;
- skCount = 0;
- }
- else {
- skCount++;
- if (skCount >= 8)
- wasSkip = isSkip = 0;
+ // Update display?
+ if ((gpu_unai.fb_dirty) && (!gpu_unai.frameskip.wasSkip) && (!(gpu_unai.GPU_GP1&0x00800000)))
+ {
+ // Display updated
+ gpuVideoOutput();
+ GPU_frameskip(true);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_updateLace(UPDATE)\n");
+ #endif
+ } else {
+ GPU_frameskip(false);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_updateLace(SKIP)\n");
+ #endif
}
- skipFrame = cbs->fskip_advice || cbs->frameskip == 1;
-}
+ if ((!gpu_unai.frameskip.skipCount) && (gpu_unai.DisplayArea[3] == 480)) gpu_unai.frameskip.skipGPU=true; // Tekken 3 hack
-long GPUopen(unsigned long *, char *, char *)
-{
- cbs->pl_vout_open();
- return 0;
+ gpu_unai.fb_dirty=false;
+ gpu_unai.dma.last_dma = NULL;
}
-long GPUclose(void)
+// Allows frontend to signal plugin to redraw screen after returning to emu
+void GPU_requestScreenRedraw()
{
- cbs->pl_vout_close();
- return 0;
+ gpu_unai.fb_dirty = true;
}
-long GPUfreeze(unsigned int ulGetFreezeData, GPUFreeze_t* p2)
+void GPU_getScreenInfo(GPUScreenInfo_t *sinfo)
{
- if (ulGetFreezeData > 1)
- return 0;
-
- return GPU_freeze(ulGetFreezeData, p2);
+ bool depth24 = (gpu_unai.GPU_GP1 & 0x00200000 ? true : false);
+ int16_t hres = (uint16_t)gpu_unai.DisplayArea[2];
+ int16_t vres = (uint16_t)gpu_unai.DisplayArea[3];
+ int16_t w = hres; // Original gpu_unai doesn't support width < 100%
+ int16_t h = gpu_unai.DisplayArea[5] - gpu_unai.DisplayArea[4];
+ if (vres == 480)
+ h *= 2;
+ if (h <= 0 || h > vres)
+ h = vres;
+
+ sinfo->vram = (uint8_t*)gpu_unai.vram;
+ sinfo->x = (uint16_t)gpu_unai.DisplayArea[0];
+ sinfo->y = (uint16_t)gpu_unai.DisplayArea[1];
+ sinfo->w = w;
+ sinfo->h = h;
+ sinfo->hres = hres;
+ sinfo->vres = vres;
+ sinfo->depth24 = depth24;
+ sinfo->pal = IS_PAL;
}
-
-void GPUrearmedCallbacks(const struct rearmed_cbs *cbs_)
-{
- enableAbbeyHack = cbs_->gpu_unai.abe_hack;
- light = !cbs_->gpu_unai.no_light;
- blend = !cbs_->gpu_unai.no_blend;
- if (cbs_->pl_vout_set_raw_vram)
- cbs_->pl_vout_set_raw_vram((void *)GPU_FrameBuffer);
-
- cbs = cbs_;
- if (cbs->pl_set_gpu_caps)
- cbs->pl_set_gpu_caps(0);
-}
-
-} /* extern "C" */
-
-#endif
diff --git a/plugins/gpu_unai/gpu.h b/plugins/gpu_unai/gpu.h
index 1811630..eade2a8 100644
--- a/plugins/gpu_unai/gpu.h
+++ b/plugins/gpu_unai/gpu.h
@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (C) 2010 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
* *
* 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 *
@@ -18,70 +19,52 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
***************************************************************************/
-#ifndef NEW_GPU_H
-#define NEW_GPU_H
+#ifndef GPU_UNAI_GPU_H
+#define GPU_UNAI_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))
+struct gpu_unai_config_t {
+ uint8_t pixel_skip:1; // If 1, allows skipping rendering pixels that
+ // would not be visible when a high horizontal
+ // resolution PS1 video mode is set.
+ // Only applies to devices with low resolutions
+ // like 320x240. Should not be used if a
+ // down-scaling framebuffer blitter is in use.
+ // Can cause gfx artifacts if game reads VRAM
+ // to do framebuffer effects.
-#define VIDEO_WIDTH 320
+ uint8_t ilace_force:3; // Option to force skipping rendering of lines,
+ // for very slow platforms. Value will be
+ // assigned to 'ilace_mask' in gpu_unai struct.
+ // Normally 0. Value '1' will skip rendering
+ // odd lines.
-typedef char s8;
-typedef signed short s16;
-typedef signed int s32;
-typedef signed long long s64;
+ uint8_t lighting:1;
+ uint8_t fast_lighting:1;
+ uint8_t blending:1;
+ uint8_t dithering:1;
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned int u32;
-typedef unsigned long long u64;
+ //senquack Only PCSX Rearmed's version of gpu_unai had this, and I
+ // don't think it's necessary. It would require adding 'AH' flag to
+ // gpuSpriteSpanFn() increasing size of sprite span function array.
+ //uint8_t enableAbbeyHack:1; // Abe's Odyssey hack
-#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];
- };
+ ////////////////////////////////////////////////////////////////////////////
+ // Variables used only by older standalone version of gpu_unai (gpu.cpp)
+#ifndef USE_GPULIB
+ uint8_t prog_ilace:1; // Progressive interlace option (old option)
+ // This option was somewhat oddly named:
+ // When in interlaced video mode, on a low-res
+ // 320x240 device, only the even lines are
+ // rendered. This option will take that one
+ // step further and only render half the even
+ // even lines one frame, and then the other half.
+ uint8_t frameskip_count:3; // Frame skip (0..7)
+#endif
};
-///////////////////////////////////////////////////////////////////////////////
-// Compile Options
+extern gpu_unai_config_t gpu_unai_config_ext;
-//#define ENABLE_GPU_NULL_SUPPORT // Enables NullGPU support
-//#define ENABLE_GPU_LOG_SUPPORT // Enables gpu logger, very slow only for windows debugging
+// TODO: clean up show_fps frontend option
+extern bool show_fps;
-///////////////////////////////////////////////////////////////////////////////
-#endif // NEW_GPU_H
+#endif // GPU_UNAI_GPU_H
diff --git a/plugins/gpu_unai/gpu_blit.h b/plugins/gpu_unai/gpu_blit.h
index 35cd056..e93f12f 100644
--- a/plugins/gpu_unai/gpu_blit.h
+++ b/plugins/gpu_unai/gpu_blit.h
@@ -32,10 +32,10 @@
///////////////////////////////////////////////////////////////////////////////
// GPU Blitting code with rescale and interlace support.
-INLINE void GPU_BlitWW(const void* src, u16* dst16, u32 isRGB24)
+INLINE void GPU_BlitWW(const void* src, u16* dst16, bool isRGB24)
{
u32 uCount;
- if(isRGB24 == 0)
+ if(!isRGB24)
{
#ifndef USE_BGR15
uCount = 20;
@@ -85,10 +85,10 @@ INLINE void GPU_BlitWW(const void* src, u16* dst16, u32 isRGB24)
}
}
-INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, u32 isRGB24)
+INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, bool isRGB24)
{
u32 uCount;
- if(isRGB24 == 0)
+ if(!isRGB24)
{
#ifndef USE_BGR15
uCount = 32;
@@ -145,10 +145,10 @@ INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, u32 isRGB24)
}
}
-INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, u32 isRGB24)
+INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, bool isRGB24)
{
u32 uCount;
- if(isRGB24 == 0)
+ if(!isRGB24)
{
#ifndef USE_BGR15
uCount = 32;
@@ -201,10 +201,10 @@ INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, u32 isRGB24)
}
}
-INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, u32 isRGB24, u32 uClip_src)
+INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, bool isRGB24, u32 uClip_src)
{
u32 uCount;
- if(isRGB24 == 0)
+ if(!isRGB24)
{
#ifndef USE_BGR15
uCount = 20;
@@ -274,10 +274,10 @@ INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, u32 isRGB24, u32 uCli
}
}
-INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, u32 isRGB24)
+INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, bool isRGB24)
{
u32 uCount;
- if(isRGB24 == 0)
+ if(!isRGB24)
{
#ifndef USE_BGR15
uCount = 32;
@@ -331,10 +331,10 @@ INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, u32 isRGB24)
}
-INLINE void GPU_BlitWS(const void* src, u16* dst16, u32 isRGB24)
+INLINE void GPU_BlitWS(const void* src, u16* dst16, bool isRGB24)
{
u32 uCount;
- if(isRGB24 == 0)
+ if(!isRGB24)
{
#ifndef USE_BGR15
uCount = 20;
diff --git a/plugins/gpu_unai/gpu_command.h b/plugins/gpu_unai/gpu_command.h
index d6e7a74..7096b75 100644
--- a/plugins/gpu_unai/gpu_command.h
+++ b/plugins/gpu_unai/gpu_command.h
@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (C) 2010 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
* *
* 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 *
@@ -19,34 +20,35 @@
***************************************************************************/
///////////////////////////////////////////////////////////////////////////////
-INLINE void gpuSetTexture(u16 tpage)
+void gpuSetTexture(u16 tpage)
{
- u32 tp;
- u32 tx, ty;
- GPU_GP1 = (GPU_GP1 & ~0x1FF) | (tpage & 0x1FF);
+ u32 tmode, tx, ty;
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x1FF) | (tpage & 0x1FF);
+ gpu_unai.TextureWindow[0]&= ~gpu_unai.TextureWindow[2];
+ gpu_unai.TextureWindow[1]&= ~gpu_unai.TextureWindow[3];
- TextureWindow[0]&= ~TextureWindow[2];
- TextureWindow[1]&= ~TextureWindow[3];
+ tmode = (tpage >> 7) & 3; // 16bpp, 8bpp, or 4bpp texture colors?
+ // 0: 4bpp 1: 8bpp 2/3: 16bpp
+
+ // Nocash PSX docs state setting of 3 is same as setting of 2 (16bpp):
+ // Note: DrHell assumes 3 is same as 0.. TODO: verify which is correct?
+ if (tmode == 3) tmode = 2;
- tp = (tpage >> 7) & 3;
tx = (tpage & 0x0F) << 6;
ty = (tpage & 0x10) << 4;
- if (tp == 3) tp = 2;
- tx += (TextureWindow[0] >> (2 - tp));
- ty += TextureWindow[1];
+ tx += (gpu_unai.TextureWindow[0] >> (2 - tmode));
+ ty += gpu_unai.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)];
-
+ gpu_unai.BLEND_MODE = ((tpage>>5) & 3) << 3;
+ gpu_unai.TEXT_MODE = (tmode + 1) << 5; // gpu_unai.TEXT_MODE should be values 1..3, so add one
+ gpu_unai.TBA = &((u16*)gpu_unai.vram)[FRAME_OFFSET(tx, ty)];
}
///////////////////////////////////////////////////////////////////////////////
INLINE void gpuSetCLUT(u16 clut)
{
- CBA = &((u16*)GPU_FrameBuffer)[(clut & 0x7FFF) << 4];
+ gpu_unai.CBA = &((u16*)gpu_unai.vram)[(clut & 0x7FFF) << 4];
}
#ifdef ENABLE_GPU_NULL_SUPPORT
@@ -61,159 +63,305 @@ INLINE void gpuSetCLUT(u16 clut)
#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))
+#define Blending (((PRIM&0x2) && BlendingEnabled()) ? (PRIM&0x2) : 0)
+#define Blending_Mode (((PRIM&0x2) && BlendingEnabled()) ? gpu_unai.BLEND_MODE : 0)
+#define Lighting (((~PRIM)&0x1) && LightingEnabled())
+// Dithering applies only to Gouraud-shaded polys or texture-blended polys:
+#define Dithering (((((~PRIM)&0x1) || (PRIM&0x10)) && DitheringEnabled()) ? \
+ (ForcedDitheringEnabled() ? (1<<9) : (gpu_unai.GPU_GP1 & (1 << 9))) \
+ : 0)
+
+///////////////////////////////////////////////////////////////////////////////
+//Now handled by Rearmed's gpulib and gpu_unai/gpulib_if.cpp:
+///////////////////////////////////////////////////////////////////////////////
+#ifndef USE_GPULIB
+
+// Handles GP0 draw settings commands 0xE1...0xE6
+static void gpuGP0Cmd_0xEx(gpu_unai_t &gpu_unai, u32 cmd_word)
+{
+ // Assume incoming GP0 command is 0xE1..0xE6, convert to 1..6
+ u8 num = (cmd_word >> 24) & 7;
+ switch (num) {
+ case 1: {
+ // GP0(E1h) - Draw Mode setting (aka "Texpage")
+ DO_LOG(("GP0(0xE1) DrawMode TexPage(0x%x)\n", cmd_word));
+ u32 cur_texpage = gpu_unai.GPU_GP1 & 0x7FF;
+ u32 new_texpage = cmd_word & 0x7FF;
+ if (cur_texpage != new_texpage) {
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x7FF) | new_texpage;
+ gpuSetTexture(gpu_unai.GPU_GP1);
+ }
+ } break;
+
+ case 2: {
+ // GP0(E2h) - Texture Window setting
+ DO_LOG(("GP0(0xE2) TextureWindow(0x%x)\n", cmd_word));
+ if (cmd_word != gpu_unai.TextureWindowCur) {
+ 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
+ };
+ gpu_unai.TextureWindowCur = cmd_word;
+ gpu_unai.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
+ gpu_unai.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
+ gpu_unai.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
+ gpu_unai.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
+ gpu_unai.TextureWindow[0] &= ~gpu_unai.TextureWindow[2];
+ gpu_unai.TextureWindow[1] &= ~gpu_unai.TextureWindow[3];
+
+ // Inner loop vars must be updated whenever texture window is changed:
+ const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
+ gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1);
+ gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+
+ gpuSetTexture(gpu_unai.GPU_GP1);
+ }
+ } break;
+
+ case 3: {
+ // GP0(E3h) - Set Drawing Area top left (X1,Y1)
+ DO_LOG(("GP0(0xE3) DrawingArea Pos(0x%x)\n", cmd_word));
+ gpu_unai.DrawingArea[0] = cmd_word & 0x3FF;
+ gpu_unai.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
+ } break;
+
+ case 4: {
+ // GP0(E4h) - Set Drawing Area bottom right (X2,Y2)
+ DO_LOG(("GP0(0xE4) DrawingArea Size(0x%x)\n", cmd_word));
+ gpu_unai.DrawingArea[2] = (cmd_word & 0x3FF) + 1;
+ gpu_unai.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
+ } break;
+
+ case 5: {
+ // GP0(E5h) - Set Drawing Offset (X,Y)
+ DO_LOG(("GP0(0xE5) DrawingOffset(0x%x)\n", cmd_word));
+ gpu_unai.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
+ gpu_unai.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
+ } break;
+
+ case 6: {
+ // GP0(E6h) - Mask Bit Setting
+ DO_LOG(("GP0(0xE6) SetMask(0x%x)\n", cmd_word));
+ gpu_unai.Masking = (cmd_word & 0x2) << 1;
+ gpu_unai.PixelMSB = (cmd_word & 0x1) << 8;
+ } break;
+ }
+}
void gpuSendPacketFunction(const int PRIM)
{
//printf("0x%x\n",PRIM);
+ //senquack - TODO: optimize this (packet pointer union as prim draw parameter
+ // introduced as optimization for gpulib command-list processing)
+ PtrUnion packet = { .ptr = (void*)&gpu_unai.PacketBuffer };
+
switch (PRIM)
{
- case 0x02:
+ case 0x02: {
NULL_GPU();
- gpuClearImage(); // prim handles updateLace && skip
+ gpuClearImage(packet); // prim handles updateLace && skip
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuClearImage(0x%x)\n",PRIM));
- break;
+ } break;
+
case 0x20:
case 0x21:
case 0x22:
- case 0x23:
- if (!isSkip)
+ case 0x23: { // Monochrome 3-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawF3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB]);
- DO_LOG(("gpuDrawF3(0x%x)\n",PRIM));
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyF(packet, driver, false);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyF(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x24:
case 0x25:
case 0x26:
- case 0x27:
- if (!isSkip)
+ case 0x27: { // Textured 3-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
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));
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture (gpu_unai.PacketBuffer.U4[4] >> 16);
+
+ u32 driver_idx =
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
+
+ if (!FastLightingEnabled()) {
+ driver_idx |= Lighting;
+ } else {
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
+ driver_idx |= Lighting;
+ }
+
+ PP driver = gpuPolySpanDrivers[driver_idx];
+ gpuDrawPolyFT(packet, driver, false);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyFT(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x28:
case 0x29:
case 0x2A:
- case 0x2B:
- if (!isSkip)
+ case 0x2B: { // Monochrome 4-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
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));
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyF(packet, driver, true); // is_quad = true
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyF(0x%x) (4-pt QUAD)\n",PRIM));
}
- break;
+ } break;
+
case 0x2C:
case 0x2D:
case 0x2E:
- case 0x2F:
- if (!isSkip)
+ case 0x2F: { // Textured 4-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
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));
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture (gpu_unai.PacketBuffer.U4[4] >> 16);
+
+ u32 driver_idx =
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
+
+ if (!FastLightingEnabled()) {
+ driver_idx |= Lighting;
+ } else {
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
+ driver_idx |= Lighting;
+ }
+
+ PP driver = gpuPolySpanDrivers[driver_idx];
+ gpuDrawPolyFT(packet, driver, true); // is_quad = true
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyFT(0x%x) (4-pt QUAD)\n",PRIM));
}
- break;
+ } break;
+
case 0x30:
case 0x31:
case 0x32:
- case 0x33:
- if (!isSkip)
+ case 0x33: { // Gouraud-shaded 3-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawG3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB]);
- DO_LOG(("gpuDrawG3(0x%x)\n",PRIM));
+ //NOTE: The '129' here is CF_GOURAUD | CF_LIGHT, however
+ // this is an untextured poly, so CF_LIGHT (texture blend)
+ // shouldn't apply. Until the original array of template
+ // instantiation ptrs is fixed, we're stuck with this. (TODO)
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyG(packet, driver, false);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyG(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x34:
case 0x35:
case 0x36:
- case 0x37:
- if (!isSkip)
+ case 0x37: { // Gouraud-shaded, textured 3-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
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));
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture (gpu_unai.PacketBuffer.U4[5] >> 16);
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyGT(packet, driver, false);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyGT(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x38:
case 0x39:
case 0x3A:
- case 0x3B:
- if (!isSkip)
+ case 0x3B: { // Gouraud-shaded 4-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
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));
+ // See notes regarding '129' for 0x30..0x33 further above -senquack
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyG(packet, driver, true); // is_quad = true
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyG(0x%x) (4-pt QUAD)\n",PRIM));
}
- break;
+ } break;
+
case 0x3C:
case 0x3D:
case 0x3E:
- case 0x3F:
- if (!isSkip)
+ case 0x3F: { // Gouraud-shaded, textured 4-pt poly
+ if (!gpu_unai.frameskip.skipGPU)
{
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));
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture (gpu_unai.PacketBuffer.U4[5] >> 16);
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyGT(packet, driver, true); // is_quad = true
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawPolyGT(0x%x) (4-pt QUAD)\n",PRIM));
}
- break;
+ } break;
+
case 0x40:
case 0x41:
case 0x42:
- case 0x43:
- if (!isSkip)
+ case 0x43: { // Monochrome line
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
- DO_LOG(("gpuDrawLF(0x%x)\n",PRIM));
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineF(packet, driver);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawLineF(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x48:
case 0x49:
case 0x4A:
@@ -221,32 +369,44 @@ void gpuSendPacketFunction(const int PRIM)
case 0x4C:
case 0x4D:
case 0x4E:
- case 0x4F:
- if (!isSkip)
+ case 0x4F: { // Monochrome line strip
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
- DO_LOG(("gpuDrawLF(0x%x)\n",PRIM));
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineF(packet, driver);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawLineF(0x%x)\n",PRIM));
}
- if ((PacketBuffer.U4[3] & 0xF000F000) != 0x50005000)
+ if ((gpu_unai.PacketBuffer.U4[3] & 0xF000F000) != 0x50005000)
{
- PacketBuffer.U4[1] = PacketBuffer.U4[2];
- PacketBuffer.U4[2] = PacketBuffer.U4[3];
- PacketCount = 1;
- PacketIndex = 3;
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[2] = gpu_unai.PacketBuffer.U4[3];
+ gpu_unai.PacketCount = 1;
+ gpu_unai.PacketIndex = 3;
}
- break;
+ } break;
+
case 0x50:
case 0x51:
case 0x52:
- case 0x53:
- if (!isSkip)
+ case 0x53: { // Gouraud-shaded line
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
- DO_LOG(("gpuDrawLG(0x%x)\n",PRIM));
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ // Index MSB selects Gouraud-shaded PixelSpanDriver:
+ driver_idx |= (1 << 5);
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineG(packet, driver);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawLineG(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x58:
case 0x59:
case 0x5A:
@@ -254,204 +414,203 @@ void gpuSendPacketFunction(const int PRIM)
case 0x5C:
case 0x5D:
case 0x5E:
- case 0x5F:
- if (!isSkip)
+ case 0x5F: { // Gouraud-shaded line strip
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
- DO_LOG(("gpuDrawLG(0x%x)\n",PRIM));
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ // Index MSB selects Gouraud-shaded PixelSpanDriver:
+ driver_idx |= (1 << 5);
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineG(packet, driver);
+ gpu_unai.fb_dirty = true;
+ DO_LOG(("gpuDrawLineG(0x%x)\n",PRIM));
}
- if ((PacketBuffer.U4[4] & 0xF000F000) != 0x50005000)
+ if ((gpu_unai.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;
+ gpu_unai.PacketBuffer.U1[3 + (2 * 4)] = gpu_unai.PacketBuffer.U1[3 + (0 * 4)];
+ gpu_unai.PacketBuffer.U4[0] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[3];
+ gpu_unai.PacketBuffer.U4[2] = gpu_unai.PacketBuffer.U4[4];
+ gpu_unai.PacketCount = 2;
+ gpu_unai.PacketIndex = 3;
}
- break;
+ } break;
+
case 0x60:
case 0x61:
case 0x62:
- case 0x63:
- if (!isSkip)
+ case 0x63: { // Monochrome rectangle (variable size)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x64:
case 0x65:
case 0x66:
- case 0x67:
- if (!isSkip)
+ case 0x67: { // Textured rectangle (variable size)
+ if (!gpu_unai.frameskip.skipGPU)
{
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]);
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
+
+ // This fixes Silent Hill running animation on loading screens:
+ // (On PSX, color values 0x00-0x7F darken the source texture's color,
+ // 0x81-FF lighten textures (ultimately clamped to 0x1F),
+ // 0x80 leaves source texture color unchanged, HOWEVER,
+ // gpu_unai uses a simple lighting LUT whereby only the upper
+ // 5 bits of an 8-bit color are used, so 0x80-0x87 all behave as
+ // 0x80.
+ //
+ // NOTE: I've changed all textured sprite draw commands here and
+ // elsewhere to use proper behavior, but left poly commands
+ // alone, I don't want to slow rendering down too much. (TODO)
+ //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
+ // Strip lower 3 bits of each color and determine if lighting should be used:
+ if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ driver_idx |= Lighting;
+ PS driver = gpuSpriteSpanDrivers[driver_idx];
+ gpuDrawS(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x68:
case 0x69:
case 0x6A:
- case 0x6B:
- if (!isSkip)
+ case 0x6B: { // Monochrome rectangle (1x1 dot)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- PacketBuffer.U4[2] = 0x00010001;
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
+ gpu_unai.PacketBuffer.U4[2] = 0x00010001;
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x70:
case 0x71:
case 0x72:
- case 0x73:
- if (!isSkip)
+ case 0x73: { // Monochrome rectangle (8x8)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- PacketBuffer.U4[2] = 0x00080008;
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
+ gpu_unai.PacketBuffer.U4[2] = 0x00080008;
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x74:
case 0x75:
case 0x76:
- case 0x77:
- if (!isSkip)
+ case 0x77: { // Textured rectangle (8x8)
+ if (!gpu_unai.frameskip.skipGPU)
{
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]);
+ gpu_unai.PacketBuffer.U4[3] = 0x00080008;
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
+
+ //senquack - Only color 808080h-878787h allows skipping lighting calculation:
+ //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
+ // Strip lower 3 bits of each color and determine if lighting should be used:
+ if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ driver_idx |= Lighting;
+ PS driver = gpuSpriteSpanDrivers[driver_idx];
+ gpuDrawS(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x78:
case 0x79:
case 0x7A:
- case 0x7B:
- if (!isSkip)
+ case 0x7B: { // Monochrome rectangle (16x16)
+ if (!gpu_unai.frameskip.skipGPU)
{
NULL_GPU();
- PacketBuffer.U4[2] = 0x00100010;
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
+ gpu_unai.PacketBuffer.U4[2] = 0x00100010;
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawT(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x7C:
case 0x7D:
-#ifdef __arm__
- if ((GPU_GP1 & 0x180) == 0 && (Masking | PixelMSB) == 0)
+ #ifdef __arm__
+ /* Notaz 4bit sprites optimization */
+ if ((!gpu_unai.frameskip.skipGPU) && (!(gpu_unai.GPU_GP1&0x180)) && (!(gpu_unai.Masking|gpu_unai.PixelMSB)))
{
- gpuSetCLUT (PacketBuffer.U4[2] >> 16);
- gpuSetTexture (GPU_GP1);
- gpuDrawS16();
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuDrawS16(packet);
+ gpu_unai.fb_dirty = true;
break;
}
- // fallthrough
-#endif
+ #endif
case 0x7E:
- case 0x7F:
- if (!isSkip)
+ case 0x7F: { // Textured rectangle (16x16)
+ if (!gpu_unai.frameskip.skipGPU)
{
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]);
+ gpu_unai.PacketBuffer.U4[3] = 0x00100010;
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
+
+ //senquack - Only color 808080h-878787h allows skipping lighting calculation:
+ //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
+ // Strip lower 3 bits of each color and determine if lighting should be used:
+ if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ driver_idx |= Lighting;
+ PS driver = gpuSpriteSpanDrivers[driver_idx];
+ gpuDrawS(packet, driver);
+ gpu_unai.fb_dirty = true;
DO_LOG(("gpuDrawS(0x%x)\n",PRIM));
}
- break;
+ } break;
+
case 0x80: // vid -> vid
- gpuMoveImage(); // prim handles updateLace && skip
+ gpuMoveImage(packet); // prim handles updateLace && skip
+ if ((!gpu_unai.frameskip.skipCount) && (gpu_unai.DisplayArea[3] == 480)) // Tekken 3 hack
+ {
+ if (!gpu_unai.frameskip.skipGPU) gpu_unai.fb_dirty = true;
+ }
+ else
+ {
+ gpu_unai.fb_dirty = true;
+ }
DO_LOG(("gpuMoveImage(0x%x)\n",PRIM));
break;
case 0xA0: // sys ->vid
- gpuLoadImage(); // prim handles updateLace && skip
-#ifndef isSkip // not a define
- if (alt_fps) isSkip=false;
-#endif
+ gpuLoadImage(packet); // prim handles updateLace && skip
DO_LOG(("gpuLoadImage(0x%x)\n",PRIM));
break;
case 0xC0: // vid -> sys
- gpuStoreImage(); // prim handles updateLace && skip
+ gpuStoreImage(packet); // prim handles updateLace && skip
DO_LOG(("gpuStoreImage(0x%x)\n",PRIM));
break;
- case 0xE1:
- {
- const u32 temp = PacketBuffer.U4[0];
- GPU_GP1 = (GPU_GP1 & ~0x000007FF) | (temp & 0x000007FF);
- gpuSetTexture(temp);
- DO_LOG(("gpuSetTexture(0x%x)\n",PRIM));
- }
- break;
- case 0xE2:
- {
- static const u8 TextureMask[32] = {
- 255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7, //
- 127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7 //
- };
- const u32 temp = PacketBuffer.U4[0];
- TextureWindow[0] = ((temp >> 10) & 0x1F) << 3;
- TextureWindow[1] = ((temp >> 15) & 0x1F) << 3;
- TextureWindow[2] = TextureMask[(temp >> 0) & 0x1F];
- TextureWindow[3] = TextureMask[(temp >> 5) & 0x1F];
- gpuSetTexture(GPU_GP1);
- //isSkip = false;
- DO_LOG(("TextureWindow(0x%x)\n",PRIM));
- }
- break;
- case 0xE3:
- {
- const u32 temp = PacketBuffer.U4[0];
- DrawingArea[0] = temp & 0x3FF;
- DrawingArea[1] = (temp >> 10) & 0x3FF;
- //isSkip = false;
- DO_LOG(("DrawingArea_Pos(0x%x)\n",PRIM));
- }
- break;
- case 0xE4:
- {
- const u32 temp = PacketBuffer.U4[0];
- DrawingArea[2] = (temp & 0x3FF) + 1;
- DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1;
- //isSkip = false;
- DO_LOG(("DrawingArea_Size(0x%x)\n",PRIM));
- }
- break;
- case 0xE5:
- {
- const u32 temp = PacketBuffer.U4[0];
- DrawingOffset[0] = ((s32)temp<<(32-11))>>(32-11);
- DrawingOffset[1] = ((s32)temp<<(32-22))>>(32-11);
- //isSkip = false;
- DO_LOG(("DrawingOffset(0x%x)\n",PRIM));
- }
- break;
- case 0xE6:
- {
- const u32 temp = PacketBuffer.U4[0];
- //GPU_GP1 = (GPU_GP1 & ~0x00001800) | ((temp&3) << 11);
- Masking = (temp & 0x2) << 1;
- PixelMSB =(temp & 0x1) << 8;
- DO_LOG(("SetMask(0x%x)\n",PRIM));
- }
- break;
+ case 0xE1 ... 0xE6: { // Draw settings
+ gpuGP0Cmd_0xEx(gpu_unai, gpu_unai.PacketBuffer.U4[0]);
+ } break;
}
}
+#endif //!USE_GPULIB
+///////////////////////////////////////////////////////////////////////////////
+// End of code specific to non-gpulib standalone version of gpu_unai
+///////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gpu_unai/gpu_fixedpoint.h b/plugins/gpu_unai/gpu_fixedpoint.h
index e72fda1..5df42cf 100644
--- a/plugins/gpu_unai/gpu_fixedpoint.h
+++ b/plugins/gpu_unai/gpu_fixedpoint.h
@@ -21,60 +21,73 @@
#ifndef FIXED_H
#define FIXED_H
-#include "arm_features.h"
-
typedef s32 fixed;
-#ifdef GPU_TABLE_10_BITS
-#define TABLE_BITS 10
-#else
-#define TABLE_BITS 16
-#endif
-
-#define FIXED_BITS 16
+//senquack - The gpu_drhell poly routines I adapted use 22.10 fixed point,
+// while original Unai used 16.16: (see README_senquack.txt)
+//#define FIXED_BITS 16
+#define FIXED_BITS 10
#define fixed_ZERO ((fixed)0)
#define fixed_ONE ((fixed)1<<FIXED_BITS)
#define fixed_TWO ((fixed)2<<FIXED_BITS)
#define fixed_HALF ((fixed)((1<<FIXED_BITS)>>1))
-// big precision inverse table.
-s32 s_invTable[(1<<TABLE_BITS)];
+#define fixed_LOMASK ((fixed)((1<<FIXED_BITS)-1))
+#define fixed_HIMASK ((fixed)(~fixed_LOMASK))
+
+// int<->fixed conversions:
+#define i2x(x) ((x)<<FIXED_BITS)
+#define x2i(x) ((x)>>FIXED_BITS)
+
+INLINE fixed FixedCeil(const fixed x)
+{
+ return (x + (fixed_ONE - 1)) & fixed_HIMASK;
+}
-INLINE fixed i2x(const int _x) { return ((_x)<<FIXED_BITS); }
-INLINE fixed x2i(const fixed _x) { return ((_x)>>FIXED_BITS); }
+INLINE s32 FixedCeilToInt(const fixed x)
+{
+ return (x + (fixed_ONE - 1)) >> FIXED_BITS;
+}
-/*
-INLINE u32 Log2(u32 _a)
+//senquack - float<->fixed conversions:
+#define f2x(x) ((s32)((x) * (float)(1<<FIXED_BITS)))
+#define x2f(x) ((float)(x) / (float)(1<<FIXED_BITS))
+
+//senquack - floating point reciprocal:
+//NOTE: These assume x is always != 0 !!!
+#ifdef GPU_UNAI_USE_FLOATMATH
+#if defined(_MIPS_ARCH_MIPS32R2) || (__mips == 64)
+INLINE float FloatInv(const float x)
+{
+ float res;
+ asm("recip.s %0,%1" : "=f" (res) : "f" (x));
+ return res;
+}
+#else
+INLINE float FloatInv(const float x)
{
- 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;
+ return (1.0f / x);
}
-*/
+#endif
+#endif
-#ifdef HAVE_ARMV5
+///////////////////////////////////////////////////////////////////////////
+// --- BEGIN INVERSE APPROXIMATION SECTION ---
+///////////////////////////////////////////////////////////////////////////
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+
+// big precision inverse table.
+#define TABLE_BITS 16
+s32 s_invTable[(1<<TABLE_BITS)];
+
+//senquack - MIPS32 happens to have same instruction/format:
+#if defined(__arm__) || (__mips == 32)
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;
@@ -82,10 +95,12 @@ INLINE void xInv (const fixed _b, s32& iFactor_, s32& iShift_)
{
u32 uLog = Log2(uD);
uLog = uLog>(TABLE_BITS-1) ? uLog-(TABLE_BITS-1) : 0;
- u32 uDen = (uD>>uLog)-1;
+ u32 uDen = (uD>>uLog);
iFactor_ = s_invTable[uDen];
iFactor_ = (_b<0) ? -iFactor_ :iFactor_;
- iShift_ = 15+uLog;
+ //senquack - Adapted to 22.10 fixed point (originally 16.16):
+ //iShift_ = 15+uLog;
+ iShift_ = 21+uLog;
}
else
{
@@ -93,7 +108,6 @@ INLINE void xInv (const fixed _b, s32& iFactor_, s32& iShift_)
iShift_ = 0;
}
}
-#endif
INLINE fixed xInvMulx (const fixed _a, const s32 _iFact, const s32 _iShift)
{
@@ -112,20 +126,9 @@ INLINE fixed xLoDivx (const fixed _a, const fixed _b)
xInv(_b, iFact, iShift);
return xInvMulx(_a, iFact, iShift);
}
-
+#endif // GPU_UNAI_USE_INT_DIV_MULTINV
///////////////////////////////////////////////////////////////////////////
-template<typename T>
-INLINE T Min2 (const T _a, const T _b) { return (_a<_b)?_a:_b; }
-
-template<typename T>
-INLINE T Min3 (const T _a, const T _b, const T _c) { return Min2(Min2(_a,_b),_c); }
-
+// --- END INVERSE APPROXIMATION SECTION ---
///////////////////////////////////////////////////////////////////////////
-template<typename T>
-INLINE T Max2 (const T _a, const T _b) { return (_a>_b)?_a:_b; }
-template<typename T>
-INLINE T Max3 (const T _a, const T _b, const T _c) { return Max2(Max2(_a,_b),_c); }
-
-///////////////////////////////////////////////////////////////////////////
#endif //FIXED_H
diff --git a/plugins/gpu_unai/gpu_inner.h b/plugins/gpu_unai/gpu_inner.h
index 4cd7bff..723e09f 100644
--- a/plugins/gpu_unai/gpu_inner.h
+++ b/plugins/gpu_unai/gpu_inner.h
@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (C) 2010 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
* *
* 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 *
@@ -19,415 +20,688 @@
***************************************************************************/
///////////////////////////////////////////////////////////////////////////////
-// Inner loop driver instanciation file
+// Inner loop driver instantiation 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)
+// Option Masks (CF template paramter)
+#define CF_LIGHT ((CF>> 0)&1) // Lighting
+#define CF_BLEND ((CF>> 1)&1) // Blending
+#define CF_MASKCHECK ((CF>> 2)&1) // Mask bit check
+#define CF_BLENDMODE ((CF>> 3)&3) // Blend mode 0..3
+#define CF_TEXTMODE ((CF>> 5)&3) // Texture mode 1..3 (0: texturing disabled)
+#define CF_GOURAUD ((CF>> 7)&1) // Gouraud shading
+#define CF_MASKSET ((CF>> 8)&1) // Mask bit set
+#define CF_DITHER ((CF>> 9)&1) // Dithering
+#define CF_BLITMASK ((CF>>10)&1) // blit_mask check (skip rendering pixels
+ // that wouldn't end up displayed on
+ // low-res screen using simple downscaler)
-#define AH ((CF>>7)&1)
-
-#define MB ((CF>>8)&1)
+//#ifdef __arm__
+//#ifndef ENABLE_GPU_ARMV7
+/* ARMv5 */
+//#include "gpu_inner_blend_arm5.h"
+//#else
+/* ARMv7 optimized */
+//#include "gpu_inner_blend_arm7.h"
+//#endif
+//#else
+//#include "gpu_inner_blend.h"
+//#endif
+// TODO: use the arm-optimized gpu_inner_blends for arm builds
#include "gpu_inner_blend.h"
+
+#include "gpu_inner_quantization.h"
#include "gpu_inner_light.h"
+// If defined, Gouraud colors are fixed-point 5.11, otherwise they are 8.16
+// This is only for debugging/verification of low-precision colors in C.
+// Low-precision Gouraud is intended for use by SIMD-optimized inner drivers
+// which get/use Gouraud colors in SIMD registers.
+//#define GPU_GOURAUD_LOW_PRECISION
+
+// How many bits of fixed-point precision GouraudColor uses
+#ifdef GPU_GOURAUD_LOW_PRECISION
+#define GPU_GOURAUD_FIXED_BITS 11
+#else
+#define GPU_GOURAUD_FIXED_BITS 16
+#endif
+
+// Used to pass Gouraud colors to gpuPixelSpanFn() (lines)
+struct GouraudColor {
+#ifdef GPU_GOURAUD_LOW_PRECISION
+ u16 r, g, b;
+ s16 r_incr, g_incr, b_incr;
+#else
+ u32 r, g, b;
+ s32 r_incr, g_incr, b_incr;
+#endif
+};
+
+static inline u16 gpuGouraudColor15bpp(u32 r, u32 g, u32 b)
+{
+ r >>= GPU_GOURAUD_FIXED_BITS;
+ g >>= GPU_GOURAUD_FIXED_BITS;
+ b >>= GPU_GOURAUD_FIXED_BITS;
+
+#ifndef GPU_GOURAUD_LOW_PRECISION
+ // High-precision Gouraud colors are 8-bit + fractional
+ r >>= 3; g >>= 3; b >>= 3;
+#endif
+
+ return r | (g << 5) | (b << 10);
+}
+
///////////////////////////////////////////////////////////////////////////////
-// GPU Pixel opperations generator
-template<const int CF>
-INLINE void gpuPixelFn(u16 *pixel,const u16 data)
+// GPU Pixel span operations generator gpuPixelSpanFn<>
+// Oct 2016: Created/adapted from old gpuPixelFn by senquack:
+// Original gpuPixelFn was used to draw lines one pixel at a time. I wrote
+// new line algorithms that draw lines using horizontal/vertical/diagonal
+// spans of pixels, necessitating new pixel-drawing function that could
+// not only render spans of pixels, but gouraud-shade them as well.
+// This speeds up line rendering and would allow tile-rendering (untextured
+// rectangles) to use the same set of functions. Since tiles are always
+// monochrome, they simply wouldn't use the extra set of 32 gouraud-shaded
+// gpuPixelSpanFn functions (TODO?).
+//
+// NOTE: While the PS1 framebuffer is 16 bit, we use 8-bit pointers here,
+// so that pDst can be incremented directly by 'incr' parameter
+// without having to shift it before use.
+template<int CF>
+static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len)
{
- if ((!M)&&(!B))
- {
- if(MB) { *pixel = data | 0x8000; }
- else { *pixel = data; }
+ // Blend func can save an operation if it knows uSrc MSB is
+ // unset. For untextured prims, this is always true.
+ const bool skip_uSrc_mask = true;
+
+ u16 col;
+ struct GouraudColor * gcPtr;
+ u32 r, g, b;
+ s32 r_incr, g_incr, b_incr;
+
+ if (CF_GOURAUD) {
+ gcPtr = (GouraudColor*)data;
+ r = gcPtr->r; r_incr = gcPtr->r_incr;
+ g = gcPtr->g; g_incr = gcPtr->g_incr;
+ b = gcPtr->b; b_incr = gcPtr->b_incr;
+ } else {
+ col = (u16)data;
}
- else if ((M)&&(!B))
- {
- if (!(*pixel&0x8000))
- {
- if(MB) { *pixel = data | 0x8000; }
- else { *pixel = data; }
+
+ do {
+ if (!CF_GOURAUD)
+ { // NO GOURAUD
+ if (!CF_MASKCHECK && !CF_BLEND) {
+ if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
+ else { *(u16*)pDst = col; }
+ } else if (CF_MASKCHECK && !CF_BLEND) {
+ if (!(*(u16*)pDst & 0x8000)) {
+ if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
+ else { *(u16*)pDst = col; }
+ }
+ } else {
+ u16 uDst = *(u16*)pDst;
+ if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; }
+
+ u16 uSrc = col;
+
+ if (CF_BLEND)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
+
+ if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; }
+ else { *(u16*)pDst = uSrc; }
+ }
+
+ } else
+ { // GOURAUD
+
+ if (!CF_MASKCHECK && !CF_BLEND) {
+ col = gpuGouraudColor15bpp(r, g, b);
+ if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
+ else { *(u16*)pDst = col; }
+ } else if (CF_MASKCHECK && !CF_BLEND) {
+ col = gpuGouraudColor15bpp(r, g, b);
+ if (!(*(u16*)pDst & 0x8000)) {
+ if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; }
+ else { *(u16*)pDst = col; }
+ }
+ } else {
+ u16 uDst = *(u16*)pDst;
+ if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; }
+ col = gpuGouraudColor15bpp(r, g, b);
+
+ u16 uSrc = col;
+
+ // Blend func can save an operation if it knows uSrc MSB is
+ // unset. For untextured prims, this is always true.
+ const bool skip_uSrc_mask = true;
+
+ if (CF_BLEND)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
+
+ if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; }
+ else { *(u16*)pDst = uSrc; }
+ }
}
+
+endpixel:
+ if (CF_GOURAUD) {
+ r += r_incr;
+ g += g_incr;
+ b += b_incr;
+ }
+ pDst += incr;
+ } while (len-- > 1);
+
+ // Note from senquack: Normally, I'd prefer to write a 'do {} while (--len)'
+ // loop, or even a for() loop, however, on MIPS platforms anything but the
+ // 'do {} while (len-- > 1)' tends to generate very unoptimal asm, with
+ // many unneeded MULs/ADDs/branches at the ends of these functions.
+ // If you change the loop structure above, be sure to compare the quality
+ // of the generated code!!
+
+ if (CF_GOURAUD) {
+ gcPtr->r = r;
+ gcPtr->g = g;
+ gcPtr->b = b;
}
- 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; }
- }
+ return pDst;
+}
+
+static u8* PixelSpanNULL(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"PixelSpanNULL()\n");
+ #endif
+ return pDst;
}
-///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-// 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
+// PixelSpan (lines) innerloops driver
+typedef u8* (*PSD)(u8* dst, uintptr_t data, ptrdiff_t incr, size_t len);
+
+const PSD gpuPixelSpanDrivers[64] =
{
- 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>
+ // Array index | 'CF' template field | Field value
+ // ------------+---------------------+----------------
+ // Bit 0 | CF_BLEND | off (0), on (1)
+ // Bit 1 | CF_MASKCHECK | off (0), on (1)
+ // Bit 3:2 | CF_BLENDMODE | 0..3
+ // Bit 4 | CF_MASKSET | off (0), on (1)
+ // Bit 5 | CF_GOURAUD | off (0), on (1)
+ //
+ // NULL entries are ones for which blending is disabled and blend-mode
+ // field is non-zero, which is obviously invalid.
+
+ // Flat-shaded
+ gpuPixelSpanFn<0x00<<1>, gpuPixelSpanFn<0x01<<1>, gpuPixelSpanFn<0x02<<1>, gpuPixelSpanFn<0x03<<1>,
+ PixelSpanNULL, gpuPixelSpanFn<0x05<<1>, PixelSpanNULL, gpuPixelSpanFn<0x07<<1>,
+ PixelSpanNULL, gpuPixelSpanFn<0x09<<1>, PixelSpanNULL, gpuPixelSpanFn<0x0B<<1>,
+ PixelSpanNULL, gpuPixelSpanFn<0x0D<<1>, PixelSpanNULL, gpuPixelSpanFn<0x0F<<1>,
+
+ // Flat-shaded + PixelMSB (CF_MASKSET)
+ gpuPixelSpanFn<(0x00<<1)|0x100>, gpuPixelSpanFn<(0x01<<1)|0x100>, gpuPixelSpanFn<(0x02<<1)|0x100>, gpuPixelSpanFn<(0x03<<1)|0x100>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x05<<1)|0x100>, PixelSpanNULL, gpuPixelSpanFn<(0x07<<1)|0x100>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x09<<1)|0x100>, PixelSpanNULL, gpuPixelSpanFn<(0x0B<<1)|0x100>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x0D<<1)|0x100>, PixelSpanNULL, gpuPixelSpanFn<(0x0F<<1)|0x100>,
+
+ // Gouraud-shaded (CF_GOURAUD)
+ gpuPixelSpanFn<(0x00<<1)|0x80>, gpuPixelSpanFn<(0x01<<1)|0x80>, gpuPixelSpanFn<(0x02<<1)|0x80>, gpuPixelSpanFn<(0x03<<1)|0x80>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x05<<1)|0x80>, PixelSpanNULL, gpuPixelSpanFn<(0x07<<1)|0x80>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x09<<1)|0x80>, PixelSpanNULL, gpuPixelSpanFn<(0x0B<<1)|0x80>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x0D<<1)|0x80>, PixelSpanNULL, gpuPixelSpanFn<(0x0F<<1)|0x80>,
+
+ // Gouraud-shaded (CF_GOURAUD) + PixelMSB (CF_MASKSET)
+ gpuPixelSpanFn<(0x00<<1)|0x180>, gpuPixelSpanFn<(0x01<<1)|0x180>, gpuPixelSpanFn<(0x02<<1)|0x180>, gpuPixelSpanFn<(0x03<<1)|0x180>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x05<<1)|0x180>, PixelSpanNULL, gpuPixelSpanFn<(0x07<<1)|0x180>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x09<<1)|0x180>, PixelSpanNULL, gpuPixelSpanFn<(0x0B<<1)|0x180>,
+ PixelSpanNULL, gpuPixelSpanFn<(0x0D<<1)|0x180>, PixelSpanNULL, gpuPixelSpanFn<(0x0F<<1)|0x180>
};
///////////////////////////////////////////////////////////////////////////////
// GPU Tiles innerloops generator
-template<const int CF>
-INLINE void gpuTileSpanFn(u16 *pDst, u32 count, u16 data)
+template<int CF>
+static void gpuTileSpanFn(u16 *pDst, u32 count, u16 data)
{
- if ((!M)&&(!B))
- {
- if (MB) { data = data | 0x8000; }
+ if (!CF_MASKCHECK && !CF_BLEND) {
+ if (CF_MASKSET) { data = data | 0x8000; }
do { *pDst++ = data; } while (--count);
- }
- else if ((M)&&(!B))
- {
- if (MB) { data = data | 0x8000; }
+ } else if (CF_MASKCHECK && !CF_BLEND) {
+ if (CF_MASKSET) { data = data | 0x8000; }
do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count);
- }
- else
+ } else
{
- u16 uSrc;
- u16 uDst;
- u32 uMsk; if (BM==0) uMsk=0x7BDE;
+ // Blend func can save an operation if it knows uSrc MSB is
+ // unset. For untextured prims, this is always true.
+ const bool skip_uSrc_mask = true;
+
+ u16 uSrc, uDst;
do
{
- // MASKING
- uDst = *pDst;
- if(M) { if (uDst&0x8000) goto endtile; }
+ if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
+ if (CF_MASKCHECK) { 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 (CF_BLEND)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (MB) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
- endtile: pDst++;
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else { *pDst = uSrc; }
+
+ //senquack - Did not apply "Silent Hill" mask-bit fix to here.
+ // It is hard to tell from scarce documentation available and
+ // lack of comments in code, but I believe the tile-span
+ // functions here should not bother to preserve any source MSB,
+ // as they are not drawing from a texture.
+endtile:
+ pDst++;
}
while (--count);
}
}
+static void TileNULL(u16 *pDst, u32 count, u16 data)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"TileNULL()\n");
+ #endif
+}
+
///////////////////////////////////////////////////////////////////////////////
// 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,
+// Template instantiation helper macros
+#define TI(cf) gpuTileSpanFn<(cf)>
+#define TN TileNULL
+#define TIBLOCK(ub) \
+ TI((ub)|0x00), TI((ub)|0x02), TI((ub)|0x04), TI((ub)|0x06), \
+ TN, TI((ub)|0x0a), TN, TI((ub)|0x0e), \
+ TN, TI((ub)|0x12), TN, TI((ub)|0x16), \
+ TN, TI((ub)|0x1a), TN, TI((ub)|0x1e)
+
+const PT gpuTileSpanDrivers[32] = {
+ TIBLOCK(0<<8), TIBLOCK(1<<8)
};
+#undef TI
+#undef TN
+#undef TIBLOCK
+
+
///////////////////////////////////////////////////////////////////////////////
// GPU Sprites innerloops generator
-template<const int CF>
-INLINE void gpuSpriteSpanFn(u16 *pDst, u32 count, u32 u0, const u32 mask)
+template<int CF>
+static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0)
{
- 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;
+ // Blend func can save an operation if it knows uSrc MSB is unset.
+ // Untextured prims can always skip (source color always comes with MSB=0).
+ // For textured prims, lighting funcs always return it unset. (bonus!)
+ const bool skip_uSrc_mask = (!CF_TEXTMODE) || CF_LIGHT;
+
+ u16 uSrc, uDst, srcMSB;
+ u32 u0_mask = gpu_unai.TextureWindow[2];
+
+ u8 r5, g5, b5;
+ if (CF_LIGHT) {
+ r5 = gpu_unai.r5;
+ g5 = gpu_unai.g5;
+ b5 = gpu_unai.b5;
+ }
+
+ if (CF_TEXTMODE==3) {
+ // Texture is accessed byte-wise, so adjust mask if 16bpp
+ u0_mask <<= 1;
+ }
+
+ const u16 *CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.CBA;
do
{
- // MASKING
- if(M) { uDst = *pDst; if (uDst&0x8000) { u0=(u0+1)&mask; goto endsprite; } }
+ if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
+ if (CF_MASKCHECK) if (uDst&0x8000) { 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); }
- }
+ if (CF_TEXTMODE==1) { // 4bpp (CLUT)
+ u8 rgb = pTxt[(u0 & u0_mask)>>1];
+ uSrc = CBA_[(rgb>>((u0&1)<<2))&0xf];
}
- else
- {
- // LIGHTING CALCULATIONS
- if(L) { gpuLightingTXT(uSrc, lCol); } else
- { if(!MB) uSrc&= 0x7fff; }
+ if (CF_TEXTMODE==2) { // 8bpp (CLUT)
+ uSrc = CBA_[pTxt[u0 & u0_mask]];
+ }
+ if (CF_TEXTMODE==3) { // 16bpp
+ uSrc = *(u16*)(&pTxt[u0 & u0_mask]);
}
- if (MB) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
+ if (!uSrc) goto endsprite;
+
+ //senquack - save source MSB, as blending or lighting macros will not
+ // (Silent Hill gray rectangles mask bit bug)
+ if (CF_BLEND || CF_LIGHT) srcMSB = uSrc & 0x8000;
- endsprite: pDst++;
+ if (CF_LIGHT)
+ uSrc = gpuLightingTXT(uSrc, r5, g5, b5);
+
+ if (CF_BLEND && srcMSB)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
+
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else if (CF_BLEND || CF_LIGHT) { *pDst = uSrc | srcMSB; }
+ else { *pDst = uSrc; }
+
+endsprite:
+ u0 += (CF_TEXTMODE==3) ? 2 : 1;
+ pDst++;
}
while (--count);
}
+
+static void SpriteNULL(u16 *pDst, u32 count, u8* pTxt, u32 u0)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"SpriteNULL()\n");
+ #endif
+}
+
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// 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>
+typedef void (*PS)(u16 *pDst, u32 count, u8* pTxt, u32 u0);
+
+// Template instantiation helper macros
+#define TI(cf) gpuSpriteSpanFn<(cf)>
+#define TN SpriteNULL
+#define TIBLOCK(ub) \
+ TN, TN, TN, TN, TN, TN, TN, TN, \
+ TN, TN, TN, TN, TN, TN, TN, TN, \
+ TN, TN, TN, TN, TN, TN, TN, TN, \
+ TN, TN, TN, TN, TN, TN, TN, TN, \
+ TI((ub)|0x20), TI((ub)|0x21), TI((ub)|0x22), TI((ub)|0x23), TI((ub)|0x24), TI((ub)|0x25), TI((ub)|0x26), TI((ub)|0x27), \
+ TN, TN, TI((ub)|0x2a), TI((ub)|0x2b), TN, TN, TI((ub)|0x2e), TI((ub)|0x2f), \
+ TN, TN, TI((ub)|0x32), TI((ub)|0x33), TN, TN, TI((ub)|0x36), TI((ub)|0x37), \
+ TN, TN, TI((ub)|0x3a), TI((ub)|0x3b), TN, TN, TI((ub)|0x3e), TI((ub)|0x3f), \
+ TI((ub)|0x40), TI((ub)|0x41), TI((ub)|0x42), TI((ub)|0x43), TI((ub)|0x44), TI((ub)|0x45), TI((ub)|0x46), TI((ub)|0x47), \
+ TN, TN, TI((ub)|0x4a), TI((ub)|0x4b), TN, TN, TI((ub)|0x4e), TI((ub)|0x4f), \
+ TN, TN, TI((ub)|0x52), TI((ub)|0x53), TN, TN, TI((ub)|0x56), TI((ub)|0x57), \
+ TN, TN, TI((ub)|0x5a), TI((ub)|0x5b), TN, TN, TI((ub)|0x5e), TI((ub)|0x5f), \
+ TI((ub)|0x60), TI((ub)|0x61), TI((ub)|0x62), TI((ub)|0x63), TI((ub)|0x64), TI((ub)|0x65), TI((ub)|0x66), TI((ub)|0x67), \
+ TN, TN, TI((ub)|0x6a), TI((ub)|0x6b), TN, TN, TI((ub)|0x6e), TI((ub)|0x6f), \
+ TN, TN, TI((ub)|0x72), TI((ub)|0x73), TN, TN, TI((ub)|0x76), TI((ub)|0x77), \
+ TN, TN, TI((ub)|0x7a), TI((ub)|0x7b), TN, TN, TI((ub)|0x7e), TI((ub)|0x7f)
+
+const PS gpuSpriteSpanDrivers[256] = {
+ TIBLOCK(0<<8), TIBLOCK(1<<8)
};
+#undef TI
+#undef TN
+#undef TIBLOCK
+
///////////////////////////////////////////////////////////////////////////////
// GPU Polygon innerloops generator
-template<const int CF>
-INLINE void gpuPolySpanFn(u16 *pDst, u32 count)
+
+//senquack - Newer version with following changes:
+// * Adapted to work with new poly routings in gpu_raster_polygon.h
+// adapted from DrHell GPU. They are less glitchy and use 22.10
+// fixed-point instead of original UNAI's 16.16.
+// * Texture coordinates are no longer packed together into one
+// unsigned int. This seems to lose too much accuracy (they each
+// end up being only 8.7 fixed-point that way) and pixel-droupouts
+// were noticeable both with original code and current DrHell
+// adaptations. An example would be the sky in NFS3. Now, they are
+// stored in separate ints, using separate masks.
+// * Function is no longer INLINE, as it was always called
+// through a function pointer.
+// * Function now ensures the mask bit of source texture is preserved
+// across calls to blending functions (Silent Hill rectangles fix)
+// * November 2016: Large refactoring of blending/lighting when
+// JohnnyF added dithering. See gpu_inner_quantization.h and
+// relevant blend/light headers.
+// (see README_senquack.txt)
+template<int CF>
+static void gpuPolySpanFn(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count)
{
- if (!TM)
- {
- // NO TEXTURE
- if (!G)
+ // Blend func can save an operation if it knows uSrc MSB is unset.
+ // Untextured prims can always skip this (src color MSB is always 0).
+ // For textured prims, lighting funcs always return it unset. (bonus!)
+ const bool skip_uSrc_mask = (!CF_TEXTMODE) || CF_LIGHT;
+
+ u32 bMsk; if (CF_BLITMASK) bMsk = gpu_unai.blit_mask;
+
+ if (!CF_TEXTMODE)
+ {
+ if (!CF_GOURAUD)
{
- // 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);
- }
+ // UNTEXTURED, NO GOURAUD
+ const u16 pix15 = gpu_unai.PixelData;
+ do {
+ u16 uSrc, uDst;
+
+ // NOTE: Don't enable CF_BLITMASK pixel skipping (speed hack)
+ // on untextured polys. It seems to do more harm than good: see
+ // gravestone text at end of Medieval intro sequence. -senquack
+ //if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) { goto endpolynotextnogou; } }
+
+ if (CF_BLEND || CF_MASKCHECK) uDst = *pDst;
+ if (CF_MASKCHECK) { if (uDst&0x8000) { goto endpolynotextnogou; } }
+
+ uSrc = pix15;
+
+ if (CF_BLEND)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
+
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else { *pDst = uSrc; }
+
+endpolynotextnogou:
+ 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);
+ // UNTEXTURED, GOURAUD
+ u32 l_gCol = gpu_unai.gCol;
+ u32 l_gInc = gpu_unai.gInc;
+
+ do {
+ u16 uDst, uSrc;
+
+ // See note in above loop regarding CF_BLITMASK
+ //if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolynotextgou; }
+
+ if (CF_BLEND || CF_MASKCHECK) uDst = *pDst;
+ if (CF_MASKCHECK) { if (uDst&0x8000) goto endpolynotextgou; }
+
+ if (CF_DITHER) {
+ // GOURAUD, DITHER
+
+ u32 uSrc24 = gpuLightingRGB24(l_gCol);
+ if (CF_BLEND)
+ uSrc24 = gpuBlending24<CF_BLENDMODE>(uSrc24, uDst);
+ uSrc = gpuColorQuantization24<CF_DITHER>(uSrc24, pDst);
+ } else {
+ // GOURAUD, NO DITHER
+
+ uSrc = gpuLightingRGB(l_gCol);
+
+ if (CF_BLEND)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
}
- if (MB) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
- endgou: pDst++; lCol=(lCol+linc);
+
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else { *pDst = uSrc; }
+
+endpolynotextgou:
+ pDst++;
+ l_gCol += l_gInc;
}
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;
+ // TEXTURED
+
+ u16 uDst, uSrc, srcMSB;
+
+ //senquack - note: original UNAI code had gpu_unai.{u4/v4} packed into
+ // one 32-bit unsigned int, but this proved to lose too much accuracy
+ // (pixel drouputs noticeable in NFS3 sky), so now are separate vars.
+ u32 l_u_msk = gpu_unai.u_msk; u32 l_v_msk = gpu_unai.v_msk;
+ u32 l_u = gpu_unai.u & l_u_msk; u32 l_v = gpu_unai.v & l_v_msk;
+ s32 l_u_inc = gpu_unai.u_inc; s32 l_v_inc = gpu_unai.v_inc;
+
+ const u16* TBA_ = gpu_unai.TBA;
+ const u16* CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.CBA;
+
+ u8 r5, g5, b5;
+ u8 r8, g8, b8;
+
+ u32 l_gInc, l_gCol;
+
+ if (CF_LIGHT) {
+ if (CF_GOURAUD) {
+ l_gInc = gpu_unai.gInc;
+ l_gCol = gpu_unai.gCol;
+ } else {
+ if (CF_DITHER) {
+ r8 = gpu_unai.r8;
+ g8 = gpu_unai.g8;
+ b8 = gpu_unai.b8;
+ } else {
+ r5 = gpu_unai.r5;
+ g5 = gpu_unai.g5;
+ b5 = gpu_unai.b5;
+ }
+ }
+ }
+
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);
- }
+ if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolytext; }
+ if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
+ if (CF_MASKCHECK) if (uDst&0x8000) { goto endpolytext; }
+
+ //senquack - adapted to work with new 22.10 fixed point routines:
+ // (UNAI originally used 16.16)
+ if (CF_TEXTMODE==1) { // 4bpp (CLUT)
+ u32 tu=(l_u>>10);
+ u32 tv=(l_v<<1)&(0xff<<11);
+ u8 rgb=((u8*)TBA_)[tv+(tu>>1)];
+ uSrc=CBA_[(rgb>>((tu&1)<<2))&0xf];
+ if (!uSrc) goto endpolytext;
+ }
+ if (CF_TEXTMODE==2) { // 8bpp (CLUT)
+ uSrc = CBA_[(((u8*)TBA_)[(l_u>>10)+((l_v<<1)&(0xff<<11))])];
+ if (!uSrc) goto endpolytext;
}
- else
+ if (CF_TEXTMODE==3) { // 16bpp
+ uSrc = TBA_[(l_u>>10)+((l_v)&(0xff<<10))];
+ if (!uSrc) goto endpolytext;
+ }
+
+ // Save source MSB, as blending or lighting will not (Silent Hill)
+ if (CF_BLEND || CF_LIGHT) srcMSB = uSrc & 0x8000;
+
+ // When textured, only dither when LIGHT (texture blend) is enabled
+ // LIGHT && BLEND => dither
+ // LIGHT && !BLEND => dither
+ //!LIGHT && BLEND => no dither
+ //!LIGHT && !BLEND => no dither
+
+ if (CF_DITHER && CF_LIGHT) {
+ u32 uSrc24;
+ if ( CF_GOURAUD)
+ uSrc24 = gpuLightingTXT24Gouraud(uSrc, l_gCol);
+ if (!CF_GOURAUD)
+ uSrc24 = gpuLightingTXT24(uSrc, r8, g8, b8);
+
+ if (CF_BLEND && srcMSB)
+ uSrc24 = gpuBlending24<CF_BLENDMODE>(uSrc24, uDst);
+
+ uSrc = gpuColorQuantization24<CF_DITHER>(uSrc24, pDst);
+ } else
{
- // light
- if(L) { gpuLightingTXT(uSrc, lCol); } else if(!MB) { uSrc&= 0x7fff; }
+ if (CF_LIGHT) {
+ if ( CF_GOURAUD)
+ uSrc = gpuLightingTXTGouraud(uSrc, l_gCol);
+ if (!CF_GOURAUD)
+ uSrc = gpuLightingTXT(uSrc, r5, g5, b5);
+ }
+
+ if (CF_BLEND && srcMSB)
+ uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
}
- if (MB) { *pDst = uSrc | 0x8000; }
- else { *pDst = uSrc; }
- endpoly: pDst++;
- tCor=(tCor+tinc)&tmsk;
- if (L&&G) lCol=(lCol+linc);
+
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else if (CF_BLEND || CF_LIGHT) { *pDst = uSrc | srcMSB; }
+ else { *pDst = uSrc; }
+endpolytext:
+ pDst++;
+ l_u = (l_u + l_u_inc) & l_u_msk;
+ l_v = (l_v + l_v_inc) & l_v_msk;
+ if (CF_LIGHT && CF_GOURAUD) l_gCol += l_gInc;
}
while (--count);
}
}
-// supposedly shouldn't be called?
-static void gpuPolySpanFn_NULL_(u16 *pDst, u32 count)
+static void PolyNULL(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count)
{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"PolyNULL()\n");
+ #endif
}
///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
// 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>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x0A>,gpuPolySpanFn<0x0B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x0E>,gpuPolySpanFn<0x0F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x12>,gpuPolySpanFn<0x13>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x16>,gpuPolySpanFn<0x17>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1A>,gpuPolySpanFn<0x1B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1E>,gpuPolySpanFn<0x1F>,
- gpuPolySpanFn<0x20>,gpuPolySpanFn<0x21>,gpuPolySpanFn<0x22>,gpuPolySpanFn<0x23>, gpuPolySpanFn<0x24>,gpuPolySpanFn<0x25>,gpuPolySpanFn<0x26>,gpuPolySpanFn<0x27>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x2A>,gpuPolySpanFn<0x2B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x2E>,gpuPolySpanFn<0x2F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x32>,gpuPolySpanFn<0x33>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x36>,gpuPolySpanFn<0x37>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x3A>,gpuPolySpanFn<0x3B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x3E>,gpuPolySpanFn<0x3F>,
- gpuPolySpanFn<0x40>,gpuPolySpanFn<0x41>,gpuPolySpanFn<0x42>,gpuPolySpanFn<0x43>, gpuPolySpanFn<0x44>,gpuPolySpanFn<0x45>,gpuPolySpanFn<0x46>,gpuPolySpanFn<0x47>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x4A>,gpuPolySpanFn<0x4B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x4E>,gpuPolySpanFn<0x4F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x52>,gpuPolySpanFn<0x53>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x56>,gpuPolySpanFn<0x57>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x5A>,gpuPolySpanFn<0x5B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x5E>,gpuPolySpanFn<0x5F>,
- gpuPolySpanFn<0x60>,gpuPolySpanFn<0x61>,gpuPolySpanFn<0x62>,gpuPolySpanFn<0x63>, gpuPolySpanFn<0x64>,gpuPolySpanFn<0x65>,gpuPolySpanFn<0x66>,gpuPolySpanFn<0x67>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x6A>,gpuPolySpanFn<0x6B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x6E>,gpuPolySpanFn<0x6F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x72>,gpuPolySpanFn<0x73>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x76>,gpuPolySpanFn<0x77>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x7A>,gpuPolySpanFn<0x7B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x7E>,gpuPolySpanFn<0x7F>,
-
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0x81>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x83>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x85>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x87>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x8B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x8F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x93>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x97>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x9B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x9F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0xa1>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xa3>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0xa5>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xa7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xaB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xaF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xb3>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xb7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xbB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xbF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0xc1>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xc3>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0xc5>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xc7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xcB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xcF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xd3>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xd7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xdB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xdF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0xe1>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xe3>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0xe5>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xe7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xeB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xeF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xf3>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xf7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xfB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0xfF>,
-
- gpuPolySpanFn<0x100>,gpuPolySpanFn<0x101>,gpuPolySpanFn<0x102>,gpuPolySpanFn<0x103>, gpuPolySpanFn<0x104>,gpuPolySpanFn<0x105>,gpuPolySpanFn<0x106>,gpuPolySpanFn<0x107>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x10A>,gpuPolySpanFn<0x10B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x10E>,gpuPolySpanFn<0x10F>,
- gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x112>,gpuPolySpanFn<0x113>, gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x116>,gpuPolySpanFn<0x117>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x11A>,gpuPolySpanFn<0x11B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x11E>,gpuPolySpanFn<0x11F>,
- gpuPolySpanFn<0x120>,gpuPolySpanFn<0x121>,gpuPolySpanFn<0x122>,gpuPolySpanFn<0x123>, gpuPolySpanFn<0x124>,gpuPolySpanFn<0x125>,gpuPolySpanFn<0x126>,gpuPolySpanFn<0x127>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x12A>,gpuPolySpanFn<0x12B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x12E>,gpuPolySpanFn<0x12F>,
- gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x132>,gpuPolySpanFn<0x133>, gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x136>,gpuPolySpanFn<0x137>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x13A>,gpuPolySpanFn<0x13B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x13E>,gpuPolySpanFn<0x13F>,
- gpuPolySpanFn<0x140>,gpuPolySpanFn<0x141>,gpuPolySpanFn<0x142>,gpuPolySpanFn<0x143>, gpuPolySpanFn<0x144>,gpuPolySpanFn<0x145>,gpuPolySpanFn<0x146>,gpuPolySpanFn<0x147>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x14A>,gpuPolySpanFn<0x14B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x14E>,gpuPolySpanFn<0x14F>,
- gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x152>,gpuPolySpanFn<0x153>, gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x156>,gpuPolySpanFn<0x157>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x15A>,gpuPolySpanFn<0x15B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x15E>,gpuPolySpanFn<0x15F>,
- gpuPolySpanFn<0x160>,gpuPolySpanFn<0x161>,gpuPolySpanFn<0x162>,gpuPolySpanFn<0x163>, gpuPolySpanFn<0x164>,gpuPolySpanFn<0x165>,gpuPolySpanFn<0x166>,gpuPolySpanFn<0x167>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x16A>,gpuPolySpanFn<0x16B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x16E>,gpuPolySpanFn<0x16F>,
- gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x172>,gpuPolySpanFn<0x173>, gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_, gpuPolySpanFn<0x176>,gpuPolySpanFn<0x177>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x17A>,gpuPolySpanFn<0x17B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x17E>,gpuPolySpanFn<0x17F>,
-
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0x181>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x183>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x185>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x187>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x18B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x18F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x193>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x197>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x19B>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x19F>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1a1>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1a3>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1a5>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1a7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1aB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1aF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1b3>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1b7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1bB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1bF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1c1>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1c3>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1c5>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1c7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1cB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1cF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1d3>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1d7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1dB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1dF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1e1>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1e3>, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1e5>,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1e7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1eB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1eF>,
- gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1f3>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_, gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1f7>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1fB>, gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn_NULL_,gpuPolySpanFn<0x1fF>
+typedef void (*PP)(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count);
+
+// Template instantiation helper macros
+#define TI(cf) gpuPolySpanFn<(cf)>
+#define TN PolyNULL
+#define TIBLOCK(ub) \
+ TI((ub)|0x00), TI((ub)|0x01), TI((ub)|0x02), TI((ub)|0x03), TI((ub)|0x04), TI((ub)|0x05), TI((ub)|0x06), TI((ub)|0x07), \
+ TN, TN, TI((ub)|0x0a), TI((ub)|0x0b), TN, TN, TI((ub)|0x0e), TI((ub)|0x0f), \
+ TN, TN, TI((ub)|0x12), TI((ub)|0x13), TN, TN, TI((ub)|0x16), TI((ub)|0x17), \
+ TN, TN, TI((ub)|0x1a), TI((ub)|0x1b), TN, TN, TI((ub)|0x1e), TI((ub)|0x1f), \
+ TI((ub)|0x20), TI((ub)|0x21), TI((ub)|0x22), TI((ub)|0x23), TI((ub)|0x24), TI((ub)|0x25), TI((ub)|0x26), TI((ub)|0x27), \
+ TN, TN, TI((ub)|0x2a), TI((ub)|0x2b), TN, TN, TI((ub)|0x2e), TI((ub)|0x2f), \
+ TN, TN, TI((ub)|0x32), TI((ub)|0x33), TN, TN, TI((ub)|0x36), TI((ub)|0x37), \
+ TN, TN, TI((ub)|0x3a), TI((ub)|0x3b), TN, TN, TI((ub)|0x3e), TI((ub)|0x3f), \
+ TI((ub)|0x40), TI((ub)|0x41), TI((ub)|0x42), TI((ub)|0x43), TI((ub)|0x44), TI((ub)|0x45), TI((ub)|0x46), TI((ub)|0x47), \
+ TN, TN, TI((ub)|0x4a), TI((ub)|0x4b), TN, TN, TI((ub)|0x4e), TI((ub)|0x4f), \
+ TN, TN, TI((ub)|0x52), TI((ub)|0x53), TN, TN, TI((ub)|0x56), TI((ub)|0x57), \
+ TN, TN, TI((ub)|0x5a), TI((ub)|0x5b), TN, TN, TI((ub)|0x5e), TI((ub)|0x5f), \
+ TI((ub)|0x60), TI((ub)|0x61), TI((ub)|0x62), TI((ub)|0x63), TI((ub)|0x64), TI((ub)|0x65), TI((ub)|0x66), TI((ub)|0x67), \
+ TN, TN, TI((ub)|0x6a), TI((ub)|0x6b), TN, TN, TI((ub)|0x6e), TI((ub)|0x6f), \
+ TN, TN, TI((ub)|0x72), TI((ub)|0x73), TN, TN, TI((ub)|0x76), TI((ub)|0x77), \
+ TN, TN, TI((ub)|0x7a), TI((ub)|0x7b), TN, TN, TI((ub)|0x7e), TI((ub)|0x7f), \
+ TN, TI((ub)|0x81), TN, TI((ub)|0x83), TN, TI((ub)|0x85), TN, TI((ub)|0x87), \
+ TN, TN, TN, TI((ub)|0x8b), TN, TN, TN, TI((ub)|0x8f), \
+ TN, TN, TN, TI((ub)|0x93), TN, TN, TN, TI((ub)|0x97), \
+ TN, TN, TN, TI((ub)|0x9b), TN, TN, TN, TI((ub)|0x9f), \
+ TN, TI((ub)|0xa1), TN, TI((ub)|0xa3), TN, TI((ub)|0xa5), TN, TI((ub)|0xa7), \
+ TN, TN, TN, TI((ub)|0xab), TN, TN, TN, TI((ub)|0xaf), \
+ TN, TN, TN, TI((ub)|0xb3), TN, TN, TN, TI((ub)|0xb7), \
+ TN, TN, TN, TI((ub)|0xbb), TN, TN, TN, TI((ub)|0xbf), \
+ TN, TI((ub)|0xc1), TN, TI((ub)|0xc3), TN, TI((ub)|0xc5), TN, TI((ub)|0xc7), \
+ TN, TN, TN, TI((ub)|0xcb), TN, TN, TN, TI((ub)|0xcf), \
+ TN, TN, TN, TI((ub)|0xd3), TN, TN, TN, TI((ub)|0xd7), \
+ TN, TN, TN, TI((ub)|0xdb), TN, TN, TN, TI((ub)|0xdf), \
+ TN, TI((ub)|0xe1), TN, TI((ub)|0xe3), TN, TI((ub)|0xe5), TN, TI((ub)|0xe7), \
+ TN, TN, TN, TI((ub)|0xeb), TN, TN, TN, TI((ub)|0xef), \
+ TN, TN, TN, TI((ub)|0xf3), TN, TN, TN, TI((ub)|0xf7), \
+ TN, TN, TN, TI((ub)|0xfb), TN, TN, TN, TI((ub)|0xff)
+
+const PP gpuPolySpanDrivers[2048] = {
+ TIBLOCK(0<<8), TIBLOCK(1<<8), TIBLOCK(2<<8), TIBLOCK(3<<8),
+ TIBLOCK(4<<8), TIBLOCK(5<<8), TIBLOCK(6<<8), TIBLOCK(7<<8)
};
+
+#undef TI
+#undef TN
+#undef TIBLOCK
diff --git a/plugins/gpu_unai/gpu_inner_blend.h b/plugins/gpu_unai/gpu_inner_blend.h
index ce439d3..93c268b 100644
--- a/plugins/gpu_unai/gpu_inner_blend.h
+++ b/plugins/gpu_unai/gpu_inner_blend.h
@@ -23,132 +23,166 @@
// GPU Blending operations functions
-#ifdef __arm__
-#define gpuBlending00(uSrc,uDst) \
-{ \
- asm ("and %[src], %[src], %[msk]\n" \
- "and %[dst], %[dst], %[msk]\n" \
- "add %[src], %[dst], %[src]\n" \
- "mov %[src], %[src], lsr #1\n" \
- : [src] "=&r" (uSrc), [dst] "=&r" (uDst) : "0" (uSrc), "1" (uDst), [msk] "r" (uMsk)); \
-}
-#else
-#define gpuBlending00(uSrc,uDst) \
-{ \
- uSrc = (((uDst & uMsk) + (uSrc & uMsk)) >> 1); \
-}
-#endif
+////////////////////////////////////////////////////////////////////////////////
+// Blend bgr555 color in 'uSrc' (foreground) with bgr555 color
+// in 'uDst' (background), returning resulting color.
+//
+// INPUT:
+// 'uSrc','uDst' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// OUTPUT:
+// u16 output: 0bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// Where '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+template <int BLENDMODE, bool SKIP_USRC_MSB_MASK>
+GPU_INLINE u16 gpuBlending(u16 uSrc, u16 uDst)
+{
+ // These use Blargg's bitwise modulo-clamping:
+ // http://blargg.8bitalley.com/info/rgb_mixing.html
+ // http://blargg.8bitalley.com/info/rgb_clamped_add.html
+ // http://blargg.8bitalley.com/info/rgb_clamped_sub.html
-// 1.0 x Back + 1.0 x Forward
-#ifdef __arm__
-#define gpuBlending01(uSrc,uDst) \
-{ \
- u32 st,dt,out; \
- asm ("and %[dt], %[dst], #0x7C00\n" \
- "and %[st], %[src], #0x7C00\n" \
- "add %[out], %[dt], %[st] \n" \
- "cmp %[out], #0x7C00 \n" \
- "movhi %[out], #0x7C00 \n" \
- "and %[dt], %[dst], #0x03E0\n" \
- "and %[st], %[src], #0x03E0\n" \
- "add %[dt], %[dt], %[st] \n" \
- "cmp %[dt], #0x03E0 \n" \
- "movhi %[dt], #0x03E0 \n" \
- "orr %[out], %[out], %[dt] \n" \
- "and %[dt], %[dst], #0x001F\n" \
- "and %[st], %[src], #0x001F\n" \
- "add %[dt], %[dt], %[st] \n" \
- "cmp %[dt], #0x001F \n" \
- "movhi %[dt], #0x001F \n" \
- "orr %[src], %[out], %[dt] \n" \
- : [src] "=r" (uSrc), [st] "=&r" (st), [dt] "=&r" (dt), [out] "=&r" (out) \
- : [dst] "r" (uDst), "0" (uSrc) : "cc"); \
-}
+ u16 mix;
+
+ // 0.5 x Back + 0.5 x Forward
+ if (BLENDMODE==0) {
+#ifdef GPU_UNAI_USE_ACCURATE_BLENDING
+ // Slower, but more accurate (doesn't lose LSB data)
+ uDst &= 0x7fff;
+ if (!SKIP_USRC_MSB_MASK)
+ uSrc &= 0x7fff;
+ mix = ((uSrc + uDst) - ((uSrc ^ uDst) & 0x0421)) >> 1;
#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; \
-}
+ mix = ((uDst & 0x7bde) + (uSrc & 0x7bde)) >> 1;
#endif
+ }
+
+ // 1.0 x Back + 1.0 x Forward
+ if (BLENDMODE==1) {
+ uDst &= 0x7fff;
+ if (!SKIP_USRC_MSB_MASK)
+ uSrc &= 0x7fff;
+ u32 sum = uSrc + uDst;
+ u32 low_bits = (uSrc ^ uDst) & 0x0421;
+ u32 carries = (sum - low_bits) & 0x8420;
+ u32 modulo = sum - carries;
+ u32 clamp = carries - (carries >> 5);
+ mix = modulo | clamp;
+ }
+
+ // 1.0 x Back - 1.0 x Forward
+ if (BLENDMODE==2) {
+ uDst &= 0x7fff;
+ if (!SKIP_USRC_MSB_MASK)
+ uSrc &= 0x7fff;
+ u32 diff = uDst - uSrc + 0x8420;
+ u32 low_bits = (uDst ^ uSrc) & 0x8420;
+ u32 borrows = (diff - low_bits) & 0x8420;
+ u32 modulo = diff - borrows;
+ u32 clamp = borrows - (borrows >> 5);
+ mix = modulo & clamp;
+ }
-// 1.0 x Back - 1.0 x Forward */
-#ifdef __arm__
-#define gpuBlending02(uSrc,uDst) \
-{ \
- u32 st,dt,out; \
- asm ("and %[dt], %[dst], #0x7C00\n" \
- "and %[st], %[src], #0x7C00\n" \
- "subs %[out], %[dt], %[st] \n" \
- "movmi %[out], #0x0000 \n" \
- "and %[dt], %[dst], #0x03E0\n" \
- "and %[st], %[src], #0x03E0\n" \
- "subs %[dt], %[dt], %[st] \n" \
- "orrpl %[out], %[out], %[dt] \n" \
- "and %[dt], %[dst], #0x001F\n" \
- "and %[st], %[src], #0x001F\n" \
- "subs %[dt], %[dt], %[st] \n" \
- "orrpl %[out], %[out], %[dt] \n" \
- "mov %[src], %[out] \n" \
- : [src] "=r" (uSrc), [st] "=&r" (st), [dt] "=&r" (dt), [out] "=&r" (out) \
- : [dst] "r" (uDst), "0" (uSrc) : "cc"); \
+ // 1.0 x Back + 0.25 x Forward
+ if (BLENDMODE==3) {
+ uDst &= 0x7fff;
+ uSrc = ((uSrc >> 2) & 0x1ce7);
+ u32 sum = uSrc + uDst;
+ u32 low_bits = (uSrc ^ uDst) & 0x0421;
+ u32 carries = (sum - low_bits) & 0x8420;
+ u32 modulo = sum - carries;
+ u32 clamp = carries - (carries >> 5);
+ mix = modulo | clamp;
+ }
+
+ return mix;
}
-int btest(int s, int d)
+
+////////////////////////////////////////////////////////////////////////////////
+// Convert bgr555 color in uSrc to padded u32 5.4:5.4:5.4 bgr fixed-pt
+// color triplet suitable for use with HQ 24-bit quantization.
+//
+// INPUT:
+// 'uDst' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u32 gpuGetRGB24(u16 uSrc)
{
- gpuBlending02(s, d);
- return s;
-}
-#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; \
+ return ((uSrc & 0x7C00)<<14)
+ | ((uSrc & 0x03E0)<< 9)
+ | ((uSrc & 0x001F)<< 4);
}
-#endif
-// 1.0 x Back + 0.25 x Forward */
-#ifdef __arm__
-#define gpuBlending03(uSrc,uDst) \
-{ \
- u32 st,dt,out; \
- asm ("mov %[src], %[src], lsr #2 \n" \
- "and %[dt], %[dst], #0x7C00\n" \
- "and %[st], %[src], #0x1C00\n" \
- "add %[out], %[dt], %[st] \n" \
- "cmp %[out], #0x7C00 \n" \
- "movhi %[out], #0x7C00 \n" \
- "and %[dt], %[dst], #0x03E0\n" \
- "and %[st], %[src], #0x00E0\n" \
- "add %[dt], %[dt], %[st] \n" \
- "cmp %[dt], #0x03E0 \n" \
- "movhi %[dt], #0x03E0 \n" \
- "orr %[out], %[out], %[dt] \n" \
- "and %[dt], %[dst], #0x001F\n" \
- "and %[st], %[src], #0x0007\n" \
- "add %[dt], %[dt], %[st] \n" \
- "cmp %[dt], #0x001F \n" \
- "movhi %[dt], #0x001F \n" \
- "orr %[src], %[out], %[dt] \n" \
- : [src] "=r" (uSrc), [st] "=&r" (st), [dt] "=&r" (dt), [out] "=&r" (out) \
- : [dst] "r" (uDst), "0" (uSrc) : "cc"); \
-}
-#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; \
+
+////////////////////////////////////////////////////////////////////////////////
+// Blend padded u32 5.4:5.4:5.4 bgr fixed-pt color triplet in 'uSrc24'
+// (foreground color) with bgr555 color in 'uDst' (background color),
+// returning the resulting u32 5.4:5.4:5.4 color.
+//
+// INPUT:
+// 'uSrc24' input: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// 'uDst' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+template <int BLENDMODE>
+GPU_INLINE u32 gpuBlending24(u32 uSrc24, u16 uDst)
+{
+ // These use techniques adapted from Blargg's techniques mentioned in
+ // in gpuBlending() comments above. Not as much bitwise trickery is
+ // necessary because of presence of 0 padding in uSrc24 format.
+
+ u32 uDst24 = gpuGetRGB24(uDst);
+ u32 mix;
+
+ // 0.5 x Back + 0.5 x Forward
+ if (BLENDMODE==0) {
+ const u32 uMsk = 0x1FE7F9FE;
+ // Only need to mask LSBs of uSrc24, uDst24's LSBs are 0 already
+ mix = (uDst24 + (uSrc24 & uMsk)) >> 1;
+ }
+
+ // 1.0 x Back + 1.0 x Forward
+ if (BLENDMODE==1) {
+ u32 sum = uSrc24 + uDst24;
+ u32 carries = sum & 0x20080200;
+ u32 modulo = sum - carries;
+ u32 clamp = carries - (carries >> 9);
+ mix = modulo | clamp;
+ }
+
+ // 1.0 x Back - 1.0 x Forward
+ if (BLENDMODE==2) {
+ // Insert ones in 0-padded borrow slot of color to be subtracted from
+ uDst24 |= 0x20080200;
+ u32 diff = uDst24 - uSrc24;
+ u32 borrows = diff & 0x20080200;
+ u32 clamp = borrows - (borrows >> 9);
+ mix = diff & clamp;
+ }
+
+ // 1.0 x Back + 0.25 x Forward
+ if (BLENDMODE==3) {
+ uSrc24 = (uSrc24 & 0x1FC7F1FC) >> 2;
+ u32 sum = uSrc24 + uDst24;
+ u32 carries = sum & 0x20080200;
+ u32 modulo = sum - carries;
+ u32 clamp = carries - (carries >> 9);
+ mix = modulo | clamp;
+ }
+
+ return mix;
}
-#endif
#endif //_OP_BLEND_H_
diff --git a/plugins/gpu_unai/gpu_inner_blend_arm5.h b/plugins/gpu_unai/gpu_inner_blend_arm5.h
new file mode 100644
index 0000000..0e9b74f
--- /dev/null
+++ b/plugins/gpu_unai/gpu_inner_blend_arm5.h
@@ -0,0 +1,100 @@
+/***************************************************************************
+* 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
+
+#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) ); \
+}
+
+// 1.0 x Back + 1.0 x Forward
+#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) ); \
+}
+
+// 1.0 x Back - 1.0 x Forward */
+#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) ); \
+}
+
+// 1.0 x Back + 0.25 x Forward */
+#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) ); \
+}
+
+#endif //_OP_BLEND_H_
diff --git a/plugins/gpu_unai/gpu_inner_blend_arm7.h b/plugins/gpu_unai/gpu_inner_blend_arm7.h
new file mode 100644
index 0000000..083e62d
--- /dev/null
+++ b/plugins/gpu_unai/gpu_inner_blend_arm7.h
@@ -0,0 +1,107 @@
+/***************************************************************************
+* 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
+
+#define gpuBlending00(uSrc,uDst) \
+{ \
+ asm ("and %[src], %[src], %[msk]\n" \
+ "and %[dst], %[dst], %[msk]\n" \
+ "add %[src], %[dst], %[src]\n" \
+ "mov %[src], %[src], lsr #1\n" \
+ : [src] "=&r" (uSrc), [dst] "=&r" (uDst) : "0" (uSrc), "1" (uDst), [msk] "r" (uMsk)); \
+}
+
+// 1.0 x Back + 1.0 x Forward
+#define gpuBlending01(uSrc,uDst) \
+{ \
+ u32 st,dt,out; \
+ asm ("and %[dt], %[dst], #0x7C00\n" \
+ "and %[st], %[src], #0x7C00\n" \
+ "add %[out], %[dt], %[st] \n" \
+ "cmp %[out], #0x7C00 \n" \
+ "movhi %[out], #0x7C00 \n" \
+ "and %[dt], %[dst], #0x03E0\n" \
+ "and %[st], %[src], #0x03E0\n" \
+ "add %[dt], %[dt], %[st] \n" \
+ "cmp %[dt], #0x03E0 \n" \
+ "movhi %[dt], #0x03E0 \n" \
+ "orr %[out], %[out], %[dt] \n" \
+ "and %[dt], %[dst], #0x001F\n" \
+ "and %[st], %[src], #0x001F\n" \
+ "add %[dt], %[dt], %[st] \n" \
+ "cmp %[dt], #0x001F \n" \
+ "movhi %[dt], #0x001F \n" \
+ "orr %[src], %[out], %[dt] \n" \
+ : [src] "=r" (uSrc), [st] "=&r" (st), [dt] "=&r" (dt), [out] "=&r" (out) \
+ : [dst] "r" (uDst), "0" (uSrc) : "cc"); \
+}
+
+// 1.0 x Back - 1.0 x Forward */
+#define gpuBlending02(uSrc,uDst) \
+{ \
+ u32 st,dt,out; \
+ asm ("and %[dt], %[dst], #0x7C00\n" \
+ "and %[st], %[src], #0x7C00\n" \
+ "subs %[out], %[dt], %[st] \n" \
+ "movmi %[out], #0x0000 \n" \
+ "and %[dt], %[dst], #0x03E0\n" \
+ "and %[st], %[src], #0x03E0\n" \
+ "subs %[dt], %[dt], %[st] \n" \
+ "orrpl %[out], %[out], %[dt] \n" \
+ "and %[dt], %[dst], #0x001F\n" \
+ "and %[st], %[src], #0x001F\n" \
+ "subs %[dt], %[dt], %[st] \n" \
+ "orrpl %[out], %[out], %[dt] \n" \
+ "mov %[src], %[out] \n" \
+ : [src] "=r" (uSrc), [st] "=&r" (st), [dt] "=&r" (dt), [out] "=&r" (out) \
+ : [dst] "r" (uDst), "0" (uSrc) : "cc"); \
+}
+
+// 1.0 x Back + 0.25 x Forward */
+#define gpuBlending03(uSrc,uDst) \
+{ \
+ u32 st,dt,out; \
+ asm ("mov %[src], %[src], lsr #2 \n" \
+ "and %[dt], %[dst], #0x7C00\n" \
+ "and %[st], %[src], #0x1C00\n" \
+ "add %[out], %[dt], %[st] \n" \
+ "cmp %[out], #0x7C00 \n" \
+ "movhi %[out], #0x7C00 \n" \
+ "and %[dt], %[dst], #0x03E0\n" \
+ "and %[st], %[src], #0x00E0\n" \
+ "add %[dt], %[dt], %[st] \n" \
+ "cmp %[dt], #0x03E0 \n" \
+ "movhi %[dt], #0x03E0 \n" \
+ "orr %[out], %[out], %[dt] \n" \
+ "and %[dt], %[dst], #0x001F\n" \
+ "and %[st], %[src], #0x0007\n" \
+ "add %[dt], %[dt], %[st] \n" \
+ "cmp %[dt], #0x001F \n" \
+ "movhi %[dt], #0x001F \n" \
+ "orr %[src], %[out], %[dt] \n" \
+ : [src] "=r" (uSrc), [st] "=&r" (st), [dt] "=&r" (dt), [out] "=&r" (out) \
+ : [dst] "r" (uDst), "0" (uSrc) : "cc"); \
+}
+
+#endif //_OP_BLEND_H_
diff --git a/plugins/gpu_unai/gpu_inner_light.h b/plugins/gpu_unai/gpu_inner_light.h
index d291418..b041dc3 100644
--- a/plugins/gpu_unai/gpu_inner_light.h
+++ b/plugins/gpu_unai/gpu_inner_light.h
@@ -1,5 +1,5 @@
/***************************************************************************
-* Copyright (C) 2010 PCSX4ALL Team *
+* Copyright (C) 2016 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
* *
* This program is free software; you can redistribute it and/or modify *
@@ -23,60 +23,249 @@
// GPU color operations for lighting calculations
-#ifdef __arm__
-#define gpuLightingRGB(uSrc,lCol) \
-{ \
- u32 cb,cg; \
- asm ("and %[cb], %[lCol], #0x7C00/32 \n" \
- "and %[cg], %[lCol], #0x03E0*2048 \n" \
- "mov %[res], %[lCol], lsr #27\n" \
- "orr %[res], %[res], %[cb], lsl #5 \n" \
- "orr %[res], %[res], %[cg], lsr #11\n" \
- : [res] "=&r" (uSrc), [cb] "=&r" (cb), [cg] "=&r" (cg) \
- : [lCol] "r" (lCol)); \
+static void SetupLightLUT()
+{
+ // 1024-entry lookup table that modulates 5-bit texture + 5-bit light value.
+ // A light value of 15 does not modify the incoming texture color.
+ // LightLUT[32*32] array is initialized to following values:
+ // 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
+
+ for (int j=0; j < 32; ++j) {
+ for (int i=0; i < 32; ++i) {
+ int val = i * j / 16;
+ if (val > 31) val = 31;
+ gpu_unai.LightLUT[(j*32) + i] = val;
+ }
+ }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Create packed Gouraud fixed-pt 8.3:8.3:8.2 rgb triplet
+//
+// INPUT:
+// 'r','g','b' are 8.10 fixed-pt color components (r shown here)
+// 'r' input: --------------rrrrrrrrXXXXXXXXXX
+// ^ bit 31
+// RETURNS:
+// u32 output: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+// ^ bit 31
+// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '-' don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u32 gpuPackGouraudCol(u32 r, u32 g, u32 b)
+{
+ return ((u32)(b>> 8)&(0x03ff ))
+ | ((u32)(g<< 3)&(0x07ff<<10))
+ | ((u32)(r<<14)&(0x07ff<<21));
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Create packed increment for Gouraud fixed-pt 8.3:8.3:8.2 rgb triplet
+//
+// INPUT:
+// Sign-extended 8.10 fixed-pt r,g,b color increment values (only dr is shown)
+// 'dr' input: ssssssssssssssrrrrrrrrXXXXXXXXXX
+// ^ bit 31
+// RETURNS:
+// u32 output: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+// ^ bit 31
+// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and 's' sign bits
+//
+// NOTE: The correctness of this code/method has not been fully verified,
+// having been merely factored out from original code in
+// poly-drawing functions. Feel free to check/improve it -senquack
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u32 gpuPackGouraudColInc(s32 dr, s32 dg, s32 db)
+{
+ u32 dr_tmp = (u32)(dr << 14)&(0xffffffff<<21); if (dr < 0) dr_tmp += 1<<21;
+ u32 dg_tmp = (u32)(dg << 3)&(0xffffffff<<10); if (dg < 0) dg_tmp += 1<<10;
+ u32 db_tmp = (u32)(db >> 8)&(0xffffffff ); if (db < 0) db_tmp += 1<< 0;
+ return db_tmp + dg_tmp + dr_tmp;
}
-#else
-#define gpuLightingRGB(uSrc,lCol) uSrc=((lCol<<5)&0x7C00) | ((lCol>>11)&0x3E0) | (lCol>>27)
-#endif
-INLINE void gpuLightingTXT(u16 &uSrc, u32 &lCol)
+
+////////////////////////////////////////////////////////////////////////////////
+// Extract bgr555 color from Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet
+//
+// INPUT:
+// 'gCol' input: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+// ^ bit 31
+// RETURNS:
+// u16 output: 0bbbbbgggggrrrrr
+// ^ bit 16
+// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '0' zero
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u16 gpuLightingRGB(u32 gCol)
+{
+ return ((gCol<< 5)&0x7C00) |
+ ((gCol>>11)&0x03E0) |
+ (gCol>>27);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Convert packed Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet in 'gCol'
+// to padded u32 5.4:5.4:5.4 bgr fixed-pt triplet, suitable for use
+// with HQ 24-bit lighting/quantization.
+//
+// INPUT:
+// 'gCol' input: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+// ^ bit 31
+// RETURNS:
+// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// Where 'X' are fixed-pt bits, '0' zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u32 gpuLightingRGB24(u32 gCol)
+{
+ return ((gCol<<19) & (0x1FF<<20)) |
+ ((gCol>> 2) & (0x1FF<<10)) |
+ (gCol>>23);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Apply fast (low-precision) 5-bit lighting to bgr555 texture color:
+//
+// INPUT:
+// 'r5','g5','b5' are unsigned 5-bit color values, value of 15
+// is midpoint that doesn't modify that component of texture
+// 'uSrc' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u16 output: 0bbbbbgggggrrrrr
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u16 gpuLightingTXT(u16 uSrc, u8 r5, u8 g5, u8 b5)
{
- // 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)]);
+ return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | b5] << 10) |
+ (gpu_unai.LightLUT[ (uSrc&0x03E0) | g5] << 5) |
+ (gpu_unai.LightLUT[((uSrc&0x001F)<<5) | r5] );
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Apply fast (low-precision) 5-bit Gouraud lighting to bgr555 texture color:
+//
+// INPUT:
+// 'gCol' is a packed Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet, value of
+// 15.0 is midpoint that does not modify color of texture
+// gCol input : rrrrrXXXXXXgggggXXXXXXbbbbbXXXXX
+// ^ bit 31
+// 'uSrc' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u16 output: 0bbbbbgggggrrrrr
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u16 gpuLightingTXTGouraud(u16 uSrc, u32 gCol)
+{
+ return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | ((gCol>> 5)&0x1F)]<<10) |
+ (gpu_unai.LightLUT[ (uSrc&0x03E0) | ((gCol>>16)&0x1F)]<< 5) |
+ (gpu_unai.LightLUT[((uSrc&0x001F)<<5) | (gCol>>27) ] );
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Apply high-precision 8-bit lighting to bgr555 texture color,
+// returning a padded u32 5.4:5.4:5.4 bgr fixed-pt triplet
+// suitable for use with HQ 24-bit lighting/quantization.
+//
+// INPUT:
+// 'r8','g8','b8' are unsigned 8-bit color component values, value of
+// 127 is midpoint that doesn't modify that component of texture
+//
+// uSrc input: -bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u32 gpuLightingTXT24(u16 uSrc, u8 r8, u8 g8, u8 b8)
+{
+ u16 r1 = uSrc&0x001F;
+ u16 g1 = uSrc&0x03E0;
+ u16 b1 = uSrc&0x7C00;
+
+ u16 r2 = r8;
+ u16 g2 = g8;
+ u16 b2 = b8;
+
+ u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
+ u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
+ u32 b3 = b1 * b2; if (b3 & 0xFFC00000) b3 = ~0xFFC00000;
+
+ return ((r3>> 3) ) |
+ ((g3>> 8)<<10) |
+ ((b3>>13)<<20);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Apply high-precision 8-bit lighting to bgr555 texture color in 'uSrc',
+// returning a padded u32 5.4:5.4:5.4 bgr fixed-pt triplet
+// suitable for use with HQ 24-bit lighting/quantization.
+//
+// INPUT:
+// 'uSrc' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// 'gCol' input: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+// ^ bit 31
+// RETURNS:
+// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE u32 gpuLightingTXT24Gouraud(u16 uSrc, u32 gCol)
+{
+ u16 r1 = uSrc&0x001F;
+ u16 g1 = uSrc&0x03E0;
+ u16 b1 = uSrc&0x7C00;
+
+ u16 r2 = (gCol>>24) & 0xFF;
+ u16 g2 = (gCol>>13) & 0xFF;
+ u16 b2 = (gCol>> 2) & 0xFF;
+
+ u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
+ u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
+ u32 b3 = b1 * b2; if (b3 & 0xFFC00000) b3 = ~0xFFC00000;
+
+ return ((r3>> 3) ) |
+ ((g3>> 8)<<10) |
+ ((b3>>13)<<20);
}
#endif //_OP_LIGHT_H_
diff --git a/plugins/gpu_unai/gpu_inner_quantization.h b/plugins/gpu_unai/gpu_inner_quantization.h
new file mode 100644
index 0000000..0e7e3e8
--- /dev/null
+++ b/plugins/gpu_unai/gpu_inner_quantization.h
@@ -0,0 +1,108 @@
+/***************************************************************************
+* Copyright (C) 2016 PCSX4ALL Team *
+* *
+* This program is free software; you can redistribute it and/or modify *
+* it under the terms of the GNU General Public License as published by *
+* the Free Software Foundation; either version 2 of the License, or *
+* (at your option) any later version. *
+* *
+* This program is distributed in the hope that it will be useful, *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+* GNU General Public License for more details. *
+* *
+* You should have received a copy of the GNU General Public License *
+* along with this program; if not, write to the *
+* Free Software Foundation, Inc., *
+* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
+***************************************************************************/
+
+#ifndef _OP_DITHER_H_
+#define _OP_DITHER_H_
+
+static void SetupDitheringConstants()
+{
+ // Initialize Dithering Constants
+ // The screen is divided into 8x8 chunks and sub-unitary noise is applied
+ // using the following matrix. This ensures that data lost in color
+ // quantization will be added back to the image 'by chance' in predictable
+ // patterns that are naturally 'smoothed' by your sight when viewed from a
+ // certain distance.
+ //
+ // http://caca.zoy.org/study/index.html
+ //
+ // Shading colors are encoded in 4.5, and then are quantitized to 5.0,
+ // DitherMatrix constants reflect that.
+
+ static const u8 DitherMatrix[] = {
+ 0, 32, 8, 40, 2, 34, 10, 42,
+ 48, 16, 56, 24, 50, 18, 58, 26,
+ 12, 44, 4, 36, 14, 46, 6, 38,
+ 60, 28, 52, 20, 62, 30, 54, 22,
+ 3, 35, 11, 43, 1, 33, 9, 41,
+ 51, 19, 59, 27, 49, 17, 57, 25,
+ 15, 47, 7, 39, 13, 45, 5, 37,
+ 63, 31, 55, 23, 61, 29, 53, 21
+ };
+
+ int i, j;
+ for (i = 0; i < 8; i++)
+ {
+ for (j = 0; j < 8; j++)
+ {
+ u16 offset = (i << 3) | j;
+
+ u32 component = ((DitherMatrix[offset] + 1) << 4) / 65; //[5.5] -> [5]
+
+ // XXX - senquack - hack Dec 2016
+ // Until JohnnyF gets the time to work further on dithering,
+ // force lower bit of component to 0. This fixes grid pattern
+ // affecting quality of dithered image, as well as loss of
+ // detail in dark areas. With lower bit unset like this, existing
+ // 27-bit accuracy of dithering math is unneeded, could be 24-bit.
+ // Is 8x8 matrix overkill as a result, can we use 4x4?
+ component &= ~1;
+
+ gpu_unai.DitherMatrix[offset] = (component)
+ | (component << 10)
+ | (component << 20);
+ }
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Convert padded u32 5.4:5.4:5.4 bgr fixed-pt triplet to final bgr555 color,
+// applying dithering if specified by template parameter.
+//
+// INPUT:
+// 'uSrc24' input: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
+// ^ bit 31
+// 'pDst' is a pointer to destination framebuffer pixel, used
+// to determine which DitherMatrix[] entry to apply.
+// RETURNS:
+// u16 output: 0bbbbbgggggrrrrr
+// ^ bit 16
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+template <int DITHER>
+GPU_INLINE u16 gpuColorQuantization24(u32 uSrc24, const u16 *pDst)
+{
+ if (DITHER)
+ {
+ u16 fbpos = (u32)(pDst - gpu_unai.vram);
+ u16 offset = ((fbpos & (0x7 << 10)) >> 7) | (fbpos & 0x7);
+
+ //clean overflow flags and add
+ uSrc24 = (uSrc24 & 0x1FF7FDFF) + gpu_unai.DitherMatrix[offset];
+
+ if (uSrc24 & (1<< 9)) uSrc24 |= (0x1FF );
+ if (uSrc24 & (1<<19)) uSrc24 |= (0x1FF<<10);
+ if (uSrc24 & (1<<29)) uSrc24 |= (0x1FF<<20);
+ }
+
+ return ((uSrc24>> 4) & (0x1F ))
+ | ((uSrc24>> 9) & (0x1F<<5 ))
+ | ((uSrc24>>14) & (0x1F<<10));
+}
+
+#endif //_OP_DITHER_H_
diff --git a/plugins/gpu_unai/gpu_raster_image.h b/plugins/gpu_unai/gpu_raster_image.h
index 0c82aa9..87d2151 100644
--- a/plugins/gpu_unai/gpu_raster_image.h
+++ b/plugins/gpu_unai/gpu_raster_image.h
@@ -19,71 +19,79 @@
***************************************************************************/
///////////////////////////////////////////////////////////////////////////////
-INLINE void gpuLoadImage(void)
+#ifndef USE_GPULIB
+void gpuLoadImage(PtrUnion packet)
{
u16 x0, y0, w0, h0;
- x0 = PacketBuffer.U2[2] & 1023;
- y0 = PacketBuffer.U2[3] & 511;
- w0 = PacketBuffer.U2[4];
- h0 = PacketBuffer.U2[5];
+ x0 = packet.U2[2] & 1023;
+ y0 = packet.U2[3] & 511;
+ w0 = packet.U2[4];
+ h0 = packet.U2[5];
if ((y0 + h0) > FRAME_HEIGHT)
{
h0 = FRAME_HEIGHT - y0;
}
- FrameToWrite = ((w0)&&(h0));
+ gpu_unai.dma.FrameToWrite = ((w0)&&(h0));
- px = 0;
- py = 0;
- x_end = w0;
- y_end = h0;
- pvram = &((u16*)GPU_FrameBuffer)[x0+(y0*1024)];
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.py = 0;
+ gpu_unai.dma.x_end = w0;
+ gpu_unai.dma.y_end = h0;
+ gpu_unai.dma.pvram = &((u16*)gpu_unai.vram)[x0+(y0*1024)];
- GPU_GP1 |= 0x08000000;
+ gpu_unai.GPU_GP1 |= 0x08000000;
}
+#endif // !USE_GPULIB
///////////////////////////////////////////////////////////////////////////////
-INLINE void gpuStoreImage(void)
+#ifndef USE_GPULIB
+void gpuStoreImage(PtrUnion packet)
{
u16 x0, y0, w0, h0;
- x0 = PacketBuffer.U2[2] & 1023;
- y0 = PacketBuffer.U2[3] & 511;
- w0 = PacketBuffer.U2[4];
- h0 = PacketBuffer.U2[5];
+ x0 = packet.U2[2] & 1023;
+ y0 = packet.U2[3] & 511;
+ w0 = packet.U2[4];
+ h0 = packet.U2[5];
if ((y0 + h0) > FRAME_HEIGHT)
{
h0 = FRAME_HEIGHT - y0;
}
- FrameToRead = ((w0)&&(h0));
+ gpu_unai.dma.FrameToRead = ((w0)&&(h0));
- px = 0;
- py = 0;
- x_end = w0;
- y_end = h0;
- pvram = &((u16*)GPU_FrameBuffer)[x0+(y0*1024)];
+ gpu_unai.dma.px = 0;
+ gpu_unai.dma.py = 0;
+ gpu_unai.dma.x_end = w0;
+ gpu_unai.dma.y_end = h0;
+ gpu_unai.dma.pvram = &((u16*)gpu_unai.vram)[x0+(y0*1024)];
- GPU_GP1 |= 0x08000000;
+ gpu_unai.GPU_GP1 |= 0x08000000;
}
+#endif // !USE_GPULIB
-INLINE void gpuMoveImage(void)
+void gpuMoveImage(PtrUnion packet)
{
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];
+ x0 = packet.U2[2] & 1023;
+ y0 = packet.U2[3] & 511;
+ x1 = packet.U2[4] & 1023;
+ y1 = packet.U2[5] & 511;
+ w0 = packet.U2[6];
+ h0 = packet.U2[7];
if( (x0==x1) && (y0==y1) ) return;
if ((w0<=0) || (h0<=0)) return;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"gpuMoveImage(x0=%u,y0=%u,x1=%u,y1=%u,w0=%d,h0=%d)\n",x0,y0,x1,y1,w0,h0);
+ #endif
+
if (((y0+h0)>512)||((x0+w0)>1024)||((y1+h0)>512)||((x1+w0)>1024))
{
- u16 *psxVuw=GPU_FrameBuffer;
+ u16 *psxVuw=gpu_unai.vram;
s32 i,j;
for(j=0;j<h0;j++)
for(i=0;i<w0;i++)
@@ -93,7 +101,7 @@ INLINE void gpuMoveImage(void)
else if ((x0&1)||(x1&1))
{
u16 *lpDst, *lpSrc;
- lpDst = lpSrc = (u16*)GPU_FrameBuffer;
+ lpDst = lpSrc = (u16*)gpu_unai.vram;
lpSrc += FRAME_OFFSET(x0, y0);
lpDst += FRAME_OFFSET(x1, y1);
x1 = FRAME_WIDTH - w0;
@@ -107,7 +115,7 @@ INLINE void gpuMoveImage(void)
else
{
u32 *lpDst, *lpSrc;
- lpDst = lpSrc = (u32*)(void*)GPU_FrameBuffer;
+ lpDst = lpSrc = (u32*)(void*)gpu_unai.vram;
lpSrc += ((FRAME_OFFSET(x0, y0))>>1);
lpDst += ((FRAME_OFFSET(x1, y1))>>1);
if (w0&1)
@@ -143,13 +151,13 @@ INLINE void gpuMoveImage(void)
}
}
-INLINE void gpuClearImage(void)
+void gpuClearImage(PtrUnion packet)
{
s32 x0, y0, w0, h0;
- x0 = PacketBuffer.S2[2];
- y0 = PacketBuffer.S2[3];
- w0 = PacketBuffer.S2[4] & 0x3ff;
- h0 = PacketBuffer.S2[5] & 0x3ff;
+ x0 = packet.S2[2];
+ y0 = packet.S2[3];
+ w0 = packet.S2[4] & 0x3ff;
+ h0 = packet.S2[5] & 0x3ff;
w0 += x0;
if (x0 < 0) x0 = 0;
@@ -162,10 +170,14 @@ INLINE void gpuClearImage(void)
h0 -= y0;
if (h0 <= 0) return;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"gpuClearImage(x0=%d,y0=%d,w0=%d,h0=%d)\n",x0,y0,w0,h0);
+ #endif
+
if (x0&1)
{
- u16* pixel = (u16*)GPU_FrameBuffer + FRAME_OFFSET(x0, y0);
- u16 rgb = GPU_RGB16(PacketBuffer.S4[0]);
+ u16* pixel = (u16*)gpu_unai.vram + FRAME_OFFSET(x0, y0);
+ u16 rgb = GPU_RGB16(packet.U4[0]);
y0 = FRAME_WIDTH - w0;
do {
x0=w0;
@@ -175,8 +187,8 @@ INLINE void gpuClearImage(void)
}
else
{
- u32* pixel = (u32*)(void*)GPU_FrameBuffer + ((FRAME_OFFSET(x0, y0))>>1);
- u32 rgb = GPU_RGB16(PacketBuffer.S4[0]);
+ u32* pixel = (u32*)gpu_unai.vram + ((FRAME_OFFSET(x0, y0))>>1);
+ u32 rgb = GPU_RGB16(packet.U4[0]);
rgb |= (rgb<<16);
if (w0&1)
{
diff --git a/plugins/gpu_unai/gpu_raster_line.h b/plugins/gpu_unai/gpu_raster_line.h
index fc59b79..28ea074 100644
--- a/plugins/gpu_unai/gpu_raster_line.h
+++ b/plugins/gpu_unai/gpu_raster_line.h
@@ -1,6 +1,7 @@
/***************************************************************************
* Copyright (C) 2010 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
* *
* 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 *
@@ -18,240 +19,697 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
***************************************************************************/
-#define GPU_TESTRANGE(x) { if((u32)(x+1024) > 2047) return; }
-
///////////////////////////////////////////////////////////////////////////////
// GPU internal line drawing functions
+//
+// Rewritten October 2016 by senquack:
+// Instead of one pixel at a time, lines are now drawn in runs of pixels,
+// whether vertical, horizontal, or diagonal. A new inner driver
+// 'gpuPixelSpanFn' is used, as well as an enhanced Bresenham run-slice
+// algorithm. For more information, see the following:
+//
+// Michael Abrash - Graphics Programming Black Book
+// Chapters 35 - 36 (does not implement diagonal runs)
+// http://www.drdobbs.com/parallel/graphics-programming-black-book/184404919
+// http://www.jagregory.com/abrash-black-book/
+//
+// Article by Andrew Delong (does not implement diagonal runs)
+// http://timetraces.ca/nw/drawline.htm
+//
+// 'Run-Based Multi-Point Line Drawing' by Eun Jae Lee & Larry F. Hodges
+// https://smartech.gatech.edu/bitstream/handle/1853/3632/93-22.pdf
+// Provided the idea of doing a half-octant transform allowing lines with
+// slopes between 0.5 and 2.0 (diagonal runs of pixels) to be handled
+// identically to the traditional horizontal/vertical run-slice method.
-#define GPU_DIGITS 16
-#define GPU_DIGITSC (GPU_DIGITS+3)
+// Use 16.16 fixed point precision for line math.
+// NOTE: Gouraud colors used by gpuPixelSpanFn can use a different precision.
+#define GPU_LINE_FIXED_BITS 16
-INLINE s32 GPU_DIV(s32 rs, s32 rt)
-{
- return rt ? (rs / rt) : (0);
-}
+// If defined, Gouraud lines will use fixed-point multiply-by-inverse to
+// do most divisions. With enough accuracy, this should be OK.
+#define USE_LINES_ALL_FIXED_PT_MATH
-///////////////////////////////////////////////////////////////////////////////
-void gpuDrawLF(const PD gpuPixelDriver)
+//////////////////////
+// Flat-shaded line //
+//////////////////////
+void gpuDrawLineF(PtrUnion packet, const PSD gpuPixelSpanDriver)
{
- 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);
+ int x0, y0, x1, y1;
+ int dx, dy;
+
+ // All three of these variables should be signed (so multiplication works)
+ ptrdiff_t sx; // Sign of x delta, positive when x0 < x1
+ const ptrdiff_t dst_depth = FRAME_BYTES_PER_PIXEL; // PSX: 2 bytes per pixel
+ const ptrdiff_t dst_stride = FRAME_BYTE_STRIDE; // PSX: 2048 bytes per framebuffer line
+
+ // Clip region: xmax/ymax seem to normally be one *past* the rightmost/
+ // bottommost pixels of the draw area. Since we render every pixel between
+ // and including both line endpoints, subtract one from xmax/ymax.
+ const int xmin = gpu_unai.DrawingArea[0];
+ const int ymin = gpu_unai.DrawingArea[1];
+ const int xmax = gpu_unai.DrawingArea[2] - 1;
+ const int ymax = gpu_unai.DrawingArea[3] - 1;
+
+ x0 = GPU_EXPANDSIGN(packet.S2[2]) + gpu_unai.DrawingOffset[0];
+ y0 = GPU_EXPANDSIGN(packet.S2[3]) + gpu_unai.DrawingOffset[1];
+ x1 = GPU_EXPANDSIGN(packet.S2[4]) + gpu_unai.DrawingOffset[0];
+ y1 = GPU_EXPANDSIGN(packet.S2[5]) + gpu_unai.DrawingOffset[1];
+
+ // Always draw top to bottom, so ensure y0 <= y1
+ if (y0 > y1) {
+ SwapValues(y0, y1);
+ SwapValues(x0, x1);
+ }
+
+ // Is line totally outside Y clipping range?
+ if (y0 > ymax || y1 < ymin) return;
+
+ dx = x1 - x0;
+ dy = y1 - y0;
+
+ // X-axis range check : max distance between any two X coords is 1023
+ // (PSX hardware will not render anything violating this rule)
+ // NOTE: We'll check y coord range further below
+ if (dx >= CHKMAX_X || dx <= -CHKMAX_X)
+ return;
+
+ // Y-axis range check and clipping
+ if (dy) {
+ // Y-axis range check : max distance between any two Y coords is 511
+ // (PSX hardware will not render anything violating this rule)
+ if (dy >= CHKMAX_Y)
+ return;
+
+ // We already know y0 < y1
+ if (y0 < ymin) {
+ x0 += GPU_FAST_DIV(((ymin - y0) * dx), dy);
+ y0 = ymin;
}
- y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx);
- y0 <<= GPU_DIGITS;
- temp = xmin - x0;
- if (temp > 0) {
- x0 = xmin;
- y0 += (y1 * temp);
+ if (y1 > ymax) {
+ x1 += GPU_FAST_DIV(((ymax - y1) * dx), dy);
+ y1 = ymax;
}
- 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);
- }
+
+ // Recompute in case clipping occurred:
+ dx = x1 - x0;
+ dy = y1 - y0;
+ }
+
+ // Check X clipping range, set 'sx' x-direction variable
+ if (dx == 0) {
+ // Is vertical line totally outside X clipping range?
+ if (x0 < xmin || x0 > xmax)
+ return;
+ sx = 0;
+ } else {
+ if (dx > 0) {
+ // x0 is leftmost coordinate
+ if (x0 > xmax) return; // Both points outside X clip range
+
+ if (x0 < xmin) {
+ if (x1 < xmin) return; // Both points outside X clip range
+ y0 += GPU_FAST_DIV(((xmin - x0) * dy), dx);
+ x0 = xmin;
+ }
+
+ if (x1 > xmax) {
+ y1 += GPU_FAST_DIV(((xmax - x1) * dy), dx);
+ x1 = xmax;
+ }
+
+ sx = +1;
+ dx = x1 - x0; // Get final value, which should also be absolute value
+ } else {
+ // x1 is leftmost coordinate
+ if (x1 > xmax) return; // Both points outside X clip range
+
+ if (x1 < xmin) {
+ if (x0 < xmin) return; // Both points outside X clip range
+
+ y1 += GPU_FAST_DIV(((xmin - x1) * dy), dx);
+ x1 = xmin;
}
- x0++;
- y0 += y1;
+
+ if (x0 > xmax) {
+ y0 += GPU_FAST_DIV(((xmax - x0) * dy), dx);
+ x0 = xmax;
+ }
+
+ sx = -1;
+ dx = x0 - x1; // Get final value, which should also be absolute value
+ }
+
+ // Recompute in case clipping occurred:
+ dy = y1 - y0;
+ }
+
+ // IMPORTANT: dx,dy should now contain their absolute values
+
+ int min_length, // Minimum length of a pixel run
+ start_length, // Length of first run
+ end_length, // Length of last run
+ err_term, // Cumulative error to determine when to draw longer run
+ err_adjup, // Increment to err_term for each run drawn
+ err_adjdown; // Subract this from err_term after drawing longer run
+
+ // Color to draw with (16 bits, highest of which is unset mask bit)
+ uintptr_t col16 = GPU_RGB16(packet.U4[0]);
+
+ // We use u8 pointers even though PS1 has u16 framebuffer.
+ // This allows pixel-drawing functions to increment dst pointer
+ // directly by the passed 'incr' value, not having to shift it first.
+ u8 *dst = (u8*)gpu_unai.vram + y0 * dst_stride + x0 * dst_depth;
+
+ // SPECIAL CASE: Vertical line
+ if (dx == 0) {
+ gpuPixelSpanDriver(dst, col16, dst_stride, dy+1);
+ return;
+ }
+
+ // SPECIAL CASE: Horizontal line
+ if (dy == 0) {
+ gpuPixelSpanDriver(dst, col16, sx * dst_depth, dx+1);
+ return;
+ }
+
+ // SPECIAL CASE: Diagonal line
+ if (dx == dy) {
+ gpuPixelSpanDriver(dst, col16, dst_stride + (sx * dst_depth), dy+1);
+ return;
+ }
+
+ int major, minor; // Major axis, minor axis
+ ptrdiff_t incr_major, incr_minor; // Ptr increment for each step along axis
+
+ if (dx > dy) {
+ major = dx;
+ minor = dy;
+ } else {
+ major = dy;
+ minor = dx;
+ }
+
+ // Determine if diagonal or horizontal runs
+ if (major < (2 * minor)) {
+ // Diagonal runs, so perform half-octant transformation
+ minor = major - minor;
+
+ // Advance diagonally when drawing runs
+ incr_major = dst_stride + (sx * dst_depth);
+
+ // After drawing each run, correct for over-advance along minor axis
+ if (dx > dy)
+ incr_minor = -dst_stride;
+ else
+ incr_minor = -sx * dst_depth;
+ } else {
+ // Horizontal or vertical runs
+ if (dx > dy) {
+ incr_major = sx * dst_depth;
+ incr_minor = dst_stride;
+ } else {
+ incr_major = dst_stride;
+ incr_minor = sx * dst_depth;
}
- } else if (dy) {
- if (y0 > y1) {
- GPU_SWAP(x0, x1, temp);
- GPU_SWAP(y0, y1, temp);
+ }
+
+ if (minor > 1) {
+ // Minimum number of pixels each run
+ min_length = major / minor;
+
+ // Initial error term; reflects an initial step of 0.5 along minor axis
+ err_term = (major % minor) - (minor * 2);
+
+ // Increment err_term this much each step along minor axis; when
+ // err_term crosses zero, draw longer pixel run.
+ err_adjup = (major % minor) * 2;
+ } else {
+ min_length = major;
+ err_term = 0;
+ err_adjup = 0;
+ }
+
+ // Error term adjustment when err_term turns over; used to factor
+ // out the major-axis step made at that time
+ err_adjdown = minor * 2;
+
+ // The initial and last runs are partial, because minor axis advances
+ // only 0.5 for these runs, rather than 1. Each is half a full run,
+ // plus the initial pixel.
+ start_length = end_length = (min_length / 2) + 1;
+
+ if (min_length & 1) {
+ // If there're an odd number of pixels per run, we have 1 pixel that
+ // can't be allocated to either the initial or last partial run, so
+ // we'll add 0.5 to err_term so that this pixel will be handled
+ // by the normal full-run loop
+ err_term += minor;
+ } else {
+ // If the minimum run length is even and there's no fractional advance,
+ // we have one pixel that could go to either the initial or last
+ // partial run, which we arbitrarily allocate to the last run
+ if (err_adjup == 0)
+ start_length--; // Leave out the extra pixel at the start
+ }
+
+ // First run of pixels
+ dst = gpuPixelSpanDriver(dst, col16, incr_major, start_length);
+ dst += incr_minor;
+
+ // Middle runs of pixels
+ while (--minor > 0) {
+ int run_length = min_length;
+ err_term += err_adjup;
+
+ // If err_term passed 0, reset it and draw longer run
+ if (err_term > 0) {
+ err_term -= err_adjdown;
+ run_length++;
}
- x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy);
- x0 <<= GPU_DIGITS;
- temp = ymin - y0;
- if (temp > 0) {
+
+ dst = gpuPixelSpanDriver(dst, col16, incr_major, run_length);
+ dst += incr_minor;
+ }
+
+ // Final run of pixels
+ gpuPixelSpanDriver(dst, col16, incr_major, end_length);
+}
+
+/////////////////////////
+// Gouraud-shaded line //
+/////////////////////////
+void gpuDrawLineG(PtrUnion packet, const PSD gpuPixelSpanDriver)
+{
+ int x0, y0, x1, y1;
+ int dx, dy, dr, dg, db;
+ u32 r0, g0, b0, r1, g1, b1;
+
+ // All three of these variables should be signed (so multiplication works)
+ ptrdiff_t sx; // Sign of x delta, positive when x0 < x1
+ const ptrdiff_t dst_depth = FRAME_BYTES_PER_PIXEL; // PSX: 2 bytes per pixel
+ const ptrdiff_t dst_stride = FRAME_BYTE_STRIDE; // PSX: 2048 bytes per framebuffer line
+
+ // Clip region: xmax/ymax seem to normally be one *past* the rightmost/
+ // bottommost pixels of the draw area. We'll render every pixel between
+ // and including both line endpoints, so subtract one from xmax/ymax.
+ const int xmin = gpu_unai.DrawingArea[0];
+ const int ymin = gpu_unai.DrawingArea[1];
+ const int xmax = gpu_unai.DrawingArea[2] - 1;
+ const int ymax = gpu_unai.DrawingArea[3] - 1;
+
+ x0 = GPU_EXPANDSIGN(packet.S2[2]) + gpu_unai.DrawingOffset[0];
+ y0 = GPU_EXPANDSIGN(packet.S2[3]) + gpu_unai.DrawingOffset[1];
+ x1 = GPU_EXPANDSIGN(packet.S2[6]) + gpu_unai.DrawingOffset[0];
+ y1 = GPU_EXPANDSIGN(packet.S2[7]) + gpu_unai.DrawingOffset[1];
+
+ u32 col0 = packet.U4[0];
+ u32 col1 = packet.U4[2];
+
+ // Always draw top to bottom, so ensure y0 <= y1
+ if (y0 > y1) {
+ SwapValues(y0, y1);
+ SwapValues(x0, x1);
+ SwapValues(col0, col1);
+ }
+
+ // Is line totally outside Y clipping range?
+ if (y0 > ymax || y1 < ymin) return;
+
+ // If defined, Gouraud colors are fixed-point 5.11, otherwise they are 8.16
+ // (This is only beneficial if using SIMD-optimized pixel driver)
+#ifdef GPU_GOURAUD_LOW_PRECISION
+ r0 = (col0 >> 3) & 0x1f; g0 = (col0 >> 11) & 0x1f; b0 = (col0 >> 19) & 0x1f;
+ r1 = (col1 >> 3) & 0x1f; g1 = (col1 >> 11) & 0x1f; b1 = (col1 >> 19) & 0x1f;
+#else
+ r0 = col0 & 0xff; g0 = (col0 >> 8) & 0xff; b0 = (col0 >> 16) & 0xff;
+ r1 = col1 & 0xff; g1 = (col1 >> 8) & 0xff; b1 = (col1 >> 16) & 0xff;
+#endif
+
+ dx = x1 - x0;
+ dy = y1 - y0;
+ dr = r1 - r0;
+ dg = g1 - g0;
+ db = b1 - b0;
+
+ // X-axis range check : max distance between any two X coords is 1023
+ // (PSX hardware will not render anything violating this rule)
+ // NOTE: We'll check y coord range further below
+ if (dx >= CHKMAX_X || dx <= -CHKMAX_X)
+ return;
+
+ // Y-axis range check and clipping
+ if (dy) {
+ // Y-axis range check : max distance between any two Y coords is 511
+ // (PSX hardware will not render anything violating this rule)
+ if (dy >= CHKMAX_Y)
+ return;
+
+ // We already know y0 < y1
+ if (y0 < ymin) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 factor = GPU_FAST_DIV(((ymin - y0) << GPU_LINE_FIXED_BITS), dy);
+ x0 += (dx * factor) >> GPU_LINE_FIXED_BITS;
+ r0 += (dr * factor) >> GPU_LINE_FIXED_BITS;
+ g0 += (dg * factor) >> GPU_LINE_FIXED_BITS;
+ b0 += (db * factor) >> GPU_LINE_FIXED_BITS;
+#else
+ x0 += (ymin - y0) * dx / dy;
+ r0 += (ymin - y0) * dr / dy;
+ g0 += (ymin - y0) * dg / dy;
+ b0 += (ymin - y0) * db / dy;
+#endif
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;
+
+ if (y1 > ymax) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 factor = GPU_FAST_DIV(((ymax - y1) << GPU_LINE_FIXED_BITS), dy);
+ x1 += (dx * factor) >> GPU_LINE_FIXED_BITS;
+ r1 += (dr * factor) >> GPU_LINE_FIXED_BITS;
+ g1 += (dg * factor) >> GPU_LINE_FIXED_BITS;
+ b1 += (db * factor) >> GPU_LINE_FIXED_BITS;
+#else
+ x1 += (ymax - y1) * dx / dy;
+ r1 += (ymax - y1) * dr / dy;
+ g1 += (ymax - y1) * dg / dy;
+ b1 += (ymax - y1) * db / dy;
+#endif
+ y1 = ymax;
}
-
+
+ // Recompute in case clipping occurred:
+ dx = x1 - x0;
+ dy = y1 - y0;
+ dr = r1 - r0;
+ dg = g1 - g0;
+ db = b1 - b0;
+ }
+
+ // Check X clipping range, set 'sx' x-direction variable
+ if (dx == 0) {
+ // Is vertical line totally outside X clipping range?
+ if (x0 < xmin || x0 > xmax)
+ return;
+ sx = 0;
} 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);
- }
+ if (dx > 0) {
+ // x0 is leftmost coordinate
+ if (x0 > xmax) return; // Both points outside X clip range
+
+ if (x0 < xmin) {
+ if (x1 < xmin) return; // Both points outside X clip range
+
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 factor = GPU_FAST_DIV(((xmin - x0) << GPU_LINE_FIXED_BITS), dx);
+ y0 += (dy * factor) >> GPU_LINE_FIXED_BITS;
+ r0 += (dr * factor) >> GPU_LINE_FIXED_BITS;
+ g0 += (dg * factor) >> GPU_LINE_FIXED_BITS;
+ b0 += (db * factor) >> GPU_LINE_FIXED_BITS;
+#else
+ y0 += (xmin - x0) * dy / dx;
+ r0 += (xmin - x0) * dr / dx;
+ g0 += (xmin - x0) * dg / dx;
+ b0 += (xmin - x0) * db / dx;
+#endif
+ x0 = xmin;
}
+
+ if (x1 > xmax) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 factor = GPU_FAST_DIV(((xmax - x1) << GPU_LINE_FIXED_BITS), dx);
+ y1 += (dy * factor) >> GPU_LINE_FIXED_BITS;
+ r1 += (dr * factor) >> GPU_LINE_FIXED_BITS;
+ g1 += (dg * factor) >> GPU_LINE_FIXED_BITS;
+ b1 += (db * factor) >> GPU_LINE_FIXED_BITS;
+#else
+ y1 += (xmax - x1) * dy / dx;
+ r1 += (xmax - x1) * dr / dx;
+ g1 += (xmax - x1) * dg / dx;
+ b1 += (xmax - x1) * db / dx;
+#endif
+ x1 = xmax;
+ }
+
+ sx = +1;
+ dx = x1 - x0; // Get final value, which should also be absolute value
+ } else {
+ // x1 is leftmost coordinate
+ if (x1 > xmax) return; // Both points outside X clip range
+
+ if (x1 < xmin) {
+ if (x0 < xmin) return; // Both points outside X clip range
+
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 factor = GPU_FAST_DIV(((xmin - x1) << GPU_LINE_FIXED_BITS), dx);
+ y1 += (dy * factor) >> GPU_LINE_FIXED_BITS;
+ r1 += (dr * factor) >> GPU_LINE_FIXED_BITS;
+ g1 += (dg * factor) >> GPU_LINE_FIXED_BITS;
+ b1 += (db * factor) >> GPU_LINE_FIXED_BITS;
+#else
+ y1 += (xmin - x1) * dy / dx;
+ r1 += (xmin - x1) * dr / dx;
+ g1 += (xmin - x1) * dg / dx;
+ b1 += (xmin - x1) * db / dx;
+#endif
+ x1 = xmin;
+ }
+
+ if (x0 > xmax) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 factor = GPU_FAST_DIV(((xmax - x0) << GPU_LINE_FIXED_BITS), dx);
+ y0 += (dy * factor) >> GPU_LINE_FIXED_BITS;
+ r0 += (dr * factor) >> GPU_LINE_FIXED_BITS;
+ g0 += (dg * factor) >> GPU_LINE_FIXED_BITS;
+ b0 += (db * factor) >> GPU_LINE_FIXED_BITS;
+#else
+ y0 += (xmax - x0) * dy / dx;
+ r0 += (xmax - x0) * dr / dx;
+ g0 += (xmax - x0) * dg / dx;
+ b0 += (xmax - x0) * db / dx;
+#endif
+ x0 = xmax;
+ }
+
+ sx = -1;
+ dx = x0 - x1; // Get final value, which should also be absolute value
}
+
+ // Recompute in case clipping occurred:
+ dy = y1 - y0;
+ dr = r1 - r0;
+ dg = g1 - g0;
+ db = b1 - b0;
}
-}
-/*----------------------------------------------------------------------
-GF
-----------------------------------------------------------------------*/
+ // IMPORTANT: dx,dy should now contain their absolute values
-///////////////////////////////////////////////////////////////////////////////
-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);
+ int min_length, // Minimum length of a pixel run
+ start_length, // Length of first run
+ end_length, // Length of last run
+ err_term, // Cumulative error to determine when to draw longer run
+ err_adjup, // Increment to err_term for each run drawn
+ err_adjdown; // Subract this from err_term after drawing longer run
+
+ GouraudColor gcol;
+ gcol.r = r0 << GPU_GOURAUD_FIXED_BITS;
+ gcol.g = g0 << GPU_GOURAUD_FIXED_BITS;
+ gcol.b = b0 << GPU_GOURAUD_FIXED_BITS;
+
+ // We use u8 pointers even though PS1 has u16 framebuffer.
+ // This allows pixel-drawing functions to increment dst pointer
+ // directly by the passed 'incr' value, not having to shift it first.
+ u8 *dst = (u8*)gpu_unai.vram + y0 * dst_stride + x0 * dst_depth;
+
+ // SPECIAL CASE: Vertical line
+ if (dx == 0) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ // Get dy fixed-point inverse
+ s32 inv_factor = 1 << GPU_GOURAUD_FIXED_BITS;
+ if (dy > 1) inv_factor = GPU_FAST_DIV(inv_factor, dy);
+
+ // Simultaneously divide and convert integer to Gouraud fixed point:
+ gcol.r_incr = dr * inv_factor;
+ gcol.g_incr = dg * inv_factor;
+ gcol.b_incr = db * inv_factor;
+#else
+ // First, convert to Gouraud fixed point
+ gcol.r_incr = dr << GPU_GOURAUD_FIXED_BITS;
+ gcol.g_incr = dg << GPU_GOURAUD_FIXED_BITS;
+ gcol.b_incr = db << GPU_GOURAUD_FIXED_BITS;
+
+ if (dy > 1) {
+ if (dr) gcol.r_incr /= dy;
+ if (dg) gcol.g_incr /= dy;
+ if (db) gcol.b_incr /= dy;
}
- if (x1 > xmax) x1 = xmax;
- x1 -= x0;
- if (x1 < 0) x1 = 0;
+#endif
- 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);
+ gpuPixelSpanDriver(dst, (uintptr_t)&gcol, dst_stride, dy+1);
+ return;
+ }
+
+ // SPECIAL CASE: Horizontal line
+ if (dy == 0) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ // Get dx fixed-point inverse
+ s32 inv_factor = (1 << GPU_GOURAUD_FIXED_BITS);
+ if (dx > 1) inv_factor = GPU_FAST_DIV(inv_factor, dx);
+
+ // Simultaneously divide and convert integer to Gouraud fixed point:
+ gcol.r_incr = dr * inv_factor;
+ gcol.g_incr = dg * inv_factor;
+ gcol.b_incr = db * inv_factor;
+#else
+ gcol.r_incr = dr << GPU_GOURAUD_FIXED_BITS;
+ gcol.g_incr = dg << GPU_GOURAUD_FIXED_BITS;
+ gcol.b_incr = db << GPU_GOURAUD_FIXED_BITS;
+
+ if (dx > 1) {
+ if (dr) gcol.r_incr /= dx;
+ if (dg) gcol.g_incr /= dx;
+ if (db) gcol.b_incr /= dx;
}
- 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);
+#endif
+
+ gpuPixelSpanDriver(dst, (uintptr_t)&gcol, sx * dst_depth, dx+1);
+ return;
+ }
+
+ // SPECIAL CASE: Diagonal line
+ if (dx == dy) {
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ // Get dx fixed-point inverse
+ s32 inv_factor = (1 << GPU_GOURAUD_FIXED_BITS);
+ if (dx > 1) inv_factor = GPU_FAST_DIV(inv_factor, dx);
+
+ // Simultaneously divide and convert integer to Gouraud fixed point:
+ gcol.r_incr = dr * inv_factor;
+ gcol.g_incr = dg * inv_factor;
+ gcol.b_incr = db * inv_factor;
+#else
+ // First, convert to Gouraud fixed point
+ gcol.r_incr = dr << GPU_GOURAUD_FIXED_BITS;
+ gcol.g_incr = dg << GPU_GOURAUD_FIXED_BITS;
+ gcol.b_incr = db << GPU_GOURAUD_FIXED_BITS;
+
+ if (dx > 1) {
+ if (dr) gcol.r_incr /= dx;
+ if (dg) gcol.g_incr /= dx;
+ if (db) gcol.b_incr /= dx;
}
- 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;
+#endif
+
+ gpuPixelSpanDriver(dst, (uintptr_t)&gcol, dst_stride + (sx * dst_depth), dy+1);
+ return;
+ }
+
+ int major, minor; // Absolute val of major,minor axis delta
+ ptrdiff_t incr_major, incr_minor; // Ptr increment for each step along axis
+
+ if (dx > dy) {
+ major = dx;
+ minor = dy;
+ } else {
+ major = dy;
+ minor = dx;
+ }
+
+ // Determine if diagonal or horizontal runs
+ if (major < (2 * minor)) {
+ // Diagonal runs, so perform half-octant transformation
+ minor = major - minor;
+
+ // Advance diagonally when drawing runs
+ incr_major = dst_stride + (sx * dst_depth);
+
+ // After drawing each run, correct for over-advance along minor axis
+ if (dx > dy)
+ incr_minor = -dst_stride;
+ else
+ incr_minor = -sx * dst_depth;
+ } else {
+ // Horizontal or vertical runs
+ if (dx > dy) {
+ incr_major = sx * dst_depth;
+ incr_minor = dst_stride;
+ } else {
+ incr_major = dst_stride;
+ incr_minor = sx * dst_depth;
}
+ }
+
+#ifdef USE_LINES_ALL_FIXED_PT_MATH
+ s32 major_inv = GPU_FAST_DIV((1 << GPU_GOURAUD_FIXED_BITS), major);
+
+ // Simultaneously divide and convert from integer to Gouraud fixed point:
+ gcol.r_incr = dr * major_inv;
+ gcol.g_incr = dg * major_inv;
+ gcol.b_incr = db * major_inv;
+#else
+ gcol.r_incr = dr ? ((dr << GPU_GOURAUD_FIXED_BITS) / major) : 0;
+ gcol.g_incr = dg ? ((dg << GPU_GOURAUD_FIXED_BITS) / major) : 0;
+ gcol.b_incr = db ? ((db << GPU_GOURAUD_FIXED_BITS) / major) : 0;
+#endif
+
+ if (minor > 1) {
+ // Minimum number of pixels each run
+ min_length = major / minor;
+
+ // Initial error term; reflects an initial step of 0.5 along minor axis
+ err_term = (major % minor) - (minor * 2);
+
+ // Increment err_term this much each step along minor axis; when
+ // err_term crosses zero, draw longer pixel run.
+ err_adjup = (major % minor) * 2;
} 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)
- );
- }
- }
+ min_length = major;
+ err_term = 0;
+ err_adjup = 0;
+ }
+
+ // Error term adjustment when err_term turns over; used to factor
+ // out the major-axis step made at that time
+ err_adjdown = minor * 2;
+
+ // The initial and last runs are partial, because minor axis advances
+ // only 0.5 for these runs, rather than 1. Each is half a full run,
+ // plus the initial pixel.
+ start_length = end_length = (min_length / 2) + 1;
+
+ if (min_length & 1) {
+ // If there're an odd number of pixels per run, we have 1 pixel that
+ // can't be allocated to either the initial or last partial run, so
+ // we'll add 0.5 to err_term so that this pixel will be handled
+ // by the normal full-run loop
+ err_term += minor;
+ } else {
+ // If the minimum run length is even and there's no fractional advance,
+ // we have one pixel that could go to either the initial or last
+ // partial run, which we'll arbitrarily allocate to the last run
+ if (err_adjup == 0)
+ start_length--; // Leave out the extra pixel at the start
+ }
+
+ // First run of pixels
+ dst = gpuPixelSpanDriver(dst, (uintptr_t)&gcol, incr_major, start_length);
+ dst += incr_minor;
+
+ // Middle runs of pixels
+ while (--minor > 0) {
+ int run_length = min_length;
+ err_term += err_adjup;
+
+ // If err_term passed 0, reset it and draw longer run
+ if (err_term > 0) {
+ err_term -= err_adjdown;
+ run_length++;
}
+
+ dst = gpuPixelSpanDriver(dst, (uintptr_t)&gcol, incr_major, run_length);
+ dst += incr_minor;
}
+
+ // Final run of pixels
+ gpuPixelSpanDriver(dst, (uintptr_t)&gcol, incr_major, end_length);
}
diff --git a/plugins/gpu_unai/gpu_raster_polygon.h b/plugins/gpu_unai/gpu_raster_polygon.h
index c4b0350..f66a9e2 100644
--- a/plugins/gpu_unai/gpu_raster_polygon.h
+++ b/plugins/gpu_unai/gpu_raster_polygon.h
@@ -18,732 +18,1431 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
***************************************************************************/
-#define GPU_TESTRANGE3() \
-{ \
- if(x0<0) { if((x1-x0)>CHKMAX_X) return; if((x2-x0)>CHKMAX_X) return; } \
- if(x1<0) { if((x0-x1)>CHKMAX_X) return; if((x2-x1)>CHKMAX_X) return; } \
- if(x2<0) { if((x0-x2)>CHKMAX_X) return; if((x1-x2)>CHKMAX_X) return; } \
- if(y0<0) { if((y1-y0)>CHKMAX_Y) return; if((y2-y0)>CHKMAX_Y) return; } \
- if(y1<0) { if((y0-y1)>CHKMAX_Y) return; if((y2-y1)>CHKMAX_Y) return; } \
- if(y2<0) { if((y0-y2)>CHKMAX_Y) return; if((y1-y2)>CHKMAX_Y) return; } \
-}
+//senquack - NOTE: GPU Unai poly routines have been rewritten/adapted
+// from DrHell routines to fix multiple issues. See README_senquack.txt
///////////////////////////////////////////////////////////////////////////////
-// GPU internal polygon drawing functions
+// Shared poly vertex buffer, able to handle 3 or 4-pt polys of any type.
+///////////////////////////////////////////////////////////////////////////////
+struct PolyVertex {
+ s32 x, y; // Sign-extended 11-bit X,Y coords
+ union {
+ struct { u8 u, v, pad[2]; } tex; // Texture coords (if used)
+ u32 tex_word;
+ };
+ union {
+ struct { u8 r, g, b, pad; } col; // 24-bit RGB color (if used)
+ u32 col_word;
+ };
+};
+
+enum PolyAttribute {
+ POLYATTR_TEXTURE = (1 << 0),
+ POLYATTR_GOURAUD = (1 << 1)
+};
+
+enum PolyType {
+ POLYTYPE_F = 0,
+ POLYTYPE_FT = (POLYATTR_TEXTURE),
+ POLYTYPE_G = (POLYATTR_GOURAUD),
+ POLYTYPE_GT = (POLYATTR_TEXTURE | POLYATTR_GOURAUD)
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// polyInitVertexBuffer()
+// Fills vbuf[] array with data from any type of poly draw-command packet.
///////////////////////////////////////////////////////////////////////////////
-void gpuDrawF3(const PP gpuPolySpanDriver)
+static void polyInitVertexBuffer(PolyVertex *vbuf, const PtrUnion packet, PolyType ptype, u32 is_quad)
{
- 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;
+ bool texturing = ptype & POLYATTR_TEXTURE;
+ bool gouraud = ptype & POLYATTR_GOURAUD;
+
+ int vert_stride = 1; // Stride of vertices in cmd packet, in 32-bit words
+ if (texturing)
+ vert_stride++;
+ if (gouraud)
+ vert_stride++;
+
+ int num_verts = (is_quad) ? 4 : 3;
+ u32 *ptr;
+
+ // X,Y coords, adjusted by draw offsets
+ s32 x_off = gpu_unai.DrawingOffset[0];
+ s32 y_off = gpu_unai.DrawingOffset[1];
+ ptr = &packet.U4[1];
+ for (int i=0; i < num_verts; ++i, ptr += vert_stride) {
+ s16* coord_ptr = (s16*)ptr;
+ vbuf[i].x = GPU_EXPANDSIGN(coord_ptr[0]) + x_off;
+ vbuf[i].y = GPU_EXPANDSIGN(coord_ptr[1]) + y_off;
+ }
- x0 = GPU_EXPANDSIGN(PacketBuffer.S2[2]);
- y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3]);
- x1 = GPU_EXPANDSIGN(PacketBuffer.S2[4]);
- y1 = GPU_EXPANDSIGN(PacketBuffer.S2[5]);
- x2 = GPU_EXPANDSIGN(PacketBuffer.S2[6]);
- y2 = GPU_EXPANDSIGN(PacketBuffer.S2[7]);
+ // U,V texture coords (if applicable)
+ if (texturing) {
+ ptr = &packet.U4[2];
+ for (int i=0; i < num_verts; ++i, ptr += vert_stride)
+ vbuf[i].tex_word = *ptr;
+ }
- GPU_TESTRANGE3();
+ // Colors (if applicable)
+ if (gouraud) {
+ ptr = &packet.U4[0];
+ for (int i=0; i < num_verts; ++i, ptr += vert_stride)
+ vbuf[i].col_word = *ptr;
+ }
+}
- x0 += DrawingOffset[0]; x1 += DrawingOffset[0]; x2 += DrawingOffset[0];
- y0 += DrawingOffset[1]; y1 += DrawingOffset[1]; y2 += DrawingOffset[1];
+///////////////////////////////////////////////////////////////////////////////
+// Helper functions to determine which vertex in a 2 or 3 vertex array
+// has the highest/lowest X/Y coordinate.
+// Note: the comparison logic is such that, given a set of vertices with
+// identical values for a given coordinate, a different index will be
+// returned from vertIdxOfLeast..() than a call to vertIdxOfHighest..().
+// This ensures that, during the vertex-ordering phase of rasterization,
+// all three vertices remain unique.
+///////////////////////////////////////////////////////////////////////////////
- xmin = DrawingArea[0]; xmax = DrawingArea[2];
- ymin = DrawingArea[1]; ymax = DrawingArea[3];
+template<typename T>
+static inline int vertIdxOfLeastXCoord2(const T *Tptr)
+{
+ return (Tptr[0].x <= Tptr[1].x) ? 0 : 1;
+}
- {
- 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]);
+template<typename T>
+static inline int vertIdxOfLeastXCoord3(const T *Tptr)
+{
+ int least_of_v0_v1 = vertIdxOfLeastXCoord2(Tptr);
+ return (Tptr[least_of_v0_v1].x <= Tptr[2].x) ? least_of_v0_v1 : 2;
+}
- 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);
- }
- }
+template<typename T>
+static inline int vertIdxOfLeastYCoord2(const T *Tptr)
+{
+ return (Tptr[0].y <= Tptr[1].y) ? 0 : 1;
+}
- ya = y2 - y0;
- yb = y2 - y1;
- dx =(x2 - x1) * ya - (x2 - x0) * yb;
+template<typename T>
+static inline int vertIdxOfLeastYCoord3(const T *Tptr)
+{
+ int least_of_v0_v1 = vertIdxOfLeastYCoord2(Tptr);
+ return (Tptr[least_of_v0_v1].y <= Tptr[2].y) ? least_of_v0_v1 : 2;
+}
+
+template<typename T>
+static inline int vertIdxOfHighestXCoord2(const T *Tptr)
+{
+ return (Tptr[1].x >= Tptr[0].x) ? 1 : 0;
+}
+
+template<typename T>
+static inline int vertIdxOfHighestXCoord3(const T *Tptr)
+{
+ int highest_of_v0_v1 = vertIdxOfHighestXCoord2(Tptr);
+ return (Tptr[2].x >= Tptr[highest_of_v0_v1].x) ? 2 : highest_of_v0_v1;
+}
+
+template<typename T>
+static inline int vertIdxOfHighestYCoord2(const T *Tptr)
+{
+ return (Tptr[1].y >= Tptr[0].y) ? 1 : 0;
+}
+
+template<typename T>
+static inline int vertIdxOfHighestYCoord3(const T *Tptr)
+{
+ int highest_of_v0_v1 = vertIdxOfHighestYCoord2(Tptr);
+ return (Tptr[2].y >= Tptr[highest_of_v0_v1].y) ? 2 : highest_of_v0_v1;
+}
- for (s32 loop0 = 2; loop0; --loop0)
+///////////////////////////////////////////////////////////////////////////////
+// polyUseTriangle()
+// Determines if the specified triangle should be rendered. If so, it
+// fills the given array of vertex pointers, vert_ptrs, in order of
+// increasing Y coordinate values, as required by rasterization algorithm.
+// Parameter 'tri_num' is 0 for first triangle (idx 0,1,2 of vbuf[]),
+// or 1 for second triangle of a quad (idx 1,2,3 of vbuf[]).
+// Returns true if triangle should be rendered, false if not.
+///////////////////////////////////////////////////////////////////////////////
+static bool polyUseTriangle(const PolyVertex *vbuf, int tri_num, const PolyVertex **vert_ptrs)
+{
+ // Using verts 0,1,2 or is this the 2nd pass of a quad (verts 1,2,3)?
+ const PolyVertex *tri_ptr = &vbuf[(tri_num == 0) ? 0 : 1];
+
+ // Get indices of highest/lowest X,Y coords within triangle
+ int idx_lowest_x = vertIdxOfLeastXCoord3(tri_ptr);
+ int idx_highest_x = vertIdxOfHighestXCoord3(tri_ptr);
+ int idx_lowest_y = vertIdxOfLeastYCoord3(tri_ptr);
+ int idx_highest_y = vertIdxOfHighestYCoord3(tri_ptr);
+
+ // Maximum absolute distance between any two X coordinates is 1023,
+ // and for Y coordinates is 511 (PS1 hardware limitation)
+ int lowest_x = tri_ptr[idx_lowest_x].x;
+ int highest_x = tri_ptr[idx_highest_x].x;
+ int lowest_y = tri_ptr[idx_lowest_y].y;
+ int highest_y = tri_ptr[idx_highest_y].y;
+ if ((highest_x - lowest_x) >= CHKMAX_X ||
+ (highest_y - lowest_y) >= CHKMAX_Y)
+ return false;
+
+ // Determine if triangle is completely outside clipping range
+ int xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+ int clipped_lowest_x = Max2(xmin,lowest_x);
+ int clipped_lowest_y = Max2(ymin,lowest_y);
+ int clipped_highest_x = Min2(xmax,highest_x);
+ int clipped_highest_y = Min2(ymax,highest_y);
+ if (clipped_lowest_x >= clipped_highest_x ||
+ clipped_lowest_y >= clipped_highest_y)
+ return false;
+
+ // Order vertex ptrs by increasing y value (draw routines need this).
+ // The middle index is deduced by a binary math trick that depends
+ // on index range always being between 0..2
+ vert_ptrs[0] = tri_ptr + idx_lowest_y;
+ vert_ptrs[1] = tri_ptr + ((idx_lowest_y + idx_highest_y) ^ 3);
+ vert_ptrs[2] = tri_ptr + idx_highest_y;
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal polygon drawing functions
+///////////////////////////////////////////////////////////////////////////////
+
+/*----------------------------------------------------------------------
+gpuDrawPolyF - Flat-shaded, untextured poly
+----------------------------------------------------------------------*/
+void gpuDrawPolyF(const PtrUnion packet, const PP gpuPolySpanDriver, u32 is_quad)
+{
+ // Set up bgr555 color to be used across calls in inner driver
+ gpu_unai.PixelData = GPU_RGB16(packet.U4[0]);
+
+ PolyVertex vbuf[4];
+ polyInitVertexBuffer(vbuf, packet, POLYTYPE_F, is_quad);
+
+ int total_passes = is_quad ? 2 : 1;
+ int cur_pass = 0;
+ do
{
- 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));
+ const PolyVertex* vptrs[3];
+ if (polyUseTriangle(vbuf, cur_pass, vptrs) == false)
+ continue;
+
+ s32 xa, xb, ya, yb;
+ s32 x3, dx3, x4, dx4, dx;
+ s32 x0, x1, x2, y0, y1, y2;
+
+ x0 = vptrs[0]->x; y0 = vptrs[0]->y;
+ x1 = vptrs[1]->x; y1 = vptrs[1]->y;
+ x2 = vptrs[2]->x; y2 = vptrs[2]->y;
+
+ ya = y2 - y0;
+ yb = y2 - y1;
+ dx = (x2 - x1) * ya - (x2 - x0) * yb;
+
+ for (int loop0 = 2; loop0; loop0--) {
+ if (loop0 == 2) {
+ ya = y0; yb = y1;
+ x3 = x4 = i2x(x0);
+ if (dx < 0) {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx3 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) * FloatInv(y2 - y0)) : 0;
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) * FloatInv(y1 - y0)) : 0;
+#else
+ dx3 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) / (float)(y2 - y0)) : 0;
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) / (float)(y1 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx3 = ((y2 - y0) != 0) ? xLoDivx((x2 - x0), (y2 - y0)) : 0;
+ dx4 = ((y1 - y0) != 0) ? xLoDivx((x1 - x0), (y1 - y0)) : 0;
+#else
+ dx3 = ((y2 - y0) != 0) ? GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0)) : 0;
+ dx4 = ((y1 - y0) != 0) ? GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0)) : 0;
+#endif
+#endif
+ } else {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx3 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) * FloatInv(y1 - y0)) : 0;
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) * FloatInv(y2 - y0)) : 0;
+#else
+ dx3 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) / (float)(y1 - y0)) : 0;
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) / (float)(y2 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx3 = ((y1 - y0) != 0) ? xLoDivx((x1 - x0), (y1 - y0)) : 0;
+ dx4 = ((y2 - y0) != 0) ? xLoDivx((x2 - x0), (y2 - y0)) : 0;
+#else
+ dx3 = ((y1 - y0) != 0) ? GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0)) : 0;
+ dx4 = ((y2 - y0) != 0) ? GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0)) : 0;
+#endif
+#endif
+ }
+ } else {
+ //senquack - break out of final loop if nothing to be drawn (1st loop
+ // must always be taken to setup dx3/dx4)
+ if (y1 == y2) break;
+
+ ya = y1; yb = y2;
+
+ if (dx < 0) {
+ x3 = i2x(x0) + (dx3 * (y1 - y0));
+ x4 = i2x(x1);
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) * FloatInv(y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) / (float)(y2 - y1)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? xLoDivx ((x2 - x1), (y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1)) : 0;
+#endif
+#endif
+ } else {
+ x3 = i2x(x1);
+ x4 = i2x(x0) + (dx4 * (y1 - y0));
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx3 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) * FloatInv(y2 - y1)) : 0;
+#else
+ dx3 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) / (float)(y2 - y1)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx3 = ((y2 - y1) != 0) ? xLoDivx ((x2 - x1), (y2 - y1)) : 0;
+#else
+ dx3 = ((y2 - y1) != 0) ? GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1)) : 0;
+#endif
+#endif
+ }
}
- }
- else
- {
- ya = y1;
- yb = y2;
- if (dx < 0)
- {
- x4 = i2x(x1);
- x3 = i2x(x0) + (dx3 * (y1 - y0));
- dx4 = xLoDivx((x2 - x1), (y2 - y1));
+
+ s32 xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+
+ if ((ymin - ya) > 0) {
+ x3 += (dx3 * (ymin - ya));
+ x4 += (dx4 * (ymin - ya));
+ ya = ymin;
}
- else
+
+ if (yb > ymax) yb = ymax;
+
+ int loop1 = yb - ya;
+ if (loop1 <= 0)
+ continue;
+
+ u16* PixelBase = &((u16*)gpu_unai.vram)[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+
+ for (; loop1; --loop1, ya++, PixelBase += FRAME_WIDTH,
+ x3 += dx3, x4 += dx4 )
{
- x3 = i2x(x1);
- x4 = i2x(x0) + (dx4 * (y1 - y0));
- dx3 = xLoDivx((x2 - x1), (y2 - y1));
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+
+ xa = FixedCeilToInt(x3); xb = FixedCeilToInt(x4);
+ if ((xmin - xa) > 0) xa = xmin;
+ if (xb > xmax) xb = xmax;
+ if ((xb - xa) > 0)
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
}
-
- 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)];
-
- for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4)
- {
- if (ya&li) continue;
- xa = x2i(x3);
- xb = x2i(x4);
- if( (xa>xmax) || (xb<xmin) ) continue;
- if(xa < xmin) xa = xmin;
- if(xb > xmax) xb = xmax;
- xb-=xa;
- if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
- }
- }
+ } while (++cur_pass < total_passes);
}
/*----------------------------------------------------------------------
-FT3
+gpuDrawPolyFT - Flat-shaded, textured poly
----------------------------------------------------------------------*/
-
-void gpuDrawFT3(const PP gpuPolySpanDriver)
+void gpuDrawPolyFT(const PtrUnion packet, const PP gpuPolySpanDriver, u32 is_quad)
{
- 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(PacketBuffer.S2[2] );
- y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3] );
- x1 = GPU_EXPANDSIGN(PacketBuffer.S2[6] );
- y1 = GPU_EXPANDSIGN(PacketBuffer.S2[7] );
- x2 = GPU_EXPANDSIGN(PacketBuffer.S2[10]);
- y2 = GPU_EXPANDSIGN(PacketBuffer.S2[11]);
-
- GPU_TESTRANGE3();
-
- 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];
-
+ // r8/g8/b8 used if texture-blending & dithering is applied (24-bit light)
+ gpu_unai.r8 = packet.U1[0];
+ gpu_unai.g8 = packet.U1[1];
+ gpu_unai.b8 = packet.U1[2];
+ // r5/g5/b5 used if just texture-blending is applied (15-bit light)
+ gpu_unai.r5 = packet.U1[0] >> 3;
+ gpu_unai.g5 = packet.U1[1] >> 3;
+ gpu_unai.b5 = packet.U1[2] >> 3;
+
+ PolyVertex vbuf[4];
+ polyInitVertexBuffer(vbuf, packet, POLYTYPE_FT, is_quad);
+
+ int total_passes = is_quad ? 2 : 1;
+ int cur_pass = 0;
+ do
{
- 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;
+ const PolyVertex* vptrs[3];
+ if (polyUseTriangle(vbuf, cur_pass, vptrs) == false)
+ continue;
+
+ s32 xa, xb, ya, yb;
+ s32 x3, dx3, x4, dx4, dx;
+ s32 u3, du3, v3, dv3;
+ s32 x0, x1, x2, y0, y1, y2;
+ s32 u0, u1, u2, v0, v1, v2;
+ s32 du4, dv4;
+
+ x0 = vptrs[0]->x; y0 = vptrs[0]->y;
+ u0 = vptrs[0]->tex.u; v0 = vptrs[0]->tex.v;
+ x1 = vptrs[1]->x; y1 = vptrs[1]->y;
+ u1 = vptrs[1]->tex.u; v1 = vptrs[1]->tex.v;
+ x2 = vptrs[2]->x; y2 = vptrs[2]->y;
+ u2 = vptrs[2]->tex.u; v2 = vptrs[2]->tex.v;
+
+ ya = y2 - y0;
+ yb = y2 - y1;
+ dx4 = (x2 - x1) * ya - (x2 - x0) * yb;
+ du4 = (u2 - u1) * ya - (u2 - u0) * yb;
+ dv4 = (v2 - v1) * ya - (v2 - v0) * yb;
+ dx = dx4;
+ if (dx4 < 0) {
+ dx4 = -dx4;
+ du4 = -du4;
+ dv4 = -dv4;
+ }
- 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);
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if (dx4 != 0) {
+ float finv = FloatInv(dx4);
+ du4 = (fixed)((du4 << FIXED_BITS) * finv);
+ dv4 = (fixed)((dv4 << FIXED_BITS) * finv);
+ } else {
+ du4 = dv4 = 0;
}
- }
- 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);
+#else
+ if (dx4 != 0) {
+ float fdiv = dx4;
+ du4 = (fixed)((du4 << FIXED_BITS) / fdiv);
+ dv4 = (fixed)((dv4 << FIXED_BITS) / fdiv);
+ } else {
+ du4 = dv4 = 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);
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if (dx4 != 0) {
+ int iF, iS;
+ xInv(dx4, iF, iS);
+ du4 = xInvMulx(du4, iF, iS);
+ dv4 = xInvMulx(dv4, iF, iS);
+ } else {
+ du4 = dv4 = 0;
}
- }
-
- 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;
+#else
+ if (dx4 != 0) {
+ du4 = GPU_FAST_DIV(du4 << FIXED_BITS, dx4);
+ dv4 = GPU_FAST_DIV(dv4 << FIXED_BITS, dx4);
+ } else {
+ du4 = dv4 = 0;
+ }
+#endif
+#endif
+ // Set u,v increments for inner driver
+ gpu_unai.u_inc = du4;
+ gpu_unai.v_inc = dv4;
+
+ //senquack - TODO: why is it always going through 2 iterations when sometimes one would suffice here?
+ // (SAME ISSUE ELSEWHERE)
+ for (s32 loop0 = 2; loop0; loop0--) {
+ if (loop0 == 2) {
+ ya = y0; yb = y1;
+ x3 = x4 = i2x(x0);
+ u3 = i2x(u0); v3 = i2x(v0);
+ if (dx < 0) {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y2 - y0) != 0) {
+ float finv = FloatInv(y2 - y0);
+ dx3 = (fixed)(((x2 - x0) << FIXED_BITS) * finv);
+ du3 = (fixed)(((u2 - u0) << FIXED_BITS) * finv);
+ dv3 = (fixed)(((v2 - v0) << FIXED_BITS) * finv);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) * FloatInv(y1 - y0)) : 0;
+#else
+ if ((y2 - y0) != 0) {
+ float fdiv = y2 - y0;
+ dx3 = (fixed)(((x2 - x0) << FIXED_BITS) / fdiv);
+ du3 = (fixed)(((u2 - u0) << FIXED_BITS) / fdiv);
+ dv3 = (fixed)(((v2 - v0) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) / (float)(y1 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y2 - y0) != 0) {
+ int iF, iS;
+ xInv((y2 - y0), iF, iS);
+ dx3 = xInvMulx((x2 - x0), iF, iS);
+ du3 = xInvMulx((u2 - u0), iF, iS);
+ dv3 = xInvMulx((v2 - v0), iF, iS);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? xLoDivx((x1 - x0), (y1 - y0)) : 0;
+#else
+ if ((y2 - y0) != 0) {
+ dx3 = GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0));
+ du3 = GPU_FAST_DIV((u2 - u0) << FIXED_BITS, (y2 - y0));
+ dv3 = GPU_FAST_DIV((v2 - v0) << FIXED_BITS, (y2 - y0));
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0)) : 0;
+#endif
+#endif
+ } else {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y1 - y0) != 0) {
+ float finv = FloatInv(y1 - y0);
+ dx3 = (fixed)(((x1 - x0) << FIXED_BITS) * finv);
+ du3 = (fixed)(((u1 - u0) << FIXED_BITS) * finv);
+ dv3 = (fixed)(((v1 - v0) << FIXED_BITS) * finv);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) * FloatInv(y2 - y0)) : 0;
+#else
+ if ((y1 - y0) != 0) {
+ float fdiv = y1 - y0;
+ dx3 = (fixed)(((x1 - x0) << FIXED_BITS) / fdiv);
+ du3 = (fixed)(((u1 - u0) << FIXED_BITS) / fdiv);
+ dv3 = (fixed)(((v1 - v0) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) / (float)(y2 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y1 - y0) != 0) {
+ int iF, iS;
+ xInv((y1 - y0), iF, iS);
+ dx3 = xInvMulx((x1 - x0), iF, iS);
+ du3 = xInvMulx((u1 - u0), iF, iS);
+ dv3 = xInvMulx((v1 - v0), iF, iS);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? xLoDivx((x2 - x0), (y2 - y0)) : 0;
+#else
+ if ((y1 - y0) != 0) {
+ dx3 = GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0));
+ du3 = GPU_FAST_DIV((u1 - u0) << FIXED_BITS, (y1 - y0));
+ dv3 = GPU_FAST_DIV((v1 - v0) << FIXED_BITS, (y1 - y0));
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0)) : 0;
+#endif
+#endif
+ }
+ } else {
+ //senquack - break out of final loop if nothing to be drawn (1st loop
+ // must always be taken to setup dx3/dx4)
+ if (y1 == y2) break;
+
+ ya = y1; yb = y2;
+
+ if (dx < 0) {
+ x3 = i2x(x0);
+ x4 = i2x(x1);
+ u3 = i2x(u0);
+ v3 = i2x(v0);
+ if ((y1 - y0) != 0) {
+ x3 += (dx3 * (y1 - y0));
+ u3 += (du3 * (y1 - y0));
+ v3 += (dv3 * (y1 - y0));
+ }
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) * FloatInv(y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) / (float)(y2 - y1)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? xLoDivx((x2 - x1), (y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1)) : 0;
+#endif
+#endif
+ } else {
+ x3 = i2x(x1);
+ x4 = i2x(x0) + (dx4 * (y1 - y0));
+ u3 = i2x(u1);
+ v3 = i2x(v1);
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y2 - y1) != 0) {
+ float finv = FloatInv(y2 - y1);
+ dx3 = (fixed)(((x2 - x1) << FIXED_BITS) * finv);
+ du3 = (fixed)(((u2 - u1) << FIXED_BITS) * finv);
+ dv3 = (fixed)(((v2 - v1) << FIXED_BITS) * finv);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+#else
+ if ((y2 - y1) != 0) {
+ float fdiv = y2 - y1;
+ dx3 = (fixed)(((x2 - x1) << FIXED_BITS) / fdiv);
+ du3 = (fixed)(((u2 - u1) << FIXED_BITS) / fdiv);
+ dv3 = (fixed)(((v2 - v1) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y2 - y1) != 0) {
+ int iF, iS;
+ xInv((y2 - y1), iF, iS);
+ dx3 = xInvMulx((x2 - x1), iF, iS);
+ du3 = xInvMulx((u2 - u1), iF, iS);
+ dv3 = xInvMulx((v2 - v1), iF, iS);
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+#else
+ if ((y2 - y1) != 0) {
+ dx3 = GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1));
+ du3 = GPU_FAST_DIV((u2 - u1) << FIXED_BITS, (y2 - y1));
+ dv3 = GPU_FAST_DIV((v2 - v1) << FIXED_BITS, (y2 - y1));
+ } else {
+ dx3 = du3 = dv3 = 0;
+ }
+#endif
+#endif
+ }
+ }
- 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;
+ s32 xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
- 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));
+ if ((ymin - ya) > 0) {
+ x3 += dx3 * (ymin - ya);
+ x4 += dx4 * (ymin - ya);
+ u3 += du3 * (ymin - ya);
+ v3 += dv3 * (ymin - ya);
+ ya = ymin;
}
- }
- 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
+
+ if (yb > ymax) yb = ymax;
+
+ int loop1 = yb - ya;
+ if (loop1 <= 0)
+ continue;
+
+ u16* PixelBase = &((u16*)gpu_unai.vram)[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+
+ for (; loop1; --loop1, ++ya, PixelBase += FRAME_WIDTH,
+ x3 += dx3, x4 += dx4,
+ u3 += du3, v3 += dv3 )
{
- 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);
- }
- }
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
- 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;
+ u32 u4, v4;
- x3+= fixed_HALF;
- x4+= fixed_HALF;
- u3+= fixed_HALF;
- v4+= fixed_HALF;
+ xa = FixedCeilToInt(x3); xb = FixedCeilToInt(x4);
+ u4 = u3; v4 = v3;
- u16* PixelBase = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
+ fixed itmp = i2x(xa) - x3;
+ if (itmp != 0) {
+ u4 += (du4 * itmp) >> FIXED_BITS;
+ v4 += (dv4 * itmp) >> FIXED_BITS;
+ }
- for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3)
- {
- if (ya&li) continue;
- xa = x2i(x3);
- xb = x2i(x4);
- if( (xa>xmax) || (xb<xmin) ) continue;
+ u4 += fixed_HALF;
+ v4 += fixed_HALF;
- temp = xmin - xa;
- if(temp > 0)
- {
- xa = xmin;
- u4 = u3 + du4*temp;
- v4 = v3 + dv4*temp;
- }
- else
- {
- u4 = u3;
- v4 = v3;
+ if ((xmin - xa) > 0) {
+ u4 += du4 * (xmin - xa);
+ v4 += dv4 * (xmin - xa);
+ xa = xmin;
+ }
+
+ // Set u,v coords for inner driver
+ gpu_unai.u = u4;
+ gpu_unai.v = v4;
+
+ if (xb > xmax) xb = xmax;
+ if ((xb - xa) > 0)
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
- if(xb > xmax) xb = xmax;
- xb-=xa;
- if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
}
- }
+ } while (++cur_pass < total_passes);
}
/*----------------------------------------------------------------------
-G3
+gpuDrawPolyG - Gouraud-shaded, untextured poly
----------------------------------------------------------------------*/
-
-void gpuDrawG3(const PP gpuPolySpanDriver)
+void gpuDrawPolyG(const PtrUnion packet, const PP gpuPolySpanDriver, u32 is_quad)
{
- 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(PacketBuffer.S2[2] );
- y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3] );
- x1 = GPU_EXPANDSIGN(PacketBuffer.S2[6] );
- y1 = GPU_EXPANDSIGN(PacketBuffer.S2[7] );
- x2 = GPU_EXPANDSIGN(PacketBuffer.S2[10]);
- y2 = GPU_EXPANDSIGN(PacketBuffer.S2[11]);
-
- GPU_TESTRANGE3();
-
- 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];
+ PolyVertex vbuf[4];
+ polyInitVertexBuffer(vbuf, packet, POLYTYPE_G, is_quad);
+ int total_passes = is_quad ? 2 : 1;
+ int cur_pass = 0;
+ do
{
- 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];
+ const PolyVertex* vptrs[3];
+ if (polyUseTriangle(vbuf, cur_pass, vptrs) == false)
+ continue;
+
+ s32 xa, xb, ya, yb;
+ s32 x3, dx3, x4, dx4, dx;
+ s32 r3, dr3, g3, dg3, b3, db3;
+ s32 x0, x1, x2, y0, y1, y2;
+ s32 r0, r1, r2, g0, g1, g2, b0, b1, b2;
+ s32 dr4, dg4, db4;
+
+ x0 = vptrs[0]->x; y0 = vptrs[0]->y;
+ r0 = vptrs[0]->col.r; g0 = vptrs[0]->col.g; b0 = vptrs[0]->col.b;
+ x1 = vptrs[1]->x; y1 = vptrs[1]->y;
+ r1 = vptrs[1]->col.r; g1 = vptrs[1]->col.g; b1 = vptrs[1]->col.b;
+ x2 = vptrs[2]->x; y2 = vptrs[2]->y;
+ r2 = vptrs[2]->col.r; g2 = vptrs[2]->col.g; b2 = vptrs[2]->col.b;
+
+ ya = y2 - y0;
+ yb = y2 - y1;
+ dx4 = (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;
+ dx = dx4;
+ if (dx4 < 0) {
+ dx4 = -dx4;
+ dr4 = -dr4;
+ dg4 = -dg4;
+ db4 = -db4;
+ }
- 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);
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if (dx4 != 0) {
+ float finv = FloatInv(dx4);
+ dr4 = (fixed)((dr4 << FIXED_BITS) * finv);
+ dg4 = (fixed)((dg4 << FIXED_BITS) * finv);
+ db4 = (fixed)((db4 << FIXED_BITS) * finv);
+ } else {
+ dr4 = dg4 = db4 = 0;
}
- }
- 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);
+#else
+ if (dx4 != 0) {
+ float fdiv = dx4;
+ dr4 = (fixed)((dr4 << FIXED_BITS) / fdiv);
+ dg4 = (fixed)((dg4 << FIXED_BITS) / fdiv);
+ db4 = (fixed)((db4 << FIXED_BITS) / fdiv);
+ } else {
+ dr4 = dg4 = db4 = 0;
}
- }
- 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);
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if (dx4 != 0) {
+ int iF, iS;
+ xInv(dx4, iF, iS);
+ dr4 = xInvMulx(dr4, iF, iS);
+ dg4 = xInvMulx(dg4, iF, iS);
+ db4 = xInvMulx(db4, iF, iS);
+ } else {
+ dr4 = dg4 = db4 = 0;
}
- }
-
- 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
+ if (dx4 != 0) {
+ dr4 = GPU_FAST_DIV(dr4 << FIXED_BITS, dx4);
+ dg4 = GPU_FAST_DIV(dg4 << FIXED_BITS, dx4);
+ db4 = GPU_FAST_DIV(db4 << FIXED_BITS, dx4);
+ } else {
+ dr4 = dg4 = db4 = 0;
}
- 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);
+#endif
+#endif
+ // Setup packed Gouraud increment for inner driver
+ gpu_unai.gInc = gpuPackGouraudColInc(dr4, dg4, db4);
+
+ for (s32 loop0 = 2; loop0; loop0--) {
+ if (loop0 == 2) {
+ ya = y0;
+ yb = y1;
+ x3 = x4 = i2x(x0);
+ r3 = i2x(r0);
+ g3 = i2x(g0);
+ b3 = i2x(b0);
+ if (dx < 0) {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y2 - y0) != 0) {
+ float finv = FloatInv(y2 - y0);
+ dx3 = (fixed)(((x2 - x0) << FIXED_BITS) * finv);
+ dr3 = (fixed)(((r2 - r0) << FIXED_BITS) * finv);
+ dg3 = (fixed)(((g2 - g0) << FIXED_BITS) * finv);
+ db3 = (fixed)(((b2 - b0) << FIXED_BITS) * finv);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) * FloatInv(y1 - y0)) : 0;
+#else
+ if ((y2 - y0) != 0) {
+ float fdiv = y2 - y0;
+ dx3 = (fixed)(((x2 - x0) << FIXED_BITS) / fdiv);
+ dr3 = (fixed)(((r2 - r0) << FIXED_BITS) / fdiv);
+ dg3 = (fixed)(((g2 - g0) << FIXED_BITS) / fdiv);
+ db3 = (fixed)(((b2 - b0) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) / (float)(y1 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y2 - y0) != 0) {
+ int iF, iS;
+ 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);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? xLoDivx((x1 - x0), (y1 - y0)) : 0;
+#else
+ if ((y2 - y0) != 0) {
+ dx3 = GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0));
+ dr3 = GPU_FAST_DIV((r2 - r0) << FIXED_BITS, (y2 - y0));
+ dg3 = GPU_FAST_DIV((g2 - g0) << FIXED_BITS, (y2 - y0));
+ db3 = GPU_FAST_DIV((b2 - b0) << FIXED_BITS, (y2 - y0));
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0)) : 0;
+#endif
+#endif
+ } else {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y1 - y0) != 0) {
+ float finv = FloatInv(y1 - y0);
+ dx3 = (fixed)(((x1 - x0) << FIXED_BITS) * finv);
+ dr3 = (fixed)(((r1 - r0) << FIXED_BITS) * finv);
+ dg3 = (fixed)(((g1 - g0) << FIXED_BITS) * finv);
+ db3 = (fixed)(((b1 - b0) << FIXED_BITS) * finv);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) * FloatInv(y2 - y0)) : 0;
+#else
+ if ((y1 - y0) != 0) {
+ float fdiv = y1 - y0;
+ dx3 = (fixed)(((x1 - x0) << FIXED_BITS) / fdiv);
+ dr3 = (fixed)(((r1 - r0) << FIXED_BITS) / fdiv);
+ dg3 = (fixed)(((g1 - g0) << FIXED_BITS) / fdiv);
+ db3 = (fixed)(((b1 - b0) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) / (float)(y2 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y1 - y0) != 0) {
+ int iF, iS;
+ 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);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? xLoDivx((x2 - x0), (y2 - y0)) : 0;
+#else
+ if ((y1 - y0) != 0) {
+ dx3 = GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0));
+ dr3 = GPU_FAST_DIV((r1 - r0) << FIXED_BITS, (y1 - y0));
+ dg3 = GPU_FAST_DIV((g1 - g0) << FIXED_BITS, (y1 - y0));
+ db3 = GPU_FAST_DIV((b1 - b0) << FIXED_BITS, (y1 - y0));
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0)) : 0;
+#endif
+#endif
+ }
+ } else {
+ //senquack - break out of final loop if nothing to be drawn (1st loop
+ // must always be taken to setup dx3/dx4)
+ if (y1 == y2) break;
+
+ ya = y1; yb = y2;
+
+ if (dx < 0) {
+ x3 = i2x(x0); x4 = i2x(x1);
+ r3 = i2x(r0); g3 = i2x(g0); b3 = i2x(b0);
+
+ if ((y1 - y0) != 0) {
+ x3 += (dx3 * (y1 - y0));
+ r3 += (dr3 * (y1 - y0));
+ g3 += (dg3 * (y1 - y0));
+ b3 += (db3 * (y1 - y0));
+ }
+
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) * FloatInv(y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) / (float)(y2 - y1)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? xLoDivx((x2 - x1), (y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1)) : 0;
+#endif
+#endif
+ } else {
+ x3 = i2x(x1);
+ x4 = i2x(x0) + (dx4 * (y1 - y0));
+
+ r3 = i2x(r1); g3 = i2x(g1); b3 = i2x(b1);
+
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y2 - y1) != 0) {
+ float finv = FloatInv(y2 - y1);
+ dx3 = (fixed)(((x2 - x1) << FIXED_BITS) * finv);
+ dr3 = (fixed)(((r2 - r1) << FIXED_BITS) * finv);
+ dg3 = (fixed)(((g2 - g1) << FIXED_BITS) * finv);
+ db3 = (fixed)(((b2 - b1) << FIXED_BITS) * finv);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+#else
+ if ((y2 - y1) != 0) {
+ float fdiv = y2 - y1;
+ dx3 = (fixed)(((x2 - x1) << FIXED_BITS) / fdiv);
+ dr3 = (fixed)(((r2 - r1) << FIXED_BITS) / fdiv);
+ dg3 = (fixed)(((g2 - g1) << FIXED_BITS) / fdiv);
+ db3 = (fixed)(((b2 - b1) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y2 - y1) != 0) {
+ int iF, iS;
+ 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);
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+#else
+ if ((y2 - y1) != 0) {
+ dx3 = GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1));
+ dr3 = GPU_FAST_DIV((r2 - r1) << FIXED_BITS, (y2 - y1));
+ dg3 = GPU_FAST_DIV((g2 - g1) << FIXED_BITS, (y2 - y1));
+ db3 = GPU_FAST_DIV((b2 - b1) << FIXED_BITS, (y2 - y1));
+ } else {
+ dx3 = dr3 = dg3 = db3 = 0;
+ }
+#endif
+#endif
+ }
}
- }
- 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)];
-
- for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, r3+=dr3, g3+=dg3, b3+=db3)
- {
- if (ya&li) continue;
- xa = x2i(x3);
- xb = x2i(x4);
- if( (xa>xmax) || (xb<xmin) ) continue;
-
- temp = xmin - xa;
- if(temp > 0)
- {
- xa = xmin;
- r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
+ s32 xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+
+ if ((ymin - ya) > 0) {
+ x3 += (dx3 * (ymin - ya));
+ x4 += (dx4 * (ymin - ya));
+ r3 += (dr3 * (ymin - ya));
+ g3 += (dg3 * (ymin - ya));
+ b3 += (db3 * (ymin - ya));
+ ya = ymin;
}
- else
+
+ if (yb > ymax) yb = ymax;
+
+ int loop1 = yb - ya;
+ if (loop1 <= 0)
+ continue;
+
+ u16* PixelBase = &((u16*)gpu_unai.vram)[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+
+ for (; loop1; --loop1, ++ya, PixelBase += FRAME_WIDTH,
+ x3 += dx3, x4 += dx4,
+ r3 += dr3, g3 += dg3, b3 += db3 )
{
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+
+ u32 r4, g4, b4;
+
+ xa = FixedCeilToInt(x3);
+ xb = FixedCeilToInt(x4);
r4 = r3; g4 = g3; b4 = b3;
+
+ fixed itmp = i2x(xa) - x3;
+ if (itmp != 0) {
+ r4 += (dr4 * itmp) >> FIXED_BITS;
+ g4 += (dg4 * itmp) >> FIXED_BITS;
+ b4 += (db4 * itmp) >> FIXED_BITS;
+ }
+
+ r4 += fixed_HALF;
+ g4 += fixed_HALF;
+ b4 += fixed_HALF;
+
+ if ((xmin - xa) > 0) {
+ r4 += (dr4 * (xmin - xa));
+ g4 += (dg4 * (xmin - xa));
+ b4 += (db4 * (xmin - xa));
+ xa = xmin;
+ }
+
+ // Setup packed Gouraud color for inner driver
+ gpu_unai.gCol = gpuPackGouraudCol(r4, g4, b4);
+
+ if (xb > xmax) xb = xmax;
+ if ((xb - xa) > 0)
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
- if(xb > xmax) xb = xmax;
- xb-=xa;
- if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
}
- }
+ } while (++cur_pass < total_passes);
}
/*----------------------------------------------------------------------
-GT3
+gpuDrawPolyGT - Gouraud-shaded, textured poly
----------------------------------------------------------------------*/
-
-void gpuDrawGT3(const PP gpuPolySpanDriver)
+void gpuDrawPolyGT(const PtrUnion packet, const PP gpuPolySpanDriver, u32 is_quad)
{
- 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(PacketBuffer.S2[2] );
- y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3] );
- x1 = GPU_EXPANDSIGN(PacketBuffer.S2[8] );
- y1 = GPU_EXPANDSIGN(PacketBuffer.S2[9] );
- x2 = GPU_EXPANDSIGN(PacketBuffer.S2[14]);
- y2 = GPU_EXPANDSIGN(PacketBuffer.S2[15]);
-
- GPU_TESTRANGE3();
-
- 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];
+ PolyVertex vbuf[4];
+ polyInitVertexBuffer(vbuf, packet, POLYTYPE_GT, is_quad);
+ int total_passes = is_quad ? 2 : 1;
+ int cur_pass = 0;
+ do
{
- 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];
+ const PolyVertex* vptrs[3];
+ if (polyUseTriangle(vbuf, cur_pass, vptrs) == false)
+ continue;
+
+ s32 xa, xb, ya, yb;
+ s32 x3, dx3, x4, dx4, dx;
+ s32 u3, du3, v3, dv3;
+ s32 r3, dr3, g3, dg3, b3, db3;
+ s32 x0, x1, x2, y0, y1, y2;
+ s32 u0, u1, u2, v0, v1, v2;
+ s32 r0, r1, r2, g0, g1, g2, b0, b1, b2;
+ s32 du4, dv4;
+ s32 dr4, dg4, db4;
+
+ x0 = vptrs[0]->x; y0 = vptrs[0]->y;
+ u0 = vptrs[0]->tex.u; v0 = vptrs[0]->tex.v;
+ r0 = vptrs[0]->col.r; g0 = vptrs[0]->col.g; b0 = vptrs[0]->col.b;
+ x1 = vptrs[1]->x; y1 = vptrs[1]->y;
+ u1 = vptrs[1]->tex.u; v1 = vptrs[1]->tex.v;
+ r1 = vptrs[1]->col.r; g1 = vptrs[1]->col.g; b1 = vptrs[1]->col.b;
+ x2 = vptrs[2]->x; y2 = vptrs[2]->y;
+ u2 = vptrs[2]->tex.u; v2 = vptrs[2]->tex.v;
+ r2 = vptrs[2]->col.r; g2 = vptrs[2]->col.g; b2 = vptrs[2]->col.b;
+
+ ya = y2 - y0;
+ yb = y2 - y1;
+ dx4 = (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;
+ dx = dx4;
+ if (dx4 < 0) {
+ dx4 = -dx4;
+ du4 = -du4;
+ dv4 = -dv4;
+ dr4 = -dr4;
+ dg4 = -dg4;
+ db4 = -db4;
+ }
- 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);
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if (dx4 != 0) {
+ float finv = FloatInv(dx4);
+ du4 = (fixed)((du4 << FIXED_BITS) * finv);
+ dv4 = (fixed)((dv4 << FIXED_BITS) * finv);
+ dr4 = (fixed)((dr4 << FIXED_BITS) * finv);
+ dg4 = (fixed)((dg4 << FIXED_BITS) * finv);
+ db4 = (fixed)((db4 << FIXED_BITS) * finv);
+ } else {
+ du4 = dv4 = dr4 = dg4 = db4 = 0;
}
- }
- 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);
+#else
+ if (dx4 != 0) {
+ float fdiv = dx4;
+ du4 = (fixed)((du4 << FIXED_BITS) / fdiv);
+ dv4 = (fixed)((dv4 << FIXED_BITS) / fdiv);
+ dr4 = (fixed)((dr4 << FIXED_BITS) / fdiv);
+ dg4 = (fixed)((dg4 << FIXED_BITS) / fdiv);
+ db4 = (fixed)((db4 << FIXED_BITS) / fdiv);
+ } else {
+ du4 = dv4 = 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);
- GPU_SWAP(r0, r1, temp); GPU_SWAP(g0, g1, temp); GPU_SWAP(b0, b1, temp);
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if (dx4 != 0) {
+ int iF, iS;
+ xInv(dx4, 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);
+ } else {
+ du4 = dv4 = dr4 = dg4 = db4 = 0;
}
- }
-
- 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
+ if (dx4 != 0) {
+ du4 = GPU_FAST_DIV(du4 << FIXED_BITS, dx4);
+ dv4 = GPU_FAST_DIV(dv4 << FIXED_BITS, dx4);
+ dr4 = GPU_FAST_DIV(dr4 << FIXED_BITS, dx4);
+ dg4 = GPU_FAST_DIV(dg4 << FIXED_BITS, dx4);
+ db4 = GPU_FAST_DIV(db4 << FIXED_BITS, dx4);
+ } else {
+ du4 = dv4 = dr4 = dg4 = db4 = 0;
}
- 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));
+#endif
+#endif
+ // Set u,v increments and packed Gouraud increment for inner driver
+ gpu_unai.u_inc = du4;
+ gpu_unai.v_inc = dv4;
+ gpu_unai.gInc = gpuPackGouraudColInc(dr4, dg4, db4);
+
+ for (s32 loop0 = 2; loop0; loop0--) {
+ if (loop0 == 2) {
+ ya = y0; yb = y1;
+ x3 = x4 = i2x(x0);
+ u3 = i2x(u0); v3 = i2x(v0);
+ r3 = i2x(r0); g3 = i2x(g0); b3 = i2x(b0);
+ if (dx < 0) {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y2 - y0) != 0) {
+ float finv = FloatInv(y2 - y0);
+ dx3 = (fixed)(((x2 - x0) << FIXED_BITS) * finv);
+ du3 = (fixed)(((u2 - u0) << FIXED_BITS) * finv);
+ dv3 = (fixed)(((v2 - v0) << FIXED_BITS) * finv);
+ dr3 = (fixed)(((r2 - r0) << FIXED_BITS) * finv);
+ dg3 = (fixed)(((g2 - g0) << FIXED_BITS) * finv);
+ db3 = (fixed)(((b2 - b0) << FIXED_BITS) * finv);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) * FloatInv(y1 - y0)) : 0;
+#else
+ if ((y2 - y0) != 0) {
+ float fdiv = y2 - y0;
+ dx3 = (fixed)(((x2 - x0) << FIXED_BITS) / fdiv);
+ du3 = (fixed)(((u2 - u0) << FIXED_BITS) / fdiv);
+ dv3 = (fixed)(((v2 - v0) << FIXED_BITS) / fdiv);
+ dr3 = (fixed)(((r2 - r0) << FIXED_BITS) / fdiv);
+ dg3 = (fixed)(((g2 - g0) << FIXED_BITS) / fdiv);
+ db3 = (fixed)(((b2 - b0) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? (fixed)(((x1 - x0) << FIXED_BITS) / (float)(y1 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y2 - y0) != 0) {
+ int iF, iS;
+ 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);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? xLoDivx((x1 - x0), (y1 - y0)) : 0;
+#else
+ if ((y2 - y0) != 0) {
+ dx3 = GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0));
+ du3 = GPU_FAST_DIV((u2 - u0) << FIXED_BITS, (y2 - y0));
+ dv3 = GPU_FAST_DIV((v2 - v0) << FIXED_BITS, (y2 - y0));
+ dr3 = GPU_FAST_DIV((r2 - r0) << FIXED_BITS, (y2 - y0));
+ dg3 = GPU_FAST_DIV((g2 - g0) << FIXED_BITS, (y2 - y0));
+ db3 = GPU_FAST_DIV((b2 - b0) << FIXED_BITS, (y2 - y0));
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y1 - y0) != 0) ? GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0)) : 0;
+#endif
+#endif
+ } else {
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y1 - y0) != 0) {
+ float finv = FloatInv(y1 - y0);
+ dx3 = (fixed)(((x1 - x0) << FIXED_BITS) * finv);
+ du3 = (fixed)(((u1 - u0) << FIXED_BITS) * finv);
+ dv3 = (fixed)(((v1 - v0) << FIXED_BITS) * finv);
+ dr3 = (fixed)(((r1 - r0) << FIXED_BITS) * finv);
+ dg3 = (fixed)(((g1 - g0) << FIXED_BITS) * finv);
+ db3 = (fixed)(((b1 - b0) << FIXED_BITS) * finv);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) * FloatInv(y2 - y0)) : 0;
+#else
+ if ((y1 - y0) != 0) {
+ float fdiv = y1 - y0;
+ dx3 = (fixed)(((x1 - x0) << FIXED_BITS) / fdiv);
+ du3 = (fixed)(((u1 - u0) << FIXED_BITS) / fdiv);
+ dv3 = (fixed)(((v1 - v0) << FIXED_BITS) / fdiv);
+ dr3 = (fixed)(((r1 - r0) << FIXED_BITS) / fdiv);
+ dg3 = (fixed)(((g1 - g0) << FIXED_BITS) / fdiv);
+ db3 = (fixed)(((b1 - b0) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? (fixed)(((x2 - x0) << FIXED_BITS) / float(y2 - y0)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y1 - y0) != 0) {
+ int iF, iS;
+ 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);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? xLoDivx((x2 - x0), (y2 - y0)) : 0;
+#else
+ if ((y1 - y0) != 0) {
+ dx3 = GPU_FAST_DIV((x1 - x0) << FIXED_BITS, (y1 - y0));
+ du3 = GPU_FAST_DIV((u1 - u0) << FIXED_BITS, (y1 - y0));
+ dv3 = GPU_FAST_DIV((v1 - v0) << FIXED_BITS, (y1 - y0));
+ dr3 = GPU_FAST_DIV((r1 - r0) << FIXED_BITS, (y1 - y0));
+ dg3 = GPU_FAST_DIV((g1 - g0) << FIXED_BITS, (y1 - y0));
+ db3 = GPU_FAST_DIV((b1 - b0) << FIXED_BITS, (y1 - y0));
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+ dx4 = ((y2 - y0) != 0) ? GPU_FAST_DIV((x2 - x0) << FIXED_BITS, (y2 - y0)) : 0;
+#endif
+#endif
+ }
+ } else {
+ //senquack - break out of final loop if nothing to be drawn (1st loop
+ // must always be taken to setup dx3/dx4)
+ if (y1 == y2) break;
+
+ ya = y1; yb = y2;
+
+ if (dx < 0) {
+ x3 = i2x(x0); x4 = i2x(x1);
+ u3 = i2x(u0); v3 = i2x(v0);
+ r3 = i2x(r0); g3 = i2x(g0); b3 = i2x(b0);
+
+ if ((y1 - y0) != 0) {
+ x3 += (dx3 * (y1 - y0));
+ u3 += (du3 * (y1 - y0));
+ v3 += (dv3 * (y1 - y0));
+ r3 += (dr3 * (y1 - y0));
+ g3 += (dg3 * (y1 - y0));
+ b3 += (db3 * (y1 - y0));
+ }
+
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) * FloatInv(y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? (fixed)(((x2 - x1) << FIXED_BITS) / (float)(y2 - y1)) : 0;
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ dx4 = ((y2 - y1) != 0) ? xLoDivx((x2 - x1), (y2 - y1)) : 0;
+#else
+ dx4 = ((y2 - y1) != 0) ? GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1)) : 0;
+#endif
+#endif
+ } else {
+ x3 = i2x(x1);
+ x4 = i2x(x0) + (dx4 * (y1 - y0));
+
+ u3 = i2x(u1); v3 = i2x(v1);
+ r3 = i2x(r1); g3 = i2x(g1); b3 = i2x(b1);
+#ifdef GPU_UNAI_USE_FLOATMATH
+#ifdef GPU_UNAI_USE_FLOAT_DIV_MULTINV
+ if ((y2 - y1) != 0) {
+ float finv = FloatInv(y2 - y1);
+ dx3 = (fixed)(((x2 - x1) << FIXED_BITS) * finv);
+ du3 = (fixed)(((u2 - u1) << FIXED_BITS) * finv);
+ dv3 = (fixed)(((v2 - v1) << FIXED_BITS) * finv);
+ dr3 = (fixed)(((r2 - r1) << FIXED_BITS) * finv);
+ dg3 = (fixed)(((g2 - g1) << FIXED_BITS) * finv);
+ db3 = (fixed)(((b2 - b1) << FIXED_BITS) * finv);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+#else
+ if ((y2 - y1) != 0) {
+ float fdiv = y2 - y1;
+ dx3 = (fixed)(((x2 - x1) << FIXED_BITS) / fdiv);
+ du3 = (fixed)(((u2 - u1) << FIXED_BITS) / fdiv);
+ dv3 = (fixed)(((v2 - v1) << FIXED_BITS) / fdiv);
+ dr3 = (fixed)(((r2 - r1) << FIXED_BITS) / fdiv);
+ dg3 = (fixed)(((g2 - g1) << FIXED_BITS) / fdiv);
+ db3 = (fixed)(((b2 - b1) << FIXED_BITS) / fdiv);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+#endif
+#else // Integer Division:
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ if ((y2 - y1) != 0) {
+ int iF, iS;
+ 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);
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+#else
+ if ((y2 - y1) != 0) {
+ dx3 = GPU_FAST_DIV((x2 - x1) << FIXED_BITS, (y2 - y1));
+ du3 = GPU_FAST_DIV((u2 - u1) << FIXED_BITS, (y2 - y1));
+ dv3 = GPU_FAST_DIV((v2 - v1) << FIXED_BITS, (y2 - y1));
+ dr3 = GPU_FAST_DIV((r2 - r1) << FIXED_BITS, (y2 - y1));
+ dg3 = GPU_FAST_DIV((g2 - g1) << FIXED_BITS, (y2 - y1));
+ db3 = GPU_FAST_DIV((b2 - b1) << FIXED_BITS, (y2 - y1));
+ } else {
+ dx3 = du3 = dv3 = dr3 = dg3 = db3 = 0;
+ }
+#endif
+#endif
+ }
}
- 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)];
-
- for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3, r3+=dr3, g3+=dg3, b3+=db3)
- {
- if (ya&li) continue;
- xa = x2i(x3);
- xb = x2i(x4);
- if( (xa>xmax) || (xb<xmin)) continue;
-
- temp = xmin - xa;
- if(temp > 0)
- {
- xa = xmin;
- u4 = u3 + du4*temp; v4 = v3 + dv4*temp;
- r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
+ s32 xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+
+ if ((ymin - ya) > 0) {
+ x3 += (dx3 * (ymin - ya));
+ x4 += (dx4 * (ymin - ya));
+ u3 += (du3 * (ymin - ya));
+ v3 += (dv3 * (ymin - ya));
+ r3 += (dr3 * (ymin - ya));
+ g3 += (dg3 * (ymin - ya));
+ b3 += (db3 * (ymin - ya));
+ ya = ymin;
}
- else
+
+ if (yb > ymax) yb = ymax;
+
+ int loop1 = yb - ya;
+ if (loop1 <= 0)
+ continue;
+
+ u16* PixelBase = &((u16*)gpu_unai.vram)[FRAME_OFFSET(0, ya)];
+ int li=gpu_unai.ilace_mask;
+ int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+
+ for (; loop1; --loop1, ++ya, PixelBase += FRAME_WIDTH,
+ x3 += dx3, x4 += dx4,
+ u3 += du3, v3 += dv3,
+ r3 += dr3, g3 += dg3, b3 += db3 )
{
+ if (ya&li) continue;
+ if ((ya&pi)==pif) continue;
+
+ u32 u4, v4;
+ u32 r4, g4, b4;
+
+ xa = FixedCeilToInt(x3);
+ xb = FixedCeilToInt(x4);
u4 = u3; v4 = v3;
r4 = r3; g4 = g3; b4 = b3;
+
+ fixed itmp = i2x(xa) - x3;
+ if (itmp != 0) {
+ u4 += (du4 * itmp) >> FIXED_BITS;
+ v4 += (dv4 * itmp) >> FIXED_BITS;
+ r4 += (dr4 * itmp) >> FIXED_BITS;
+ g4 += (dg4 * itmp) >> FIXED_BITS;
+ b4 += (db4 * itmp) >> FIXED_BITS;
+ }
+
+ u4 += fixed_HALF;
+ v4 += fixed_HALF;
+ r4 += fixed_HALF;
+ g4 += fixed_HALF;
+ b4 += fixed_HALF;
+
+ if ((xmin - xa) > 0) {
+ u4 += du4 * (xmin - xa);
+ v4 += dv4 * (xmin - xa);
+ r4 += dr4 * (xmin - xa);
+ g4 += dg4 * (xmin - xa);
+ b4 += db4 * (xmin - xa);
+ xa = xmin;
+ }
+
+ // Set packed Gouraud color and u,v coords for inner driver
+ gpu_unai.u = u4;
+ gpu_unai.v = v4;
+ gpu_unai.gCol = gpuPackGouraudCol(r4, g4, b4);
+
+ if (xb > xmax) xb = xmax;
+ if ((xb - xa) > 0)
+ gpuPolySpanDriver(gpu_unai, PixelBase + xa, (xb - xa));
}
- if(xb > xmax) xb = xmax;
- xb-=xa;
- if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
}
- }
+ } while (++cur_pass < total_passes);
}
diff --git a/plugins/gpu_unai/gpu_raster_sprite.h b/plugins/gpu_unai/gpu_raster_sprite.h
index a700db3..0afdbf5 100644
--- a/plugins/gpu_unai/gpu_raster_sprite.h
+++ b/plugins/gpu_unai/gpu_raster_sprite.h
@@ -21,73 +21,70 @@
///////////////////////////////////////////////////////////////////////////////
// GPU internal sprite drawing functions
-///////////////////////////////////////////////////////////////////////////////
-void gpuDrawS(const PS gpuSpriteSpanDriver)
+void gpuDrawS(PtrUnion packet, const PS gpuSpriteSpanDriver)
{
- s32 x0, x1;
- s32 y0, y1;
- s32 u0;
- s32 v0;
-
- x1 = x0 = GPU_EXPANDSIGN(PacketBuffer.S2[2]) + DrawingOffset[0];
- y1 = y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3]) + DrawingOffset[1];
- x1+= PacketBuffer.S2[6];
- y1+= PacketBuffer.S2[7];
-
- {
- s32 xmin, xmax;
- s32 ymin, ymax;
- xmin = DrawingArea[0]; xmax = DrawingArea[2];
- ymin = DrawingArea[1]; ymax = DrawingArea[3];
-
- {
- int rx0 = Max2(xmin,Min2(x0,x1));
- int ry0 = Max2(ymin,Min2(y0,y1));
- int rx1 = Min2(xmax,Max2(x0,x1));
- int ry1 = Min2(ymax,Max2(y0,y1));
- if( rx0>=rx1 || ry0>=ry1) return;
- }
-
- u0 = PacketBuffer.U1[8];
- v0 = PacketBuffer.U1[9];
-
- r4 = s32(PacketBuffer.U1[0]);
- g4 = s32(PacketBuffer.U1[1]);
- b4 = s32(PacketBuffer.U1[2]);
-
- {
- s32 temp;
- temp = ymin - y0;
- if (temp > 0) { y0 = ymin; v0 += temp; }
- if (y1 > ymax) y1 = ymax;
- if (y1 <= y0) return;
-
- temp = xmin - x0;
- if (temp > 0) { x0 = xmin; u0 += temp; }
- if (x1 > xmax) x1 = xmax;
- x1 -= x0;
- if (x1 <= 0) return;
- }
- }
-
- {
- u16 *Pixel = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)];
- const int li=linesInterlace;
- const u32 masku=TextureWindow[2];
- const u32 maskv=TextureWindow[3];
-
- for (;y0<y1;++y0) {
- if( 0 == (y0&li) ) gpuSpriteSpanDriver(Pixel,x1,FRAME_OFFSET(u0,v0),masku);
- Pixel += FRAME_WIDTH;
- v0 = (v0+1)&maskv;
- }
+ s32 x0, x1, y0, y1;
+ u32 u0, v0;
+
+ //NOTE: Must 11-bit sign-extend the whole sum here, not just packet X/Y,
+ // or sprites in 1st level of SkullMonkeys disappear when walking right.
+ // This now matches behavior of Mednafen and PCSX Rearmed's gpu_neon:
+ x0 = GPU_EXPANDSIGN(packet.S2[2] + gpu_unai.DrawingOffset[0]);
+ y0 = GPU_EXPANDSIGN(packet.S2[3] + gpu_unai.DrawingOffset[1]);
+
+ u32 w = packet.U2[6] & 0x3ff; // Max width is 1023
+ u32 h = packet.U2[7] & 0x1ff; // Max height is 511
+ x1 = x0 + w;
+ y1 = y0 + h;
+
+ s32 xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+
+ u0 = packet.U1[8];
+ v0 = packet.U1[9];
+
+ 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;
+
+ gpu_unai.r5 = packet.U1[0] >> 3;
+ gpu_unai.g5 = packet.U1[1] >> 3;
+ gpu_unai.b5 = packet.U1[2] >> 3;
+
+ u16 *Pixel = &((u16*)gpu_unai.vram)[FRAME_OFFSET(x0, y0)];
+ const int li=gpu_unai.ilace_mask;
+ const int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ const int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+ unsigned int tmode = gpu_unai.TEXT_MODE >> 5;
+ const u32 v0_mask = gpu_unai.TextureWindow[3];
+ u8* pTxt_base = (u8*)gpu_unai.TBA;
+
+ // Texture is accessed byte-wise, so adjust idx if 16bpp
+ if (tmode == 3) u0 <<= 1;
+
+ for (; y0<y1; ++y0) {
+ u8* pTxt = pTxt_base + ((v0 & v0_mask) * 2048);
+ if (!(y0&li) && (y0&pi)!=pif)
+ gpuSpriteSpanDriver(Pixel, x1, pTxt, u0);
+ Pixel += FRAME_WIDTH;
+ v0++;
}
}
#ifdef __arm__
#include "gpu_arm.h"
-void gpuDrawS16(void)
+/* Notaz 4bit sprites optimization */
+void gpuDrawS16(PtrUnion packet)
{
s32 x0, y0;
s32 u0, v0;
@@ -95,19 +92,22 @@ void gpuDrawS16(void)
s32 ymin, ymax;
u32 h = 16;
- x0 = GPU_EXPANDSIGN(PacketBuffer.S2[2]) + DrawingOffset[0];
- y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3]) + DrawingOffset[1];
+ //NOTE: Must 11-bit sign-extend the whole sum here, not just packet X/Y,
+ // or sprites in 1st level of SkullMonkeys disappear when walking right.
+ // This now matches behavior of Mednafen and PCSX Rearmed's gpu_neon:
+ x0 = GPU_EXPANDSIGN(packet.S2[2] + gpu_unai.DrawingOffset[0]);
+ y0 = GPU_EXPANDSIGN(packet.S2[3] + gpu_unai.DrawingOffset[1]);
- xmin = DrawingArea[0]; xmax = DrawingArea[2];
- ymin = DrawingArea[1]; ymax = DrawingArea[3];
- u0 = PacketBuffer.U1[8];
- v0 = PacketBuffer.U1[9];
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+ u0 = packet.U1[8];
+ v0 = packet.U1[9];
if (x0 > xmax - 16 || x0 < xmin ||
- ((u0 | v0) & 15) || !(TextureWindow[2] & TextureWindow[3] & 8)) {
+ ((u0 | v0) & 15) || !(gpu_unai.TextureWindow[2] & gpu_unai.TextureWindow[3] & 8)) {
// send corner cases to general handler
- PacketBuffer.U4[3] = 0x00100010;
- gpuDrawS(gpuSpriteSpanFn<0x20>);
+ packet.U4[3] = 0x00100010;
+ gpuDrawS(packet, gpuSpriteSpanFn<0x20>);
return;
}
@@ -121,54 +121,45 @@ void gpuDrawS16(void)
else if (ymax - y0 < 16)
h = ymax - y0;
- draw_spr16_full(&GPU_FrameBuffer[FRAME_OFFSET(x0, y0)], &TBA[FRAME_OFFSET(u0/4, v0)], CBA, h);
+ draw_spr16_full(&gpu_unai.vram[FRAME_OFFSET(x0, y0)], &gpu_unai.TBA[FRAME_OFFSET(u0/4, v0)], gpu_unai.CBA, h);
}
#endif // __arm__
-///////////////////////////////////////////////////////////////////////////////
-void gpuDrawT(const PT gpuTileSpanDriver)
+void gpuDrawT(PtrUnion packet, const PT gpuTileSpanDriver)
{
- s32 x0, y0;
- s32 x1, y1;
-
- x1 = x0 = GPU_EXPANDSIGN(PacketBuffer.S2[2]) + DrawingOffset[0];
- y1 = y0 = GPU_EXPANDSIGN(PacketBuffer.S2[3]) + DrawingOffset[1];
- x1+= PacketBuffer.S2[4];
- y1+= PacketBuffer.S2[5];
-
- {
- s32 xmin, xmax;
- s32 ymin, ymax;
- xmin = DrawingArea[0]; xmax = DrawingArea[2];
- ymin = DrawingArea[1]; ymax = DrawingArea[3];
-
- {
- int rx0 = Max2(xmin,Min2(x0,x1));
- int ry0 = Max2(ymin,Min2(y0,y1));
- int rx1 = Min2(xmax,Max2(x0,x1));
- int ry1 = Min2(ymax,Max2(y0,y1));
- if(rx0>=rx1 || ry0>=ry1) return;
- }
-
- if (y0 < ymin) y0 = ymin;
- if (y1 > ymax) y1 = ymax;
- if (y1 <= y0) return;
-
- if (x0 < xmin) x0 = xmin;
- if (x1 > xmax) x1 = xmax;
- x1 -= x0;
- if (x1 <= 0) return;
- }
-
- {
- u16 *Pixel = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)];
- const u16 Data = GPU_RGB16(PacketBuffer.U4[0]);
- const int li=linesInterlace;
-
- for (; y0<y1; ++y0)
- {
- if( 0 == (y0&li) ) gpuTileSpanDriver(Pixel,x1,Data);
- Pixel += FRAME_WIDTH;
- }
+ s32 x0, x1, y0, y1;
+
+ // This now matches behavior of Mednafen and PCSX Rearmed's gpu_neon:
+ x0 = GPU_EXPANDSIGN(packet.S2[2] + gpu_unai.DrawingOffset[0]);
+ y0 = GPU_EXPANDSIGN(packet.S2[3] + gpu_unai.DrawingOffset[1]);
+
+ u32 w = packet.U2[4] & 0x3ff; // Max width is 1023
+ u32 h = packet.U2[5] & 0x1ff; // Max height is 511
+ x1 = x0 + w;
+ y1 = y0 + h;
+
+ s32 xmin, xmax, ymin, ymax;
+ xmin = gpu_unai.DrawingArea[0]; xmax = gpu_unai.DrawingArea[2];
+ ymin = gpu_unai.DrawingArea[1]; ymax = gpu_unai.DrawingArea[3];
+
+ 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;
+
+ const u16 Data = GPU_RGB16(packet.U4[0]);
+ u16 *Pixel = &((u16*)gpu_unai.vram)[FRAME_OFFSET(x0, y0)];
+ const int li=gpu_unai.ilace_mask;
+ const int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.ilace_mask+1):0);
+ const int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.ilace_mask+1):0):1);
+
+ for (; y0<y1; ++y0) {
+ if (!(y0&li) && (y0&pi)!=pif)
+ gpuTileSpanDriver(Pixel,x1,Data);
+ Pixel += FRAME_WIDTH;
}
}
diff --git a/plugins/gpu_unai/gpu_unai.h b/plugins/gpu_unai/gpu_unai.h
new file mode 100644
index 0000000..8fb2293
--- /dev/null
+++ b/plugins/gpu_unai/gpu_unai.h
@@ -0,0 +1,318 @@
+/***************************************************************************
+* Copyright (C) 2010 PCSX4ALL Team *
+* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
+* *
+* 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 GPU_UNAI_H
+#define GPU_UNAI_H
+
+#include "gpu.h"
+
+// Header shared between both standalone gpu_unai (gpu.cpp) and new
+// gpulib-compatible gpu_unai (gpulib_if.cpp)
+// -> Anything here should be for gpu_unai's private use. <-
+
+///////////////////////////////////////////////////////////////////////////////
+// Compile Options
+
+//#define ENABLE_GPU_NULL_SUPPORT // Enables NullGPU support
+//#define ENABLE_GPU_LOG_SUPPORT // Enables gpu logger, very slow only for windows debugging
+//#define ENABLE_GPU_ARMV7 // Enables ARMv7 optimized assembly
+
+//Poly routine options (default is integer math and accurate division)
+//#define GPU_UNAI_USE_FLOATMATH // Use float math in poly routines
+//#define GPU_UNAI_USE_FLOAT_DIV_MULTINV // If GPU_UNAI_USE_FLOATMATH is defined,
+ // use multiply-by-inverse for division
+//#define GPU_UNAI_USE_INT_DIV_MULTINV // If GPU_UNAI_USE_FLOATMATH is *not*
+ // defined, use old inaccurate division
+
+
+#define GPU_INLINE static inline __attribute__((always_inline))
+#define INLINE static inline __attribute__((always_inline))
+
+#define u8 uint8_t
+#define s8 int8_t
+#define u16 uint16_t
+#define s16 int16_t
+#define u32 uint32_t
+#define s32 int32_t
+#define s64 int64_t
+
+union PtrUnion
+{
+ u32 *U4;
+ s32 *S4;
+ u16 *U2;
+ s16 *S2;
+ u8 *U1;
+ s8 *S1;
+ void *ptr;
+};
+
+union GPUPacket
+{
+ u32 U4[16];
+ s32 S4[16];
+ u16 U2[32];
+ s16 S2[32];
+ u8 U1[64];
+ s8 S1[64];
+};
+
+template<class T> static inline void SwapValues(T &x, T &y)
+{
+ T tmp(x); x = y; y = tmp;
+}
+
+template<typename T>
+static inline T Min2 (const T a, const T b)
+{
+ return (a<b)?a:b;
+}
+
+template<typename T>
+static inline T Min3 (const T a, const T b, const T c)
+{
+ return Min2(Min2(a,b),c);
+}
+
+template<typename T>
+static inline T Max2 (const T a, const T b)
+{
+ return (a>b)?a:b;
+}
+
+template<typename T>
+static inline T Max3 (const T a, const T b, const T c)
+{
+ return Max2(Max2(a,b),c);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU Raster Macros
+
+// Convert 24bpp color parameter of GPU command to 16bpp (15bpp + mask bit)
+#define GPU_RGB16(rgb) ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))
+
+// Sign-extend 11-bit coordinate command param
+#define GPU_EXPANDSIGN(x) (((s32)(x)<<(32-11))>>(32-11))
+
+// Max difference between any two X or Y primitive coordinates
+#define CHKMAX_X 1024
+#define CHKMAX_Y 512
+
+#define FRAME_BUFFER_SIZE (1024*512*2)
+#define FRAME_WIDTH 1024
+#define FRAME_HEIGHT 512
+#define FRAME_OFFSET(x,y) (((y)<<10)+(x))
+#define FRAME_BYTE_STRIDE 2048
+#define FRAME_BYTES_PER_PIXEL 2
+
+static inline s32 GPU_DIV(s32 rs, s32 rt)
+{
+ return rt ? (rs / rt) : (0);
+}
+
+// 'Unsafe' version of above that doesn't check for div-by-zero
+#define GPU_FAST_DIV(rs, rt) ((signed)(rs) / (signed)(rt))
+
+struct gpu_unai_t {
+ u32 GPU_GP1;
+ GPUPacket PacketBuffer;
+ u16 *vram;
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Variables used only by older standalone version of gpu_unai (gpu.cpp)
+#ifndef USE_GPULIB
+ u32 GPU_GP0;
+ u32 tex_window; // Current texture window vals (set by GP0(E2h) cmd)
+ s32 PacketCount;
+ s32 PacketIndex;
+ bool fb_dirty; // Framebuffer is dirty (according to GPU)
+
+ // Display status
+ // NOTE: Standalone older gpu_unai didn't care about horiz display range
+ u16 DisplayArea[6]; // [0] : Start of display area (in VRAM) X
+ // [1] : Start of display area (in VRAM) Y
+ // [2] : Display mode resolution HORIZONTAL
+ // [3] : Display mode resolution VERTICAL
+ // [4] : Vertical display range (on TV) START
+ // [5] : Vertical display range (on TV) END
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Dma Transfers info
+ struct {
+ s32 px,py;
+ s32 x_end,y_end;
+ u16* pvram;
+ u32 *last_dma; // Last dma pointer
+ bool FrameToRead; // Load image in progress
+ bool FrameToWrite; // Store image in progress
+ } dma;
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Frameskip
+ struct {
+ int skipCount; // Frame skip (0,1,2,3...)
+ bool isSkip; // Skip frame (according to GPU)
+ bool skipFrame; // Skip this frame (according to frame skip)
+ bool wasSkip; // Skip frame old value (according to GPU)
+ bool skipGPU; // Skip GPU primitives
+ } frameskip;
+#endif
+ // END of standalone gpu_unai variables
+ ////////////////////////////////////////////////////////////////////////////
+
+ u32 TextureWindowCur; // Current setting from last GP0(0xE2) cmd (raw form)
+ u8 TextureWindow[4]; // [0] : Texture window offset X
+ // [1] : Texture window offset Y
+ // [2] : Texture window mask X
+ // [3] : Texture window mask Y
+
+ u16 DrawingArea[4]; // [0] : Drawing area top left X
+ // [1] : Drawing area top left Y
+ // [2] : Drawing area bottom right X
+ // [3] : Drawing area bottom right Y
+
+ s16 DrawingOffset[2]; // [0] : Drawing offset X (signed)
+ // [1] : Drawing offset Y (signed)
+
+ u16* TBA; // Ptr to current texture in VRAM
+ u16* CBA; // Ptr to current CLUT in VRAM
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Inner Loop parameters
+
+ // 22.10 Fixed-pt texture coords, mask, scanline advance
+ // NOTE: U,V are no longer packed together into one u32, this proved to be
+ // too imprecise, leading to pixel dropouts. Example: NFS3's skybox.
+ u32 u, v;
+ u32 u_msk, v_msk;
+ s32 u_inc, v_inc;
+
+ // Color for Gouraud-shaded prims
+ // Packed fixed-pt 8.3:8.3:8.2 rgb triplet
+ // layout: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+ // ^ bit 31 ^ bit 0
+ u32 gCol;
+ u32 gInc; // Increment along scanline for gCol
+
+ // Color for flat-shaded, texture-blended prims
+ u8 r5, g5, b5; // 5-bit light for undithered prims
+ u8 r8, g8, b8; // 8-bit light for dithered prims
+
+ // Color for flat-shaded, untextured prims
+ u16 PixelData; // bgr555 color for untextured flat-shaded polys
+
+ // End of inner Loop parameters
+ ////////////////////////////////////////////////////////////////////////////
+
+
+ u8 blit_mask; // Determines what pixels to skip when rendering.
+ // Only useful on low-resolution devices using
+ // a simple pixel-dropping downscaler for PS1
+ // high-res modes. See 'pixel_skip' option.
+
+ u8 ilace_mask; // Determines what lines to skip when rendering.
+ // Normally 0 when PS1 240 vertical res is in
+ // use and ilace_force is 0. When running in
+ // PS1 480 vertical res on a low-resolution
+ // device (320x240), will usually be set to 1
+ // so odd lines are not rendered. (Unless future
+ // full-screen scaling option is in use ..TODO)
+
+ bool prog_ilace_flag; // Tracks successive frames for 'prog_ilace' option
+
+ u8 BLEND_MODE;
+ u8 TEXT_MODE;
+ u8 Masking;
+
+ u16 PixelMSB;
+
+ gpu_unai_config_t config;
+
+ u8 LightLUT[32*32]; // 5-bit lighting LUT (gpu_inner_light.h)
+ u32 DitherMatrix[64]; // Matrix of dither coefficients
+};
+
+static gpu_unai_t gpu_unai;
+
+// Global config that frontend can alter.. Values are read in GPU_init().
+// TODO: if frontend menu modifies a setting, add a function that can notify
+// GPU plugin to use new setting.
+gpu_unai_config_t gpu_unai_config_ext;
+
+///////////////////////////////////////////////////////////////////////////////
+// Internal inline funcs to get option status: (Allows flexibility)
+static inline bool LightingEnabled()
+{
+ return gpu_unai.config.lighting;
+}
+
+static inline bool FastLightingEnabled()
+{
+ return gpu_unai.config.fast_lighting;
+}
+
+static inline bool BlendingEnabled()
+{
+ return gpu_unai.config.blending;
+}
+
+static inline bool DitheringEnabled()
+{
+ return gpu_unai.config.dithering;
+}
+
+// For now, this is just for development/experimentation purposes..
+// If modified to return true, it will allow ignoring the status register
+// bit 9 setting (dither enable). It will still restrict dithering only
+// to Gouraud-shaded or texture-blended polys.
+static inline bool ForcedDitheringEnabled()
+{
+ return false;
+}
+
+static inline bool ProgressiveInterlaceEnabled()
+{
+#ifdef USE_GPULIB
+ // Using this old option greatly decreases quality of image. Disabled
+ // for now when using new gpulib, since it also adds more work in loops.
+ return false;
+#else
+ return gpu_unai.config.prog_ilace;
+#endif
+}
+
+// For now, 320x240 output resolution is assumed, using simple line-skipping
+// and pixel-skipping downscaler.
+// TODO: Flesh these out so they return useful values based on whether
+// running on higher-res device or a resampling downscaler is enabled.
+static inline bool PixelSkipEnabled()
+{
+ return gpu_unai.config.pixel_skip;
+}
+
+static inline bool LineSkipEnabled()
+{
+ return true;
+}
+
+#endif // GPU_UNAI_H
diff --git a/plugins/gpu_unai/gpulib_if.cpp b/plugins/gpu_unai/gpulib_if.cpp
index e9a199c..8b5174e 100644
--- a/plugins/gpu_unai/gpulib_if.cpp
+++ b/plugins/gpu_unai/gpulib_if.cpp
@@ -2,6 +2,7 @@
* Copyright (C) 2010 PCSX4ALL Team *
* Copyright (C) 2010 Unai *
* Copyright (C) 2011 notaz *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
* *
* 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 *
@@ -19,140 +20,81 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
***************************************************************************/
+#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../gpulib/gpu.h"
-#include "arm_features.h"
-
-#define u8 uint8_t
-#define s8 int8_t
-#define u16 uint16_t
-#define s16 int16_t
-#define u32 uint32_t
-#define s32 int32_t
-#define s64 int64_t
-
-#define INLINE static
-
-#define FRAME_BUFFER_SIZE (1024*512*2)
-#define FRAME_WIDTH 1024
-#define FRAME_HEIGHT 512
-#define FRAME_OFFSET(x,y) (((y)<<10)+(x))
-
-#define isSkip 0 /* skip frame (info coming from GPU) */
-#define alt_fps 0
-static int linesInterlace; /* internal lines interlace */
-static int force_interlace;
-
-static bool light = true; /* lighting */
-static bool blend = true; /* blending */
-static bool FrameToRead = false; /* load image in progress */
-static bool FrameToWrite = false; /* store image in progress */
-
-static bool enableAbbeyHack = false; /* Abe's Odyssey hack */
-
-static u8 BLEND_MODE;
-static u8 TEXT_MODE;
-static u8 Masking;
-
-static u16 PixelMSB;
-static u16 PixelData;
-
-///////////////////////////////////////////////////////////////////////////////
-// GPU Global data
-///////////////////////////////////////////////////////////////////////////////
-
-// Dma Transfers info
-static s32 px,py;
-static s32 x_end,y_end;
-static u16* pvram;
-
-static s32 PacketCount;
-static s32 PacketIndex;
-
-// Rasterizer status
-static u32 TextureWindow [4];
-static u32 DrawingArea [4];
-static u32 DrawingOffset [2];
-
-static u16* TBA;
-static u16* CBA;
-
-// Inner Loops
-static s32 u4, du4;
-static s32 v4, dv4;
-static s32 r4, dr4;
-static s32 g4, dg4;
-static s32 b4, db4;
-static u32 lInc;
-static u32 tInc, tMsk;
-
-union GPUPacket
-{
- u32 U4[16];
- s32 S4[16];
- u16 U2[32];
- s16 S2[32];
- u8 U1[64];
- s8 S1[64];
-};
-
-static GPUPacket PacketBuffer;
-static u16 *GPU_FrameBuffer;
-static u32 GPU_GP1;
-
-///////////////////////////////////////////////////////////////////////////////
-
-#include "../gpu_unai/gpu_fixedpoint.h"
-
-// Inner loop driver instanciation file
-#include "../gpu_unai/gpu_inner.h"
-
-// GPU Raster Macros
-#define GPU_RGB16(rgb) ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))
+//#include "port.h"
+#include "gpu_unai.h"
-#define GPU_EXPANDSIGN(x) (((s32)(x)<<21)>>21)
+// GPU fixed point math
+#include "gpu_fixedpoint.h"
-#define CHKMAX_X 1024
-#define CHKMAX_Y 512
-
-#define GPU_SWAP(a,b,t) {(t)=(a);(a)=(b);(b)=(t);}
+// Inner loop driver instantiation file
+#include "gpu_inner.h"
// GPU internal image drawing functions
-#include "../gpu_unai/gpu_raster_image.h"
+#include "gpu_raster_image.h"
// GPU internal line drawing functions
-#include "../gpu_unai/gpu_raster_line.h"
+#include "gpu_raster_line.h"
// GPU internal polygon drawing functions
-#include "../gpu_unai/gpu_raster_polygon.h"
+#include "gpu_raster_polygon.h"
// GPU internal sprite drawing functions
-#include "../gpu_unai/gpu_raster_sprite.h"
+#include "gpu_raster_sprite.h"
// GPU command buffer execution/store
-#include "../gpu_unai/gpu_command.h"
+#include "gpu_command.h"
/////////////////////////////////////////////////////////////////////////////
int renderer_init(void)
{
- GPU_FrameBuffer = (u16 *)gpu.vram;
-
- // s_invTable
- for(int i=1;i<=(1<<TABLE_BITS);++i)
- {
- double v = 1.0 / double(i);
- #ifdef GPU_TABLE_10_BITS
- v *= double(0xffffffff>>1);
- #else
- v *= double(0x80000000);
- #endif
- s_invTable[i-1]=s32(v);
- }
-
- return 0;
+ memset((void*)&gpu_unai, 0, sizeof(gpu_unai));
+ gpu_unai.vram = (u16*)gpu.vram;
+
+ // Original standalone gpu_unai initialized TextureWindow[]. I added the
+ // same behavior here, since it seems unsafe to leave [2],[3] unset when
+ // using HLE and Rearmed gpu_neon sets this similarly on init. -senquack
+ gpu_unai.TextureWindow[0] = 0;
+ gpu_unai.TextureWindow[1] = 0;
+ gpu_unai.TextureWindow[2] = 255;
+ gpu_unai.TextureWindow[3] = 255;
+ //senquack - new vars must be updated whenever texture window is changed:
+ // (used for polygon-drawing in gpu_inner.h, gpu_raster_polygon.h)
+ const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
+ gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1);
+ gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+
+ // Configuration options
+ gpu_unai.config = gpu_unai_config_ext;
+ //senquack - disabled, not sure this is needed and would require modifying
+ // sprite-span functions, perhaps unnecessarily. No Abe Oddysey hack was
+ // present in latest PCSX4ALL sources we were using.
+ //gpu_unai.config.enableAbbeyHack = gpu_unai_config_ext.abe_hack;
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
+
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ // s_invTable
+ for(int i=1;i<=(1<<TABLE_BITS);++i)
+ {
+ double v = 1.0 / double(i);
+#ifdef GPU_TABLE_10_BITS
+ v *= double(0xffffffff>>1);
+#else
+ v *= double(0x80000000);
+#endif
+ s_invTable[i-1]=s32(v);
+ }
+#endif
+
+ SetupLightLUT();
+ SetupDitheringConstants();
+
+ return 0;
}
void renderer_finish(void)
@@ -161,6 +103,111 @@ void renderer_finish(void)
void renderer_notify_res_change(void)
{
+ if (PixelSkipEnabled()) {
+ // Set blit_mask for high horizontal resolutions. This allows skipping
+ // rendering pixels that would never get displayed on low-resolution
+ // platforms that use simple pixel-dropping scaler.
+
+ switch (gpu.screen.hres)
+ {
+ case 512: gpu_unai.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
+ case 640: gpu_unai.blit_mask = 0xaa; break; // GPU_BlitWS
+ default: gpu_unai.blit_mask = 0; break;
+ }
+ } else {
+ gpu_unai.blit_mask = 0;
+ }
+
+ if (LineSkipEnabled()) {
+ // Set rendering line-skip (only render every other line in high-res
+ // 480 vertical mode, or, optionally, force it for all video modes)
+
+ if (gpu.screen.vres == 480) {
+ if (gpu_unai.config.ilace_force) {
+ gpu_unai.ilace_mask = 3; // Only need 1/4 of lines
+ } else {
+ gpu_unai.ilace_mask = 1; // Only need 1/2 of lines
+ }
+ } else {
+ // Vert resolution changed from 480 to lower one
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
+ }
+ } else {
+ gpu_unai.ilace_mask = 0;
+ }
+
+ /*
+ printf("res change hres: %d vres: %d depth: %d ilace_mask: %d\n",
+ gpu.screen.hres, gpu.screen.vres, gpu.status.rgb24 ? 24 : 15,
+ gpu_unai.ilace_mask);
+ */
+}
+
+// Handles GP0 draw settings commands 0xE1...0xE6
+static void gpuGP0Cmd_0xEx(gpu_unai_t &gpu_unai, u32 cmd_word)
+{
+ // Assume incoming GP0 command is 0xE1..0xE6, convert to 1..6
+ u8 num = (cmd_word >> 24) & 7;
+ gpu.ex_regs[num] = cmd_word; // Update gpulib register
+ switch (num) {
+ case 1: {
+ // GP0(E1h) - Draw Mode setting (aka "Texpage")
+ u32 cur_texpage = gpu_unai.GPU_GP1 & 0x7FF;
+ u32 new_texpage = cmd_word & 0x7FF;
+ if (cur_texpage != new_texpage) {
+ gpu_unai.GPU_GP1 = (gpu_unai.GPU_GP1 & ~0x7FF) | new_texpage;
+ gpuSetTexture(gpu_unai.GPU_GP1);
+ }
+ } break;
+
+ case 2: {
+ // GP0(E2h) - Texture Window setting
+ if (cmd_word != gpu_unai.TextureWindowCur) {
+ 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
+ };
+ gpu_unai.TextureWindowCur = cmd_word;
+ gpu_unai.TextureWindow[0] = ((cmd_word >> 10) & 0x1F) << 3;
+ gpu_unai.TextureWindow[1] = ((cmd_word >> 15) & 0x1F) << 3;
+ gpu_unai.TextureWindow[2] = TextureMask[(cmd_word >> 0) & 0x1F];
+ gpu_unai.TextureWindow[3] = TextureMask[(cmd_word >> 5) & 0x1F];
+ gpu_unai.TextureWindow[0] &= ~gpu_unai.TextureWindow[2];
+ gpu_unai.TextureWindow[1] &= ~gpu_unai.TextureWindow[3];
+
+ // Inner loop vars must be updated whenever texture window is changed:
+ const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
+ gpu_unai.u_msk = (((u32)gpu_unai.TextureWindow[2]) << fb) | ((1 << fb) - 1);
+ gpu_unai.v_msk = (((u32)gpu_unai.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+
+ gpuSetTexture(gpu_unai.GPU_GP1);
+ }
+ } break;
+
+ case 3: {
+ // GP0(E3h) - Set Drawing Area top left (X1,Y1)
+ gpu_unai.DrawingArea[0] = cmd_word & 0x3FF;
+ gpu_unai.DrawingArea[1] = (cmd_word >> 10) & 0x3FF;
+ } break;
+
+ case 4: {
+ // GP0(E4h) - Set Drawing Area bottom right (X2,Y2)
+ gpu_unai.DrawingArea[2] = (cmd_word & 0x3FF) + 1;
+ gpu_unai.DrawingArea[3] = ((cmd_word >> 10) & 0x3FF) + 1;
+ } break;
+
+ case 5: {
+ // GP0(E5h) - Set Drawing Offset (X,Y)
+ gpu_unai.DrawingOffset[0] = ((s32)cmd_word<<(32-11))>>(32-11);
+ gpu_unai.DrawingOffset[1] = ((s32)cmd_word<<(32-22))>>(32-11);
+ } break;
+
+ case 6: {
+ // GP0(E6h) - Mask Bit Setting
+ gpu_unai.Masking = (cmd_word & 0x2) << 1;
+ gpu_unai.PixelMSB = (cmd_word & 0x1) << 8;
+ } break;
+ }
}
extern const unsigned char cmd_lengths[256];
@@ -171,9 +218,12 @@ int do_cmd_list(u32 *list, int list_len, int *last_cmd)
u32 *list_start = list;
u32 *list_end = list + list_len;
- linesInterlace = force_interlace;
+ //TODO: set ilace_mask when resolution changes instead of every time,
+ // eliminate #ifdef below.
+ gpu_unai.ilace_mask = gpu_unai.config.ilace_force;
+
#ifdef HAVE_PRE_ARMV7 /* XXX */
- linesInterlace |= gpu.status.interlace;
+ gpu_unai.ilace_mask |= gpu.status.interlace;
#endif
for (; list < list_end; list += 1 + len)
@@ -186,126 +236,175 @@ int do_cmd_list(u32 *list, int list_len, int *last_cmd)
}
#define PRIM cmd
- PacketBuffer.U4[0] = list[0];
+ gpu_unai.PacketBuffer.U4[0] = list[0];
for (i = 1; i <= len; i++)
- PacketBuffer.U4[i] = list[i];
+ gpu_unai.PacketBuffer.U4[i] = list[i];
+
+ PtrUnion packet = { .ptr = (void*)&gpu_unai.PacketBuffer };
switch (cmd)
{
case 0x02:
- gpuClearImage();
+ gpuClearImage(packet);
break;
case 0x20:
case 0x21:
case 0x22:
- case 0x23:
- gpuDrawF3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB]);
- break;
+ case 0x23: { // Monochrome 3-pt poly
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyF(packet, driver, false);
+ } break;
case 0x24:
case 0x25:
case 0x26:
- case 0x27:
- 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]);
- break;
+ case 0x27: { // Textured 3-pt poly
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture(gpu_unai.PacketBuffer.U4[4] >> 16);
+
+ u32 driver_idx =
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
+
+ if (!FastLightingEnabled()) {
+ driver_idx |= Lighting;
+ } else {
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
+ driver_idx |= Lighting;
+ }
+
+ PP driver = gpuPolySpanDrivers[driver_idx];
+ gpuDrawPolyFT(packet, driver, false);
+ } break;
case 0x28:
case 0x29:
case 0x2A:
- case 0x2B: {
- const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB];
- gpuDrawF3(gpuPolySpanDriver);
- PacketBuffer.U4[1] = PacketBuffer.U4[4];
- gpuDrawF3(gpuPolySpanDriver);
- break;
- }
+ case 0x2B: { // Monochrome 4-pt poly
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyF(packet, driver, true); // is_quad = true
+ } break;
case 0x2C:
case 0x2D:
case 0x2E:
- case 0x2F: {
- 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];
- gpuDrawFT3(gpuPolySpanDriver);
- PacketBuffer.U4[1] = PacketBuffer.U4[7];
- PacketBuffer.U4[2] = PacketBuffer.U4[8];
- gpuDrawFT3(gpuPolySpanDriver);
- break;
- }
+ case 0x2F: { // Textured 4-pt poly
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture(gpu_unai.PacketBuffer.U4[4] >> 16);
+
+ u32 driver_idx =
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | gpu_unai.PixelMSB;
+
+ if (!FastLightingEnabled()) {
+ driver_idx |= Lighting;
+ } else {
+ if (!((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F)))
+ driver_idx |= Lighting;
+ }
+
+ PP driver = gpuPolySpanDrivers[driver_idx];
+ gpuDrawPolyFT(packet, driver, true); // is_quad = true
+ } break;
case 0x30:
case 0x31:
case 0x32:
- case 0x33:
- gpuDrawG3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB]);
- break;
+ case 0x33: { // Gouraud-shaded 3-pt poly
+ //NOTE: The '129' here is CF_GOURAUD | CF_LIGHT, however
+ // this is an untextured poly, so CF_LIGHT (texture blend)
+ // shouldn't apply. Until the original array of template
+ // instantiation ptrs is fixed, we're stuck with this. (TODO)
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyG(packet, driver, false);
+ } break;
case 0x34:
case 0x35:
case 0x36:
- case 0x37:
- gpuSetCLUT (PacketBuffer.U4[2] >> 16);
- gpuSetTexture (PacketBuffer.U4[5] >> 16);
- gpuDrawGT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB]);
- break;
+ case 0x37: { // Gouraud-shaded, textured 3-pt poly
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture (gpu_unai.PacketBuffer.U4[5] >> 16);
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyGT(packet, driver, false);
+ } break;
case 0x38:
case 0x39:
case 0x3A:
- case 0x3B: {
- const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB];
- gpuDrawG3(gpuPolySpanDriver);
- PacketBuffer.U4[0] = PacketBuffer.U4[6];
- PacketBuffer.U4[1] = PacketBuffer.U4[7];
- gpuDrawG3(gpuPolySpanDriver);
- break;
- }
+ case 0x3B: { // Gouraud-shaded 4-pt poly
+ // See notes regarding '129' for 0x30..0x33 further above -senquack
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode |
+ gpu_unai.Masking | Blending | 129 | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyG(packet, driver, true); // is_quad = true
+ } break;
case 0x3C:
case 0x3D:
case 0x3E:
- case 0x3F: {
- gpuSetCLUT (PacketBuffer.U4[2] >> 16);
- gpuSetTexture (PacketBuffer.U4[5] >> 16);
- const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB];
- gpuDrawGT3(gpuPolySpanDriver);
- PacketBuffer.U4[0] = PacketBuffer.U4[9];
- PacketBuffer.U4[1] = PacketBuffer.U4[10];
- PacketBuffer.U4[2] = PacketBuffer.U4[11];
- gpuDrawGT3(gpuPolySpanDriver);
- break;
- }
+ case 0x3F: { // Gouraud-shaded, textured 4-pt poly
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuSetTexture (gpu_unai.PacketBuffer.U4[5] >> 16);
+ PP driver = gpuPolySpanDrivers[
+ (gpu_unai.blit_mask?1024:0) |
+ Dithering |
+ Blending_Mode | gpu_unai.TEXT_MODE |
+ gpu_unai.Masking | Blending | ((Lighting)?129:0) | gpu_unai.PixelMSB
+ ];
+ gpuDrawPolyGT(packet, driver, true); // is_quad = true
+ } break;
case 0x40:
case 0x41:
case 0x42:
- case 0x43:
- gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
- break;
-
- case 0x48 ... 0x4F:
- {
+ case 0x43: { // Monochrome line
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineF(packet, driver);
+ } break;
+
+ case 0x48 ... 0x4F: { // Monochrome line strip
u32 num_vertexes = 1;
u32 *list_position = &(list[2]);
- gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineF(packet, driver);
while(1)
{
- PacketBuffer.U4[1] = PacketBuffer.U4[2];
- PacketBuffer.U4[2] = *list_position++;
- gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[2] = *list_position++;
+ gpuDrawLineF(packet, driver);
num_vertexes++;
if(list_position >= list_end) {
@@ -317,30 +416,38 @@ int do_cmd_list(u32 *list, int list_len, int *last_cmd)
}
len += (num_vertexes - 2);
- break;
- }
+ } break;
case 0x50:
case 0x51:
case 0x52:
- case 0x53:
- gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
- break;
-
- case 0x58 ... 0x5F:
- {
+ case 0x53: { // Gouraud-shaded line
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ // Index MSB selects Gouraud-shaded PixelSpanDriver:
+ driver_idx |= (1 << 5);
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineG(packet, driver);
+ } break;
+
+ case 0x58 ... 0x5F: { // Gouraud-shaded line strip
u32 num_vertexes = 1;
u32 *list_position = &(list[2]);
- gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
+ // Shift index right by one, as untextured prims don't use lighting
+ u32 driver_idx = (Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1;
+ // Index MSB selects Gouraud-shaded PixelSpanDriver:
+ driver_idx |= (1 << 5);
+ PSD driver = gpuPixelSpanDrivers[driver_idx];
+ gpuDrawLineG(packet, driver);
while(1)
{
- PacketBuffer.U4[0] = PacketBuffer.U4[2];
- PacketBuffer.U4[1] = PacketBuffer.U4[3];
- PacketBuffer.U4[2] = *list_position++;
- PacketBuffer.U4[3] = *list_position++;
- gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
+ gpu_unai.PacketBuffer.U4[0] = gpu_unai.PacketBuffer.U4[2];
+ gpu_unai.PacketBuffer.U4[1] = gpu_unai.PacketBuffer.U4[3];
+ gpu_unai.PacketBuffer.U4[2] = *list_position++;
+ gpu_unai.PacketBuffer.U4[3] = *list_position++;
+ gpuDrawLineG(packet, driver);
num_vertexes++;
if(list_position >= list_end) {
@@ -352,91 +459,116 @@ int do_cmd_list(u32 *list, int list_len, int *last_cmd)
}
len += (num_vertexes - 2) * 2;
- break;
- }
+ } break;
case 0x60:
case 0x61:
case 0x62:
- case 0x63:
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
- break;
+ case 0x63: { // Monochrome rectangle (variable size)
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ } break;
case 0x64:
case 0x65:
case 0x66:
- case 0x67:
- 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]);
- break;
+ case 0x67: { // Textured rectangle (variable size)
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
+
+ //senquack - Only color 808080h-878787h allows skipping lighting calculation:
+ // This fixes Silent Hill running animation on loading screens:
+ // (On PSX, color values 0x00-0x7F darken the source texture's color,
+ // 0x81-FF lighten textures (ultimately clamped to 0x1F),
+ // 0x80 leaves source texture color unchanged, HOWEVER,
+ // gpu_unai uses a simple lighting LUT whereby only the upper
+ // 5 bits of an 8-bit color are used, so 0x80-0x87 all behave as
+ // 0x80.
+ //
+ // NOTE: I've changed all textured sprite draw commands here and
+ // elsewhere to use proper behavior, but left poly commands
+ // alone, I don't want to slow rendering down too much. (TODO)
+ //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
+ // Strip lower 3 bits of each color and determine if lighting should be used:
+ if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ driver_idx |= Lighting;
+ PS driver = gpuSpriteSpanDrivers[driver_idx];
+ gpuDrawS(packet, driver);
+ } break;
case 0x68:
case 0x69:
case 0x6A:
- case 0x6B:
- PacketBuffer.U4[2] = 0x00010001;
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
- break;
+ case 0x6B: { // Monochrome rectangle (1x1 dot)
+ gpu_unai.PacketBuffer.U4[2] = 0x00010001;
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ } break;
case 0x70:
case 0x71:
case 0x72:
- case 0x73:
- PacketBuffer.U4[2] = 0x00080008;
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
- break;
+ case 0x73: { // Monochrome rectangle (8x8)
+ gpu_unai.PacketBuffer.U4[2] = 0x00080008;
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ } break;
case 0x74:
case 0x75:
case 0x76:
- case 0x77:
- 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]);
- break;
+ case 0x77: { // Textured rectangle (8x8)
+ gpu_unai.PacketBuffer.U4[3] = 0x00080008;
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
+
+ //senquack - Only color 808080h-878787h allows skipping lighting calculation:
+ //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
+ // Strip lower 3 bits of each color and determine if lighting should be used:
+ if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ driver_idx |= Lighting;
+ PS driver = gpuSpriteSpanDrivers[driver_idx];
+ gpuDrawS(packet, driver);
+ } break;
case 0x78:
case 0x79:
case 0x7A:
- case 0x7B:
- PacketBuffer.U4[2] = 0x00100010;
- gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
- break;
+ case 0x7B: { // Monochrome rectangle (16x16)
+ gpu_unai.PacketBuffer.U4[2] = 0x00100010;
+ PT driver = gpuTileSpanDrivers[(Blending_Mode | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>3)) >> 1];
+ gpuDrawT(packet, driver);
+ } break;
case 0x7C:
case 0x7D:
#ifdef __arm__
- if ((GPU_GP1 & 0x180) == 0 && (Masking | PixelMSB) == 0)
+ if ((gpu_unai.GPU_GP1 & 0x180) == 0 && (gpu_unai.Masking | gpu_unai.PixelMSB) == 0)
{
- gpuSetCLUT (PacketBuffer.U4[2] >> 16);
- gpuSetTexture (GPU_GP1);
- gpuDrawS16();
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ gpuDrawS16(packet);
break;
}
// fallthrough
#endif
case 0x7E:
- case 0x7F:
- 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]);
- break;
+ case 0x7F: { // Textured rectangle (16x16)
+ gpu_unai.PacketBuffer.U4[3] = 0x00100010;
+ gpuSetCLUT (gpu_unai.PacketBuffer.U4[2] >> 16);
+ u32 driver_idx = Blending_Mode | gpu_unai.TEXT_MODE | gpu_unai.Masking | Blending | (gpu_unai.PixelMSB>>1);
+ //senquack - Only color 808080h-878787h allows skipping lighting calculation:
+ //if ((gpu_unai.PacketBuffer.U1[0]>0x5F) && (gpu_unai.PacketBuffer.U1[1]>0x5F) && (gpu_unai.PacketBuffer.U1[2]>0x5F))
+ // Strip lower 3 bits of each color and determine if lighting should be used:
+ if ((gpu_unai.PacketBuffer.U4[0] & 0xF8F8F8) != 0x808080)
+ driver_idx |= Lighting;
+ PS driver = gpuSpriteSpanDrivers[driver_idx];
+ gpuDrawS(packet, driver);
+ } break;
case 0x80: // vid -> vid
- gpuMoveImage(); // prim handles updateLace && skip
+ gpuMoveImage(packet);
break;
+
#ifdef TEST
case 0xA0: // sys -> vid
{
@@ -445,70 +577,25 @@ int do_cmd_list(u32 *list, int list_len, int *last_cmd)
u32 load_size = load_width * load_height;
len += load_size / 2;
- break;
- }
+ } break;
+
case 0xC0:
break;
#else
case 0xA0: // sys ->vid
case 0xC0: // vid -> sys
+ // Handled by gpulib
goto breakloop;
#endif
- case 0xE1: {
- const u32 temp = PacketBuffer.U4[0];
- GPU_GP1 = (GPU_GP1 & ~0x000007FF) | (temp & 0x000007FF);
- gpuSetTexture(temp);
- gpu.ex_regs[1] = temp;
- 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);
- gpu.ex_regs[2] = temp;
- break;
- }
- case 0xE3: {
- const u32 temp = PacketBuffer.U4[0];
- DrawingArea[0] = temp & 0x3FF;
- DrawingArea[1] = (temp >> 10) & 0x3FF;
- gpu.ex_regs[3] = temp;
- break;
- }
- case 0xE4: {
- const u32 temp = PacketBuffer.U4[0];
- DrawingArea[2] = (temp & 0x3FF) + 1;
- DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1;
- gpu.ex_regs[4] = temp;
- break;
- }
- case 0xE5: {
- const u32 temp = PacketBuffer.U4[0];
- DrawingOffset[0] = ((s32)temp<<(32-11))>>(32-11);
- DrawingOffset[1] = ((s32)temp<<(32-22))>>(32-11);
- gpu.ex_regs[5] = temp;
- break;
- }
- case 0xE6: {
- const u32 temp = PacketBuffer.U4[0];
- Masking = (temp & 0x2) << 1;
- PixelMSB =(temp & 0x1) << 8;
- gpu.ex_regs[6] = temp;
- break;
- }
+ case 0xE1 ... 0xE6: { // Draw settings
+ gpuGP0Cmd_0xEx(gpu_unai, gpu_unai.PacketBuffer.U4[0]);
+ } break;
}
}
breakloop:
gpu.ex_regs[1] &= ~0x1ff;
- gpu.ex_regs[1] |= GPU_GP1 & 0x1ff;
+ gpu.ex_regs[1] |= gpu_unai.GPU_GP1 & 0x1ff;
*last_cmd = cmd;
return list - list_start;
@@ -532,20 +619,17 @@ void renderer_set_interlace(int enable, int is_odd)
{
}
-#ifndef TEST
-
#include "../../frontend/plugin_lib.h"
-
+// Handle any gpulib settings applicable to gpu_unai:
void renderer_set_config(const struct rearmed_cbs *cbs)
{
- force_interlace = cbs->gpu_unai.lineskip;
- enableAbbeyHack = cbs->gpu_unai.abe_hack;
- light = !cbs->gpu_unai.no_light;
- blend = !cbs->gpu_unai.no_blend;
-
- GPU_FrameBuffer = (u16 *)gpu.vram;
+ gpu_unai.vram = (u16*)gpu.vram;
+ gpu_unai.config.ilace_force = cbs->gpu_unai.ilace_force;
+ gpu_unai.config.pixel_skip = cbs->gpu_unai.pixel_skip;
+ gpu_unai.config.lighting = cbs->gpu_unai.lighting;
+ gpu_unai.config.fast_lighting = cbs->gpu_unai.fast_lighting;
+ gpu_unai.config.blending = cbs->gpu_unai.blending;
+ gpu_unai.config.dithering = cbs->gpu_unai.dithering;
}
-#endif
-
// vim:shiftwidth=2:expandtab
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-03 10:38:51 +0000