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