src/emu/video/v9938.c
| r15546 | r15547 | |
| 1 | 1 | |
| 2 | 2 | /*************************************************************************** |
| 3 | 3 | |
| 4 | | v9938 / v9958 emulation |
| 4 | v9938 / v9958 emulation |
| 5 | 5 | |
| 6 | 6 | ***************************************************************************/ |
| 7 | 7 | |
| 8 | 8 | /* |
| 9 | | todo: |
| 9 | todo: |
| 10 | 10 | |
| 11 | | - sprite collision |
| 12 | | - vdp engine -- make run at correct speed |
| 13 | | - vr/hr/fh flags: double-check all of that |
| 14 | | - make vdp engine work in exp. ram |
| 11 | - sprite collision |
| 12 | - vdp engine -- make run at correct speed |
| 13 | - vr/hr/fh flags: double-check all of that |
| 14 | - make vdp engine work in exp. ram |
| 15 | 15 | */ |
| 16 | 16 | |
| 17 | 17 | #include "emu.h" |
| r15546 | r15547 | |
| 20 | 20 | #define VERBOSE 0 |
| 21 | 21 | #define LOG(x) do { if (VERBOSE) logerror x; } while (0) |
| 22 | 22 | |
| 23 | | #define V9938_MODE_TEXT1 (0) |
| 24 | | #define V9938_MODE_MULTI (1) |
| 25 | | #define V9938_MODE_GRAPHIC1 (2) |
| 26 | | #define V9938_MODE_GRAPHIC2 (3) |
| 27 | | #define V9938_MODE_GRAPHIC3 (4) |
| 28 | | #define V9938_MODE_GRAPHIC4 (5) |
| 29 | | #define V9938_MODE_GRAPHIC5 (6) |
| 30 | | #define V9938_MODE_GRAPHIC6 (7) |
| 31 | | #define V9938_MODE_GRAPHIC7 (8) |
| 32 | | #define V9938_MODE_TEXT2 (9) |
| 33 | | #define V9938_MODE_UNKNOWN (10) |
| 23 | enum |
| 24 | { |
| 25 | V9938_MODE_TEXT1 = 0, |
| 26 | V9938_MODE_MULTI, |
| 27 | V9938_MODE_GRAPHIC1, |
| 28 | V9938_MODE_GRAPHIC2, |
| 29 | V9938_MODE_GRAPHIC3, |
| 30 | V9938_MODE_GRAPHIC4, |
| 31 | V9938_MODE_GRAPHIC5, |
| 32 | V9938_MODE_GRAPHIC6, |
| 33 | V9938_MODE_GRAPHIC7, |
| 34 | V9938_MODE_TEXT2, |
| 35 | V9938_MODE_UNKNOWN |
| 36 | }; |
| 34 | 37 | |
| 38 | #define EXPMEM_OFFSET 0x20000 |
| 35 | 39 | |
| 36 | 40 | static const char *const v9938_modes[] = { |
| 37 | 41 | "TEXT 1", "MULTICOLOR", "GRAPHIC 1", "GRAPHIC 2", "GRAPHIC 3", |
| r15546 | r15547 | |
| 43 | 47 | // GLOBAL VARIABLES |
| 44 | 48 | //************************************************************************** |
| 45 | 49 | |
| 50 | /* |
| 51 | Similar to the TMS9928, the V9938 has an own address space. It can handle |
| 52 | at most 192 KiB RAM (128 KiB base, 64 KiB expansion). |
| 53 | */ |
| 54 | static ADDRESS_MAP_START(memmap, AS_DATA, 8, v99x8_device) |
| 55 | ADDRESS_MAP_GLOBAL_MASK(0x3ffff) |
| 56 | AM_RANGE(0x00000, 0x2ffff) AM_RAM |
| 57 | ADDRESS_MAP_END |
| 58 | |
| 59 | |
| 46 | 60 | // devices |
| 47 | 61 | const device_type V9938 = &device_creator<v9938_device>; |
| 48 | 62 | const device_type V9958 = &device_creator<v9958_device>; |
| 49 | 63 | |
| 50 | 64 | v99x8_device::v99x8_device(const machine_config &mconfig, device_type type, const char *name, const char *shortname, const char *tag, device_t *owner, UINT32 clock) |
| 51 | | : device_t(mconfig, type, name, shortname, tag, owner, clock), |
| 52 | | m_model(0), |
| 53 | | m_offset_x(0), |
| 54 | | m_offset_y(0), |
| 55 | | m_visible_y(0), |
| 56 | | m_mode(0), |
| 57 | | m_pal_write_first(0), |
| 58 | | m_cmd_write_first(0), |
| 59 | | m_pal_write(0), |
| 60 | | m_cmd_write(0), |
| 61 | | m_read_ahead(0), |
| 62 | | m_address_latch(0), |
| 63 | | m_vram_exp(NULL), |
| 64 | | m_vram_size(0), |
| 65 | | m_int_state(0), |
| 66 | | m_int_callback_device_name(NULL), |
| 67 | | m_scanline(0), |
| 68 | | m_blink(0), |
| 69 | | m_blink_count(0), |
| 70 | | m_sprite_limit(0), |
| 71 | | m_size(0), |
| 72 | | m_size_old(0), |
| 73 | | m_size_auto(0), |
| 74 | | m_size_now(0), |
| 75 | | m_mx_delta(0), |
| 76 | | m_my_delta(0), |
| 77 | | m_button_state(0), |
| 78 | | m_screen(NULL), |
| 79 | | m_screen_name(NULL), |
| 80 | | m_vdp_ops_count(0), |
| 81 | | m_vdp_engine(NULL) |
| 65 | : device_t(mconfig, type, name, shortname, tag, owner, clock), |
| 66 | device_memory_interface(mconfig, *this), |
| 67 | m_space_config("vram", ENDIANNESS_BIG, 8, 18), |
| 68 | m_model(0), |
| 69 | m_offset_x(0), |
| 70 | m_offset_y(0), |
| 71 | m_visible_y(0), |
| 72 | m_mode(0), |
| 73 | m_pal_write_first(0), |
| 74 | m_cmd_write_first(0), |
| 75 | m_pal_write(0), |
| 76 | m_cmd_write(0), |
| 77 | m_read_ahead(0), |
| 78 | m_address_latch(0), |
| 79 | m_vram_size(0), |
| 80 | m_int_state(0), |
| 81 | m_int_callback_device_name(NULL), |
| 82 | m_scanline(0), |
| 83 | m_blink(0), |
| 84 | m_blink_count(0), |
| 85 | m_sprite_limit(0), |
| 86 | m_size(0), |
| 87 | m_size_old(0), |
| 88 | m_size_auto(0), |
| 89 | m_size_now(0), |
| 90 | m_mx_delta(0), |
| 91 | m_my_delta(0), |
| 92 | m_button_state(0), |
| 93 | m_screen(NULL), |
| 94 | m_screen_name(NULL), |
| 95 | m_vdp_ops_count(0), |
| 96 | m_vdp_engine(NULL) |
| 82 | 97 | { |
| 98 | static_set_addrmap(*this, AS_DATA, ADDRESS_MAP_NAME(memmap)); |
| 83 | 99 | } |
| 84 | 100 | |
| 85 | 101 | v9938_device::v9938_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 86 | | : v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock) |
| 102 | : v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock) |
| 87 | 103 | { |
| 88 | 104 | m_model = MODEL_V9938; |
| 89 | 105 | } |
| 90 | 106 | |
| 91 | 107 | v9958_device::v9958_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 92 | | : v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock) |
| 108 | : v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock) |
| 93 | 109 | { |
| 94 | 110 | m_model = MODEL_V9958; |
| 95 | 111 | } |
| r15546 | r15547 | |
| 118 | 134 | max = (pal) ? 255 : (m_cont_reg[9] & 0x80) ? 234 : 244; |
| 119 | 135 | scanline = (m_scanline - scanline_start - m_offset_y); |
| 120 | 136 | if ( (scanline >= 0) && (scanline <= max) && |
| 121 | | ( ( (scanline + m_cont_reg[23]) & 255) == m_cont_reg[19]) ) |
| 137 | ( ( (scanline + m_cont_reg[23]) & 255) == m_cont_reg[19]) ) |
| 122 | 138 | { |
| 123 | 139 | m_stat_reg[1] |= 1; |
| 124 | 140 | LOG(("V9938: scanline interrupt (%d)\n", scanline)); |
| r15546 | r15547 | |
| 131 | 147 | // check for start of vblank |
| 132 | 148 | if ((pal && (m_scanline == 310)) || |
| 133 | 149 | (!pal && (m_scanline == 259))) |
| 134 | | interrupt_start_vblank (); |
| 150 | interrupt_start_vblank (); |
| 135 | 151 | |
| 136 | 152 | // render the current line |
| 137 | 153 | if ((m_scanline >= scanline_start) && (m_scanline < (212 + 28 + scanline_start))) |
| r15546 | r15547 | |
| 196 | 212 | |
| 197 | 213 | /*************************************************************************** |
| 198 | 214 | |
| 199 | | Palette functions |
| 215 | Palette functions |
| 200 | 216 | |
| 201 | 217 | ***************************************************************************/ |
| 202 | 218 | |
| r15546 | r15547 | |
| 217 | 233 | */ |
| 218 | 234 | |
| 219 | 235 | /* |
| 220 | | In screen 8, the colors are encoded as: |
| 236 | In screen 8, the colors are encoded as: |
| 221 | 237 | |
| 222 | | 7 6 5 4 3 2 1 0 |
| 238 | 7 6 5 4 3 2 1 0 |
| 223 | 239 | +--+--+--+--+--+--+--+--+ |
| 224 | 240 | |g2|g1|g0|r2|r1|r0|b2|b1| |
| 225 | 241 | +--+--+--+--+--+--+--+--+ |
| r15546 | r15547 | |
| 314 | 330 | } |
| 315 | 331 | |
| 316 | 332 | /* |
| 333 | so lookups for screen 12 will look like: |
| 317 | 334 | |
| 318 | | so lookups for screen 12 will look like: |
| 335 | int ind; |
| 319 | 336 | |
| 320 | | int ind; |
| 337 | ind = (*data & 7) << 11 | (*(data + 1) & 7) << 14 | |
| 338 | (*(data + 2) & 7) << 5 | (*(data + 3) & 7) << 8; |
| 321 | 339 | |
| 322 | | ind = (*data & 7) << 11 | (*(data + 1) & 7) << 14 | |
| 323 | | (*(data + 2) & 7) << 5 | (*(data + 3) & 7) << 8; |
| 340 | pixel0 = s_pal_indYJK[ind | (*data >> 3) & 31]; |
| 341 | pixel1 = s_pal_indYJK[ind | (*(data + 1) >> 3) & 31]; |
| 342 | pixel2 = s_pal_indYJK[ind | (*(data + 2) >> 3) & 31]; |
| 343 | pixel3 = s_pal_indYJK[ind | (*(data + 3) >> 3) & 31]; |
| 324 | 344 | |
| 325 | | pixel0 = s_pal_indYJK[ind | (*data >> 3) & 31]; |
| 326 | | pixel1 = s_pal_indYJK[ind | (*(data + 1) >> 3) & 31]; |
| 327 | | pixel2 = s_pal_indYJK[ind | (*(data + 2) >> 3) & 31]; |
| 328 | | pixel3 = s_pal_indYJK[ind | (*(data + 3) >> 3) & 31]; |
| 345 | and for screen 11: |
| 329 | 346 | |
| 330 | | and for screen 11: |
| 331 | | |
| 332 | | pixel0 = (*data) & 8 ? pal_ind16[(*data) >> 4] : s_pal_indYJK[ind | (*data >> 3) & 30]; |
| 333 | | pixel1 = *(data+1) & 8 ? pal_ind16[*(data+1) >> 4] : s_pal_indYJK[ind | *(data+1) >> 3) & 30]; |
| 334 | | pixel2 = *(data+2) & 8 ? pal_ind16[*(data+2) >> 4] : s_pal_indYJK[ind | *(data+2) >> 3) & 30]; |
| 335 | | pixel3 = *(data+3) & 8 ? pal_ind16[*(data+3) >> 4] : s_pal_indYJK[ind | *(data+3) >> 3) & 30]; |
| 336 | | |
| 347 | pixel0 = (*data) & 8 ? pal_ind16[(*data) >> 4] : s_pal_indYJK[ind | (*data >> 3) & 30]; |
| 348 | pixel1 = *(data+1) & 8 ? pal_ind16[*(data+1) >> 4] : s_pal_indYJK[ind | *(data+1) >> 3) & 30]; |
| 349 | pixel2 = *(data+2) & 8 ? pal_ind16[*(data+2) >> 4] : s_pal_indYJK[ind | *(data+2) >> 3) & 30]; |
| 350 | pixel3 = *(data+3) & 8 ? pal_ind16[*(data+3) >> 4] : s_pal_indYJK[ind | *(data+3) >> 3) & 30]; |
| 337 | 351 | */ |
| 338 | 352 | |
| 339 | 353 | READ8_MEMBER( v99x8_device::read ) |
| 340 | 354 | { |
| 341 | 355 | switch (offset & 3) |
| 342 | 356 | { |
| 343 | | case 0: return vram_r(); |
| 344 | | case 1: return status_r(); |
| 357 | case 0: return vram_r(); |
| 358 | case 1: return status_r(); |
| 345 | 359 | } |
| 346 | 360 | return 0xff; |
| 347 | 361 | } |
| r15546 | r15547 | |
| 350 | 364 | { |
| 351 | 365 | switch (offset & 3) |
| 352 | 366 | { |
| 353 | | case 0: vram_w(data); break; |
| 354 | | case 1: command_w(data); break; |
| 355 | | case 2: palette_w(data); break; |
| 356 | | case 3: register_w(data); break; |
| 367 | case 0: vram_w(data); break; |
| 368 | case 1: command_w(data); break; |
| 369 | case 2: palette_w(data); break; |
| 370 | case 3: register_w(data); break; |
| 357 | 371 | } |
| 358 | 372 | } |
| 359 | 373 | |
| r15546 | r15547 | |
| 368 | 382 | |
| 369 | 383 | ret = m_read_ahead; |
| 370 | 384 | |
| 371 | | if (m_cont_reg[45] & 0x40) |
| 385 | if (m_cont_reg[45] & 0x40) // Expansion memory |
| 372 | 386 | { |
| 373 | 387 | if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) ) |
| 374 | 388 | address >>= 1; // correct? |
| 375 | | // correct? |
| 376 | | if (m_vram_exp && address < 0x10000) |
| 377 | | m_read_ahead = m_vram_exp[address]; |
| 389 | // Expansion memory only offers 64 K |
| 390 | if (m_vram_size > 0x20000 && ((address & 0x10000)==0)) |
| 391 | m_read_ahead = m_vram_space->read_byte(address + EXPMEM_OFFSET); |
| 378 | 392 | else |
| 379 | 393 | m_read_ahead = 0xff; |
| 380 | 394 | } |
| 381 | 395 | else |
| 382 | 396 | { |
| 383 | | m_read_ahead = vram_read (address); |
| 397 | m_read_ahead = vram_read(address); |
| 384 | 398 | } |
| 385 | 399 | |
| 386 | 400 | m_address_latch = (m_address_latch + 1) & 0x3fff; |
| r15546 | r15547 | |
| 405 | 419 | |
| 406 | 420 | switch (reg) |
| 407 | 421 | { |
| 408 | | case 0: |
| 409 | | ret = m_stat_reg[0]; |
| 410 | | m_stat_reg[0] &= 0x1f; |
| 411 | | break; |
| 412 | | case 1: |
| 413 | | ret = m_stat_reg[1]; |
| 414 | | m_stat_reg[1] &= 0xfe; |
| 415 | | if ((m_cont_reg[8] & 0xc0) == 0x80) |
| 416 | | // mouse mode: add button state |
| 417 | | ret |= m_button_state & 0xc0; |
| 418 | | break; |
| 419 | | case 2: |
| 420 | | /*update_command ();*/ |
| 421 | | /* |
| 422 | | WTF is this? Whatever this was intended to do, it is nonsensical. |
| 423 | | Might as well pick a random number.... |
| 424 | | This was an attempt to emulate H-Blank flag ;) |
| 425 | | n = cycles_currently_ran (); |
| 426 | | if ( (n < 28) || (n > 199) ) vdp.statReg[2] |= 0x20; |
| 427 | | else vdp.statReg[2] &= ~0x20; |
| 428 | | */ |
| 429 | | if (machine().rand() & 1) m_stat_reg[2] |= 0x20; |
| 430 | | else m_stat_reg[2] &= ~0x20; |
| 431 | | ret = m_stat_reg[2]; |
| 432 | | break; |
| 433 | | case 3: |
| 434 | | if ((m_cont_reg[8] & 0xc0) == 0x80) |
| 435 | | { // mouse mode: return x mouse delta |
| 436 | | ret = m_mx_delta; |
| 437 | | m_mx_delta = 0; |
| 438 | | } |
| 439 | | else |
| 440 | | ret = m_stat_reg[3]; |
| 441 | | break; |
| 442 | | case 5: |
| 443 | | if ((m_cont_reg[8] & 0xc0) == 0x80) |
| 444 | | { // mouse mode: return y mouse delta |
| 445 | | ret = m_my_delta; |
| 446 | | m_my_delta = 0; |
| 447 | | } |
| 448 | | else |
| 449 | | ret = m_stat_reg[5]; |
| 450 | | break; |
| 451 | | case 7: |
| 452 | | ret = m_stat_reg[7]; |
| 453 | | m_stat_reg[7] = m_cont_reg[44] = vdp_to_cpu () ; |
| 454 | | break; |
| 455 | | default: |
| 456 | | ret = m_stat_reg[reg]; |
| 457 | | break; |
| 422 | case 0: |
| 423 | ret = m_stat_reg[0]; |
| 424 | m_stat_reg[0] &= 0x1f; |
| 425 | break; |
| 426 | case 1: |
| 427 | ret = m_stat_reg[1]; |
| 428 | m_stat_reg[1] &= 0xfe; |
| 429 | if ((m_cont_reg[8] & 0xc0) == 0x80) |
| 430 | // mouse mode: add button state |
| 431 | ret |= m_button_state & 0xc0; |
| 432 | break; |
| 433 | case 2: |
| 434 | /*update_command ();*/ |
| 435 | /* |
| 436 | WTF is this? Whatever this was intended to do, it is nonsensical. |
| 437 | Might as well pick a random number.... |
| 438 | This was an attempt to emulate H-Blank flag ;) |
| 439 | n = cycles_currently_ran (); |
| 440 | if ( (n < 28) || (n > 199) ) vdp.statReg[2] |= 0x20; |
| 441 | else vdp.statReg[2] &= ~0x20; |
| 442 | */ |
| 443 | if (machine().rand() & 1) m_stat_reg[2] |= 0x20; |
| 444 | else m_stat_reg[2] &= ~0x20; |
| 445 | ret = m_stat_reg[2]; |
| 446 | break; |
| 447 | case 3: |
| 448 | if ((m_cont_reg[8] & 0xc0) == 0x80) |
| 449 | { // mouse mode: return x mouse delta |
| 450 | ret = m_mx_delta; |
| 451 | m_mx_delta = 0; |
| 452 | } |
| 453 | else |
| 454 | ret = m_stat_reg[3]; |
| 455 | break; |
| 456 | case 5: |
| 457 | if ((m_cont_reg[8] & 0xc0) == 0x80) |
| 458 | { // mouse mode: return y mouse delta |
| 459 | ret = m_my_delta; |
| 460 | m_my_delta = 0; |
| 461 | } |
| 462 | else |
| 463 | ret = m_stat_reg[5]; |
| 464 | break; |
| 465 | case 7: |
| 466 | ret = m_stat_reg[7]; |
| 467 | m_stat_reg[7] = m_cont_reg[44] = vdp_to_cpu () ; |
| 468 | break; |
| 469 | default: |
| 470 | ret = m_stat_reg[reg]; |
| 471 | break; |
| 458 | 472 | } |
| 459 | 473 | |
| 460 | 474 | LOG(("V9938: Read %02x from S#%d\n", ret, reg)); |
| r15546 | r15547 | |
| 475 | 489 | m_pal_reg[indexp*2+1] = data & 0x07; |
| 476 | 490 | // update palette |
| 477 | 491 | m_pal_ind16[indexp] = (((int)m_pal_write << 2) & 0x01c0) | |
| 478 | | (((int)data << 3) & 0x0038) | |
| 479 | | ((int)m_pal_write & 0x0007); |
| 492 | (((int)data << 3) & 0x0038) | |
| 493 | ((int)m_pal_write & 0x0007); |
| 480 | 494 | |
| 481 | 495 | m_cont_reg[0x10] = (m_cont_reg[0x10] + 1) & 15; |
| 482 | 496 | m_pal_write_first = 0; |
| r15546 | r15547 | |
| 496 | 510 | |
| 497 | 511 | m_cmd_write_first = 0; |
| 498 | 512 | |
| 499 | | address = ((int)m_cont_reg[14] << 14) | m_address_latch; |
| 513 | address = ((int)m_cont_reg[14] << 14) | m_address_latch; |
| 500 | 514 | |
| 501 | | if (m_cont_reg[45] & 0x40) |
| 502 | | { |
| 515 | if (m_cont_reg[45] & 0x40) |
| 516 | { |
| 503 | 517 | if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) ) |
| 504 | 518 | address >>= 1; // correct? |
| 505 | | if (m_vram_exp && address < 0x10000) |
| 506 | | m_vram_exp[address] = data; |
| 507 | | } |
| 508 | | else |
| 509 | | { |
| 510 | | vram_write (address, data); |
| 511 | | } |
| 519 | if (m_vram_size > 0x20000 && ((address & 0x10000)==0)) |
| 520 | m_vram_space->write_byte(EXPMEM_OFFSET + address, data); |
| 521 | } |
| 522 | else |
| 523 | { |
| 524 | vram_write(address, data); |
| 525 | } |
| 512 | 526 | |
| 513 | 527 | m_address_latch = (m_address_latch + 1) & 0x3fff; |
| 514 | 528 | if ((!m_address_latch) && (m_cont_reg[0] & 0x0c) ) // correct ??? |
| r15546 | r15547 | |
| 524 | 538 | if (data & 0x80) |
| 525 | 539 | { |
| 526 | 540 | if (!(data & 0x40)) |
| 527 | | register_write (data & 0x3f, m_cmd_write); |
| 541 | register_write (data & 0x3f, m_cmd_write); |
| 528 | 542 | } |
| 529 | 543 | else |
| 530 | 544 | { |
| 531 | 545 | m_address_latch = |
| 532 | | (((UINT16)data << 8) | m_cmd_write) & 0x3fff; |
| 546 | (((UINT16)data << 8) | m_cmd_write) & 0x3fff; |
| 533 | 547 | if ( !(data & 0x40) ) vram_r (); // read ahead! |
| 534 | 548 | } |
| 535 | 549 | |
| r15546 | r15547 | |
| 548 | 562 | |
| 549 | 563 | reg = m_cont_reg[17] & 0x3f; |
| 550 | 564 | if (reg != 17) |
| 551 | | register_write (reg, data); // true ? |
| 565 | register_write(reg, data); // true ? |
| 552 | 566 | |
| 553 | 567 | if (!(m_cont_reg[17] & 0x80)) |
| 554 | 568 | m_cont_reg[17] = (m_cont_reg[17] + 1) & 0x3f; |
| r15546 | r15547 | |
| 599 | 613 | m_screen->register_screen_bitmap(m_bitmap); |
| 600 | 614 | m_size_old = -1; |
| 601 | 615 | |
| 616 | // Video RAM is allocated as an own address space |
| 617 | m_vram_space = space(AS_DATA); |
| 618 | |
| 602 | 619 | // allocate VRAM |
| 603 | 620 | assert(m_vram_size > 0); |
| 604 | | memset(m_vram, 0, sizeof(m_vram)); |
| 621 | |
| 605 | 622 | if (m_vram_size < 0x20000) |
| 606 | 623 | { |
| 607 | 624 | // set unavailable RAM to 0xff |
| 608 | | memset (m_vram + m_vram_size, 0xff, (sizeof(m_vram) - m_vram_size) ); |
| 625 | for (int addr = m_vram_size; addr < 0x30000; addr++) m_vram_space->write_byte(addr, 0xff); |
| 609 | 626 | } |
| 610 | 627 | |
| 611 | | // do we have expanded memory? |
| 612 | | if (m_vram_size > 0x20000) |
| 613 | | m_vram_exp = auto_alloc_array_clear(machine(), UINT8, 0x10000); |
| 614 | | else |
| 615 | | m_vram_exp = NULL; |
| 616 | | |
| 617 | 628 | save_item(NAME(m_offset_x)); |
| 618 | 629 | save_item(NAME(m_offset_y)); |
| 619 | 630 | save_item(NAME(m_visible_y)); |
| r15546 | r15547 | |
| 626 | 637 | save_item(NAME(m_stat_reg)); |
| 627 | 638 | save_item(NAME(m_cont_reg)); |
| 628 | 639 | save_item(NAME(m_read_ahead)); |
| 629 | | save_item(NAME(m_vram)); |
| 630 | | if ( m_vram_exp != NULL ) |
| 631 | | save_pointer(NAME(m_vram_exp), 0x10000); |
| 640 | // save_item(NAME(m_vram)); |
| 641 | // if ( m_vram_exp != NULL ) |
| 642 | // save_pointer(NAME(m_vram_exp), 0x10000); |
| 632 | 643 | save_item(NAME(m_int_state)); |
| 633 | 644 | save_item(NAME(m_scanline)); |
| 634 | 645 | save_item(NAME(m_blink)); |
| r15546 | r15547 | |
| 695 | 706 | } |
| 696 | 707 | |
| 697 | 708 | |
| 698 | | |
| 699 | | |
| 700 | 709 | void v99x8_device::reset_palette () |
| 701 | | { |
| 710 | { |
| 702 | 711 | // taken from V9938 Technical Data book, page 148. it's in G-R-B format |
| 703 | 712 | static const UINT8 pal16[16*3] = { |
| 704 | 713 | 0, 0, 0, // 0: black/transparent |
| r15546 | r15547 | |
| 743 | 752 | |
| 744 | 753 | /*************************************************************************** |
| 745 | 754 | |
| 746 | | Memory functions |
| 755 | Memory functions |
| 747 | 756 | |
| 748 | 757 | ***************************************************************************/ |
| 749 | 758 | |
| 750 | | void v99x8_device::vram_write (int offset, int data) |
| 759 | void v99x8_device::vram_write(int offset, int data) |
| 751 | 760 | { |
| 752 | 761 | int newoffset; |
| 753 | 762 | |
| 754 | 763 | if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) ) |
| 755 | 764 | { |
| 756 | | newoffset = ((offset & 1) << 16) | (offset >> 1); |
| 765 | newoffset = ((offset & 1) << 16) | (offset >> 1); |
| 757 | 766 | if (newoffset < m_vram_size) |
| 758 | | m_vram[newoffset] = data; |
| 767 | m_vram_space->write_byte(newoffset, data); |
| 759 | 768 | } |
| 760 | 769 | else |
| 761 | 770 | { |
| 762 | 771 | if (offset < m_vram_size) |
| 763 | | m_vram[offset] = data; |
| 764 | | } |
| 772 | m_vram_space->write_byte(offset, data); |
| 773 | } |
| 765 | 774 | } |
| 766 | 775 | |
| 767 | | int v99x8_device::vram_read (int offset) |
| 776 | int v99x8_device::vram_read(int offset) |
| 768 | 777 | { |
| 769 | 778 | if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) ) |
| 770 | | return m_vram[((offset & 1) << 16) | (offset >> 1)]; |
| 779 | return m_vram_space->read_byte(((offset & 1) << 16) | (offset >> 1)); |
| 771 | 780 | else |
| 772 | | return m_vram[offset]; |
| 781 | return m_vram_space->read_byte(offset); |
| 773 | 782 | } |
| 774 | 783 | |
| 775 | | void v99x8_device::check_int () |
| 784 | void v99x8_device::check_int() |
| 776 | 785 | { |
| 777 | 786 | UINT8 n; |
| 778 | 787 | |
| 779 | 788 | n = ( (m_cont_reg[1] & 0x20) && (m_stat_reg[0] & 0x80) /*&& m_vblank_int*/) || |
| 780 | | ( (m_stat_reg[1] & 0x01) && (m_cont_reg[0] & 0x10) ); |
| 789 | ( (m_stat_reg[1] & 0x01) && (m_cont_reg[0] & 0x10) ); |
| 781 | 790 | |
| 782 | | #if 0 |
| 791 | #if 0 |
| 783 | 792 | if(n && m_vblank_int) |
| 784 | 793 | { |
| 785 | 794 | m_vblank_int = 0; |
| 786 | 795 | } |
| 787 | | #endif |
| 796 | #endif |
| 788 | 797 | |
| 789 | 798 | if (n != m_int_state) |
| 790 | 799 | { |
| r15546 | r15547 | |
| 796 | 805 | ** Somehow the IRQ request is going down without cpu_irq_line () being |
| 797 | 806 | ** called; because of this Mr. Ghost, Xevious and SD Snatcher don't |
| 798 | 807 | ** run. As a patch it's called every scanline |
| 799 | | */ |
| 808 | */ |
| 800 | 809 | m_int_callback (*this, n); |
| 801 | 810 | } |
| 802 | 811 | |
| r15546 | r15547 | |
| 832 | 841 | /*update_command ();*/ |
| 833 | 842 | |
| 834 | 843 | switch (reg) { |
| 835 | | // registers that affect interrupt and display mode |
| 844 | // registers that affect interrupt and display mode |
| 836 | 845 | case 0: |
| 837 | 846 | case 1: |
| 838 | 847 | m_cont_reg[reg] = data; |
| 839 | | set_mode (); |
| 840 | | check_int (); |
| 841 | | LOG(("V9938: mode = %s\n", v9938_modes[m_mode])); |
| 848 | set_mode(); |
| 849 | check_int(); |
| 850 | LOG(("v9938: mode = %s\n", v9938_modes[m_mode])); |
| 842 | 851 | break; |
| 843 | 852 | |
| 844 | 853 | case 18: |
| r15546 | r15547 | |
| 862 | 871 | m_pal_write_first = 0; |
| 863 | 872 | break; |
| 864 | 873 | |
| 865 | | // color burst registers aren't emulated |
| 874 | // color burst registers aren't emulated |
| 866 | 875 | case 20: |
| 867 | 876 | case 21: |
| 868 | 877 | case 22: |
| 869 | | LOG(("V9938: Write %02xh to R#%d; color burst not emulated\n", |
| 870 | | data, reg)); |
| 878 | LOG(("v9938: Write %02xh to R#%d; color burst not emulated\n", data, reg)); |
| 871 | 879 | break; |
| 872 | 880 | case 25: |
| 873 | 881 | case 26: |
| 874 | 882 | case 27: |
| 875 | 883 | if (m_model != MODEL_V9958) |
| 876 | 884 | { |
| 877 | | LOG(("V9938: Attempting to write %02xh to V9958 R#%d\n", data, reg)); |
| 885 | LOG(("v9938: Attempting to write %02xh to V9958 R#%d\n", data, reg)); |
| 878 | 886 | data = 0; |
| 879 | 887 | } |
| 880 | 888 | break; |
| r15546 | r15547 | |
| 889 | 897 | } |
| 890 | 898 | |
| 891 | 899 | if (reg != 15) |
| 892 | | LOG(("V9938: Write %02x to R#%d\n", data, reg)); |
| 900 | LOG(("v9938: Write %02x to R#%d\n", data, reg)); |
| 893 | 901 | |
| 894 | 902 | m_cont_reg[reg] = data; |
| 895 | 903 | } |
| 896 | 904 | |
| 897 | 905 | /*************************************************************************** |
| 898 | 906 | |
| 899 | | Refresh / render function |
| 907 | Refresh / render function |
| 900 | 908 | |
| 901 | 909 | ***************************************************************************/ |
| 902 | 910 | |
| 903 | | #define V9938_SECOND_FIELD ( !(((m_cont_reg[9] & 0x04) && !(m_stat_reg[2] & 2)) || m_blink)) |
| 911 | inline bool v99x8_device::v9938_second_field() |
| 912 | { |
| 913 | return !(((m_cont_reg[9] & 0x04) && !(m_stat_reg[2] & 2)) || m_blink); |
| 914 | } |
| 904 | 915 | |
| 905 | 916 | /* |
| 906 | | * This file is included for a number of different situations: |
| 907 | | * _Width : can be 512 + 32 or 256 + 16 |
| 908 | | * V9938_BPP : can be 8 or 16 |
| 909 | | */ |
| 917 | * This file is included for a number of different situations: |
| 918 | * _Width : can be 512 + 32 or 256 + 16 |
| 919 | * V9938_BPP : can be 8 or 16 |
| 920 | */ |
| 910 | 921 | |
| 911 | 922 | |
| 912 | 923 | template<typename _PixelType, int _Width> |
| r15546 | r15547 | |
| 963 | 974 | { |
| 964 | 975 | int pattern, x, xx, name, xxx; |
| 965 | 976 | _PixelType fg, bg, pen; |
| 966 | | UINT8 *nametbl, *patterntbl; |
| 977 | int nametbl_addr, patterntbl_addr; |
| 967 | 978 | |
| 968 | | patterntbl = m_vram + (m_cont_reg[4] << 11); |
| 969 | | nametbl = m_vram + (m_cont_reg[2] << 10); |
| 979 | patterntbl_addr = m_cont_reg[4] << 11; |
| 980 | nametbl_addr = m_cont_reg[2] << 10; |
| 970 | 981 | |
| 971 | | fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]]; |
| 972 | | bg = pens[m_pal_ind16[m_cont_reg[7] & 15]]; |
| 982 | fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]]; |
| 983 | bg = pens[m_pal_ind16[m_cont_reg[7] & 15]]; |
| 973 | 984 | |
| 974 | 985 | name = (line/8)*40; |
| 975 | 986 | |
| r15546 | r15547 | |
| 982 | 993 | |
| 983 | 994 | for (x=0;x<40;x++) |
| 984 | 995 | { |
| 985 | | pattern = patterntbl[(nametbl[name] * 8) + |
| 986 | | ((line + m_cont_reg[23]) & 7)]; |
| 996 | pattern = m_vram_space->read_byte(patterntbl_addr + (m_vram_space->read_byte(nametbl_addr + name) * 8) + |
| 997 | ((line + m_cont_reg[23]) & 7)); |
| 987 | 998 | for (xx=0;xx<6;xx++) |
| 988 | 999 | { |
| 989 | 1000 | *ln++ = (pattern & 0x80) ? fg : bg; |
| r15546 | r15547 | |
| 1007 | 1018 | { |
| 1008 | 1019 | int pattern, x, charcode, name, xxx, patternmask, colourmask; |
| 1009 | 1020 | _PixelType fg, bg, fg0, bg0, pen; |
| 1010 | | UINT8 *nametbl, *patterntbl, *colourtbl; |
| 1021 | int nametbl_addr, patterntbl_addr, colourtbl_addr; |
| 1011 | 1022 | |
| 1012 | | patterntbl = m_vram + (m_cont_reg[4] << 11); |
| 1013 | | colourtbl = m_vram + ((m_cont_reg[3] & 0xf8) << 6) + (m_cont_reg[10] << 14); |
| 1014 | | #if 0 |
| 1023 | patterntbl_addr = m_cont_reg[4] << 11; |
| 1024 | colourtbl_addr = ((m_cont_reg[3] & 0xf8) << 6) + (m_cont_reg[10] << 14); |
| 1025 | #if 0 |
| 1015 | 1026 | colourmask = ((m_cont_reg[3] & 7) << 5) | 0x1f; /* cause a bug in Forth+ v1.0 on Geneve */ |
| 1016 | | #else |
| 1027 | #else |
| 1017 | 1028 | colourmask = ((m_cont_reg[3] & 7) << 6) | 0x3f; /* verify! */ |
| 1018 | | #endif |
| 1019 | | nametbl = m_vram + ((m_cont_reg[2] & 0xfc) << 10); |
| 1029 | #endif |
| 1030 | nametbl_addr = ((m_cont_reg[2] & 0xfc) << 10); |
| 1020 | 1031 | patternmask = ((m_cont_reg[2] & 3) << 10) | 0x3ff; /* seems correct */ |
| 1021 | 1032 | |
| 1022 | | fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]]; |
| 1023 | | bg = pens[m_pal_ind16[m_cont_reg[7] & 15]]; |
| 1024 | | fg0 = pens[m_pal_ind16[m_cont_reg[12] >> 4]]; |
| 1025 | | bg0 = pens[m_pal_ind16[m_cont_reg[12] & 15]]; |
| 1033 | fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]]; |
| 1034 | bg = pens[m_pal_ind16[m_cont_reg[7] & 15]]; |
| 1035 | fg0 = pens[m_pal_ind16[m_cont_reg[12] >> 4]]; |
| 1036 | bg0 = pens[m_pal_ind16[m_cont_reg[12] & 15]]; |
| 1026 | 1037 | |
| 1027 | 1038 | name = (line/8)*80; |
| 1028 | 1039 | |
| r15546 | r15547 | |
| 1034 | 1045 | |
| 1035 | 1046 | for (x=0;x<80;x++) |
| 1036 | 1047 | { |
| 1037 | | charcode = nametbl[name&patternmask]; |
| 1048 | charcode = m_vram_space->read_byte(nametbl_addr + (name&patternmask)); |
| 1038 | 1049 | if (m_blink) |
| 1039 | 1050 | { |
| 1040 | | pattern = colourtbl[(name/8)&colourmask]; |
| 1051 | pattern = m_vram_space->read_byte(colourtbl_addr + ((name/8)&colourmask)); |
| 1041 | 1052 | if (pattern & (0x80 >> (name & 7) ) ) |
| 1042 | 1053 | { |
| 1043 | | pattern = patterntbl[(charcode * 8) + |
| 1044 | | ((line + m_cont_reg[23]) & 7)]; |
| 1054 | pattern = m_vram_space->read_byte(patterntbl_addr + ((charcode * 8) + |
| 1055 | ((line + m_cont_reg[23]) & 7))); |
| 1045 | 1056 | |
| 1046 | 1057 | if (_Width > 512) |
| 1047 | 1058 | { |
| r15546 | r15547 | |
| 1064 | 1075 | } |
| 1065 | 1076 | } |
| 1066 | 1077 | |
| 1067 | | pattern = patterntbl[(charcode * 8) + |
| 1068 | | ((line + m_cont_reg[23]) & 7)]; |
| 1078 | pattern = m_vram_space->read_byte(patterntbl_addr + ((charcode * 8) + |
| 1079 | ((line + m_cont_reg[23]) & 7))); |
| 1069 | 1080 | |
| 1070 | 1081 | if (_Width > 512) |
| 1071 | 1082 | { |
| r15546 | r15547 | |
| 1096 | 1107 | template<typename _PixelType, int _Width> |
| 1097 | 1108 | void v99x8_device::mode_multi(const pen_t *pens, _PixelType *ln, int line) |
| 1098 | 1109 | { |
| 1099 | | UINT8 *nametbl, *patterntbl, colour; |
| 1110 | int nametbl_addr, patterntbl_addr, colour; |
| 1100 | 1111 | int name, line2, x, xx; |
| 1101 | 1112 | _PixelType pen, pen_bg; |
| 1102 | 1113 | |
| 1103 | | nametbl = m_vram + (m_cont_reg[2] << 10); |
| 1104 | | patterntbl = m_vram + (m_cont_reg[4] << 11); |
| 1114 | nametbl_addr = (m_cont_reg[2] << 10); |
| 1115 | patterntbl_addr = (m_cont_reg[4] << 11); |
| 1105 | 1116 | |
| 1106 | 1117 | line2 = (line - m_cont_reg[23]) & 255; |
| 1107 | 1118 | name = (line2/8)*32; |
| r15546 | r15547 | |
| 1115 | 1126 | |
| 1116 | 1127 | for (x=0;x<32;x++) |
| 1117 | 1128 | { |
| 1118 | | colour = patterntbl[(nametbl[name] * 8) + ((line2/4)&7)]; |
| 1129 | colour = m_vram_space->read_byte(patterntbl_addr + (m_vram_space->read_byte(nametbl_addr + name) * 8) + ((line2/4)&7)); |
| 1119 | 1130 | pen = pens[m_pal_ind16[colour>>4]]; |
| 1120 | 1131 | /* eight pixels */ |
| 1121 | 1132 | *ln++ = pen; |
| r15546 | r15547 | |
| 1156 | 1167 | void v99x8_device::mode_graphic1(const pen_t *pens, _PixelType *ln, int line) |
| 1157 | 1168 | { |
| 1158 | 1169 | _PixelType fg, bg, pen; |
| 1159 | | UINT8 *nametbl, *patterntbl, *colourtbl; |
| 1170 | int nametbl_addr, patterntbl_addr, colourtbl_addr; |
| 1160 | 1171 | int pattern, x, xx, line2, name, charcode, colour, xxx; |
| 1161 | 1172 | |
| 1162 | | nametbl = m_vram + (m_cont_reg[2] << 10); |
| 1163 | | colourtbl = m_vram + (m_cont_reg[3] << 6) + (m_cont_reg[10] << 14); |
| 1164 | | patterntbl = m_vram + (m_cont_reg[4] << 11); |
| 1173 | nametbl_addr = (m_cont_reg[2] << 10); |
| 1174 | colourtbl_addr = (m_cont_reg[3] << 6) + (m_cont_reg[10] << 14); |
| 1175 | patterntbl_addr = (m_cont_reg[4] << 11); |
| 1165 | 1176 | |
| 1166 | 1177 | line2 = (line - m_cont_reg[23]) & 255; |
| 1167 | 1178 | |
| r15546 | r15547 | |
| 1176 | 1187 | |
| 1177 | 1188 | for (x=0;x<32;x++) |
| 1178 | 1189 | { |
| 1179 | | charcode = nametbl[name]; |
| 1180 | | colour = colourtbl[charcode/8]; |
| 1190 | charcode = m_vram_space->read_byte(nametbl_addr + name); |
| 1191 | colour = m_vram_space->read_byte(colourtbl_addr + charcode/8); |
| 1181 | 1192 | fg = pens[m_pal_ind16[colour>>4]]; |
| 1182 | 1193 | bg = pens[m_pal_ind16[colour&15]]; |
| 1183 | | pattern = patterntbl[charcode * 8 + (line2 & 7)]; |
| 1194 | pattern = m_vram_space->read_byte(patterntbl_addr + (charcode * 8 + (line2 & 7))); |
| 1184 | 1195 | |
| 1185 | 1196 | for (xx=0;xx<8;xx++) |
| 1186 | 1197 | { |
| r15546 | r15547 | |
| 1203 | 1214 | void v99x8_device::mode_graphic23(const pen_t *pens, _PixelType *ln, int line) |
| 1204 | 1215 | { |
| 1205 | 1216 | _PixelType fg, bg, pen; |
| 1206 | | UINT8 *nametbl, *patterntbl, *colourtbl; |
| 1217 | int nametbl_addr, patterntbl_addr, colourtbl_addr; |
| 1207 | 1218 | int pattern, x, xx, line2, name, charcode, |
| 1208 | | colour, colourmask, patternmask, xxx; |
| 1219 | colour, colourmask, patternmask, xxx; |
| 1209 | 1220 | |
| 1210 | 1221 | colourmask = (m_cont_reg[3] & 0x7f) * 8 | 7; |
| 1211 | 1222 | patternmask = (m_cont_reg[4] & 0x03) * 256 | (colourmask & 255); |
| 1212 | 1223 | |
| 1213 | | nametbl = m_vram + (m_cont_reg[2] << 10); |
| 1214 | | colourtbl = m_vram + ((m_cont_reg[3] & 0x80) << 6) + (m_cont_reg[10] << 14); |
| 1215 | | patterntbl = m_vram + ((m_cont_reg[4] & 0x3c) << 11); |
| 1224 | nametbl_addr = (m_cont_reg[2] << 10); |
| 1225 | colourtbl_addr = ((m_cont_reg[3] & 0x80) << 6) + (m_cont_reg[10] << 14); |
| 1226 | patterntbl_addr = ((m_cont_reg[4] & 0x3c) << 11); |
| 1216 | 1227 | |
| 1217 | 1228 | line2 = (line + m_cont_reg[23]) & 255; |
| 1218 | 1229 | name = (line2/8)*32; |
| r15546 | r15547 | |
| 1226 | 1237 | |
| 1227 | 1238 | for (x=0;x<32;x++) |
| 1228 | 1239 | { |
| 1229 | | charcode = nametbl[name] + (line2&0xc0)*4; |
| 1230 | | colour = colourtbl[(charcode&colourmask)*8+(line2&7)]; |
| 1231 | | pattern = patterntbl[(charcode&patternmask)*8+(line2&7)]; |
| 1232 | | fg = pens[m_pal_ind16[colour>>4]]; |
| 1233 | | bg = pens[m_pal_ind16[colour&15]]; |
| 1240 | charcode = m_vram_space->read_byte(nametbl_addr + name) + (line2&0xc0)*4; |
| 1241 | colour = m_vram_space->read_byte(colourtbl_addr + ((charcode&colourmask)*8+(line2&7))); |
| 1242 | pattern = m_vram_space->read_byte(patterntbl_addr + ((charcode&patternmask)*8+(line2&7))); |
| 1243 | fg = pens[m_pal_ind16[colour>>4]]; |
| 1244 | bg = pens[m_pal_ind16[colour&15]]; |
| 1234 | 1245 | for (xx=0;xx<8;xx++) |
| 1235 | 1246 | { |
| 1236 | 1247 | *ln++ = (pattern & 0x80) ? fg : bg; |
| 1237 | 1248 | if (_Width > 512) |
| 1238 | 1249 | *ln++ = (pattern & 0x80) ? fg : bg; |
| 1239 | | pattern <<= 1; |
| 1250 | pattern <<= 1; |
| 1240 | 1251 | } |
| 1241 | 1252 | name++; |
| 1242 | 1253 | } |
| r15546 | r15547 | |
| 1251 | 1262 | template<typename _PixelType, int _Width> |
| 1252 | 1263 | void v99x8_device::mode_graphic4(const pen_t *pens, _PixelType *ln, int line) |
| 1253 | 1264 | { |
| 1254 | | UINT8 *nametbl, colour; |
| 1265 | int nametbl_addr, colour; |
| 1255 | 1266 | int line2, linemask, x, xx; |
| 1256 | 1267 | _PixelType pen, pen_bg; |
| 1257 | 1268 | |
| r15546 | r15547 | |
| 1259 | 1270 | |
| 1260 | 1271 | line2 = ((line + m_cont_reg[23]) & linemask) & 255; |
| 1261 | 1272 | |
| 1262 | | nametbl = m_vram + ((m_cont_reg[2] & 0x40) << 10) + line2 * 128; |
| 1263 | | if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) ) |
| 1264 | | nametbl += 0x8000; |
| 1273 | nametbl_addr = ((m_cont_reg[2] & 0x40) << 10) + line2 * 128; |
| 1274 | if ( (m_cont_reg[2] & 0x20) && v9938_second_field() ) |
| 1275 | nametbl_addr += 0x8000; |
| 1265 | 1276 | |
| 1266 | 1277 | pen_bg = pens[m_pal_ind16[(m_cont_reg[7]&0x0f)]]; |
| 1267 | 1278 | if (_Width < 512) |
| r15546 | r15547 | |
| 1272 | 1283 | |
| 1273 | 1284 | for (x=0;x<128;x++) |
| 1274 | 1285 | { |
| 1275 | | colour = *nametbl++; |
| 1276 | | pen = pens[m_pal_ind16[colour>>4]]; |
| 1286 | colour = m_vram_space->read_byte(nametbl_addr++); |
| 1287 | pen = pens[m_pal_ind16[colour>>4]]; |
| 1277 | 1288 | *ln++ = pen; |
| 1278 | 1289 | if (_Width > 512) |
| 1279 | 1290 | *ln++ = pen; |
| 1280 | | pen = pens[m_pal_ind16[colour&15]]; |
| 1291 | pen = pens[m_pal_ind16[colour&15]]; |
| 1281 | 1292 | *ln++ = pen; |
| 1282 | 1293 | if (_Width > 512) |
| 1283 | 1294 | *ln++ = pen; |
| r15546 | r15547 | |
| 1293 | 1304 | template<typename _PixelType, int _Width> |
| 1294 | 1305 | void v99x8_device::mode_graphic5(const pen_t *pens, _PixelType *ln, int line) |
| 1295 | 1306 | { |
| 1296 | | UINT8 *nametbl, colour; |
| 1307 | int nametbl_addr, colour; |
| 1297 | 1308 | int line2, linemask, x, xx; |
| 1298 | 1309 | _PixelType pen_bg0[4]; |
| 1299 | 1310 | _PixelType pen_bg1[4]; |
| r15546 | r15547 | |
| 1302 | 1313 | |
| 1303 | 1314 | line2 = ((line + m_cont_reg[23]) & linemask) & 255; |
| 1304 | 1315 | |
| 1305 | | nametbl = m_vram + ((m_cont_reg[2] & 0x40) << 10) + line2 * 128; |
| 1306 | | if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) ) |
| 1307 | | nametbl += 0x8000; |
| 1316 | nametbl_addr = ((m_cont_reg[2] & 0x40) << 10) + line2 * 128; |
| 1317 | if ( (m_cont_reg[2] & 0x20) && v9938_second_field() ) |
| 1318 | nametbl_addr += 0x8000; |
| 1308 | 1319 | |
| 1309 | 1320 | if (_Width > 512) |
| 1310 | 1321 | { |
| r15546 | r15547 | |
| 1316 | 1327 | |
| 1317 | 1328 | x = (m_cont_reg[8] & 0x20) ? 0 : 1; |
| 1318 | 1329 | |
| 1319 | | for (;x<4;x++) |
| 1330 | for (;x<4;x++) |
| 1320 | 1331 | { |
| 1321 | 1332 | pen_bg0[x] = pens[m_pal_ind16[x]]; |
| 1322 | 1333 | pen_bg1[x] = pens[m_pal_ind16[x]]; |
| r15546 | r15547 | |
| 1324 | 1335 | |
| 1325 | 1336 | for (x=0;x<128;x++) |
| 1326 | 1337 | { |
| 1327 | | colour = *nametbl++; |
| 1338 | colour = m_vram_space->read_byte(nametbl_addr++); |
| 1328 | 1339 | |
| 1329 | | *ln++ = pen_bg0[colour>>6]; |
| 1340 | *ln++ = pen_bg0[colour>>6]; |
| 1330 | 1341 | *ln++ = pen_bg1[(colour>>4)&3]; |
| 1331 | | *ln++ = pen_bg0[(colour>>2)&3]; |
| 1332 | | *ln++ = pen_bg1[(colour&3)]; |
| 1342 | *ln++ = pen_bg0[(colour>>2)&3]; |
| 1343 | *ln++ = pen_bg1[(colour&3)]; |
| 1333 | 1344 | } |
| 1334 | 1345 | |
| 1335 | 1346 | pen_bg1[0] = pens[m_pal_ind16[(m_cont_reg[7]&0x03)]]; |
| r15546 | r15547 | |
| 1343 | 1354 | |
| 1344 | 1355 | x = (m_cont_reg[8] & 0x20) ? 0 : 1; |
| 1345 | 1356 | |
| 1346 | | for (;x<4;x++) |
| 1357 | for (;x<4;x++) |
| 1347 | 1358 | pen_bg0[x] = pens[m_pal_ind16[x]]; |
| 1348 | 1359 | |
| 1349 | 1360 | xx = m_offset_x; |
| r15546 | r15547 | |
| 1351 | 1362 | |
| 1352 | 1363 | for (x=0;x<128;x++) |
| 1353 | 1364 | { |
| 1354 | | colour = *nametbl++; |
| 1355 | | *ln++ = pen_bg0[colour>>6]; |
| 1356 | | *ln++ = pen_bg0[(colour>>2)&3]; |
| 1365 | colour = m_vram_space->read_byte(nametbl_addr++); |
| 1366 | *ln++ = pen_bg0[colour>>6]; |
| 1367 | *ln++ = pen_bg0[(colour>>2)&3]; |
| 1357 | 1368 | } |
| 1358 | 1369 | |
| 1359 | 1370 | pen_bg0[0] = pens[m_pal_ind16[((m_cont_reg[7]>>2)&0x03)]]; |
| r15546 | r15547 | |
| 1366 | 1377 | template<typename _PixelType, int _Width> |
| 1367 | 1378 | void v99x8_device::mode_graphic6(const pen_t *pens, _PixelType *ln, int line) |
| 1368 | 1379 | { |
| 1369 | | UINT8 colour; |
| 1370 | | int line2, linemask, x, xx, nametbl; |
| 1371 | | _PixelType pen_bg, fg0; |
| 1380 | UINT8 colour; |
| 1381 | int line2, linemask, x, xx, nametbl_addr; |
| 1382 | _PixelType pen_bg, fg0; |
| 1372 | 1383 | _PixelType fg1; |
| 1373 | 1384 | |
| 1374 | | linemask = ((m_cont_reg[2] & 0x1f) << 3) | 7; |
| 1385 | linemask = ((m_cont_reg[2] & 0x1f) << 3) | 7; |
| 1375 | 1386 | |
| 1376 | 1387 | line2 = ((line + m_cont_reg[23]) & linemask) & 255; |
| 1377 | 1388 | |
| 1378 | | nametbl = line2 << 8 ; |
| 1379 | | if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) ) |
| 1380 | | nametbl += 0x10000; |
| 1389 | nametbl_addr = line2 << 8 ; |
| 1390 | if ( (m_cont_reg[2] & 0x20) && v9938_second_field() ) |
| 1391 | nametbl_addr += 0x10000; |
| 1381 | 1392 | |
| 1382 | 1393 | pen_bg = pens[m_pal_ind16[(m_cont_reg[7]&0x0f)]]; |
| 1383 | 1394 | if (_Width < 512) |
| r15546 | r15547 | |
| 1390 | 1401 | { |
| 1391 | 1402 | for (x=0;x<32;x++) |
| 1392 | 1403 | { |
| 1393 | | nametbl++; |
| 1394 | | colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)]; |
| 1395 | | fg0 = pens[m_pal_ind16[colour>>4]]; |
| 1404 | nametbl_addr++; |
| 1405 | colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1)); |
| 1406 | fg0 = pens[m_pal_ind16[colour>>4]]; |
| 1396 | 1407 | if (_Width < 512) |
| 1397 | 1408 | { |
| 1398 | 1409 | *ln++ = fg0; *ln++ = fg0; |
| r15546 | r15547 | |
| 1402 | 1413 | } |
| 1403 | 1414 | else |
| 1404 | 1415 | { |
| 1405 | | fg1 = pens[m_pal_ind16[colour&15]]; |
| 1416 | fg1 = pens[m_pal_ind16[colour&15]]; |
| 1406 | 1417 | *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1; |
| 1407 | 1418 | *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1; |
| 1408 | 1419 | *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1; |
| 1409 | 1420 | *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1; |
| 1410 | 1421 | } |
| 1411 | | nametbl += 7; |
| 1422 | nametbl_addr += 7; |
| 1412 | 1423 | } |
| 1413 | 1424 | } |
| 1414 | 1425 | else |
| 1415 | 1426 | { |
| 1416 | 1427 | for (x=0;x<256;x++) |
| 1417 | 1428 | { |
| 1418 | | colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)]; |
| 1419 | | *ln++ = pens[m_pal_ind16[colour>>4]]; |
| 1429 | colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1)); |
| 1430 | *ln++ = pens[m_pal_ind16[colour>>4]]; |
| 1420 | 1431 | if (_Width > 512) |
| 1421 | | *ln++ = pens[m_pal_ind16[colour&15]]; |
| 1422 | | nametbl++; |
| 1423 | | } |
| 1432 | *ln++ = pens[m_pal_ind16[colour&15]]; |
| 1433 | nametbl_addr++; |
| 1434 | } |
| 1424 | 1435 | } |
| 1425 | 1436 | |
| 1426 | 1437 | xx = 16 - m_offset_x; |
| r15546 | r15547 | |
| 1433 | 1444 | template<typename _PixelType, int _Width> |
| 1434 | 1445 | void v99x8_device::mode_graphic7(const pen_t *pens, _PixelType *ln, int line) |
| 1435 | 1446 | { |
| 1436 | | UINT8 colour; |
| 1437 | | int line2, linemask, x, xx, nametbl; |
| 1438 | | _PixelType pen, pen_bg; |
| 1447 | UINT8 colour; |
| 1448 | int line2, linemask, x, xx, nametbl_addr; |
| 1449 | _PixelType pen, pen_bg; |
| 1439 | 1450 | |
| 1440 | 1451 | linemask = ((m_cont_reg[2] & 0x1f) << 3) | 7; |
| 1441 | 1452 | |
| 1442 | 1453 | line2 = ((line + m_cont_reg[23]) & linemask) & 255; |
| 1443 | 1454 | |
| 1444 | | nametbl = line2 << 8; |
| 1445 | | if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) ) |
| 1446 | | nametbl += 0x10000; |
| 1455 | nametbl_addr = line2 << 8; |
| 1456 | if ( (m_cont_reg[2] & 0x20) && v9938_second_field() ) |
| 1457 | nametbl_addr += 0x10000; |
| 1447 | 1458 | |
| 1448 | 1459 | pen_bg = pens[m_pal_ind256[m_cont_reg[7]]]; |
| 1449 | 1460 | if (_Width < 512) |
| r15546 | r15547 | |
| 1456 | 1467 | { |
| 1457 | 1468 | for (x=0;x<32;x++) |
| 1458 | 1469 | { |
| 1459 | | nametbl++; |
| 1460 | | colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)]; |
| 1470 | nametbl_addr++; |
| 1471 | colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1)); |
| 1461 | 1472 | pen = pens[m_pal_ind256[colour]]; |
| 1462 | 1473 | *ln++ = pen; *ln++ = pen; |
| 1463 | 1474 | *ln++ = pen; *ln++ = pen; |
| r15546 | r15547 | |
| 1470 | 1481 | *ln++ = pen; *ln++ = pen; |
| 1471 | 1482 | *ln++ = pen; *ln++ = pen; |
| 1472 | 1483 | } |
| 1473 | | nametbl++; |
| 1484 | nametbl_addr++; |
| 1474 | 1485 | } |
| 1475 | 1486 | } |
| 1476 | 1487 | else |
| 1477 | 1488 | { |
| 1478 | 1489 | for (x=0;x<256;x++) |
| 1479 | | { |
| 1480 | | colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)]; |
| 1490 | { |
| 1491 | colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1)); |
| 1481 | 1492 | pen = pens[m_pal_ind256[colour]]; |
| 1482 | 1493 | *ln++ = pen; |
| 1483 | 1494 | if (_Width > 512) |
| 1484 | 1495 | *ln++ = pen; |
| 1485 | | nametbl++; |
| 1486 | | } |
| 1496 | nametbl_addr++; |
| 1497 | } |
| 1487 | 1498 | } |
| 1488 | 1499 | |
| 1489 | 1500 | xx = 16 - m_offset_x; |
| r15546 | r15547 | |
| 1499 | 1510 | _PixelType fg, bg; |
| 1500 | 1511 | int x; |
| 1501 | 1512 | |
| 1502 | | fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]]; |
| 1503 | | bg = pens[m_pal_ind16[m_cont_reg[7] & 15]]; |
| 1513 | fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]]; |
| 1514 | bg = pens[m_pal_ind16[m_cont_reg[7] & 15]]; |
| 1504 | 1515 | |
| 1505 | 1516 | if (_Width < 512) |
| 1506 | 1517 | { |
| r15546 | r15547 | |
| 1586 | 1597 | { |
| 1587 | 1598 | static const UINT16 g7_ind16[16] = { |
| 1588 | 1599 | 0, 2, 192, 194, 48, 50, 240, 242, |
| 1589 | | 482, 7, 448, 455, 56, 63, 504, 511 }; |
| 1600 | 482, 7, 448, 455, 56, 63, 504, 511 }; |
| 1590 | 1601 | int i; |
| 1591 | 1602 | |
| 1592 | 1603 | if (_Width > 512) |
| r15546 | r15547 | |
| 1615 | 1626 | |
| 1616 | 1627 | void v99x8_device::sprite_mode1 (int line, UINT8 *col) |
| 1617 | 1628 | { |
| 1618 | | UINT8 *attrtbl, *patterntbl, *patternptr; |
| 1629 | int attrtbl_addr, patterntbl_addr, pattern_addr; |
| 1619 | 1630 | int x, y, p, height, c, p2, i, n, pattern; |
| 1620 | 1631 | |
| 1621 | | memset (col, 0, 256); |
| 1632 | memset(col, 0, 256); |
| 1622 | 1633 | |
| 1623 | 1634 | // are sprites disabled? |
| 1624 | 1635 | if (m_cont_reg[8] & 0x02) return; |
| 1625 | 1636 | |
| 1626 | | attrtbl = m_vram + (m_cont_reg[5] << 7) + (m_cont_reg[11] << 15); |
| 1627 | | patterntbl = m_vram + (m_cont_reg[6] << 11); |
| 1637 | attrtbl_addr = (m_cont_reg[5] << 7) + (m_cont_reg[11] << 15); |
| 1638 | patterntbl_addr = (m_cont_reg[6] << 11); |
| 1628 | 1639 | |
| 1629 | 1640 | // 16x16 or 8x8 sprites |
| 1630 | 1641 | height = (m_cont_reg[1] & 2) ? 16 : 8; |
| r15546 | r15547 | |
| 1634 | 1645 | p2 = p = 0; |
| 1635 | 1646 | while (1) |
| 1636 | 1647 | { |
| 1637 | | y = attrtbl[0]; |
| 1648 | y = m_vram_space->read_byte(attrtbl_addr); |
| 1638 | 1649 | if (y == 208) break; |
| 1639 | 1650 | y = (y - m_cont_reg[23]) & 255; |
| 1640 | 1651 | if (y > 208) |
| r15546 | r15547 | |
| 1654 | 1665 | if (m_sprite_limit) break; |
| 1655 | 1666 | } |
| 1656 | 1667 | // get x |
| 1657 | | x = attrtbl[1]; |
| 1658 | | if (attrtbl[3] & 0x80) x -= 32; |
| 1668 | x = m_vram_space->read_byte(attrtbl_addr + 1); |
| 1669 | if (m_vram_space->read_byte(attrtbl_addr + 3) & 0x80) x -= 32; |
| 1659 | 1670 | |
| 1660 | 1671 | // get pattern |
| 1661 | | pattern = attrtbl[2]; |
| 1672 | pattern = m_vram_space->read_byte(attrtbl_addr + 2); |
| 1662 | 1673 | if (m_cont_reg[1] & 2) |
| 1663 | 1674 | pattern &= 0xfc; |
| 1664 | 1675 | n = line - y; |
| 1665 | | patternptr = patterntbl + pattern * 8 + |
| 1666 | | ((m_cont_reg[1] & 1) ? n/2 : n); |
| 1667 | | pattern = patternptr[0] << 8 | patternptr[16]; |
| 1676 | pattern_addr = patterntbl_addr + pattern * 8 + ((m_cont_reg[1] & 1) ? n/2 : n); |
| 1677 | pattern = (m_vram_space->read_byte(pattern_addr) << 8) | m_vram_space->read_byte(pattern_addr+16); |
| 1668 | 1678 | |
| 1669 | 1679 | // get colour |
| 1670 | | c = attrtbl[3] & 0x0f; |
| 1680 | c = m_vram_space->read_byte(attrtbl_addr + 3) & 0x0f; |
| 1671 | 1681 | |
| 1672 | 1682 | // draw left part |
| 1673 | 1683 | n = 0; |
| 1674 | 1684 | while (1) |
| 1675 | 1685 | { |
| 1676 | | if (n == 0) pattern = patternptr[0]; |
| 1677 | | else if ( (n == 1) && (m_cont_reg[1] & 2) ) pattern = patternptr[16]; |
| 1686 | if (n == 0) pattern = m_vram_space->read_byte(pattern_addr); |
| 1687 | else if ( (n == 1) && (m_cont_reg[1] & 2) ) pattern = m_vram_space->read_byte(pattern_addr + 16); |
| 1678 | 1688 | else break; |
| 1679 | 1689 | |
| 1680 | 1690 | n++; |
| r15546 | r15547 | |
| 1703 | 1713 | if (m_cont_reg[1] & 1) |
| 1704 | 1714 | { |
| 1705 | 1715 | if (col[x+1] & 0x40) |
| 1706 | | { |
| 1707 | | // we have a collision! |
| 1716 | { |
| 1717 | // we have a collision! |
| 1708 | 1718 | if (p2 < 4) |
| 1709 | 1719 | m_stat_reg[0] |= 0x20; |
| 1710 | | } |
| 1711 | | if ( !(col[x+1] & 0x80) ) |
| 1712 | | { |
| 1713 | | if (c || (m_cont_reg[8] & 0x20) ) |
| 1720 | } |
| 1721 | if ( !(col[x+1] & 0x80) ) |
| 1722 | { |
| 1723 | if (c || (m_cont_reg[8] & 0x20) ) |
| 1714 | 1724 | col[x+1] |= 0xc0 | c; |
| 1715 | 1725 | else |
| 1716 | 1726 | col[x+1] |= 0x80; |
| 1717 | | } |
| 1727 | } |
| 1718 | 1728 | } |
| 1719 | 1729 | } |
| 1720 | 1730 | } |
| r15546 | r15547 | |
| 1728 | 1738 | |
| 1729 | 1739 | if (p >= 31) break; |
| 1730 | 1740 | p++; |
| 1731 | | attrtbl += 4; |
| 1741 | attrtbl_addr += 4; |
| 1732 | 1742 | } |
| 1733 | 1743 | |
| 1734 | 1744 | if ( !(m_stat_reg[0] & 0x40) ) |
| r15546 | r15547 | |
| 1737 | 1747 | |
| 1738 | 1748 | void v99x8_device::sprite_mode2 (int line, UINT8 *col) |
| 1739 | 1749 | { |
| 1740 | | int attrtbl, patterntbl, patternptr, colourtbl; |
| 1750 | int attrtbl_addr, patterntbl_addr, pattern_addr, colourtbl_addr; |
| 1741 | 1751 | int x, i, y, p, height, c, p2, n, pattern, colourmask, first_cc_seen; |
| 1742 | 1752 | |
| 1743 | | memset (col, 0, 256); |
| 1753 | memset(col, 0, 256); |
| 1744 | 1754 | |
| 1745 | 1755 | // are sprites disabled? |
| 1746 | 1756 | if (m_cont_reg[8] & 0x02) return; |
| 1747 | 1757 | |
| 1748 | | attrtbl = ( (m_cont_reg[5] & 0xfc) << 7) + (m_cont_reg[11] << 15); |
| 1749 | | colourtbl = ( (m_cont_reg[5] & 0xf8) << 7) + (m_cont_reg[11] << 15); |
| 1750 | | patterntbl = (m_cont_reg[6] << 11); |
| 1758 | attrtbl_addr = ( (m_cont_reg[5] & 0xfc) << 7) + (m_cont_reg[11] << 15); |
| 1759 | colourtbl_addr = ( (m_cont_reg[5] & 0xf8) << 7) + (m_cont_reg[11] << 15); |
| 1760 | patterntbl_addr = (m_cont_reg[6] << 11); |
| 1751 | 1761 | colourmask = ( (m_cont_reg[5] & 3) << 3) | 0x7; // check this! |
| 1752 | 1762 | |
| 1753 | 1763 | // 16x16 or 8x8 sprites |
| r15546 | r15547 | |
| 1758 | 1768 | p2 = p = first_cc_seen = 0; |
| 1759 | 1769 | while (1) |
| 1760 | 1770 | { |
| 1761 | | y = vram_read (attrtbl); |
| 1771 | y = vram_read(attrtbl_addr); |
| 1762 | 1772 | if (y == 216) break; |
| 1763 | 1773 | y = (y - m_cont_reg[23]) & 255; |
| 1764 | 1774 | if (y > 216) |
| r15546 | r15547 | |
| 1780 | 1790 | |
| 1781 | 1791 | n = line - y; if (m_cont_reg[1] & 1) n /= 2; |
| 1782 | 1792 | // get colour |
| 1783 | | c = vram_read (colourtbl + (((p&colourmask)*16) + n)); |
| 1793 | c = vram_read(colourtbl_addr + (((p&colourmask)*16) + n)); |
| 1784 | 1794 | |
| 1785 | 1795 | // don't draw all sprite with CC set before any sprites |
| 1786 | | // with CC = 0 are seen on this line |
| 1796 | // with CC = 0 are seen on this line |
| 1787 | 1797 | if (c & 0x40) |
| 1788 | 1798 | { |
| 1789 | 1799 | if (!first_cc_seen) |
| r15546 | r15547 | |
| 1793 | 1803 | first_cc_seen = 1; |
| 1794 | 1804 | |
| 1795 | 1805 | // get pattern |
| 1796 | | pattern = vram_read (attrtbl + 2); |
| 1806 | pattern = vram_read(attrtbl_addr + 2); |
| 1797 | 1807 | if (m_cont_reg[1] & 2) |
| 1798 | 1808 | pattern &= 0xfc; |
| 1799 | | patternptr = patterntbl + pattern * 8 + n; |
| 1800 | | pattern = (vram_read (patternptr) << 8) | |
| 1801 | | vram_read (patternptr + 16); |
| 1809 | pattern_addr = patterntbl_addr + pattern * 8 + n; |
| 1810 | pattern = (vram_read(pattern_addr) << 8) | vram_read(pattern_addr + 16); |
| 1802 | 1811 | |
| 1803 | 1812 | // get x |
| 1804 | | x = vram_read (attrtbl + 1); |
| 1813 | x = vram_read(attrtbl_addr + 1); |
| 1805 | 1814 | if (c & 0x80) x -= 32; |
| 1806 | 1815 | |
| 1807 | 1816 | n = (m_cont_reg[1] & 2) ? 16 : 8; |
| r15546 | r15547 | |
| 1852 | 1861 | pattern <<= 1; |
| 1853 | 1862 | } |
| 1854 | 1863 | |
| 1855 | | skip_first_cc_set: |
| 1864 | skip_first_cc_set: |
| 1856 | 1865 | p2++; |
| 1857 | 1866 | } |
| 1858 | 1867 | |
| 1859 | 1868 | if (p >= 31) break; |
| 1860 | 1869 | p++; |
| 1861 | | attrtbl += 4; |
| 1870 | attrtbl_addr += 4; |
| 1862 | 1871 | } |
| 1863 | 1872 | |
| 1864 | 1873 | if ( !(m_stat_reg[0] & 0x40) ) |
| r15546 | r15547 | |
| 1876 | 1885 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1877 | 1886 | NULL, |
| 1878 | 1887 | NULL, |
| 1879 | | NULL }, |
| 1888 | NULL }, |
| 1880 | 1889 | { 0x01, |
| 1881 | 1890 | &v99x8_device::mode_multi<UINT16, LONG_WIDTH>, |
| 1882 | 1891 | &v99x8_device::mode_multi<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1884 | 1893 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1885 | 1894 | &v99x8_device::sprite_mode1, |
| 1886 | 1895 | &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>, |
| 1887 | | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1896 | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1888 | 1897 | { 0x00, |
| 1889 | 1898 | &v99x8_device::mode_graphic1<UINT16, LONG_WIDTH>, |
| 1890 | 1899 | &v99x8_device::mode_graphic1<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1892 | 1901 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1893 | 1902 | &v99x8_device::sprite_mode1, |
| 1894 | 1903 | &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>, |
| 1895 | | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1904 | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1896 | 1905 | { 0x04, |
| 1897 | 1906 | &v99x8_device::mode_graphic23<UINT16, LONG_WIDTH>, |
| 1898 | 1907 | &v99x8_device::mode_graphic23<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1900 | 1909 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1901 | 1910 | &v99x8_device::sprite_mode1, |
| 1902 | 1911 | &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>, |
| 1903 | | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1912 | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1904 | 1913 | { 0x08, |
| 1905 | 1914 | &v99x8_device::mode_graphic23<UINT16, LONG_WIDTH>, |
| 1906 | 1915 | &v99x8_device::mode_graphic23<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1908 | 1917 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1909 | 1918 | &v99x8_device::sprite_mode2, |
| 1910 | 1919 | &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>, |
| 1911 | | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1920 | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1912 | 1921 | { 0x0c, |
| 1913 | 1922 | &v99x8_device::mode_graphic4<UINT16, LONG_WIDTH>, |
| 1914 | 1923 | &v99x8_device::mode_graphic4<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1916 | 1925 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1917 | 1926 | &v99x8_device::sprite_mode2, |
| 1918 | 1927 | &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>, |
| 1919 | | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1928 | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1920 | 1929 | { 0x10, |
| 1921 | 1930 | &v99x8_device::mode_graphic5<UINT16, LONG_WIDTH>, |
| 1922 | 1931 | &v99x8_device::mode_graphic5<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1924 | 1933 | &v99x8_device::graphic5_border<UINT16, SHORT_WIDTH>, |
| 1925 | 1934 | &v99x8_device::sprite_mode2, |
| 1926 | 1935 | &v99x8_device::graphic5_draw_sprite<UINT16, LONG_WIDTH>, |
| 1927 | | &v99x8_device::graphic5_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1936 | &v99x8_device::graphic5_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1928 | 1937 | { 0x14, |
| 1929 | 1938 | &v99x8_device::mode_graphic6<UINT16, LONG_WIDTH>, |
| 1930 | 1939 | &v99x8_device::mode_graphic6<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1932 | 1941 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1933 | 1942 | &v99x8_device::sprite_mode2, |
| 1934 | 1943 | &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>, |
| 1935 | | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1944 | &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1936 | 1945 | { 0x1c, |
| 1937 | 1946 | &v99x8_device::mode_graphic7<UINT16, LONG_WIDTH>, |
| 1938 | 1947 | &v99x8_device::mode_graphic7<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1940 | 1949 | &v99x8_device::graphic7_border<UINT16, SHORT_WIDTH>, |
| 1941 | 1950 | &v99x8_device::sprite_mode2, |
| 1942 | 1951 | &v99x8_device::graphic7_draw_sprite<UINT16, LONG_WIDTH>, |
| 1943 | | &v99x8_device::graphic7_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1952 | &v99x8_device::graphic7_draw_sprite<UINT16, SHORT_WIDTH> }, |
| 1944 | 1953 | { 0x0a, |
| 1945 | 1954 | &v99x8_device::mode_text2<UINT16, LONG_WIDTH>, |
| 1946 | 1955 | &v99x8_device::mode_text2<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1948 | 1957 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1949 | 1958 | NULL, |
| 1950 | 1959 | NULL, |
| 1951 | | NULL }, |
| 1960 | NULL }, |
| 1952 | 1961 | { 0xff, |
| 1953 | 1962 | &v99x8_device::mode_unknown<UINT16, LONG_WIDTH>, |
| 1954 | 1963 | &v99x8_device::mode_unknown<UINT16, SHORT_WIDTH>, |
| r15546 | r15547 | |
| 1956 | 1965 | &v99x8_device::default_border<UINT16, SHORT_WIDTH>, |
| 1957 | 1966 | NULL, |
| 1958 | 1967 | NULL, |
| 1959 | | NULL }, |
| 1968 | NULL }, |
| 1960 | 1969 | }; |
| 1961 | 1970 | |
| 1962 | | void v99x8_device::set_mode () |
| 1971 | void v99x8_device::set_mode() |
| 1963 | 1972 | { |
| 1964 | 1973 | int n,i; |
| 1965 | 1974 | |
| r15546 | r15547 | |
| 1971 | 1980 | m_mode = i; |
| 1972 | 1981 | } |
| 1973 | 1982 | |
| 1974 | | void v99x8_device::refresh_16 (int line) |
| 1983 | void v99x8_device::refresh_16(int line) |
| 1975 | 1984 | { |
| 1976 | 1985 | const pen_t *pens = machine().pens; |
| 1977 | 1986 | int i, double_lines; |
| r15546 | r15547 | |
| 2031 | 2040 | memcpy (ln2, ln, (512 + 32) * 2); |
| 2032 | 2041 | } |
| 2033 | 2042 | |
| 2034 | | void v99x8_device::refresh_line (int line) |
| 2043 | void v99x8_device::refresh_line(int line) |
| 2035 | 2044 | { |
| 2036 | 2045 | int ind16, ind256; |
| 2037 | 2046 | |
| r15546 | r15547 | |
| 2158 | 2167 | have to test. |
| 2159 | 2168 | */ |
| 2160 | 2169 | |
| 2161 | | void v99x8_device::interrupt_start_vblank () |
| 2170 | void v99x8_device::interrupt_start_vblank() |
| 2162 | 2171 | { |
| 2163 | | #if 0 |
| 2172 | #if 0 |
| 2164 | 2173 | if (machine.input().code_pressed (KEYCODE_D) ) |
| 2165 | 2174 | { |
| 2166 | | FILE *fp; |
| 2167 | | int i; |
| 2168 | | |
| 2169 | | fp = fopen ("vram.dmp", "wb"); |
| 2170 | | if (fp) |
| 2171 | | { |
| 2172 | | fwrite (m_vram, 0x10000, 1, fp); |
| 2173 | | fclose (fp); |
| 2174 | | popmessage("saved"); |
| 2175 | | } |
| 2176 | | |
| 2177 | 2175 | for (i=0;i<24;i++) mame_printf_debug ("R#%d = %02x\n", i, m_cont_reg[i]); |
| 2178 | 2176 | } |
| 2179 | | #endif |
| 2177 | #endif |
| 2180 | 2178 | |
| 2181 | 2179 | // at every frame, vdp switches fields |
| 2182 | 2180 | m_stat_reg[2] = (m_stat_reg[2] & 0xfd) | (~m_stat_reg[2] & 2); |
| r15546 | r15547 | |
| 2220 | 2218 | |
| 2221 | 2219 | /*************************************************************************** |
| 2222 | 2220 | |
| 2223 | | Command unit |
| 2221 | Command unit |
| 2224 | 2222 | |
| 2225 | 2223 | ***************************************************************************/ |
| 2226 | 2224 | |
| 2227 | | #define VDP m_cont_reg |
| 2228 | | #define VDPStatus m_stat_reg |
| 2229 | | #define VRAM m_vram |
| 2230 | | #define VRAM_EXP m_vram_exp |
| 2231 | | #define ScrMode m_mode |
| 2232 | | |
| 2233 | 2225 | /*************************************************************/ |
| 2234 | 2226 | /** Completely rewritten by Alex Wulms: **/ |
| 2235 | 2227 | /** - VDP Command execution 'in parallel' with CPU **/ |
| r15546 | r15547 | |
| 2248 | 2240 | /** Public release 1.0: 20-04-2000 **/ |
| 2249 | 2241 | /*************************************************************/ |
| 2250 | 2242 | |
| 2251 | | #define VDP_VRMP5(MX, X, Y) ((!MX) ? (VRAM + ((Y&1023)<<7) + ((X&255)>>1)) : (VRAM_EXP + ((Y&511)<<7) + ((X&255)>>1))) |
| 2252 | | #define VDP_VRMP6(MX, X, Y) ((!MX) ? (VRAM + ((Y&1023)<<7) + ((X&511)>>2)) : (VRAM_EXP + ((Y&511)<<7) + ((X&511)>>2))) |
| 2253 | | //#define VDP_VRMP7(MX, X, Y) ((!MX) ? (VRAM + ((Y&511)<<8) + ((X&511)>>1)) : (VRAM_EXP + ((Y&255)<<8) + ((X&511)>>1))) |
| 2254 | | #define VDP_VRMP7(MX, X, Y) ((!MX) ? (VRAM + ((X&2)<<15) + ((Y&511)<<7) + ((X&511)>>2)) : (VRAM_EXP + ((Y&511)<<7) + ((X&511)>>2))/*(VRAM_EXP + ((Y&255)<<8) + ((X&511)>>1))*/) |
| 2255 | | //#define VDP_VRMP8(MX, X, Y) ((!MX) ? (VRAM + ((Y&511)<<8) + (X&255)) : (VRAM_EXP + ((Y&255)<<8) + (X&255))) |
| 2256 | | #define VDP_VRMP8(MX, X, Y) ((!MX) ? (VRAM + ((X&1)<<16) + ((Y&511)<<7) + ((X>>1)&127)) : (VRAM_EXP + ((Y&511)<<7) + ((X>>1)&127))/*(VRAM_EXP + ((Y&255)<<8) + (X&255))*/) |
| 2243 | #define VDP_VRMP5(MX, X, Y) ((!MX) ? (((Y&1023)<<7) + ((X&255)>>1)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X&255)>>1))) |
| 2244 | #define VDP_VRMP6(MX, X, Y) ((!MX) ? (((Y&1023)<<7) + ((X&511)>>2)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X&511)>>2))) |
| 2245 | //#define VDP_VRMP7(MX, X, Y) ((!MX) ? (((Y&511)<<8) + ((X&511)>>1)) : (EXPMEM_OFFSET + ((Y&255)<<8) + ((X&511)>>1))) |
| 2246 | #define VDP_VRMP7(MX, X, Y) ((!MX) ? (((X&2)<<15) + ((Y&511)<<7) + ((X&511)>>2)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X&511)>>2))/*(EXPMEM_OFFSET + ((Y&255)<<8) + ((X&511)>>1))*/) |
| 2247 | //#define VDP_VRMP8(MX, X, Y) ((!MX) ? (((Y&511)<<8) + (X&255)) : (EXPMEM_OFFSET + ((Y&255)<<8) + (X&255))) |
| 2248 | #define VDP_VRMP8(MX, X, Y) ((!MX) ? (((X&1)<<16) + ((Y&511)<<7) + ((X>>1)&127)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X>>1)&127))/*(EXPMEM_OFFSET + ((Y&255)<<8) + (X&255))*/) |
| 2257 | 2249 | |
| 2258 | 2250 | #define VDP_VRMP(M, MX, X, Y) VDPVRMP(M, MX, X, Y) |
| 2259 | 2251 | #define VDP_POINT(M, MX, X, Y) VDPpoint(M, MX, X, Y) |
| r15546 | r15547 | |
| 2273 | 2265 | #define CM_YMMM 0xE |
| 2274 | 2266 | #define CM_HMMC 0xF |
| 2275 | 2267 | |
| 2276 | | /*************************************************************/ |
| 2277 | | // Many VDP commands are executed in some kind of loop but |
| 2278 | | // essentially, there are only a few basic loop structures |
| 2279 | | // that are re-used. We define the loop structures that are |
| 2280 | | // re-used here so that they have to be entered only once |
| 2281 | | /*************************************************************/ |
| 2268 | /************************************************************* |
| 2269 | Many VDP commands are executed in some kind of loop but |
| 2270 | essentially, there are only a few basic loop structures |
| 2271 | that are re-used. We define the loop structures that are |
| 2272 | re-used here so that they have to be entered only once |
| 2273 | *************************************************************/ |
| 2282 | 2274 | #define pre_loop \ |
| 2283 | | while ((cnt-=delta) > 0) { |
| 2275 | while ((cnt-=delta) > 0) { |
| 2284 | 2276 | |
| 2285 | | #define post_loop \ |
| 2286 | | } |
| 2277 | #define post_loop \ |
| 2278 | } |
| 2287 | 2279 | |
| 2288 | 2280 | // Loop over DX, DY |
| 2289 | 2281 | #define post__x_y(MX) \ |
| 2290 | | if (!--ANX || ((ADX+=TX)&MX)) { \ |
| 2291 | | if (!(--NY&1023) || (DY+=TY)==-1) \ |
| 2282 | if (!--ANX || ((ADX+=TX)&MX)) { \ |
| 2283 | if (!(--NY&1023) || (DY+=TY)==-1) \ |
| 2292 | 2284 | break; \ |
| 2293 | | else { \ |
| 2285 | else { \ |
| 2294 | 2286 | ADX=DX; \ |
| 2295 | 2287 | ANX=NX; \ |
| 2296 | | } \ |
| 2297 | 2288 | } \ |
| 2298 | | post_loop |
| 2289 | } \ |
| 2290 | post_loop |
| 2299 | 2291 | |
| 2300 | 2292 | // Loop over DX, SY, DY |
| 2301 | 2293 | #define post__xyy(MX) \ |
| 2302 | | if ((ADX+=TX)&MX) { \ |
| 2303 | | if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \ |
| 2294 | if ((ADX+=TX)&MX) { \ |
| 2295 | if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \ |
| 2304 | 2296 | break; \ |
| 2305 | | else \ |
| 2297 | else \ |
| 2306 | 2298 | ADX=DX; \ |
| 2307 | | } \ |
| 2308 | | post_loop |
| 2299 | } \ |
| 2300 | post_loop |
| 2309 | 2301 | |
| 2310 | 2302 | // Loop over SX, DX, SY, DY |
| 2311 | 2303 | #define post_xxyy(MX) \ |
| 2312 | | if (!--ANX || ((ASX+=TX)&MX) || ((ADX+=TX)&MX)) { \ |
| 2313 | | if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \ |
| 2304 | if (!--ANX || ((ASX+=TX)&MX) || ((ADX+=TX)&MX)) { \ |
| 2305 | if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \ |
| 2314 | 2306 | break; \ |
| 2315 | | else { \ |
| 2307 | else { \ |
| 2316 | 2308 | ASX=SX; \ |
| 2317 | 2309 | ADX=DX; \ |
| 2318 | 2310 | ANX=NX; \ |
| 2319 | | } \ |
| 2320 | 2311 | } \ |
| 2321 | | post_loop |
| 2312 | } \ |
| 2313 | post_loop |
| 2322 | 2314 | |
| 2323 | 2315 | /*************************************************************/ |
| 2324 | 2316 | /** Variables visible only in this module **/ |
| r15546 | r15547 | |
| 2330 | 2322 | // SprOn SprOn SprOf SprOf |
| 2331 | 2323 | // ScrOf ScrOn ScrOf ScrOn |
| 2332 | 2324 | static const int srch_timing[8]={ |
| 2333 | | 818, 1025, 818, 830, // ntsc |
| 2334 | | 696, 854, 696, 684 // pal |
| 2325 | 818, 1025, 818, 830, // ntsc |
| 2326 | 696, 854, 696, 684 // pal |
| 2335 | 2327 | }; |
| 2336 | 2328 | static const int line_timing[8]={ |
| 2337 | | 1063, 1259, 1063, 1161, |
| 2338 | | 904, 1026, 904, 953 |
| 2329 | 1063, 1259, 1063, 1161, |
| 2330 | 904, 1026, 904, 953 |
| 2339 | 2331 | }; |
| 2340 | 2332 | static const int hmmv_timing[8]={ |
| 2341 | | 439, 549, 439, 531, |
| 2342 | | 366, 439, 366, 427 |
| 2333 | 439, 549, 439, 531, |
| 2334 | 366, 439, 366, 427 |
| 2343 | 2335 | }; |
| 2344 | 2336 | static const int lmmv_timing[8]={ |
| 2345 | | 873, 1135, 873, 1056, |
| 2346 | | 732, 909, 732, 854 |
| 2337 | 873, 1135, 873, 1056, |
| 2338 | 732, 909, 732, 854 |
| 2347 | 2339 | }; |
| 2348 | 2340 | static const int ymmm_timing[8]={ |
| 2349 | | 586, 952, 586, 610, |
| 2350 | | 488, 720, 488, 500 |
| 2341 | 586, 952, 586, 610, |
| 2342 | 488, 720, 488, 500 |
| 2351 | 2343 | }; |
| 2352 | 2344 | static const int hmmm_timing[8]={ |
| 2353 | | 818, 1111, 818, 854, |
| 2354 | | 684, 879, 684, 708 |
| 2345 | 818, 1111, 818, 854, |
| 2346 | 684, 879, 684, 708 |
| 2355 | 2347 | }; |
| 2356 | 2348 | static const int lmmm_timing[8]={ |
| 2357 | | 1160, 1599, 1160, 1172, |
| 2358 | | 964, 1257, 964, 977 |
| 2349 | 1160, 1599, 1160, 1172, |
| 2350 | 964, 1257, 964, 977 |
| 2359 | 2351 | }; |
| 2360 | 2352 | |
| 2361 | 2353 | /** VDPVRMP() **********************************************/ |
| 2362 | 2354 | /** Calculate addr of a pixel in vram **/ |
| 2363 | 2355 | /*************************************************************/ |
| 2364 | | inline UINT8 *v99x8_device::VDPVRMP(UINT8 M,int MX,int X,int Y) |
| 2356 | inline int v99x8_device::VDPVRMP(UINT8 M,int MX,int X,int Y) |
| 2365 | 2357 | { |
| 2366 | | switch(M) |
| 2367 | | { |
| 2368 | | case 0: return VDP_VRMP5(MX,X,Y); |
| 2369 | | case 1: return VDP_VRMP6(MX,X,Y); |
| 2370 | | case 2: return VDP_VRMP7(MX,X,Y); |
| 2371 | | case 3: return VDP_VRMP8(MX,X,Y); |
| 2372 | | } |
| 2358 | switch(M) |
| 2359 | { |
| 2360 | case 0: return VDP_VRMP5(MX,X,Y); |
| 2361 | case 1: return VDP_VRMP6(MX,X,Y); |
| 2362 | case 2: return VDP_VRMP7(MX,X,Y); |
| 2363 | case 3: return VDP_VRMP8(MX,X,Y); |
| 2364 | } |
| 2373 | 2365 | |
| 2374 | | return(VRAM); |
| 2366 | return 0; |
| 2375 | 2367 | } |
| 2376 | 2368 | |
| 2377 | 2369 | /** VDPpoint5() ***********************************************/ |
| r15546 | r15547 | |
| 2379 | 2371 | /*************************************************************/ |
| 2380 | 2372 | inline UINT8 v99x8_device::VDPpoint5(int MXS, int SX, int SY) |
| 2381 | 2373 | { |
| 2382 | | return (*VDP_VRMP5(MXS, SX, SY) >> |
| 2383 | | (((~SX)&1)<<2) |
| 2384 | | )&15; |
| 2374 | return (m_vram_space->read_byte(VDP_VRMP5(MXS, SX, SY)) >> |
| 2375 | (((~SX)&1)<<2) |
| 2376 | )&15; |
| 2385 | 2377 | } |
| 2386 | 2378 | |
| 2387 | 2379 | /** VDPpoint6() ***********************************************/ |
| r15546 | r15547 | |
| 2389 | 2381 | /*************************************************************/ |
| 2390 | 2382 | inline UINT8 v99x8_device::VDPpoint6(int MXS, int SX, int SY) |
| 2391 | 2383 | { |
| 2392 | | return (*VDP_VRMP6(MXS, SX, SY) >> |
| 2393 | | (((~SX)&3)<<1) |
| 2394 | | )&3; |
| 2384 | return (m_vram_space->read_byte(VDP_VRMP6(MXS, SX, SY)) >> |
| 2385 | (((~SX)&3)<<1) |
| 2386 | )&3; |
| 2395 | 2387 | } |
| 2396 | 2388 | |
| 2397 | 2389 | /** VDPpoint7() ***********************************************/ |
| r15546 | r15547 | |
| 2399 | 2391 | /*************************************************************/ |
| 2400 | 2392 | inline UINT8 v99x8_device::VDPpoint7(int MXS, int SX, int SY) |
| 2401 | 2393 | { |
| 2402 | | return (*VDP_VRMP7(MXS, SX, SY) >> |
| 2403 | | (((~SX)&1)<<2) |
| 2404 | | )&15; |
| 2394 | return (m_vram_space->read_byte(VDP_VRMP7(MXS, SX, SY)) >> |
| 2395 | (((~SX)&1)<<2) |
| 2396 | )&15; |
| 2405 | 2397 | } |
| 2406 | 2398 | |
| 2407 | 2399 | /** VDPpoint8() ***********************************************/ |
| r15546 | r15547 | |
| 2409 | 2401 | /*************************************************************/ |
| 2410 | 2402 | inline UINT8 v99x8_device::VDPpoint8(int MXS, int SX, int SY) |
| 2411 | 2403 | { |
| 2412 | | return *VDP_VRMP8(MXS, SX, SY); |
| 2404 | return m_vram_space->read_byte(VDP_VRMP8(MXS, SX, SY)); |
| 2413 | 2405 | } |
| 2414 | 2406 | |
| 2415 | 2407 | /** VDPpoint() ************************************************/ |
| r15546 | r15547 | |
| 2417 | 2409 | /*************************************************************/ |
| 2418 | 2410 | inline UINT8 v99x8_device::VDPpoint(UINT8 SM, int MXS, int SX, int SY) |
| 2419 | 2411 | { |
| 2420 | | switch(SM) |
| 2421 | | { |
| 2422 | | case 0: return VDPpoint5(MXS,SX,SY); |
| 2423 | | case 1: return VDPpoint6(MXS,SX,SY); |
| 2424 | | case 2: return VDPpoint7(MXS,SX,SY); |
| 2425 | | case 3: return VDPpoint8(MXS,SX,SY); |
| 2426 | | } |
| 2412 | switch(SM) |
| 2413 | { |
| 2414 | case 0: return VDPpoint5(MXS,SX,SY); |
| 2415 | case 1: return VDPpoint6(MXS,SX,SY); |
| 2416 | case 2: return VDPpoint7(MXS,SX,SY); |
| 2417 | case 3: return VDPpoint8(MXS,SX,SY); |
| 2418 | } |
| 2427 | 2419 | |
| 2428 | | return(0); |
| 2420 | return(0); |
| 2429 | 2421 | } |
| 2430 | 2422 | |
| 2431 | 2423 | /** VDPpsetlowlevel() ****************************************/ |
| 2432 | 2424 | /** Low level function to set a pixel on a screen **/ |
| 2433 | 2425 | /** Make it inline to make it fast **/ |
| 2434 | 2426 | /*************************************************************/ |
| 2435 | | inline void v99x8_device::VDPpsetlowlevel(UINT8 *P, UINT8 CL, UINT8 M, UINT8 OP) |
| 2427 | inline void v99x8_device::VDPpsetlowlevel(int addr, UINT8 CL, UINT8 M, UINT8 OP) |
| 2436 | 2428 | { |
| 2437 | | switch (OP) |
| 2438 | | { |
| 2439 | | case 0: *P = (*P & M) | CL; break; |
| 2440 | | case 1: *P = *P & (CL | M); break; |
| 2441 | | case 2: *P |= CL; break; |
| 2442 | | case 3: *P ^= CL; break; |
| 2443 | | case 4: *P = (*P & M) | ~(CL | M); break; |
| 2444 | | case 8: if (CL) *P = (*P & M) | CL; break; |
| 2445 | | case 9: if (CL) *P = *P & (CL | M); break; |
| 2446 | | case 10: if (CL) *P |= CL; break; |
| 2447 | | case 11: if (CL) *P ^= CL; break; |
| 2448 | | case 12: if (CL) *P = (*P & M) | ~(CL|M); break; |
| 2449 | | } |
| 2429 | // If this turns out to be too slow, get a pointer to the address space |
| 2430 | // and work directly on it. |
| 2431 | UINT8 val = m_vram_space->read_byte(addr); |
| 2432 | switch (OP) |
| 2433 | { |
| 2434 | case 0: val = (val & M) | CL; break; |
| 2435 | case 1: val = val & (CL | M); break; |
| 2436 | case 2: val |= CL; break; |
| 2437 | case 3: val ^= CL; break; |
| 2438 | case 4: val = (val & M) | ~(CL | M); break; |
| 2439 | case 8: if (CL) val = (val & M) | CL; break; |
| 2440 | case 9: if (CL) val = val & (CL | M); break; |
| 2441 | case 10: if (CL) val |= CL; break; |
| 2442 | case 11: if (CL) val ^= CL; break; |
| 2443 | case 12: if (CL) val = (val & M) | ~(CL|M); break; |
| 2444 | default: |
| 2445 | LOG(("v9938: invalid operation %d in pset\n", OP)); |
| 2446 | } |
| 2447 | |
| 2448 | m_vram_space->write_byte(addr, val); |
| 2450 | 2449 | } |
| 2451 | 2450 | |
| 2452 | 2451 | /** VDPpset5() ***********************************************/ |
| r15546 | r15547 | |
| 2454 | 2453 | /*************************************************************/ |
| 2455 | 2454 | inline void v99x8_device::VDPpset5(int MXD, int DX, int DY, UINT8 CL, UINT8 OP) |
| 2456 | 2455 | { |
| 2457 | | UINT8 SH = ((~DX)&1)<<2; |
| 2458 | | |
| 2459 | | VDPpsetlowlevel(VDP_VRMP5(MXD, DX, DY), |
| 2460 | | CL << SH, ~(15<<SH), OP); |
| 2456 | UINT8 SH = ((~DX)&1)<<2; |
| 2457 | VDPpsetlowlevel(VDP_VRMP5(MXD, DX, DY), CL << SH, ~(15<<SH), OP); |
| 2461 | 2458 | } |
| 2462 | 2459 | |
| 2463 | 2460 | /** VDPpset6() ***********************************************/ |
| r15546 | r15547 | |
| 2465 | 2462 | /*************************************************************/ |
| 2466 | 2463 | inline void v99x8_device::VDPpset6(int MXD, int DX, int DY, UINT8 CL, UINT8 OP) |
| 2467 | 2464 | { |
| 2468 | | UINT8 SH = ((~DX)&3)<<1; |
| 2465 | UINT8 SH = ((~DX)&3)<<1; |
| 2469 | 2466 | |
| 2470 | | VDPpsetlowlevel(VDP_VRMP6(MXD, DX, DY), |
| 2471 | | CL << SH, ~(3<<SH), OP); |
| 2467 | VDPpsetlowlevel(VDP_VRMP6(MXD, DX, DY), CL << SH, ~(3<<SH), OP); |
| 2472 | 2468 | } |
| 2473 | 2469 | |
| 2474 | 2470 | /** VDPpset7() ***********************************************/ |
| r15546 | r15547 | |
| 2476 | 2472 | /*************************************************************/ |
| 2477 | 2473 | inline void v99x8_device::VDPpset7(int MXD, int DX, int DY, UINT8 CL, UINT8 OP) |
| 2478 | 2474 | { |
| 2479 | | UINT8 SH = ((~DX)&1)<<2; |
| 2475 | UINT8 SH = ((~DX)&1)<<2; |
| 2480 | 2476 | |
| 2481 | | VDPpsetlowlevel(VDP_VRMP7(MXD, DX, DY), |
| 2482 | | CL << SH, ~(15<<SH), OP); |
| 2477 | VDPpsetlowlevel(VDP_VRMP7(MXD, DX, DY), CL << SH, ~(15<<SH), OP); |
| 2483 | 2478 | } |
| 2484 | 2479 | |
| 2485 | 2480 | /** VDPpset8() ***********************************************/ |
| r15546 | r15547 | |
| 2487 | 2482 | /*************************************************************/ |
| 2488 | 2483 | inline void v99x8_device::VDPpset8(int MXD, int DX, int DY, UINT8 CL, UINT8 OP) |
| 2489 | 2484 | { |
| 2490 | | VDPpsetlowlevel(VDP_VRMP8(MXD, DX, DY), |
| 2491 | | CL, 0, OP); |
| 2485 | VDPpsetlowlevel(VDP_VRMP8(MXD, DX, DY), CL, 0, OP); |
| 2492 | 2486 | } |
| 2493 | 2487 | |
| 2494 | 2488 | /** VDPpset() ************************************************/ |
| r15546 | r15547 | |
| 2496 | 2490 | /*************************************************************/ |
| 2497 | 2491 | inline void v99x8_device::VDPpset(UINT8 SM, int MXD, int DX, int DY, UINT8 CL, UINT8 OP) |
| 2498 | 2492 | { |
| 2499 | | switch (SM) { |
| 2493 | switch (SM) { |
| 2500 | 2494 | case 0: VDPpset5(MXD, DX, DY, CL, OP); break; |
| 2501 | 2495 | case 1: VDPpset6(MXD, DX, DY, CL, OP); break; |
| 2502 | 2496 | case 2: VDPpset7(MXD, DX, DY, CL, OP); break; |
| 2503 | 2497 | case 3: VDPpset8(MXD, DX, DY, CL, OP); break; |
| 2504 | | } |
| 2498 | } |
| 2505 | 2499 | } |
| 2506 | 2500 | |
| 2507 | | /** GetVdpTimingValue() **************************************/ |
| 2501 | /** get_vdp_timing_value() **************************************/ |
| 2508 | 2502 | /** Get timing value for a certain VDP command **/ |
| 2509 | 2503 | /*************************************************************/ |
| 2510 | | int v99x8_device::GetVdpTimingValue(const int *timing_values) |
| 2504 | int v99x8_device::get_vdp_timing_value(const int *timing_values) |
| 2511 | 2505 | { |
| 2512 | | return(timing_values[((VDP[1]>>6)&1)|(VDP[8]&2)|((VDP[9]<<1)&4)]); |
| 2506 | return(timing_values[((m_cont_reg[1]>>6)&1)|(m_cont_reg[8]&2)|((m_cont_reg[9]<<1)&4)]); |
| 2513 | 2507 | } |
| 2514 | 2508 | |
| 2515 | 2509 | /** SrchEgine()** ********************************************/ |
| 2516 | 2510 | /** Search a dot **/ |
| 2517 | 2511 | /*************************************************************/ |
| 2518 | | void v99x8_device::SrchEngine() |
| 2512 | void v99x8_device::srch_engine() |
| 2519 | 2513 | { |
| 2520 | | int SX=m_mmc.SX; |
| 2521 | | int SY=m_mmc.SY; |
| 2522 | | int TX=m_mmc.TX; |
| 2523 | | int ANX=m_mmc.ANX; |
| 2524 | | UINT8 CL=m_mmc.CL; |
| 2525 | | int MXD = m_mmc.MXD; |
| 2526 | | int cnt; |
| 2527 | | int delta; |
| 2514 | int SX=m_mmc.SX; |
| 2515 | int SY=m_mmc.SY; |
| 2516 | int TX=m_mmc.TX; |
| 2517 | int ANX=m_mmc.ANX; |
| 2518 | UINT8 CL=m_mmc.CL; |
| 2519 | int MXD = m_mmc.MXD; |
| 2520 | int cnt; |
| 2521 | int delta; |
| 2528 | 2522 | |
| 2529 | | delta = GetVdpTimingValue(srch_timing); |
| 2530 | | cnt = m_vdp_ops_count; |
| 2523 | delta = get_vdp_timing_value(srch_timing); |
| 2524 | cnt = m_vdp_ops_count; |
| 2531 | 2525 | |
| 2532 | | #define pre_srch \ |
| 2533 | | pre_loop \ |
| 2534 | | if (( |
| 2535 | | #define post_srch(MX) \ |
| 2536 | | ==CL) ^ANX) { \ |
| 2537 | | VDPStatus[2]|=0x10; /* Border detected */\ |
| 2538 | | break; \ |
| 2539 | | } \ |
| 2540 | | if ((SX+=TX) & MX) { \ |
| 2541 | | VDPStatus[2]&=0xEF; /* Border not detected */\ |
| 2542 | | break; \ |
| 2543 | | } \ |
| 2544 | | post_loop |
| 2526 | #define post_srch(MX) \ |
| 2527 | { m_stat_reg[2]|=0x10; /* Border detected */ break; } \ |
| 2528 | if ((SX+=TX) & MX) { m_stat_reg[2] &= 0xEF; /* Border not detected */ break; } \ |
| 2545 | 2529 | |
| 2546 | | switch (ScrMode) { |
| 2547 | | default: |
| 2548 | | case 5: pre_srch VDPpoint5(MXD, SX, SY) post_srch(256) |
| 2549 | | break; |
| 2550 | | case 6: pre_srch VDPpoint6(MXD, SX, SY) post_srch(512) |
| 2551 | | break; |
| 2552 | | case 7: pre_srch VDPpoint7(MXD, SX, SY) post_srch(512) |
| 2553 | | break; |
| 2554 | | case 8: pre_srch VDPpoint8(MXD, SX, SY) post_srch(256) |
| 2555 | | break; |
| 2556 | | } |
| 2530 | switch (m_mode) { |
| 2531 | default: |
| 2532 | case V9938_MODE_GRAPHIC4: pre_loop if ((VDPpoint5(MXD, SX, SY)==CL) ^ANX) post_srch(256) post_loop |
| 2533 | break; |
| 2534 | case V9938_MODE_GRAPHIC5: pre_loop if ((VDPpoint6(MXD, SX, SY)==CL) ^ANX) post_srch(512) post_loop |
| 2535 | break; |
| 2536 | case V9938_MODE_GRAPHIC6: pre_loop if ((VDPpoint7(MXD, SX, SY)==CL) ^ANX) post_srch(512) post_loop |
| 2537 | break; |
| 2538 | case V9938_MODE_GRAPHIC7: pre_loop if ((VDPpoint8(MXD, SX, SY)==CL) ^ANX) post_srch(256) post_loop |
| 2539 | break; |
| 2540 | } |
| 2557 | 2541 | |
| 2558 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2559 | | // Command execution done |
| 2560 | | VDPStatus[2]&=0xFE; |
| 2561 | | m_vdp_engine=0; |
| 2562 | | // Update SX in VDP registers |
| 2563 | | VDPStatus[8]=SX&0xFF; |
| 2564 | | VDPStatus[9]=(SX>>8)|0xFE; |
| 2565 | | } |
| 2566 | | else { |
| 2567 | | m_mmc.SX=SX; |
| 2568 | | } |
| 2542 | if ((m_vdp_ops_count=cnt)>0) { |
| 2543 | // Command execution done |
| 2544 | m_stat_reg[2] &= 0xFE; |
| 2545 | m_vdp_engine = 0; |
| 2546 | // Update SX in VDP registers |
| 2547 | m_stat_reg[8] = SX & 0xFF; |
| 2548 | m_stat_reg[9] = (SX>>8) | 0xFE; |
| 2549 | } |
| 2550 | else { |
| 2551 | m_mmc.SX=SX; |
| 2552 | } |
| 2569 | 2553 | } |
| 2570 | 2554 | |
| 2571 | 2555 | /** LineEgine()** ********************************************/ |
| 2572 | 2556 | /** Draw a line **/ |
| 2573 | 2557 | /*************************************************************/ |
| 2574 | | void v99x8_device::LineEngine() |
| 2558 | void v99x8_device::line_engine() |
| 2575 | 2559 | { |
| 2576 | | int DX=m_mmc.DX; |
| 2577 | | int DY=m_mmc.DY; |
| 2578 | | int TX=m_mmc.TX; |
| 2579 | | int TY=m_mmc.TY; |
| 2580 | | int NX=m_mmc.NX; |
| 2581 | | int NY=m_mmc.NY; |
| 2582 | | int ASX=m_mmc.ASX; |
| 2583 | | int ADX=m_mmc.ADX; |
| 2584 | | UINT8 CL=m_mmc.CL; |
| 2585 | | UINT8 LO=m_mmc.LO; |
| 2586 | | int MXD = m_mmc.MXD; |
| 2587 | | int cnt; |
| 2588 | | int delta; |
| 2560 | int DX=m_mmc.DX; |
| 2561 | int DY=m_mmc.DY; |
| 2562 | int TX=m_mmc.TX; |
| 2563 | int TY=m_mmc.TY; |
| 2564 | int NX=m_mmc.NX; |
| 2565 | int NY=m_mmc.NY; |
| 2566 | int ASX=m_mmc.ASX; |
| 2567 | int ADX=m_mmc.ADX; |
| 2568 | UINT8 CL=m_mmc.CL; |
| 2569 | UINT8 LO=m_mmc.LO; |
| 2570 | int MXD = m_mmc.MXD; |
| 2571 | int cnt; |
| 2572 | int delta; |
| 2589 | 2573 | |
| 2590 | | delta = GetVdpTimingValue(line_timing); |
| 2591 | | cnt = m_vdp_ops_count; |
| 2574 | delta = get_vdp_timing_value(line_timing); |
| 2575 | cnt = m_vdp_ops_count; |
| 2592 | 2576 | |
| 2593 | | #define post_linexmaj(MX) \ |
| 2594 | | DX+=TX; \ |
| 2595 | | if ((ASX-=NY)<0) { \ |
| 2596 | | ASX+=NX; \ |
| 2597 | | DY+=TY; \ |
| 2598 | | } \ |
| 2599 | | ASX&=1023; /* Mask to 10 bits range */\ |
| 2600 | | if (ADX++==NX || (DX&MX)) \ |
| 2601 | | break; \ |
| 2602 | | post_loop |
| 2577 | #define post_linexmaj(MX) \ |
| 2578 | DX+=TX; \ |
| 2579 | if ((ASX-=NY)<0) { \ |
| 2580 | ASX+=NX; \ |
| 2581 | DY+=TY; \ |
| 2582 | } \ |
| 2583 | ASX&=1023; /* Mask to 10 bits range */\ |
| 2584 | if (ADX++==NX || (DX&MX)) \ |
| 2585 | break; \ |
| 2586 | post_loop |
| 2603 | 2587 | |
| 2604 | | #define post_lineymaj(MX) \ |
| 2605 | | DY+=TY; \ |
| 2606 | | if ((ASX-=NY)<0) { \ |
| 2607 | | ASX+=NX; \ |
| 2608 | | DX+=TX; \ |
| 2609 | | } \ |
| 2610 | | ASX&=1023; /* Mask to 10 bits range */\ |
| 2611 | | if (ADX++==NX || (DX&MX)) \ |
| 2612 | | break; \ |
| 2613 | | post_loop |
| 2588 | #define post_lineymaj(MX) \ |
| 2589 | DY+=TY; \ |
| 2590 | if ((ASX-=NY)<0) { \ |
| 2591 | ASX+=NX; \ |
| 2592 | DX+=TX; \ |
| 2593 | } \ |
| 2594 | ASX&=1023; /* Mask to 10 bits range */\ |
| 2595 | if (ADX++==NX || (DX&MX)) \ |
| 2596 | break; \ |
| 2597 | post_loop |
| 2614 | 2598 | |
| 2615 | | if ((VDP[45]&0x01)==0) |
| 2616 | | // X-Axis is major direction |
| 2617 | | switch (ScrMode) { |
| 2618 | | default: |
| 2619 | | case 5: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_linexmaj(256) |
| 2620 | | break; |
| 2621 | | case 6: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_linexmaj(512) |
| 2622 | | break; |
| 2623 | | case 7: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_linexmaj(512) |
| 2624 | | break; |
| 2625 | | case 8: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_linexmaj(256) |
| 2626 | | break; |
| 2627 | | } |
| 2628 | | else |
| 2629 | | // Y-Axis is major direction |
| 2630 | | switch (ScrMode) { |
| 2631 | | default: |
| 2632 | | case 5: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_lineymaj(256) |
| 2633 | | break; |
| 2634 | | case 6: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_lineymaj(512) |
| 2635 | | break; |
| 2636 | | case 7: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_lineymaj(512) |
| 2637 | | break; |
| 2638 | | case 8: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_lineymaj(256) |
| 2639 | | break; |
| 2640 | | } |
| 2599 | if ((m_cont_reg[45]&0x01)==0) |
| 2600 | // X-Axis is major direction |
| 2601 | switch (m_mode) { |
| 2602 | default: |
| 2603 | case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_linexmaj(256) |
| 2604 | break; |
| 2605 | case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_linexmaj(512) |
| 2606 | break; |
| 2607 | case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_linexmaj(512) |
| 2608 | break; |
| 2609 | case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_linexmaj(256) |
| 2610 | break; |
| 2611 | } |
| 2612 | else |
| 2613 | // Y-Axis is major direction |
| 2614 | switch (m_mode) { |
| 2615 | default: |
| 2616 | case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_lineymaj(256) |
| 2617 | break; |
| 2618 | case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_lineymaj(512) |
| 2619 | break; |
| 2620 | case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_lineymaj(512) |
| 2621 | break; |
| 2622 | case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_lineymaj(256) |
| 2623 | break; |
| 2624 | } |
| 2641 | 2625 | |
| 2642 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2643 | | // Command execution done |
| 2644 | | VDPStatus[2]&=0xFE; |
| 2645 | | m_vdp_engine=0; |
| 2646 | | VDP[38]=DY & 0xFF; |
| 2647 | | VDP[39]=(DY>>8) & 0x03; |
| 2648 | | } |
| 2649 | | else { |
| 2650 | | m_mmc.DX=DX; |
| 2651 | | m_mmc.DY=DY; |
| 2652 | | m_mmc.ASX=ASX; |
| 2653 | | m_mmc.ADX=ADX; |
| 2654 | | } |
| 2626 | if ((m_vdp_ops_count=cnt)>0) { |
| 2627 | // Command execution done |
| 2628 | m_stat_reg[2]&=0xFE; |
| 2629 | m_vdp_engine=0; |
| 2630 | m_cont_reg[38]=DY & 0xFF; |
| 2631 | m_cont_reg[39]=(DY>>8) & 0x03; |
| 2632 | } |
| 2633 | else { |
| 2634 | m_mmc.DX=DX; |
| 2635 | m_mmc.DY=DY; |
| 2636 | m_mmc.ASX=ASX; |
| 2637 | m_mmc.ADX=ADX; |
| 2638 | } |
| 2655 | 2639 | } |
| 2656 | 2640 | |
| 2657 | | /** LmmvEngine() *********************************************/ |
| 2641 | /** lmmv_engine() *********************************************/ |
| 2658 | 2642 | /** VDP -> Vram **/ |
| 2659 | 2643 | /*************************************************************/ |
| 2660 | | void v99x8_device::LmmvEngine() |
| 2644 | void v99x8_device::lmmv_engine() |
| 2661 | 2645 | { |
| 2662 | | int DX=m_mmc.DX; |
| 2663 | | int DY=m_mmc.DY; |
| 2664 | | int TX=m_mmc.TX; |
| 2665 | | int TY=m_mmc.TY; |
| 2666 | | int NX=m_mmc.NX; |
| 2667 | | int NY=m_mmc.NY; |
| 2668 | | int ADX=m_mmc.ADX; |
| 2669 | | int ANX=m_mmc.ANX; |
| 2670 | | UINT8 CL=m_mmc.CL; |
| 2671 | | UINT8 LO=m_mmc.LO; |
| 2672 | | int MXD = m_mmc.MXD; |
| 2673 | | int cnt; |
| 2674 | | int delta; |
| 2646 | int DX=m_mmc.DX; |
| 2647 | int DY=m_mmc.DY; |
| 2648 | int TX=m_mmc.TX; |
| 2649 | int TY=m_mmc.TY; |
| 2650 | int NX=m_mmc.NX; |
| 2651 | int NY=m_mmc.NY; |
| 2652 | int ADX=m_mmc.ADX; |
| 2653 | int ANX=m_mmc.ANX; |
| 2654 | UINT8 CL=m_mmc.CL; |
| 2655 | UINT8 LO=m_mmc.LO; |
| 2656 | int MXD = m_mmc.MXD; |
| 2657 | int cnt; |
| 2658 | int delta; |
| 2675 | 2659 | |
| 2676 | | delta = GetVdpTimingValue(lmmv_timing); |
| 2677 | | cnt = m_vdp_ops_count; |
| 2660 | delta = get_vdp_timing_value(lmmv_timing); |
| 2661 | cnt = m_vdp_ops_count; |
| 2678 | 2662 | |
| 2679 | | switch (ScrMode) { |
| 2680 | | default: |
| 2681 | | case 5: pre_loop VDPpset5(MXD, ADX, DY, CL, LO); post__x_y(256) |
| 2682 | | break; |
| 2683 | | case 6: pre_loop VDPpset6(MXD, ADX, DY, CL, LO); post__x_y(512) |
| 2684 | | break; |
| 2685 | | case 7: pre_loop VDPpset7(MXD, ADX, DY, CL, LO); post__x_y(512) |
| 2686 | | break; |
| 2687 | | case 8: pre_loop VDPpset8(MXD, ADX, DY, CL, LO); post__x_y(256) |
| 2688 | | break; |
| 2689 | | } |
| 2663 | switch (m_mode) { |
| 2664 | default: |
| 2665 | case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, ADX, DY, CL, LO); post__x_y(256) |
| 2666 | break; |
| 2667 | case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, ADX, DY, CL, LO); post__x_y(512) |
| 2668 | break; |
| 2669 | case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, ADX, DY, CL, LO); post__x_y(512) |
| 2670 | break; |
| 2671 | case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, ADX, DY, CL, LO); post__x_y(256) |
| 2672 | break; |
| 2673 | } |
| 2690 | 2674 | |
| 2691 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2692 | | // Command execution done |
| 2693 | | VDPStatus[2]&=0xFE; |
| 2694 | | m_vdp_engine=0; |
| 2695 | | if (!NY) |
| 2696 | | DY+=TY; |
| 2697 | | VDP[38]=DY & 0xFF; |
| 2698 | | VDP[39]=(DY>>8) & 0x03; |
| 2699 | | VDP[42]=NY & 0xFF; |
| 2700 | | VDP[43]=(NY>>8) & 0x03; |
| 2701 | | } |
| 2702 | | else { |
| 2703 | | m_mmc.DY=DY; |
| 2704 | | m_mmc.NY=NY; |
| 2705 | | m_mmc.ANX=ANX; |
| 2706 | | m_mmc.ADX=ADX; |
| 2707 | | } |
| 2675 | if ((m_vdp_ops_count=cnt)>0) { |
| 2676 | // Command execution done |
| 2677 | m_stat_reg[2]&=0xFE; |
| 2678 | m_vdp_engine=0; |
| 2679 | if (!NY) |
| 2680 | DY+=TY; |
| 2681 | m_cont_reg[38]=DY & 0xFF; |
| 2682 | m_cont_reg[39]=(DY>>8) & 0x03; |
| 2683 | m_cont_reg[42]=NY & 0xFF; |
| 2684 | m_cont_reg[43]=(NY>>8) & 0x03; |
| 2685 | } |
| 2686 | else { |
| 2687 | m_mmc.DY=DY; |
| 2688 | m_mmc.NY=NY; |
| 2689 | m_mmc.ANX=ANX; |
| 2690 | m_mmc.ADX=ADX; |
| 2691 | } |
| 2708 | 2692 | } |
| 2709 | 2693 | |
| 2710 | | /** LmmmEngine() *********************************************/ |
| 2694 | /** lmmm_engine() *********************************************/ |
| 2711 | 2695 | /** Vram -> Vram **/ |
| 2712 | 2696 | /*************************************************************/ |
| 2713 | | void v99x8_device::LmmmEngine() |
| 2697 | void v99x8_device::lmmm_engine() |
| 2714 | 2698 | { |
| 2715 | | int SX=m_mmc.SX; |
| 2716 | | int SY=m_mmc.SY; |
| 2717 | | int DX=m_mmc.DX; |
| 2718 | | int DY=m_mmc.DY; |
| 2719 | | int TX=m_mmc.TX; |
| 2720 | | int TY=m_mmc.TY; |
| 2721 | | int NX=m_mmc.NX; |
| 2722 | | int NY=m_mmc.NY; |
| 2723 | | int ASX=m_mmc.ASX; |
| 2724 | | int ADX=m_mmc.ADX; |
| 2725 | | int ANX=m_mmc.ANX; |
| 2726 | | UINT8 LO=m_mmc.LO; |
| 2727 | | int MXS = m_mmc.MXS; |
| 2728 | | int MXD = m_mmc.MXD; |
| 2729 | | int cnt; |
| 2730 | | int delta; |
| 2699 | int SX=m_mmc.SX; |
| 2700 | int SY=m_mmc.SY; |
| 2701 | int DX=m_mmc.DX; |
| 2702 | int DY=m_mmc.DY; |
| 2703 | int TX=m_mmc.TX; |
| 2704 | int TY=m_mmc.TY; |
| 2705 | int NX=m_mmc.NX; |
| 2706 | int NY=m_mmc.NY; |
| 2707 | int ASX=m_mmc.ASX; |
| 2708 | int ADX=m_mmc.ADX; |
| 2709 | int ANX=m_mmc.ANX; |
| 2710 | UINT8 LO=m_mmc.LO; |
| 2711 | int MXS = m_mmc.MXS; |
| 2712 | int MXD = m_mmc.MXD; |
| 2713 | int cnt; |
| 2714 | int delta; |
| 2731 | 2715 | |
| 2732 | | delta = GetVdpTimingValue(lmmm_timing); |
| 2733 | | cnt = m_vdp_ops_count; |
| 2716 | delta = get_vdp_timing_value(lmmm_timing); |
| 2717 | cnt = m_vdp_ops_count; |
| 2734 | 2718 | |
| 2735 | | switch (ScrMode) { |
| 2736 | | default: |
| 2737 | | case 5: pre_loop VDPpset5(MXD, ADX, DY, VDPpoint5(MXS, ASX, SY), LO); post_xxyy(256) |
| 2738 | | break; |
| 2739 | | case 6: pre_loop VDPpset6(MXD, ADX, DY, VDPpoint6(MXS, ASX, SY), LO); post_xxyy(512) |
| 2740 | | break; |
| 2741 | | case 7: pre_loop VDPpset7(MXD, ADX, DY, VDPpoint7(MXS, ASX, SY), LO); post_xxyy(512) |
| 2742 | | break; |
| 2743 | | case 8: pre_loop VDPpset8(MXD, ADX, DY, VDPpoint8(MXS, ASX, SY), LO); post_xxyy(256) |
| 2744 | | break; |
| 2745 | | } |
| 2719 | switch (m_mode) { |
| 2720 | default: |
| 2721 | case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, ADX, DY, VDPpoint5(MXS, ASX, SY), LO); post_xxyy(256) |
| 2722 | break; |
| 2723 | case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, ADX, DY, VDPpoint6(MXS, ASX, SY), LO); post_xxyy(512) |
| 2724 | break; |
| 2725 | case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, ADX, DY, VDPpoint7(MXS, ASX, SY), LO); post_xxyy(512) |
| 2726 | break; |
| 2727 | case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, ADX, DY, VDPpoint8(MXS, ASX, SY), LO); post_xxyy(256) |
| 2728 | break; |
| 2729 | } |
| 2746 | 2730 | |
| 2747 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2748 | | // Command execution done |
| 2749 | | VDPStatus[2]&=0xFE; |
| 2750 | | m_vdp_engine=0; |
| 2751 | | if (!NY) { |
| 2752 | | SY+=TY; |
| 2753 | | DY+=TY; |
| 2754 | | } |
| 2755 | | else |
| 2756 | | if (SY==-1) |
| 2757 | | DY+=TY; |
| 2758 | | VDP[42]=NY & 0xFF; |
| 2759 | | VDP[43]=(NY>>8) & 0x03; |
| 2760 | | VDP[34]=SY & 0xFF; |
| 2761 | | VDP[35]=(SY>>8) & 0x03; |
| 2762 | | VDP[38]=DY & 0xFF; |
| 2763 | | VDP[39]=(DY>>8) & 0x03; |
| 2764 | | } |
| 2765 | | else { |
| 2766 | | m_mmc.SY=SY; |
| 2767 | | m_mmc.DY=DY; |
| 2768 | | m_mmc.NY=NY; |
| 2769 | | m_mmc.ANX=ANX; |
| 2770 | | m_mmc.ASX=ASX; |
| 2771 | | m_mmc.ADX=ADX; |
| 2772 | | } |
| 2731 | if ((m_vdp_ops_count=cnt)>0) { |
| 2732 | // Command execution done |
| 2733 | m_stat_reg[2]&=0xFE; |
| 2734 | m_vdp_engine=0; |
| 2735 | if (!NY) { |
| 2736 | SY+=TY; |
| 2737 | DY+=TY; |
| 2738 | } |
| 2739 | else |
| 2740 | if (SY==-1) |
| 2741 | DY+=TY; |
| 2742 | m_cont_reg[42]=NY & 0xFF; |
| 2743 | m_cont_reg[43]=(NY>>8) & 0x03; |
| 2744 | m_cont_reg[34]=SY & 0xFF; |
| 2745 | m_cont_reg[35]=(SY>>8) & 0x03; |
| 2746 | m_cont_reg[38]=DY & 0xFF; |
| 2747 | m_cont_reg[39]=(DY>>8) & 0x03; |
| 2748 | } |
| 2749 | else { |
| 2750 | m_mmc.SY=SY; |
| 2751 | m_mmc.DY=DY; |
| 2752 | m_mmc.NY=NY; |
| 2753 | m_mmc.ANX=ANX; |
| 2754 | m_mmc.ASX=ASX; |
| 2755 | m_mmc.ADX=ADX; |
| 2756 | } |
| 2773 | 2757 | } |
| 2774 | 2758 | |
| 2775 | | /** LmcmEngine() *********************************************/ |
| 2759 | /** lmcm_engine() *********************************************/ |
| 2776 | 2760 | /** Vram -> CPU **/ |
| 2777 | 2761 | /*************************************************************/ |
| 2778 | | void v99x8_device::LmcmEngine() |
| 2762 | void v99x8_device::lmcm_engine() |
| 2779 | 2763 | { |
| 2780 | | if ((VDPStatus[2]&0x80)!=0x80) { |
| 2764 | if ((m_stat_reg[2]&0x80)!=0x80) { |
| 2781 | 2765 | |
| 2782 | | VDPStatus[7]=VDP[44]=VDP_POINT(((ScrMode >= 5) && (ScrMode <= 8)) ? (ScrMode-5) : 0, m_mmc.MXS, m_mmc.ASX, m_mmc.SY); |
| 2783 | | m_vdp_ops_count-=GetVdpTimingValue(lmmv_timing); |
| 2784 | | VDPStatus[2]|=0x80; |
| 2766 | m_stat_reg[7]=m_cont_reg[44]=VDP_POINT(((m_mode >= 5) && (m_mode <= 8)) ? (m_mode-5) : 0, m_mmc.MXS, m_mmc.ASX, m_mmc.SY); |
| 2767 | m_vdp_ops_count-=get_vdp_timing_value(lmmv_timing); |
| 2768 | m_stat_reg[2]|=0x80; |
| 2785 | 2769 | |
| 2786 | | if (!--m_mmc.ANX || ((m_mmc.ASX+=m_mmc.TX)&m_mmc.MX)) { |
| 2787 | | if (!(--m_mmc.NY & 1023) || (m_mmc.SY+=m_mmc.TY)==-1) { |
| 2788 | | VDPStatus[2]&=0xFE; |
| 2789 | | m_vdp_engine=0; |
| 2790 | | if (!m_mmc.NY) |
| 2791 | | m_mmc.DY+=m_mmc.TY; |
| 2792 | | VDP[42]=m_mmc.NY & 0xFF; |
| 2793 | | VDP[43]=(m_mmc.NY>>8) & 0x03; |
| 2794 | | VDP[34]=m_mmc.SY & 0xFF; |
| 2795 | | VDP[35]=(m_mmc.SY>>8) & 0x03; |
| 2796 | | } |
| 2797 | | else { |
| 2798 | | m_mmc.ASX=m_mmc.SX; |
| 2799 | | m_mmc.ANX=m_mmc.NX; |
| 2800 | | } |
| 2801 | | } |
| 2802 | | } |
| 2770 | if (!--m_mmc.ANX || ((m_mmc.ASX+=m_mmc.TX)&m_mmc.MX)) { |
| 2771 | if (!(--m_mmc.NY & 1023) || (m_mmc.SY+=m_mmc.TY)==-1) { |
| 2772 | m_stat_reg[2]&=0xFE; |
| 2773 | m_vdp_engine=0; |
| 2774 | if (!m_mmc.NY) |
| 2775 | m_mmc.DY+=m_mmc.TY; |
| 2776 | m_cont_reg[42]=m_mmc.NY & 0xFF; |
| 2777 | m_cont_reg[43]=(m_mmc.NY>>8) & 0x03; |
| 2778 | m_cont_reg[34]=m_mmc.SY & 0xFF; |
| 2779 | m_cont_reg[35]=(m_mmc.SY>>8) & 0x03; |
| 2780 | } |
| 2781 | else { |
| 2782 | m_mmc.ASX=m_mmc.SX; |
| 2783 | m_mmc.ANX=m_mmc.NX; |
| 2784 | } |
| 2785 | } |
| 2786 | } |
| 2803 | 2787 | } |
| 2804 | 2788 | |
| 2805 | | /** LmmcEngine() *********************************************/ |
| 2789 | /** lmmc_engine() *********************************************/ |
| 2806 | 2790 | /** CPU -> Vram **/ |
| 2807 | 2791 | /*************************************************************/ |
| 2808 | | void v99x8_device::LmmcEngine() |
| 2792 | void v99x8_device::lmmc_engine() |
| 2809 | 2793 | { |
| 2810 | | if ((VDPStatus[2]&0x80)!=0x80) { |
| 2811 | | UINT8 SM=((ScrMode >= 5) && (ScrMode <= 8)) ? (ScrMode-5) : 0; |
| 2794 | if ((m_stat_reg[2]&0x80)!=0x80) { |
| 2795 | UINT8 SM=((m_mode >= 5) && (m_mode <= 8)) ? (m_mode-5) : 0; |
| 2812 | 2796 | |
| 2813 | | VDPStatus[7]=VDP[44]&=Mask[SM]; |
| 2814 | | VDP_PSET(SM, m_mmc.MXD, m_mmc.ADX, m_mmc.DY, VDP[44], m_mmc.LO); |
| 2815 | | m_vdp_ops_count-=GetVdpTimingValue(lmmv_timing); |
| 2816 | | VDPStatus[2]|=0x80; |
| 2797 | m_stat_reg[7]=m_cont_reg[44]&=Mask[SM]; |
| 2798 | VDP_PSET(SM, m_mmc.MXD, m_mmc.ADX, m_mmc.DY, m_cont_reg[44], m_mmc.LO); |
| 2799 | m_vdp_ops_count-=get_vdp_timing_value(lmmv_timing); |
| 2800 | m_stat_reg[2]|=0x80; |
| 2817 | 2801 | |
| 2818 | | if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) { |
| 2819 | | if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) { |
| 2820 | | VDPStatus[2]&=0xFE; |
| 2821 | | m_vdp_engine=0; |
| 2822 | | if (!m_mmc.NY) |
| 2823 | | m_mmc.DY+=m_mmc.TY; |
| 2824 | | VDP[42]=m_mmc.NY & 0xFF; |
| 2825 | | VDP[43]=(m_mmc.NY>>8) & 0x03; |
| 2826 | | VDP[38]=m_mmc.DY & 0xFF; |
| 2827 | | VDP[39]=(m_mmc.DY>>8) & 0x03; |
| 2828 | | } |
| 2829 | | else { |
| 2830 | | m_mmc.ADX=m_mmc.DX; |
| 2831 | | m_mmc.ANX=m_mmc.NX; |
| 2832 | | } |
| 2833 | | } |
| 2834 | | } |
| 2802 | if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) { |
| 2803 | if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) { |
| 2804 | m_stat_reg[2]&=0xFE; |
| 2805 | m_vdp_engine=0; |
| 2806 | if (!m_mmc.NY) |
| 2807 | m_mmc.DY+=m_mmc.TY; |
| 2808 | m_cont_reg[42]=m_mmc.NY & 0xFF; |
| 2809 | m_cont_reg[43]=(m_mmc.NY>>8) & 0x03; |
| 2810 | m_cont_reg[38]=m_mmc.DY & 0xFF; |
| 2811 | m_cont_reg[39]=(m_mmc.DY>>8) & 0x03; |
| 2812 | } |
| 2813 | else { |
| 2814 | m_mmc.ADX=m_mmc.DX; |
| 2815 | m_mmc.ANX=m_mmc.NX; |
| 2816 | } |
| 2817 | } |
| 2818 | } |
| 2835 | 2819 | } |
| 2836 | 2820 | |
| 2837 | | /** HmmvEngine() *********************************************/ |
| 2821 | /** hmmv_engine() *********************************************/ |
| 2838 | 2822 | /** VDP --> Vram **/ |
| 2839 | 2823 | /*************************************************************/ |
| 2840 | | void v99x8_device::HmmvEngine() |
| 2824 | void v99x8_device::hmmv_engine() |
| 2841 | 2825 | { |
| 2842 | | int DX=m_mmc.DX; |
| 2843 | | int DY=m_mmc.DY; |
| 2844 | | int TX=m_mmc.TX; |
| 2845 | | int TY=m_mmc.TY; |
| 2846 | | int NX=m_mmc.NX; |
| 2847 | | int NY=m_mmc.NY; |
| 2848 | | int ADX=m_mmc.ADX; |
| 2849 | | int ANX=m_mmc.ANX; |
| 2850 | | UINT8 CL=m_mmc.CL; |
| 2851 | | int MXD = m_mmc.MXD; |
| 2852 | | int cnt; |
| 2853 | | int delta; |
| 2826 | int DX=m_mmc.DX; |
| 2827 | int DY=m_mmc.DY; |
| 2828 | int TX=m_mmc.TX; |
| 2829 | int TY=m_mmc.TY; |
| 2830 | int NX=m_mmc.NX; |
| 2831 | int NY=m_mmc.NY; |
| 2832 | int ADX=m_mmc.ADX; |
| 2833 | int ANX=m_mmc.ANX; |
| 2834 | UINT8 CL=m_mmc.CL; |
| 2835 | int MXD = m_mmc.MXD; |
| 2836 | int cnt; |
| 2837 | int delta; |
| 2854 | 2838 | |
| 2855 | | delta = GetVdpTimingValue(hmmv_timing); |
| 2856 | | cnt = m_vdp_ops_count; |
| 2839 | delta = get_vdp_timing_value(hmmv_timing); |
| 2840 | cnt = m_vdp_ops_count; |
| 2857 | 2841 | |
| 2858 | | switch (ScrMode) { |
| 2842 | switch (m_mode) { |
| 2859 | 2843 | default: |
| 2860 | | case 5: pre_loop *VDP_VRMP5(MXD, ADX, DY) = CL; post__x_y(256) |
| 2861 | | break; |
| 2862 | | case 6: pre_loop *VDP_VRMP6(MXD, ADX, DY) = CL; post__x_y(512) |
| 2863 | | break; |
| 2864 | | case 7: pre_loop *VDP_VRMP7(MXD, ADX, DY) = CL; post__x_y(512) |
| 2865 | | break; |
| 2866 | | case 8: pre_loop *VDP_VRMP8(MXD, ADX, DY) = CL; post__x_y(256) |
| 2867 | | break; |
| 2868 | | } |
| 2844 | case V9938_MODE_GRAPHIC4: pre_loop m_vram_space->write_byte(VDP_VRMP5(MXD, ADX, DY), CL); post__x_y(256) |
| 2845 | break; |
| 2846 | case V9938_MODE_GRAPHIC5: pre_loop m_vram_space->write_byte(VDP_VRMP6(MXD, ADX, DY), CL); post__x_y(512) |
| 2847 | break; |
| 2848 | case V9938_MODE_GRAPHIC6: pre_loop m_vram_space->write_byte(VDP_VRMP7(MXD, ADX, DY), CL); post__x_y(512) |
| 2849 | break; |
| 2850 | case V9938_MODE_GRAPHIC7: pre_loop m_vram_space->write_byte(VDP_VRMP8(MXD, ADX, DY), CL); post__x_y(256) |
| 2851 | break; |
| 2852 | } |
| 2869 | 2853 | |
| 2870 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2871 | | // Command execution done |
| 2872 | | VDPStatus[2]&=0xFE; |
| 2873 | | m_vdp_engine=0; |
| 2874 | | if (!NY) |
| 2875 | | DY+=TY; |
| 2876 | | VDP[42]=NY & 0xFF; |
| 2877 | | VDP[43]=(NY>>8) & 0x03; |
| 2878 | | VDP[38]=DY & 0xFF; |
| 2879 | | VDP[39]=(DY>>8) & 0x03; |
| 2880 | | } |
| 2881 | | else { |
| 2882 | | m_mmc.DY=DY; |
| 2883 | | m_mmc.NY=NY; |
| 2884 | | m_mmc.ANX=ANX; |
| 2885 | | m_mmc.ADX=ADX; |
| 2886 | | } |
| 2854 | if ((m_vdp_ops_count=cnt)>0) { |
| 2855 | // Command execution done |
| 2856 | m_stat_reg[2]&=0xFE; |
| 2857 | m_vdp_engine=0; |
| 2858 | if (!NY) |
| 2859 | DY+=TY; |
| 2860 | m_cont_reg[42]=NY & 0xFF; |
| 2861 | m_cont_reg[43]=(NY>>8) & 0x03; |
| 2862 | m_cont_reg[38]=DY & 0xFF; |
| 2863 | m_cont_reg[39]=(DY>>8) & 0x03; |
| 2864 | } |
| 2865 | else { |
| 2866 | m_mmc.DY=DY; |
| 2867 | m_mmc.NY=NY; |
| 2868 | m_mmc.ANX=ANX; |
| 2869 | m_mmc.ADX=ADX; |
| 2870 | } |
| 2887 | 2871 | } |
| 2888 | 2872 | |
| 2889 | | /** HmmmEngine() *********************************************/ |
| 2873 | /** hmmm_engine() *********************************************/ |
| 2890 | 2874 | /** Vram -> Vram **/ |
| 2891 | 2875 | /*************************************************************/ |
| 2892 | | void v99x8_device::HmmmEngine() |
| 2876 | void v99x8_device::hmmm_engine() |
| 2893 | 2877 | { |
| 2894 | | int SX=m_mmc.SX; |
| 2895 | | int SY=m_mmc.SY; |
| 2896 | | int DX=m_mmc.DX; |
| 2897 | | int DY=m_mmc.DY; |
| 2898 | | int TX=m_mmc.TX; |
| 2899 | | int TY=m_mmc.TY; |
| 2900 | | int NX=m_mmc.NX; |
| 2901 | | int NY=m_mmc.NY; |
| 2902 | | int ASX=m_mmc.ASX; |
| 2903 | | int ADX=m_mmc.ADX; |
| 2904 | | int ANX=m_mmc.ANX; |
| 2905 | | int MXS = m_mmc.MXS; |
| 2906 | | int MXD = m_mmc.MXD; |
| 2907 | | int cnt; |
| 2908 | | int delta; |
| 2878 | int SX=m_mmc.SX; |
| 2879 | int SY=m_mmc.SY; |
| 2880 | int DX=m_mmc.DX; |
| 2881 | int DY=m_mmc.DY; |
| 2882 | int TX=m_mmc.TX; |
| 2883 | int TY=m_mmc.TY; |
| 2884 | int NX=m_mmc.NX; |
| 2885 | int NY=m_mmc.NY; |
| 2886 | int ASX=m_mmc.ASX; |
| 2887 | int ADX=m_mmc.ADX; |
| 2888 | int ANX=m_mmc.ANX; |
| 2889 | int MXS = m_mmc.MXS; |
| 2890 | int MXD = m_mmc.MXD; |
| 2891 | int cnt; |
| 2892 | int delta; |
| 2909 | 2893 | |
| 2910 | | delta = GetVdpTimingValue(hmmm_timing); |
| 2911 | | cnt = m_vdp_ops_count; |
| 2894 | delta = get_vdp_timing_value(hmmm_timing); |
| 2895 | cnt = m_vdp_ops_count; |
| 2912 | 2896 | |
| 2913 | | switch (ScrMode) { |
| 2914 | | default: |
| 2915 | | case 5: pre_loop *VDP_VRMP5(MXD, ADX, DY) = *VDP_VRMP5(MXS, ASX, SY); post_xxyy(256) |
| 2916 | | break; |
| 2917 | | case 6: pre_loop *VDP_VRMP6(MXD, ADX, DY) = *VDP_VRMP6(MXS, ASX, SY); post_xxyy(512) |
| 2918 | | break; |
| 2919 | | case 7: pre_loop *VDP_VRMP7(MXD, ADX, DY) = *VDP_VRMP7(MXS, ASX, SY); post_xxyy(512) |
| 2920 | | break; |
| 2921 | | case 8: pre_loop *VDP_VRMP8(MXD, ADX, DY) = *VDP_VRMP8(MXS, ASX, SY); post_xxyy(256) |
| 2922 | | break; |
| 2923 | | } |
| 2897 | switch (m_mode) { |
| 2898 | default: |
| 2899 | case V9938_MODE_GRAPHIC4: pre_loop m_vram_space->write_byte(VDP_VRMP5(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP5(MXS, ASX, SY))); post_xxyy(256) |
| 2900 | break; |
| 2901 | case V9938_MODE_GRAPHIC5: pre_loop m_vram_space->write_byte(VDP_VRMP6(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP6(MXS, ASX, SY))); post_xxyy(512) |
| 2902 | break; |
| 2903 | case V9938_MODE_GRAPHIC6: pre_loop m_vram_space->write_byte(VDP_VRMP7(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP7(MXS, ASX, SY))); post_xxyy(512) |
| 2904 | break; |
| 2905 | case V9938_MODE_GRAPHIC7: pre_loop m_vram_space->write_byte(VDP_VRMP8(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP8(MXS, ASX, SY))); post_xxyy(256) |
| 2906 | break; |
| 2907 | } |
| 2924 | 2908 | |
| 2925 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2926 | | // Command execution done |
| 2927 | | VDPStatus[2]&=0xFE; |
| 2928 | | m_vdp_engine=0; |
| 2929 | | if (!NY) { |
| 2930 | | SY+=TY; |
| 2931 | | DY+=TY; |
| 2932 | | } |
| 2933 | | else |
| 2934 | | if (SY==-1) |
| 2935 | | DY+=TY; |
| 2936 | | VDP[42]=NY & 0xFF; |
| 2937 | | VDP[43]=(NY>>8) & 0x03; |
| 2938 | | VDP[34]=SY & 0xFF; |
| 2939 | | VDP[35]=(SY>>8) & 0x03; |
| 2940 | | VDP[38]=DY & 0xFF; |
| 2941 | | VDP[39]=(DY>>8) & 0x03; |
| 2942 | | } |
| 2943 | | else { |
| 2944 | | m_mmc.SY=SY; |
| 2945 | | m_mmc.DY=DY; |
| 2946 | | m_mmc.NY=NY; |
| 2947 | | m_mmc.ANX=ANX; |
| 2948 | | m_mmc.ASX=ASX; |
| 2949 | | m_mmc.ADX=ADX; |
| 2950 | | } |
| 2909 | if ((m_vdp_ops_count=cnt)>0) { |
| 2910 | // Command execution done |
| 2911 | m_stat_reg[2]&=0xFE; |
| 2912 | m_vdp_engine=0; |
| 2913 | if (!NY) { |
| 2914 | SY+=TY; |
| 2915 | DY+=TY; |
| 2916 | } |
| 2917 | else |
| 2918 | if (SY==-1) |
| 2919 | DY+=TY; |
| 2920 | m_cont_reg[42]=NY & 0xFF; |
| 2921 | m_cont_reg[43]=(NY>>8) & 0x03; |
| 2922 | m_cont_reg[34]=SY & 0xFF; |
| 2923 | m_cont_reg[35]=(SY>>8) & 0x03; |
| 2924 | m_cont_reg[38]=DY & 0xFF; |
| 2925 | m_cont_reg[39]=(DY>>8) & 0x03; |
| 2926 | } |
| 2927 | else { |
| 2928 | m_mmc.SY=SY; |
| 2929 | m_mmc.DY=DY; |
| 2930 | m_mmc.NY=NY; |
| 2931 | m_mmc.ANX=ANX; |
| 2932 | m_mmc.ASX=ASX; |
| 2933 | m_mmc.ADX=ADX; |
| 2934 | } |
| 2951 | 2935 | } |
| 2952 | 2936 | |
| 2953 | | /** YmmmEngine() *********************************************/ |
| 2937 | /** ymmm_engine() *********************************************/ |
| 2954 | 2938 | /** Vram -> Vram **/ |
| 2955 | 2939 | /*************************************************************/ |
| 2956 | | void v99x8_device::YmmmEngine() |
| 2940 | |
| 2941 | void v99x8_device::ymmm_engine() |
| 2957 | 2942 | { |
| 2958 | | int SY=m_mmc.SY; |
| 2959 | | int DX=m_mmc.DX; |
| 2960 | | int DY=m_mmc.DY; |
| 2961 | | int TX=m_mmc.TX; |
| 2962 | | int TY=m_mmc.TY; |
| 2963 | | int NY=m_mmc.NY; |
| 2964 | | int ADX=m_mmc.ADX; |
| 2965 | | int MXD = m_mmc.MXD; |
| 2966 | | int cnt; |
| 2967 | | int delta; |
| 2943 | int SY=m_mmc.SY; |
| 2944 | int DX=m_mmc.DX; |
| 2945 | int DY=m_mmc.DY; |
| 2946 | int TX=m_mmc.TX; |
| 2947 | int TY=m_mmc.TY; |
| 2948 | int NY=m_mmc.NY; |
| 2949 | int ADX=m_mmc.ADX; |
| 2950 | int MXD = m_mmc.MXD; |
| 2951 | int cnt; |
| 2952 | int delta; |
| 2968 | 2953 | |
| 2969 | | delta = GetVdpTimingValue(ymmm_timing); |
| 2970 | | cnt = m_vdp_ops_count; |
| 2954 | delta = get_vdp_timing_value(ymmm_timing); |
| 2955 | cnt = m_vdp_ops_count; |
| 2971 | 2956 | |
| 2972 | | switch (ScrMode) { |
| 2973 | | default: |
| 2974 | | case 5: pre_loop *VDP_VRMP5(MXD, ADX, DY) = *VDP_VRMP5(MXD, ADX, SY); post__xyy(256) |
| 2975 | | break; |
| 2976 | | case 6: pre_loop *VDP_VRMP6(MXD, ADX, DY) = *VDP_VRMP6(MXD, ADX, SY); post__xyy(512) |
| 2977 | | break; |
| 2978 | | case 7: pre_loop *VDP_VRMP7(MXD, ADX, DY) = *VDP_VRMP7(MXD, ADX, SY); post__xyy(512) |
| 2979 | | break; |
| 2980 | | case 8: pre_loop *VDP_VRMP8(MXD, ADX, DY) = *VDP_VRMP8(MXD, ADX, SY); post__xyy(256) |
| 2981 | | break; |
| 2982 | | } |
| 2957 | switch (m_mode) { |
| 2958 | default: |
| 2959 | case V9938_MODE_GRAPHIC4: pre_loop m_vram_space->write_byte(VDP_VRMP5(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP5(MXD, ADX, SY))); post__xyy(256) |
| 2960 | break; |
| 2961 | case V9938_MODE_GRAPHIC5: pre_loop m_vram_space->write_byte(VDP_VRMP6(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP6(MXD, ADX, SY))); post__xyy(512) |
| 2962 | break; |
| 2963 | case V9938_MODE_GRAPHIC6: pre_loop m_vram_space->write_byte(VDP_VRMP7(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP7(MXD, ADX, SY))); post__xyy(512) |
| 2964 | break; |
| 2965 | case V9938_MODE_GRAPHIC7: pre_loop m_vram_space->write_byte(VDP_VRMP8(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP8(MXD, ADX, SY))); post__xyy(256) |
| 2966 | break; |
| 2967 | } |
| 2983 | 2968 | |
| 2984 | | if ((m_vdp_ops_count=cnt)>0) { |
| 2985 | | // Command execution done |
| 2986 | | VDPStatus[2]&=0xFE; |
| 2987 | | m_vdp_engine=0; |
| 2988 | | if (!NY) { |
| 2989 | | SY+=TY; |
| 2990 | | DY+=TY; |
| 2991 | | } |
| 2992 | | else |
| 2993 | | if (SY==-1) |
| 2994 | | DY+=TY; |
| 2995 | | VDP[42]=NY & 0xFF; |
| 2996 | | VDP[43]=(NY>>8) & 0x03; |
| 2997 | | VDP[34]=SY & 0xFF; |
| 2998 | | VDP[35]=(SY>>8) & 0x03; |
| 2999 | | VDP[38]=DY & 0xFF; |
| 3000 | | VDP[39]=(DY>>8) & 0x03; |
| 3001 | | } |
| 3002 | | else { |
| 3003 | | m_mmc.SY=SY; |
| 3004 | | m_mmc.DY=DY; |
| 3005 | | m_mmc.NY=NY; |
| 3006 | | m_mmc.ADX=ADX; |
| 3007 | | } |
| 2969 | if ((m_vdp_ops_count=cnt)>0) { |
| 2970 | // Command execution done |
| 2971 | m_stat_reg[2]&=0xFE; |
| 2972 | m_vdp_engine=0; |
| 2973 | if (!NY) { |
| 2974 | SY+=TY; |
| 2975 | DY+=TY; |
| 2976 | } |
| 2977 | else |
| 2978 | if (SY==-1) |
| 2979 | DY+=TY; |
| 2980 | m_cont_reg[42]=NY & 0xFF; |
| 2981 | m_cont_reg[43]=(NY>>8) & 0x03; |
| 2982 | m_cont_reg[34]=SY & 0xFF; |
| 2983 | m_cont_reg[35]=(SY>>8) & 0x03; |
| 2984 | m_cont_reg[38]=DY & 0xFF; |
| 2985 | m_cont_reg[39]=(DY>>8) & 0x03; |
| 2986 | } |
| 2987 | else { |
| 2988 | m_mmc.SY=SY; |
| 2989 | m_mmc.DY=DY; |
| 2990 | m_mmc.NY=NY; |
| 2991 | m_mmc.ADX=ADX; |
| 2992 | } |
| 3008 | 2993 | } |
| 3009 | 2994 | |
| 3010 | | /** HmmcEngine() *********************************************/ |
| 2995 | /** hmmc_engine() *********************************************/ |
| 3011 | 2996 | /** CPU -> Vram **/ |
| 3012 | 2997 | /*************************************************************/ |
| 3013 | | void v99x8_device::HmmcEngine() |
| 2998 | void v99x8_device::hmmc_engine() |
| 3014 | 2999 | { |
| 3015 | | if ((VDPStatus[2]&0x80)!=0x80) { |
| 3000 | if ((m_stat_reg[2]&0x80)!=0x80) { |
| 3016 | 3001 | |
| 3017 | | *VDP_VRMP(((ScrMode >= 5) && (ScrMode <= 8)) ? (ScrMode-5) : 0, m_mmc.MXD, m_mmc.ADX, m_mmc.DY)=VDP[44]; |
| 3018 | | m_vdp_ops_count-=GetVdpTimingValue(hmmv_timing); |
| 3019 | | VDPStatus[2]|=0x80; |
| 3002 | m_vram_space->write_byte(VDP_VRMP(((m_mode >= 5) && (m_mode <= 8)) ? (m_mode-5) : 0, m_mmc.MXD, m_mmc.ADX, m_mmc.DY), m_cont_reg[44]); |
| 3003 | m_vdp_ops_count -= get_vdp_timing_value(hmmv_timing); |
| 3004 | m_stat_reg[2]|=0x80; |
| 3020 | 3005 | |
| 3021 | | if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) { |
| 3022 | | if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) { |
| 3023 | | VDPStatus[2]&=0xFE; |
| 3024 | | m_vdp_engine=0; |
| 3025 | | if (!m_mmc.NY) |
| 3026 | | m_mmc.DY+=m_mmc.TY; |
| 3027 | | VDP[42]=m_mmc.NY & 0xFF; |
| 3028 | | VDP[43]=(m_mmc.NY>>8) & 0x03; |
| 3029 | | VDP[38]=m_mmc.DY & 0xFF; |
| 3030 | | VDP[39]=(m_mmc.DY>>8) & 0x03; |
| 3031 | | } |
| 3032 | | else { |
| 3033 | | m_mmc.ADX=m_mmc.DX; |
| 3034 | | m_mmc.ANX=m_mmc.NX; |
| 3035 | | } |
| 3036 | | } |
| 3037 | | } |
| 3006 | if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) { |
| 3007 | if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) { |
| 3008 | m_stat_reg[2]&=0xFE; |
| 3009 | m_vdp_engine=0; |
| 3010 | if (!m_mmc.NY) |
| 3011 | m_mmc.DY+=m_mmc.TY; |
| 3012 | m_cont_reg[42]=m_mmc.NY & 0xFF; |
| 3013 | m_cont_reg[43]=(m_mmc.NY>>8) & 0x03; |
| 3014 | m_cont_reg[38]=m_mmc.DY & 0xFF; |
| 3015 | m_cont_reg[39]=(m_mmc.DY>>8) & 0x03; |
| 3016 | } |
| 3017 | else { |
| 3018 | m_mmc.ADX=m_mmc.DX; |
| 3019 | m_mmc.ANX=m_mmc.NX; |
| 3020 | } |
| 3021 | } |
| 3022 | } |
| 3038 | 3023 | } |
| 3039 | 3024 | |
| 3040 | 3025 | /** VDPWrite() ***********************************************/ |
| 3041 | 3026 | /** Use this function to transfer pixel(s) from CPU to m_ **/ |
| 3042 | 3027 | /*************************************************************/ |
| 3043 | | void v99x8_device::cpu_to_vdp (UINT8 V) |
| 3028 | void v99x8_device::cpu_to_vdp(UINT8 V) |
| 3044 | 3029 | { |
| 3045 | | VDPStatus[2]&=0x7F; |
| 3046 | | VDPStatus[7]=VDP[44]=V; |
| 3047 | | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3030 | m_stat_reg[2]&=0x7F; |
| 3031 | m_stat_reg[7]=m_cont_reg[44]=V; |
| 3032 | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3048 | 3033 | } |
| 3049 | 3034 | |
| 3050 | 3035 | /** VDPRead() ************************************************/ |
| 3051 | 3036 | /** Use this function to transfer pixel(s) from VDP to CPU. **/ |
| 3052 | 3037 | /*************************************************************/ |
| 3053 | | UINT8 v99x8_device::vdp_to_cpu () |
| 3038 | UINT8 v99x8_device::vdp_to_cpu() |
| 3054 | 3039 | { |
| 3055 | | VDPStatus[2]&=0x7F; |
| 3056 | | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3057 | | return(VDP[44]); |
| 3040 | m_stat_reg[2]&=0x7F; |
| 3041 | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3042 | return(m_cont_reg[44]); |
| 3058 | 3043 | } |
| 3059 | 3044 | |
| 3060 | | /** ReportVdpCommand() ***************************************/ |
| 3045 | /** report_vdp_command() ***************************************/ |
| 3061 | 3046 | /** Report VDP Command to be executed **/ |
| 3062 | 3047 | /*************************************************************/ |
| 3063 | | void v99x8_device::ReportVdpCommand(UINT8 Op) |
| 3048 | void v99x8_device::report_vdp_command(UINT8 Op) |
| 3064 | 3049 | { |
| 3065 | 3050 | static const char *const Ops[16] = |
| 3066 | 3051 | { |
| r15546 | r15547 | |
| 3077 | 3062 | int SX,SY, DX,DY, NX,NY; |
| 3078 | 3063 | |
| 3079 | 3064 | // Fetch arguments |
| 3080 | | CL = VDP[44]; |
| 3081 | | SX = (VDP[32]+((int)VDP[33]<<8)) & 511; |
| 3082 | | SY = (VDP[34]+((int)VDP[35]<<8)) & 1023; |
| 3083 | | DX = (VDP[36]+((int)VDP[37]<<8)) & 511; |
| 3084 | | DY = (VDP[38]+((int)VDP[39]<<8)) & 1023; |
| 3085 | | NX = (VDP[40]+((int)VDP[41]<<8)) & 1023; |
| 3086 | | NY = (VDP[42]+((int)VDP[43]<<8)) & 1023; |
| 3065 | CL = m_cont_reg[44]; |
| 3066 | SX = (m_cont_reg[32]+((int)m_cont_reg[33]<<8)) & 511; |
| 3067 | SY = (m_cont_reg[34]+((int)m_cont_reg[35]<<8)) & 1023; |
| 3068 | DX = (m_cont_reg[36]+((int)m_cont_reg[37]<<8)) & 511; |
| 3069 | DY = (m_cont_reg[38]+((int)m_cont_reg[39]<<8)) & 1023; |
| 3070 | NX = (m_cont_reg[40]+((int)m_cont_reg[41]<<8)) & 1023; |
| 3071 | NY = (m_cont_reg[42]+((int)m_cont_reg[43]<<8)) & 1023; |
| 3087 | 3072 | CM = Op>>4; |
| 3088 | 3073 | LO = Op&0x0F; |
| 3089 | 3074 | |
| 3090 | 3075 | LOG(("V9938: Opcode %02Xh %s-%s (%d,%d)->(%d,%d),%d [%d,%d]%s\n", |
| 3091 | | Op, Commands[CM], Ops[LO], |
| 3092 | | SX,SY, DX,DY, CL, VDP[45]&0x04? -NX:NX, |
| 3093 | | VDP[45]&0x08? -NY:NY, |
| 3094 | | VDP[45]&0x70? " on ExtVRAM":"" |
| 3076 | Op, Commands[CM], Ops[LO], |
| 3077 | SX,SY, DX,DY, CL, m_cont_reg[45]&0x04? -NX:NX, |
| 3078 | m_cont_reg[45]&0x08? -NY:NY, |
| 3079 | m_cont_reg[45]&0x70? " on ExtVRAM":"" |
| 3095 | 3080 | )); |
| 3096 | 3081 | } |
| 3097 | 3082 | |
| 3098 | 3083 | /** VDPDraw() ************************************************/ |
| 3099 | 3084 | /** Perform a given V9938 operation Op. **/ |
| 3100 | 3085 | /*************************************************************/ |
| 3101 | | UINT8 v99x8_device::command_unit_w (UINT8 Op) |
| 3086 | UINT8 v99x8_device::command_unit_w(UINT8 Op) |
| 3102 | 3087 | { |
| 3103 | | int SM; |
| 3088 | int SM; |
| 3104 | 3089 | |
| 3105 | | // V9938 ops only work in SCREENs 5-8 |
| 3106 | | if (ScrMode<5) |
| 3107 | | return(0); |
| 3090 | // V9938 ops only work in SCREENs 5-8 |
| 3091 | if (m_mode<5) |
| 3092 | return(0); |
| 3108 | 3093 | |
| 3109 | | SM = ScrMode-5; // Screen mode index 0..3 |
| 3094 | SM = m_mode-5; // Screen mode index 0..3 |
| 3110 | 3095 | |
| 3111 | | m_mmc.CM = Op>>4; |
| 3112 | | if ((m_mmc.CM & 0x0C) != 0x0C && m_mmc.CM != 0) |
| 3113 | | // Dot operation: use only relevant bits of color |
| 3114 | | VDPStatus[7]=(VDP[44]&=Mask[SM]); |
| 3096 | m_mmc.CM = Op>>4; |
| 3097 | if ((m_mmc.CM & 0x0C) != 0x0C && m_mmc.CM != 0) |
| 3098 | // Dot operation: use only relevant bits of color |
| 3099 | m_stat_reg[7]=(m_cont_reg[44]&=Mask[SM]); |
| 3115 | 3100 | |
| 3116 | | // if(Verbose&0x02) |
| 3117 | | ReportVdpCommand(Op); |
| 3101 | // if(Verbose&0x02) |
| 3102 | report_vdp_command(Op); |
| 3118 | 3103 | |
| 3119 | | switch(Op>>4) { |
| 3120 | | case CM_ABRT: |
| 3121 | | VDPStatus[2]&=0xFE; |
| 3122 | | m_vdp_engine=0; |
| 3123 | | return 1; |
| 3124 | | case CM_POINT: |
| 3125 | | VDPStatus[2]&=0xFE; |
| 3126 | | m_vdp_engine=0; |
| 3127 | | VDPStatus[7]=VDP[44]= |
| 3128 | | VDP_POINT(SM, (VDP[45] & 0x10) != 0, |
| 3129 | | VDP[32]+((int)VDP[33]<<8), |
| 3130 | | VDP[34]+((int)VDP[35]<<8)); |
| 3131 | | return 1; |
| 3132 | | case CM_PSET: |
| 3133 | | VDPStatus[2]&=0xFE; |
| 3134 | | m_vdp_engine=0; |
| 3135 | | VDP_PSET(SM, (VDP[45] & 0x20) != 0, |
| 3136 | | VDP[36]+((int)VDP[37]<<8), |
| 3137 | | VDP[38]+((int)VDP[39]<<8), |
| 3138 | | VDP[44], |
| 3139 | | Op&0x0F); |
| 3140 | | return 1; |
| 3141 | | case CM_SRCH: |
| 3142 | | m_vdp_engine=&v99x8_device::SrchEngine; |
| 3143 | | break; |
| 3144 | | case CM_LINE: |
| 3145 | | m_vdp_engine=&v99x8_device::LineEngine; |
| 3146 | | break; |
| 3147 | | case CM_LMMV: |
| 3148 | | m_vdp_engine=&v99x8_device::LmmvEngine; |
| 3149 | | break; |
| 3150 | | case CM_LMMM: |
| 3151 | | m_vdp_engine=&v99x8_device::LmmmEngine; |
| 3152 | | break; |
| 3153 | | case CM_LMCM: |
| 3154 | | m_vdp_engine=&v99x8_device::LmcmEngine; |
| 3155 | | break; |
| 3156 | | case CM_LMMC: |
| 3157 | | m_vdp_engine=&v99x8_device::LmmcEngine; |
| 3158 | | break; |
| 3159 | | case CM_HMMV: |
| 3160 | | m_vdp_engine=&v99x8_device::HmmvEngine; |
| 3161 | | break; |
| 3162 | | case CM_HMMM: |
| 3163 | | m_vdp_engine=&v99x8_device::HmmmEngine; |
| 3164 | | break; |
| 3165 | | case CM_YMMM: |
| 3166 | | m_vdp_engine=&v99x8_device::YmmmEngine; |
| 3167 | | break; |
| 3168 | | case CM_HMMC: |
| 3169 | | m_vdp_engine=&v99x8_device::HmmcEngine; |
| 3170 | | break; |
| 3171 | | default: |
| 3172 | | LOG(("V9938: Unrecognized opcode %02Xh\n",Op)); |
| 3173 | | return(0); |
| 3174 | | } |
| 3104 | switch(Op>>4) { |
| 3105 | case CM_ABRT: |
| 3106 | m_stat_reg[2]&=0xFE; |
| 3107 | m_vdp_engine=0; |
| 3108 | return 1; |
| 3109 | case CM_POINT: |
| 3110 | m_stat_reg[2]&=0xFE; |
| 3111 | m_vdp_engine=0; |
| 3112 | m_stat_reg[7]=m_cont_reg[44]= |
| 3113 | VDP_POINT(SM, (m_cont_reg[45] & 0x10) != 0, |
| 3114 | m_cont_reg[32]+((int)m_cont_reg[33]<<8), |
| 3115 | m_cont_reg[34]+((int)m_cont_reg[35]<<8)); |
| 3116 | return 1; |
| 3117 | case CM_PSET: |
| 3118 | m_stat_reg[2]&=0xFE; |
| 3119 | m_vdp_engine=0; |
| 3120 | VDP_PSET(SM, (m_cont_reg[45] & 0x20) != 0, |
| 3121 | m_cont_reg[36]+((int)m_cont_reg[37]<<8), |
| 3122 | m_cont_reg[38]+((int)m_cont_reg[39]<<8), |
| 3123 | m_cont_reg[44], |
| 3124 | Op&0x0F); |
| 3125 | return 1; |
| 3126 | case CM_SRCH: |
| 3127 | m_vdp_engine=&v99x8_device::srch_engine; |
| 3128 | break; |
| 3129 | case CM_LINE: |
| 3130 | m_vdp_engine=&v99x8_device::line_engine; |
| 3131 | break; |
| 3132 | case CM_LMMV: |
| 3133 | m_vdp_engine=&v99x8_device::lmmv_engine; |
| 3134 | break; |
| 3135 | case CM_LMMM: |
| 3136 | m_vdp_engine=&v99x8_device::lmmm_engine; |
| 3137 | break; |
| 3138 | case CM_LMCM: |
| 3139 | m_vdp_engine=&v99x8_device::lmcm_engine; |
| 3140 | break; |
| 3141 | case CM_LMMC: |
| 3142 | m_vdp_engine=&v99x8_device::lmmc_engine; |
| 3143 | break; |
| 3144 | case CM_HMMV: |
| 3145 | m_vdp_engine=&v99x8_device::hmmv_engine; |
| 3146 | break; |
| 3147 | case CM_HMMM: |
| 3148 | m_vdp_engine=&v99x8_device::hmmm_engine; |
| 3149 | break; |
| 3150 | case CM_YMMM: |
| 3151 | m_vdp_engine=&v99x8_device::ymmm_engine; |
| 3152 | break; |
| 3153 | case CM_HMMC: |
| 3154 | m_vdp_engine=&v99x8_device::hmmc_engine; |
| 3155 | break; |
| 3156 | default: |
| 3157 | LOG(("V9938: Unrecognized opcode %02Xh\n",Op)); |
| 3158 | return(0); |
| 3159 | } |
| 3175 | 3160 | |
| 3176 | | // Fetch unconditional arguments |
| 3177 | | m_mmc.SX = (VDP[32]+((int)VDP[33]<<8)) & 511; |
| 3178 | | m_mmc.SY = (VDP[34]+((int)VDP[35]<<8)) & 1023; |
| 3179 | | m_mmc.DX = (VDP[36]+((int)VDP[37]<<8)) & 511; |
| 3180 | | m_mmc.DY = (VDP[38]+((int)VDP[39]<<8)) & 1023; |
| 3181 | | m_mmc.NY = (VDP[42]+((int)VDP[43]<<8)) & 1023; |
| 3182 | | m_mmc.TY = VDP[45]&0x08? -1:1; |
| 3183 | | m_mmc.MX = PPL[SM]; |
| 3184 | | m_mmc.CL = VDP[44]; |
| 3185 | | m_mmc.LO = Op&0x0F; |
| 3186 | | m_mmc.MXS = (VDP[45] & 0x10) != 0; |
| 3187 | | m_mmc.MXD = (VDP[45] & 0x20) != 0; |
| 3161 | // Fetch unconditional arguments |
| 3162 | m_mmc.SX = (m_cont_reg[32]+((int)m_cont_reg[33]<<8)) & 511; |
| 3163 | m_mmc.SY = (m_cont_reg[34]+((int)m_cont_reg[35]<<8)) & 1023; |
| 3164 | m_mmc.DX = (m_cont_reg[36]+((int)m_cont_reg[37]<<8)) & 511; |
| 3165 | m_mmc.DY = (m_cont_reg[38]+((int)m_cont_reg[39]<<8)) & 1023; |
| 3166 | m_mmc.NY = (m_cont_reg[42]+((int)m_cont_reg[43]<<8)) & 1023; |
| 3167 | m_mmc.TY = m_cont_reg[45]&0x08? -1:1; |
| 3168 | m_mmc.MX = PPL[SM]; |
| 3169 | m_mmc.CL = m_cont_reg[44]; |
| 3170 | m_mmc.LO = Op&0x0F; |
| 3171 | m_mmc.MXS = (m_cont_reg[45] & 0x10) != 0; |
| 3172 | m_mmc.MXD = (m_cont_reg[45] & 0x20) != 0; |
| 3188 | 3173 | |
| 3189 | | // Argument depends on UINT8 or dot operation |
| 3190 | | if ((m_mmc.CM & 0x0C) == 0x0C) { |
| 3191 | | m_mmc.TX = VDP[45]&0x04? -PPB[SM]:PPB[SM]; |
| 3192 | | m_mmc.NX = ((VDP[40]+((int)VDP[41]<<8)) & 1023)/PPB[SM]; |
| 3193 | | } |
| 3194 | | else { |
| 3195 | | m_mmc.TX = VDP[45]&0x04? -1:1; |
| 3196 | | m_mmc.NX = (VDP[40]+((int)VDP[41]<<8)) & 1023; |
| 3197 | | } |
| 3174 | // Argument depends on UINT8 or dot operation |
| 3175 | if ((m_mmc.CM & 0x0C) == 0x0C) { |
| 3176 | m_mmc.TX = m_cont_reg[45]&0x04? -PPB[SM]:PPB[SM]; |
| 3177 | m_mmc.NX = ((m_cont_reg[40]+((int)m_cont_reg[41]<<8)) & 1023)/PPB[SM]; |
| 3178 | } |
| 3179 | else { |
| 3180 | m_mmc.TX = m_cont_reg[45]&0x04? -1:1; |
| 3181 | m_mmc.NX = (m_cont_reg[40]+((int)m_cont_reg[41]<<8)) & 1023; |
| 3182 | } |
| 3198 | 3183 | |
| 3199 | | // X loop variables are treated specially for LINE command |
| 3200 | | if (m_mmc.CM == CM_LINE) { |
| 3201 | | m_mmc.ASX=((m_mmc.NX-1)>>1); |
| 3202 | | m_mmc.ADX=0; |
| 3203 | | } |
| 3204 | | else { |
| 3205 | | m_mmc.ASX = m_mmc.SX; |
| 3206 | | m_mmc.ADX = m_mmc.DX; |
| 3207 | | } |
| 3184 | // X loop variables are treated specially for LINE command |
| 3185 | if (m_mmc.CM == CM_LINE) { |
| 3186 | m_mmc.ASX=((m_mmc.NX-1)>>1); |
| 3187 | m_mmc.ADX=0; |
| 3188 | } |
| 3189 | else { |
| 3190 | m_mmc.ASX = m_mmc.SX; |
| 3191 | m_mmc.ADX = m_mmc.DX; |
| 3192 | } |
| 3208 | 3193 | |
| 3209 | | // NX loop variable is treated specially for SRCH command |
| 3210 | | if (m_mmc.CM == CM_SRCH) |
| 3211 | | m_mmc.ANX=(VDP[45]&0x02)!=0; // Do we look for "==" or "!="? |
| 3212 | | else |
| 3213 | | m_mmc.ANX = m_mmc.NX; |
| 3194 | // NX loop variable is treated specially for SRCH command |
| 3195 | if (m_mmc.CM == CM_SRCH) |
| 3196 | m_mmc.ANX=(m_cont_reg[45]&0x02)!=0; // Do we look for "==" or "!="? |
| 3197 | else |
| 3198 | m_mmc.ANX = m_mmc.NX; |
| 3214 | 3199 | |
| 3215 | | // Command execution started |
| 3216 | | VDPStatus[2]|=0x01; |
| 3200 | // Command execution started |
| 3201 | m_stat_reg[2]|=0x01; |
| 3217 | 3202 | |
| 3218 | | // Start execution if we still have time slices |
| 3219 | | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3203 | // Start execution if we still have time slices |
| 3204 | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3220 | 3205 | |
| 3221 | | // Operation successfull initiated |
| 3222 | | return(1); |
| 3206 | // Operation successfull initiated |
| 3207 | return(1); |
| 3223 | 3208 | } |
| 3224 | 3209 | |
| 3225 | | /** LoopVDP() ************************************************/ |
| 3226 | | /** Run X steps of active VDP command **/ |
| 3227 | | /*************************************************************/ |
| 3228 | | void v99x8_device::update_command () |
| 3210 | /** LoopVDP() ************************************************ |
| 3211 | Run X steps of active VDP command |
| 3212 | *************************************************************/ |
| 3213 | void v99x8_device::update_command() |
| 3229 | 3214 | { |
| 3230 | | if(m_vdp_ops_count<=0) |
| 3231 | | { |
| 3232 | | m_vdp_ops_count+=13662; |
| 3233 | | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3234 | | } |
| 3235 | | else |
| 3236 | | { |
| 3237 | | m_vdp_ops_count=13662; |
| 3238 | | if(m_vdp_engine) (this->*m_vdp_engine)(); |
| 3239 | | } |
| 3215 | if(m_vdp_ops_count<=0) |
| 3216 | { |
| 3217 | m_vdp_ops_count+=13662; |
| 3218 | if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)(); |
| 3219 | } |
| 3220 | else |
| 3221 | { |
| 3222 | m_vdp_ops_count=13662; |
| 3223 | if(m_vdp_engine) (this->*m_vdp_engine)(); |
| 3224 | } |
| 3240 | 3225 | } |
| 3241 | 3226 | |