| 1 | /*************************************************************************** |
| 2 | * Copyright (C) 2010 PCSX4ALL Team * |
| 3 | * Copyright (C) 2010 Unai * |
| 4 | * Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) * |
| 5 | * * |
| 6 | * This program is free software; you can redistribute it and/or modify * |
| 7 | * it under the terms of the GNU General Public License as published by * |
| 8 | * the Free Software Foundation; either version 2 of the License, or * |
| 9 | * (at your option) any later version. * |
| 10 | * * |
| 11 | * This program is distributed in the hope that it will be useful, * |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
| 14 | * GNU General Public License for more details. * |
| 15 | * * |
| 16 | * You should have received a copy of the GNU General Public License * |
| 17 | * along with this program; if not, write to the * |
| 18 | * Free Software Foundation, Inc., * |
| 19 | * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * |
| 20 | ***************************************************************************/ |
| 21 | |
| 22 | /////////////////////////////////////////////////////////////////////////////// |
| 23 | // Inner loop driver instantiation file |
| 24 | |
| 25 | /////////////////////////////////////////////////////////////////////////////// |
| 26 | // Option Masks (CF template paramter) |
| 27 | #define CF_LIGHT ((CF>> 0)&1) // Lighting |
| 28 | #define CF_BLEND ((CF>> 1)&1) // Blending |
| 29 | #define CF_MASKCHECK ((CF>> 2)&1) // Mask bit check |
| 30 | #define CF_BLENDMODE ((CF>> 3)&3) // Blend mode 0..3 |
| 31 | #define CF_TEXTMODE ((CF>> 5)&3) // Texture mode 1..3 (0: texturing disabled) |
| 32 | #define CF_GOURAUD ((CF>> 7)&1) // Gouraud shading |
| 33 | #define CF_MASKSET ((CF>> 8)&1) // Mask bit set |
| 34 | #define CF_DITHER ((CF>> 9)&1) // Dithering |
| 35 | #define CF_BLITMASK ((CF>>10)&1) // blit_mask check (skip rendering pixels |
| 36 | // that wouldn't end up displayed on |
| 37 | // low-res screen using simple downscaler) |
| 38 | |
| 39 | //#ifdef __arm__ |
| 40 | //#ifndef ENABLE_GPU_ARMV7 |
| 41 | /* ARMv5 */ |
| 42 | //#include "gpu_inner_blend_arm5.h" |
| 43 | //#else |
| 44 | /* ARMv7 optimized */ |
| 45 | //#include "gpu_inner_blend_arm7.h" |
| 46 | //#endif |
| 47 | //#else |
| 48 | //#include "gpu_inner_blend.h" |
| 49 | //#endif |
| 50 | |
| 51 | #include "gpu_inner_blend.h" |
| 52 | #include "gpu_inner_quantization.h" |
| 53 | #include "gpu_inner_light.h" |
| 54 | |
| 55 | #ifdef __arm__ |
| 56 | #include "gpu_inner_blend_arm.h" |
| 57 | #include "gpu_inner_light_arm.h" |
| 58 | #define gpuBlending gpuBlendingARM |
| 59 | #define gpuLightingRGB gpuLightingRGBARM |
| 60 | #define gpuLightingTXT gpuLightingTXTARM |
| 61 | #define gpuLightingTXTGouraud gpuLightingTXTGouraudARM |
| 62 | // Non-dithering lighting and blending functions preserve uSrc |
| 63 | // MSB. This saves a few operations and useless load/stores. |
| 64 | #define MSB_PRESERVED (!CF_DITHER) |
| 65 | #else |
| 66 | #define gpuBlending gpuBlendingGeneric |
| 67 | #define gpuLightingRGB gpuLightingRGBGeneric |
| 68 | #define gpuLightingTXT gpuLightingTXTGeneric |
| 69 | #define gpuLightingTXTGouraud gpuLightingTXTGouraudGeneric |
| 70 | #define MSB_PRESERVED 0 |
| 71 | #endif |
| 72 | |
| 73 | |
| 74 | // If defined, Gouraud colors are fixed-point 5.11, otherwise they are 8.16 |
| 75 | // This is only for debugging/verification of low-precision colors in C. |
| 76 | // Low-precision Gouraud is intended for use by SIMD-optimized inner drivers |
| 77 | // which get/use Gouraud colors in SIMD registers. |
| 78 | //#define GPU_GOURAUD_LOW_PRECISION |
| 79 | |
| 80 | // How many bits of fixed-point precision GouraudColor uses |
| 81 | #ifdef GPU_GOURAUD_LOW_PRECISION |
| 82 | #define GPU_GOURAUD_FIXED_BITS 11 |
| 83 | #else |
| 84 | #define GPU_GOURAUD_FIXED_BITS 16 |
| 85 | #endif |
| 86 | |
| 87 | // Used to pass Gouraud colors to gpuPixelSpanFn() (lines) |
| 88 | struct GouraudColor { |
| 89 | #ifdef GPU_GOURAUD_LOW_PRECISION |
| 90 | u16 r, g, b; |
| 91 | s16 r_incr, g_incr, b_incr; |
| 92 | #else |
| 93 | u32 r, g, b; |
| 94 | s32 r_incr, g_incr, b_incr; |
| 95 | #endif |
| 96 | }; |
| 97 | |
| 98 | static inline u16 gpuGouraudColor15bpp(u32 r, u32 g, u32 b) |
| 99 | { |
| 100 | r >>= GPU_GOURAUD_FIXED_BITS; |
| 101 | g >>= GPU_GOURAUD_FIXED_BITS; |
| 102 | b >>= GPU_GOURAUD_FIXED_BITS; |
| 103 | |
| 104 | #ifndef GPU_GOURAUD_LOW_PRECISION |
| 105 | // High-precision Gouraud colors are 8-bit + fractional |
| 106 | r >>= 3; g >>= 3; b >>= 3; |
| 107 | #endif |
| 108 | |
| 109 | return r | (g << 5) | (b << 10); |
| 110 | } |
| 111 | |
| 112 | /////////////////////////////////////////////////////////////////////////////// |
| 113 | // GPU Pixel span operations generator gpuPixelSpanFn<> |
| 114 | // Oct 2016: Created/adapted from old gpuPixelFn by senquack: |
| 115 | // Original gpuPixelFn was used to draw lines one pixel at a time. I wrote |
| 116 | // new line algorithms that draw lines using horizontal/vertical/diagonal |
| 117 | // spans of pixels, necessitating new pixel-drawing function that could |
| 118 | // not only render spans of pixels, but gouraud-shade them as well. |
| 119 | // This speeds up line rendering and would allow tile-rendering (untextured |
| 120 | // rectangles) to use the same set of functions. Since tiles are always |
| 121 | // monochrome, they simply wouldn't use the extra set of 32 gouraud-shaded |
| 122 | // gpuPixelSpanFn functions (TODO?). |
| 123 | // |
| 124 | // NOTE: While the PS1 framebuffer is 16 bit, we use 8-bit pointers here, |
| 125 | // so that pDst can be incremented directly by 'incr' parameter |
| 126 | // without having to shift it before use. |
| 127 | template<int CF> |
| 128 | static u8* gpuPixelSpanFn(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) |
| 129 | { |
| 130 | // Blend func can save an operation if it knows uSrc MSB is |
| 131 | // unset. For untextured prims, this is always true. |
| 132 | const bool skip_uSrc_mask = true; |
| 133 | |
| 134 | u16 col; |
| 135 | struct GouraudColor * gcPtr; |
| 136 | u32 r, g, b; |
| 137 | s32 r_incr, g_incr, b_incr; |
| 138 | |
| 139 | if (CF_GOURAUD) { |
| 140 | gcPtr = (GouraudColor*)data; |
| 141 | r = gcPtr->r; r_incr = gcPtr->r_incr; |
| 142 | g = gcPtr->g; g_incr = gcPtr->g_incr; |
| 143 | b = gcPtr->b; b_incr = gcPtr->b_incr; |
| 144 | } else { |
| 145 | col = (u16)data; |
| 146 | } |
| 147 | |
| 148 | do { |
| 149 | if (!CF_GOURAUD) |
| 150 | { // NO GOURAUD |
| 151 | if (!CF_MASKCHECK && !CF_BLEND) { |
| 152 | if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } |
| 153 | else { *(u16*)pDst = col; } |
| 154 | } else if (CF_MASKCHECK && !CF_BLEND) { |
| 155 | if (!(*(u16*)pDst & 0x8000)) { |
| 156 | if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } |
| 157 | else { *(u16*)pDst = col; } |
| 158 | } |
| 159 | } else { |
| 160 | uint_fast16_t uDst = *(u16*)pDst; |
| 161 | if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; } |
| 162 | |
| 163 | uint_fast16_t uSrc = col; |
| 164 | |
| 165 | if (CF_BLEND) |
| 166 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 167 | |
| 168 | if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; } |
| 169 | else { *(u16*)pDst = uSrc; } |
| 170 | } |
| 171 | |
| 172 | } else |
| 173 | { // GOURAUD |
| 174 | |
| 175 | if (!CF_MASKCHECK && !CF_BLEND) { |
| 176 | col = gpuGouraudColor15bpp(r, g, b); |
| 177 | if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } |
| 178 | else { *(u16*)pDst = col; } |
| 179 | } else if (CF_MASKCHECK && !CF_BLEND) { |
| 180 | col = gpuGouraudColor15bpp(r, g, b); |
| 181 | if (!(*(u16*)pDst & 0x8000)) { |
| 182 | if (CF_MASKSET) { *(u16*)pDst = col | 0x8000; } |
| 183 | else { *(u16*)pDst = col; } |
| 184 | } |
| 185 | } else { |
| 186 | uint_fast16_t uDst = *(u16*)pDst; |
| 187 | if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; } |
| 188 | col = gpuGouraudColor15bpp(r, g, b); |
| 189 | |
| 190 | uint_fast16_t uSrc = col; |
| 191 | |
| 192 | // Blend func can save an operation if it knows uSrc MSB is |
| 193 | // unset. For untextured prims, this is always true. |
| 194 | const bool skip_uSrc_mask = true; |
| 195 | |
| 196 | if (CF_BLEND) |
| 197 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 198 | |
| 199 | if (CF_MASKSET) { *(u16*)pDst = uSrc | 0x8000; } |
| 200 | else { *(u16*)pDst = uSrc; } |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | endpixel: |
| 205 | if (CF_GOURAUD) { |
| 206 | r += r_incr; |
| 207 | g += g_incr; |
| 208 | b += b_incr; |
| 209 | } |
| 210 | pDst += incr; |
| 211 | } while (len-- > 1); |
| 212 | |
| 213 | // Note from senquack: Normally, I'd prefer to write a 'do {} while (--len)' |
| 214 | // loop, or even a for() loop, however, on MIPS platforms anything but the |
| 215 | // 'do {} while (len-- > 1)' tends to generate very unoptimal asm, with |
| 216 | // many unneeded MULs/ADDs/branches at the ends of these functions. |
| 217 | // If you change the loop structure above, be sure to compare the quality |
| 218 | // of the generated code!! |
| 219 | |
| 220 | if (CF_GOURAUD) { |
| 221 | gcPtr->r = r; |
| 222 | gcPtr->g = g; |
| 223 | gcPtr->b = b; |
| 224 | } |
| 225 | return pDst; |
| 226 | } |
| 227 | |
| 228 | static u8* PixelSpanNULL(u8* pDst, uintptr_t data, ptrdiff_t incr, size_t len) |
| 229 | { |
| 230 | #ifdef ENABLE_GPU_LOG_SUPPORT |
| 231 | fprintf(stdout,"PixelSpanNULL()\n"); |
| 232 | #endif |
| 233 | return pDst; |
| 234 | } |
| 235 | |
| 236 | /////////////////////////////////////////////////////////////////////////////// |
| 237 | // PixelSpan (lines) innerloops driver |
| 238 | typedef u8* (*PSD)(u8* dst, uintptr_t data, ptrdiff_t incr, size_t len); |
| 239 | |
| 240 | const PSD gpuPixelSpanDrivers[64] = |
| 241 | { |
| 242 | // Array index | 'CF' template field | Field value |
| 243 | // ------------+---------------------+---------------- |
| 244 | // Bit 0 | CF_BLEND | off (0), on (1) |
| 245 | // Bit 1 | CF_MASKCHECK | off (0), on (1) |
| 246 | // Bit 3:2 | CF_BLENDMODE | 0..3 |
| 247 | // Bit 4 | CF_MASKSET | off (0), on (1) |
| 248 | // Bit 5 | CF_GOURAUD | off (0), on (1) |
| 249 | // |
| 250 | // NULL entries are ones for which blending is disabled and blend-mode |
| 251 | // field is non-zero, which is obviously invalid. |
| 252 | |
| 253 | // Flat-shaded |
| 254 | gpuPixelSpanFn<0x00<<1>, gpuPixelSpanFn<0x01<<1>, gpuPixelSpanFn<0x02<<1>, gpuPixelSpanFn<0x03<<1>, |
| 255 | PixelSpanNULL, gpuPixelSpanFn<0x05<<1>, PixelSpanNULL, gpuPixelSpanFn<0x07<<1>, |
| 256 | PixelSpanNULL, gpuPixelSpanFn<0x09<<1>, PixelSpanNULL, gpuPixelSpanFn<0x0B<<1>, |
| 257 | PixelSpanNULL, gpuPixelSpanFn<0x0D<<1>, PixelSpanNULL, gpuPixelSpanFn<0x0F<<1>, |
| 258 | |
| 259 | // Flat-shaded + PixelMSB (CF_MASKSET) |
| 260 | gpuPixelSpanFn<(0x00<<1)|0x100>, gpuPixelSpanFn<(0x01<<1)|0x100>, gpuPixelSpanFn<(0x02<<1)|0x100>, gpuPixelSpanFn<(0x03<<1)|0x100>, |
| 261 | PixelSpanNULL, gpuPixelSpanFn<(0x05<<1)|0x100>, PixelSpanNULL, gpuPixelSpanFn<(0x07<<1)|0x100>, |
| 262 | PixelSpanNULL, gpuPixelSpanFn<(0x09<<1)|0x100>, PixelSpanNULL, gpuPixelSpanFn<(0x0B<<1)|0x100>, |
| 263 | PixelSpanNULL, gpuPixelSpanFn<(0x0D<<1)|0x100>, PixelSpanNULL, gpuPixelSpanFn<(0x0F<<1)|0x100>, |
| 264 | |
| 265 | // Gouraud-shaded (CF_GOURAUD) |
| 266 | gpuPixelSpanFn<(0x00<<1)|0x80>, gpuPixelSpanFn<(0x01<<1)|0x80>, gpuPixelSpanFn<(0x02<<1)|0x80>, gpuPixelSpanFn<(0x03<<1)|0x80>, |
| 267 | PixelSpanNULL, gpuPixelSpanFn<(0x05<<1)|0x80>, PixelSpanNULL, gpuPixelSpanFn<(0x07<<1)|0x80>, |
| 268 | PixelSpanNULL, gpuPixelSpanFn<(0x09<<1)|0x80>, PixelSpanNULL, gpuPixelSpanFn<(0x0B<<1)|0x80>, |
| 269 | PixelSpanNULL, gpuPixelSpanFn<(0x0D<<1)|0x80>, PixelSpanNULL, gpuPixelSpanFn<(0x0F<<1)|0x80>, |
| 270 | |
| 271 | // Gouraud-shaded (CF_GOURAUD) + PixelMSB (CF_MASKSET) |
| 272 | gpuPixelSpanFn<(0x00<<1)|0x180>, gpuPixelSpanFn<(0x01<<1)|0x180>, gpuPixelSpanFn<(0x02<<1)|0x180>, gpuPixelSpanFn<(0x03<<1)|0x180>, |
| 273 | PixelSpanNULL, gpuPixelSpanFn<(0x05<<1)|0x180>, PixelSpanNULL, gpuPixelSpanFn<(0x07<<1)|0x180>, |
| 274 | PixelSpanNULL, gpuPixelSpanFn<(0x09<<1)|0x180>, PixelSpanNULL, gpuPixelSpanFn<(0x0B<<1)|0x180>, |
| 275 | PixelSpanNULL, gpuPixelSpanFn<(0x0D<<1)|0x180>, PixelSpanNULL, gpuPixelSpanFn<(0x0F<<1)|0x180> |
| 276 | }; |
| 277 | |
| 278 | /////////////////////////////////////////////////////////////////////////////// |
| 279 | // GPU Tiles innerloops generator |
| 280 | |
| 281 | template<int CF> |
| 282 | static void gpuTileSpanFn(u16 *pDst, u32 count, u16 data) |
| 283 | { |
| 284 | if (!CF_MASKCHECK && !CF_BLEND) { |
| 285 | if (CF_MASKSET) { data = data | 0x8000; } |
| 286 | do { *pDst++ = data; } while (--count); |
| 287 | } else if (CF_MASKCHECK && !CF_BLEND) { |
| 288 | if (CF_MASKSET) { data = data | 0x8000; } |
| 289 | do { if (!(*pDst&0x8000)) { *pDst = data; } pDst++; } while (--count); |
| 290 | } else |
| 291 | { |
| 292 | // Blend func can save an operation if it knows uSrc MSB is |
| 293 | // unset. For untextured prims, this is always true. |
| 294 | const bool skip_uSrc_mask = true; |
| 295 | |
| 296 | uint_fast16_t uSrc, uDst; |
| 297 | do |
| 298 | { |
| 299 | if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; } |
| 300 | if (CF_MASKCHECK) { if (uDst&0x8000) goto endtile; } |
| 301 | |
| 302 | uSrc = data; |
| 303 | |
| 304 | if (CF_BLEND) |
| 305 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 306 | |
| 307 | if (CF_MASKSET) { *pDst = uSrc | 0x8000; } |
| 308 | else { *pDst = uSrc; } |
| 309 | |
| 310 | //senquack - Did not apply "Silent Hill" mask-bit fix to here. |
| 311 | // It is hard to tell from scarce documentation available and |
| 312 | // lack of comments in code, but I believe the tile-span |
| 313 | // functions here should not bother to preserve any source MSB, |
| 314 | // as they are not drawing from a texture. |
| 315 | endtile: |
| 316 | pDst++; |
| 317 | } |
| 318 | while (--count); |
| 319 | } |
| 320 | } |
| 321 | |
| 322 | static void TileNULL(u16 *pDst, u32 count, u16 data) |
| 323 | { |
| 324 | #ifdef ENABLE_GPU_LOG_SUPPORT |
| 325 | fprintf(stdout,"TileNULL()\n"); |
| 326 | #endif |
| 327 | } |
| 328 | |
| 329 | /////////////////////////////////////////////////////////////////////////////// |
| 330 | // Tiles innerloops driver |
| 331 | typedef void (*PT)(u16 *pDst, u32 count, u16 data); |
| 332 | |
| 333 | // Template instantiation helper macros |
| 334 | #define TI(cf) gpuTileSpanFn<(cf)> |
| 335 | #define TN TileNULL |
| 336 | #define TIBLOCK(ub) \ |
| 337 | TI((ub)|0x00), TI((ub)|0x02), TI((ub)|0x04), TI((ub)|0x06), \ |
| 338 | TN, TI((ub)|0x0a), TN, TI((ub)|0x0e), \ |
| 339 | TN, TI((ub)|0x12), TN, TI((ub)|0x16), \ |
| 340 | TN, TI((ub)|0x1a), TN, TI((ub)|0x1e) |
| 341 | |
| 342 | const PT gpuTileSpanDrivers[32] = { |
| 343 | TIBLOCK(0<<8), TIBLOCK(1<<8) |
| 344 | }; |
| 345 | |
| 346 | #undef TI |
| 347 | #undef TN |
| 348 | #undef TIBLOCK |
| 349 | |
| 350 | |
| 351 | /////////////////////////////////////////////////////////////////////////////// |
| 352 | // GPU Sprites innerloops generator |
| 353 | |
| 354 | template<int CF> |
| 355 | static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0) |
| 356 | { |
| 357 | // Blend func can save an operation if it knows uSrc MSB is unset. |
| 358 | // Untextured prims can always skip (source color always comes with MSB=0). |
| 359 | // For textured prims, the generic lighting funcs always return it unset. (bonus!) |
| 360 | const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT; |
| 361 | |
| 362 | uint_fast16_t uSrc, uDst, srcMSB; |
| 363 | bool should_blend; |
| 364 | u32 u0_mask = gpu_unai.TextureWindow[2]; |
| 365 | |
| 366 | u8 r5, g5, b5; |
| 367 | if (CF_LIGHT) { |
| 368 | r5 = gpu_unai.r5; |
| 369 | g5 = gpu_unai.g5; |
| 370 | b5 = gpu_unai.b5; |
| 371 | } |
| 372 | |
| 373 | if (CF_TEXTMODE==3) { |
| 374 | // Texture is accessed byte-wise, so adjust mask if 16bpp |
| 375 | u0_mask <<= 1; |
| 376 | } |
| 377 | |
| 378 | const u16 *CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.CBA; |
| 379 | |
| 380 | do |
| 381 | { |
| 382 | if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; } |
| 383 | if (CF_MASKCHECK) if (uDst&0x8000) { goto endsprite; } |
| 384 | |
| 385 | if (CF_TEXTMODE==1) { // 4bpp (CLUT) |
| 386 | u8 rgb = pTxt[(u0 & u0_mask)>>1]; |
| 387 | uSrc = CBA_[(rgb>>((u0&1)<<2))&0xf]; |
| 388 | } |
| 389 | if (CF_TEXTMODE==2) { // 8bpp (CLUT) |
| 390 | uSrc = CBA_[pTxt[u0 & u0_mask]]; |
| 391 | } |
| 392 | if (CF_TEXTMODE==3) { // 16bpp |
| 393 | uSrc = *(u16*)(&pTxt[u0 & u0_mask]); |
| 394 | } |
| 395 | |
| 396 | if (!uSrc) goto endsprite; |
| 397 | |
| 398 | //senquack - save source MSB, as blending or lighting macros will not |
| 399 | // (Silent Hill gray rectangles mask bit bug) |
| 400 | if (CF_BLEND || CF_LIGHT) srcMSB = uSrc & 0x8000; |
| 401 | |
| 402 | if (CF_LIGHT) |
| 403 | uSrc = gpuLightingTXT(uSrc, r5, g5, b5); |
| 404 | |
| 405 | should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB; |
| 406 | |
| 407 | if (CF_BLEND && should_blend) |
| 408 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 409 | |
| 410 | if (CF_MASKSET) { *pDst = uSrc | 0x8000; } |
| 411 | else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; } |
| 412 | else { *pDst = uSrc; } |
| 413 | |
| 414 | endsprite: |
| 415 | u0 += (CF_TEXTMODE==3) ? 2 : 1; |
| 416 | pDst++; |
| 417 | } |
| 418 | while (--count); |
| 419 | } |
| 420 | |
| 421 | static void SpriteNULL(u16 *pDst, u32 count, u8* pTxt, u32 u0) |
| 422 | { |
| 423 | #ifdef ENABLE_GPU_LOG_SUPPORT |
| 424 | fprintf(stdout,"SpriteNULL()\n"); |
| 425 | #endif |
| 426 | } |
| 427 | |
| 428 | /////////////////////////////////////////////////////////////////////////////// |
| 429 | |
| 430 | /////////////////////////////////////////////////////////////////////////////// |
| 431 | // Sprite innerloops driver |
| 432 | typedef void (*PS)(u16 *pDst, u32 count, u8* pTxt, u32 u0); |
| 433 | |
| 434 | // Template instantiation helper macros |
| 435 | #define TI(cf) gpuSpriteSpanFn<(cf)> |
| 436 | #define TN SpriteNULL |
| 437 | #define TIBLOCK(ub) \ |
| 438 | TN, TN, TN, TN, TN, TN, TN, TN, \ |
| 439 | TN, TN, TN, TN, TN, TN, TN, TN, \ |
| 440 | TN, TN, TN, TN, TN, TN, TN, TN, \ |
| 441 | TN, TN, TN, TN, TN, TN, TN, TN, \ |
| 442 | TI((ub)|0x20), TI((ub)|0x21), TI((ub)|0x22), TI((ub)|0x23), TI((ub)|0x24), TI((ub)|0x25), TI((ub)|0x26), TI((ub)|0x27), \ |
| 443 | TN, TN, TI((ub)|0x2a), TI((ub)|0x2b), TN, TN, TI((ub)|0x2e), TI((ub)|0x2f), \ |
| 444 | TN, TN, TI((ub)|0x32), TI((ub)|0x33), TN, TN, TI((ub)|0x36), TI((ub)|0x37), \ |
| 445 | TN, TN, TI((ub)|0x3a), TI((ub)|0x3b), TN, TN, TI((ub)|0x3e), TI((ub)|0x3f), \ |
| 446 | TI((ub)|0x40), TI((ub)|0x41), TI((ub)|0x42), TI((ub)|0x43), TI((ub)|0x44), TI((ub)|0x45), TI((ub)|0x46), TI((ub)|0x47), \ |
| 447 | TN, TN, TI((ub)|0x4a), TI((ub)|0x4b), TN, TN, TI((ub)|0x4e), TI((ub)|0x4f), \ |
| 448 | TN, TN, TI((ub)|0x52), TI((ub)|0x53), TN, TN, TI((ub)|0x56), TI((ub)|0x57), \ |
| 449 | TN, TN, TI((ub)|0x5a), TI((ub)|0x5b), TN, TN, TI((ub)|0x5e), TI((ub)|0x5f), \ |
| 450 | TI((ub)|0x60), TI((ub)|0x61), TI((ub)|0x62), TI((ub)|0x63), TI((ub)|0x64), TI((ub)|0x65), TI((ub)|0x66), TI((ub)|0x67), \ |
| 451 | TN, TN, TI((ub)|0x6a), TI((ub)|0x6b), TN, TN, TI((ub)|0x6e), TI((ub)|0x6f), \ |
| 452 | TN, TN, TI((ub)|0x72), TI((ub)|0x73), TN, TN, TI((ub)|0x76), TI((ub)|0x77), \ |
| 453 | TN, TN, TI((ub)|0x7a), TI((ub)|0x7b), TN, TN, TI((ub)|0x7e), TI((ub)|0x7f) |
| 454 | |
| 455 | const PS gpuSpriteSpanDrivers[256] = { |
| 456 | TIBLOCK(0<<8), TIBLOCK(1<<8) |
| 457 | }; |
| 458 | |
| 459 | #undef TI |
| 460 | #undef TN |
| 461 | #undef TIBLOCK |
| 462 | |
| 463 | /////////////////////////////////////////////////////////////////////////////// |
| 464 | // GPU Polygon innerloops generator |
| 465 | |
| 466 | //senquack - Newer version with following changes: |
| 467 | // * Adapted to work with new poly routings in gpu_raster_polygon.h |
| 468 | // adapted from DrHell GPU. They are less glitchy and use 22.10 |
| 469 | // fixed-point instead of original UNAI's 16.16. |
| 470 | // * Texture coordinates are no longer packed together into one |
| 471 | // unsigned int. This seems to lose too much accuracy (they each |
| 472 | // end up being only 8.7 fixed-point that way) and pixel-droupouts |
| 473 | // were noticeable both with original code and current DrHell |
| 474 | // adaptations. An example would be the sky in NFS3. Now, they are |
| 475 | // stored in separate ints, using separate masks. |
| 476 | // * Function is no longer INLINE, as it was always called |
| 477 | // through a function pointer. |
| 478 | // * Function now ensures the mask bit of source texture is preserved |
| 479 | // across calls to blending functions (Silent Hill rectangles fix) |
| 480 | // * November 2016: Large refactoring of blending/lighting when |
| 481 | // JohnnyF added dithering. See gpu_inner_quantization.h and |
| 482 | // relevant blend/light headers. |
| 483 | // (see README_senquack.txt) |
| 484 | template<int CF> |
| 485 | static void gpuPolySpanFn(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count) |
| 486 | { |
| 487 | // Blend func can save an operation if it knows uSrc MSB is unset. |
| 488 | // Untextured prims can always skip this (src color MSB is always 0). |
| 489 | // For textured prims, the generic lighting funcs always return it unset. (bonus!) |
| 490 | const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT; |
| 491 | bool should_blend; |
| 492 | |
| 493 | u32 bMsk; if (CF_BLITMASK) bMsk = gpu_unai.blit_mask; |
| 494 | |
| 495 | if (!CF_TEXTMODE) |
| 496 | { |
| 497 | if (!CF_GOURAUD) |
| 498 | { |
| 499 | // UNTEXTURED, NO GOURAUD |
| 500 | const u16 pix15 = gpu_unai.PixelData; |
| 501 | do { |
| 502 | uint_fast16_t uSrc, uDst; |
| 503 | |
| 504 | // NOTE: Don't enable CF_BLITMASK pixel skipping (speed hack) |
| 505 | // on untextured polys. It seems to do more harm than good: see |
| 506 | // gravestone text at end of Medieval intro sequence. -senquack |
| 507 | //if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) { goto endpolynotextnogou; } } |
| 508 | |
| 509 | if (CF_BLEND || CF_MASKCHECK) uDst = *pDst; |
| 510 | if (CF_MASKCHECK) { if (uDst&0x8000) { goto endpolynotextnogou; } } |
| 511 | |
| 512 | uSrc = pix15; |
| 513 | |
| 514 | if (CF_BLEND) |
| 515 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 516 | |
| 517 | if (CF_MASKSET) { *pDst = uSrc | 0x8000; } |
| 518 | else { *pDst = uSrc; } |
| 519 | |
| 520 | endpolynotextnogou: |
| 521 | pDst++; |
| 522 | } while(--count); |
| 523 | } |
| 524 | else |
| 525 | { |
| 526 | // UNTEXTURED, GOURAUD |
| 527 | u32 l_gCol = gpu_unai.gCol; |
| 528 | u32 l_gInc = gpu_unai.gInc; |
| 529 | |
| 530 | do { |
| 531 | uint_fast16_t uDst, uSrc; |
| 532 | |
| 533 | // See note in above loop regarding CF_BLITMASK |
| 534 | //if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolynotextgou; } |
| 535 | |
| 536 | if (CF_BLEND || CF_MASKCHECK) uDst = *pDst; |
| 537 | if (CF_MASKCHECK) { if (uDst&0x8000) goto endpolynotextgou; } |
| 538 | |
| 539 | if (CF_DITHER) { |
| 540 | // GOURAUD, DITHER |
| 541 | |
| 542 | u32 uSrc24 = gpuLightingRGB24(l_gCol); |
| 543 | if (CF_BLEND) |
| 544 | uSrc24 = gpuBlending24<CF_BLENDMODE>(uSrc24, uDst); |
| 545 | uSrc = gpuColorQuantization24<CF_DITHER>(uSrc24, pDst); |
| 546 | } else { |
| 547 | // GOURAUD, NO DITHER |
| 548 | |
| 549 | uSrc = gpuLightingRGB(l_gCol); |
| 550 | |
| 551 | if (CF_BLEND) |
| 552 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 553 | } |
| 554 | |
| 555 | if (CF_MASKSET) { *pDst = uSrc | 0x8000; } |
| 556 | else { *pDst = uSrc; } |
| 557 | |
| 558 | endpolynotextgou: |
| 559 | pDst++; |
| 560 | l_gCol += l_gInc; |
| 561 | } |
| 562 | while (--count); |
| 563 | } |
| 564 | } |
| 565 | else |
| 566 | { |
| 567 | // TEXTURED |
| 568 | |
| 569 | uint_fast16_t uDst, uSrc, srcMSB; |
| 570 | |
| 571 | //senquack - note: original UNAI code had gpu_unai.{u4/v4} packed into |
| 572 | // one 32-bit unsigned int, but this proved to lose too much accuracy |
| 573 | // (pixel drouputs noticeable in NFS3 sky), so now are separate vars. |
| 574 | u32 l_u_msk = gpu_unai.u_msk; u32 l_v_msk = gpu_unai.v_msk; |
| 575 | u32 l_u = gpu_unai.u & l_u_msk; u32 l_v = gpu_unai.v & l_v_msk; |
| 576 | s32 l_u_inc = gpu_unai.u_inc; s32 l_v_inc = gpu_unai.v_inc; |
| 577 | |
| 578 | const u16* TBA_ = gpu_unai.TBA; |
| 579 | const u16* CBA_; if (CF_TEXTMODE!=3) CBA_ = gpu_unai.CBA; |
| 580 | |
| 581 | u8 r5, g5, b5; |
| 582 | u8 r8, g8, b8; |
| 583 | |
| 584 | u32 l_gInc, l_gCol; |
| 585 | |
| 586 | if (CF_LIGHT) { |
| 587 | if (CF_GOURAUD) { |
| 588 | l_gInc = gpu_unai.gInc; |
| 589 | l_gCol = gpu_unai.gCol; |
| 590 | } else { |
| 591 | if (CF_DITHER) { |
| 592 | r8 = gpu_unai.r8; |
| 593 | g8 = gpu_unai.g8; |
| 594 | b8 = gpu_unai.b8; |
| 595 | } else { |
| 596 | r5 = gpu_unai.r5; |
| 597 | g5 = gpu_unai.g5; |
| 598 | b5 = gpu_unai.b5; |
| 599 | } |
| 600 | } |
| 601 | } |
| 602 | |
| 603 | do |
| 604 | { |
| 605 | if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolytext; } |
| 606 | if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; } |
| 607 | if (CF_MASKCHECK) if (uDst&0x8000) { goto endpolytext; } |
| 608 | |
| 609 | //senquack - adapted to work with new 22.10 fixed point routines: |
| 610 | // (UNAI originally used 16.16) |
| 611 | if (CF_TEXTMODE==1) { // 4bpp (CLUT) |
| 612 | u32 tu=(l_u>>10); |
| 613 | u32 tv=(l_v<<1)&(0xff<<11); |
| 614 | u8 rgb=((u8*)TBA_)[tv+(tu>>1)]; |
| 615 | uSrc=CBA_[(rgb>>((tu&1)<<2))&0xf]; |
| 616 | if (!uSrc) goto endpolytext; |
| 617 | } |
| 618 | if (CF_TEXTMODE==2) { // 8bpp (CLUT) |
| 619 | uSrc = CBA_[(((u8*)TBA_)[(l_u>>10)+((l_v<<1)&(0xff<<11))])]; |
| 620 | if (!uSrc) goto endpolytext; |
| 621 | } |
| 622 | if (CF_TEXTMODE==3) { // 16bpp |
| 623 | uSrc = TBA_[(l_u>>10)+((l_v)&(0xff<<10))]; |
| 624 | if (!uSrc) goto endpolytext; |
| 625 | } |
| 626 | |
| 627 | // Save source MSB, as blending or lighting will not (Silent Hill) |
| 628 | if (CF_BLEND || CF_LIGHT) srcMSB = uSrc & 0x8000; |
| 629 | |
| 630 | // When textured, only dither when LIGHT (texture blend) is enabled |
| 631 | // LIGHT && BLEND => dither |
| 632 | // LIGHT && !BLEND => dither |
| 633 | //!LIGHT && BLEND => no dither |
| 634 | //!LIGHT && !BLEND => no dither |
| 635 | |
| 636 | if (CF_DITHER && CF_LIGHT) { |
| 637 | u32 uSrc24; |
| 638 | if ( CF_GOURAUD) |
| 639 | uSrc24 = gpuLightingTXT24Gouraud(uSrc, l_gCol); |
| 640 | if (!CF_GOURAUD) |
| 641 | uSrc24 = gpuLightingTXT24(uSrc, r8, g8, b8); |
| 642 | |
| 643 | if (CF_BLEND && srcMSB) |
| 644 | uSrc24 = gpuBlending24<CF_BLENDMODE>(uSrc24, uDst); |
| 645 | |
| 646 | uSrc = gpuColorQuantization24<CF_DITHER>(uSrc24, pDst); |
| 647 | } else |
| 648 | { |
| 649 | if (CF_LIGHT) { |
| 650 | if ( CF_GOURAUD) |
| 651 | uSrc = gpuLightingTXTGouraud(uSrc, l_gCol); |
| 652 | if (!CF_GOURAUD) |
| 653 | uSrc = gpuLightingTXT(uSrc, r5, g5, b5); |
| 654 | } |
| 655 | |
| 656 | should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB; |
| 657 | if (CF_BLEND && should_blend) |
| 658 | uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst); |
| 659 | } |
| 660 | |
| 661 | if (CF_MASKSET) { *pDst = uSrc | 0x8000; } |
| 662 | else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; } |
| 663 | else { *pDst = uSrc; } |
| 664 | endpolytext: |
| 665 | pDst++; |
| 666 | l_u = (l_u + l_u_inc) & l_u_msk; |
| 667 | l_v = (l_v + l_v_inc) & l_v_msk; |
| 668 | if (CF_LIGHT && CF_GOURAUD) l_gCol += l_gInc; |
| 669 | } |
| 670 | while (--count); |
| 671 | } |
| 672 | } |
| 673 | |
| 674 | static void PolyNULL(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count) |
| 675 | { |
| 676 | #ifdef ENABLE_GPU_LOG_SUPPORT |
| 677 | fprintf(stdout,"PolyNULL()\n"); |
| 678 | #endif |
| 679 | } |
| 680 | |
| 681 | /////////////////////////////////////////////////////////////////////////////// |
| 682 | // Polygon innerloops driver |
| 683 | typedef void (*PP)(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count); |
| 684 | |
| 685 | // Template instantiation helper macros |
| 686 | #define TI(cf) gpuPolySpanFn<(cf)> |
| 687 | #define TN PolyNULL |
| 688 | #define TIBLOCK(ub) \ |
| 689 | TI((ub)|0x00), TI((ub)|0x01), TI((ub)|0x02), TI((ub)|0x03), TI((ub)|0x04), TI((ub)|0x05), TI((ub)|0x06), TI((ub)|0x07), \ |
| 690 | TN, TN, TI((ub)|0x0a), TI((ub)|0x0b), TN, TN, TI((ub)|0x0e), TI((ub)|0x0f), \ |
| 691 | TN, TN, TI((ub)|0x12), TI((ub)|0x13), TN, TN, TI((ub)|0x16), TI((ub)|0x17), \ |
| 692 | TN, TN, TI((ub)|0x1a), TI((ub)|0x1b), TN, TN, TI((ub)|0x1e), TI((ub)|0x1f), \ |
| 693 | TI((ub)|0x20), TI((ub)|0x21), TI((ub)|0x22), TI((ub)|0x23), TI((ub)|0x24), TI((ub)|0x25), TI((ub)|0x26), TI((ub)|0x27), \ |
| 694 | TN, TN, TI((ub)|0x2a), TI((ub)|0x2b), TN, TN, TI((ub)|0x2e), TI((ub)|0x2f), \ |
| 695 | TN, TN, TI((ub)|0x32), TI((ub)|0x33), TN, TN, TI((ub)|0x36), TI((ub)|0x37), \ |
| 696 | TN, TN, TI((ub)|0x3a), TI((ub)|0x3b), TN, TN, TI((ub)|0x3e), TI((ub)|0x3f), \ |
| 697 | TI((ub)|0x40), TI((ub)|0x41), TI((ub)|0x42), TI((ub)|0x43), TI((ub)|0x44), TI((ub)|0x45), TI((ub)|0x46), TI((ub)|0x47), \ |
| 698 | TN, TN, TI((ub)|0x4a), TI((ub)|0x4b), TN, TN, TI((ub)|0x4e), TI((ub)|0x4f), \ |
| 699 | TN, TN, TI((ub)|0x52), TI((ub)|0x53), TN, TN, TI((ub)|0x56), TI((ub)|0x57), \ |
| 700 | TN, TN, TI((ub)|0x5a), TI((ub)|0x5b), TN, TN, TI((ub)|0x5e), TI((ub)|0x5f), \ |
| 701 | TI((ub)|0x60), TI((ub)|0x61), TI((ub)|0x62), TI((ub)|0x63), TI((ub)|0x64), TI((ub)|0x65), TI((ub)|0x66), TI((ub)|0x67), \ |
| 702 | TN, TN, TI((ub)|0x6a), TI((ub)|0x6b), TN, TN, TI((ub)|0x6e), TI((ub)|0x6f), \ |
| 703 | TN, TN, TI((ub)|0x72), TI((ub)|0x73), TN, TN, TI((ub)|0x76), TI((ub)|0x77), \ |
| 704 | TN, TN, TI((ub)|0x7a), TI((ub)|0x7b), TN, TN, TI((ub)|0x7e), TI((ub)|0x7f), \ |
| 705 | TN, TI((ub)|0x81), TN, TI((ub)|0x83), TN, TI((ub)|0x85), TN, TI((ub)|0x87), \ |
| 706 | TN, TN, TN, TI((ub)|0x8b), TN, TN, TN, TI((ub)|0x8f), \ |
| 707 | TN, TN, TN, TI((ub)|0x93), TN, TN, TN, TI((ub)|0x97), \ |
| 708 | TN, TN, TN, TI((ub)|0x9b), TN, TN, TN, TI((ub)|0x9f), \ |
| 709 | TN, TI((ub)|0xa1), TN, TI((ub)|0xa3), TN, TI((ub)|0xa5), TN, TI((ub)|0xa7), \ |
| 710 | TN, TN, TN, TI((ub)|0xab), TN, TN, TN, TI((ub)|0xaf), \ |
| 711 | TN, TN, TN, TI((ub)|0xb3), TN, TN, TN, TI((ub)|0xb7), \ |
| 712 | TN, TN, TN, TI((ub)|0xbb), TN, TN, TN, TI((ub)|0xbf), \ |
| 713 | TN, TI((ub)|0xc1), TN, TI((ub)|0xc3), TN, TI((ub)|0xc5), TN, TI((ub)|0xc7), \ |
| 714 | TN, TN, TN, TI((ub)|0xcb), TN, TN, TN, TI((ub)|0xcf), \ |
| 715 | TN, TN, TN, TI((ub)|0xd3), TN, TN, TN, TI((ub)|0xd7), \ |
| 716 | TN, TN, TN, TI((ub)|0xdb), TN, TN, TN, TI((ub)|0xdf), \ |
| 717 | TN, TI((ub)|0xe1), TN, TI((ub)|0xe3), TN, TI((ub)|0xe5), TN, TI((ub)|0xe7), \ |
| 718 | TN, TN, TN, TI((ub)|0xeb), TN, TN, TN, TI((ub)|0xef), \ |
| 719 | TN, TN, TN, TI((ub)|0xf3), TN, TN, TN, TI((ub)|0xf7), \ |
| 720 | TN, TN, TN, TI((ub)|0xfb), TN, TN, TN, TI((ub)|0xff) |
| 721 | |
| 722 | const PP gpuPolySpanDrivers[2048] = { |
| 723 | TIBLOCK(0<<8), TIBLOCK(1<<8), TIBLOCK(2<<8), TIBLOCK(3<<8), |
| 724 | TIBLOCK(4<<8), TIBLOCK(5<<8), TIBLOCK(6<<8), TIBLOCK(7<<8) |
| 725 | }; |
| 726 | |
| 727 | #undef TI |
| 728 | #undef TN |
| 729 | #undef TIBLOCK |