source/src/vm/315-5124.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : SMS Plus
   5         Author : tanam
   6         Date   : 2013.09.14 -
   7
   8         [ _315_5124 ]
   9 */
  10
  11 #include "z80.h"
  12 #include "315-5124.h"
  13 #include "gamegear/keyboard.h"
  14
  15 /* Return values from the V counter */
  16 static const uint8_t vcnt[0x200] =
  17 {
  18     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  19     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
  20     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
  21     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
  22     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
  23     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
  24     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
  25     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
  26     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
  27     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
  28     0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
  29     0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
  30     0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
  31     0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
  32                                   0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
  33     0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
  34     0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
  35 };
  36
  37 /* Return values from the H counter */
  38 static const uint8_t hcnt[0x200] =
  39 {
  40     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  41     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
  42     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
  43     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
  44     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
  45     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
  46     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
  47     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
  48     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
  49     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
  50     0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
  51     0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
  52     0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
  53     0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
  54     0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
  55                       0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
  56     0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
  57     0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
  58     0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
  59     0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
  60     0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
  61     0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
  62 };
  63
  64 /* Attribute expansion table */
  65 static const uint32_t atex[4] =
  66 {
  67         0x00000000,
  68         0x10101010,
  69         0x20202020,
  70         0x30303030,
  71 };
  72
  73 #ifdef _MASTERSYSTEM
  74 static const uint8_t tms_crom[] =
  75 {
  76         0x00, 0x00, 0x08, 0x0C,
  77         0x10, 0x30, 0x01, 0x3C,
  78         0x02, 0x03, 0x05, 0x0F,
  79         0x04, 0x33, 0x15, 0x3F
  80 };
  81 #endif
  82
  83 /* Mark a pattern as dirty */
  84 #define MARK_BG_DIRTY(addr)                                                             \
  85 {                                                                                                               \
  86         int name = (addr >> 5) & 0x1FF;                                         \
  87         if(bg_name_dirty[name] == 0)                                            \
  88         {                                                                                                       \
  89                 bg_name_list[bg_list_index] = name;                             \
  90                 bg_list_index++;                                                                \
  91         }                                                                                                       \
  92         bg_name_dirty[name] |= (1 << ((addr >> 2) & 7));        \
  93 }
  94
  95 void _315_5124::initialize()
  96 {
  97         // Game Gear : console = 0x40, vdp_mode = 4
  98         // Mark3     : console = 0x20, vdp_mode = 4
  99         // SC-3000   : console = 0x10, vdp_mode = 0
 100         // COLECO    : console = 0x00, vdp_mode = 0
 101         console = 0x20;
 102         // register event
 103         register_vline_event(this);
 104 }
 105
 106 void _315_5124::reset()
 107 {
 108         int i, j;
 109         int bx, sx, b, s, bp, bf, sf, c;
 110
 111         /* Generate 64k of data for the look up table */
 112         for (bx = 0; bx < 0x100; bx++) {
 113                 for (sx = 0; sx < 0x100; sx++) {
 114                         /* Background pixel */
 115                         b  = (bx & 0x0F);
 116                         /* Background priority */
 117                         bp = (bx & 0x20) ? 1 : 0;
 118                         /* Full background pixel + priority + sprite marker */
 119                         bf = (bx & 0x7F);
 120                         /* Sprite pixel */
 121                         s  = (sx & 0x0F);
 122                         /* Full sprite pixel, w/ palette and marker bits added */
 123                         sf = (sx & 0x0F) | 0x10 | 0x40;
 124                         /* Overwriting a sprite pixel ? */
 125                         if (bx & 0x40) {
 126                                 /* Return the input */
 127                                 c = bf;
 128                         } else {
 129                                 /* Work out priority and transparency for both pixels */
 130                                 if (bp) {
 131                                         /* Underlying pixel is high priority */
 132                                         if (b) {
 133                                                 c = bf | 0x40;
 134                                         } else {
 135                                                 if (s) {
 136                                                         c = sf;
 137                                                 } else {
 138                                                         c = bf;
 139                                                 }
 140                                         }
 141                                 } else {
 142                                         /* Underlying pixel is low priority */
 143                                         if (s) {
 144                                                 c = sf;
 145                                         } else {
 146                                                 c = bf;
 147                                         }
 148                                 }
 149                         }
 150                         /* Store result */
 151                         lut[(bx << 8) | (sx)] = c;
 152                 }
 153         }
 154
 155         /* Make bitplane to pixel lookup table */
 156         for (i = 0; i < 0x100; i++) {
 157                 for (j = 0; j < 0x100; j++) {
 158                         int x;
 159                         uint32_t out = 0;
 160                         for (x = 0; x < 8; x++) {
 161                                 out |= (j & (0x80 >> x)) ? (uint32_t)(8 << (x << 2)) : 0;
 162                                 out |= (i & (0x80 >> x)) ? (uint32_t)(4 << (x << 2)) : 0;
 163                         }
 164                         bp_lut[(j << 8) | (i)] = out;
 165                 }
 166         }
 167
 168         for (i = 0; i < 4; i++) {
 169                 uint8_t c = i << 6 | i << 4 | i << 2 | i;
 170                 sms_cram_expand_table[i] = c;
 171         }
 172
 173         for (i = 0; i < 16; i++) {
 174                 uint8_t c = i << 4 | i;
 175                 gg_cram_expand_table[i] = c;
 176         }
 177
 178         /* Invalidate pattern cache */
 179         memset(bg_name_dirty, 0, sizeof(bg_name_dirty));
 180         memset(bg_name_list, 0, sizeof(bg_name_list));
 181         bg_list_index = 0;
 182         memset(bg_pattern_cache, 0, sizeof(bg_pattern_cache));
 183         memset(cram, 0, sizeof(cram));
 184
 185         linebuf = 0;
 186         cram_latch = 0;
 187         addrmode = 0;
 188         buffer = 0;
 189         hlatch = 0;
 190         vcounter = 0;
 191 ///     counter = 0;
 192         vdp_mode = 4;
 193
 194         memset(vram, 0, sizeof(vram));
 195         memset(screen, 0, sizeof(screen));
 196         memset(regs, 0, sizeof(regs));
 197         status_reg = read_ahead = first_byte = 0;
 198         vram_addr = 0;
 199         intstat = latch = false;
 200         color_table = pattern_table = name_table = 0;
 201         sprite_pattern = sprite_attrib = 0;
 202         color_mask = pattern_mask = 0;
 203
 204         // TMS9918 palette
 205         palette_pc[0]=RGB_COLOR(0,   0,   0);
 206         palette_pc[1]=RGB_COLOR(0,   0,   0);
 207         palette_pc[2]=RGB_COLOR(33, 200,  66);
 208         palette_pc[3]=RGB_COLOR(94, 220, 120);
 209         palette_pc[4]=RGB_COLOR(84,  85, 237);
 210         palette_pc[5]=RGB_COLOR(125, 118, 252);
 211         palette_pc[6]=RGB_COLOR(212,  82,  77);
 212         palette_pc[7]=RGB_COLOR(66, 235, 245);
 213         palette_pc[8]=RGB_COLOR(252,  85,  84);
 214         palette_pc[9]=RGB_COLOR(255, 121, 120);
 215         palette_pc[10]=RGB_COLOR(212, 193,  84);
 216         palette_pc[11]=RGB_COLOR(230, 206, 128);
 217         palette_pc[12]=RGB_COLOR(33, 176,  59);
 218         palette_pc[13]=RGB_COLOR(201,  91, 186);
 219         palette_pc[14]=RGB_COLOR(204, 204, 204);
 220         palette_pc[15]=RGB_COLOR(255, 255, 255);
 221         palette_pc[16]=RGB_COLOR(0,   0,   0);
 222         palette_pc[17]=RGB_COLOR(0,   0,   0);
 223         palette_pc[18]=RGB_COLOR(0,   0,   0);
 224         palette_pc[19]=RGB_COLOR(0,   0,   0);
 225         palette_pc[20]=RGB_COLOR(0,   0,   0);
 226         palette_pc[21]=RGB_COLOR(0,   0,   0);
 227         palette_pc[22]=RGB_COLOR(0,   0,   0);
 228         palette_pc[23]=RGB_COLOR(0,   0,   0);
 229         palette_pc[24]=RGB_COLOR(0,   0,   0);
 230         palette_pc[25]=RGB_COLOR(0,   0,   0);
 231         palette_pc[26]=RGB_COLOR(0,   0,   0);
 232         palette_pc[27]=RGB_COLOR(0,   0,   0);
 233         palette_pc[28]=RGB_COLOR(0,   0,   0);
 234         palette_pc[29]=RGB_COLOR(0,   0,   0);
 235         palette_pc[30]=RGB_COLOR(0,   0,   0);
 236         palette_pc[31]=RGB_COLOR(0,   0,   0);
 237 #ifdef _MASTERSYSTEM // 315-5124 palette
 238         if (console) {   // without COLECO
 239                 for (i = 0; i < 32; i++) {
 240                         int r = (tms_crom[i & 0x0F] >> 0) & 3;
 241                         int g = (tms_crom[i & 0x0F] >> 2) & 3;
 242                         int b = (tms_crom[i & 0x0F] >> 4) & 3;
 243                         r = sms_cram_expand_table[r];
 244                         g = sms_cram_expand_table[g];
 245                         b = sms_cram_expand_table[b];
 246                         palette_pc[i]=RGB_COLOR(r, g, b);
 247                 }
 248         }
 249 #endif
 250         vp_x = (console == 0x40) ? 48 : 0;
 251         vp_y = (console == 0x40) ? 24 : 0;
 252         vp_w = (console == 0x40) ? 160 : 256;
 253         vp_h = (console == 0x40) ? 144 : 192;
 254 }
 255
 256 void _315_5124::viewport_check(void)
 257 {
 258         vdp_mode = 4;
 259         int m1 = (regs[1] >> 4) & 1;
 260         int m3 = (regs[1] >> 3) & 1;
 261         int m2 = (regs[0] >> 1) & 1;
 262         int m4 = (regs[0] >> 2) & 1;
 263
 264         // check if this is switching out of tms
 265         if (!(console & 0x40)) {
 266                 if (m4) {
 267                         // Game Gear or Mark3
 268                         for(int i = 0; i < 0x20; i++) {
 269                                 palette_sync(i, 1);
 270                         }
 271                 } else {
 272                         // SC-3000
 273                         d_key->sk1100=true;
 274                         console = 0x10;
 275                         vdp_mode = 0;
 276                 }
 277         }
 278         name_table = (regs[2] << 10) & 0x3800;
 279         color_table = (regs[3] <<  6) & 0x3FC0;
 280         pattern_table = (regs[4] << 11) & 0x3800;
 281         sprite_attrib = (regs[5] <<  7) & 0x3F00;
 282         sprite_pattern = (regs[6] << 11) & 0x3800;
 283 }
 284
 285 void _315_5124::vdp_reg_w(uint8_t r, uint8_t d)
 286 {
 287         // Store register data
 288         regs[r] = d;
 289
 290         switch(r)
 291         {
 292         case 0x00: // Mode Control No. 1
 293         case 0x01: // Mode Control No. 2
 294         case 0x02: // Name Table A Base Address
 295                 viewport_check();
 296                 break;
 297         case 0x03:
 298         case 0x04:
 299         case 0x05: // Sprite Attribute Table Base Address
 300         case 0x06:
 301         case 0x07:
 302                 break;
 303         }
 304 }
 305
 306 void _315_5124::write_io8(uint32_t addr, uint32_t data)
 307 {
 308         int index;
 309         if ((addr & 0x000000ff)==0x7f) {
 310                 d_psg->write_io8(0xff, data);
 311                 return;
 312         }
 313         if (addr & 1) {
 314                 // register
 315                 if(latch) {
 316                         latch = false;
 317                         // Game Gear or Mark3
 318                         if (vdp_mode == 4) {
 319                                 addrmode = (data >> 6) & 3;
 320                                 vram_addr = (data << 8 | first_byte) & 0x3FFF;
 321                                 if (addrmode == 0) {
 322                                          buffer = vram[vram_addr & 0x3FFF];
 323                                         vram_addr = (vram_addr + 1) & 0x3FFF;
 324                                 }
 325                                 if (addrmode == 2) {
 326                                         int r = (data & 0x0F);
 327                                         int d = first_byte;
 328                                         vdp_reg_w(r, d);
 329                                 }
 330                                 return;
 331                         }
 332                         // SC-3000
 333                         if (data & 0x80) {
 334                                 switch(data & 7) {
 335                                 case 0:
 336                                         regs[0] = first_byte & 3;
 337                                         if(regs[0] & 2) {
 338                                                 color_table = ((regs[3] & 0x80) * 64) & ADDR_MASK;
 339                                                 color_mask = ((regs[3] & 0x7f) * 8) | 7;
 340                                                 pattern_table = ((regs[4] & 4) * 2048) & ADDR_MASK;
 341                                                 pattern_mask = ((regs[4] & 3) * 256) | (color_mask & 0xff);
 342                                         } else {
 343                                                 color_table = (regs[3] * 64) & ADDR_MASK;
 344                                                 pattern_table = (regs[4] * 2048) & ADDR_MASK;
 345                                         }
 346                                         break;
 347                                 case 1:
 348                                         regs[1] = first_byte & 0xfb;
 349                                         set_intstat((regs[1] & 0x20) && (status_reg & 0x80));
 350                                         break;
 351                                 case 2:
 352                                         regs[2] = first_byte & 0x0f;
 353                                         name_table = (regs[2] * 1024) & ADDR_MASK;
 354                                         break;
 355                                 case 3:
 356                                         regs[3] = first_byte;
 357                                         if(regs[0] & 2) {
 358                                                 color_table = ((regs[3] & 0x80) * 64) & ADDR_MASK;
 359                                                 color_mask = ((regs[3] & 0x7f) * 8) | 7;
 360                                         } else {
 361                                                 color_table = (regs[3] * 64) & ADDR_MASK;
 362                                         }
 363                                         pattern_mask = ((regs[4] & 3) * 256) | (color_mask & 0xff);
 364                                         break;
 365                                 case 4:
 366                                         regs[4] = first_byte & 7;
 367                                         if(regs[0] & 2) {
 368                                                 pattern_table = ((regs[4] & 4) * 2048) & ADDR_MASK;
 369                                                 pattern_mask = ((regs[4] & 3) * 256) | 255;
 370                                         } else {
 371                                                 pattern_table = (regs[4] * 2048) & ADDR_MASK;
 372                                         }
 373                                         break;
 374                                 case 5:
 375                                         regs[5] = first_byte & 0x7f;
 376                                         sprite_attrib = (regs[5] * 128) & ADDR_MASK;
 377                                         break;
 378                                 case 6:
 379                                         regs[6] = first_byte & 7;
 380                                         sprite_pattern = (regs[6] * 2048) & ADDR_MASK;
 381                                         break;
 382                                 case 7:
 383                                         regs[7] = first_byte;
 384                                         break;
 385                                 }
 386                         } else {
 387                                 vram_addr = ((data * 256) | first_byte) & ADDR_MASK;
 388                                 if(!(data & 0x40)) {
 389                                         read_io8(0);    // read ahead
 390                                 }
 391                         }
 392                 } else {
 393             vram_addr = (vram_addr & 0x3F00) | (data & 0xFF);
 394                         first_byte = data;
 395                         latch = true;
 396                 }
 397         } else {
 398                 latch = false;
 399                 // Game Gear or Mark3
 400                 if (vdp_mode == 4) {
 401                         switch(addrmode)
 402                         {
 403                         case 0: /* VRAM write */
 404                         case 1: /* VRAM write */
 405                         case 2: /* VRAM write */
 406                                 index = (vram_addr & 0x3FFF);
 407                                 if (data != vram[index]) {
 408                                         vram[index] = data;
 409                                         MARK_BG_DIRTY(vram_addr);
 410                                 }
 411                                 break;
 412                         case 3: /* CRAM write */
 413                                 if (console & 0x40) {
 414                                         if (vram_addr & 1) {
 415                                                 cram_latch = (cram_latch & 0x00FF) | ((data & 0xFF) << 8);
 416                                                 cram[(vram_addr & 0x3E) | (0)] = (cram_latch >> 0) & 0xFF;
 417                                                 cram[(vram_addr & 0x3E) | (1)] = (cram_latch >> 8) & 0xFF;
 418                                                 palette_sync((vram_addr >> 1) & 0x1F, 0);
 419                                         } else {
 420                                                 cram_latch = (cram_latch & 0xFF00) | ((data & 0xFF) << 0);
 421                                         }
 422                                 } else {
 423                                         index = (vram_addr & 0x1F);
 424                                         if(data != cram[index]) {
 425                                                 cram[index] = data;
 426                                                 palette_sync(index, 0);
 427                                         }
 428                                 }
 429                                 break;
 430                         }
 431                         vram_addr = (vram_addr + 1) & 0x3FFF;
 432                         return;
 433                 }
 434                 // SC-3000
 435                 vram[vram_addr] = data;
 436                 vram_addr = (vram_addr + 1) & ADDR_MASK;
 437                 read_ahead = data;
 438         }
 439 }
 440
 441 uint32_t _315_5124::read_io8(uint32_t addr)
 442 {
 443         uint8_t temp;
 444         if ((addr & 0x000000ff) == 0x7e) {
 445                 /* V Counter */
 446                 return vcnt[vcounter & 0x01FF];
 447         }
 448         if ((addr & 0x000000ff) == 0x7f) {
 449                 /* H Counter */
 450                 uint16_t pixel = (((z80_icount % CYCLES_PER_LINE) / 4) * 3) * 2;
 451                 return hcnt[(pixel >> 1) & 0x01FF];;
 452         }
 453         switch(addr & 1)
 454         {
 455         case 0: // CPU <-> VDP data buffer
 456                 latch = false;
 457                 temp = buffer;
 458                 buffer = vram[vram_addr & 0x3FFF];
 459                 vram_addr = (vram_addr + 1) & 0x3FFF;
 460                 return temp;
 461         case 1: // Status flags
 462                 temp = status_reg;
 463                 latch = false;
 464                 status_reg = 0;
 465                 set_intstat(false);
 466                 return temp;
 467         }
 468         // Just to please the compiler
 469         return -1;
 470 }
 471
 472 void _315_5124::draw_screen()
 473 {
 474         // update screen buffer
 475         for(int y = 0; y < 192; y++) {
 476                 scrntype_t* dest = emu->get_screen_buffer(y);
 477                 uint8_t* src = screen[y];
 478                 for(int x = 0; x < 256; x++) {
 479                         if (x>=vp_x && x<vp_x+vp_w && y>=vp_y && y<vp_y+vp_h) {
 480                                 int color=(src[x] & 0x1f);
 481                                 dest[x] = palette_pc[color];
 482                         } else {
 483                                 dest[x] = palette_pc[0x10];
 484                         }
 485                 }
 486         }
 487 }
 488
 489 void _315_5124::event_vline(int v, int clock)
 490 {
 491         z80_icount++;
 492         vcounter = v;
 493         if (vdp_mode == 4) {
 494                 if(v <= 0xC0) {
 495                         if(v == 0xC0) {
 496                                 status_reg |= 0x80;
 497                         }
 498                         if(v == 0) {
 499                                 hlatch = regs[10];
 500                         }
 501                         if(hlatch == 0) {
 502                                 hlatch = regs[10];
 503                                 status_reg |= 0x40;
 504                         } else {
 505                                 hlatch -= 1;
 506                         }
 507                         if((status_reg & 0x40) && (regs[0] & 0x10)) {
 508                                 status_reg |= 0x40;
 509                                 set_intstat((regs[0] & 0x10) != 0);
 510                         }
 511                 } else {
 512                         hlatch = regs[10];
 513                         if((v < 0xE0) && (status_reg & 0x80) && (regs[1] & 0x20)) {
 514                                 status_reg |= 0x80;
 515                                 set_intstat((regs[1] & 0x20) != 0);
 516                         }
 517                 }
 518
 519                 /* Ensure we're within the viewport range */
 520                 if(v < vp_y || v >= (vp_y + vp_h)) return;
 521
 522                 /* Point to current line in output buffer */
 523                 linebuf = (uint8_t *)screen[v];
 524
 525             /* Update pattern cache */
 526                 update_bg_pattern_cache();
 527
 528                 /* Blank line (full width) */
 529                 if (!(regs[1] & 0x40)) {
 530                         memset(linebuf, BACKDROP_COLOR, 256);
 531                 } else {
 532                         /* Draw background */
 533                         render_bg(v);
 534                         /* Draw sprites */
 535                         render_obj(v);
 536                         /* Blank leftmost column of display */
 537                         if (regs[0] & 0x20) {
 538                                 memset(linebuf, BACKDROP_COLOR, 8);
 539                         }
 540                 }
 541         } else {
 542                 if (v == 192) {
 543                         // create virtual screen
 544                         if(regs[1] & 0x40) {
 545                                 // draw character plane
 546                                 int mode = (regs[0] & 2) | ((regs[1] & 0x10) >> 4) | ((regs[1] & 8) >> 1);
 547                                 switch(mode)
 548                                 {
 549                                 case 0:
 550                                         draw_mode0();
 551                                         break;
 552                                 case 1:
 553                                         draw_mode1();
 554                                         break;
 555                                 case 2:
 556                                         draw_mode2();
 557                                         break;
 558                                 case 3:
 559                                         draw_mode12();
 560                                         break;
 561                                 case 4:
 562                                         draw_mode3();
 563                                         break;
 564                                 case 6:
 565                                         draw_mode23();
 566                                         break;
 567                                 case 5:
 568                                 case 7:
 569                                         draw_modebogus();
 570                                         break;
 571                                 }
 572                                 // draw sprite plane
 573                                 if((regs[1] & 0x50) == 0x40) {
 574                                         draw_sprites();
 575                                 }
 576                         } else {
 577                                 memset(screen, 0, sizeof(screen));
 578                         }
 579                         // do interrupt
 580                         status_reg |= 0x80;
 581                         set_intstat((regs[1] & 0x20) != 0);
 582                 }
 583         }
 584 }
 585
 586 void _315_5124::set_intstat(bool val)
 587 {
 588         if(val != intstat) {
 589                 write_signals(&outputs_irq, val ? 0xffffffff : 0);
 590                 intstat = val;
 591         }
 592 }
 593
 594 void _315_5124::draw_mode0()
 595 {
 596         for(int y = 0, name = 0; y < 24; y++) {
 597                 for(int x = 0; x < 32; x++) {
 598                         uint16_t code = vram[name_table + (name++)];
 599                         uint8_t* pattern_ptr = vram + pattern_table + code * 8;
 600                         uint8_t color = vram[color_table + (code >> 3)];
 601                         uint8_t fg = (color & 0xf0) ? (color >> 4) : (regs[7] & 0x0f);
 602                         uint8_t bg = (color & 0x0f) ? (color & 0x0f) : (regs[7] & 0x0f);
 603                         for(int yy=0; yy < 8; yy++) {
 604                                 uint8_t pattern = *pattern_ptr++;
 605                                 uint8_t* buffer = screen[y * 8 + yy] + x * 8;
 606                                 buffer[0] = (pattern & 0x80) ? fg : bg;
 607                                 buffer[1] = (pattern & 0x40) ? fg : bg;
 608                                 buffer[2] = (pattern & 0x20) ? fg : bg;
 609                                 buffer[3] = (pattern & 0x10) ? fg : bg;
 610                                 buffer[4] = (pattern & 0x08) ? fg : bg;
 611                                 buffer[5] = (pattern & 0x04) ? fg : bg;
 612                                 buffer[6] = (pattern & 0x02) ? fg : bg;
 613                                 buffer[7] = (pattern & 0x01) ? fg : bg;
 614                         }
 615                 }
 616         }
 617 }
 618
 619 void _315_5124::draw_mode1()
 620 {
 621         uint8_t fg = regs[7] >> 4;
 622         uint8_t bg = regs[7] & 0x0f;
 623         for(int y = 0, name = 0; y < 24; y++) {
 624                 for(int x = 0; x < 40; x++) {
 625                         uint16_t code = vram[name_table + (name++)];
 626                         uint8_t* pattern_ptr = vram + pattern_table + code * 8;
 627                         for(int yy = 0; yy < 8; yy++) {
 628                                 uint8_t pattern = *pattern_ptr++;
 629                                 uint8_t* buffer = screen[y * 8 + yy] + x * 6 + 8;
 630                                 buffer[0] = (pattern & 0x80) ? fg : bg;
 631                                 buffer[1] = (pattern & 0x40) ? fg : bg;
 632                                 buffer[2] = (pattern & 0x20) ? fg : bg;
 633                                 buffer[3] = (pattern & 0x10) ? fg : bg;
 634                                 buffer[4] = (pattern & 0x08) ? fg : bg;
 635                                 buffer[5] = (pattern & 0x04) ? fg : bg;
 636                         }
 637                 }
 638         }
 639 }
 640
 641 void _315_5124::draw_mode2()
 642 {
 643         for(int y = 0, name = 0; y < 24; y++) {
 644                 for(int x = 0; x < 32; x++) {
 645                         uint16_t code = vram[name_table + (name++)] + (y & 0xf8) * 32;
 646                         uint8_t* pattern_ptr = vram + pattern_table + (code & pattern_mask) * 8;
 647                         uint8_t* color_ptr = vram + color_table + (code & color_mask) * 8;
 648                         for(int yy = 0; yy < 8; yy++) {
 649                                 uint8_t pattern = *pattern_ptr++;
 650                                 uint8_t color = *color_ptr++;
 651                                 uint8_t fg = (color & 0xf0) ? (color >> 4) : (regs[7] & 0x0f);
 652                                 uint8_t bg = (color & 0x0f) ? (color & 0x0f) : (regs[7] & 0x0f);
 653                                 uint8_t* buffer = screen[y * 8 + yy] + x * 8;
 654                                 buffer[0] = (pattern & 0x80) ? fg : bg;
 655                                 buffer[1] = (pattern & 0x40) ? fg : bg;
 656                                 buffer[2] = (pattern & 0x20) ? fg : bg;
 657                                 buffer[3] = (pattern & 0x10) ? fg : bg;
 658                                 buffer[4] = (pattern & 0x08) ? fg : bg;
 659                                 buffer[5] = (pattern & 0x04) ? fg : bg;
 660                                 buffer[6] = (pattern & 0x02) ? fg : bg;
 661                                 buffer[7] = (pattern & 0x01) ? fg : bg;
 662                         }
 663                 }
 664         }
 665 }
 666
 667 void _315_5124::draw_mode12()
 668 {
 669         uint8_t fg = regs[7] >> 4;
 670         uint8_t bg = regs[7] & 0x0f;
 671         for(int y = 0, name = 0; y < 24; y++) {
 672                 for(int x = 0; x < 40; x++) {
 673                         uint16_t code = vram[name_table + (name++)] + (y & 0xf8) * 32;
 674                         uint8_t* pattern_ptr = vram + pattern_table + (code & pattern_mask) * 8;
 675                         for(int yy = 0; yy < 8; yy++) {
 676                                 uint8_t pattern = *pattern_ptr++;
 677                                 uint8_t* buffer = screen[y * 8 + yy] + x * 6 + 8;
 678                                 buffer[0] = (pattern & 0x80) ? fg : bg;
 679                                 buffer[1] = (pattern & 0x40) ? fg : bg;
 680                                 buffer[2] = (pattern & 0x20) ? fg : bg;
 681                                 buffer[3] = (pattern & 0x10) ? fg : bg;
 682                                 buffer[4] = (pattern & 0x08) ? fg : bg;
 683                                 buffer[5] = (pattern & 0x04) ? fg : bg;
 684                         }
 685                 }
 686         }
 687 }
 688
 689 void _315_5124::draw_mode3()
 690 {
 691         for(int y = 0, name = 0; y < 24; y++) {
 692                 for(int x = 0; x < 32; x++) {
 693                         uint16_t code = vram[name_table + (name++)];
 694                         uint8_t* pattern_ptr = vram + pattern_table + code * 8 + (y & 3) * 2;
 695                         for(int yy = 0; yy < 2; yy++) {
 696                                 uint8_t color = *pattern_ptr++;
 697                                 uint8_t fg = (color & 0xf0) ? (color >> 4) : (regs[7] & 0x0f);
 698                                 uint8_t bg = (color & 0x0f) ? (color & 0x0f) : (regs[7] & 0x0f);
 699                                 for(int yyy = 0; yyy < 4; yyy++) {
 700                                         uint8_t* buffer = screen[y * 8 + yy * 4 + yyy] + x * 8;
 701                                         buffer[0] = buffer[1] = buffer[2] = buffer[3] = fg;
 702                                         buffer[4] = buffer[5] = buffer[6] = buffer[7] = bg;
 703                                 }
 704                         }
 705                 }
 706         }
 707 }
 708
 709 void _315_5124::draw_mode23()
 710 {
 711         for(int y = 0, name = 0; y < 24;y++) {
 712                 for(int x = 0; x < 32; x++) {
 713                         uint16_t code = vram[name_table + (name++)];
 714                         uint8_t* pattern_ptr = vram + pattern_table + ((code + (y & 3) * 2 + (y & 0xf8) * 32) & pattern_mask) * 8;
 715                         for(int yy = 0; yy < 2; yy++) {
 716                                 uint8_t color = *pattern_ptr++;
 717                                 uint8_t fg = (color & 0xf0) ? (color >> 4) : (regs[7] & 0x0f);
 718                                 uint8_t bg = (color & 0x0f) ? (color & 0x0f) : (regs[7] & 0x0f);
 719                                 for(int yyy = 0; yyy < 4; yyy++) {
 720                                         uint8_t* buffer = screen[y * 8 + yy * 4 + yyy] + x * 8;
 721                                         buffer[0] = buffer[1] = buffer[2] = buffer[3] = fg;
 722                                         buffer[4] = buffer[5] = buffer[6] = buffer[7] = bg;
 723                                 }
 724                         }
 725                 }
 726         }
 727 }
 728
 729 void _315_5124::draw_modebogus()
 730 {
 731         uint8_t fg = regs[7] >> 4;
 732         uint8_t bg = regs[7] & 0x0f;
 733         for(int y = 0; y < 192; y++) {
 734                 uint8_t* buffer = screen[y];
 735                 int x = 0;
 736                 for(int i = 0; i < 8; i++) {
 737                         buffer[x++] = bg;
 738                 }
 739                 for(int i = 0; i < 40; i++) {
 740                         for(int j = 0; j < 4; j++) {
 741                                 buffer[x++] = fg;
 742                         }
 743                         for(int j = 0; j < 2; j++) {
 744                                 buffer[x++] = bg;
 745                         }
 746                 }
 747                 for(int i = 0; i < 8; i++) {
 748                         buffer[x++] = bg;
 749                 }
 750         }
 751 }
 752
 753 void _315_5124::draw_sprites()
 754 {
 755         uint8_t* attrib_ptr = vram + sprite_attrib;
 756         int size = (regs[1] & 2) ? 16 : 8;
 757         bool large = ((regs[1] & 1) != 0);
 758         uint8_t limit[192], collision[192][256];
 759         int illegal_sprite = 0, illegal_sprite_line = 255, p;
 760         memset(limit, 4, sizeof(limit));
 761         memset(collision, 0, sizeof(collision));
 762         status_reg = 0x80;
 763
 764         for(p = 0; p < 32; p++) {
 765                 int y = *attrib_ptr++;
 766                 if(y == 208) {
 767                         break;
 768                 }
 769                 if(y > 208) {
 770                         y = -(~y & 0xff);
 771                 } else {
 772                         y++;
 773                 }
 774                 int x = *attrib_ptr++;
 775                 uint8_t* pattern_ptr = vram + sprite_pattern + ((size == 16) ? (*attrib_ptr & 0xfc) : *attrib_ptr) * 8;
 776                 attrib_ptr++;
 777                 uint8_t c = *attrib_ptr & 0x0f;
 778                 if(*attrib_ptr & 0x80) {
 779                         x -= 32;
 780                 }
 781                 attrib_ptr++;
 782
 783                 if(!large) {
 784                         // draw sprite (not enlarged)
 785                         for(int yy = y; yy < y + size; yy++) {
 786                                 if(yy < 0 || 191 < yy) {
 787                                         continue;
 788                                 }
 789                                 if(limit[yy] == 0) {
 790                                         // illegal sprite line
 791                                         if(yy < illegal_sprite_line) {
 792                                                 illegal_sprite_line = yy;
 793                                                 illegal_sprite = p;
 794                                         } else if(illegal_sprite_line == yy) {
 795                                                 if(illegal_sprite > p) {
 796                                                         illegal_sprite = p;
 797                                                 }
 798                                         }
 799 #ifdef _315_5124_LIMIT_SPRITES
 800                                         continue;
 801 #endif
 802                                 } else {
 803                                         limit[yy]--;
 804                                 }
 805                                 uint16_t line = pattern_ptr[yy - y] * 256 + pattern_ptr[yy - y + 16];
 806                                 for(int xx = x; xx < x + size; xx++) {
 807                                         if(line & 0x8000) {
 808                                                 if(0 <= xx && xx < 256) {
 809                                                         if(collision[yy][xx]) {
 810                                                                 status_reg |= 0x20;
 811                                                         } else {
 812                                                                 collision[yy][xx] = 1;
 813                                                         }
 814                                                         if(c && !(collision[yy][xx] & 2)) {
 815                                                                 collision[yy][xx] |= 2;
 816                                                                 screen[yy][xx] = c;
 817                                                         }
 818                                                 }
 819                                         }
 820                                         line *= 2;
 821                                 }
 822                         }
 823                 } else {
 824                         // draw enlarged sprite
 825                         for(int i = 0; i < size; i++) {
 826                                 int yy = y + i * 2;
 827                                 uint16_t line2 = pattern_ptr[i] * 256 + pattern_ptr[i + 16];
 828                                 for(int j = 0; j < 2; j++) {
 829                                         if(0 <= yy && yy <= 191) {
 830                                                 if(limit[yy] == 0) {
 831                                                         // illegal sprite line
 832                                                         if(yy < illegal_sprite_line) {
 833                                                                 illegal_sprite_line = yy;
 834                                                                  illegal_sprite = p;
 835                                                         } else if(illegal_sprite_line == yy) {
 836                                                                 if(illegal_sprite > p) {
 837                                                                         illegal_sprite = p;
 838                                                                 }
 839                                                         }
 840 #ifdef _315_5124_LIMIT_SPRITES
 841                                                         continue;
 842 #endif
 843                                                 } else {
 844                                                         limit[yy]--;
 845                                                 }
 846                                                 uint16_t line = line2;
 847                                                 for(int xx = x; xx < x + size * 2; xx += 2) {
 848                                                         if(line & 0x8000) {
 849                                                                 if(0 <= xx && xx < 256) {
 850                                                                         if(collision[yy][xx]) {
 851                                                                                 status_reg |= 0x20;
 852                                                                         } else {
 853                                                                                 collision[yy][xx] = 1;
 854                                                                         }
 855                                                                         if(c && !(collision[yy][xx] & 2)) {
 856                                                                                 collision[yy][xx] |= 2;
 857                                                                                 screen[yy][xx] = c;
 858                                                                         }
 859                                                                 }
 860                                                                 if(0 <= xx + 1 && xx + 1 < 256) {
 861                                                                         if(collision[yy][xx + 1]) {
 862                                                                                 status_reg |= 0x20;
 863                                                                         } else {
 864                                                                                 collision[yy][xx + 1] = 1;
 865                                                                         }
 866                                                                         if(c && !(collision[yy][xx + 1] & 2)) {
 867                                                                                 collision[yy][xx + 1] |= 2;
 868                                                                                 screen[yy][xx + 1] = c;
 869                                                                         }
 870                                                                 }
 871                                                         }
 872                                                         line *= 2;
 873                                                 }
 874                                         }
 875                                         yy++;
 876                                 }
 877                         }
 878                 }
 879         }
 880         if(illegal_sprite_line == 255) {
 881                 status_reg |= (p > 31) ? 31 : p;
 882         } else {
 883                 status_reg |= 0x40 + illegal_sprite;
 884         }
 885 }
 886
 887 /* Draw the background */
 888 void _315_5124::render_bg(int line)
 889 {
 890         int locked = 0;
 891         int yscroll_mask = 224;
 892         int v_line = (line + regs[9]) % yscroll_mask;
 893         int v_row  = (v_line & 7) << 3;
 894         int hscroll = ((regs[0] & 0x40) && (line < 0x10)) ? 0 : (0x100 - regs[8]);
 895         int column = 0;
 896         uint16_t attr;
 897         uint16_t *nt = (uint16_t *)&vram[name_table + ((v_line >> 3) << 6)];
 898         int nt_scroll = (hscroll >> 3);
 899         int shift = (hscroll & 7);
 900         uint32_t atex_mask;
 901         uint32_t *cache_ptr;
 902         uint32_t *linebuf_ptr = (uint32_t *)&linebuf[0 - shift];
 903
 904         /* Draw first column (clipped) */
 905         if(shift) {
 906                 int x;
 907                 for(x = shift; x < 8; x++)
 908                         linebuf[(0 - shift) + (x)] = 0;
 909                 column++;
 910         }
 911         /* Draw a line of the background */
 912         for (; column < 32; column++) {
 913                 /* Stop vertical scrolling for leftmost eight columns */
 914                 if ((regs[0] & 0x80) && (!locked) && (column >= 24)) {
 915                         locked = 1;
 916                         v_row = (line & 7) << 3;
 917                         nt = (uint16_t *)&vram[((regs[2] << 10) & 0x3800) + ((line >> 3) << 6)];
 918                 }
 919                 /* Get name table attribute word */
 920                 attr = nt[(column + nt_scroll) & 0x1F];
 921                 /* Expand priority and palette bits */
 922                 atex_mask = atex[(attr >> 11) & 3];
 923                 /* Point to a line of pattern data in cache */
 924                 cache_ptr = (uint32_t *)&bg_pattern_cache[((attr & 0x7FF) << 6) | (v_row)];
 925                 /* Copy the left half, adding the attribute bits in */
 926                 write_dword( &linebuf_ptr[(column << 1)] , read_dword( &cache_ptr[0] ) | (atex_mask));
 927                 /* Copy the right half, adding the attribute bits in */
 928                 write_dword( &linebuf_ptr[(column << 1) | (1)], read_dword( &cache_ptr[1] ) | (atex_mask));
 929         }
 930         /* Draw last column (clipped) */
 931         if (shift) {
 932                 int x, c, a;
 933                 uint8_t *p = &linebuf[(0 - shift)+(column << 3)];
 934                 attr = nt[(column + nt_scroll) & 0x1F];
 935                 a = (attr >> 7) & 0x30;
 936                 for (x = 0; x < shift; x++) {
 937                         c = bg_pattern_cache[((attr & 0x7FF) << 6) | (v_row) | (x)];
 938                         p[x] = ((c) | (a));
 939                 }
 940         }
 941 }
 942
 943 /* Draw sprites */
 944 void _315_5124::render_obj(int line)
 945 {
 946         int i;
 947         uint8_t collision_buffer = 0;
 948         /* Sprite count for current line (8 max.) */
 949         int count = 0;
 950         /* Sprite dimensions */
 951         int width = 8;
 952         int height = (regs[1] & 0x02) ? 16 : 8;
 953         /* Pointer to sprite attribute table */
 954         uint8_t *st = (uint8_t *)&vram[sprite_attrib];
 955         /* Adjust dimensions for double size sprites */
 956         if (regs[1] & 0x01) {
 957                 width *= 2;
 958                 height *= 2;
 959         }
 960         /* Draw sprites in front-to-back order */
 961         for (i = 0; i < 64; i++) {
 962                 /* Sprite Y position */
 963                 int yp = st[i];
 964                 /* Found end of sprite list marker for non-extended modes? */
 965                 if (yp == 208) goto end;
 966                 /* Actual Y position is +1 */
 967                 yp++;
 968                 /* Wrap Y coordinate for sprites > 240 */
 969                 if (yp > 240) yp -= 256;
 970                 /* Check if sprite falls on current line */
 971                 if ((line >= yp) && (line < (yp + height))) {
 972                         uint8_t *linebuf_ptr;
 973                         /* Width of sprite */
 974                         int start = 0;
 975                         int end = width;
 976                         /* Sprite X position */
 977                         int xp = st[0x80 + (i << 1)];
 978                         /* Pattern name */
 979                         int n = st[0x81 + (i << 1)];
 980                         /* Bump sprite count */
 981                         count++;
 982                         /* Too many sprites on this line ? */
 983                         if (count == 9) {
 984                                 status_reg |= 0x40;
 985                                 goto end;
 986                         }
 987                         /* X position shift */
 988                         if (regs[0] & 0x08) xp -= 8;
 989                         /* Add MSB of pattern name */
 990                         if (regs[6] & 0x04) n |= 0x0100;
 991                         /* Mask LSB for 8x16 sprites */
 992                         if (regs[1] & 0x02) n &= 0x01FE;
 993                         /* Point to offset in line buffer */
 994                         linebuf_ptr = (uint8_t *)&linebuf[xp];
 995                         /* Clip sprites on left edge */
 996                         if (xp < 0) {
 997                                 start = (0 - xp);
 998                         }
 999                         /* Clip sprites on right edge */
1000                         if ((xp + width) > 256) {
1001                                 end = (256 - xp);
1002                         }
1003                         /* Draw double size sprite */
1004                         if (regs[1] & 0x01) {
1005                                 int x;
1006                                 uint8_t *cache_ptr = (uint8_t *)&bg_pattern_cache[(n << 6) | (((line - yp) >> 1) << 3)];
1007                                 /* Draw sprite line */
1008                                 for (x = start; x < end; x++) {
1009                                         /* Source pixel from cache */
1010                                         uint8_t sp = cache_ptr[(x >> 1)];
1011                                         /* Only draw opaque sprite pixels */
1012                                         if (sp) {
1013                                                 /* Background pixel from line buffer */
1014                                                 uint8_t bg = linebuf_ptr[x];
1015                                                 /* Look up result */
1016                                                 linebuf_ptr[x] = lut[(bg << 8) | (sp)];
1017                                                 /* Update collision buffer */
1018                                                 collision_buffer |= bg;
1019                                         }
1020                                 }
1021                         } else { /* Regular size sprite (8x8 / 8x16) */
1022                                 int x;
1023                                 uint8_t *cache_ptr = (uint8_t *)&bg_pattern_cache[(n << 6) | ((line - yp) << 3)];
1024                                 /* Draw sprite line */
1025                                 for (x = start; x < end; x++) {
1026                                         /* Source pixel from cache */
1027                                         uint8_t sp = cache_ptr[x];
1028                                         /* Only draw opaque sprite pixels */
1029                                         if (sp) {
1030                                                 /* Background pixel from line buffer */
1031                                                 uint8_t bg = linebuf_ptr[x];
1032                                                 /* Look up result */
1033                                                 linebuf_ptr[x] = lut[(bg << 8) | (sp)];
1034                                                 /* Update collision buffer */
1035                                                 collision_buffer |= bg;
1036                                         }
1037                                 }
1038                         }
1039                 }
1040         }
1041 end:
1042         /* Set sprite collision flag */
1043         if (collision_buffer & 0x40) status_reg |= 0x20;
1044 }
1045
1046 void _315_5124::update_bg_pattern_cache(void)
1047 {
1048         int i;
1049         uint8_t x, y;
1050         uint16_t name;
1051         if (!bg_list_index) return;
1052         for (i = 0; i < bg_list_index; i++) {
1053                 name = bg_name_list[i];
1054                 bg_name_list[i] = 0;
1055                 for (y = 0; y < 8; y++) {
1056                         if (bg_name_dirty[name] & (1 << y)) {
1057                                 uint8_t *dst = &bg_pattern_cache[name << 6];
1058                                 uint16_t bp01 = *(uint16_t *)&vram[(name << 5) | (y << 2) | (0)];
1059                                 uint16_t bp23 = *(uint16_t *)&vram[(name << 5) | (y << 2) | (2)];
1060                                 uint32_t temp = (bp_lut[bp01] >> 2) | (bp_lut[bp23]);
1061                                 for (x = 0; x < 8; x++) {
1062                                         uint8_t c = (temp >> (x << 2)) & 0x0F;
1063                                         dst[0x00000 | (y << 3) | (x)] = (c);
1064                                         dst[0x08000 | (y << 3) | (x ^ 7)] = (c);
1065                                         dst[0x10000 | ((y ^ 7) << 3) | (x)] = (c);
1066                                         dst[0x18000 | ((y ^ 7) << 3) | (x ^ 7)] = (c);
1067                                 }
1068                         }
1069                 }
1070                 bg_name_dirty[name] = 0;
1071         }
1072         bg_list_index = 0;
1073 }
1074
1075 void _315_5124::palette_sync(int index, int force)
1076 {
1077         int r, g, b;
1078         if (console & 0x40) {
1079                 /* ----BBBBGGGGRRRR */
1080                 r = (cram[(index << 1) | (0)] >> 0) & 0x0F;
1081                 g = (cram[(index << 1) | (0)] >> 4) & 0x0F;
1082                 b = (cram[(index << 1) | (1)] >> 0) & 0x0F;
1083                 r = gg_cram_expand_table[r];
1084                 g = gg_cram_expand_table[g];
1085                 b = gg_cram_expand_table[b];
1086         } else {
1087                 // unless we are forcing an update,
1088                 // if not in mode 4, exit
1089                 if (!force && (regs[0] & 4) == 0) return;
1090                 /* --BBGGRR */
1091                 r = (cram[index] >> 0) & 3;
1092                 g = (cram[index] >> 2) & 3;
1093                 b = (cram[index] >> 4) & 3;
1094                 r = sms_cram_expand_table[r];
1095                 g = sms_cram_expand_table[g];
1096                 b = sms_cram_expand_table[b];
1097         }
1098         palette_pc[index] = RGB_COLOR(r, g, b);
1099 }