Minor changes to sprite rendering subsystem.

diff --git a/src/screen.cpp b/src/screen.cpp
index fef69a0a7a1653e77e273d60d8534bb8ee3b2f7a..fd35a1376a4425dde8aeaf19d82ad9f87e3f0702 100755 (executable)
--- a/src/screen.cpp
+++ b/src/screen.cpp
@@ -28,6 +28,7 @@
 void DrawSprites(uint8 priority);
 int FindPCXName(void);
 static void DrawChar(uint8 * chr, uint8 * ram, uint8 sx, uint8 sy, uint16 scp, uint32 baseAddr, uint32 scrollOffset, bool transparent = true);
+void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, uint8 horiz_bl, uint8 vert_bl);
 
 // Private global variables
 
@@ -50,70 +51,75 @@ extern bool show_scr;                                                                       // Whether or not to show screen
 //
 void BlitChar(SDL_Surface * scr, uint8 * chr, uint8 * ram)
 {
-// Screen structure:
-// Screen is 288 x 224 pixels, with character and independent sprites. Tiles are 36 x 28.
-// There are four tile planes, three of them affected by the h/vscroll values, the last
-// one is a static display (also has highest priority). Screens are 128 bytes wide by
-// 32 bytes high.
+       // Screen structure:
+       // Screen is 288 x 224 pixels, with character and independent sprites. Tiles are 36 x 28.
+       // There are four tile planes, three of them affected by the h/vscroll values, the last
+       // one is a static display (also has highest priority). Screens are 128 bytes wide by
+       // 32 bytes high.
 
        if (show_scr)
        {
-               int sx, sy;
                uint32 sc_base = ((ram[0x9000] << 8) | ram[0x9001]) + 4;        // Adjust hscroll val
                hScrollOffset = sc_base & 0x07;                                 // Horiz. fine scroll offset
                sc_base = (sc_base & 0xFFF8) >> 2;                              // Skip odds..
                uint8 vsc_base = ((ram[0x9002] + 1) & 0xF8) >> 3;// Vertical scroll addr adjust
                vScrollOffset = ((ram[0x9002] + 1) & 0x07);             // Vertical fine scroll amount
-               uint32 scp1 = 0x0180 | ((sc_base + 0x04) & 0x7F);       /*0x0188;*/
-               uint32 scp2 = 0x1180 | ((sc_base + 0x04) & 0x7F);       /*0x1188;*/
-               uint32 scp3 = 0x2180 | ((sc_base + 0x04) & 0x7F);       /*0x2188;*/
-               uint32 scp = 0x3208;
+
+               uint32 scp0 = 0x0180 | ((sc_base + 0x04) & 0x7F);       /*0x0188;*/
+               uint32 scp1 = 0x1180 | ((sc_base + 0x04) & 0x7F);       /*0x1188;*/
+               uint32 scp2 = 0x2180 | ((sc_base + 0x04) & 0x7F);       /*0x2188;*/
+               uint32 scp3 = 0x3208;
+
+               scp0 += vsc_base * 0x80;
+               scp0 &= 0x0FFF;                                                                 // Set vertical scroll addr
                scp1 += vsc_base * 0x80;
-               scp1 &= 0x0FFF;                                                                 // Set vertical scroll addr
+               scp1 = 0x1000 | (scp1 & 0x0FFF);                                // Set vertical scroll addr
                scp2 += vsc_base * 0x80;
-               scp2 = 0x1000 | (scp2 & 0x0FFF);                                // Set vertical scroll addr
-               scp3 += vsc_base * 0x80;
-               scp3 = 0x2000 | (scp3 & 0x0FFF);                                // Set vertical scroll addr
+               scp2 = 0x2000 | (scp2 & 0x0FFF);                                // Set vertical scroll addr
 
-               for(sy=0; sy<29; sy++)
+               // Layer 0 (bottom layer)
+               for(uint8 sy=0; sy<29; sy++)
                {
-                       for(sx=0; sx<37; sx++)
-                               DrawChar(chr, ram, sx, sy, scp1, (charbase ? 0x20000 : 0x00000), 0, false);
+                       for(uint8 sx=0; sx<37; sx++)
+                               DrawChar(chr, ram, sx, sy, scp0, (charbase ? 0x20000 : 0x00000), 0, false);
 
-                       scp1 += 0x80;
-                       scp1 = 0x0000 | (scp1 & 0x0FFF);
+                       scp0 += 0x80;
+                       scp0 = 0x0000 | (scp0 & 0x0FFF);
                }
 
                DrawSprites(0x40);                                                              // Draw sprites at lowest layer...
 
-               for(sy=0; sy<29; sy++)
+               // Layer 1
+               for(uint8 sy=0; sy<29; sy++)
                {
-                       for(sx=0; sx<37; sx++)
-                               DrawChar(chr, ram, sx, sy, scp2, (charbase ? 0x30000 : 0x10000), 0);
+                       for(uint8 sx=0; sx<37; sx++)
+                               DrawChar(chr, ram, sx, sy, scp1, (charbase ? 0x30000 : 0x10000), 0);
 
-                       scp2 += 0x80;
-                       scp2 = 0x1000 | (scp2 & 0x0FFF);
+                       scp1 += 0x80;
+                       scp1 = 0x1000 | (scp1 & 0x0FFF);
                }
 
                DrawSprites(0x80);                                                              // Draw sprites under layer #2...
 
-               for(sy=0; sy<29; sy++)
+               // Layer 2
+               for(uint8 sy=0; sy<29; sy++)
                {
-                       for(sx=0; sx<37; sx++)
-                               DrawChar(chr, ram, sx, sy, scp3, 0x40000, 0);
+                       for(uint8 sx=0; sx<37; sx++)
+                               DrawChar(chr, ram, sx, sy, scp2, 0x40000, 0);
 
-                       scp3 += 0x80;
-                       scp3 = 0x2000 | (scp3 & 0x0FFF);
+                       scp2 += 0x80;
+                       scp2 = 0x2000 | (scp2 & 0x0FFF);
                }
 
                DrawSprites(0xC0);                                                              // Draw highest priority sprites...
 
-               for(sy=0; sy<28; sy++)
+               // Layer 3 (top layer)
+               for(uint8 sy=0; sy<28; sy++)
                {
-                       for(sx=0; sx<36; sx++)
-                               DrawChar(chr, ram, sx, sy, scp, 0x50000, hScrollOffset + voffsets[vScrollOffset]);
+                       for(uint8 sx=0; sx<36; sx++)
+                               DrawChar(chr, ram, sx, sy, scp3, 0x50000, hScrollOffset + voffsets[vScrollOffset]);
 
-                       scp += 0x80;
+                       scp3 += 0x80;
                }
        }
 
@@ -218,11 +224,11 @@ void DrawSprites(uint8 priority)
 
                        uint16 y = 192 - gram1[i + 9];
                        uint8 flip = gram1[i + 4] & 0x20;               // Horizontal flip
-                       uint32 spr_num = ((gram1[i + 4] & 0x07) << 9) | ((gram1[i + 5] & 0x7F) << 2);
-                       spr_num += ((gram1[i + 4] & 0x10) >> 4) + ((gram1[i + 8] & 0x10) >> 3);
+                       uint32 spr_num = ((gram1[i + 4] & 0x07) << 9) | ((gram1[i + 5] & 0x7F) << 2)
+                               | ((gram1[i + 4] & 0x10) >> 4) | ((gram1[i + 8] & 0x10) >> 3);
 
                        // Draw sprite...
-                       Sprite(spr_num, x, y, flip, (gram1[i + 4] & 0x80 ? true : false), (gram1[i + 8] & 0x04 ? true : false));
+                       Sprite(spr_num, x, y, flip, gram1[i + 4] & 0x80, gram1[i + 8] & 0x04);
                }
        }
 }
@@ -230,8 +236,7 @@ void DrawSprites(uint8 priority)
 //
 // Sprite handler
 //
-//void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, uint16 spr_id)
-void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, bool horiz_bl, bool vert_bl)
+void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, uint8 horiz_bl, uint8 vert_bl)
 {
        extern uint8 spr_rom[];
        uint32 sc_addr;

diff --git a/src/screen.h b/src/screen.h
index f616de012d6d1f7a364dda8bc42fabbd043d54e2..417c8c2849ae9fbfb1f8859fa4aea278c0326139 100755 (executable)
--- a/src/screen.h
+++ b/src/screen.h
@@ -16,7 +16,5 @@
 
 void SnapPCX(SDL_Surface *);          // Take a PCX snapshot
 void BlitChar(SDL_Surface *, uint8 *, uint8 *); // Show NAMCO screen
-//void Sprite(uint32, uint16, uint16, uint8, uint16); // Show sprite on the screen
-void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, bool horiz_bl, bool vert_bl);
 
 #endif // __SCREEN_H__