1 #include "../copyright"
2
3 #include "snes9x.h"
4
5 #include "memmap.h"
6 #include "ppu.h"
7 #include "display.h"
8 #include "gfx.h"
9 #include "tile.h"
10
11 extern uint32_t HeadMask [4];
12 extern uint32_t TailMask [5];
13
ConvertTile(uint8_t * pCache,uint32_t TileAddr)14 static uint8_t ConvertTile(uint8_t* pCache, uint32_t TileAddr)
15 {
16 uint8_t* tp = &Memory.VRAM[TileAddr];
17 uint32_t* p = (uint32_t*) pCache;
18 uint32_t non_zero = 0;
19 uint8_t line;
20 uint32_t p1;
21 uint32_t p2;
22 uint8_t pix;
23
24 switch (BG.BitShift)
25 {
26 case 8:
27 for (line = 8; line != 0; line--, tp += 2)
28 {
29 p1 = p2 = 0;
30 if((pix = tp[0]))
31 {
32 p1 |= odd_high[0][pix >> 4];
33 p2 |= odd_low[0][pix & 0xf];
34 }
35 if((pix = tp[1]))
36 {
37 p1 |= even_high[0][pix >> 4];
38 p2 |= even_low[0][pix & 0xf];
39 }
40 if((pix = tp[16]))
41 {
42 p1 |= odd_high[1][pix >> 4];
43 p2 |= odd_low[1][pix & 0xf];
44 }
45 if((pix = tp[17]))
46 {
47 p1 |= even_high[1][pix >> 4];
48 p2 |= even_low[1][pix & 0xf];
49 }
50 if((pix = tp[32]))
51 {
52 p1 |= odd_high[2][pix >> 4];
53 p2 |= odd_low[2][pix & 0xf];
54 }
55 if((pix = tp[33]))
56 {
57 p1 |= even_high[2][pix >> 4];
58 p2 |= even_low[2][pix & 0xf];
59 }
60 if((pix = tp[48]))
61 {
62 p1 |= odd_high[3][pix >> 4];
63 p2 |= odd_low[3][pix & 0xf];
64 }
65 if((pix = tp[49]))
66 {
67 p1 |= even_high[3][pix >> 4];
68 p2 |= even_low[3][pix & 0xf];
69 }
70 *p++ = p1;
71 *p++ = p2;
72 non_zero |= p1 | p2;
73 }
74 break;
75 case 4:
76 for (line = 8; line != 0; line--, tp += 2)
77 {
78 p1 = p2 = 0;
79 if((pix = tp[0]))
80 {
81 p1 |= odd_high[0][pix >> 4];
82 p2 |= odd_low[0][pix & 0xf];
83 }
84 if((pix = tp[1]))
85 {
86 p1 |= even_high[0][pix >> 4];
87 p2 |= even_low[0][pix & 0xf];
88 }
89 if((pix = tp[16]))
90 {
91 p1 |= odd_high[1][pix >> 4];
92 p2 |= odd_low[1][pix & 0xf];
93 }
94 if((pix = tp[17]))
95 {
96 p1 |= even_high[1][pix >> 4];
97 p2 |= even_low[1][pix & 0xf];
98 }
99 *p++ = p1;
100 *p++ = p2;
101 non_zero |= p1 | p2;
102 }
103 break;
104 case 2:
105 for (line = 8; line != 0; line--, tp += 2)
106 {
107 p1 = p2 = 0;
108 if((pix = tp[0]))
109 {
110 p1 |= odd_high[0][pix >> 4];
111 p2 |= odd_low[0][pix & 0xf];
112 }
113 if((pix = tp[1]))
114 {
115 p1 |= even_high[0][pix >> 4];
116 p2 |= even_low[0][pix & 0xf];
117 }
118 *p++ = p1;
119 *p++ = p2;
120 non_zero |= p1 | p2;
121 }
122 break;
123 }
124 return non_zero ? 1 : BLANK_TILE;
125 }
126
127 #define PLOT_PIXEL(screen, pixel) (pixel)
128
WRITE_4PIXELS16(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)129 static INLINE void WRITE_4PIXELS16(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
130 {
131 #if defined(__MIPSEL) && defined(__GNUC__) && !defined(NO_ASM)
132 uint16_t *Screen = (uint16_t *) GFX.S + Offset;
133 uint8_t *Depth = GFX.DB + Offset;
134 uint8_t Pixel_A, Pixel_B, Pixel_C, Pixel_D;
135 uint8_t Depth_A, Depth_B, Depth_C, Depth_D;
136 uint8_t Cond;
137 uint32_t Temp;
138 __asm__ __volatile__ (
139 ".set noreorder \n"
140 " lbu %[In8A], 0(%[In8]) \n"
141 " lbu %[In8B], 1(%[In8]) \n"
142 " lbu %[In8C], 2(%[In8]) \n"
143 " lbu %[In8D], 3(%[In8]) \n"
144 " lbu %[ZA], 0(%[Z]) \n"
145 " lbu %[ZB], 1(%[Z]) \n"
146 " lbu %[ZC], 2(%[Z]) \n"
147 " lbu %[ZD], 3(%[Z]) \n"
148 /* If In8A is non-zero (opaque) and ZCompare > ZA, write the pixel to
149 * the screen from the palette. */
150 " sltiu %[Temp], %[In8A], 1 \n"
151 " sltu %[Cond], %[ZCompare], %[ZA] \n"
152 " or %[Cond], %[Cond], %[Temp] \n"
153 /* Otherwise skip to the next pixel, B. */
154 " bne %[Cond], $0, 2f \n"
155 /* Load the address of the palette entry (16-bit) corresponding to
156 * this pixel (partially in the delay slot). */
157 " sll %[In8A], %[In8A], 1 \n"
158 " addu %[Temp], %[Palette], %[In8A] \n"
159 /* Load the palette entry. While that's being done, store the new
160 * depth for this pixel. Then store to the screen. */
161 " lhu %[Temp], 0(%[Temp]) \n"
162 " sb %[ZSet], 0(%[Z]) \n"
163 " sh %[Temp], 0(%[Out16]) \n"
164 /* Now do the same for pixel B. */
165 "2: sltiu %[Temp], %[In8B], 1 \n"
166 " sltu %[Cond], %[ZCompare], %[ZB] \n"
167 " or %[Cond], %[Cond], %[Temp] \n"
168 " bne %[Cond], $0, 3f \n"
169 " sll %[In8B], %[In8B], 1 \n"
170 " addu %[Temp], %[Palette], %[In8B] \n"
171 " lhu %[Temp], 0(%[Temp]) \n"
172 " sb %[ZSet], 1(%[Z]) \n"
173 " sh %[Temp], 2(%[Out16]) \n"
174 /* Now do the same for pixel C. */
175 "3: sltiu %[Temp], %[In8C], 1 \n"
176 " sltu %[Cond], %[ZCompare], %[ZC] \n"
177 " or %[Cond], %[Cond], %[Temp] \n"
178 " bne %[Cond], $0, 4f \n"
179 " sll %[In8C], %[In8C], 1 \n"
180 " addu %[Temp], %[Palette], %[In8C] \n"
181 " lhu %[Temp], 0(%[Temp]) \n"
182 " sb %[ZSet], 2(%[Z]) \n"
183 " sh %[Temp], 4(%[Out16]) \n"
184 /* Now do the same for pixel D. */
185 "4: sltiu %[Temp], %[In8D], 1 \n"
186 " sltu %[Cond], %[ZCompare], %[ZD] \n"
187 " or %[Cond], %[Cond], %[Temp] \n"
188 " bne %[Cond], $0, 5f \n"
189 " sll %[In8D], %[In8D], 1 \n"
190 " addu %[Temp], %[Palette], %[In8D] \n"
191 " lhu %[Temp], 0(%[Temp]) \n"
192 " sb %[ZSet], 3(%[Z]) \n"
193 " sh %[Temp], 6(%[Out16]) \n"
194 "5: \n"
195 ".set reorder \n"
196 : /* output */ [In8A] "=&r" (Pixel_A), [In8B] "=&r" (Pixel_B), [In8C] "=&r" (Pixel_C), [In8D] "=&r" (Pixel_D), [ZA] "=&r" (Depth_A), [ZB] "=&r" (Depth_B), [ZC] "=&r" (Depth_C), [ZD] "=&r" (Depth_D), [Cond] "=&r" (Cond), [Temp] "=&r" (Temp)
197 : /* input */ [Out16] "r" (Screen), [Z] "r" (Depth), [In8] "r" (Pixels), [Palette] "r" (ScreenColors), [ZCompare] "r" (GFX.Z1), [ZSet] "r" (GFX.Z2)
198 : /* clobber */ "memory"
199 );
200 #else
201 uint8_t Pixel, N;
202 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
203 uint8_t* Depth = GFX.DB + Offset;
204
205 for (N = 0; N < 4; N++)
206 {
207 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
208 {
209 Screen [N] = ScreenColors [Pixel];
210 Depth [N] = GFX.Z2;
211 }
212 }
213 #endif
214 }
215
WRITE_4PIXELS16_FLIPPED(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)216 static INLINE void WRITE_4PIXELS16_FLIPPED(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
217 {
218 #if defined(__MIPSEL) && defined(__GNUC__) && !defined(NO_ASM)
219 uint16_t *Screen = (uint16_t *) GFX.S + Offset;
220 uint8_t *Depth = GFX.DB + Offset;
221 uint8_t Pixel_A, Pixel_B, Pixel_C, Pixel_D;
222 uint8_t Depth_A, Depth_B, Depth_C, Depth_D;
223 uint8_t Cond;
224 uint32_t Temp;
225 __asm__ __volatile__ (
226 ".set noreorder \n"
227 " lbu %[In8A], 3(%[In8]) \n"
228 " lbu %[In8B], 2(%[In8]) \n"
229 " lbu %[In8C], 1(%[In8]) \n"
230 " lbu %[In8D], 0(%[In8]) \n"
231 " lbu %[ZA], 0(%[Z]) \n"
232 " lbu %[ZB], 1(%[Z]) \n"
233 " lbu %[ZC], 2(%[Z]) \n"
234 " lbu %[ZD], 3(%[Z]) \n"
235 /* If In8A is non-zero (opaque) and ZCompare > ZA, write the pixel to
236 * the screen from the palette. */
237 " sltiu %[Temp], %[In8A], 1 \n"
238 " sltu %[Cond], %[ZCompare], %[ZA] \n"
239 " or %[Cond], %[Cond], %[Temp] \n"
240 /* Otherwise skip to the next pixel, B. */
241 " bne %[Cond], $0, 2f \n"
242 /* Load the address of the palette entry (16-bit) corresponding to
243 * this pixel (partially in the delay slot). */
244 " sll %[In8A], %[In8A], 1 \n"
245 " addu %[Temp], %[Palette], %[In8A] \n"
246 /* Load the palette entry. While that's being done, store the new
247 * depth for this pixel. Then store to the screen. */
248 " lhu %[Temp], 0(%[Temp]) \n"
249 " sb %[ZSet], 0(%[Z]) \n"
250 " sh %[Temp], 0(%[Out16]) \n"
251 /* Now do the same for pixel B. */
252 "2: sltiu %[Temp], %[In8B], 1 \n"
253 " sltu %[Cond], %[ZCompare], %[ZB] \n"
254 " or %[Cond], %[Cond], %[Temp] \n"
255 " bne %[Cond], $0, 3f \n"
256 " sll %[In8B], %[In8B], 1 \n"
257 " addu %[Temp], %[Palette], %[In8B] \n"
258 " lhu %[Temp], 0(%[Temp]) \n"
259 " sb %[ZSet], 1(%[Z]) \n"
260 " sh %[Temp], 2(%[Out16]) \n"
261 /* Now do the same for pixel C. */
262 "3: sltiu %[Temp], %[In8C], 1 \n"
263 " sltu %[Cond], %[ZCompare], %[ZC] \n"
264 " or %[Cond], %[Cond], %[Temp] \n"
265 " bne %[Cond], $0, 4f \n"
266 " sll %[In8C], %[In8C], 1 \n"
267 " addu %[Temp], %[Palette], %[In8C] \n"
268 " lhu %[Temp], 0(%[Temp]) \n"
269 " sb %[ZSet], 2(%[Z]) \n"
270 " sh %[Temp], 4(%[Out16]) \n"
271 /* Now do the same for pixel D. */
272 "4: sltiu %[Temp], %[In8D], 1 \n"
273 " sltu %[Cond], %[ZCompare], %[ZD] \n"
274 " or %[Cond], %[Cond], %[Temp] \n"
275 " bne %[Cond], $0, 5f \n"
276 " sll %[In8D], %[In8D], 1 \n"
277 " addu %[Temp], %[Palette], %[In8D] \n"
278 " lhu %[Temp], 0(%[Temp]) \n"
279 " sb %[ZSet], 3(%[Z]) \n"
280 " sh %[Temp], 6(%[Out16]) \n"
281 "5: \n"
282 ".set reorder \n"
283 : /* output */ [In8A] "=&r" (Pixel_A), [In8B] "=&r" (Pixel_B), [In8C] "=&r" (Pixel_C), [In8D] "=&r" (Pixel_D), [ZA] "=&r" (Depth_A), [ZB] "=&r" (Depth_B), [ZC] "=&r" (Depth_C), [ZD] "=&r" (Depth_D), [Cond] "=&r" (Cond), [Temp] "=&r" (Temp)
284 : /* input */ [Out16] "r" (Screen), [Z] "r" (Depth), [In8] "r" (Pixels), [Palette] "r" (ScreenColors), [ZCompare] "r" (GFX.Z1), [ZSet] "r" (GFX.Z2)
285 : /* clobber */ "memory"
286 );
287 #else
288 uint8_t Pixel, N;
289 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
290 uint8_t* Depth = GFX.DB + Offset;
291
292 for (N = 0; N < 4; N++)
293 {
294 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
295 {
296 Screen [N] = ScreenColors [Pixel];
297 Depth [N] = GFX.Z2;
298 }
299 }
300 #endif
301 }
302
WRITE_4PIXELS16_HALFWIDTH(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)303 static void WRITE_4PIXELS16_HALFWIDTH(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
304 {
305 uint8_t Pixel, N;
306 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
307 uint8_t* Depth = GFX.DB + Offset;
308
309 for (N = 0; N < 4; N += 2)
310 {
311 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
312 {
313 Screen [N >> 1] = ScreenColors [Pixel];
314 Depth [N >> 1] = GFX.Z2;
315 }
316 }
317 }
318
WRITE_4PIXELS16_FLIPPED_HALFWIDTH(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)319 static void WRITE_4PIXELS16_FLIPPED_HALFWIDTH(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
320 {
321 uint8_t Pixel, N;
322 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
323 uint8_t* Depth = GFX.DB + Offset;
324
325 for (N = 0; N < 4; N += 2)
326 {
327 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[2 - N]))
328 {
329 Screen [N >> 1] = ScreenColors [Pixel];
330 Depth [N >> 1] = GFX.Z2;
331 }
332 }
333 }
334
WRITE_4PIXELS16x2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)335 static void WRITE_4PIXELS16x2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
336 {
337 uint8_t Pixel, N;
338 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
339 uint8_t* Depth = GFX.DB + Offset;
340
341 for (N = 0; N < 4; N++)
342 {
343 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[N]))
344 {
345 Screen [N * 2] = Screen [N * 2 + 1] = ScreenColors [Pixel];
346 Depth [N * 2] = Depth [N * 2 + 1] = GFX.Z2;
347 }
348 }
349 }
350
WRITE_4PIXELS16_FLIPPEDx2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)351 static void WRITE_4PIXELS16_FLIPPEDx2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
352 {
353 uint8_t Pixel, N;
354 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
355 uint8_t* Depth = GFX.DB + Offset;
356
357 for (N = 0; N < 4; N++)
358 {
359 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[3 - N]))
360 {
361 Screen [N * 2] = Screen [N * 2 + 1] = ScreenColors [Pixel];
362 Depth [N * 2] = Depth [N * 2 + 1] = GFX.Z2;
363 }
364 }
365 }
366
WRITE_4PIXELS16x2x2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)367 static void WRITE_4PIXELS16x2x2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
368 {
369 uint8_t Pixel, N;
370 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
371 uint8_t* Depth = GFX.DB + Offset;
372
373 for (N = 0; N < 4; N++)
374 {
375 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[N]))
376 {
377 Screen [N * 2] = Screen [N * 2 + 1] = Screen [(GFX.RealPitch >> 1) + N * 2] = Screen [(GFX.RealPitch >> 1) + N * 2 + 1] = ScreenColors [Pixel];
378 Depth [N * 2] = Depth [N * 2 + 1] = Depth [(GFX.RealPitch >> 1) + N * 2] = Depth [(GFX.RealPitch >> 1) + N * 2 + 1] = GFX.Z2;
379 }
380 }
381 }
382
WRITE_4PIXELS16_FLIPPEDx2x2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)383 static void WRITE_4PIXELS16_FLIPPEDx2x2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
384 {
385 uint8_t Pixel, N;
386 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
387 uint8_t* Depth = GFX.DB + Offset;
388
389 for (N = 0; N < 4; N++)
390 {
391 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[3 - N]))
392 {
393 Screen [N * 2] = Screen [N * 2 + 1] = Screen [(GFX.RealPitch >> 1) + N * 2] = Screen [(GFX.RealPitch >> 1) + N * 2 + 1] = ScreenColors [Pixel];
394 Depth [N * 2] = Depth [N * 2 + 1] = Depth [(GFX.RealPitch >> 1) + N * 2] = Depth [(GFX.RealPitch >> 1) + N * 2 + 1] = GFX.Z2;
395 }
396 }
397 }
398
DrawTile16(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)399 void DrawTile16(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
400 {
401 uint8_t* bp;
402 TILE_PREAMBLE_VARS();
403 TILE_PREAMBLE_CODE();
404 RENDER_TILE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4);
405 }
406
DrawClippedTile16(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)407 void DrawClippedTile16(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
408 {
409 uint8_t* bp;
410 TILE_PREAMBLE_VARS();
411 TILE_CLIP_PREAMBLE_VARS();
412 RENDER_CLIPPED_TILE_VARS();
413 TILE_PREAMBLE_CODE();
414 TILE_CLIP_PREAMBLE_CODE();
415 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4);
416 }
417
DrawTile16HalfWidth(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)418 void DrawTile16HalfWidth(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
419 {
420 uint8_t* bp;
421 TILE_PREAMBLE_VARS();
422 TILE_PREAMBLE_CODE();
423 RENDER_TILE(WRITE_4PIXELS16_HALFWIDTH, WRITE_4PIXELS16_FLIPPED_HALFWIDTH, 2);
424 }
425
DrawClippedTile16HalfWidth(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)426 void DrawClippedTile16HalfWidth(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
427 {
428 uint8_t* bp;
429 TILE_PREAMBLE_VARS();
430 TILE_CLIP_PREAMBLE_VARS();
431 RENDER_CLIPPED_TILE_VARS();
432 TILE_PREAMBLE_CODE();
433 TILE_CLIP_PREAMBLE_CODE();
434 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_HALFWIDTH, WRITE_4PIXELS16_FLIPPED_HALFWIDTH, 2);
435 }
436
DrawTile16x2(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)437 void DrawTile16x2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
438 {
439 uint8_t* bp;
440 TILE_PREAMBLE_VARS();
441 TILE_PREAMBLE_CODE();
442 RENDER_TILE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8);
443 }
444
DrawClippedTile16x2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)445 void DrawClippedTile16x2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
446 {
447 uint8_t* bp;
448 TILE_PREAMBLE_VARS();
449 TILE_CLIP_PREAMBLE_VARS();
450 RENDER_CLIPPED_TILE_VARS();
451 TILE_PREAMBLE_CODE();
452 TILE_CLIP_PREAMBLE_CODE();
453 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8);
454 }
455
DrawTile16x2x2(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)456 void DrawTile16x2x2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
457 {
458 uint8_t* bp;
459 TILE_PREAMBLE_VARS();
460 TILE_PREAMBLE_CODE();
461 RENDER_TILE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8);
462 }
463
DrawClippedTile16x2x2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)464 void DrawClippedTile16x2x2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
465 {
466 uint8_t* bp;
467 TILE_PREAMBLE_VARS();
468 TILE_CLIP_PREAMBLE_VARS();
469 RENDER_CLIPPED_TILE_VARS();
470 TILE_PREAMBLE_CODE();
471 TILE_CLIP_PREAMBLE_CODE();
472 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8);
473 }
474
DrawLargePixel16(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Pixels,uint32_t StartLine,uint32_t LineCount)475 void DrawLargePixel16(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
476 {
477 uint16_t pixel;
478 uint16_t *sp;
479 uint8_t *Depth;
480 TILE_PREAMBLE_VARS();
481 TILE_PREAMBLE_CODE();
482 sp = (uint16_t*) GFX.S + Offset;
483 Depth = GFX.DB + Offset;
484 RENDER_TILE_LARGE(ScreenColors [pixel], PLOT_PIXEL);
485 }
486
DrawLargePixel16HalfWidth(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Pixels,uint32_t StartLine,uint32_t LineCount)487 void DrawLargePixel16HalfWidth(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
488 {
489 uint16_t pixel;
490 uint16_t *sp;
491 uint8_t *Depth;
492 TILE_PREAMBLE_VARS();
493 TILE_PREAMBLE_CODE();
494 sp = (uint16_t*) GFX.S + Offset;
495 Depth = GFX.DB + Offset;
496 RENDER_TILE_LARGE_HALFWIDTH(ScreenColors [pixel], PLOT_PIXEL);
497 }
498
WRITE_4PIXELS16_ADD(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)499 static void WRITE_4PIXELS16_ADD(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
500 {
501 uint8_t Pixel, N;
502 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
503 uint8_t* Depth = GFX.ZBuffer + Offset;
504 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
505
506 for (N = 0; N < 4; N++)
507 {
508 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
509 {
510 switch (SubDepth [N])
511 {
512 case 0:
513 Screen [N] = ScreenColors [Pixel];
514 break;
515 case 1:
516 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
517 break;
518 default:
519 Screen [N] = COLOR_ADD(ScreenColors [Pixel], Screen [GFX.Delta + N]);
520 break;
521 }
522 Depth [N] = GFX.Z2;
523 }
524 }
525 }
526
WRITE_4PIXELS16_FLIPPED_ADD(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)527 static void WRITE_4PIXELS16_FLIPPED_ADD(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
528 {
529 uint8_t Pixel, N;
530 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
531 uint8_t* Depth = GFX.ZBuffer + Offset;
532 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
533
534 for (N = 0; N < 4; N++)
535 {
536 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
537 {
538 switch (SubDepth [N])
539 {
540 case 0:
541 Screen [N] = ScreenColors [Pixel];
542 break;
543 case 1:
544 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
545 break;
546 default:
547 Screen [N] = COLOR_ADD(ScreenColors [Pixel], Screen [GFX.Delta + N]);
548 break;
549 }
550 Depth [N] = GFX.Z2;
551 }
552 }
553 }
554
WRITE_4PIXELS16_ADD1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)555 static void WRITE_4PIXELS16_ADD1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
556 {
557 uint8_t Pixel, N;
558 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
559 uint8_t* Depth = GFX.ZBuffer + Offset;
560 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
561
562 for (N = 0; N < 4; N++)
563 {
564 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
565 {
566 switch (SubDepth [N])
567 {
568 case 0:
569 Screen [N] = ScreenColors [Pixel];
570 break;
571 case 1:
572 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
573 break;
574 default:
575 Screen [N] = (uint16_t)(COLOR_ADD1_2(ScreenColors [Pixel], Screen [GFX.Delta + N]));
576 break;
577 }
578 Depth [N] = GFX.Z2;
579 }
580 }
581 }
582
WRITE_4PIXELS16_FLIPPED_ADD1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)583 static void WRITE_4PIXELS16_FLIPPED_ADD1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
584 {
585 uint8_t Pixel, N;
586 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
587 uint8_t* Depth = GFX.ZBuffer + Offset;
588 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
589
590 for (N = 0; N < 4; N++)
591 {
592 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
593 {
594 switch (SubDepth [N])
595 {
596 case 0:
597 Screen [N] = ScreenColors [Pixel];
598 break;
599 case 1:
600 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
601 break;
602 default:
603 Screen [N] = (uint16_t)(COLOR_ADD1_2(ScreenColors [Pixel], Screen [GFX.Delta + N]));
604 break;
605 }
606 Depth [N] = GFX.Z2;
607 }
608 }
609 }
610
WRITE_4PIXELS16_SUB(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)611 static void WRITE_4PIXELS16_SUB(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
612 {
613 uint8_t Pixel, N;
614 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
615 uint8_t* Depth = GFX.ZBuffer + Offset;
616 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
617
618 for (N = 0; N < 4; N++)
619 {
620 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
621 {
622 switch (SubDepth [N])
623 {
624 case 0:
625 Screen [N] = ScreenColors [Pixel];
626 break;
627 case 1:
628 Screen [N] = (uint16_t) COLOR_SUB(ScreenColors [Pixel], GFX.FixedColour);
629 break;
630 default:
631 Screen [N] = (uint16_t) COLOR_SUB(ScreenColors [Pixel], Screen [GFX.Delta + N]);
632 break;
633 }
634 Depth [N] = GFX.Z2;
635 }
636 }
637 }
638
WRITE_4PIXELS16_FLIPPED_SUB(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)639 static void WRITE_4PIXELS16_FLIPPED_SUB(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
640 {
641 uint8_t Pixel, N;
642 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
643 uint8_t* Depth = GFX.ZBuffer + Offset;
644 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
645
646 for (N = 0; N < 4; N++)
647 {
648 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
649 {
650 switch (SubDepth [N])
651 {
652 case 0:
653 Screen [N] = ScreenColors [Pixel];
654 break;
655 case 1:
656 Screen [N] = (uint16_t) COLOR_SUB(ScreenColors [Pixel], GFX.FixedColour);
657 break;
658 default:
659 Screen [N] = (uint16_t) COLOR_SUB(ScreenColors [Pixel], Screen [GFX.Delta + N]);
660 break;
661 }
662 Depth [N] = GFX.Z2;
663 }
664 }
665 }
666
WRITE_4PIXELS16_SUB1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)667 static void WRITE_4PIXELS16_SUB1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
668 {
669 uint8_t Pixel, N;
670 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
671 uint8_t* Depth = GFX.ZBuffer + Offset;
672 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
673
674 for (N = 0; N < 4; N++)
675 {
676 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
677 {
678 switch (SubDepth [N])
679 {
680 case 0:
681 Screen [N] = ScreenColors [Pixel];
682 break;
683 case 1:
684 Screen [N] = (uint16_t) COLOR_SUB(ScreenColors [Pixel], GFX.FixedColour);
685 break;
686 default:
687 Screen [N] = (uint16_t) COLOR_SUB1_2(ScreenColors [Pixel], Screen [GFX.Delta + N]);
688 break;
689 }
690 Depth [N] = GFX.Z2;
691 }
692 }
693 }
694
WRITE_4PIXELS16_FLIPPED_SUB1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)695 static void WRITE_4PIXELS16_FLIPPED_SUB1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
696 {
697 uint8_t Pixel, N;
698 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
699 uint8_t* Depth = GFX.ZBuffer + Offset;
700 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
701
702 for (N = 0; N < 4; N++)
703 {
704 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
705 {
706 switch (SubDepth [N])
707 {
708 case 0:
709 Screen [N] = ScreenColors [Pixel];
710 break;
711 case 1:
712 Screen [N] = (uint16_t) COLOR_SUB(ScreenColors [Pixel], GFX.FixedColour);
713 break;
714 default:
715 Screen [N] = (uint16_t) COLOR_SUB1_2(ScreenColors [Pixel], Screen [GFX.Delta + N]);
716 break;
717 }
718 Depth [N] = GFX.Z2;
719 }
720 }
721 }
722
723
DrawTile16Add(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)724 void DrawTile16Add(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
725 {
726 uint8_t* bp;
727 uint8_t Pixel;
728 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
729 uint8_t* Depth = GFX.ZBuffer + Offset;
730 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
731 TILE_PREAMBLE_VARS();
732 TILE_PREAMBLE_CODE();
733
734 switch (Tile & (V_FLIP | H_FLIP))
735 {
736 case 0:
737 bp = pCache + StartLine;
738 for (l = LineCount; l != 0; l--, bp += 8, Screen += GFX.PPL, Depth += GFX.PPL, SubDepth += GFX.PPL)
739 {
740 uint8_t N;
741 for (N = 0; N < 8; N++)
742 {
743 if (GFX.Z1 > Depth [N] && (Pixel = bp[N]))
744 {
745 switch (SubDepth [N])
746 {
747 case 0:
748 Screen [N] = ScreenColors [Pixel];
749 break;
750 case 1:
751 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
752 break;
753 default:
754 Screen [N] = COLOR_ADD(ScreenColors [Pixel], Screen [GFX.Delta + N]);
755 break;
756 }
757 Depth [N] = GFX.Z2;
758 }
759 }
760 }
761 break;
762 case H_FLIP:
763 bp = pCache + StartLine;
764 for (l = LineCount; l != 0; l--, bp += 8, Screen += GFX.PPL, Depth += GFX.PPL, SubDepth += GFX.PPL)
765 {
766 uint8_t N;
767 for (N = 0; N < 8; N++)
768 {
769 if (GFX.Z1 > Depth [N] && (Pixel = bp[7 - N]))
770 {
771 switch (SubDepth [N])
772 {
773 case 0:
774 Screen [N] = ScreenColors [Pixel];
775 break;
776 case 1:
777 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
778 break;
779 default:
780 Screen [N] = COLOR_ADD(ScreenColors [Pixel], Screen [GFX.Delta + N]);
781 break;
782 }
783 Depth [N] = GFX.Z2;
784 }
785 }
786 }
787 break;
788 case H_FLIP | V_FLIP:
789 bp = pCache + 56 - StartLine;
790 for (l = LineCount; l != 0; l--, bp -= 8, Screen += GFX.PPL, Depth += GFX.PPL, SubDepth += GFX.PPL)
791 {
792 uint8_t N;
793 for (N = 0; N < 8; N++)
794 {
795 if (GFX.Z1 > Depth [N] && (Pixel = bp[7 - N]))
796 {
797 switch (SubDepth [N])
798 {
799 case 0:
800 Screen [N] = ScreenColors [Pixel];
801 break;
802 case 1:
803 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
804 break;
805 default:
806 Screen [N] = COLOR_ADD(ScreenColors [Pixel], Screen [GFX.Delta + N]);
807 break;
808 }
809 Depth [N] = GFX.Z2;
810 }
811 }
812 }
813 break;
814 case V_FLIP:
815 bp = pCache + 56 - StartLine;
816 for (l = LineCount; l != 0; l--, bp -= 8, Screen += GFX.PPL, Depth += GFX.PPL, SubDepth += GFX.PPL)
817 {
818 uint8_t N;
819 for (N = 0; N < 8; N++)
820 {
821 if (GFX.Z1 > Depth [N] && (Pixel = bp[N]))
822 {
823 switch (SubDepth [N])
824 {
825 case 0:
826 Screen [N] = ScreenColors [Pixel];
827 break;
828 case 1:
829 Screen [N] = COLOR_ADD(ScreenColors [Pixel], GFX.FixedColour);
830 break;
831 default:
832 Screen [N] = COLOR_ADD(ScreenColors [Pixel], Screen [GFX.Delta + N]);
833 break;
834 }
835 Depth [N] = GFX.Z2;
836 }
837 }
838 }
839 break;
840 default:
841 break;
842 }
843 }
844
DrawClippedTile16Add(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)845 void DrawClippedTile16Add(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
846 {
847 uint8_t* bp;
848 TILE_PREAMBLE_VARS();
849 TILE_CLIP_PREAMBLE_VARS();
850 RENDER_CLIPPED_TILE_VARS();
851 TILE_PREAMBLE_CODE();
852 TILE_CLIP_PREAMBLE_CODE();
853 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_ADD, WRITE_4PIXELS16_FLIPPED_ADD, 4);
854 }
855
DrawTile16Add1_2(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)856 void DrawTile16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
857 {
858 uint8_t* bp;
859 TILE_PREAMBLE_VARS();
860 TILE_PREAMBLE_CODE();
861 RENDER_TILE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4);
862 }
863
DrawClippedTile16Add1_2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)864 void DrawClippedTile16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
865 {
866 uint8_t* bp;
867 TILE_PREAMBLE_VARS();
868 TILE_CLIP_PREAMBLE_VARS();
869 RENDER_CLIPPED_TILE_VARS();
870 TILE_PREAMBLE_CODE();
871 TILE_CLIP_PREAMBLE_CODE();
872 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4);
873 }
874
DrawTile16Sub(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)875 void DrawTile16Sub(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
876 {
877 uint8_t* bp;
878 TILE_PREAMBLE_VARS();
879 TILE_PREAMBLE_CODE();
880 RENDER_TILE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4);
881 }
882
DrawClippedTile16Sub(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)883 void DrawClippedTile16Sub(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
884 {
885 uint8_t* bp;
886 TILE_PREAMBLE_VARS();
887 TILE_CLIP_PREAMBLE_VARS();
888 RENDER_CLIPPED_TILE_VARS();
889 TILE_PREAMBLE_CODE();
890 TILE_CLIP_PREAMBLE_CODE();
891 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4);
892 }
893
DrawTile16Sub1_2(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)894 void DrawTile16Sub1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
895 {
896 uint8_t* bp;
897 TILE_PREAMBLE_VARS();
898 TILE_PREAMBLE_CODE();
899 RENDER_TILE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4);
900 }
901
DrawClippedTile16Sub1_2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)902 void DrawClippedTile16Sub1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
903 {
904 uint8_t* bp;
905 TILE_PREAMBLE_VARS();
906 TILE_CLIP_PREAMBLE_VARS();
907 RENDER_CLIPPED_TILE_VARS();
908 TILE_PREAMBLE_CODE();
909 TILE_CLIP_PREAMBLE_CODE();
910 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4);
911 }
912
WRITE_4PIXELS16_ADDF1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)913 static void WRITE_4PIXELS16_ADDF1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
914 {
915 uint8_t Pixel, N;
916 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
917 uint8_t* Depth = GFX.ZBuffer + Offset;
918 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
919
920 for (N = 0; N < 4; N++)
921 {
922 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
923 {
924 if (SubDepth [N] == 1)
925 Screen [N] = (uint16_t)(COLOR_ADD1_2(ScreenColors [Pixel], GFX.FixedColour));
926 else
927 Screen [N] = ScreenColors [Pixel];
928 Depth [N] = GFX.Z2;
929 }
930 }
931 }
932
WRITE_4PIXELS16_FLIPPED_ADDF1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)933 static void WRITE_4PIXELS16_FLIPPED_ADDF1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
934 {
935 uint8_t Pixel, N;
936 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
937 uint8_t* Depth = GFX.ZBuffer + Offset;
938 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
939
940 for (N = 0; N < 4; N++)
941 {
942 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
943 {
944 if (SubDepth [N] == 1)
945 Screen [N] = (uint16_t)(COLOR_ADD1_2(ScreenColors [Pixel], GFX.FixedColour));
946 else
947 Screen [N] = ScreenColors [Pixel];
948 Depth [N] = GFX.Z2;
949 }
950 }
951 }
952
WRITE_4PIXELS16_SUBF1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)953 static void WRITE_4PIXELS16_SUBF1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
954 {
955 uint8_t Pixel, N;
956 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
957 uint8_t* Depth = GFX.ZBuffer + Offset;
958 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
959
960 for (N = 0; N < 4; N++)
961 {
962 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N]))
963 {
964 if (SubDepth [N] == 1)
965 Screen [N] = (uint16_t) COLOR_SUB1_2(ScreenColors [Pixel], GFX.FixedColour);
966 else
967 Screen [N] = ScreenColors [Pixel];
968 Depth [N] = GFX.Z2;
969 }
970 }
971 }
972
WRITE_4PIXELS16_FLIPPED_SUBF1_2(int32_t Offset,uint8_t * Pixels,uint16_t * ScreenColors)973 static void WRITE_4PIXELS16_FLIPPED_SUBF1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
974 {
975 uint8_t Pixel, N;
976 uint16_t* Screen = (uint16_t*) GFX.S + Offset;
977 uint8_t* Depth = GFX.ZBuffer + Offset;
978 uint8_t* SubDepth = GFX.SubZBuffer + Offset;
979
980 for (N = 0; N < 4; N++)
981 {
982 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N]))
983 {
984 if (SubDepth [N] == 1)
985 Screen [N] = (uint16_t) COLOR_SUB1_2(ScreenColors [Pixel], GFX.FixedColour);
986 else
987 Screen [N] = ScreenColors [Pixel];
988 Depth [N] = GFX.Z2;
989 }
990 }
991 }
992
DrawTile16FixedAdd1_2(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)993 void DrawTile16FixedAdd1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
994 {
995 uint8_t* bp;
996 TILE_PREAMBLE_VARS();
997 TILE_PREAMBLE_CODE();
998 RENDER_TILE(WRITE_4PIXELS16_ADDF1_2, WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4);
999 }
1000
DrawClippedTile16FixedAdd1_2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)1001 void DrawClippedTile16FixedAdd1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
1002 {
1003 uint8_t* bp;
1004 TILE_PREAMBLE_VARS();
1005 TILE_CLIP_PREAMBLE_VARS();
1006 RENDER_CLIPPED_TILE_VARS();
1007 TILE_PREAMBLE_CODE();
1008 TILE_CLIP_PREAMBLE_CODE();
1009 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_ADDF1_2, WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4);
1010 }
1011
DrawTile16FixedSub1_2(uint32_t Tile,int32_t Offset,uint32_t StartLine,uint32_t LineCount)1012 void DrawTile16FixedSub1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
1013 {
1014 uint8_t* bp;
1015 TILE_PREAMBLE_VARS();
1016 TILE_PREAMBLE_CODE();
1017 RENDER_TILE(WRITE_4PIXELS16_SUBF1_2, WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4);
1018 }
1019
DrawClippedTile16FixedSub1_2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Width,uint32_t StartLine,uint32_t LineCount)1020 void DrawClippedTile16FixedSub1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
1021 {
1022 uint8_t* bp;
1023 TILE_PREAMBLE_VARS();
1024 TILE_CLIP_PREAMBLE_VARS();
1025 RENDER_CLIPPED_TILE_VARS();
1026 TILE_PREAMBLE_CODE();
1027 TILE_CLIP_PREAMBLE_CODE();
1028 RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_SUBF1_2, WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4);
1029 }
1030
DrawLargePixel16Add(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Pixels,uint32_t StartLine,uint32_t LineCount)1031 void DrawLargePixel16Add(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
1032 {
1033 uint16_t* sp = (uint16_t*) GFX.S + Offset;
1034 uint8_t* Depth = GFX.ZBuffer + Offset;
1035 uint16_t pixel;
1036 TILE_PREAMBLE_VARS();
1037 TILE_PREAMBLE_CODE();
1038
1039 #define LARGE_ADD_PIXEL(s, p) \
1040 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1041 COLOR_ADD (p, *(s + GFX.Delta)) : \
1042 COLOR_ADD (p, GFX.FixedColour)) : p)
1043
1044 RENDER_TILE_LARGE(ScreenColors [pixel], LARGE_ADD_PIXEL);
1045 }
1046
DrawLargePixel16Add1_2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Pixels,uint32_t StartLine,uint32_t LineCount)1047 void DrawLargePixel16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
1048 {
1049 uint16_t* sp = (uint16_t*) GFX.S + Offset;
1050 uint8_t* Depth = GFX.ZBuffer + Offset;
1051 uint16_t pixel;
1052 TILE_PREAMBLE_VARS();
1053 TILE_PREAMBLE_CODE();
1054
1055 #define LARGE_ADD_PIXEL1_2(s, p) \
1056 ((uint16_t) (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1057 COLOR_ADD1_2 (p, *(s + GFX.Delta)) : \
1058 COLOR_ADD (p, GFX.FixedColour)) : p))
1059
1060 RENDER_TILE_LARGE(ScreenColors [pixel], LARGE_ADD_PIXEL1_2);
1061 }
1062
DrawLargePixel16Sub(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Pixels,uint32_t StartLine,uint32_t LineCount)1063 void DrawLargePixel16Sub(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
1064 {
1065 uint16_t* sp = (uint16_t*) GFX.S + Offset;
1066 uint8_t* Depth = GFX.ZBuffer + Offset;
1067 uint16_t pixel;
1068 TILE_PREAMBLE_VARS();
1069 TILE_PREAMBLE_CODE();
1070
1071 #define LARGE_SUB_PIXEL(s, p) \
1072 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1073 COLOR_SUB (p, *(s + GFX.Delta)) : \
1074 COLOR_SUB (p, GFX.FixedColour)) : p)
1075
1076 RENDER_TILE_LARGE(ScreenColors [pixel], LARGE_SUB_PIXEL);
1077 }
1078
DrawLargePixel16Sub1_2(uint32_t Tile,int32_t Offset,uint32_t StartPixel,uint32_t Pixels,uint32_t StartLine,uint32_t LineCount)1079 void DrawLargePixel16Sub1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
1080 {
1081 uint16_t* sp = (uint16_t*) GFX.S + Offset;
1082 uint8_t* Depth = GFX.ZBuffer + Offset;
1083 uint16_t pixel;
1084 TILE_PREAMBLE_VARS();
1085 TILE_PREAMBLE_CODE();
1086
1087 #define LARGE_SUB_PIXEL1_2(s, p) \
1088 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1089 COLOR_SUB1_2 (p, *(s + GFX.Delta)) : \
1090 COLOR_SUB (p, GFX.FixedColour)) : p)
1091
1092 RENDER_TILE_LARGE(ScreenColors [pixel], LARGE_SUB_PIXEL1_2);
1093 }
1094