trunk/src/mame/drivers/rabbit.c
| r243434 | r243435 | |
| 96 | 96 | |
| 97 | 97 | rabbit_state(const machine_config &mconfig, device_type type, const char *tag) |
| 98 | 98 | : driver_device(mconfig, type, tag), |
| 99 | m_maincpu(*this, "maincpu"), |
| 100 | m_eeprom(*this, "eeprom"), |
| 101 | m_gfxdecode(*this, "gfxdecode"), |
| 102 | m_palette(*this, "palette"), |
| 99 | 103 | m_viewregs0(*this, "viewregs0"), |
| 100 | 104 | m_viewregs6(*this, "viewregs6"), |
| 101 | 105 | m_viewregs7(*this, "viewregs7"), |
| r243434 | r243435 | |
| 104 | 108 | m_tilemap_regs(*this, "tilemap_regs"), |
| 105 | 109 | m_spriteregs(*this, "spriteregs"), |
| 106 | 110 | m_blitterregs(*this, "blitterregs"), |
| 107 | | m_spriteram(*this, "spriteram"), |
| 108 | | m_maincpu(*this, "maincpu"), |
| 109 | | m_eeprom(*this, "eeprom"), |
| 110 | | m_gfxdecode(*this, "gfxdecode"), |
| 111 | | m_palette(*this, "palette") { } |
| 111 | m_spriteram(*this, "spriteram") { } |
| 112 | 112 | |
| 113 | required_device<cpu_device> m_maincpu; |
| 114 | required_device<eeprom_serial_93cxx_device> m_eeprom; |
| 115 | required_device<gfxdecode_device> m_gfxdecode; |
| 116 | required_device<palette_device> m_palette; |
| 117 | |
| 113 | 118 | required_shared_ptr<UINT32> m_viewregs0; |
| 114 | 119 | required_shared_ptr<UINT32> m_viewregs6; |
| 115 | 120 | required_shared_ptr<UINT32> m_viewregs7; |
| r243434 | r243435 | |
| 118 | 123 | required_shared_ptr_array<UINT32, 4> m_tilemap_regs; |
| 119 | 124 | required_shared_ptr<UINT32> m_spriteregs; |
| 120 | 125 | required_shared_ptr<UINT32> m_blitterregs; |
| 126 | required_shared_ptr<UINT32> m_spriteram; |
| 127 | |
| 121 | 128 | bitmap_ind16 *m_sprite_bitmap; |
| 122 | 129 | rectangle m_sprite_clip; |
| 123 | 130 | int m_vblirqlevel; |
| 124 | 131 | int m_bltirqlevel; |
| 125 | 132 | int m_banking; |
| 126 | 133 | UINT32 *m_tilemap_ram[4]; |
| 127 | | required_shared_ptr<UINT32> m_spriteram; |
| 128 | 134 | tilemap_t *m_tilemap[4]; |
| 129 | | DECLARE_WRITE32_MEMBER(rabbit_tilemap0_w); |
| 130 | | DECLARE_WRITE32_MEMBER(rabbit_tilemap1_w); |
| 131 | | DECLARE_WRITE32_MEMBER(rabbit_tilemap2_w); |
| 132 | | DECLARE_WRITE32_MEMBER(rabbit_tilemap3_w); |
| 133 | | DECLARE_READ32_MEMBER(rabbit_tilemap0_r); |
| 134 | | DECLARE_READ32_MEMBER(rabbit_tilemap1_r); |
| 135 | | DECLARE_READ32_MEMBER(rabbit_tilemap2_r); |
| 136 | | DECLARE_READ32_MEMBER(rabbit_tilemap3_r); |
| 135 | |
| 136 | DECLARE_WRITE32_MEMBER(tilemap0_w); |
| 137 | DECLARE_WRITE32_MEMBER(tilemap1_w); |
| 138 | DECLARE_WRITE32_MEMBER(tilemap2_w); |
| 139 | DECLARE_WRITE32_MEMBER(tilemap3_w); |
| 140 | DECLARE_READ32_MEMBER(tilemap0_r); |
| 141 | DECLARE_READ32_MEMBER(tilemap1_r); |
| 142 | DECLARE_READ32_MEMBER(tilemap2_r); |
| 143 | DECLARE_READ32_MEMBER(tilemap3_r); |
| 137 | 144 | DECLARE_READ32_MEMBER(randomrabbits); |
| 138 | | DECLARE_WRITE32_MEMBER(rabbit_rombank_w); |
| 139 | | DECLARE_WRITE32_MEMBER(rabbit_blitter_w); |
| 140 | | DECLARE_WRITE32_MEMBER(rabbit_eeprom_write); |
| 145 | DECLARE_WRITE32_MEMBER(rombank_w); |
| 146 | DECLARE_WRITE32_MEMBER(blitter_w); |
| 147 | DECLARE_WRITE32_MEMBER(eeprom_write); |
| 148 | |
| 141 | 149 | DECLARE_DRIVER_INIT(rabbit); |
| 142 | | TILE_GET_INFO_MEMBER(get_rabbit_tilemap0_tile_info); |
| 143 | | TILE_GET_INFO_MEMBER(get_rabbit_tilemap1_tile_info); |
| 144 | | TILE_GET_INFO_MEMBER(get_rabbit_tilemap2_tile_info); |
| 145 | | TILE_GET_INFO_MEMBER(get_rabbit_tilemap3_tile_info); |
| 150 | |
| 151 | TILE_GET_INFO_MEMBER(get_tilemap0_tile_info); |
| 152 | TILE_GET_INFO_MEMBER(get_tilemap1_tile_info); |
| 153 | TILE_GET_INFO_MEMBER(get_tilemap2_tile_info); |
| 154 | TILE_GET_INFO_MEMBER(get_tilemap3_tile_info); |
| 155 | |
| 156 | INTERRUPT_GEN_MEMBER(vblank_interrupt); |
| 157 | |
| 146 | 158 | virtual void video_start(); |
| 147 | | UINT32 screen_update_rabbit(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 148 | | INTERRUPT_GEN_MEMBER(rabbit_vblank_interrupt); |
| 149 | | inline void get_rabbit_tilemap_info(tile_data &tileinfo, int tile_index, int whichtilemap, int tilesize); |
| 159 | |
| 160 | UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 161 | inline void get_tilemap_info(tile_data &tileinfo, int tile_index, int whichtilemap, int tilesize); |
| 150 | 162 | void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect ); |
| 151 | | void rabbit_clearspritebitmap( bitmap_ind16 &bitmap, const rectangle &cliprect ); |
| 163 | void clearspritebitmap( bitmap_ind16 &bitmap, const rectangle &cliprect ); |
| 152 | 164 | void draw_sprite_bitmap( bitmap_ind16 &bitmap, const rectangle &cliprect ); |
| 153 | | void rabbit_drawtilemap( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int whichtilemap ); |
| 154 | | void rabbit_do_blit(); |
| 155 | | required_device<cpu_device> m_maincpu; |
| 156 | | required_device<eeprom_serial_93cxx_device> m_eeprom; |
| 157 | | required_device<gfxdecode_device> m_gfxdecode; |
| 158 | | required_device<palette_device> m_palette; |
| 165 | void drawtilemap( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int whichtilemap ); |
| 166 | void do_blit(); |
| 167 | |
| 159 | 168 | protected: |
| 160 | 169 | virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr); |
| 161 | 170 | }; |
| 162 | 171 | |
| 163 | 172 | |
| 164 | 173 | /* call with tilesize = 0 for 8x8 or 1 for 16x16 */ |
| 165 | | void rabbit_state::get_rabbit_tilemap_info(tile_data &tileinfo, int tile_index, int whichtilemap, int tilesize) |
| 174 | void rabbit_state::get_tilemap_info(tile_data &tileinfo, int tile_index, int whichtilemap, int tilesize) |
| 166 | 175 | { |
| 167 | 176 | /* fedcba98 76543210 fedcba98 76543210 |
| 168 | 177 | x color mask? how exactly does it relate to color bits? |
| r243434 | r243435 | |
| 222 | 231 | } |
| 223 | 232 | } |
| 224 | 233 | |
| 225 | | TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap0_tile_info) |
| 234 | TILE_GET_INFO_MEMBER(rabbit_state::get_tilemap0_tile_info) |
| 226 | 235 | { |
| 227 | | get_rabbit_tilemap_info(tileinfo,tile_index,0,1); |
| 236 | get_tilemap_info(tileinfo,tile_index,0,1); |
| 228 | 237 | } |
| 229 | 238 | |
| 230 | | TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap1_tile_info) |
| 239 | TILE_GET_INFO_MEMBER(rabbit_state::get_tilemap1_tile_info) |
| 231 | 240 | { |
| 232 | | get_rabbit_tilemap_info(tileinfo,tile_index,1,1); |
| 241 | get_tilemap_info(tileinfo,tile_index,1,1); |
| 233 | 242 | } |
| 234 | 243 | |
| 235 | | TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap2_tile_info) |
| 244 | TILE_GET_INFO_MEMBER(rabbit_state::get_tilemap2_tile_info) |
| 236 | 245 | { |
| 237 | | get_rabbit_tilemap_info(tileinfo,tile_index,2,1); |
| 246 | get_tilemap_info(tileinfo,tile_index,2,1); |
| 238 | 247 | } |
| 239 | 248 | |
| 240 | | TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap3_tile_info) |
| 249 | TILE_GET_INFO_MEMBER(rabbit_state::get_tilemap3_tile_info) |
| 241 | 250 | { |
| 242 | | get_rabbit_tilemap_info(tileinfo,tile_index,3,0); |
| 251 | get_tilemap_info(tileinfo,tile_index,3,0); |
| 243 | 252 | } |
| 244 | 253 | |
| 245 | | WRITE32_MEMBER(rabbit_state::rabbit_tilemap0_w) |
| 254 | WRITE32_MEMBER(rabbit_state::tilemap0_w) |
| 246 | 255 | { |
| 247 | 256 | COMBINE_DATA(&m_tilemap_ram[0][offset]); |
| 248 | 257 | m_tilemap[0]->mark_tile_dirty(offset); |
| 249 | 258 | } |
| 250 | 259 | |
| 251 | | WRITE32_MEMBER(rabbit_state::rabbit_tilemap1_w) |
| 260 | WRITE32_MEMBER(rabbit_state::tilemap1_w) |
| 252 | 261 | { |
| 253 | 262 | COMBINE_DATA(&m_tilemap_ram[1][offset]); |
| 254 | 263 | m_tilemap[1]->mark_tile_dirty(offset); |
| 255 | 264 | } |
| 256 | 265 | |
| 257 | | WRITE32_MEMBER(rabbit_state::rabbit_tilemap2_w) |
| 266 | WRITE32_MEMBER(rabbit_state::tilemap2_w) |
| 258 | 267 | { |
| 259 | 268 | COMBINE_DATA(&m_tilemap_ram[2][offset]); |
| 260 | 269 | m_tilemap[2]->mark_tile_dirty(offset); |
| 261 | 270 | } |
| 262 | 271 | |
| 263 | 272 | |
| 264 | | WRITE32_MEMBER(rabbit_state::rabbit_tilemap3_w) |
| 273 | WRITE32_MEMBER(rabbit_state::tilemap3_w) |
| 265 | 274 | { |
| 266 | 275 | COMBINE_DATA(&m_tilemap_ram[3][offset]); |
| 267 | 276 | m_tilemap[3]->mark_tile_dirty(offset); |
| r243434 | r243435 | |
| 323 | 332 | } |
| 324 | 333 | |
| 325 | 334 | /* the sprite bitmap can probably be handled better than this ... */ |
| 326 | | void rabbit_state::rabbit_clearspritebitmap( bitmap_ind16 &bitmap, const rectangle &cliprect ) |
| 335 | void rabbit_state::clearspritebitmap( bitmap_ind16 &bitmap, const rectangle &cliprect ) |
| 327 | 336 | { |
| 328 | 337 | int startx, starty; |
| 329 | 338 | int y; |
| r243434 | r243435 | |
| 411 | 420 | m_tilemap_ram[2] = auto_alloc_array_clear(machine(), UINT32, 0x20000/4); |
| 412 | 421 | m_tilemap_ram[3] = auto_alloc_array_clear(machine(), UINT32, 0x20000/4); |
| 413 | 422 | |
| 414 | | m_tilemap[0] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap0_tile_info),this),TILEMAP_SCAN_ROWS,16, 16, 128,32); |
| 415 | | m_tilemap[1] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap1_tile_info),this),TILEMAP_SCAN_ROWS,16, 16, 128,32); |
| 416 | | m_tilemap[2] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap2_tile_info),this),TILEMAP_SCAN_ROWS,16, 16, 128,32); |
| 417 | | m_tilemap[3] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap3_tile_info),this),TILEMAP_SCAN_ROWS, 8, 8, 128,32); |
| 423 | m_tilemap[0] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_tilemap0_tile_info),this),TILEMAP_SCAN_ROWS,16, 16, 128,32); |
| 424 | m_tilemap[1] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_tilemap1_tile_info),this),TILEMAP_SCAN_ROWS,16, 16, 128,32); |
| 425 | m_tilemap[2] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_tilemap2_tile_info),this),TILEMAP_SCAN_ROWS,16, 16, 128,32); |
| 426 | m_tilemap[3] = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(rabbit_state::get_tilemap3_tile_info),this),TILEMAP_SCAN_ROWS, 8, 8, 128,32); |
| 418 | 427 | |
| 419 | 428 | /* the tilemaps mix 4bpp and 8bbp tiles, we split these into 2 groups, and set a different transpen for each group */ |
| 420 | 429 | m_tilemap[0]->map_pen_to_layer(0, 15, TILEMAP_PIXEL_TRANSPARENT); |
| r243434 | r243435 | |
| 428 | 437 | |
| 429 | 438 | m_sprite_bitmap = auto_bitmap_ind16_alloc(machine(),0x1000,0x1000); |
| 430 | 439 | m_sprite_clip.set(0, 0x1000-1, 0, 0x1000-1); |
| 440 | |
| 441 | save_pointer(NAME(m_tilemap_ram[0]), 0x20000/4); |
| 442 | save_pointer(NAME(m_tilemap_ram[1]), 0x20000/4); |
| 443 | save_pointer(NAME(m_tilemap_ram[2]), 0x20000/4); |
| 444 | save_pointer(NAME(m_tilemap_ram[3]), 0x20000/4); |
| 431 | 445 | } |
| 432 | 446 | |
| 433 | 447 | /* |
| r243434 | r243435 | |
| 452 | 466 | |
| 453 | 467 | */ |
| 454 | 468 | |
| 455 | | void rabbit_state::rabbit_drawtilemap( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int whichtilemap ) |
| 469 | void rabbit_state::drawtilemap( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int whichtilemap ) |
| 456 | 470 | { |
| 457 | 471 | INT32 startx, starty, incxx, incxy, incyx, incyy, tran; |
| 458 | 472 | |
| r243434 | r243435 | |
| 475 | 489 | tran ? 0 : TILEMAP_DRAW_OPAQUE,0); |
| 476 | 490 | } |
| 477 | 491 | |
| 478 | | UINT32 rabbit_state::screen_update_rabbit(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 492 | UINT32 rabbit_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 479 | 493 | { |
| 480 | 494 | int prilevel; |
| 481 | 495 | |
| r243434 | r243435 | |
| 497 | 511 | /* prio isnt certain but seems to work.. */ |
| 498 | 512 | for (prilevel = 0xf; prilevel >0; prilevel--) |
| 499 | 513 | { |
| 500 | | if (prilevel == ((m_tilemap_regs[3][0]&0x0f000000)>>24)) rabbit_drawtilemap(screen,bitmap,cliprect, 3); |
| 501 | | if (prilevel == ((m_tilemap_regs[2][0]&0x0f000000)>>24)) rabbit_drawtilemap(screen,bitmap,cliprect, 2); |
| 502 | | if (prilevel == ((m_tilemap_regs[1][0]&0x0f000000)>>24)) rabbit_drawtilemap(screen,bitmap,cliprect, 1); |
| 503 | | if (prilevel == ((m_tilemap_regs[0][0]&0x0f000000)>>24)) rabbit_drawtilemap(screen,bitmap,cliprect, 0); |
| 514 | if (prilevel == ((m_tilemap_regs[3][0]&0x0f000000)>>24)) drawtilemap(screen,bitmap,cliprect, 3); |
| 515 | if (prilevel == ((m_tilemap_regs[2][0]&0x0f000000)>>24)) drawtilemap(screen,bitmap,cliprect, 2); |
| 516 | if (prilevel == ((m_tilemap_regs[1][0]&0x0f000000)>>24)) drawtilemap(screen,bitmap,cliprect, 1); |
| 517 | if (prilevel == ((m_tilemap_regs[0][0]&0x0f000000)>>24)) drawtilemap(screen,bitmap,cliprect, 0); |
| 504 | 518 | |
| 505 | 519 | if (prilevel == 0x09) // should it be selectable? |
| 506 | 520 | { |
| 507 | | rabbit_clearspritebitmap(bitmap,cliprect); |
| 521 | clearspritebitmap(bitmap,cliprect); |
| 508 | 522 | draw_sprites(bitmap,cliprect); // render to bitmap |
| 509 | 523 | draw_sprite_bitmap(bitmap,cliprect); // copy bitmap to screen |
| 510 | 524 | } |
| r243434 | r243435 | |
| 515 | 529 | |
| 516 | 530 | |
| 517 | 531 | |
| 518 | | READ32_MEMBER(rabbit_state::rabbit_tilemap0_r) |
| 532 | READ32_MEMBER(rabbit_state::tilemap0_r) |
| 519 | 533 | { |
| 520 | 534 | return m_tilemap_ram[0][offset]; |
| 521 | 535 | } |
| 522 | 536 | |
| 523 | | READ32_MEMBER(rabbit_state::rabbit_tilemap1_r) |
| 537 | READ32_MEMBER(rabbit_state::tilemap1_r) |
| 524 | 538 | { |
| 525 | 539 | return m_tilemap_ram[1][offset]; |
| 526 | 540 | } |
| 527 | 541 | |
| 528 | | READ32_MEMBER(rabbit_state::rabbit_tilemap2_r) |
| 542 | READ32_MEMBER(rabbit_state::tilemap2_r) |
| 529 | 543 | { |
| 530 | 544 | return m_tilemap_ram[2][offset]; |
| 531 | 545 | } |
| 532 | 546 | |
| 533 | | READ32_MEMBER(rabbit_state::rabbit_tilemap3_r) |
| 547 | READ32_MEMBER(rabbit_state::tilemap3_r) |
| 534 | 548 | { |
| 535 | 549 | return m_tilemap_ram[3][offset]; |
| 536 | 550 | } |
| r243434 | r243435 | |
| 541 | 555 | } |
| 542 | 556 | |
| 543 | 557 | /* rom bank is used when testing roms, not currently hooked up */ |
| 544 | | WRITE32_MEMBER(rabbit_state::rabbit_rombank_w) |
| 558 | WRITE32_MEMBER(rabbit_state::rombank_w) |
| 545 | 559 | { |
| 546 | 560 | UINT8 *dataroms = memregion("gfx1")->base(); |
| 547 | 561 | #if 0 |
| r243434 | r243435 | |
| 572 | 586 | } |
| 573 | 587 | } |
| 574 | 588 | |
| 575 | | void rabbit_state::rabbit_do_blit() |
| 589 | void rabbit_state::do_blit() |
| 576 | 590 | { |
| 577 | 591 | UINT8 *blt_data = memregion("gfx1")->base(); |
| 578 | 592 | int blt_source = (m_blitterregs[0]&0x000fffff)>>0; |
| r243434 | r243435 | |
| 667 | 681 | |
| 668 | 682 | |
| 669 | 683 | |
| 670 | | WRITE32_MEMBER(rabbit_state::rabbit_blitter_w) |
| 684 | WRITE32_MEMBER(rabbit_state::blitter_w) |
| 671 | 685 | { |
| 672 | 686 | COMBINE_DATA(&m_blitterregs[offset]); |
| 673 | 687 | |
| 674 | 688 | if (offset == 0x0c/4) |
| 675 | 689 | { |
| 676 | | rabbit_do_blit(); |
| 690 | do_blit(); |
| 677 | 691 | } |
| 678 | 692 | } |
| 679 | 693 | |
| 680 | | WRITE32_MEMBER(rabbit_state::rabbit_eeprom_write) |
| 694 | WRITE32_MEMBER(rabbit_state::eeprom_write) |
| 681 | 695 | { |
| 682 | 696 | // don't disturb the EEPROM if we're not actually writing to it |
| 683 | 697 | // (in particular, data & 0x100 here with mask = ffff00ff looks to be the watchdog) |
| r243434 | r243435 | |
| 700 | 714 | AM_RANGE(0x000010, 0x000013) AM_WRITENOP // bug in code / emulation? |
| 701 | 715 | AM_RANGE(0x000024, 0x000027) AM_WRITENOP // bug in code / emulation? |
| 702 | 716 | AM_RANGE(0x00719c, 0x00719f) AM_WRITENOP // bug in code / emulation? |
| 703 | | AM_RANGE(0x200000, 0x200003) AM_READ_PORT("INPUTS") AM_WRITE(rabbit_eeprom_write) |
| 717 | AM_RANGE(0x200000, 0x200003) AM_READ_PORT("INPUTS") AM_WRITE(eeprom_write) |
| 704 | 718 | AM_RANGE(0x400010, 0x400013) AM_READ(randomrabbits) // gfx chip status? |
| 705 | 719 | /* this lot are probably gfxchip/blitter etc. related */ |
| 706 | 720 | AM_RANGE(0x400010, 0x400013) AM_WRITEONLY AM_SHARE("viewregs0" ) |
| r243434 | r243435 | |
| 709 | 723 | AM_RANGE(0x400140, 0x400157) AM_WRITEONLY AM_SHARE("tilemap_regs.2" ) // tilemap regs3 |
| 710 | 724 | AM_RANGE(0x400160, 0x400177) AM_WRITEONLY AM_SHARE("tilemap_regs.3" ) // tilemap regs4 |
| 711 | 725 | AM_RANGE(0x400200, 0x40021b) AM_WRITEONLY AM_SHARE("spriteregs" ) // sprregs? |
| 712 | | AM_RANGE(0x400300, 0x400303) AM_WRITE(rabbit_rombank_w) // used during rom testing, rombank/area select + something else? |
| 726 | AM_RANGE(0x400300, 0x400303) AM_WRITE(rombank_w) // used during rom testing, rombank/area select + something else? |
| 713 | 727 | AM_RANGE(0x400400, 0x400413) AM_WRITEONLY AM_SHARE("viewregs6" ) // some global controls? (brightness etc.?) |
| 714 | 728 | AM_RANGE(0x400500, 0x400503) AM_WRITEONLY AM_SHARE("viewregs7" ) |
| 715 | | AM_RANGE(0x400700, 0x40070f) AM_WRITE(rabbit_blitter_w) AM_SHARE("blitterregs" ) |
| 729 | AM_RANGE(0x400700, 0x40070f) AM_WRITE(blitter_w) AM_SHARE("blitterregs" ) |
| 716 | 730 | AM_RANGE(0x400800, 0x40080f) AM_WRITEONLY AM_SHARE("viewregs9" ) // never changes? |
| 717 | 731 | AM_RANGE(0x400900, 0x4009ff) AM_DEVREADWRITE16("i5000snd", i5000snd_device, read, write, 0xffffffff) |
| 718 | 732 | /* hmm */ |
| r243434 | r243435 | |
| 720 | 734 | |
| 721 | 735 | AM_RANGE(0x440000, 0x47ffff) AM_ROMBANK("bank1") // data (gfx / sound) rom readback for ROM testing |
| 722 | 736 | /* tilemaps */ |
| 723 | | AM_RANGE(0x480000, 0x483fff) AM_READWRITE(rabbit_tilemap0_r,rabbit_tilemap0_w) |
| 724 | | AM_RANGE(0x484000, 0x487fff) AM_READWRITE(rabbit_tilemap1_r,rabbit_tilemap1_w) |
| 725 | | AM_RANGE(0x488000, 0x48bfff) AM_READWRITE(rabbit_tilemap2_r,rabbit_tilemap2_w) |
| 726 | | AM_RANGE(0x48c000, 0x48ffff) AM_READWRITE(rabbit_tilemap3_r,rabbit_tilemap3_w) |
| 737 | AM_RANGE(0x480000, 0x483fff) AM_READWRITE(tilemap0_r,tilemap0_w) |
| 738 | AM_RANGE(0x484000, 0x487fff) AM_READWRITE(tilemap1_r,tilemap1_w) |
| 739 | AM_RANGE(0x488000, 0x48bfff) AM_READWRITE(tilemap2_r,tilemap2_w) |
| 740 | AM_RANGE(0x48c000, 0x48ffff) AM_READWRITE(tilemap3_r,tilemap3_w) |
| 727 | 741 | AM_RANGE(0x494000, 0x497fff) AM_RAM AM_SHARE("spriteram") // sprites? |
| 728 | 742 | AM_RANGE(0x4a0000, 0x4affff) AM_RAM_DEVWRITE("palette", palette_device, write) AM_SHARE("palette") |
| 729 | 743 | AM_RANGE(0xff0000, 0xffffff) AM_RAM |
| r243434 | r243435 | |
| 761 | 775 | INPUT_PORTS_END |
| 762 | 776 | |
| 763 | 777 | |
| 764 | | static const gfx_layout rabbit_sprite_8x8x4_layout = |
| 778 | static const gfx_layout sprite_8x8x4_layout = |
| 765 | 779 | { |
| 766 | 780 | 8,8, |
| 767 | 781 | RGN_FRAC(1,1), |
| r243434 | r243435 | |
| 772 | 786 | 8*32 |
| 773 | 787 | }; |
| 774 | 788 | |
| 775 | | static const gfx_layout rabbit_sprite_8x8x8_layout = |
| 789 | static const gfx_layout sprite_8x8x8_layout = |
| 776 | 790 | { |
| 777 | 791 | 8,8, |
| 778 | 792 | RGN_FRAC(1,1), |
| r243434 | r243435 | |
| 785 | 799 | |
| 786 | 800 | |
| 787 | 801 | |
| 788 | | static const gfx_layout rabbit_sprite_16x16x4_layout = |
| 802 | static const gfx_layout sprite_16x16x4_layout = |
| 789 | 803 | { |
| 790 | 804 | 16,16, |
| 791 | 805 | RGN_FRAC(1,2), |
| r243434 | r243435 | |
| 796 | 810 | 16*32 |
| 797 | 811 | }; |
| 798 | 812 | |
| 799 | | static const gfx_layout rabbit_sprite_16x16x8_layout = |
| 813 | static const gfx_layout sprite_16x16x8_layout = |
| 800 | 814 | { |
| 801 | 815 | 16,16, |
| 802 | 816 | RGN_FRAC(1,2), |
| r243434 | r243435 | |
| 807 | 821 | 16*64 |
| 808 | 822 | }; |
| 809 | 823 | |
| 810 | | static const gfx_layout rabbit_8x8x4_layout = |
| 824 | static const gfx_layout _8x8x4_layout = |
| 811 | 825 | { |
| 812 | 826 | 8,8, |
| 813 | 827 | RGN_FRAC(1,1), |
| r243434 | r243435 | |
| 818 | 832 | 8*32 |
| 819 | 833 | }; |
| 820 | 834 | |
| 821 | | static const gfx_layout rabbit_16x16x4_layout = |
| 835 | static const gfx_layout _16x16x4_layout = |
| 822 | 836 | { |
| 823 | 837 | 16,16, |
| 824 | 838 | RGN_FRAC(1,1), |
| r243434 | r243435 | |
| 829 | 843 | 16*64 |
| 830 | 844 | }; |
| 831 | 845 | |
| 832 | | static const gfx_layout rabbit_8x8x8_layout = |
| 846 | static const gfx_layout _8x8x8_layout = |
| 833 | 847 | { |
| 834 | 848 | 8,8, |
| 835 | 849 | RGN_FRAC(1,1), |
| r243434 | r243435 | |
| 840 | 854 | 8*64 |
| 841 | 855 | }; |
| 842 | 856 | |
| 843 | | static const gfx_layout rabbit_16x16x8_layout = |
| 857 | static const gfx_layout _16x16x8_layout = |
| 844 | 858 | { |
| 845 | 859 | 16,16, |
| 846 | 860 | RGN_FRAC(1,1), |
| r243434 | r243435 | |
| 855 | 869 | |
| 856 | 870 | static GFXDECODE_START( rabbit ) |
| 857 | 871 | /* this seems to be sprites */ |
| 858 | | GFXDECODE_ENTRY( "gfx1", 0, rabbit_sprite_8x8x4_layout, 0x0, 0x1000 ) |
| 859 | | GFXDECODE_ENTRY( "gfx1", 0, rabbit_sprite_16x16x4_layout, 0x0, 0x1000 ) |
| 860 | | GFXDECODE_ENTRY( "gfx1", 0, rabbit_sprite_8x8x8_layout, 0x0, 0x1000 ) // wrong |
| 861 | | GFXDECODE_ENTRY( "gfx1", 0, rabbit_sprite_16x16x8_layout, 0x0, 0x1000 ) // wrong |
| 872 | GFXDECODE_ENTRY( "gfx1", 0, sprite_8x8x4_layout, 0x0, 0x1000 ) |
| 873 | GFXDECODE_ENTRY( "gfx1", 0, sprite_16x16x4_layout, 0x0, 0x1000 ) |
| 874 | GFXDECODE_ENTRY( "gfx1", 0, sprite_8x8x8_layout, 0x0, 0x1000 ) // wrong |
| 875 | GFXDECODE_ENTRY( "gfx1", 0, sprite_16x16x8_layout, 0x0, 0x1000 ) // wrong |
| 862 | 876 | |
| 863 | 877 | /* this seems to be backgrounds and tilemap gfx */ |
| 864 | | GFXDECODE_ENTRY( "gfx2", 0, rabbit_8x8x4_layout, 0x0, 0x1000 ) |
| 865 | | GFXDECODE_ENTRY( "gfx2", 0, rabbit_16x16x4_layout, 0x0, 0x1000 ) |
| 866 | | GFXDECODE_ENTRY( "gfx2", 0, rabbit_8x8x8_layout, 0x0, 0x1000 ) |
| 867 | | GFXDECODE_ENTRY( "gfx2", 0, rabbit_16x16x8_layout, 0x0, 0x1000 ) |
| 878 | GFXDECODE_ENTRY( "gfx2", 0, _8x8x4_layout, 0x0, 0x1000 ) |
| 879 | GFXDECODE_ENTRY( "gfx2", 0, _16x16x4_layout, 0x0, 0x1000 ) |
| 880 | GFXDECODE_ENTRY( "gfx2", 0, _8x8x8_layout, 0x0, 0x1000 ) |
| 881 | GFXDECODE_ENTRY( "gfx2", 0, _16x16x8_layout, 0x0, 0x1000 ) |
| 868 | 882 | |
| 869 | 883 | GFXDECODE_END |
| 870 | 884 | |
| r243434 | r243435 | |
| 875 | 889 | |
| 876 | 890 | */ |
| 877 | 891 | |
| 878 | | INTERRUPT_GEN_MEMBER(rabbit_state::rabbit_vblank_interrupt) |
| 892 | INTERRUPT_GEN_MEMBER(rabbit_state::vblank_interrupt) |
| 879 | 893 | { |
| 880 | 894 | m_maincpu->set_input_line(m_vblirqlevel, HOLD_LINE); |
| 881 | 895 | } |
| r243434 | r243435 | |
| 883 | 897 | static MACHINE_CONFIG_START( rabbit, rabbit_state ) |
| 884 | 898 | MCFG_CPU_ADD("maincpu", M68EC020, XTAL_24MHz) |
| 885 | 899 | MCFG_CPU_PROGRAM_MAP(rabbit_map) |
| 886 | | MCFG_CPU_VBLANK_INT_DRIVER("screen", rabbit_state, rabbit_vblank_interrupt) |
| 900 | MCFG_CPU_VBLANK_INT_DRIVER("screen", rabbit_state, vblank_interrupt) |
| 887 | 901 | |
| 888 | 902 | MCFG_EEPROM_SERIAL_93C46_ADD("eeprom") |
| 889 | 903 | |
| r243434 | r243435 | |
| 896 | 910 | MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1) |
| 897 | 911 | // MCFG_SCREEN_VISIBLE_AREA(0*8, 64*16-1, 0*16, 64*16-1) |
| 898 | 912 | // MCFG_SCREEN_VISIBLE_AREA(0*8, 20*16-1, 32*16, 48*16-1) |
| 899 | | MCFG_SCREEN_UPDATE_DRIVER(rabbit_state, screen_update_rabbit) |
| 913 | MCFG_SCREEN_UPDATE_DRIVER(rabbit_state, screen_update) |
| 900 | 914 | MCFG_SCREEN_PALETTE("palette") |
| 901 | 915 | |
| 902 | 916 | MCFG_PALETTE_ADD_INIT_BLACK("palette", 0x4000) |
| r243434 | r243435 | |
| 966 | 980 | ROM_END |
| 967 | 981 | |
| 968 | 982 | |
| 969 | | GAME( 1997, rabbit, 0, rabbit, rabbit, rabbit_state, rabbit, ROT0, "Aorn / Electronic Arts", "Rabbit (Japan)", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND ) // somewhat playable |
| 983 | GAME( 1997, rabbit, 0, rabbit, rabbit, rabbit_state, rabbit, ROT0, "Aorn / Electronic Arts", "Rabbit (Japan)", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) // somewhat playable |
trunk/src/mame/drivers/tmmjprd.c
| r243434 | r243435 | |
| 39 | 39 | public: |
| 40 | 40 | tmmjprd_state(const machine_config &mconfig, device_type type, const char *tag) |
| 41 | 41 | : driver_device(mconfig, type, tag), |
| 42 | | m_tilemap_regs(*this, "tilemap_regs"), |
| 43 | | m_spriteregs(*this, "spriteregs"), |
| 44 | | m_spriteram(*this, "spriteram") , |
| 45 | 42 | m_maincpu(*this, "maincpu"), |
| 46 | 43 | m_eeprom(*this, "eeprom"), |
| 47 | 44 | m_gfxdecode(*this, "gfxdecode"), |
| 48 | | m_palette(*this, "palette") { } |
| 45 | m_palette(*this, "palette"), |
| 46 | m_tilemap_regs(*this, "tilemap_regs"), |
| 47 | m_spriteregs(*this, "spriteregs"), |
| 48 | m_spriteram(*this, "spriteram") { } |
| 49 | 49 | |
| 50 | required_device<cpu_device> m_maincpu; |
| 51 | required_device<eeprom_serial_93cxx_device> m_eeprom; |
| 52 | required_device<gfxdecode_device> m_gfxdecode; |
| 53 | required_device<palette_device> m_palette; |
| 54 | |
| 50 | 55 | required_shared_ptr_array<UINT32, 4> m_tilemap_regs; |
| 51 | 56 | required_shared_ptr<UINT32> m_spriteregs; |
| 57 | required_shared_ptr<UINT32> m_spriteram; |
| 58 | |
| 52 | 59 | UINT32 *m_tilemap_ram[4]; |
| 53 | | required_shared_ptr<UINT32> m_spriteram; |
| 54 | 60 | UINT8 m_mux_data; |
| 55 | 61 | UINT8 m_system_in; |
| 56 | 62 | double m_old_brt1; |
| 57 | 63 | double m_old_brt2; |
| 58 | | DECLARE_WRITE32_MEMBER(tmmjprd_tilemap0_w); |
| 59 | | DECLARE_WRITE32_MEMBER(tmmjprd_tilemap1_w); |
| 60 | | DECLARE_WRITE32_MEMBER(tmmjprd_tilemap2_w); |
| 61 | | DECLARE_WRITE32_MEMBER(tmmjprd_tilemap3_w); |
| 62 | | DECLARE_READ32_MEMBER(tmmjprd_tilemap0_r); |
| 63 | | DECLARE_READ32_MEMBER(tmmjprd_tilemap1_r); |
| 64 | | DECLARE_READ32_MEMBER(tmmjprd_tilemap2_r); |
| 65 | | DECLARE_READ32_MEMBER(tmmjprd_tilemap3_r); |
| 64 | |
| 65 | DECLARE_WRITE32_MEMBER(tilemap0_w); |
| 66 | DECLARE_WRITE32_MEMBER(tilemap1_w); |
| 67 | DECLARE_WRITE32_MEMBER(tilemap2_w); |
| 68 | DECLARE_WRITE32_MEMBER(tilemap3_w); |
| 69 | DECLARE_READ32_MEMBER(tilemap0_r); |
| 70 | DECLARE_READ32_MEMBER(tilemap1_r); |
| 71 | DECLARE_READ32_MEMBER(tilemap2_r); |
| 72 | DECLARE_READ32_MEMBER(tilemap3_r); |
| 66 | 73 | DECLARE_READ32_MEMBER(randomtmmjprds); |
| 67 | | DECLARE_WRITE32_MEMBER(tmmjprd_blitter_w); |
| 68 | | DECLARE_READ32_MEMBER(tmmjprd_mux_r); |
| 69 | | DECLARE_WRITE32_MEMBER(tmmjprd_brt_1_w); |
| 70 | | DECLARE_WRITE32_MEMBER(tmmjprd_brt_2_w); |
| 71 | | DECLARE_WRITE32_MEMBER(tmmjprd_eeprom_write); |
| 74 | DECLARE_WRITE32_MEMBER(blitter_w); |
| 75 | DECLARE_READ32_MEMBER(mux_r); |
| 76 | DECLARE_WRITE32_MEMBER(brt_1_w); |
| 77 | DECLARE_WRITE32_MEMBER(brt_2_w); |
| 78 | DECLARE_WRITE32_MEMBER(eeprom_write); |
| 79 | |
| 80 | virtual void machine_start(); |
| 72 | 81 | virtual void video_start(); |
| 73 | | UINT32 screen_update_tmmjprd_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 74 | | UINT32 screen_update_tmmjprd_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 75 | | TIMER_CALLBACK_MEMBER(tmmjprd_blit_done); |
| 76 | | TIMER_DEVICE_CALLBACK_MEMBER(tmmjprd_scanline); |
| 82 | |
| 83 | UINT32 screen_update_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 84 | UINT32 screen_update_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 85 | |
| 86 | TIMER_CALLBACK_MEMBER(blit_done); |
| 87 | TIMER_DEVICE_CALLBACK_MEMBER(scanline); |
| 88 | |
| 77 | 89 | void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int screen); |
| 78 | | void ttmjprd_draw_tile(bitmap_ind16 &bitmap, const rectangle &cliprect, int x,int y,int sizex,int sizey, UINT32 tiledata, UINT8* rom); |
| 79 | | void ttmjprd_draw_tilemap(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32*tileram, UINT32*tileregs, UINT8*rom ); |
| 80 | | void tmmjprd_do_blit(); |
| 81 | | required_device<cpu_device> m_maincpu; |
| 82 | | required_device<eeprom_serial_93cxx_device> m_eeprom; |
| 83 | | required_device<gfxdecode_device> m_gfxdecode; |
| 84 | | required_device<palette_device> m_palette; |
| 90 | void draw_tile(bitmap_ind16 &bitmap, const rectangle &cliprect, int x,int y,int sizex,int sizey, UINT32 tiledata, UINT8* rom); |
| 91 | void draw_tilemap(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32*tileram, UINT32*tileregs, UINT8*rom ); |
| 92 | void do_blit(); |
| 85 | 93 | }; |
| 86 | 94 | |
| 87 | 95 | |
| 88 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_tilemap0_w) |
| 96 | WRITE32_MEMBER(tmmjprd_state::tilemap0_w) |
| 89 | 97 | { |
| 90 | 98 | COMBINE_DATA(&m_tilemap_ram[0][offset]); |
| 91 | 99 | } |
| 92 | 100 | |
| 93 | 101 | |
| 94 | 102 | |
| 95 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_tilemap1_w) |
| 103 | WRITE32_MEMBER(tmmjprd_state::tilemap1_w) |
| 96 | 104 | { |
| 97 | 105 | COMBINE_DATA(&m_tilemap_ram[1][offset]); |
| 98 | 106 | } |
| 99 | 107 | |
| 100 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_tilemap2_w) |
| 108 | WRITE32_MEMBER(tmmjprd_state::tilemap2_w) |
| 101 | 109 | { |
| 102 | 110 | COMBINE_DATA(&m_tilemap_ram[2][offset]); |
| 103 | 111 | } |
| 104 | 112 | |
| 105 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_tilemap3_w) |
| 113 | WRITE32_MEMBER(tmmjprd_state::tilemap3_w) |
| 106 | 114 | { |
| 107 | 115 | COMBINE_DATA(&m_tilemap_ram[3][offset]); |
| 108 | 116 | } |
| r243434 | r243435 | |
| 183 | 191 | } |
| 184 | 192 | } |
| 185 | 193 | |
| 186 | | void tmmjprd_state::ttmjprd_draw_tile(bitmap_ind16 &bitmap, const rectangle &cliprect, int x,int y,int sizex,int sizey, UINT32 tiledata, UINT8* rom) |
| 194 | void tmmjprd_state::draw_tile(bitmap_ind16 &bitmap, const rectangle &cliprect, int x,int y,int sizex,int sizey, UINT32 tiledata, UINT8* rom) |
| 187 | 195 | { |
| 188 | 196 | /* note, it's tile address _NOT_ tile number, 'sub-tile' access is possible, hence using the custom rendering */ |
| 189 | 197 | int tileaddr = (tiledata&0x000fffff)>>0; |
| r243434 | r243435 | |
| 262 | 270 | } |
| 263 | 271 | } |
| 264 | 272 | |
| 265 | | void tmmjprd_state::ttmjprd_draw_tilemap(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32*tileram, UINT32*tileregs, UINT8*rom ) |
| 273 | void tmmjprd_state::draw_tilemap(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32*tileram, UINT32*tileregs, UINT8*rom ) |
| 266 | 274 | { |
| 267 | 275 | int y,x; |
| 268 | 276 | int count; |
| r243434 | r243435 | |
| 296 | 304 | { |
| 297 | 305 | UINT32 tiledata = tileram[count]; |
| 298 | 306 | // todo: handle wraparound |
| 299 | | ttmjprd_draw_tile(bitmap,cliprect,(x*tile_sizex)-scrollx,(y*tile_sizey)-scrolly,tile_sizex,tile_sizey, tiledata, rom); |
| 307 | draw_tile(bitmap,cliprect,(x*tile_sizex)-scrollx,(y*tile_sizey)-scrolly,tile_sizex,tile_sizey, tiledata, rom); |
| 300 | 308 | count++; |
| 301 | 309 | } |
| 302 | 310 | } |
| 303 | 311 | |
| 304 | 312 | } |
| 305 | 313 | |
| 306 | | UINT32 tmmjprd_state::screen_update_tmmjprd_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 314 | UINT32 tmmjprd_state::screen_update_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 307 | 315 | { |
| 308 | 316 | UINT8* gfxroms = memregion("gfx2")->base(); |
| 309 | 317 | |
| 310 | 318 | bitmap.fill(m_palette->black_pen(), cliprect); |
| 311 | 319 | |
| 312 | | ttmjprd_draw_tilemap(bitmap, cliprect, m_tilemap_ram[3], m_tilemap_regs[3], gfxroms ); |
| 320 | draw_tilemap(bitmap, cliprect, m_tilemap_ram[3], m_tilemap_regs[3], gfxroms ); |
| 313 | 321 | draw_sprites(bitmap,cliprect, 1); |
| 314 | | ttmjprd_draw_tilemap(bitmap, cliprect, m_tilemap_ram[2], m_tilemap_regs[2], gfxroms ); |
| 322 | draw_tilemap(bitmap, cliprect, m_tilemap_ram[2], m_tilemap_regs[2], gfxroms ); |
| 315 | 323 | |
| 316 | 324 | /* |
| 317 | 325 | popmessage("%08x %08x %08x %08x %08x %08x", |
| r243434 | r243435 | |
| 337 | 345 | return 0; |
| 338 | 346 | } |
| 339 | 347 | |
| 340 | | UINT32 tmmjprd_state::screen_update_tmmjprd_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 348 | UINT32 tmmjprd_state::screen_update_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
| 341 | 349 | { |
| 342 | 350 | UINT8* gfxroms = memregion("gfx2")->base(); |
| 343 | 351 | |
| 344 | 352 | bitmap.fill(m_palette->black_pen(), cliprect); |
| 345 | 353 | |
| 346 | | ttmjprd_draw_tilemap(bitmap, cliprect, m_tilemap_ram[1], m_tilemap_regs[1], gfxroms ); |
| 354 | draw_tilemap(bitmap, cliprect, m_tilemap_ram[1], m_tilemap_regs[1], gfxroms ); |
| 347 | 355 | draw_sprites(bitmap,cliprect, 0); |
| 348 | | ttmjprd_draw_tilemap(bitmap, cliprect, m_tilemap_ram[0], m_tilemap_regs[0], gfxroms ); |
| 356 | draw_tilemap(bitmap, cliprect, m_tilemap_ram[0], m_tilemap_regs[0], gfxroms ); |
| 349 | 357 | |
| 350 | 358 | return 0; |
| 351 | 359 | } |
| r243434 | r243435 | |
| 358 | 366 | m_tilemap_ram[1] = auto_alloc_array_clear(machine(), UINT32, 0x8000); |
| 359 | 367 | m_tilemap_ram[2] = auto_alloc_array_clear(machine(), UINT32, 0x8000); |
| 360 | 368 | m_tilemap_ram[3] = auto_alloc_array_clear(machine(), UINT32, 0x8000); |
| 369 | |
| 370 | |
| 371 | save_pointer(NAME(m_tilemap_ram[0]), 0x8000); |
| 372 | save_pointer(NAME(m_tilemap_ram[1]), 0x8000); |
| 373 | save_pointer(NAME(m_tilemap_ram[2]), 0x8000); |
| 374 | save_pointer(NAME(m_tilemap_ram[3]), 0x8000); |
| 375 | |
| 376 | save_item(NAME(m_old_brt1)); |
| 377 | save_item(NAME(m_old_brt2)); |
| 361 | 378 | } |
| 362 | 379 | |
| 363 | | READ32_MEMBER(tmmjprd_state::tmmjprd_tilemap0_r) |
| 380 | READ32_MEMBER(tmmjprd_state::tilemap0_r) |
| 364 | 381 | { |
| 365 | 382 | return m_tilemap_ram[0][offset]; |
| 366 | 383 | } |
| 367 | 384 | |
| 368 | | READ32_MEMBER(tmmjprd_state::tmmjprd_tilemap1_r) |
| 385 | READ32_MEMBER(tmmjprd_state::tilemap1_r) |
| 369 | 386 | { |
| 370 | 387 | return m_tilemap_ram[1][offset]; |
| 371 | 388 | } |
| 372 | 389 | |
| 373 | | READ32_MEMBER(tmmjprd_state::tmmjprd_tilemap2_r) |
| 390 | READ32_MEMBER(tmmjprd_state::tilemap2_r) |
| 374 | 391 | { |
| 375 | 392 | return m_tilemap_ram[2][offset]; |
| 376 | 393 | } |
| 377 | 394 | |
| 378 | | READ32_MEMBER(tmmjprd_state::tmmjprd_tilemap3_r) |
| 395 | READ32_MEMBER(tmmjprd_state::tilemap3_r) |
| 379 | 396 | { |
| 380 | 397 | return m_tilemap_ram[3][offset]; |
| 381 | 398 | } |
| r243434 | r243435 | |
| 390 | 407 | #define BLITLOG 0 |
| 391 | 408 | |
| 392 | 409 | #if 0 |
| 393 | | TIMER_CALLBACK_MEMBER(tmmjprd_state::tmmjprd_blit_done) |
| 410 | TIMER_CALLBACK_MEMBER(tmmjprd_state::blit_done) |
| 394 | 411 | { |
| 395 | 412 | m_maincpu->set_input_line(3, HOLD_LINE); |
| 396 | 413 | } |
| 397 | 414 | |
| 398 | | void tmmjprd_state::tmmjprd_do_blit() |
| 415 | void tmmjprd_state::do_blit() |
| 399 | 416 | { |
| 400 | 417 | UINT8 *blt_data = memregion("gfx1")->base(); |
| 401 | | int blt_source = (tmmjprd_blitterregs[0]&0x000fffff)>>0; |
| 402 | | int blt_column = (tmmjprd_blitterregs[1]&0x00ff0000)>>16; |
| 403 | | int blt_line = (tmmjprd_blitterregs[1]&0x000000ff); |
| 404 | | int blt_tilemp = (tmmjprd_blitterregs[2]&0x0000e000)>>13; |
| 405 | | int blt_oddflg = (tmmjprd_blitterregs[2]&0x00000001)>>0; |
| 418 | int blt_source = (m_blitterregs[0]&0x000fffff)>>0; |
| 419 | int blt_column = (m_blitterregs[1]&0x00ff0000)>>16; |
| 420 | int blt_line = (m_blitterregs[1]&0x000000ff); |
| 421 | int blt_tilemp = (m_blitterregs[2]&0x0000e000)>>13; |
| 422 | int blt_oddflg = (m_blitterregs[2]&0x00000001)>>0; |
| 406 | 423 | int mask,shift; |
| 407 | 424 | |
| 408 | 425 | |
| 409 | | if(BLITCMDLOG) osd_printf_debug("BLIT command %08x %08x %08x\n", tmmjprd_blitterregs[0], tmmjprd_blitterregs[1], tmmjprd_blitterregs[2]); |
| 426 | if(BLITCMDLOG) osd_printf_debug("BLIT command %08x %08x %08x\n", m_blitterregs[0], m_blitterregs[1], m_blitterregs[2]); |
| 410 | 427 | |
| 411 | 428 | if (blt_oddflg&1) |
| 412 | 429 | { |
| r243434 | r243435 | |
| 439 | 456 | if (!blt_amount) |
| 440 | 457 | { |
| 441 | 458 | if(BLITLOG) osd_printf_debug("end of blit list\n"); |
| 442 | | machine().scheduler().timer_set(attotime::from_usec(500), timer_expired_delegate(FUNC(tmmjprd_state::tmmjprd_blit_done),this)); |
| 459 | machine().scheduler().timer_set(attotime::from_usec(500), timer_expired_delegate(FUNC(tmmjprd_state::blit_done),this)); |
| 443 | 460 | return; |
| 444 | 461 | } |
| 445 | 462 | |
| r243434 | r243435 | |
| 450 | 467 | blt_source+=2; |
| 451 | 468 | writeoffs=blt_oddflg+blt_column; |
| 452 | 469 | m_tilemap_ram[blt_tilemp][writeoffs]=(m_tilemap_ram[blt_tilemp][writeoffs]&mask)|(blt_value<<shift); |
| 453 | | tmmjprd_tilemap[blt_tilemp]->mark_tile_dirty(writeoffs); |
| 470 | m_tilemap[blt_tilemp]->mark_tile_dirty(writeoffs); |
| 454 | 471 | |
| 455 | 472 | blt_column++; |
| 456 | 473 | blt_column&=0x7f; |
| r243434 | r243435 | |
| 467 | 484 | { |
| 468 | 485 | writeoffs=blt_oddflg+blt_column; |
| 469 | 486 | m_tilemap_ram[blt_tilemp][writeoffs]=(m_tilemap_ram[blt_tilemp][writeoffs]&mask)|(blt_value<<shift); |
| 470 | | tmmjprd_tilemap[blt_tilemp]->mark_tile_dirty(writeoffs); |
| 487 | m_tilemap[blt_tilemp]->mark_tile_dirty(writeoffs); |
| 471 | 488 | blt_column++; |
| 472 | 489 | blt_column&=0x7f; |
| 473 | 490 | } |
| r243434 | r243435 | |
| 476 | 493 | |
| 477 | 494 | case 0x03: /* next line */ |
| 478 | 495 | if(BLITLOG) osd_printf_debug("blit: move to next line\n"); |
| 479 | | blt_column = (tmmjprd_blitterregs[1]&0x00ff0000)>>16; /* --CC---- */ |
| 496 | blt_column = (m_blitterregs[1]&0x00ff0000)>>16; /* --CC---- */ |
| 480 | 497 | blt_oddflg+=128; |
| 481 | 498 | break; |
| 482 | 499 | |
| r243434 | r243435 | |
| 490 | 507 | |
| 491 | 508 | |
| 492 | 509 | |
| 493 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_blitter_w) |
| 510 | WRITE32_MEMBER(tmmjprd_state::blitter_w) |
| 494 | 511 | { |
| 495 | | COMBINE_DATA(&tmmjprd_blitterregs[offset]); |
| 512 | COMBINE_DATA(&m_blitterregs[offset]); |
| 496 | 513 | |
| 497 | 514 | if (offset == 0x0c/4) |
| 498 | 515 | { |
| 499 | | tmmjprd_do_blit(machine()); |
| 516 | do_blit(); |
| 500 | 517 | } |
| 501 | 518 | } |
| 502 | 519 | #endif |
| 503 | 520 | |
| 521 | void tmmjprd_state::machine_start() |
| 522 | { |
| 523 | save_item(NAME(m_mux_data)); |
| 524 | save_item(NAME(m_system_in)); |
| 525 | } |
| 504 | 526 | |
| 505 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_eeprom_write) |
| 527 | WRITE32_MEMBER(tmmjprd_state::eeprom_write) |
| 506 | 528 | { |
| 507 | 529 | // don't disturb the EEPROM if we're not actually writing to it |
| 508 | 530 | // (in particular, data & 0x100 here with mask = ffff00ff looks to be the watchdog) |
| r243434 | r243435 | |
| 522 | 544 | } |
| 523 | 545 | } |
| 524 | 546 | |
| 525 | | READ32_MEMBER(tmmjprd_state::tmmjprd_mux_r) |
| 547 | READ32_MEMBER(tmmjprd_state::mux_r) |
| 526 | 548 | { |
| 527 | 549 | m_system_in = ioport("SYSTEM")->read(); |
| 528 | 550 | |
| r243434 | r243435 | |
| 629 | 651 | |
| 630 | 652 | /* notice that data & 0x4 is always cleared on brt_1 and set on brt_2. * |
| 631 | 653 | * My wild guess is that bits 0,1 and 2 controls what palette entries to dim. */ |
| 632 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_brt_1_w) |
| 654 | WRITE32_MEMBER(tmmjprd_state::brt_1_w) |
| 633 | 655 | { |
| 634 | 656 | int i; |
| 635 | 657 | double brt; |
| r243434 | r243435 | |
| 647 | 669 | } |
| 648 | 670 | } |
| 649 | 671 | |
| 650 | | WRITE32_MEMBER(tmmjprd_state::tmmjprd_brt_2_w) |
| 672 | WRITE32_MEMBER(tmmjprd_state::brt_2_w) |
| 651 | 673 | { |
| 652 | 674 | int i; |
| 653 | 675 | double brt; |
| r243434 | r243435 | |
| 669 | 691 | AM_RANGE(0x000000, 0x1fffff) AM_ROM |
| 670 | 692 | AM_RANGE(0x200010, 0x200013) AM_READ(randomtmmjprds) // gfx chip status? |
| 671 | 693 | /* check these are used .. */ |
| 672 | | // AM_RANGE(0x200010, 0x200013) AM_WRITEONLY AM_SHARE("tmmjprd_viewregs0") |
| 694 | // AM_RANGE(0x200010, 0x200013) AM_WRITEONLY AM_SHARE("viewregs0") |
| 673 | 695 | AM_RANGE(0x200100, 0x200117) AM_WRITEONLY AM_SHARE("tilemap_regs.0" ) // tilemap regs1 |
| 674 | 696 | AM_RANGE(0x200120, 0x200137) AM_WRITEONLY AM_SHARE("tilemap_regs.1" ) // tilemap regs2 |
| 675 | 697 | AM_RANGE(0x200140, 0x200157) AM_WRITEONLY AM_SHARE("tilemap_regs.2" ) // tilemap regs3 |
| 676 | 698 | AM_RANGE(0x200160, 0x200177) AM_WRITEONLY AM_SHARE("tilemap_regs.3" ) // tilemap regs4 |
| 677 | 699 | AM_RANGE(0x200200, 0x20021b) AM_WRITEONLY AM_SHARE("spriteregs" ) // sprregs? |
| 678 | | // AM_RANGE(0x200300, 0x200303) AM_WRITE(tmmjprd_rombank_w) // used during rom testing, rombank/area select + something else? |
| 679 | | AM_RANGE(0x20040c, 0x20040f) AM_WRITE(tmmjprd_brt_1_w) |
| 680 | | AM_RANGE(0x200410, 0x200413) AM_WRITE(tmmjprd_brt_2_w) |
| 681 | | // AM_RANGE(0x200500, 0x200503) AM_WRITEONLY AM_SHARE("tmmjprd_viewregs7") |
| 682 | | // AM_RANGE(0x200700, 0x20070f) AM_WRITE(tmmjprd_blitter_w) AM_SHARE("tmmjprd_blitterregs") |
| 683 | | // AM_RANGE(0x200800, 0x20080f) AM_WRITEONLY AM_SHARE("tmmjprd_viewregs9") // never changes? |
| 700 | // AM_RANGE(0x200300, 0x200303) AM_WRITE(rombank_w) // used during rom testing, rombank/area select + something else? |
| 701 | AM_RANGE(0x20040c, 0x20040f) AM_WRITE(brt_1_w) |
| 702 | AM_RANGE(0x200410, 0x200413) AM_WRITE(brt_2_w) |
| 703 | // AM_RANGE(0x200500, 0x200503) AM_WRITEONLY AM_SHARE("viewregs7") |
| 704 | // AM_RANGE(0x200700, 0x20070f) AM_WRITE(blitter_w) AM_SHARE("blitterregs") |
| 705 | // AM_RANGE(0x200800, 0x20080f) AM_WRITEONLY AM_SHARE("viewregs9") // never changes? |
| 684 | 706 | AM_RANGE(0x200900, 0x2009ff) AM_DEVREADWRITE16("i5000snd", i5000snd_device, read, write, 0xffffffff) |
| 685 | 707 | /* hmm */ |
| 686 | | // AM_RANGE(0x279700, 0x279713) AM_WRITEONLY AM_SHARE("tmmjprd_viewregs10") |
| 708 | // AM_RANGE(0x279700, 0x279713) AM_WRITEONLY AM_SHARE("viewregs10") |
| 687 | 709 | /* tilemaps */ |
| 688 | | AM_RANGE(0x280000, 0x283fff) AM_READWRITE(tmmjprd_tilemap0_r,tmmjprd_tilemap0_w) |
| 689 | | AM_RANGE(0x284000, 0x287fff) AM_READWRITE(tmmjprd_tilemap1_r,tmmjprd_tilemap1_w) |
| 690 | | AM_RANGE(0x288000, 0x28bfff) AM_READWRITE(tmmjprd_tilemap2_r,tmmjprd_tilemap2_w) |
| 691 | | AM_RANGE(0x28c000, 0x28ffff) AM_READWRITE(tmmjprd_tilemap3_r,tmmjprd_tilemap3_w) |
| 710 | AM_RANGE(0x280000, 0x283fff) AM_READWRITE(tilemap0_r,tilemap0_w) |
| 711 | AM_RANGE(0x284000, 0x287fff) AM_READWRITE(tilemap1_r,tilemap1_w) |
| 712 | AM_RANGE(0x288000, 0x28bfff) AM_READWRITE(tilemap2_r,tilemap2_w) |
| 713 | AM_RANGE(0x28c000, 0x28ffff) AM_READWRITE(tilemap3_r,tilemap3_w) |
| 692 | 714 | /* ?? is palette ram shared with sprites in this case or just a different map */ |
| 693 | 715 | AM_RANGE(0x290000, 0x29bfff) AM_RAM AM_SHARE("spriteram") |
| 694 | 716 | AM_RANGE(0x29c000, 0x29ffff) AM_RAM_DEVWRITE("palette", palette_device, write) AM_SHARE("palette") |
| 695 | 717 | |
| 696 | | AM_RANGE(0x400000, 0x400003) AM_READ(tmmjprd_mux_r) AM_WRITE(tmmjprd_eeprom_write) |
| 718 | AM_RANGE(0x400000, 0x400003) AM_READ(mux_r) AM_WRITE(eeprom_write) |
| 697 | 719 | AM_RANGE(0xf00000, 0xffffff) AM_RAM |
| 698 | 720 | ADDRESS_MAP_END |
| 699 | 721 | |
| 700 | 722 | |
| 701 | 723 | |
| 702 | | static const gfx_layout rabbit_sprite_16x16x8_layout = |
| 724 | static const gfx_layout sprite_16x16x8_layout = |
| 703 | 725 | { |
| 704 | 726 | 16,16, |
| 705 | 727 | RGN_FRAC(1,2), |
| r243434 | r243435 | |
| 721 | 743 | // gfx decoding is ugly.. 16*16 tiles can start at varying different offsets.. |
| 722 | 744 | static GFXDECODE_START( tmmjprd ) |
| 723 | 745 | /* this seems to be sprites */ |
| 724 | | // GFXDECODE_ENTRY( "gfx1", 0, tmmjprd_sprite_8x8x4_layout, 0x0, 0x1000 ) |
| 725 | | // GFXDECODE_ENTRY( "gfx1", 0, rabbit_sprite_16x16x4_layout, 0x0, 0x1000 ) |
| 726 | | // GFXDECODE_ENTRY( "gfx1", 0, tmmjprd_sprite_8x8x8_layout, 0x0, 0x1000 ) |
| 727 | | GFXDECODE_ENTRY( "gfx1", 0, rabbit_sprite_16x16x8_layout, 0x0, 0x10 ) |
| 746 | // GFXDECODE_ENTRY( "gfx1", 0, sprite_8x8x4_layout, 0x0, 0x1000 ) |
| 747 | // GFXDECODE_ENTRY( "gfx1", 0, sprite_16x16x4_layout, 0x0, 0x1000 ) |
| 748 | // GFXDECODE_ENTRY( "gfx1", 0, sprite_8x8x8_layout, 0x0, 0x1000 ) |
| 749 | GFXDECODE_ENTRY( "gfx1", 0, sprite_16x16x8_layout, 0x0, 0x10 ) |
| 728 | 750 | GFXDECODE_END |
| 729 | 751 | |
| 730 | 752 | |
| 731 | | TIMER_DEVICE_CALLBACK_MEMBER(tmmjprd_state::tmmjprd_scanline) |
| 753 | TIMER_DEVICE_CALLBACK_MEMBER(tmmjprd_state::scanline) |
| 732 | 754 | { |
| 733 | 755 | int scanline = param; |
| 734 | 756 | |
| r243434 | r243435 | |
| 743 | 765 | static MACHINE_CONFIG_START( tmmjprd, tmmjprd_state ) |
| 744 | 766 | MCFG_CPU_ADD("maincpu",M68EC020,24000000) /* 24 MHz */ |
| 745 | 767 | MCFG_CPU_PROGRAM_MAP(tmmjprd_map) |
| 746 | | MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", tmmjprd_state, tmmjprd_scanline, "lscreen", 0, 1) |
| 768 | MCFG_TIMER_DRIVER_ADD_SCANLINE("scantimer", tmmjprd_state, scanline, "lscreen", 0, 1) |
| 747 | 769 | |
| 748 | 770 | MCFG_EEPROM_SERIAL_93C46_ADD("eeprom") |
| 749 | 771 | MCFG_EEPROM_SERIAL_ENABLE_STREAMING() |
| r243434 | r243435 | |
| 768 | 790 | MCFG_SCREEN_SIZE(64*16, 64*16) |
| 769 | 791 | MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1) |
| 770 | 792 | //MCFG_SCREEN_VISIBLE_AREA(0*8, 64*16-1, 0*8, 64*16-1) |
| 771 | | MCFG_SCREEN_UPDATE_DRIVER(tmmjprd_state, screen_update_tmmjprd_left) |
| 793 | MCFG_SCREEN_UPDATE_DRIVER(tmmjprd_state, screen_update_left) |
| 772 | 794 | MCFG_SCREEN_PALETTE("palette") |
| 773 | 795 | |
| 774 | 796 | MCFG_SCREEN_ADD("rscreen", RASTER) |
| r243434 | r243435 | |
| 777 | 799 | MCFG_SCREEN_SIZE(64*16, 64*16) |
| 778 | 800 | MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1) |
| 779 | 801 | //MCFG_SCREEN_VISIBLE_AREA(0*8, 64*16-1, 0*8, 64*16-1) |
| 780 | | MCFG_SCREEN_UPDATE_DRIVER(tmmjprd_state, screen_update_tmmjprd_right) |
| 802 | MCFG_SCREEN_UPDATE_DRIVER(tmmjprd_state, screen_update_right) |
| 781 | 803 | MCFG_SCREEN_PALETTE("palette") |
| 782 | 804 | |
| 783 | 805 | |
| r243434 | r243435 | |
| 863 | 885 | ROM_END |
| 864 | 886 | |
| 865 | 887 | |
| 866 | | GAME( 1997, tmmjprd, 0, tmmjprd, tmmjprd, driver_device, 0, ROT0, "Media / Sonnet", "Tokimeki Mahjong Paradise - Dear My Love", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND ) |
| 867 | | GAME( 1998, tmpdoki, tmmjprd, tmpdoki, tmmjprd, driver_device, 0, ROT0, "Media / Sonnet", "Tokimeki Mahjong Paradise - Doki Doki Hen", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND ) // missing gfx due to wrong roms? |
| 888 | GAME( 1997, tmmjprd, 0, tmmjprd, tmmjprd, driver_device, 0, ROT0, "Media / Sonnet", "Tokimeki Mahjong Paradise - Dear My Love", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) |
| 889 | GAME( 1998, tmpdoki, tmmjprd, tmpdoki, tmmjprd, driver_device, 0, ROT0, "Media / Sonnet", "Tokimeki Mahjong Paradise - Doki Doki Hen", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND | GAME_SUPPORTS_SAVE ) // missing gfx due to wrong roms? |