src/mess/video/gb.c
| r1905 | r1906 | |
| 12 | 12 | ***************************************************************************/ |
| 13 | 13 | |
| 14 | 14 | #include "driver.h" |
| 15 | | #include "deprecat.h" |
| 16 | 15 | #include "includes/gb.h" |
| 17 | 16 | #include "cpu/z80gb/z80gb.h" |
| 18 | 17 | #include "profiler.h" |
| r1905 | r1906 | |
| 108 | 107 | emu_timer *lcd_timer; |
| 109 | 108 | } gb_lcd; |
| 110 | 109 | |
| 111 | | static void (*update_scanline)(void); |
| 110 | static void (*update_scanline)( running_machine *machine ); |
| 112 | 111 | |
| 113 | 112 | /* Prototypes */ |
| 114 | 113 | static TIMER_CALLBACK(gb_lcd_timer_proc); |
| 115 | 114 | static TIMER_CALLBACK(gbc_lcd_timer_proc); |
| 116 | | static void gb_lcd_switch_on( void ); |
| 115 | static void gb_lcd_switch_on( running_machine *machine ); |
| 117 | 116 | |
| 118 | 117 | static const unsigned char palette[] = |
| 119 | 118 | { |
| r1905 | r1906 | |
| 242 | 241 | } |
| 243 | 242 | } |
| 244 | 243 | |
| 245 | | INLINE void gb_update_sprites (void) |
| 244 | INLINE void gb_update_sprites ( running_machine *machine ) |
| 246 | 245 | { |
| 247 | 246 | bitmap_t *bitmap = tmpbitmap; |
| 248 | 247 | UINT8 height, tilemask, line, *oam, *vram; |
| r1905 | r1906 | |
| 292 | 291 | { |
| 293 | 292 | register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0); |
| 294 | 293 | if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160) |
| 295 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[spal[colour]]); |
| 294 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]); |
| 296 | 295 | data >>= 1; |
| 297 | 296 | } |
| 298 | 297 | break; |
| r1905 | r1906 | |
| 301 | 300 | { |
| 302 | 301 | register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0); |
| 303 | 302 | if (colour && xindex >= 0 && xindex < 160) |
| 304 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[spal[colour]]); |
| 303 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]); |
| 305 | 304 | data >>= 1; |
| 306 | 305 | } |
| 307 | 306 | break; |
| r1905 | r1906 | |
| 310 | 309 | { |
| 311 | 310 | register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0); |
| 312 | 311 | if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160) |
| 313 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[spal[colour]]); |
| 312 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]); |
| 314 | 313 | data <<= 1; |
| 315 | 314 | } |
| 316 | 315 | break; |
| r1905 | r1906 | |
| 319 | 318 | { |
| 320 | 319 | register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0); |
| 321 | 320 | if (colour && xindex >= 0 && xindex < 160) |
| 322 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[spal[colour]]); |
| 321 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]); |
| 323 | 322 | data <<= 1; |
| 324 | 323 | } |
| 325 | 324 | break; |
| r1905 | r1906 | |
| 329 | 328 | } |
| 330 | 329 | } |
| 331 | 330 | |
| 332 | | static void gb_update_scanline (void) { |
| 331 | static void gb_update_scanline( running_machine *machine ) { |
| 333 | 332 | bitmap_t *bitmap = tmpbitmap; |
| 334 | 333 | |
| 335 | 334 | profiler_mark(PROFILER_VIDEO); |
| r1905 | r1906 | |
| 386 | 385 | r.min_y = r.max_y = gb_lcd.current_line; |
| 387 | 386 | r.min_x = gb_lcd.start_x; |
| 388 | 387 | r.max_x = gb_lcd.end_x - 1; |
| 389 | | fillbitmap( bitmap, Machine->pens[ gb_bpal[0] ], &r ); |
| 388 | fillbitmap( bitmap, machine->pens[ gb_bpal[0] ], &r ); |
| 390 | 389 | } |
| 391 | 390 | while ( l < 2 ) { |
| 392 | 391 | UINT8 xindex, *map, *tiles; |
| r1905 | r1906 | |
| 414 | 413 | while ( i > 0 ) { |
| 415 | 414 | while ( ( gb_lcd.layer[l].xshift < 8 ) && i ) { |
| 416 | 415 | register int colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 ); |
| 417 | | gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, Machine->pens[ gb_bpal[ colour ] ] ); |
| 416 | gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, machine->pens[ gb_bpal[ colour ] ] ); |
| 418 | 417 | bg_zbuf[ xindex ] = colour; |
| 419 | 418 | xindex++; |
| 420 | 419 | data <<= 1; |
| r1905 | r1906 | |
| 438 | 437 | l++; |
| 439 | 438 | } |
| 440 | 439 | if ( gb_lcd.end_x == 160 && LCDCONT & 0x02 ) { |
| 441 | | gb_update_sprites(); |
| 440 | gb_update_sprites( machine ); |
| 442 | 441 | } |
| 443 | 442 | gb_lcd.start_x = gb_lcd.end_x; |
| 444 | 443 | } |
| r1905 | r1906 | |
| 447 | 446 | /* Draw an empty line when LCD is disabled */ |
| 448 | 447 | if ( gb_lcd.previous_line != gb_lcd.current_line ) { |
| 449 | 448 | if ( gb_lcd.current_line < 144 ) { |
| 450 | | rectangle r = Machine->screen[0].visarea; |
| 449 | rectangle r = machine->screen[0].visarea; |
| 451 | 450 | r.min_y = r.max_y = gb_lcd.current_line; |
| 452 | | fillbitmap( bitmap, Machine->pens[0], &r ); |
| 451 | fillbitmap( bitmap, machine->pens[0], &r ); |
| 453 | 452 | } |
| 454 | 453 | gb_lcd.previous_line = gb_lcd.current_line; |
| 455 | 454 | } |
| r1905 | r1906 | |
| 618 | 617 | } |
| 619 | 618 | } |
| 620 | 619 | |
| 621 | | static void sgb_update_scanline (void) { |
| 620 | static void sgb_update_scanline( running_machine *machine ) { |
| 622 | 621 | bitmap_t *bitmap = tmpbitmap; |
| 623 | 622 | |
| 624 | 623 | profiler_mark(PROFILER_VIDEO); |
| r1905 | r1906 | |
| 676 | 675 | return; |
| 677 | 676 | case 2: /* Blank screen (black) */ |
| 678 | 677 | { |
| 679 | | rectangle r = Machine->screen[0].visarea; |
| 678 | rectangle r = machine->screen[0].visarea; |
| 680 | 679 | r.min_x = SGB_XOFFSET; |
| 681 | 680 | r.max_x -= SGB_XOFFSET; |
| 682 | 681 | r.min_y = SGB_YOFFSET; |
| 683 | 682 | r.max_y -= SGB_YOFFSET; |
| 684 | | fillbitmap( bitmap, Machine->pens[0], &r ); |
| 683 | fillbitmap( bitmap, machine->pens[0], &r ); |
| 685 | 684 | } return; |
| 686 | 685 | case 3: /* Blank screen (white - or should it be color 0?) */ |
| 687 | 686 | { |
| 688 | | rectangle r = Machine->screen[0].visarea; |
| 687 | rectangle r = machine->screen[0].visarea; |
| 689 | 688 | r.min_x = SGB_XOFFSET; |
| 690 | 689 | r.max_x -= SGB_XOFFSET; |
| 691 | 690 | r.min_y = SGB_YOFFSET; |
| 692 | 691 | r.max_y -= SGB_YOFFSET; |
| 693 | | fillbitmap( bitmap, Machine->pens[32767], &r ); |
| 692 | fillbitmap( bitmap, machine->pens[32767], &r ); |
| 694 | 693 | } return; |
| 695 | 694 | } |
| 696 | 695 | |
| r1905 | r1906 | |
| 704 | 703 | |
| 705 | 704 | /* if background or screen disabled clear line */ |
| 706 | 705 | if ( ! ( LCDCONT & 0x01 ) ) { |
| 707 | | rectangle r = Machine->screen[0].visarea; |
| 706 | rectangle r = machine->screen[0].visarea; |
| 708 | 707 | r.min_x = SGB_XOFFSET; |
| 709 | 708 | r.max_x -= SGB_XOFFSET; |
| 710 | 709 | r.min_y = r.max_y = gb_lcd.current_line + SGB_YOFFSET; |
| 711 | | fillbitmap( bitmap, Machine->pens[0], &r ); |
| 710 | fillbitmap( bitmap, machine->pens[0], &r ); |
| 712 | 711 | } |
| 713 | 712 | while( l < 2 ) { |
| 714 | 713 | UINT8 xindex, sgb_palette, *map, *tiles; |
| r1905 | r1906 | |
| 774 | 773 | if ( gb_lcd.previous_line != gb_lcd.current_line ) { |
| 775 | 774 | /* Also refresh border here??? */ |
| 776 | 775 | if ( gb_lcd.current_line < 144 ) { |
| 777 | | rectangle r = Machine->screen[0].visarea; |
| 776 | rectangle r = machine->screen[0].visarea; |
| 778 | 777 | r.min_x = SGB_XOFFSET; |
| 779 | 778 | r.max_x -= SGB_XOFFSET; |
| 780 | 779 | r.min_y = r.max_y = gb_lcd.current_line + SGB_YOFFSET; |
| 781 | | fillbitmap(bitmap, Machine->pens[0], &r); |
| 780 | fillbitmap(bitmap, machine->pens[0], &r); |
| 782 | 781 | } |
| 783 | 782 | gb_lcd.previous_line = gb_lcd.current_line; |
| 784 | 783 | } |
| r1905 | r1906 | |
| 790 | 789 | |
| 791 | 790 | /* --- Gameboy Color Specific --- */ |
| 792 | 791 | |
| 793 | | INLINE void cgb_update_sprites (void) { |
| 792 | INLINE void cgb_update_sprites ( running_machine *machine ) { |
| 794 | 793 | bitmap_t *bitmap = tmpbitmap; |
| 795 | 794 | UINT8 height, tilemask, line, *oam; |
| 796 | 795 | int i, xindex, yindex; |
| r1905 | r1906 | |
| 844 | 843 | { |
| 845 | 844 | register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0); |
| 846 | 845 | if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160) |
| 847 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[cgb_spal[pal + colour]]); |
| 846 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]); |
| 848 | 847 | data >>= 1; |
| 849 | 848 | } |
| 850 | 849 | break; |
| r1905 | r1906 | |
| 855 | 854 | if((bg_zbuf[xindex] & 0x80) && (bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1)) |
| 856 | 855 | colour = 0; |
| 857 | 856 | if (colour && xindex >= 0 && xindex < 160) |
| 858 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[cgb_spal[pal + colour]]); |
| 857 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]); |
| 859 | 858 | data >>= 1; |
| 860 | 859 | } |
| 861 | 860 | break; |
| r1905 | r1906 | |
| 864 | 863 | { |
| 865 | 864 | register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0); |
| 866 | 865 | if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160) |
| 867 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[cgb_spal[pal + colour]]); |
| 866 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]); |
| 868 | 867 | data <<= 1; |
| 869 | 868 | } |
| 870 | 869 | break; |
| r1905 | r1906 | |
| 875 | 874 | if((bg_zbuf[xindex] & 0x80) && (bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1)) |
| 876 | 875 | colour = 0; |
| 877 | 876 | if (colour && xindex >= 0 && xindex < 160) |
| 878 | | gb_plot_pixel(bitmap, xindex, yindex, Machine->pens[cgb_spal[pal + colour]]); |
| 877 | gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]); |
| 879 | 878 | data <<= 1; |
| 880 | 879 | } |
| 881 | 880 | break; |
| r1905 | r1906 | |
| 885 | 884 | } |
| 886 | 885 | } |
| 887 | 886 | |
| 888 | | static void cgb_update_scanline (void) { |
| 887 | static void cgb_update_scanline ( running_machine *machine ) { |
| 889 | 888 | bitmap_t *bitmap = tmpbitmap; |
| 890 | 889 | |
| 891 | 890 | profiler_mark(PROFILER_VIDEO); |
| r1905 | r1906 | |
| 938 | 937 | gb_lcd.end_x = MIN(160 - cycles_to_go,160); |
| 939 | 938 | /* Draw empty line when the background is disabled */ |
| 940 | 939 | if ( ! ( LCDCONT & 0x01 ) ) { |
| 941 | | rectangle r = Machine->screen[0].visarea; |
| 940 | rectangle r = machine->screen[0].visarea; |
| 942 | 941 | r.min_y = r.max_y = gb_lcd.current_line; |
| 943 | 942 | r.min_x = gb_lcd.start_x; |
| 944 | 943 | r.max_x = gb_lcd.end_x - 1; |
| 945 | | fillbitmap( bitmap, Machine->pens[ ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767 ], &r ); |
| 944 | fillbitmap( bitmap, machine->pens[ ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767 ], &r ); |
| 946 | 945 | } |
| 947 | 946 | while ( l < 2 ) { |
| 948 | 947 | UINT8 xindex, *map, *tiles, *gbcmap; |
| r1905 | r1906 | |
| 991 | 990 | colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 ); |
| 992 | 991 | data <<= 1; |
| 993 | 992 | } |
| 994 | | gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, Machine->pens[ cgb_bpal[ ( ( gbcmap[ gb_lcd.layer[l].xindex ] & 0x07 ) * 4 ) + colour ] ] ); |
| 993 | gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, machine->pens[ cgb_bpal[ ( ( gbcmap[ gb_lcd.layer[l].xindex ] & 0x07 ) * 4 ) + colour ] ] ); |
| 995 | 994 | bg_zbuf[ xindex ] = colour + ( gbcmap[ gb_lcd.layer[l].xindex ] & 0x80 ); |
| 996 | 995 | xindex++; |
| 997 | 996 | gb_lcd.layer[l].xshift++; |
| r1905 | r1906 | |
| 1022 | 1021 | l++; |
| 1023 | 1022 | } |
| 1024 | 1023 | if ( gb_lcd.end_x == 160 && ( LCDCONT & 0x02 ) ) { |
| 1025 | | cgb_update_sprites(); |
| 1024 | cgb_update_sprites( machine ); |
| 1026 | 1025 | } |
| 1027 | 1026 | gb_lcd.start_x = gb_lcd.end_x; |
| 1028 | 1027 | } |
| r1905 | r1906 | |
| 1031 | 1030 | /* Draw an empty line when LCD is disabled */ |
| 1032 | 1031 | if ( gb_lcd.previous_line != gb_lcd.current_line ) { |
| 1033 | 1032 | if ( gb_lcd.current_line < 144 ) { |
| 1034 | | rectangle r = Machine->screen[0].visarea; |
| 1033 | rectangle r = machine->screen[0].visarea; |
| 1035 | 1034 | r.min_y = r.max_y = gb_lcd.current_line; |
| 1036 | | fillbitmap( bitmap, Machine->pens[ ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767 ], &r ); |
| 1035 | fillbitmap( bitmap, machine->pens[ ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767 ], &r ); |
| 1037 | 1036 | } |
| 1038 | 1037 | gb_lcd.previous_line = gb_lcd.current_line; |
| 1039 | 1038 | } |
| r1905 | r1906 | |
| 1161 | 1160 | switch( mode ) { |
| 1162 | 1161 | case GB_VIDEO_CGB: vram_size = 0x4000; break; |
| 1163 | 1162 | } |
| 1164 | | gb_vram = new_memory_region( Machine, REGION_GFX1, vram_size, 0 ); |
| 1165 | | gb_oam = new_memory_region( Machine, REGION_GFX2, 0x100, 0 ); |
| 1163 | gb_vram = new_memory_region( machine, REGION_GFX1, vram_size, 0 ); |
| 1164 | gb_oam = new_memory_region( machine, REGION_GFX2, 0x100, 0 ); |
| 1166 | 1165 | memset( gb_vram, 0, vram_size ); |
| 1167 | 1166 | memset( &gb_lcd, 0, sizeof(gb_lcd) ); |
| 1168 | 1167 | |
| r1905 | r1906 | |
| 1349 | 1348 | break; |
| 1350 | 1349 | case GB_LCD_STATE_LYXX_M0: /* Switch to mode 0 */ |
| 1351 | 1350 | /* update current scanline */ |
| 1352 | | update_scanline(); |
| 1351 | update_scanline( machine ); |
| 1353 | 1352 | /* Increment the number of window lines drawn if enabled */ |
| 1354 | 1353 | if ( gb_lcd.layer[1].enabled ) { |
| 1355 | 1354 | gb_lcd.window_lines_drawn++; |
| r1905 | r1906 | |
| 1550 | 1549 | } else { |
| 1551 | 1550 | gb_increment_scanline(); |
| 1552 | 1551 | if ( gb_lcd.current_line < 144 ) { |
| 1553 | | update_scanline(); |
| 1552 | update_scanline( machine ); |
| 1554 | 1553 | } |
| 1555 | 1554 | timer_adjust_oneshot(gb_lcd.lcd_timer, ATTOTIME_IN_CYCLES(456,0), 0); |
| 1556 | 1555 | } |
| r1905 | r1906 | |
| 1580 | 1579 | break; |
| 1581 | 1580 | case GB_LCD_STATE_LYXX_M0: /* Switch to mode 0 */ |
| 1582 | 1581 | /* update current scanline */ |
| 1583 | | update_scanline(); |
| 1582 | update_scanline( machine ); |
| 1584 | 1583 | /* Increment the number of window lines drawn if enabled */ |
| 1585 | 1584 | if ( gb_lcd.layer[1].enabled ) { |
| 1586 | 1585 | gb_lcd.window_lines_drawn++; |
| r1905 | r1906 | |
| 1801 | 1800 | } else { |
| 1802 | 1801 | gb_increment_scanline(); |
| 1803 | 1802 | if ( gb_lcd.current_line < 144 ) { |
| 1804 | | update_scanline(); |
| 1803 | update_scanline( machine ); |
| 1805 | 1804 | } |
| 1806 | 1805 | timer_adjust_oneshot(gb_lcd.lcd_timer, ATTOTIME_IN_CYCLES(456,0), 0); |
| 1807 | 1806 | } |
| 1808 | 1807 | } |
| 1809 | 1808 | |
| 1810 | | static void gb_lcd_switch_on( void ) { |
| 1809 | static void gb_lcd_switch_on( running_machine *machine ) { |
| 1811 | 1810 | gb_lcd.current_line = 0; |
| 1812 | 1811 | gb_lcd.previous_line = 153; |
| 1813 | 1812 | gb_lcd.window_lines_drawn = 0; |
| r1905 | r1906 | |
| 1820 | 1819 | LCDSTAT |= 0x04; |
| 1821 | 1820 | /* Generate lcd interrupt if requested */ |
| 1822 | 1821 | if ( LCDSTAT & 0x40 ) { |
| 1823 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 1822 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 1824 | 1823 | } |
| 1825 | 1824 | } |
| 1826 | 1825 | gb_lcd.state = GB_LCD_STATE_LY00_M2; |
| r1905 | r1906 | |
| 1869 | 1868 | } |
| 1870 | 1869 | /* If LCD is being switched on */ |
| 1871 | 1870 | if ( !( LCDCONT & 0x80 ) && ( data & 0x80 ) ) { |
| 1872 | | gb_lcd_switch_on(); |
| 1871 | gb_lcd_switch_on( machine ); |
| 1873 | 1872 | } |
| 1874 | 1873 | break; |
| 1875 | 1874 | case 0x01: /* STAT - LCD Status */ |
| r1905 | r1906 | |
| 1901 | 1900 | ( ( LCDSTAT & 0x60 ) == 0x00 && ( data & 0x60 ) == 0x20 ) || |
| 1902 | 1901 | ( ( LCDSTAT & 0x60 ) == 0x20 && ( data & 0x40 ) ) |
| 1903 | 1902 | ) ) { |
| 1904 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 1903 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 1905 | 1904 | } |
| 1906 | 1905 | /* |
| 1907 | 1906 | - 0x20 -> 0x08/0x18/0x28/0x48 (mode 0, after m2int) - trigger |
| r1905 | r1906 | |
| 1909 | 1908 | - 0x00 -> 0xXX (mode 0) - trigger stat bug |
| 1910 | 1909 | */ |
| 1911 | 1910 | if ( gb_lcd.mode_irq && gb_lcd.mode == 0 ) { |
| 1912 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 1911 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 1913 | 1912 | } |
| 1914 | 1913 | } |
| 1915 | 1914 | break; |
| r1905 | r1906 | |
| 1922 | 1921 | LCDSTAT |= 0x04; |
| 1923 | 1922 | /* Generate lcd interrupt if requested */ |
| 1924 | 1923 | if ( LCDSTAT & 0x40 ) { |
| 1925 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 1924 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 1926 | 1925 | } |
| 1927 | 1926 | } |
| 1928 | 1927 | } else { |
| r1905 | r1906 | |
| 1940 | 1939 | } |
| 1941 | 1940 | return; |
| 1942 | 1941 | case 0x07: /* BGP - Background Palette */ |
| 1943 | | update_scanline(); |
| 1942 | update_scanline( machine ); |
| 1944 | 1943 | gb_bpal[0] = data & 0x3; |
| 1945 | 1944 | gb_bpal[1] = (data & 0xC) >> 2; |
| 1946 | 1945 | gb_bpal[2] = (data & 0x30) >> 4; |
| 1947 | 1946 | gb_bpal[3] = (data & 0xC0) >> 6; |
| 1948 | 1947 | break; |
| 1949 | 1948 | case 0x08: /* OBP0 - Object Palette 0 */ |
| 1950 | | // update_scanline(); |
| 1949 | // update_scanline( machine ); |
| 1951 | 1950 | gb_spal0[0] = data & 0x3; |
| 1952 | 1951 | gb_spal0[1] = (data & 0xC) >> 2; |
| 1953 | 1952 | gb_spal0[2] = (data & 0x30) >> 4; |
| 1954 | 1953 | gb_spal0[3] = (data & 0xC0) >> 6; |
| 1955 | 1954 | break; |
| 1956 | 1955 | case 0x09: /* OBP1 - Object Palette 1 */ |
| 1957 | | // update_scanline(); |
| 1956 | // update_scanline( machine ); |
| 1958 | 1957 | gb_spal1[0] = data & 0x3; |
| 1959 | 1958 | gb_spal1[1] = (data & 0xC) >> 2; |
| 1960 | 1959 | gb_spal1[2] = (data & 0x30) >> 4; |
| r1905 | r1906 | |
| 1962 | 1961 | break; |
| 1963 | 1962 | case 0x02: /* SCY - Scroll Y */ |
| 1964 | 1963 | case 0x03: /* SCX - Scroll X */ |
| 1965 | | update_scanline(); |
| 1964 | update_scanline( machine ); |
| 1966 | 1965 | case 0x0A: /* WY - Window Y position */ |
| 1967 | 1966 | case 0x0B: /* WX - Window X position */ |
| 1968 | 1967 | break; |
| r1905 | r1906 | |
| 2012 | 2011 | } |
| 2013 | 2012 | /* If LCD is being switched on */ |
| 2014 | 2013 | if ( !( LCDCONT & 0x80 ) && ( data & 0x80 ) ) { |
| 2015 | | gb_lcd_switch_on(); |
| 2014 | gb_lcd_switch_on( machine ); |
| 2016 | 2015 | } |
| 2017 | 2016 | break; |
| 2018 | 2017 | case 0x01: /* STAT - LCD Status */ |
| r1905 | r1906 | |
| 2022 | 2021 | - 0x20 -> 0x08/0x18/0x28/0x48 (mode 0, after m2int) - trigger |
| 2023 | 2022 | */ |
| 2024 | 2023 | if ( gb_lcd.mode_irq && gb_lcd.mode == 0 && ( LCDSTAT & 0x28 ) == 0x20 && ( data & 0x08 ) ) { |
| 2025 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 2024 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 2026 | 2025 | } |
| 2027 | 2026 | /* Check if line irqs are being disabled */ |
| 2028 | 2027 | if ( ! ( data & 0x40 ) ) { |
| r1905 | r1906 | |
| 2032 | 2031 | if ( ! ( LCDSTAT & 0x40 ) && ( data & 0x40 ) ) { |
| 2033 | 2032 | if ( CMPLINE == CURLINE ) { |
| 2034 | 2033 | gb_lcd.line_irq = 1; |
| 2035 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 2034 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 2036 | 2035 | } |
| 2037 | 2036 | } |
| 2038 | 2037 | } |
| r1905 | r1906 | |
| 2044 | 2043 | LCDSTAT |= 0x04; |
| 2045 | 2044 | /* Generate lcd interrupt if requested */ |
| 2046 | 2045 | if ( LCDSTAT & 0x40 ) { |
| 2047 | | cpunum_set_input_line( Machine, 0, LCD_INT, HOLD_LINE ); |
| 2046 | cpunum_set_input_line( machine, 0, LCD_INT, HOLD_LINE ); |
| 2048 | 2047 | } |
| 2049 | 2048 | } else { |
| 2050 | 2049 | LCDSTAT &= 0xFB; |
| r1905 | r1906 | |
| 2056 | 2055 | case 0x07: /* BGP - GB background palette */ |
| 2057 | 2056 | /* Some GBC games are lazy and still call this */ |
| 2058 | 2057 | if( gbc_mode == GBC_MODE_MONO ) { |
| 2059 | | update_scanline(); |
| 2058 | update_scanline( machine ); |
| 2060 | 2059 | cgb_bpal[0] = gbc_to_gb_pal[(data & 0x03)]; |
| 2061 | 2060 | cgb_bpal[1] = gbc_to_gb_pal[(data & 0x0C) >> 2]; |
| 2062 | 2061 | cgb_bpal[2] = gbc_to_gb_pal[(data & 0x30) >> 4]; |