src/mess/drivers/supracan.c
| r9082 | r9083 | |
| 48 | 48 | - C.U.G.: Gameplay backgrounds are broken. |
| 49 | 49 | - Sango Fighter: Possible missing masking on the upper edges of the screen during gameplay. |
| 50 | 50 | - Sango Fighter: Raster effects off by 1 line |
| 51 | - Sango Fighter: Specifies tiles out of range of video ram?? |
| 51 | 52 | - Speedy Dragon: Backgrounds are broken (wrong tile bank/region). |
| 52 | 53 | - Super Taiwanese Baseball League: Does not boot for unknown reasons. |
| 53 | 54 | - Super Taiwanese Baseball League: Missing window effect applied on tilemaps? |
| 54 | 55 | - The Son of Evil: Does not boot for unknown reasons. |
| 55 | 56 | - The Son of Evil: Many graphical issues. |
| 56 | | |
| 57 | |
| 57 | 58 | - All: are ALL the layers ROZ capable?? |
| 58 | 59 | |
| 59 | 60 | DEBUG TRICKS: |
| r9082 | r9083 | |
| 135 | 136 | UINT16 *vram; |
| 136 | 137 | UINT16 *vram_swapped; |
| 137 | 138 | UINT8 *vram_addr_swapped; |
| 138 | | |
| 139 | |
| 139 | 140 | UINT16 *pram; |
| 140 | 141 | |
| 141 | 142 | UINT16 sprite_count; |
| r9082 | r9083 | |
| 171 | 172 | UINT16 video_regs[256]; |
| 172 | 173 | |
| 173 | 174 | bool hack_68k_to_6502_access; |
| 174 | | |
| 175 | |
| 175 | 176 | tilemap_t *tilemap_sizes[4][4]; |
| 176 | 177 | bitmap_t *sprite_final_bitmap; |
| 177 | 178 | |
| r9082 | r9083 | |
| 213 | 214 | { |
| 214 | 215 | return 2; |
| 215 | 216 | } |
| 216 | | |
| 217 | | |
| 217 | |
| 218 | |
| 218 | 219 | if (layer==3) |
| 219 | 220 | { |
| 220 | 221 | // roz layer |
| 221 | 222 | |
| 222 | 223 | int gfx_mode = (state->roz_mode & 3); |
| 223 | | |
| 224 | |
| 224 | 225 | switch(gfx_mode) |
| 225 | 226 | { |
| 226 | 227 | case 0: return 4; |
| r9082 | r9083 | |
| 242 | 243 | case 2: return 1; |
| 243 | 244 | case 0: return 1; |
| 244 | 245 | } |
| 245 | | |
| 246 | |
| 246 | 247 | return 1; |
| 247 | 248 | } |
| 248 | 249 | |
| r9082 | r9083 | |
| 259 | 260 | int region = supracan_tilemap_get_region(machine, layer); |
| 260 | 261 | |
| 261 | 262 | count += base; |
| 262 | | |
| 263 | |
| 263 | 264 | UINT16 tile_bank = 0; |
| 264 | 265 | UINT16 palette_bank = 0; |
| 265 | 266 | switch(gfx_mode) |
| r9082 | r9083 | |
| 294 | 295 | { |
| 295 | 296 | tile_bank = 0x1000; |
| 296 | 297 | } |
| 297 | | |
| 298 | |
| 298 | 299 | int tile = (supracan_vram[count] & 0x03ff) + tile_bank; |
| 299 | 300 | int flipxy = (supracan_vram[count] & 0x0c00)>>10; |
| 300 | 301 | int palette = ((supracan_vram[count] & 0xf000) >> 12) + palette_bank; |
| r9082 | r9083 | |
| 308 | 309 | supracan_state *state = machine->driver_data<supracan_state>(); |
| 309 | 310 | |
| 310 | 311 | UINT16* supracan_vram = state->vram; |
| 311 | | |
| 312 | |
| 312 | 313 | UINT32 base = state->roz_base_addr; |
| 313 | 314 | |
| 314 | | |
| 315 | |
| 315 | 316 | int region = 1; |
| 316 | 317 | UINT16 tile_bank = 0; |
| 317 | 318 | UINT16 palette_bank = 0; |
| 318 | | |
| 319 | |
| 319 | 320 | region = supracan_tilemap_get_region(machine, layer); |
| 320 | | |
| 321 | |
| 321 | 322 | switch(state->roz_mode & 3) //FIXME: fix gfx bpp order |
| 322 | 323 | { |
| 323 | 324 | case 0: |
| r9082 | r9083 | |
| 326 | 327 | { |
| 327 | 328 | int tile = 0x880 + ((count & 7)*2); |
| 328 | 329 | // tile += (count & 0x070) >> 2; |
| 329 | | |
| 330 | |
| 330 | 331 | if (count & 0x20) tile ^= 1; |
| 331 | 332 | tile |= (count & 0xc0)>>2; |
| 332 | | |
| 333 | |
| 333 | 334 | SET_TILE_INFO(region, tile, 0, 0); |
| 334 | 335 | return; |
| 335 | 336 | } |
| r9082 | r9083 | |
| 347 | 348 | tile_bank = (state->roz_tile_bank & 0xf000) >> 3; |
| 348 | 349 | break; |
| 349 | 350 | } |
| 350 | | |
| 351 | |
| 351 | 352 | count += base; |
| 352 | | |
| 353 | |
| 353 | 354 | int tile = (supracan_vram[count] & 0x03ff) + tile_bank; |
| 354 | 355 | int flipxy = (supracan_vram[count] & 0x0c00)>>10; |
| 355 | 356 | int palette = ((supracan_vram[count] & 0xf000) >> 12) + palette_bank; |
| r9082 | r9083 | |
| 387 | 388 | { |
| 388 | 389 | supracan_state *state = machine->driver_data<supracan_state>(); |
| 389 | 390 | state->sprite_final_bitmap = auto_bitmap_alloc(machine, 1024, 1024, BITMAP_FORMAT_INDEXED16); |
| 390 | | |
| 391 | |
| 391 | 392 | state->vram = (UINT16*)memory_region(machine,"ram_gfx"); |
| 392 | 393 | state->vram_swapped = (UINT16*)memory_region(machine,"ram_gfx2"); |
| 393 | 394 | state->vram_addr_swapped = (UINT8*)memory_region(machine,"ram_gfx3"); // hack for 1bpp layer at startup |
| r9082 | r9083 | |
| 410 | 411 | state->tilemap_sizes[3][0] = tilemap_create(machine, get_supracan_roz_tile_info, tilemap_scan_rows, 8, 8, 32, 32); |
| 411 | 412 | state->tilemap_sizes[3][1] = tilemap_create(machine, get_supracan_roz_tile_info, tilemap_scan_rows, 8, 8, 64, 32); |
| 412 | 413 | state->tilemap_sizes[3][2] = tilemap_create(machine, get_supracan_roz_tile_info, tilemap_scan_rows, 8, 8, 128, 32); |
| 413 | | state->tilemap_sizes[3][3] = tilemap_create(machine, get_supracan_roz_tile_info, tilemap_scan_rows, 8, 8, 64, 64); |
| 414 | state->tilemap_sizes[3][3] = tilemap_create(machine, get_supracan_roz_tile_info, tilemap_scan_rows, 8, 8, 64, 64); |
| 414 | 415 | } |
| 415 | 416 | |
| 416 | 417 | static int get_tilemap_dimensions(running_machine* machine, int &xsize, int &ysize, int layer) |
| 417 | 418 | { |
| 418 | 419 | supracan_state *state = (supracan_state *)machine->driver_data<supracan_state>(); |
| 419 | 420 | int select; |
| 420 | | |
| 421 | |
| 421 | 422 | xsize = 32; |
| 422 | 423 | ysize = 32; |
| 423 | | |
| 424 | |
| 424 | 425 | if (layer==3) select = (state->roz_mode & 0x0f00); |
| 425 | 426 | else select = state->tilemap_flags[layer] & 0x0f00; |
| 426 | | |
| 427 | |
| 427 | 428 | switch(select) |
| 428 | 429 | { |
| 429 | 430 | case 0x600: |
| r9082 | r9083 | |
| 474 | 475 | UINT32 skip_count = 0; |
| 475 | 476 | UINT32 start_word = (state->sprite_base_addr >> 1) + skip_count * 4; |
| 476 | 477 | UINT32 end_word = start_word + (state->sprite_count - skip_count) * 4; |
| 477 | | int region = (state->sprite_flags & 1) ? 0 : 1; //8bpp : 4bpp |
| 478 | int region = (state->sprite_flags & 1) ? 0 : 1; //8bpp : 4bpp |
| 478 | 479 | |
| 480 | // printf("frame\n"); |
| 481 | #define VRAM_MASK (0xffff) |
| 482 | |
| 479 | 483 | for(int i = start_word; i < end_word; i += 4) |
| 480 | 484 | { |
| 481 | 485 | int x = supracan_vram[i+2] & 0x01ff; |
| 482 | 486 | int y = supracan_vram[i+0] & 0x01ff; |
| 483 | | |
| 484 | | int sprite_offset = supracan_vram[i+3] << 2; |
| 487 | |
| 488 | int sprite_offset = (supracan_vram[i+3])<< 1; |
| 489 | |
| 490 | sprite_offset &= VRAM_MASK; // there are only 0xffff words of vram? sango is specifying tiles outside of this, why, I'm sure it didn't used to, timing? DMA? |
| 491 | |
| 492 | |
| 485 | 493 | int bank = (supracan_vram[i+1] & 0xf000) >> 12; |
| 486 | 494 | //int mask = (supracan_vram[i+1] & 0x0300) >> 8; |
| 487 | 495 | bool hflip = (supracan_vram[i+1] & 0x0800) ? true : false; |
| r9082 | r9083 | |
| 489 | 497 | //int xscale = (supracan_vram[i+2] & 0xf000) >> 12; |
| 490 | 498 | const gfx_element *gfx = machine->gfx[region]; |
| 491 | 499 | |
| 500 | /* |
| 501 | printf("%d (unk Y %02x) (unk Y2 %02x) (y pos %02x) (bank %01x) (flip %01x) (unknown %02x) (x size %02x) (xscale %01x) (unk %01x) (xpos %02x) (code %04x)\n", i, |
| 502 | (supracan_vram[i+0] & 0xe000) >> 12, |
| 503 | (supracan_vram[i+0] & 0x1e00) >> 8, |
| 504 | (supracan_vram[i+0] & 0x01ff), |
| 505 | (supracan_vram[i+1] & 0xf000) >> 12, |
| 506 | (supracan_vram[i+1] & 0x0c00) >> 10, |
| 507 | (supracan_vram[i+1] & 0x03f0) >> 4, |
| 508 | (supracan_vram[i+1] & 0x000f), |
| 509 | (supracan_vram[i+2] & 0xf000) >> 12, |
| 510 | (supracan_vram[i+2] & 0x0e00) >> 8, |
| 511 | (supracan_vram[i+2] & 0x01ff) >> 0, |
| 512 | (supracan_vram[i+3] & 0xffff)); |
| 513 | */ |
| 514 | |
| 515 | |
| 516 | |
| 517 | |
| 492 | 518 | // wraparound |
| 493 | 519 | if (y>=0x180) y-=0x200; |
| 494 | 520 | if (x>=0x180) x-=0x200; |
| r9082 | r9083 | |
| 506 | 532 | { |
| 507 | 533 | for(int xtile = (xsize - 1); xtile >= 0; xtile--) |
| 508 | 534 | { |
| 509 | | UINT16 data = supracan_vram[sprite_offset/2+ytile*xsize+xtile]; |
| 535 | UINT16 data = supracan_vram[(sprite_offset+ytile*xsize+xtile)&VRAM_MASK]; |
| 510 | 536 | int tile = (bank * 0x200) + (data & 0x03ff); |
| 511 | 537 | bool xflip = (data & 0x0800) ? false : true; |
| 512 | 538 | bool yflip = (data & 0x0400) ? false : true; |
| 513 | 539 | int palette = (data & 0xf000) >> 12; |
| 514 | 540 | int xpos = x + ((xsize - 1) - xtile)*8; |
| 515 | 541 | int ypos = y + ((ysize - 1) - ytile)*8; |
| 516 | | |
| 542 | |
| 517 | 543 | drawgfx_transpen(bitmap,cliprect,gfx,tile,palette,xflip,yflip, |
| 518 | 544 | xpos, |
| 519 | 545 | ypos, |
| 520 | | 0); |
| 521 | | |
| 546 | 0); |
| 547 | |
| 522 | 548 | } |
| 523 | 549 | } |
| 524 | 550 | else |
| 525 | 551 | { |
| 526 | 552 | for(int xtile = 0; xtile < xsize; xtile++) |
| 527 | 553 | { |
| 528 | | UINT16 data = supracan_vram[sprite_offset/2+ytile*xsize+xtile]; |
| 554 | UINT16 data = supracan_vram[(sprite_offset+ytile*xsize+xtile)&VRAM_MASK]; |
| 529 | 555 | int tile = (bank * 0x200) + (data & 0x03ff); |
| 530 | 556 | bool xflip = (data & 0x0800) ? true : false; |
| 531 | 557 | bool yflip = (data & 0x0400) ? false : true; |
| 532 | 558 | int palette = (data & 0xf000) >> 12; |
| 533 | | |
| 559 | |
| 534 | 560 | int xpos = x + xtile*8; |
| 535 | 561 | int ypos = y + ((ysize - 1) - ytile)*8; |
| 536 | 562 | |
| r9082 | r9083 | |
| 550 | 576 | { |
| 551 | 577 | for(int xtile = (xsize - 1); xtile >= 0; xtile--) |
| 552 | 578 | { |
| 553 | | UINT16 data = supracan_vram[sprite_offset/2+ytile*xsize+xtile]; |
| 579 | UINT16 data = supracan_vram[(sprite_offset+ytile*xsize+xtile)&VRAM_MASK]; |
| 554 | 580 | int tile = (bank * 0x200) + (data & 0x03ff); |
| 555 | 581 | bool xflip = (data & 0x0800) ? false : true; |
| 556 | 582 | bool yflip = (data & 0x0400) ? true : false; |
| r9082 | r9083 | |
| 569 | 595 | { |
| 570 | 596 | for(int xtile = 0; xtile < xsize; xtile++) |
| 571 | 597 | { |
| 572 | | UINT16 data = supracan_vram[sprite_offset/2+ytile*xsize+xtile]; |
| 598 | UINT16 data = supracan_vram[(sprite_offset+ytile*xsize+xtile)&VRAM_MASK]; |
| 573 | 599 | int tile = (bank * 0x200) + (data & 0x03ff); |
| 574 | 600 | bool xflip = (data & 0x0800) ? true : false; |
| 575 | 601 | bool yflip = (data & 0x0400) ? true : false; |
| r9082 | r9083 | |
| 582 | 608 | xpos, |
| 583 | 609 | ypos, |
| 584 | 610 | 0); |
| 585 | | |
| 611 | |
| 586 | 612 | } |
| 587 | 613 | } |
| 588 | 614 | } |
| r9082 | r9083 | |
| 602 | 628 | dx += delta; |
| 603 | 629 | } |
| 604 | 630 | } |
| 605 | | #endif |
| 606 | | |
| 631 | #endif |
| 632 | |
| 607 | 633 | } |
| 608 | 634 | } |
| 609 | 635 | } |
| r9082 | r9083 | |
| 615 | 641 | supracan_state *state = (supracan_state *)machine->driver_data<supracan_state>(); |
| 616 | 642 | int xsize = 0; |
| 617 | 643 | int ysize = 0; |
| 618 | | |
| 644 | |
| 619 | 645 | int which_tilemap_size; |
| 620 | 646 | |
| 621 | 647 | which_tilemap_size = get_tilemap_dimensions(machine, xsize, ysize, layer); |
| r9082 | r9083 | |
| 627 | 653 | |
| 628 | 654 | |
| 629 | 655 | /* draws ROZ with linescroll OR columnscroll to 16-bit indexed bitmap */ |
| 630 | | static void supracan_suprnova_draw_roz(bitmap_t* bitmap, const rectangle *cliprect, tilemap_t *tmap, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound/*, int columnscroll, UINT32* scrollram*/, int transmask) |
| 656 | static void supracan_suprnova_draw_roz(running_machine* machine, bitmap_t* bitmap, const rectangle *cliprect, tilemap_t *tmap, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound/*, int columnscroll, UINT32* scrollram*/, int transmask) |
| 631 | 657 | { |
| 632 | 658 | //bitmap_t *destbitmap = bitmap; |
| 633 | 659 | bitmap_t *srcbitmap = tilemap_get_pixmap(tmap); |
| r9082 | r9083 | |
| 683 | 709 | if (columnscroll) |
| 684 | 710 | { |
| 685 | 711 | int scroll = 0;//scrollram[(cx>>16)&0x3ff]); |
| 686 | | |
| 687 | | |
| 712 | |
| 713 | |
| 688 | 714 | UINT16 data = BITMAP_ADDR16(srcbitmap, |
| 689 | 715 | ((cy >> 16) - scroll) & ymask, |
| 690 | 716 | (cx >> 16) & xmask)[0]; |
| 691 | | |
| 717 | |
| 692 | 718 | if ((data & transmask)!=0) |
| 693 | 719 | dest[0] = data; |
| 694 | | |
| 720 | |
| 695 | 721 | //destflags[0] = BITMAP_ADDR8(srcbitmapflags, ((cy >> 16) - scrollram[(cx>>16)&0x3ff]) & ymask, (cx >> 16) & xmask)[0]; |
| 696 | 722 | } |
| 697 | 723 | else |
| r9082 | r9083 | |
| 701 | 727 | UINT16 data = BITMAP_ADDR16(srcbitmap, |
| 702 | 728 | (cy >> 16) & ymask, |
| 703 | 729 | ((cx >> 16) - scroll) & xmask)[0]; |
| 704 | | |
| 705 | | |
| 730 | |
| 731 | |
| 706 | 732 | if ((data & transmask)!=0) |
| 707 | 733 | dest[0] = data; |
| 708 | | |
| 734 | |
| 709 | 735 | //destflags[0] = BITMAP_ADDR8(srcbitmapflags, (cy >> 16) & ymask, ((cx >> 16) - scrollram[(cy>>16)&0x3ff]) & xmask)[0]; |
| 710 | 736 | } |
| 711 | 737 | } |
| r9082 | r9083 | |
| 764 | 790 | if (cliprect->min_y == 0x00) |
| 765 | 791 | { |
| 766 | 792 | const rectangle &visarea = screen->visible_area(); |
| 767 | | |
| 793 | |
| 768 | 794 | bitmap_fill(state->sprite_final_bitmap, &visarea, 0x00); |
| 769 | 795 | bitmap_fill(bitmap, &visarea, 0x80); |
| 770 | | |
| 796 | |
| 771 | 797 | draw_sprites(screen->machine, state->sprite_final_bitmap, &visarea); |
| 772 | | |
| 773 | 798 | |
| 799 | |
| 774 | 800 | } |
| 775 | 801 | } |
| 776 | 802 | else |
| 777 | 803 | { |
| 778 | | |
| 804 | |
| 779 | 805 | bitmap_fill(state->sprite_final_bitmap, cliprect, 0x00); |
| 780 | 806 | bitmap_fill(bitmap, cliprect, 0x80); |
| 781 | | |
| 807 | |
| 782 | 808 | draw_sprites(screen->machine, state->sprite_final_bitmap, cliprect); |
| 783 | 809 | |
| 784 | | |
| 810 | |
| 785 | 811 | } |
| 786 | | |
| 787 | 812 | |
| 788 | 813 | |
| 814 | |
| 789 | 815 | // mix screen |
| 790 | 816 | int xsize = 0, ysize = 0; |
| 791 | 817 | bitmap_t *src_bitmap = 0; |
| 792 | 818 | int tilemap_num; |
| 793 | 819 | int which_tilemap_size; |
| 794 | 820 | int priority = 0; |
| 795 | | |
| 796 | 821 | |
| 797 | | for (int pri=7;pri>=0;pri--) |
| 822 | |
| 823 | for (int pri=7;pri>=0;pri--) |
| 798 | 824 | { |
| 799 | 825 | |
| 800 | 826 | for (int layer = 3; layer >=0; layer--) |
| 801 | 827 | { |
| 802 | 828 | // popmessage("%04x\n",state->video_flags); |
| 803 | 829 | int enabled = 0; |
| 804 | | |
| 830 | |
| 805 | 831 | if(state->video_flags & 0x04) |
| 806 | 832 | if (layer==3) enabled = 1; |
| 807 | | |
| 833 | |
| 808 | 834 | if(state->video_flags & 0x80) |
| 809 | 835 | if (layer==0) enabled = 1; |
| 810 | 836 | |
| r9082 | r9083 | |
| 813 | 839 | |
| 814 | 840 | if(state->video_flags & 0x20) |
| 815 | 841 | if (layer==2) enabled = 1; |
| 816 | | |
| 817 | | |
| 842 | |
| 843 | |
| 818 | 844 | if (layer==3) priority = ((state->roz_mode >> 13) & 7); // roz case |
| 819 | 845 | else priority = ((state->tilemap_flags[layer] >> 13) & 7); // normal cases |
| 820 | | |
| 821 | | |
| 846 | |
| 847 | |
| 822 | 848 | if (priority==pri) |
| 823 | 849 | { |
| 824 | 850 | tilemap_num = layer; |
| 825 | 851 | which_tilemap_size = get_tilemap_dimensions(screen->machine, xsize, ysize, layer); |
| 826 | | src_bitmap = tilemap_get_pixmap(state->tilemap_sizes[layer][which_tilemap_size]); |
| 852 | src_bitmap = tilemap_get_pixmap(state->tilemap_sizes[layer][which_tilemap_size]); |
| 827 | 853 | int gfx_region = supracan_tilemap_get_region(screen->machine, layer); |
| 828 | 854 | int transmask = 0xff; |
| 829 | | |
| 855 | |
| 830 | 856 | switch (gfx_region) |
| 831 | 857 | { |
| 832 | 858 | case 0:transmask = 0xff; break; |
| 833 | 859 | case 1:transmask = 0x0f; break; |
| 834 | 860 | case 2:transmask = 0x03; break; |
| 835 | 861 | case 3:transmask = 0x01; break; |
| 836 | | case 4:transmask = 0x01; break; |
| 862 | case 4:transmask = 0x01; break; |
| 837 | 863 | } |
| 838 | | |
| 864 | |
| 839 | 865 | if (enabled) |
| 840 | 866 | { |
| 841 | 867 | if (layer != 3) // standard layers, NOT roz |
| 842 | 868 | { |
| 843 | | |
| 869 | |
| 844 | 870 | int wrap = (state->tilemap_flags[layer] & 0x20); |
| 845 | | |
| 871 | |
| 846 | 872 | int scrollx = state->tilemap_scrollx[layer]; |
| 847 | 873 | int scrolly = state->tilemap_scrolly[layer]; |
| 848 | | |
| 874 | |
| 849 | 875 | if (scrollx&0x8000) scrollx-= 0x10000; |
| 850 | 876 | if (scrolly&0x8000) scrolly-= 0x10000; |
| 851 | | |
| 877 | |
| 852 | 878 | int mosaic_count = (state->tilemap_flags[layer] & 0x001c) >> 2; |
| 853 | 879 | int mosaic_mask = 0xffffffff << mosaic_count; |
| 854 | | |
| 880 | |
| 855 | 881 | int y,x; |
| 856 | 882 | // yes, it will draw a single line if you specify a cliprect as such (partial updates...) |
| 857 | | |
| 883 | |
| 858 | 884 | for (y=cliprect->min_y;y<=cliprect->max_y;y++) |
| 859 | | { |
| 885 | { |
| 860 | 886 | // these will have to change to ADDR32 etc. once alpha blending is supported |
| 861 | 887 | UINT16* screen = BITMAP_ADDR16(bitmap, y, 0); |
| 862 | | |
| 888 | |
| 863 | 889 | int actualy = y&mosaic_mask; |
| 864 | | |
| 890 | |
| 865 | 891 | int realy = actualy+scrolly; |
| 866 | | |
| 892 | |
| 867 | 893 | if (!wrap) |
| 868 | 894 | if (scrolly+y < 0 || scrolly+y > ((ysize*8)-1)) |
| 869 | 895 | continue; |
| 870 | 896 | |
| 871 | | |
| 897 | |
| 872 | 898 | UINT16* src = BITMAP_ADDR16(src_bitmap, (realy)&((ysize*8)-1), 0); |
| 873 | | |
| 899 | |
| 874 | 900 | for (x=cliprect->min_x;x<=cliprect->max_x;x++) |
| 875 | 901 | { |
| 876 | 902 | int actualx = x & mosaic_mask; |
| 877 | 903 | int realx = actualx+scrollx; |
| 878 | | |
| 904 | |
| 879 | 905 | if (!wrap) |
| 880 | 906 | if (scrollx+x < 0 || scrollx+x > ((xsize*8)-1)) |
| 881 | 907 | continue; |
| 882 | | |
| 908 | |
| 883 | 909 | UINT16 srcpix = src[(realx)&((xsize*8)-1)]; |
| 884 | | |
| 910 | |
| 885 | 911 | if ((srcpix & transmask) != 0) |
| 886 | | screen[x] = srcpix; |
| 887 | | } |
| 912 | screen[x] = srcpix; |
| 913 | } |
| 888 | 914 | } |
| 889 | 915 | } |
| 890 | 916 | else |
| 891 | 917 | { |
| 892 | 918 | int wrap = state->roz_mode & 0x20; |
| 893 | | |
| 919 | |
| 894 | 920 | int incxx = (state->roz_coeffa); |
| 895 | 921 | int incyy = (state->roz_coeffd); |
| 896 | | |
| 922 | |
| 897 | 923 | int incxy = (state->roz_coeffc); |
| 898 | 924 | int incyx = (state->roz_coeffb); |
| 899 | | |
| 925 | |
| 926 | int scrollx = (state->roz_scrollx); |
| 927 | int scrolly = (state->roz_scrolly); |
| 928 | |
| 929 | |
| 930 | |
| 931 | |
| 932 | |
| 933 | |
| 900 | 934 | if (incyx & 0x8000) incyx -= 0x10000; |
| 901 | 935 | if (incxy & 0x8000) incxy -= 0x10000; |
| 902 | | |
| 936 | |
| 903 | 937 | if (incyy & 0x8000) incyy -= 0x10000; |
| 904 | 938 | if (incxx & 0x8000) incxx -= 0x10000; |
| 905 | 939 | |
| 906 | | |
| 907 | | supracan_suprnova_draw_roz(bitmap, cliprect, state->tilemap_sizes[layer][which_tilemap_size], (state->roz_scrollx)<<8, (state->roz_scrolly)<<8, incxx<<8, incxy<<8, incyx<<8, incyy<<8, wrap, transmask); |
| 940 | //popmessage("%04x %04x\n",state->video_flags, state->roz_mode); |
| 941 | |
| 942 | // roz mode.. |
| 943 | //4020 = enabled speedyd |
| 944 | //6c22 = enabled speedyd |
| 945 | //2c22 = enabled speedyd |
| 946 | //4622 = disabled jttlaugh |
| 947 | //2602 = disabled monopoly |
| 948 | //0402 = disabled (sango title) |
| 949 | // or is it always enabled, and only corrupt because we don't clear ram properly? |
| 950 | // (probably not this register?) |
| 951 | |
| 952 | if (!(state->roz_mode & 0x0200) && (state->roz_mode&0xf000) ) // HACK - Not Trusted, Acan Logo, Speedy Dragon Intro ,Speed Dragon Bonus stage need it. Monopoly and JTT *don't* causes graphical issues |
| 953 | { |
| 954 | // NOT accurate, causes issues when the attract mode loops and the logo is shown the 2nd time in some games - investigate |
| 955 | for (int y=cliprect->min_y;y<=cliprect->max_y;y++) |
| 956 | { |
| 957 | rectangle clip; |
| 958 | clip.min_x = cliprect->min_x; |
| 959 | clip.max_x = cliprect->max_x; |
| 960 | |
| 961 | clip.min_y = clip.max_y = y; |
| 962 | |
| 963 | scrollx = (state->roz_scrollx); |
| 964 | scrolly = (state->roz_scrolly); |
| 965 | incxx = (state->roz_coeffa); |
| 966 | |
| 967 | incxx += state->vram[state->roz_unk_base0/2 + y]; |
| 968 | |
| 969 | scrollx += state->vram[state->roz_unk_base1/2 + y*2] << 16; |
| 970 | scrollx += state->vram[state->roz_unk_base1/2 + y*2 + 1]; |
| 971 | |
| 972 | scrolly += state->vram[state->roz_unk_base2/2 + y*2] << 16; |
| 973 | scrolly += state->vram[state->roz_unk_base2/2 + y*2 + 1]; |
| 974 | |
| 975 | if (incxx & 0x8000) incxx -= 0x10000; |
| 976 | |
| 977 | supracan_suprnova_draw_roz(screen->machine, bitmap, &clip, state->tilemap_sizes[layer][which_tilemap_size], scrollx<<8, scrolly<<8, incxx<<8, incxy<<8, incyx<<8, incyy<<8, wrap, transmask); |
| 978 | } |
| 979 | } |
| 980 | else |
| 981 | { |
| 982 | supracan_suprnova_draw_roz(screen->machine, bitmap, cliprect, state->tilemap_sizes[layer][which_tilemap_size], scrollx<<8, scrolly<<8, incxx<<8, incxy<<8, incyx<<8, incyy<<8, wrap, transmask); |
| 983 | } |
| 908 | 984 | } |
| 909 | 985 | } |
| 910 | 986 | } |
| 911 | | } |
| 987 | } |
| 912 | 988 | } |
| 913 | 989 | |
| 914 | 990 | |
| r9082 | r9083 | |
| 919 | 995 | { |
| 920 | 996 | UINT16* src = BITMAP_ADDR16( state->sprite_final_bitmap, y, 0); |
| 921 | 997 | UINT16* dst = BITMAP_ADDR16( bitmap, y, 0); |
| 922 | | |
| 998 | |
| 923 | 999 | for (int x=cliprect->min_x;x<=cliprect->max_x;x++) |
| 924 | 1000 | { |
| 925 | 1001 | UINT16 dat = src[x]; |
| 926 | | if (dat) dst[x] = dat; |
| 1002 | if (dat) dst[x] = dat; |
| 927 | 1003 | } |
| 928 | 1004 | } |
| 929 | 1005 | } |
| 930 | | |
| 1006 | |
| 931 | 1007 | return 0; |
| 932 | 1008 | } |
| 933 | 1009 | |
| r9082 | r9083 | |
| 976 | 1052 | { |
| 977 | 1053 | // if(data & 0x2000) |
| 978 | 1054 | // acan_dma_regs->source-=2; |
| 979 | | verboselog("maincpu", space->machine, 0, "supracan_dma_w: Kicking off a DMA from %08x to %08x, %d bytes (%04x)\n", acan_dma_regs->source[ch], acan_dma_regs->dest[ch], acan_dma_regs->count[ch] + 1, data); |
| 1055 | logerror("supracan_dma_w: Kicking off a DMA from %08x to %08x, %d bytes (%04x)\n", acan_dma_regs->source[ch], acan_dma_regs->dest[ch], acan_dma_regs->count[ch] + 1, data); |
| 980 | 1056 | |
| 981 | 1057 | for(int i = 0; i <= acan_dma_regs->count[ch]; i++) |
| 982 | 1058 | { |
| r9082 | r9083 | |
| 1048 | 1124 | // hack for 1bpp layer at startup |
| 1049 | 1125 | write_swapped_byte(space->machine, offset*2+1, (data & 0xff00)>>8); |
| 1050 | 1126 | write_swapped_byte(space->machine, offset*2, (data & 0x00ff)); |
| 1051 | | |
| 1127 | |
| 1052 | 1128 | // mark tiles of each depth as dirty |
| 1053 | 1129 | gfx_element_mark_dirty(space->machine->gfx[0], (offset*2)/(64)); |
| 1054 | 1130 | gfx_element_mark_dirty(space->machine->gfx[1], (offset*2)/(32)); |
| r9082 | r9083 | |
| 1479 | 1555 | { |
| 1480 | 1556 | case 0: |
| 1481 | 1557 | state->video_regs[0] &= 0x7fff; |
| 1482 | | |
| 1558 | |
| 1483 | 1559 | // we really need better management of this |
| 1484 | 1560 | mark_active_tilemap_all_dirty(machine, 0); |
| 1485 | 1561 | mark_active_tilemap_all_dirty(machine, 1); |
| 1486 | 1562 | mark_active_tilemap_all_dirty(machine, 2); |
| 1487 | 1563 | mark_active_tilemap_all_dirty(machine, 3); |
| 1488 | 1564 | |
| 1489 | | |
| 1565 | |
| 1490 | 1566 | break; |
| 1491 | 1567 | case 240: |
| 1492 | 1568 | state->video_regs[0] |= 0x8000; |
| r9082 | r9083 | |
| 1548 | 1624 | acan_sprdma_regs->src_inc = data; |
| 1549 | 1625 | break; |
| 1550 | 1626 | case 0x1e/2: |
| 1551 | | verboselog("maincpu", space->machine, 0, "supracan_dma_w: Kicking off a DMA from %08x to %08x, %d bytes (%04x)\n", acan_sprdma_regs->src, acan_sprdma_regs->dst, acan_sprdma_regs->count, data); |
| 1627 | logerror( "supracan_video_w: Kicking off a DMA from %08x to %08x, %d bytes (%04x)\n", acan_sprdma_regs->src, acan_sprdma_regs->dst, acan_sprdma_regs->count, data); |
| 1552 | 1628 | |
| 1553 | 1629 | /* TODO: what's 0x2000 and 0x4000 for? */ |
| 1554 | 1630 | if(data & 0x8000) |
| r9082 | r9083 | |
| 1780 | 1856 | }; |
| 1781 | 1857 | |
| 1782 | 1858 | |
| 1783 | | static const UINT32 xtexlayout_xoffset[64] = { 0,1,2,3,4,5,6,7, 8,9,10,11,12,13,14,15, |
| 1859 | static const UINT32 xtexlayout_xoffset[64] = { 0,1,2,3,4,5,6,7, 8,9,10,11,12,13,14,15, |
| 1784 | 1860 | 16,17,18,19,20,21,22,23, 24,25,26,27,28,29,30,31, |
| 1785 | | 32,33,34,35,36,37,38,39, 40,41,42,43,44,45,46,47, |
| 1861 | 32,33,34,35,36,37,38,39, 40,41,42,43,44,45,46,47, |
| 1786 | 1862 | 48,49,50,51,52,53,54,55, 56,57,58,59,60,61,62,63 }; |
| 1787 | 1863 | static const UINT32 xtexlayout_yoffset[64] = { 0*64,1*64,2*64,3*64,4*64,5*64,6*64,7*64, |
| 1788 | 1864 | 8*64,9*64,10*64,11*64,12*64,13*64,14*64,15*64, |
| 1789 | 1865 | 16*64,17*64,18*64,19*64,20*64,21*64,22*64,23*64, |
| 1790 | | 24*64,25*64,26*64,27*64,28*64,29*64,30*64,31*64, |
| 1866 | 24*64,25*64,26*64,27*64,28*64,29*64,30*64,31*64, |
| 1791 | 1867 | 32*64,33*64,34*64,35*64,36*64,37*64,38*64,39*64, |
| 1792 | 1868 | 40*64,41*64,42*64,43*64,44*64,45*64,46*64,47*64, |
| 1793 | 1869 | 48*64,49*64,50*64,51*64,52*64,53*64,54*64,55*64, |