2 * Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
4 * (c) Copyright 1996 - 2001 Gary Henderson (gary.henderson@ntlworld.com) and
5 * Jerremy Koot (jkoot@snes9x.com)
7 * Super FX C emulator code
8 * (c) Copyright 1997 - 1999 Ivar (ivar@snes9x.com) and
10 * Super FX assembler emulator code (c) Copyright 1998 zsKnight and _Demo_.
12 * DSP1 emulator code (c) Copyright 1998 Ivar, _Demo_ and Gary Henderson.
13 * C4 asm and some C emulation code (c) Copyright 2000 zsKnight and _Demo_.
14 * C4 C code (c) Copyright 2001 Gary Henderson (gary.henderson@ntlworld.com).
16 * DOS port code contains the works of other authors. See headers in
19 * Snes9x homepage: http://www.snes9x.com
21 * Permission to use, copy, modify and distribute Snes9x in both binary and
22 * source form, for non-commercial purposes, is hereby granted without fee,
23 * providing that this license information and copyright notice appear with
24 * all copies and any derived work.
26 * This software is provided 'as-is', without any express or implied
27 * warranty. In no event shall the authors be held liable for any damages
28 * arising from the use of this software.
30 * Snes9x is freeware for PERSONAL USE only. Commercial users should
31 * seek permission of the copyright holders first. Commercial use includes
32 * charging money for Snes9x or software derived from Snes9x.
34 * The copyright holders request that bug fixes and improvements to the code
35 * should be forwarded to them so everyone can benefit from the modifications
38 * Super NES and Super Nintendo Entertainment System are trademarks of
39 * Nintendo Co., Limited and its subsidiary companies.
49 #define TILE_PREAMBLE \
52 uint32 TileAddr = BG.TileAddress + ((Tile & 0x3ff) << BG.TileShift); \
53 if ((Tile & 0x1ff) >= 256) \
54 TileAddr += BG.NameSelect; \
59 pCache = &BG.Buffer[(TileNumber = (TileAddr >> BG.TileShift)) << 6]; \
61 if (!BG.Buffered [TileNumber]) \
62 BG.Buffered[TileNumber] = ConvertTile (pCache, TileAddr); \
64 if (BG.Buffered [TileNumber] == BLANK_TILE) \
68 if (BG.DirectColourMode) \
70 if (IPPU.DirectColourMapsNeedRebuild) \
71 S9xBuildDirectColourMaps (); \
72 GFX.ScreenColors = DirectColourMaps [(Tile >> 10) & BG.PaletteMask]; \
75 GFX.ScreenColors = &IPPU.ScreenColors [(((Tile >> 10) & BG.PaletteMask) << BG.PaletteShift) + BG.StartPalette];
77 #define RENDER_TILE(NORMAL, FLIPPED, N) \
78 if (!(Tile & (V_FLIP | H_FLIP))) \
80 bp = pCache + StartLine; \
81 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
84 NORMAL (Offset, bp); \
85 if (*(uint32 *) (bp + 4)) \
86 NORMAL (Offset + N, bp + 4); \
90 if (!(Tile & V_FLIP)) \
92 bp = pCache + StartLine; \
93 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
95 if (*(uint32 *) (bp + 4)) \
96 FLIPPED (Offset, bp + 4); \
98 FLIPPED (Offset + N, bp); \
104 bp = pCache + 56 - StartLine; \
105 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
107 if (*(uint32 *) (bp + 4)) \
108 FLIPPED (Offset, bp + 4); \
109 if (*(uint32 *) bp) \
110 FLIPPED (Offset + N, bp); \
115 bp = pCache + 56 - StartLine; \
116 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
118 if (*(uint32 *) bp) \
119 NORMAL (Offset, bp); \
120 if (*(uint32 *) (bp + 4)) \
121 NORMAL (Offset + N, bp + 4); \
125 #define TILE_CLIP_PREAMBLE \
130 if (StartPixel < 4) \
132 d1 = HeadMask [StartPixel]; \
133 if (StartPixel + Width < 4) \
134 d1 &= TailMask [StartPixel + Width]; \
139 if (StartPixel + Width > 4) \
141 if (StartPixel > 4) \
142 d2 = HeadMask [StartPixel - 4]; \
146 d2 &= TailMask [(StartPixel + Width - 4)]; \
152 #define RENDER_CLIPPED_TILE(NORMAL, FLIPPED, N) \
153 if (!(Tile & (V_FLIP | H_FLIP))) \
155 bp = pCache + StartLine; \
156 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
158 if ((dd = (*(uint32 *) bp) & d1)) \
159 NORMAL (Offset, (uint8 *) &dd); \
160 if ((dd = (*(uint32 *) (bp + 4)) & d2)) \
161 NORMAL (Offset + N, (uint8 *) &dd); \
165 if (!(Tile & V_FLIP)) \
167 bp = pCache + StartLine; \
170 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
172 if ((dd = *(uint32 *) (bp + 4) & d1)) \
173 FLIPPED (Offset, (uint8 *) &dd); \
174 if ((dd = *(uint32 *) bp & d2)) \
175 FLIPPED (Offset + N, (uint8 *) &dd); \
181 bp = pCache + 56 - StartLine; \
184 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
186 if ((dd = *(uint32 *) (bp + 4) & d1)) \
187 FLIPPED (Offset, (uint8 *) &dd); \
188 if ((dd = *(uint32 *) bp & d2)) \
189 FLIPPED (Offset + N, (uint8 *) &dd); \
194 bp = pCache + 56 - StartLine; \
195 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
197 if ((dd = (*(uint32 *) bp) & d1)) \
198 NORMAL (Offset, (uint8 *) &dd); \
199 if ((dd = (*(uint32 *) (bp + 4)) & d2)) \
200 NORMAL (Offset + N, (uint8 *) &dd); \
204 #define RENDER_TILE_LARGE(PIXEL, FUNCTION) \
205 if (!(Tile & (V_FLIP | H_FLIP))) \
207 if ((pixel = *(pCache + StartLine + StartPixel))) \
210 for (l = LineCount; l != 0; l--, sp += GFX.PPL, Depth += GFX.PPL) \
212 for (int z = Pixels - 1; z >= 0; z--) \
213 if (GFX.Z1 > Depth [z]) \
215 sp [z] = FUNCTION(sp + z, pixel); \
216 Depth [z] = GFX.Z2; \
222 if (!(Tile & V_FLIP)) \
224 StartPixel = 7 - StartPixel; \
225 if ((pixel = *(pCache + StartLine + StartPixel))) \
228 for (l = LineCount; l != 0; l--, sp += GFX.PPL, Depth += GFX.PPL) \
230 for (int z = Pixels - 1; z >= 0; z--) \
231 if (GFX.Z1 > Depth [z]) \
233 sp [z] = FUNCTION(sp + z, pixel); \
234 Depth [z] = GFX.Z2; \
242 StartPixel = 7 - StartPixel; \
243 if ((pixel = *(pCache + 56 - StartLine + StartPixel))) \
246 for (l = LineCount; l != 0; l--, sp += GFX.PPL, Depth += GFX.PPL) \
248 for (int z = Pixels - 1; z >= 0; z--) \
249 if (GFX.Z1 > Depth [z]) \
251 sp [z] = FUNCTION(sp + z, pixel); \
252 Depth [z] = GFX.Z2; \
259 if ((pixel = *(pCache + 56 - StartLine + StartPixel))) \
262 for (l = LineCount; l != 0; l--, sp += GFX.PPL, Depth += GFX.PPL) \
264 for (int z = Pixels - 1; z >= 0; z--) \
265 if (GFX.Z1 > Depth [z]) \
267 sp [z] = FUNCTION(sp + z, pixel); \
268 Depth [z] = GFX.Z2; \
274 #define RENDER_TILEHI(NORMAL, FLIPPED, N) \
275 if (!(Tile & (V_FLIP | H_FLIP))) \
277 bp = pCache + StartLine; \
278 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
280 /*if (*(uint32 *) bp)*/if (((uint32)bp[0])|((uint32)bp[2])|((uint32)bp[4])|((uint32)bp[6])) \
281 NORMAL (Offset, bp); \
285 if (!(Tile & V_FLIP)) \
287 bp = pCache + StartLine; \
288 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
290 /*if (*(uint32 *) (bp + 4))*/if (((uint32)bp[0])|((uint32)bp[2])|((uint32)bp[4])|((uint32)bp[6])) \
291 FLIPPED (Offset, bp); \
297 bp = pCache + 56 - StartLine; \
298 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
300 /*if (*(uint32 *) (bp + 4))*/if (((uint32)bp[0])|((uint32)bp[2])|((uint32)bp[4])|((uint32)bp[6])) \
301 FLIPPED (Offset, bp); \
306 bp = pCache + 56 - StartLine; \
307 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
309 /*if (*(uint32 *) bp)*/if (((uint32)bp[0])|((uint32)bp[2])|((uint32)bp[4])|((uint32)bp[6])) \
310 NORMAL (Offset, bp); \
316 #define RENDER_CLIPPED_TILEHI(NORMAL, FLIPPED, N) \
317 d1=(d1&0xFF)|((d1&0xFF0000)>>8)|((d2&0xFF)<<16)|((d2&0xFF0000)<<8);\
318 if (!(Tile & (V_FLIP | H_FLIP))) \
320 bp = pCache + StartLine; \
321 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
323 /*if ((dd = (*(uint32 *) bp) & d1))*/if ((dd = (((((uint32)bp[6])<<24)|(((uint32)bp[4])<<16)|(((uint32)bp[2])<<8)|((uint32)bp[0]))&d1))) \
324 NORMAL (Offset, (uint8 *) &dd); \
328 if (!(Tile & V_FLIP)) \
330 bp = pCache + StartLine; \
332 /*SWAP_DWORD (d2);*/ \
333 for (l = LineCount; l != 0; l--, bp += 8, Offset += GFX.PPL) \
335 /*if ((dd = *(uint32 *) (bp + 4) & d1))*/if ((dd = (((((uint32)bp[6])<<24)|(((uint32)bp[4])<<16)|(((uint32)bp[2])<<8)|((uint32)bp[0]))&d1))) \
336 FLIPPED (Offset, (uint8 *) &dd); \
342 bp = pCache + 56 - StartLine; \
344 /*SWAP_DWORD (d2);*/ \
345 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
347 /*if ((dd = *(uint32 *) (bp + 4) & d1))*/if ((dd = (((((uint32)bp[6])<<24)|(((uint32)bp[4])<<16)|(((uint32)bp[2])<<8)|((uint32)bp[0]))&d1))) \
348 FLIPPED (Offset, (uint8 *) &dd); \
353 bp = pCache + 56 - StartLine; \
354 for (l = LineCount; l != 0; l--, bp -= 8, Offset += GFX.PPL) \
356 /*if ((dd = (*(uint32 *) bp) & d1))*/ if ((dd = (((((uint32)bp[6])<<24)|(((uint32)bp[4])<<16)|(((uint32)bp[2])<<8)|((uint32)bp[0]))&d1))) \
357 NORMAL (Offset, (uint8 *) &dd); \
361 extern uint32 HeadMask [4];
362 extern uint32 TailMask [5];
364 uint8 ConvertTile (uint8 *pCache, uint32 TileAddr)
366 register uint8 *tp = &Memory.VRAM[TileAddr];
367 uint32 *p = (uint32 *) pCache;
377 for (line = 8; line != 0; line--, tp += 2)
380 if ((pix = *(tp + 0)))
382 p1 |= odd_high[0][pix >> 4];
383 p2 |= odd_low[0][pix & 0xf];
385 if ((pix = *(tp + 1)))
387 p1 |= even_high[0][pix >> 4];
388 p2 |= even_low[0][pix & 0xf];
390 if ((pix = *(tp + 16)))
392 p1 |= odd_high[1][pix >> 4];
393 p2 |= odd_low[1][pix & 0xf];
395 if ((pix = *(tp + 17)))
397 p1 |= even_high[1][pix >> 4];
398 p2 |= even_low[1][pix & 0xf];
400 if ((pix = *(tp + 32)))
402 p1 |= odd_high[2][pix >> 4];
403 p2 |= odd_low[2][pix & 0xf];
405 if ((pix = *(tp + 33)))
407 p1 |= even_high[2][pix >> 4];
408 p2 |= even_low[2][pix & 0xf];
410 if ((pix = *(tp + 48)))
412 p1 |= odd_high[3][pix >> 4];
413 p2 |= odd_low[3][pix & 0xf];
415 if ((pix = *(tp + 49)))
417 p1 |= even_high[3][pix >> 4];
418 p2 |= even_low[3][pix & 0xf];
427 for (line = 8; line != 0; line--, tp += 2)
430 if ((pix = *(tp + 0)))
432 p1 |= odd_high[0][pix >> 4];
433 p2 |= odd_low[0][pix & 0xf];
435 if ((pix = *(tp + 1)))
437 p1 |= even_high[0][pix >> 4];
438 p2 |= even_low[0][pix & 0xf];
440 if ((pix = *(tp + 16)))
442 p1 |= odd_high[1][pix >> 4];
443 p2 |= odd_low[1][pix & 0xf];
445 if ((pix = *(tp + 17)))
447 p1 |= even_high[1][pix >> 4];
448 p2 |= even_low[1][pix & 0xf];
457 for (line = 8; line != 0; line--, tp += 2)
460 if ((pix = *(tp + 0)))
462 p1 |= odd_high[0][pix >> 4];
463 p2 |= odd_low[0][pix & 0xf];
465 if ((pix = *(tp + 1)))
467 p1 |= even_high[0][pix >> 4];
468 p2 |= even_low[0][pix & 0xf];
476 return (non_zero ? TRUE : BLANK_TILE);
479 INLINE void WRITE_4PIXELS (uint32 Offset, uint8 *Pixels)
481 register uint8 Pixel;
482 uint8 *Screen = GFX.S + Offset;
483 uint8 *Depth = GFX.DB + Offset;
486 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
488 Screen [N] = (uint8) GFX.ScreenColors [Pixel]; \
489 Depth [N] = GFX.Z2; \
499 INLINE void WRITE_4PIXELS_FLIPPED (uint32 Offset, uint8 *Pixels)
501 register uint8 Pixel;
502 uint8 *Screen = GFX.S + Offset;
503 uint8 *Depth = GFX.DB + Offset;
506 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
508 Screen [N] = (uint8) GFX.ScreenColors [Pixel]; \
509 Depth [N] = GFX.Z2; \
519 inline void WRITE_4PIXELSHI16 (uint32 Offset, uint8 *Pixels)
522 uint16 *Screen = (uint16 *) GFX.S + Offset;
523 uint8 *Depth = GFX.DB + Offset;
526 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[2*N])) \
528 Screen [N] = GFX.ScreenColors [Pixel]; \
529 Depth [N] = GFX.Z2; \
539 inline void WRITE_4PIXELSHI16_FLIPPED (uint32 Offset, uint8 *Pixels)
542 uint16 *Screen = (uint16 *) GFX.S + Offset;
543 uint8 *Depth = GFX.DB + Offset;
546 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[6 - 2*N])) \
548 Screen [N] = GFX.ScreenColors [Pixel]; \
549 Depth [N] = GFX.Z2; \
559 INLINE void WRITE_4PIXELSx2 (uint32 Offset, uint8 *Pixels)
561 register uint8 Pixel;
562 uint8 *Screen = GFX.S + Offset;
563 uint8 *Depth = GFX.DB + Offset;
566 if (GFX.Z1 > Depth [0] && (Pixel = Pixels[N])) \
568 Screen [N * 2] = Screen [N * 2 + 1] = (uint8) GFX.ScreenColors [Pixel]; \
569 Depth [N * 2] = Depth [N * 2 + 1] = GFX.Z2; \
579 INLINE void WRITE_4PIXELS_FLIPPEDx2 (uint32 Offset, uint8 *Pixels)
581 register uint8 Pixel;
582 uint8 *Screen = GFX.S + Offset;
583 uint8 *Depth = GFX.DB + Offset;
586 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[3 - N])) \
588 Screen [N * 2] = Screen [N * 2 + 1] = (uint8) GFX.ScreenColors [Pixel]; \
589 Depth [N * 2] = Depth [N * 2 + 1] = GFX.Z2; \
599 INLINE void WRITE_4PIXELSx2x2 (uint32 Offset, uint8 *Pixels)
601 register uint8 Pixel;
602 uint8 *Screen = GFX.S + Offset;
603 uint8 *Depth = GFX.DB + Offset;
606 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[N])) \
608 Screen [N * 2] = Screen [N * 2 + 1] = Screen [GFX.RealPitch + N * 2] = \
609 Screen [GFX.RealPitch + N * 2 + 1] = (uint8) GFX.ScreenColors [Pixel]; \
610 Depth [N * 2] = Depth [N * 2 + 1] = Depth [GFX.RealPitch + N * 2] = \
611 Depth [GFX.RealPitch + N * 2 + 1] = GFX.Z2; \
621 INLINE void WRITE_4PIXELS_FLIPPEDx2x2 (uint32 Offset, uint8 *Pixels)
623 register uint8 Pixel;
624 uint8 *Screen = GFX.S + Offset;
625 uint8 *Depth = GFX.DB + Offset;
628 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[3 - N])) \
630 Screen [N * 2] = Screen [N * 2 + 1] = Screen [GFX.RealPitch + N * 2] = \
631 Screen [GFX.RealPitch + N * 2 + 1] = (uint8) GFX.ScreenColors [Pixel]; \
632 Depth [N * 2] = Depth [N * 2 + 1] = Depth [GFX.RealPitch + N * 2] = \
633 Depth [GFX.RealPitch + N * 2 + 1] = GFX.Z2; \
643 void DrawTile(uint32 Tile, uint32 Offset, uint32 StartLine, uint32 LineCount)
649 RENDER_TILE(WRITE_4PIXELS, WRITE_4PIXELS_FLIPPED, 4)
652 void DrawClippedTile(uint32 Tile, uint32 Offset,
653 uint32 StartPixel, uint32 Width,
654 uint32 StartLine, uint32 LineCount)
660 RENDER_CLIPPED_TILE(WRITE_4PIXELS, WRITE_4PIXELS_FLIPPED, 4)
663 void DrawTilex2 (uint32 Tile, uint32 Offset, uint32 StartLine, uint32 LineCount)
669 RENDER_TILE(WRITE_4PIXELSx2, WRITE_4PIXELS_FLIPPEDx2, 8)
672 void DrawClippedTilex2 (uint32 Tile, uint32 Offset,
673 uint32 StartPixel, uint32 Width,
674 uint32 StartLine, uint32 LineCount)
680 RENDER_CLIPPED_TILE(WRITE_4PIXELSx2, WRITE_4PIXELS_FLIPPEDx2, 8)
683 void DrawTilex2x2 (uint32 Tile, uint32 Offset, uint32 StartLine,
690 RENDER_TILE(WRITE_4PIXELSx2x2, WRITE_4PIXELS_FLIPPEDx2x2, 8)
693 void DrawClippedTilex2x2 (uint32 Tile, uint32 Offset,
694 uint32 StartPixel, uint32 Width,
695 uint32 StartLine, uint32 LineCount)
701 RENDER_CLIPPED_TILE(WRITE_4PIXELSx2x2, WRITE_4PIXELS_FLIPPEDx2x2, 8)
704 void DrawLargePixel (uint32 Tile, uint32 Offset,
705 uint32 StartPixel, uint32 Pixels,
706 uint32 StartLine, uint32 LineCount)
710 register uint8 *sp = GFX.S + Offset;
711 uint8 *Depth = GFX.DB + Offset;
713 #define PLOT_PIXEL(screen, pixel) (pixel)
715 RENDER_TILE_LARGE (((uint8) GFX.ScreenColors [pixel]), PLOT_PIXEL)
718 INLINE void WRITE_4PIXELS16 (uint32 Offset, uint8 *Pixels)
720 register uint32 Pixel;
721 uint16 *Screen = (uint16 *) GFX.S + Offset;
722 uint8 *Depth = GFX.DB + Offset;
725 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
727 Screen [N] = GFX.ScreenColors [Pixel]; \
728 Depth [N] = GFX.Z2; \
738 INLINE void WRITE_4PIXELS16_FLIPPED (uint32 Offset, uint8 *Pixels)
740 register uint32 Pixel;
741 uint16 *Screen = (uint16 *) GFX.S + Offset;
742 uint8 *Depth = GFX.DB + Offset;
745 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
747 Screen [N] = GFX.ScreenColors [Pixel]; \
748 Depth [N] = GFX.Z2; \
758 INLINE void WRITE_4PIXELS16x2 (uint32 Offset, uint8 *Pixels)
760 register uint32 Pixel;
761 uint16 *Screen = (uint16 *) GFX.S + Offset;
762 uint8 *Depth = GFX.DB + Offset;
765 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[N])) \
767 Screen [N * 2] = Screen [N * 2 + 1] = GFX.ScreenColors [Pixel]; \
768 Depth [N * 2] = Depth [N * 2 + 1] = GFX.Z2; \
778 INLINE void WRITE_4PIXELS16_FLIPPEDx2 (uint32 Offset, uint8 *Pixels)
780 register uint32 Pixel;
781 uint16 *Screen = (uint16 *) GFX.S + Offset;
782 uint8 *Depth = GFX.DB + Offset;
785 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[3 - N])) \
787 Screen [N * 2] = Screen [N * 2 + 1] = GFX.ScreenColors [Pixel]; \
788 Depth [N * 2] = Depth [N * 2 + 1] = GFX.Z2; \
798 INLINE void WRITE_4PIXELS16x2x2 (uint32 Offset, uint8 *Pixels)
800 register uint32 Pixel;
801 uint16 *Screen = (uint16 *) GFX.S + Offset;
802 uint8 *Depth = GFX.DB + Offset;
805 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[N])) \
807 Screen [N * 2] = Screen [N * 2 + 1] = Screen [(GFX.RealPitch >> 1) + N * 2] = \
808 Screen [(GFX.RealPitch >> 1) + N * 2 + 1] = GFX.ScreenColors [Pixel]; \
809 Depth [N * 2] = Depth [N * 2 + 1] = Depth [(GFX.RealPitch >> 1) + N * 2] = \
810 Depth [(GFX.RealPitch >> 1) + N * 2 + 1] = GFX.Z2; \
820 INLINE void WRITE_4PIXELS16_FLIPPEDx2x2 (uint32 Offset, uint8 *Pixels)
822 register uint32 Pixel;
823 uint16 *Screen = (uint16 *) GFX.S + Offset;
824 uint8 *Depth = GFX.DB + Offset;
827 if (GFX.Z1 > Depth [N * 2] && (Pixel = Pixels[3 - N])) \
829 Screen [N * 2] = Screen [N * 2 + 1] = Screen [(GFX.RealPitch >> 1) + N * 2] = \
830 Screen [(GFX.RealPitch >> 1) + N * 2 + 1] = GFX.ScreenColors [Pixel]; \
831 Depth [N * 2] = Depth [N * 2 + 1] = Depth [(GFX.RealPitch >> 1) + N * 2] = \
832 Depth [(GFX.RealPitch >> 1) + N * 2 + 1] = GFX.Z2; \
842 void DrawTile16 (uint32 Tile, uint32 Offset, uint32 StartLine,
848 RENDER_TILE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4)
851 void DrawClippedTile16 (uint32 Tile, uint32 Offset,
852 uint32 StartPixel, uint32 Width,
853 uint32 StartLine, uint32 LineCount)
859 RENDER_CLIPPED_TILE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4)
862 void DrawTile16x2 (uint32 Tile, uint32 Offset, uint32 StartLine,
868 RENDER_TILE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8)
871 void DrawClippedTile16x2 (uint32 Tile, uint32 Offset,
872 uint32 StartPixel, uint32 Width,
873 uint32 StartLine, uint32 LineCount)
879 RENDER_CLIPPED_TILE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8)
882 void DrawTile16x2x2 (uint32 Tile, uint32 Offset, uint32 StartLine,
888 RENDER_TILE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8)
891 void DrawClippedTile16x2x2 (uint32 Tile, uint32 Offset,
892 uint32 StartPixel, uint32 Width,
893 uint32 StartLine, uint32 LineCount)
899 RENDER_CLIPPED_TILE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8)
902 void DrawLargePixel16 (uint32 Tile, uint32 Offset,
903 uint32 StartPixel, uint32 Pixels,
904 uint32 StartLine, uint32 LineCount)
908 register uint16 *sp = (uint16 *) GFX.S + Offset;
909 uint8 *Depth = GFX.DB + Offset;
912 RENDER_TILE_LARGE (GFX.ScreenColors [pixel], PLOT_PIXEL)
915 INLINE void WRITE_4PIXELS16_ADD (uint32 Offset, uint8 *Pixels)
917 register uint32 Pixel;
918 uint16 *Screen = (uint16 *) GFX.S + Offset;
919 uint8 *Depth = GFX.ZBuffer + Offset;
920 uint8 *SubDepth = GFX.SubZBuffer + Offset;
923 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
927 if (SubDepth [N] != 1) \
928 Screen [N] = COLOR_ADD (GFX.ScreenColors [Pixel], \
929 Screen [GFX.Delta + N]); \
931 Screen [N] = COLOR_ADD (GFX.ScreenColors [Pixel], \
935 Screen [N] = GFX.ScreenColors [Pixel]; \
936 Depth [N] = GFX.Z2; \
947 INLINE void WRITE_4PIXELS16_FLIPPED_ADD (uint32 Offset, uint8 *Pixels)
949 register uint32 Pixel;
950 uint16 *Screen = (uint16 *) GFX.S + Offset;
951 uint8 *Depth = GFX.ZBuffer + Offset;
952 uint8 *SubDepth = GFX.SubZBuffer + Offset;
955 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
959 if (SubDepth [N] != 1) \
960 Screen [N] = COLOR_ADD (GFX.ScreenColors [Pixel], \
961 Screen [GFX.Delta + N]); \
963 Screen [N] = COLOR_ADD (GFX.ScreenColors [Pixel], \
967 Screen [N] = GFX.ScreenColors [Pixel]; \
968 Depth [N] = GFX.Z2; \
979 INLINE void WRITE_4PIXELS16_ADD1_2 (uint32 Offset, uint8 *Pixels)
981 register uint32 Pixel;
982 uint16 *Screen = (uint16 *) GFX.S + Offset;
983 uint8 *Depth = GFX.ZBuffer + Offset;
984 uint8 *SubDepth = GFX.SubZBuffer + Offset;
987 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
991 if (SubDepth [N] != 1) \
992 Screen [N] = (uint16) (COLOR_ADD1_2 (GFX.ScreenColors [Pixel], \
993 Screen [GFX.Delta + N])); \
995 Screen [N] = COLOR_ADD (GFX.ScreenColors [Pixel], \
999 Screen [N] = GFX.ScreenColors [Pixel]; \
1000 Depth [N] = GFX.Z2; \
1011 INLINE void WRITE_4PIXELS16_FLIPPED_ADD1_2 (uint32 Offset, uint8 *Pixels)
1013 register uint32 Pixel;
1014 uint16 *Screen = (uint16 *) GFX.S + Offset;
1015 uint8 *Depth = GFX.ZBuffer + Offset;
1016 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1019 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
1023 if (SubDepth [N] != 1) \
1024 Screen [N] = (uint16) (COLOR_ADD1_2 (GFX.ScreenColors [Pixel], \
1025 Screen [GFX.Delta + N])); \
1027 Screen [N] = COLOR_ADD (GFX.ScreenColors [Pixel], \
1031 Screen [N] = GFX.ScreenColors [Pixel]; \
1032 Depth [N] = GFX.Z2; \
1043 INLINE void WRITE_4PIXELS16_SUB (uint32 Offset, uint8 *Pixels)
1045 register uint32 Pixel;
1046 uint16 *Screen = (uint16 *) GFX.S + Offset;
1047 uint8 *Depth = GFX.ZBuffer + Offset;
1048 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1051 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
1055 if (SubDepth [N] != 1) \
1056 Screen [N] = (uint16) COLOR_SUB (GFX.ScreenColors [Pixel], \
1057 Screen [GFX.Delta + N]); \
1059 Screen [N] = (uint16) COLOR_SUB (GFX.ScreenColors [Pixel], \
1063 Screen [N] = GFX.ScreenColors [Pixel]; \
1064 Depth [N] = GFX.Z2; \
1075 INLINE void WRITE_4PIXELS16_FLIPPED_SUB (uint32 Offset, uint8 *Pixels)
1077 register uint32 Pixel;
1078 uint16 *Screen = (uint16 *) GFX.S + Offset;
1079 uint8 *Depth = GFX.ZBuffer + Offset;
1080 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1083 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
1087 if (SubDepth [N] != 1) \
1088 Screen [N] = (uint16) COLOR_SUB (GFX.ScreenColors [Pixel], \
1089 Screen [GFX.Delta + N]); \
1091 Screen [N] = (uint16) COLOR_SUB (GFX.ScreenColors [Pixel], \
1095 Screen [N] = GFX.ScreenColors [Pixel]; \
1096 Depth [N] = GFX.Z2; \
1107 INLINE void WRITE_4PIXELS16_SUB1_2 (uint32 Offset, uint8 *Pixels)
1109 register uint32 Pixel;
1110 uint16 *Screen = (uint16 *) GFX.S + Offset;
1111 uint8 *Depth = GFX.ZBuffer + Offset;
1112 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1115 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
1119 if (SubDepth [N] != 1) \
1120 Screen [N] = (uint16) COLOR_SUB1_2 (GFX.ScreenColors [Pixel], \
1121 Screen [GFX.Delta + N]); \
1123 Screen [N] = (uint16) COLOR_SUB (GFX.ScreenColors [Pixel], \
1127 Screen [N] = GFX.ScreenColors [Pixel]; \
1128 Depth [N] = GFX.Z2; \
1139 INLINE void WRITE_4PIXELS16_FLIPPED_SUB1_2 (uint32 Offset, uint8 *Pixels)
1141 register uint32 Pixel;
1142 uint16 *Screen = (uint16 *) GFX.S + Offset;
1143 uint8 *Depth = GFX.ZBuffer + Offset;
1144 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1147 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
1151 if (SubDepth [N] != 1) \
1152 Screen [N] = (uint16) COLOR_SUB1_2 (GFX.ScreenColors [Pixel], \
1153 Screen [GFX.Delta + N]); \
1155 Screen [N] = (uint16) COLOR_SUB (GFX.ScreenColors [Pixel], \
1159 Screen [N] = GFX.ScreenColors [Pixel]; \
1160 Depth [N] = GFX.Z2; \
1172 void DrawTile16Add (uint32 Tile, uint32 Offset, uint32 StartLine,
1178 RENDER_TILE(WRITE_4PIXELS16_ADD, WRITE_4PIXELS16_FLIPPED_ADD, 4)
1181 void DrawClippedTile16Add (uint32 Tile, uint32 Offset,
1182 uint32 StartPixel, uint32 Width,
1183 uint32 StartLine, uint32 LineCount)
1189 RENDER_CLIPPED_TILE(WRITE_4PIXELS16_ADD, WRITE_4PIXELS16_FLIPPED_ADD, 4)
1192 void DrawTile16Add1_2 (uint32 Tile, uint32 Offset, uint32 StartLine,
1198 RENDER_TILE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4)
1201 void DrawClippedTile16Add1_2 (uint32 Tile, uint32 Offset,
1202 uint32 StartPixel, uint32 Width,
1203 uint32 StartLine, uint32 LineCount)
1209 RENDER_CLIPPED_TILE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4)
1212 void DrawTile16Sub (uint32 Tile, uint32 Offset, uint32 StartLine,
1218 RENDER_TILE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4)
1221 void DrawClippedTile16Sub (uint32 Tile, uint32 Offset,
1222 uint32 StartPixel, uint32 Width,
1223 uint32 StartLine, uint32 LineCount)
1229 RENDER_CLIPPED_TILE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4)
1232 void DrawTile16Sub1_2 (uint32 Tile, uint32 Offset, uint32 StartLine,
1238 RENDER_TILE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4)
1241 void DrawClippedTile16Sub1_2 (uint32 Tile, uint32 Offset,
1242 uint32 StartPixel, uint32 Width,
1243 uint32 StartLine, uint32 LineCount)
1249 RENDER_CLIPPED_TILE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4)
1252 INLINE void WRITE_4PIXELS16_ADDF1_2 (uint32 Offset, uint8 *Pixels)
1254 register uint32 Pixel;
1255 uint16 *Screen = (uint16 *) GFX.S + Offset;
1256 uint8 *Depth = GFX.ZBuffer + Offset;
1257 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1260 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
1262 if (SubDepth [N] == 1) \
1263 Screen [N] = (uint16) (COLOR_ADD1_2 (GFX.ScreenColors [Pixel], \
1264 GFX.FixedColour)); \
1266 Screen [N] = GFX.ScreenColors [Pixel];\
1267 Depth [N] = GFX.Z2; \
1278 INLINE void WRITE_4PIXELS16_FLIPPED_ADDF1_2 (uint32 Offset, uint8 *Pixels)
1280 register uint32 Pixel;
1281 uint16 *Screen = (uint16 *) GFX.S + Offset;
1282 uint8 *Depth = GFX.ZBuffer + Offset;
1283 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1286 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
1288 if (SubDepth [N] == 1) \
1289 Screen [N] = (uint16) (COLOR_ADD1_2 (GFX.ScreenColors [Pixel], \
1290 GFX.FixedColour)); \
1292 Screen [N] = GFX.ScreenColors [Pixel];\
1293 Depth [N] = GFX.Z2; \
1304 INLINE void WRITE_4PIXELS16_SUBF1_2 (uint32 Offset, uint8 *Pixels)
1306 register uint32 Pixel;
1307 uint16 *Screen = (uint16 *) GFX.S + Offset;
1308 uint8 *Depth = GFX.ZBuffer + Offset;
1309 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1312 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[N])) \
1314 if (SubDepth [N] == 1) \
1315 Screen [N] = (uint16) COLOR_SUB1_2 (GFX.ScreenColors [Pixel], \
1318 Screen [N] = GFX.ScreenColors [Pixel]; \
1319 Depth [N] = GFX.Z2; \
1330 INLINE void WRITE_4PIXELS16_FLIPPED_SUBF1_2 (uint32 Offset, uint8 *Pixels)
1332 register uint32 Pixel;
1333 uint16 *Screen = (uint16 *) GFX.S + Offset;
1334 uint8 *Depth = GFX.ZBuffer + Offset;
1335 uint8 *SubDepth = GFX.SubZBuffer + Offset;
1338 if (GFX.Z1 > Depth [N] && (Pixel = Pixels[3 - N])) \
1340 if (SubDepth [N] == 1) \
1341 Screen [N] = (uint16) COLOR_SUB1_2 (GFX.ScreenColors [Pixel], \
1344 Screen [N] = GFX.ScreenColors [Pixel]; \
1345 Depth [N] = GFX.Z2; \
1356 void DrawTile16FixedAdd1_2 (uint32 Tile, uint32 Offset, uint32 StartLine,
1362 RENDER_TILE(WRITE_4PIXELS16_ADDF1_2, WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4)
1365 void DrawClippedTile16FixedAdd1_2 (uint32 Tile, uint32 Offset,
1366 uint32 StartPixel, uint32 Width,
1367 uint32 StartLine, uint32 LineCount)
1373 RENDER_CLIPPED_TILE(WRITE_4PIXELS16_ADDF1_2,
1374 WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4)
1377 void DrawTile16FixedSub1_2 (uint32 Tile, uint32 Offset, uint32 StartLine,
1383 RENDER_TILE(WRITE_4PIXELS16_SUBF1_2, WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4)
1386 void DrawClippedTile16FixedSub1_2 (uint32 Tile, uint32 Offset,
1387 uint32 StartPixel, uint32 Width,
1388 uint32 StartLine, uint32 LineCount)
1394 RENDER_CLIPPED_TILE(WRITE_4PIXELS16_SUBF1_2,
1395 WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4)
1398 void DrawLargePixel16Add (uint32 Tile, uint32 Offset,
1399 uint32 StartPixel, uint32 Pixels,
1400 uint32 StartLine, uint32 LineCount)
1404 register uint16 *sp = (uint16 *) GFX.S + Offset;
1405 uint8 *Depth = GFX.ZBuffer + Offset;
1406 register uint16 pixel;
1408 #define LARGE_ADD_PIXEL(s, p) \
1409 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1410 COLOR_ADD (p, *(s + GFX.Delta)) : \
1411 COLOR_ADD (p, GFX.FixedColour)) \
1414 RENDER_TILE_LARGE (GFX.ScreenColors [pixel], LARGE_ADD_PIXEL)
1417 void DrawLargePixel16Add1_2 (uint32 Tile, uint32 Offset,
1418 uint32 StartPixel, uint32 Pixels,
1419 uint32 StartLine, uint32 LineCount)
1423 register uint16 *sp = (uint16 *) GFX.S + Offset;
1424 uint8 *Depth = GFX.ZBuffer + Offset;
1425 register uint16 pixel;
1427 #define LARGE_ADD_PIXEL1_2(s, p) \
1428 ((uint16) (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1429 COLOR_ADD1_2 (p, *(s + GFX.Delta)) : \
1430 COLOR_ADD (p, GFX.FixedColour)) \
1433 RENDER_TILE_LARGE (GFX.ScreenColors [pixel], LARGE_ADD_PIXEL1_2)
1436 void DrawLargePixel16Sub (uint32 Tile, uint32 Offset,
1437 uint32 StartPixel, uint32 Pixels,
1438 uint32 StartLine, uint32 LineCount)
1442 register uint16 *sp = (uint16 *) GFX.S + Offset;
1443 uint8 *Depth = GFX.ZBuffer + Offset;
1444 register uint16 pixel;
1446 #define LARGE_SUB_PIXEL(s, p) \
1447 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1448 COLOR_SUB (p, *(s + GFX.Delta)) : \
1449 COLOR_SUB (p, GFX.FixedColour)) \
1452 RENDER_TILE_LARGE (GFX.ScreenColors [pixel], LARGE_SUB_PIXEL)
1455 void DrawLargePixel16Sub1_2 (uint32 Tile, uint32 Offset,
1456 uint32 StartPixel, uint32 Pixels,
1457 uint32 StartLine, uint32 LineCount)
1461 register uint16 *sp = (uint16 *) GFX.S + Offset;
1462 uint8 *Depth = GFX.ZBuffer + Offset;
1465 #define LARGE_SUB_PIXEL1_2(s, p) \
1466 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
1467 COLOR_SUB1_2 (p, *(s + GFX.Delta)) : \
1468 COLOR_SUB (p, GFX.FixedColour)) \
1471 RENDER_TILE_LARGE (GFX.ScreenColors [pixel], LARGE_SUB_PIXEL1_2)
1474 void DrawHiResTile16 (uint32 Tile, uint32 Offset, uint32 StartLine,
1480 RENDER_TILEHI(WRITE_4PIXELSHI16, WRITE_4PIXELSHI16_FLIPPED, 4)
1483 void DrawHiResClippedTile16 (uint32 Tile, uint32 Offset,
1484 uint32 StartPixel, uint32 Width,
1485 uint32 StartLine, uint32 LineCount)
1491 RENDER_CLIPPED_TILEHI(WRITE_4PIXELSHI16, WRITE_4PIXELSHI16_FLIPPED, 4)