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