X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=plugins%2Fgpu_unai%2Fgpu_inner.h;h=4cd7bffe0dd40018e352d8e8397de70d980ff511;hp=8cb4bd534b2364934372b786cc12fa1cdcff0b8c;hb=HEAD;hpb=4cfc568dce10c4ff9a476e229c56b17f8f1ed678 diff --git a/plugins/gpu_unai/gpu_inner.h b/plugins/gpu_unai/gpu_inner.h index 8cb4bd53..3281d0fa 100644 --- a/plugins/gpu_unai/gpu_inner.h +++ b/plugins/gpu_unai/gpu_inner.h @@ -55,24 +55,22 @@ #include "gpu_inner_quantization.h" #include "gpu_inner_light.h" +#include "arm_features.h" +#include "compiler_features.h" #ifdef __arm__ +#include "gpu_arm.h" #include "gpu_inner_blend_arm.h" #include "gpu_inner_light_arm.h" #define gpuBlending gpuBlendingARM -#define gpuLightingRGB gpuLightingRGBARM #define gpuLightingTXT gpuLightingTXTARM -#define gpuLightingTXTGouraud gpuLightingTXTGouraudARM -// Non-dithering lighting and blending functions preserve uSrc -// MSB. This saves a few operations and useless load/stores. -#define MSB_PRESERVED (!CF_DITHER) #else #define gpuBlending gpuBlendingGeneric -#define gpuLightingRGB gpuLightingRGBGeneric #define gpuLightingTXT gpuLightingTXTGeneric -#define gpuLightingTXTGouraud gpuLightingTXTGouraudGeneric -#define MSB_PRESERVED 0 #endif +// Non-dithering lighting and blending functions preserve uSrc +// MSB. This saves a few operations and useless load/stores. +#define MSB_PRESERVED (!CF_DITHER) // 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. @@ -123,12 +121,8 @@ static inline u16 gpuGouraudColor15bpp(u32 r, u32 g, u32 b) // 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 -static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) +static le16_t* gpuPixelSpanFn(le16_t* pDst, uintptr_t data, ptrdiff_t incr, size_t len) { // Blend func can save an operation if it knows uSrc MSB is // unset. For untextured prims, this is always true. @@ -139,6 +133,9 @@ static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) u32 r, g, b; s32 r_incr, g_incr, b_incr; + // Caller counts in bytes, we count in pixels + incr /= 2; + if (CF_GOURAUD) { gcPtr = (GouraudColor*)data; r = gcPtr->r; r_incr = gcPtr->r_incr; @@ -152,15 +149,15 @@ static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) if (!CF_GOURAUD) { // NO GOURAUD if (!CF_MASKCHECK && !CF_BLEND) { - if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } - else { *(u16*)pDst = col; } + if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); } + else { *pDst = u16_to_le16(col); } } else if (CF_MASKCHECK && !CF_BLEND) { - if (!(*(u16*)pDst & 0x8000)) { - if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } - else { *(u16*)pDst = col; } + if (!(le16_raw(*pDst) & HTOLE16(0x8000))) { + if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); } + else { *pDst = u16_to_le16(col); } } } else { - uint_fast16_t uDst = *(u16*)pDst; + uint_fast16_t uDst = le16_to_u16(*pDst); if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; } uint_fast16_t uSrc = col; @@ -168,8 +165,8 @@ static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) if (CF_BLEND) uSrc = gpuBlending(uSrc, uDst); - if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; } - else { *(u16*)pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else { *pDst = u16_to_le16(uSrc); } } } else @@ -177,16 +174,16 @@ static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) if (!CF_MASKCHECK && !CF_BLEND) { col = gpuGouraudColor15bpp(r, g, b); - if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } - else { *(u16*)pDst = col; } + if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); } + else { *pDst = u16_to_le16(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; } + if (!(le16_raw(*pDst) & HTOLE16(0x8000))) { + if (CF_MASKSET) { *pDst = u16_to_le16(col | 0x8000); } + else { *pDst = u16_to_le16(col); } } } else { - uint_fast16_t uDst = *(u16*)pDst; + uint_fast16_t uDst = le16_to_u16(*pDst); if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; } col = gpuGouraudColor15bpp(r, g, b); @@ -199,8 +196,8 @@ static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) if (CF_BLEND) uSrc = gpuBlending(uSrc, uDst); - if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; } - else { *(u16*)pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else { *pDst = u16_to_le16(uSrc); } } } @@ -228,7 +225,7 @@ endpixel: return pDst; } -static u8* PixelSpanNULL(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) +static le16_t* PixelSpanNULL(le16_t* pDst, uintptr_t data, ptrdiff_t incr, size_t len) { #ifdef ENABLE_GPU_LOG_SUPPORT fprintf(stdout,"PixelSpanNULL()\n"); @@ -238,7 +235,7 @@ static u8* PixelSpanNULL(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) /////////////////////////////////////////////////////////////////////////////// // PixelSpan (lines) innerloops driver -typedef u8* (*PSD)(u8* dst, uintptr_t data, ptrdiff_t incr, size_t len); +typedef le16_t* (*PSD)(le16_t* dst, uintptr_t data, ptrdiff_t incr, size_t len); const PSD gpuPixelSpanDrivers[64] = { @@ -282,14 +279,26 @@ const PSD gpuPixelSpanDrivers[64] = // GPU Tiles innerloops generator template -static void gpuTileSpanFn(u16 *pDst, u32 count, u16 data) +static inline void gpuTileSpanFn(le16_t *pDst, u16 data, u32 count) { + le16_t ldata; + if (!CF_MASKCHECK && !CF_BLEND) { - if (CF_MASKSET) { data = data | 0x8000; } - do { *pDst++ = data; } while (--count); + if (CF_MASKSET) + ldata = u16_to_le16(data | 0x8000); + else + ldata = u16_to_le16(data); + do { *pDst++ = ldata; } while (--count); } else if (CF_MASKCHECK && !CF_BLEND) { - if (CF_MASKSET) { data = data | 0x8000; } - do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count); + if (CF_MASKSET) + ldata = u16_to_le16(data | 0x8000); + else + ldata = u16_to_le16(data); + do { + if (!(le16_raw(*pDst) & HTOLE16(0x8000))) + *pDst = ldata; + pDst++; + } while (--count); } else { // Blend func can save an operation if it knows uSrc MSB is @@ -299,16 +308,16 @@ static void gpuTileSpanFn(u16 *pDst, u32 count, u16 data) uint_fast16_t uSrc, uDst; do { - if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; } - if (CF_MASKCHECK) { if (uDst&0x8000) goto endtile; } + if (CF_MASKCHECK || CF_BLEND) { uDst = le16_to_u16(*pDst); } + if (CF_MASKCHECK) if (uDst&0x8000) { goto endtile; } uSrc = data; if (CF_BLEND) uSrc = gpuBlending(uSrc, uDst); - if (CF_MASKSET) { *pDst = uSrc | 0x8000; } - else { *pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else { *pDst = u16_to_le16(uSrc); } //senquack - Did not apply "Silent Hill" mask-bit fix to here. // It is hard to tell from scarce documentation available and @@ -322,7 +331,42 @@ endtile: } } -static void TileNULL(u16 *pDst, u32 count, u16 data) +template +static noinline void gpuTileDriverFn(le16_t *pDst, u16 data, u32 count, + const gpu_unai_inner_t &inn) +{ + const int li=gpu_unai.inn.ilace_mask; + const int pi=(ProgressiveInterlaceEnabled()?(gpu_unai.inn.ilace_mask+1):0); + const int pif=(ProgressiveInterlaceEnabled()?(gpu_unai.prog_ilace_flag?(gpu_unai.inn.ilace_mask+1):0):1); + const int y1 = inn.y1; + int y0 = inn.y0; + + for (; y0 < y1; ++y0) { + if (!(y0&li) && (y0&pi) != pif) + gpuTileSpanFn(pDst, data, count); + pDst += FRAME_WIDTH; + } +} + +#ifdef __arm__ + +template +static void TileAsm(le16_t *pDst, u16 data, u32 count, const gpu_unai_inner_t &inn) +{ + switch (CF) { + case 0x02: tile_driver_st0_asm(pDst, data, count, &inn); return; + case 0x0a: tile_driver_st1_asm(pDst, data, count, &inn); return; + case 0x1a: tile_driver_st3_asm(pDst, data, count, &inn); return; +#ifdef HAVE_ARMV6 + case 0x12: tile_driver_st2_asm(pDst, data, count, &inn); return; +#endif + } + gpuTileDriverFn(pDst, data, count, inn); +} + +#endif + +static void TileNULL(le16_t *pDst, u16 data, u32 count, const gpu_unai_inner_t &inn) { #ifdef ENABLE_GPU_LOG_SUPPORT fprintf(stdout,"TileNULL()\n"); @@ -331,31 +375,47 @@ static void TileNULL(u16 *pDst, u32 count, u16 data) /////////////////////////////////////////////////////////////////////////////// // Tiles innerloops driver -typedef void (*PT)(u16 *pDst, u32 count, u16 data); +typedef void (*PT)(le16_t *pDst, u16 data, u32 count, const gpu_unai_inner_t &inn); // Template instantiation helper macros -#define TI(cf) gpuTileSpanFn<(cf)> +#define TI(cf) gpuTileDriverFn<(cf)> #define TN TileNULL +#ifdef __arm__ +#define TA(cf) TileAsm<(cf)> +#else +#define TA(cf) TI(cf) +#endif +#ifdef HAVE_ARMV6 +#define TA6(cf) TileAsm<(cf)> +#else +#define TA6(cf) TI(cf) +#endif #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) + TI((ub)|0x00), TA6((ub)|0x02), TI((ub)|0x04), TI((ub)|0x06), \ + TN, TA ((ub)|0x0a), TN, TI((ub)|0x0e), \ + TN, TA6((ub)|0x12), TN, TI((ub)|0x16), \ + TN, TA ((ub)|0x1a), TN, TI((ub)|0x1e) -const PT gpuTileSpanDrivers[32] = { +const PT gpuTileDrivers[32] = { TIBLOCK(0<<8), TIBLOCK(1<<8) }; #undef TI #undef TN +#undef TA +#undef TA6 #undef TIBLOCK /////////////////////////////////////////////////////////////////////////////// // GPU Sprites innerloops generator +typedef void (*PS)(le16_t *pPixel, u32 count, const u8 *pTxt, + const gpu_unai_inner_t &inn); + template -static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0) +static noinline void gpuSpriteDriverFn(le16_t *pPixel, u32 count, const u8 *pTxt_base, + const gpu_unai_inner_t &inn) { // 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). @@ -364,36 +424,47 @@ static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0) uint_fast16_t uSrc, uDst, srcMSB; bool should_blend; - u32 u0_mask = gpu_senquack.TextureWindow[2]; + u32 u0_mask = inn.u_msk >> 10; u8 r5, g5, b5; if (CF_LIGHT) { - r5 = gpu_senquack.r5; - g5 = gpu_senquack.g5; - b5 = gpu_senquack.b5; + r5 = inn.r5; + g5 = inn.g5; + b5 = inn.b5; } + const le16_t *CBA_; if (CF_TEXTMODE!=3) CBA_ = inn.CBA; + const u32 v0_mask = inn.v_msk >> 10; + s32 y0 = inn.y0, y1 = inn.y1, li = inn.ilace_mask; + u32 u0_ = inn.u, v0 = inn.v; + if (CF_TEXTMODE==3) { - // Texture is accessed byte-wise, so adjust mask if 16bpp + // Texture is accessed byte-wise, so adjust to 16bpp + u0_ <<= 1; u0_mask <<= 1; } - const u16 *CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_senquack.CBA; - - do + for (; y0 < y1; ++y0, pPixel += FRAME_WIDTH, ++v0) { - if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; } + if (y0 & li) continue; + const u8 *pTxt = pTxt_base + ((v0 & v0_mask) * 2048); + le16_t *pDst = pPixel; + u32 u0 = u0_; + u32 count1 = count; + do + { + if (CF_MASKCHECK || CF_BLEND) { uDst = le16_to_u16(*pDst); } if (CF_MASKCHECK) if (uDst&0x8000) { goto endsprite; } if (CF_TEXTMODE==1) { // 4bpp (CLUT) u8 rgb = pTxt[(u0 & u0_mask)>>1]; - uSrc = CBA_[(rgb>>((u0&1)<<2))&0xf]; + uSrc = le16_to_u16(CBA_[(rgb>>((u0&1)<<2))&0xf]); } if (CF_TEXTMODE==2) { // 8bpp (CLUT) - uSrc = CBA_[pTxt[u0 & u0_mask]]; + uSrc = le16_to_u16(CBA_[pTxt[u0 & u0_mask]]); } if (CF_TEXTMODE==3) { // 16bpp - uSrc = *(u16*)(&pTxt[u0 & u0_mask]); + uSrc = le16_to_u16(*(le16_t*)(&pTxt[u0 & u0_mask])); } if (!uSrc) goto endsprite; @@ -410,18 +481,59 @@ static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0) if (CF_BLEND && should_blend) uSrc = gpuBlending(uSrc, uDst); - if (CF_MASKSET) { *pDst = uSrc | 0x8000; } - else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; } - else { *pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = u16_to_le16(uSrc | srcMSB); } + else { *pDst = u16_to_le16(uSrc); } endsprite: u0 += (CF_TEXTMODE==3) ? 2 : 1; pDst++; + } + while (--count1); } - while (--count); } -static void SpriteNULL(u16 *pDst, u32 count, u8* pTxt, u32 u0) +#ifdef __arm__ + +template +static void SpriteMaybeAsm(le16_t *pPixel, u32 count, const u8 *pTxt_base, + const gpu_unai_inner_t &inn) +{ +#if 1 + s32 lines = inn.y1 - inn.y0; + u32 u1m = inn.u + count - 1, v1m = inn.v + lines - 1; + if (u1m == (u1m & (inn.u_msk >> 10)) && v1m == (v1m & (inn.v_msk >> 10))) { + const u8 *pTxt = pTxt_base + inn.v * 2048; + switch (CF) { + case 0x20: sprite_driver_4bpp_asm (pPixel, pTxt + inn.u / 2, count, &inn); return; + case 0x40: sprite_driver_8bpp_asm (pPixel, pTxt + inn.u, count, &inn); return; + case 0x60: sprite_driver_16bpp_asm(pPixel, pTxt + inn.u * 2, count, &inn); return; + } + } + if (v1m == (v1m & (inn.v_msk >> 10))) { + const u8 *pTxt = pTxt_base + inn.v * 2048; + switch (CF) { + case 0x20: sprite_driver_4bpp_l0_std_asm(pPixel, pTxt, count, &inn); return; + case 0x22: sprite_driver_4bpp_l0_st0_asm(pPixel, pTxt, count, &inn); return; + case 0x40: sprite_driver_8bpp_l0_std_asm(pPixel, pTxt, count, &inn); return; + case 0x42: sprite_driver_8bpp_l0_st0_asm(pPixel, pTxt, count, &inn); return; +#ifdef HAVE_ARMV6 + case 0x21: sprite_driver_4bpp_l1_std_asm(pPixel, pTxt, count, &inn); return; + case 0x23: sprite_driver_4bpp_l1_st0_asm(pPixel, pTxt, count, &inn); return; + case 0x2b: sprite_driver_4bpp_l1_st1_asm(pPixel, pTxt, count, &inn); return; + case 0x41: sprite_driver_8bpp_l1_std_asm(pPixel, pTxt, count, &inn); return; + case 0x43: sprite_driver_8bpp_l1_st0_asm(pPixel, pTxt, count, &inn); return; + case 0x4b: sprite_driver_8bpp_l1_st1_asm(pPixel, pTxt, count, &inn); return; +#endif + } + } +#endif + gpuSpriteDriverFn(pPixel, count, pTxt_base, inn); +} +#endif // __arm__ + +static void SpriteNULL(le16_t *pPixel, u32 count, const u8 *pTxt_base, + const gpu_unai_inner_t &inn) { #ifdef ENABLE_GPU_LOG_SUPPORT fprintf(stdout,"SpriteNULL()\n"); @@ -432,36 +544,47 @@ static void SpriteNULL(u16 *pDst, u32 count, u8* pTxt, u32 u0) /////////////////////////////////////////////////////////////////////////////// // Sprite innerloops driver -typedef void (*PS)(u16 *pDst, u32 count, u8* pTxt, u32 u0); // Template instantiation helper macros -#define TI(cf) gpuSpriteSpanFn<(cf)> +#define TI(cf) gpuSpriteDriverFn<(cf)> #define TN SpriteNULL +#ifdef __arm__ +#define TA(cf) SpriteMaybeAsm<(cf)> +#else +#define TA(cf) TI(cf) +#endif +#ifdef HAVE_ARMV6 +#define TA6(cf) SpriteMaybeAsm<(cf)> +#else +#define TA6(cf) TI(cf) +#endif #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), \ + TA((ub)|0x20), TA6((ub)|0x21),TA6((ub)|0x22),TA6((ub)|0x23),TI((ub)|0x24), TI((ub)|0x25), TI((ub)|0x26), TI((ub)|0x27), \ + TN, TN, TI((ub)|0x2a), TA6((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), \ + TA((ub)|0x40), TA6((ub)|0x41),TA6((ub)|0x42),TA6((ub)|0x43),TI((ub)|0x44), TI((ub)|0x45), TI((ub)|0x46), TI((ub)|0x47), \ + TN, TN, TI((ub)|0x4a), TA6((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), \ + TA((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] = { +const PS gpuSpriteDrivers[256] = { TIBLOCK(0<<8), TIBLOCK(1<<8) }; #undef TI #undef TN #undef TIBLOCK +#undef TA +#undef TA6 /////////////////////////////////////////////////////////////////////////////// // GPU Polygon innerloops generator @@ -485,7 +608,7 @@ const PS gpuSpriteSpanDrivers[256] = { // relevant blend/light headers. // (see README_senquack.txt) template -static void gpuPolySpanFn(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count) +static noinline void gpuPolySpanFn(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count) { // 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). @@ -493,14 +616,14 @@ static void gpuPolySpanFn(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 cou const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT; bool should_blend; - u32 bMsk; if (CF_BLITMASK) bMsk = gpu_senquack.blit_mask; + u32 bMsk; if (CF_BLITMASK) bMsk = gpu_unai.inn.blit_mask; if (!CF_TEXTMODE) { if (!CF_GOURAUD) { // UNTEXTURED, NO GOURAUD - const u16 pix15 = gpu_senquack.PixelData; + const u16 pix15 = gpu_unai.inn.PixelData; do { uint_fast16_t uSrc, uDst; @@ -509,7 +632,7 @@ static void gpuPolySpanFn(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 cou // 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_BLEND || CF_MASKCHECK) uDst = le16_to_u16(*pDst); if (CF_MASKCHECK) { if (uDst&0x8000) { goto endpolynotextnogou; } } uSrc = pix15; @@ -517,8 +640,8 @@ static void gpuPolySpanFn(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 cou if (CF_BLEND) uSrc = gpuBlending(uSrc, uDst); - if (CF_MASKSET) { *pDst = uSrc | 0x8000; } - else { *pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else { *pDst = u16_to_le16(uSrc); } endpolynotextnogou: pDst++; @@ -527,8 +650,8 @@ endpolynotextnogou: else { // UNTEXTURED, GOURAUD - u32 l_gCol = gpu_senquack.gCol; - u32 l_gInc = gpu_senquack.gInc; + gcol_t l_gCol = gpu_unai.inn.gCol; + gcol_t l_gInc = gpu_unai.inn.gInc; do { uint_fast16_t uDst, uSrc; @@ -536,7 +659,7 @@ endpolynotextnogou: // 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_BLEND || CF_MASKCHECK) uDst = le16_to_u16(*pDst); if (CF_MASKCHECK) { if (uDst&0x8000) goto endpolynotextgou; } if (CF_DITHER) { @@ -555,12 +678,12 @@ endpolynotextnogou: uSrc = gpuBlending(uSrc, uDst); } - if (CF_MASKSET) { *pDst = uSrc | 0x8000; } - else { *pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else { *pDst = u16_to_le16(uSrc); } endpolynotextgou: pDst++; - l_gCol += l_gInc; + l_gCol.raw += l_gInc.raw; } while (--count); } @@ -571,34 +694,37 @@ endpolynotextgou: uint_fast16_t uDst, uSrc, srcMSB; - //senquack - note: original UNAI code had gpu_senquack.{u4/v4} packed into + //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_senquack.u_msk; u32 l_v_msk = gpu_senquack.v_msk; - u32 l_u = gpu_senquack.u & l_u_msk; u32 l_v = gpu_senquack.v & l_v_msk; - s32 l_u_inc = gpu_senquack.u_inc; s32 l_v_inc = gpu_senquack.v_inc; + u32 l_u_msk = gpu_unai.inn.u_msk; u32 l_v_msk = gpu_unai.inn.v_msk; + u32 l_u = gpu_unai.inn.u & l_u_msk; u32 l_v = gpu_unai.inn.v & l_v_msk; + s32 l_u_inc = gpu_unai.inn.u_inc; s32 l_v_inc = gpu_unai.inn.v_inc; + l_v <<= 1; + l_v_inc <<= 1; + l_v_msk = (l_v_msk & (0xff<<10)) << 1; - const u16* TBA_ = gpu_senquack.TBA; - const u16* CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_senquack.CBA; + const le16_t* TBA_ = gpu_unai.inn.TBA; + const le16_t* CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.inn.CBA; u8 r5, g5, b5; u8 r8, g8, b8; - u32 l_gInc, l_gCol; + gcol_t l_gInc, l_gCol; if (CF_LIGHT) { if (CF_GOURAUD) { - l_gInc = gpu_senquack.gInc; - l_gCol = gpu_senquack.gCol; + l_gInc = gpu_unai.inn.gInc; + l_gCol = gpu_unai.inn.gCol; } else { if (CF_DITHER) { - r8 = gpu_senquack.r8; - g8 = gpu_senquack.g8; - b8 = gpu_senquack.b8; + r8 = gpu_unai.inn.r8; + g8 = gpu_unai.inn.g8; + b8 = gpu_unai.inn.b8; } else { - r5 = gpu_senquack.r5; - g5 = gpu_senquack.g5; - b5 = gpu_senquack.b5; + r5 = gpu_unai.inn.r5; + g5 = gpu_unai.inn.g5; + b5 = gpu_unai.inn.b5; } } } @@ -606,24 +732,26 @@ endpolynotextgou: do { if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolytext; } - if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; } + if (CF_MASKCHECK || CF_BLEND) { uDst = le16_to_u16(*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); + u32 tv=l_v&l_v_msk; u8 rgb=((u8*)TBA_)[tv+(tu>>1)]; - uSrc=CBA_[(rgb>>((tu&1)<<2))&0xf]; + uSrc=le16_to_u16(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))])]; + u32 tv=l_v&l_v_msk; + uSrc = le16_to_u16(CBA_[((u8*)TBA_)[tv+(l_u>>10)]]); if (!uSrc) goto endpolytext; } if (CF_TEXTMODE==3) { // 16bpp - uSrc = TBA_[(l_u>>10)+((l_v)&(0xff<<10))]; + u32 tv=(l_v&l_v_msk)>>1; + uSrc = le16_to_u16(TBA_[tv+(l_u>>10)]); if (!uSrc) goto endpolytext; } @@ -661,20 +789,45 @@ endpolynotextgou: uSrc = gpuBlending(uSrc, uDst); } - if (CF_MASKSET) { *pDst = uSrc | 0x8000; } - else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; } - else { *pDst = uSrc; } + if (CF_MASKSET) { *pDst = u16_to_le16(uSrc | 0x8000); } + else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = u16_to_le16(uSrc | srcMSB); } + else { *pDst = u16_to_le16(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; + l_v += l_v_inc; + if (CF_LIGHT && CF_GOURAUD) + l_gCol.raw += l_gInc.raw; } while (--count); } } -static void PolyNULL(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count) +#ifdef __arm__ +template +static void PolySpanMaybeAsm(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count) +{ + switch (CF) { + case 0x02: poly_untex_st0_asm (pDst, &gpu_unai.inn, count); break; + case 0x0a: poly_untex_st1_asm (pDst, &gpu_unai.inn, count); break; + case 0x1a: poly_untex_st3_asm (pDst, &gpu_unai.inn, count); break; + case 0x20: poly_4bpp_asm (pDst, &gpu_unai.inn, count); break; + case 0x22: poly_4bpp_l0_st0_asm(pDst, &gpu_unai.inn, count); break; + case 0x40: poly_8bpp_asm (pDst, &gpu_unai.inn, count); break; + case 0x42: poly_8bpp_l0_st0_asm(pDst, &gpu_unai.inn, count); break; +#ifdef HAVE_ARMV6 + case 0x12: poly_untex_st2_asm (pDst, &gpu_unai.inn, count); break; + case 0x21: poly_4bpp_l1_std_asm(pDst, &gpu_unai.inn, count); break; + case 0x23: poly_4bpp_l1_st0_asm(pDst, &gpu_unai.inn, count); break; + case 0x41: poly_8bpp_l1_std_asm(pDst, &gpu_unai.inn, count); break; + case 0x43: poly_8bpp_l1_st0_asm(pDst, &gpu_unai.inn, count); break; +#endif + default: gpuPolySpanFn(gpu_unai, pDst, count); + } +} +#endif + +static void PolyNULL(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count) { #ifdef ENABLE_GPU_LOG_SUPPORT fprintf(stdout,"PolyNULL()\n"); @@ -683,21 +836,31 @@ static void PolyNULL(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count) /////////////////////////////////////////////////////////////////////////////// // Polygon innerloops driver -typedef void (*PP)(const gpu_senquack_t &gpu_senquack, u16 *pDst, u32 count); +typedef void (*PP)(const gpu_unai_t &gpu_unai, le16_t *pDst, u32 count); // Template instantiation helper macros #define TI(cf) gpuPolySpanFn<(cf)> #define TN PolyNULL +#ifdef __arm__ +#define TA(cf) PolySpanMaybeAsm<(cf)> +#else +#define TA(cf) TI(cf) +#endif +#ifdef HAVE_ARMV6 +#define TA6(cf) PolySpanMaybeAsm<(cf)> +#else +#define TA6(cf) TI(cf) +#endif #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), \ + TI((ub)|0x00), TI((ub)|0x01), TA6((ub)|0x02),TI((ub)|0x03), TI((ub)|0x04), TI((ub)|0x05), TI((ub)|0x06), TI((ub)|0x07), \ + TN, TN, TA((ub)|0x0a), TI((ub)|0x0b), TN, TN, TI((ub)|0x0e), TI((ub)|0x0f), \ + TN, TN, TA6((ub)|0x12),TI((ub)|0x13), TN, TN, TI((ub)|0x16), TI((ub)|0x17), \ + TN, TN, TA((ub)|0x1a), TI((ub)|0x1b), TN, TN, TI((ub)|0x1e), TI((ub)|0x1f), \ + TA((ub)|0x20), TA6((ub)|0x21),TA6((ub)|0x22),TA6((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), \ + TA((ub)|0x40), TA6((ub)|0x41),TA6((ub)|0x42),TA6((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), \ @@ -730,5 +893,7 @@ const PP gpuPolySpanDrivers[2048] = { #undef TI #undef TN #undef TIBLOCK +#undef TA +#undef TA6 #endif /* __GPU_UNAI_GPU_INNER_H__ */