src/mess/video/vic6567.c
| r5507 | r5508 | |
| 1 | 1 | /*************************************************************************** |
| 2 | 2 | |
| 3 | | Video Interface Chip 6567 (6566 6569 and some other) |
| 3 | Video Interface Chip (6567R8 for NTSC system and 6569 for PAL system) |
| 4 | 4 | PeT mess@utanet.at |
| 5 | 5 | |
| 6 | A part of the code (cycle routine and drawing routines) is a modified version of the vic ii emulation used in |
| 7 | commodore 64 emulator "frodo" by Christian Bauer |
| 8 | |
| 9 | http://frodo.cebix.net/ |
| 10 | The rights on the source code remain at the author. |
| 11 | It may not - not even in parts - used for commercial purposes without explicit written permission by the author. |
| 12 | Permission to use it for non-commercial purposes is hereby granted als long as my copyright notice remains in the program. |
| 13 | You are not allowed to use the source to create and distribute a modified version of Frodo. |
| 14 | |
| 6 | 15 | ***************************************************************************/ |
| 7 | 16 | /* mos videochips |
| 8 | 17 | vic (6560 NTSC, 6561 PAL) |
| r5507 | r5508 | |
| 65 | 74 | /* lightpen values */ |
| 66 | 75 | #include "includes/c64.h" |
| 67 | 76 | |
| 68 | | // emu_timer *vicii_scanline_timer; |
| 69 | | |
| 70 | 77 | #define VERBOSE_LEVEL 0 |
| 71 | 78 | #define DBG_LOG(N,M,A) \ |
| 72 | 79 | do { \ |
| r5507 | r5508 | |
| 78 | 85 | } \ |
| 79 | 86 | } while (0) |
| 80 | 87 | |
| 88 | // Display |
| 89 | #define ROW25_YSTART 0x33 |
| 90 | #define ROW25_YSTOP 0xfb |
| 91 | #define ROW24_YSTART 0x37 |
| 92 | #define ROW24_YSTOP 0xf7 |
| 81 | 93 | |
| 94 | static UINT16 dy_start = ROW24_YSTART; |
| 95 | static UINT16 dy_stop = ROW24_YSTOP; |
| 82 | 96 | |
| 83 | | /*#define GFX */ |
| 97 | // GFX |
| 98 | static UINT8 draw_this_line = 0; |
| 99 | static UINT8 is_bad_line = 0; |
| 100 | static UINT8 bad_lines_enabled = 0; |
| 101 | static UINT8 display_state = 0; |
| 102 | static UINT8 char_data = 0; |
| 103 | static UINT8 gfx_data = 0; |
| 104 | static UINT8 color_data = 0; |
| 105 | static UINT8 last_char_data = 0; |
| 106 | static UINT8 matrix_line[40]; // Buffer for video line, read in Bad Lines |
| 107 | static UINT8 color_line[40]; // Buffer for color line, read in Bad Lines |
| 108 | static UINT8 vblanking = 0; |
| 109 | static UINT16 ml_index = 0; |
| 110 | static UINT8 rc = 0; |
| 111 | static UINT16 vc = 0; |
| 112 | static UINT16 vc_base = 0; |
| 113 | static UINT8 ref_cnt = 0; |
| 84 | 114 | |
| 85 | | #define VREFRESHINLINES 28 |
| 115 | // Sprites |
| 116 | static UINT8 spr_coll_buf[0x400]; // Buffer for sprite-sprite collisions and priorities |
| 117 | static UINT8 fore_coll_buf[0x400]; // Buffer for foreground-sprite collisions and priorities |
| 118 | static UINT8 spr_draw_data[8][4]; // Sprite data for drawing |
| 119 | static UINT8 spr_exp_y = 0; |
| 120 | static UINT8 spr_dma_on; |
| 121 | static UINT8 spr_draw = 0; |
| 122 | static UINT8 spr_disp_on = 0; |
| 123 | static UINT16 spr_ptr[8]; |
| 124 | static UINT8 spr_data[8][4]; |
| 125 | static UINT16 mc_base[8]; // Sprite data counter bases |
| 126 | static UINT16 mc[8] = {63, 63, 63, 63, 63, 63, 63, 63}; // Sprite data counters |
| 86 | 127 | |
| 87 | | #define VIC2_YPOS 50 |
| 88 | | #define RASTERLINE_2_C64(a) (a) |
| 89 | | #define C64_2_RASTERLINE(a) (a) |
| 90 | | #define XPOS (VIC2_STARTVISIBLECOLUMNS + (VIC2_VISIBLECOLUMNS - VIC2_HSIZE)/2) |
| 91 | | #define YPOS (VIC2_STARTVISIBLELINES /* + (VIC2_VISIBLELINES - VIC2_VSIZE)/2 */) |
| 92 | | #define FIRSTLINE 36 /* ((VIC2_VISIBLELINES - VIC2_VSIZE)/2) */ |
| 128 | // Border |
| 129 | static UINT8 border_on = 0; |
| 130 | static UINT8 ud_border_on = 0; |
| 131 | static UINT8 border_on_sample[5]; |
| 132 | static UINT8 border_color_sample[0x400 / 8]; // Samples of border color at each "displayed" cycle |
| 93 | 133 | |
| 134 | // Cycles |
| 135 | static UINT64 first_ba_cycle; |
| 136 | static UINT8 cpu_suspended = 0; |
| 137 | |
| 138 | #define VREFRESHINLINES 28 |
| 139 | |
| 140 | #define VIC2_YPOS 50 |
| 141 | #define RASTERLINE_2_C64(a) (a) |
| 142 | #define C64_2_RASTERLINE(a) (a) |
| 143 | #define XPOS (VIC2_STARTVISIBLECOLUMNS + (VIC2_VISIBLECOLUMNS - VIC2_HSIZE) / 2) |
| 144 | #define YPOS (VIC2_STARTVISIBLELINES /* + (VIC2_VISIBLELINES - VIC2_VSIZE) / 2 */) |
| 145 | #define FIRSTLINE 10 /* 36 ((VIC2_VISIBLELINES - VIC2_VSIZE)/2) */ |
| 146 | #define FIRSTCOLUMN 50 |
| 147 | |
| 94 | 148 | /* 2008-05 FP: lightpen code needs to read input port from c64.c and cbmb.c */ |
| 95 | | #define LIGHTPEN_BUTTON (input_port_read(machine, "OTHER") & 0x04) |
| 96 | | #define LIGHTPEN_X_VALUE (input_port_read(machine, "LIGHTX") & ~0x01) |
| 97 | | #define LIGHTPEN_Y_VALUE (input_port_read(machine, "LIGHTY") & ~0x01) |
| 149 | #define LIGHTPEN_BUTTON (input_port_read(machine, "OTHER") & 0x04) |
| 150 | #define LIGHTPEN_X_VALUE (input_port_read(machine, "LIGHTX") & ~0x01) |
| 151 | #define LIGHTPEN_Y_VALUE (input_port_read(machine, "LIGHTY") & ~0x01) |
| 98 | 152 | |
| 99 | | /* lightpen delivers values from internal counters |
| 100 | | * they do not start with the visual area or frame area */ |
| 101 | | #define VIC2_MAME_XPOS 0 |
| 102 | | #define VIC2_MAME_YPOS 0 |
| 103 | | #define VIC6567_X_BEGIN 38 |
| 104 | | #define VIC6567_Y_BEGIN -6 /* first 6 lines after retrace not for lightpen! */ |
| 105 | | #define VIC6569_X_BEGIN 38 |
| 106 | | #define VIC6569_Y_BEGIN -6 |
| 107 | | #define VIC2_X_BEGIN (vic2.pal?VIC6569_X_BEGIN:VIC6567_X_BEGIN) |
| 108 | | #define VIC2_Y_BEGIN (vic2.pal?VIC6569_Y_BEGIN:VIC6567_Y_BEGIN) |
| 109 | | #define VIC2_X_VALUE ((LIGHTPEN_X_VALUE+VIC2_X_BEGIN \ |
| 110 | | +VIC2_MAME_XPOS)/2) |
| 111 | | #define VIC2_Y_VALUE ((LIGHTPEN_Y_VALUE+VIC2_Y_BEGIN \ |
| 112 | | +VIC2_MAME_YPOS)) |
| 153 | /* lightpen delivers values from internal counters; they do not start with the visual area or frame area */ |
| 154 | #define VIC2_MAME_XPOS 0 |
| 155 | #define VIC2_MAME_YPOS 0 |
| 156 | #define VIC6567_X_BEGIN 38 |
| 157 | #define VIC6567_Y_BEGIN -6 /* first 6 lines after retrace not for lightpen! */ |
| 158 | #define VIC6569_X_BEGIN 38 |
| 159 | #define VIC6569_Y_BEGIN -6 |
| 160 | #define VIC2_X_BEGIN (vic2.pal ? VIC6569_X_BEGIN : VIC6567_X_BEGIN) |
| 161 | #define VIC2_Y_BEGIN (vic2.pal ? VIC6569_Y_BEGIN : VIC6567_Y_BEGIN) |
| 162 | #define VIC2_X_VALUE ((LIGHTPEN_X_VALUE+VIC2_X_BEGIN + VIC2_MAME_XPOS) / 2) |
| 163 | #define VIC2_Y_VALUE ((LIGHTPEN_Y_VALUE+VIC2_Y_BEGIN + VIC2_MAME_YPOS)) |
| 113 | 164 | |
| 114 | | #define VIC2E_K0_LEVEL (vic2.reg[0x2f]&1) |
| 115 | | #define VIC2E_K1_LEVEL (vic2.reg[0x2f]&2) |
| 116 | | #define VIC2E_K2_LEVEL (vic2.reg[0x2f]&4) |
| 165 | #define VIC2E_K0_LEVEL (vic2.reg[0x2f] & 0x01) |
| 166 | #define VIC2E_K1_LEVEL (vic2.reg[0x2f] & 0x02) |
| 167 | #define VIC2E_K2_LEVEL (vic2.reg[0x2f] & 0x04) |
| 117 | 168 | |
| 118 | | /*#define VIC3_P5_LEVEL (vic2.reg[0x30]&0x20) */ |
| 119 | | #define VIC3_BITPLANES (vic2.reg[0x31]&0x10) |
| 120 | | #define VIC3_80COLUMNS (vic2.reg[0x31]&0x80) |
| 121 | | #define VIC3_LINES ((vic2.reg[0x31]&0x19)==0x19?400:200) |
| 122 | | #define VIC3_BITPLANES_WIDTH (vic2.reg[0x31]&0x80?640:320) |
| 169 | /*#define VIC3_P5_LEVEL (vic2.reg[0x30] & 0x20) */ |
| 170 | #define VIC3_BITPLANES (vic2.reg[0x31] & 0x10) |
| 171 | #define VIC3_80COLUMNS (vic2.reg[0x31] & 0x80) |
| 172 | #define VIC3_LINES ((vic2.reg[0x31] & 0x19) == 0x19 ? 400 : 200) |
| 173 | #define VIC3_BITPLANES_WIDTH (vic2.reg[0x31] & 0x80 ? 640 : 320) |
| 123 | 174 | |
| 124 | | /*#define VIC2E_TEST (vic2[0x30]&2) */ |
| 125 | | #define DOUBLE_CLOCK (vic2.reg[0x30]&1) |
| 175 | /*#define VIC2E_TEST (vic2[0x30] & 2) */ |
| 176 | #define DOUBLE_CLOCK (vic2.reg[0x30] & 0x01) |
| 126 | 177 | |
| 127 | 178 | /* sprites 0 .. 7 */ |
| 128 | | #define SPRITE_BASE_X_SIZE 24 |
| 129 | | #define SPRITE_BASE_Y_SIZE 21 |
| 130 | | #define SPRITEON(nr) (vic2.reg[0x15]&(1<<nr)) |
| 131 | | #define SPRITE_Y_EXPAND(nr) (vic2.reg[0x17]&(1<<nr)) |
| 132 | | #define SPRITE_Y_SIZE(nr) (SPRITE_Y_EXPAND(nr)?2*21:21) |
| 133 | | #define SPRITE_X_EXPAND(nr) (vic2.reg[0x1d]&(1<<nr)) |
| 134 | | #define SPRITE_X_SIZE(nr) (SPRITE_X_EXPAND(nr)?2*24:24) |
| 135 | | #define SPRITE_X_POS(nr) ( (vic2.reg[(nr)*2]|(vic2.reg[0x10]&(1<<(nr))?0x100:0))-24+XPOS ) |
| 136 | | #define SPRITE_Y_POS(nr) (vic2.reg[1+2*(nr)]-50+YPOS) |
| 137 | | #define SPRITE_MULTICOLOR(nr) (vic2.reg[0x1c]&(1<<nr)) |
| 138 | | #define SPRITE_PRIORITY(nr) (vic2.reg[0x1b]&(1<<nr)) |
| 139 | | #define SPRITE_MULTICOLOR1 (vic2.reg[0x25]&0xf) |
| 140 | | #define SPRITE_MULTICOLOR2 (vic2.reg[0x26]&0xf) |
| 141 | | #define SPRITE_COLOR(nr) (vic2.reg[0x27+nr]&0xf) |
| 142 | | #define SPRITE_ADDR(nr) (vic2.videoaddr+0x3f8+nr) |
| 143 | | #define SPRITE_BG_COLLISION(nr) (vic2.reg[0x1f]&(1<<nr)) |
| 144 | | #define SPRITE_COLLISION(nr) (vic2.reg[0x1e]&(1<<nr)) |
| 145 | | #define SPRITE_SET_BG_COLLISION(nr) (vic2.reg[0x1f]|=(1<<nr)) |
| 146 | | #define SPRITE_SET_COLLISION(nr) (vic2.reg[0x1e]|=(1<<nr)) |
| 179 | #define SPRITE_BASE_X_SIZE 24 |
| 180 | #define SPRITE_BASE_Y_SIZE 21 |
| 181 | #define SPRITEON(nr) (vic2.reg[0x15] & (1 << nr)) |
| 182 | #define SPRITE_Y_EXPAND(nr) (vic2.reg[0x17] & (1 << nr)) |
| 183 | #define SPRITE_Y_SIZE(nr) (SPRITE_Y_EXPAND(nr) ? 2 * 21 : 21) |
| 184 | #define SPRITE_X_EXPAND(nr) (vic2.reg[0x1d] & (1 << nr)) |
| 185 | #define SPRITE_X_SIZE(nr) (SPRITE_X_EXPAND(nr) ? 2 * 24 : 24) |
| 186 | #define SPRITE_X_POS(nr) ((vic2.reg[(nr) * 2] | (vic2.reg[0x10] & (1 << (nr)) ? 0x100 : 0)) - 24 + XPOS) |
| 187 | #define SPRITE_X_POS2(nr) (vic2.reg[(nr) * 2] | (vic2.reg[0x10] & (1 << (nr)) ? 0x100 : 0)) |
| 188 | #define SPRITE_Y_POS(nr) (vic2.reg[1+2*(nr)] - 50 + YPOS) |
| 189 | #define SPRITE_Y_POS2(nr) (vic2.reg[1 + 2 * (nr)]) |
| 190 | #define SPRITE_MULTICOLOR(nr) (vic2.reg[0x1c] & (1 << nr)) |
| 191 | #define SPRITE_PRIORITY(nr) (vic2.reg[0x1b] & (1 << nr)) |
| 192 | #define SPRITE_MULTICOLOR1 (vic2.reg[0x25] & 0x0f) |
| 193 | #define SPRITE_MULTICOLOR2 (vic2.reg[0x26] & 0x0f) |
| 194 | #define SPRITE_COLOR(nr) (vic2.reg[0x27+nr] & 0x0f) |
| 195 | #define SPRITE_ADDR(nr) (vic2.videoaddr | 0x3f8 | nr) |
| 196 | #define SPRITE_BG_COLLISION(nr) (vic2.reg[0x1f] & (1 << nr)) |
| 197 | #define SPRITE_COLLISION(nr) (vic2.reg[0x1e] & (1 << nr)) |
| 198 | #define SPRITE_SET_BG_COLLISION(nr) (vic2.reg[0x1f] |= (1 << nr)) |
| 199 | #define SPRITE_SET_COLLISION(nr) (vic2.reg[0x1e] |= (1 << nr)) |
| 200 | #define SPRITE_COLL (vic2.reg[0x1e]) |
| 201 | #define SPRITE_BG_COLL (vic2.reg[0x1f]) |
| 147 | 202 | |
| 148 | | // for sprite's changes in the middle of a raster line |
| 149 | | #define SPRITE_X_POS_BUFFER(nr) ( (vic2.reg_buffer[(nr)*2]|(vic2.reg_buffer[0x10]&(1<<(nr))?0x100:0))-24+XPOS ) |
| 150 | | #define SPRITE_Y_POS_BUFFER(nr) (vic2.reg_buffer[1+2*(nr)]-50+YPOS) |
| 151 | | #define SPRITE_MULTICOLOR1_BUFFER (vic2.reg_buffer[0x25]&0xf) |
| 152 | | #define SPRITE_MULTICOLOR2_BUFFER (vic2.reg_buffer[0x26]&0xf) |
| 203 | #define GFXMODE ((vic2.reg[0x11] & 0x60) | (vic2.reg[0x16] & 0x10)) >> 4 |
| 204 | #define SCREENON (vic2.reg[0x11] & 0x10) |
| 205 | #define VERTICALPOS (vic2.reg[0x11] & 0x07) |
| 206 | #define HORIZONTALPOS (vic2.reg[0x16] & 0x07) |
| 207 | #define ECMON (vic2.reg[0x11] & 0x40) |
| 208 | #define HIRESON (vic2.reg[0x11] & 0x20) |
| 209 | #define MULTICOLORON (vic2.reg[0x16] & 0x10) |
| 210 | #define LINES25 (vic2.reg[0x11] & 0x08) /* else 24 Lines */ |
| 211 | #define LINES (LINES25 ? 25 : 24) |
| 212 | #define YSIZE (LINES * 8) |
| 213 | #define COLUMNS40 (vic2.reg[0x16] & 0x08) /* else 38 Columns */ |
| 214 | #define COLUMNS (COLUMNS40 ? 40 : 38) |
| 215 | #define XSIZE (COLUMNS * 8) |
| 153 | 216 | |
| 154 | | #define SCREENON (vic2.reg[0x11]&0x10) |
| 155 | | #define VERTICALPOS (vic2.reg[0x11]&7) |
| 156 | | #define HORIZONTALPOS (vic2.reg[0x16]&7) |
| 157 | | #define ECMON (vic2.reg[0x11]&0x40) |
| 158 | | #define HIRESON (vic2.reg[0x11]&0x20) |
| 159 | | #define MULTICOLORON (vic2.reg[0x16]&0x10) |
| 160 | | #define LINES25 (vic2.reg[0x11]&8) /* else 24 Lines */ |
| 161 | | #define LINES (LINES25?25:24) |
| 162 | | #define YSIZE (LINES*8) |
| 163 | | #define COLUMNS40 (vic2.reg[0x16]&8) /* else 38 Columns */ |
| 164 | | #define COLUMNS (COLUMNS40?40:38) |
| 165 | | #define XSIZE (COLUMNS*8) |
| 217 | #define VIDEOADDR ((vic2.reg[0x18] & 0xf0) << (10 - 4)) |
| 218 | #define CHARGENADDR ((vic2.reg[0x18] & 0x0e) << 10) |
| 219 | #define BITMAPADDR ((data & 0x08) << 10) |
| 166 | 220 | |
| 167 | | #define VIDEOADDR ( (vic2.reg[0x18]&0xf0)<<(10-4) ) |
| 168 | | #define CHARGENADDR ((vic2.reg[0x18]&0xe)<<10) |
| 221 | #define RASTERLINE (((vic2.reg[0x11] & 0x80) << 1) | vic2.reg[0x12]) |
| 169 | 222 | |
| 170 | | #define RASTERLINE ( ((vic2.reg[0x11]&0x80)<<1)|vic2.reg[0x12]) |
| 223 | #define FRAMECOLOR (vic2.reg[0x20] & 0x0f) |
| 224 | #define BACKGROUNDCOLOR (vic2.reg[0x21] & 0x0f) |
| 225 | #define MULTICOLOR1 (vic2.reg[0x22] & 0x0f) |
| 226 | #define MULTICOLOR2 (vic2.reg[0x23] & 0x0f) |
| 227 | #define FOREGROUNDCOLOR (vic2.reg[0x24] & 0x0f) |
| 171 | 228 | |
| 172 | | #define BACKGROUNDCOLOR (vic2.reg[0x21]&0xf) |
| 173 | | #define MULTICOLOR1 (vic2.reg[0x22]&0xf) |
| 174 | | #define MULTICOLOR2 (vic2.reg[0x23]&0xf) |
| 175 | | #define FOREGROUNDCOLOR (vic2.reg[0x24]&0xf) |
| 176 | | #define FRAMECOLOR (vic2.reg[0x20]&0xf) |
| 177 | | |
| 178 | 229 | const unsigned char vic2_palette[] = |
| 179 | 230 | { |
| 180 | 231 | /* black, white, red, cyan */ |
| r5507 | r5508 | |
| 189 | 240 | }; |
| 190 | 241 | |
| 191 | 242 | static struct { |
| 192 | | UINT8 reg[0x80],reg_buffer[0x80]; // buffer for sprite's changes in a middle of a rasterline |
| 243 | UINT8 reg[0x80]; |
| 193 | 244 | int pal; |
| 194 | | int vic2e; /* version with some port lines */ |
| 245 | int vic2e; /* version with some port lines */ |
| 195 | 246 | int vic3; |
| 196 | | int on; /* rastering of the screen */ |
| 247 | int on; /* rastering of the screen */ |
| 197 | 248 | |
| 198 | 249 | int (*dma_read)(running_machine *, int); |
| 199 | 250 | int (*dma_read_color)(running_machine *, int); |
| r5507 | r5508 | |
| 202 | 253 | |
| 203 | 254 | int lines; |
| 204 | 255 | |
| 205 | | int chargenaddr, videoaddr; |
| 256 | UINT16 chargenaddr, videoaddr, bitmapaddr; |
| 206 | 257 | |
| 207 | 258 | bitmap_t *bitmap; |
| 208 | 259 | int x_begin, x_end; |
| 209 | 260 | int y_begin, y_end; |
| 210 | 261 | |
| 211 | | UINT16 c64_bitmap[2], bitmapmulti[4], mono[2], multi[4], ecmcolor[2], colors[4], spritemulti[4], spritemulti_buffer[4]; |
| 262 | UINT16 c64_bitmap[2], bitmapmulti[4], mono[2], multi[4], ecmcolor[2], colors[4], spritemulti[4]; |
| 212 | 263 | |
| 213 | 264 | int lastline, rasterline, raster_mod; |
| 214 | | UINT64 rasterline_start_cpu_cycles, totalcycles; |
| 215 | | UINT8 rasterX; |
| 265 | UINT64 rasterline_start_cpu_cycles, totalcycles, cycles_counter; |
| 266 | UINT8 rasterX, cycle; |
| 267 | UINT16 raster_x; |
| 268 | UINT16 graphic_x; |
| 216 | 269 | |
| 217 | 270 | /* background/foreground for sprite collision */ |
| 218 | 271 | UINT8 *screen[216], shift[216]; |
| r5507 | r5508 | |
| 225 | 278 | /* converts sprite multicolor info to info for background collision checking */ |
| 226 | 279 | UINT8 multi_collision[256]; |
| 227 | 280 | |
| 228 | | struct { |
| 281 | struct |
| 282 | { |
| 229 | 283 | int on, x, y, xexpand, yexpand; |
| 230 | 284 | |
| 231 | | int repeat; /* y expand, line once drawn */ |
| 232 | | int line; /* 0 not painting, else painting */ |
| 285 | int repeat; /* expand, line once drawn */ |
| 286 | int line; /* 0 not painting, else painting */ |
| 233 | 287 | |
| 234 | 288 | /* buffer for currently painted line */ |
| 235 | 289 | int paintedline[8]; |
| 236 | | UINT8 bitmap[8][SPRITE_BASE_X_SIZE * 2 / 8 + 1/*for simplier sprite collision detection*/]; |
| 237 | | } |
| 238 | | sprites[8]; // buffer for sprite's changes in a middle of a rasterline |
| 239 | | struct { |
| 240 | | int on, x, y, xexpand, yexpand; |
| 241 | | } |
| 242 | | sprites_buffer[8]; |
| 290 | UINT8 bitmap[8][SPRITE_BASE_X_SIZE * 2 / 8 + 1 /*for simplier sprite collision detection*/]; |
| 291 | } sprites[8]; |
| 243 | 292 | } vic2; |
| 244 | 293 | |
| 245 | 294 | INLINE int vic2_getforeground (register int y, register int x) |
| r5507 | r5508 | |
| 270 | 319 | { |
| 271 | 320 | memset(&vic2, 0, sizeof(vic2)); |
| 272 | 321 | |
| 273 | | vic2.totalcycles = 63; |
| 322 | vic2.cycles_counter = 0; // total cycles |
| 323 | vic2.cycle = 63; // first cycle |
| 274 | 324 | vic2.pal = pal; |
| 275 | 325 | vic2.lines = VIC2_LINES; |
| 276 | 326 | |
| r5507 | r5508 | |
| 364 | 414 | WRITE8_HANDLER ( vic2_port_w ) |
| 365 | 415 | { |
| 366 | 416 | running_machine *machine = space->machine; |
| 367 | | int cycles, realx; |
| 368 | 417 | DBG_LOG (2, "vic write", ("%.2x:%.2x\n", offset, data)); |
| 369 | 418 | offset &= 0x3f; |
| 419 | |
| 370 | 420 | switch (offset) |
| 371 | 421 | { |
| 372 | | case 1: |
| 373 | | case 3: |
| 374 | | case 5: |
| 375 | | case 7: |
| 376 | | case 9: |
| 377 | | case 0xb: |
| 378 | | case 0xd: |
| 379 | | case 0xf: |
| 380 | | /* sprite y positions */ |
| 422 | case 0x01: |
| 423 | case 0x03: |
| 424 | case 0x05: |
| 425 | case 0x07: |
| 426 | case 0x09: |
| 427 | case 0x0b: |
| 428 | case 0x0d: |
| 429 | case 0x0f: |
| 430 | /* sprite y positions */ |
| 381 | 431 | if (vic2.reg[offset] != data) |
| 382 | 432 | { |
| 383 | | vic2.reg_buffer[offset] = data; |
| 384 | | vic2.sprites_buffer[offset/2].y = SPRITE_Y_POS_BUFFER(offset/2); |
| 433 | vic2.reg[offset] = data; |
| 434 | vic2.sprites[offset / 2].y = SPRITE_Y_POS(offset / 2); |
| 385 | 435 | } |
| 386 | 436 | break; |
| 387 | | case 0: |
| 388 | | case 2: |
| 389 | | case 4: |
| 390 | | case 6: |
| 391 | | case 8: |
| 392 | | case 0xa: |
| 393 | | case 0xc: |
| 394 | | case 0xe: |
| 395 | | /* sprite x positions */ |
| 437 | |
| 438 | case 0x00: |
| 439 | case 0x02: |
| 440 | case 0x04: |
| 441 | case 0x06: |
| 442 | case 0x08: |
| 443 | case 0x0a: |
| 444 | case 0x0c: |
| 445 | case 0x0e: |
| 446 | /* sprite x positions */ |
| 396 | 447 | if (vic2.reg[offset] != data) |
| 397 | 448 | { |
| 398 | | vic2.reg_buffer[offset] = data; |
| 399 | | vic2.sprites_buffer[offset/2].x = SPRITE_X_POS_BUFFER(offset/2); |
| 449 | vic2.reg[offset] = data; |
| 450 | vic2.sprites[offset / 2].x = SPRITE_X_POS(offset / 2); |
| 400 | 451 | } |
| 401 | 452 | break; |
| 402 | | case 0x10: |
| 403 | | /* sprite x positions */ |
| 453 | |
| 454 | case 0x10: /* sprite x positions */ |
| 404 | 455 | if (vic2.reg[offset] != data) |
| 405 | 456 | { |
| 406 | | vic2.reg_buffer[offset] = data; |
| 407 | | vic2.sprites_buffer[0].x = SPRITE_X_POS_BUFFER(0); |
| 408 | | vic2.sprites_buffer[1].x = SPRITE_X_POS_BUFFER(1); |
| 409 | | vic2.sprites_buffer[2].x = SPRITE_X_POS_BUFFER(2); |
| 410 | | vic2.sprites_buffer[3].x = SPRITE_X_POS_BUFFER(3); |
| 411 | | vic2.sprites_buffer[4].x = SPRITE_X_POS_BUFFER(4); |
| 412 | | vic2.sprites_buffer[5].x = SPRITE_X_POS_BUFFER(5); |
| 413 | | vic2.sprites_buffer[6].x = SPRITE_X_POS_BUFFER(6); |
| 414 | | vic2.sprites_buffer[7].x = SPRITE_X_POS_BUFFER(7); |
| 457 | vic2.reg[offset] = data; |
| 458 | vic2.sprites[0].x = SPRITE_X_POS(0); |
| 459 | vic2.sprites[1].x = SPRITE_X_POS(1); |
| 460 | vic2.sprites[2].x = SPRITE_X_POS(2); |
| 461 | vic2.sprites[3].x = SPRITE_X_POS(3); |
| 462 | vic2.sprites[4].x = SPRITE_X_POS(4); |
| 463 | vic2.sprites[5].x = SPRITE_X_POS(5); |
| 464 | vic2.sprites[6].x = SPRITE_X_POS(6); |
| 465 | vic2.sprites[7].x = SPRITE_X_POS(7); |
| 415 | 466 | } |
| 416 | 467 | break; |
| 417 | | case 0x17: /* sprite y size */ |
| 418 | | case 0x1d: /* sprite x size */ |
| 419 | | case 0x1b: /* sprite background priority */ |
| 420 | | case 0x1c: /* sprite multicolor mode select */ |
| 468 | |
| 469 | case 0x17: /* sprite y size */ |
| 470 | spr_exp_y |= ~data; |
| 471 | if (vic2.reg[offset] != data) |
| 472 | { |
| 473 | vic2.reg[offset] = data; |
| 474 | } |
| 475 | break; |
| 476 | |
| 477 | case 0x1d: /* sprite x size */ |
| 478 | if (vic2.reg[offset] != data) |
| 479 | { |
| 480 | vic2.reg[offset] = data; |
| 481 | } |
| 482 | break; |
| 483 | |
| 484 | case 0x1b: /* sprite background priority */ |
| 485 | if (vic2.reg[offset] != data) |
| 486 | { |
| 487 | vic2.reg[offset] = data; |
| 488 | } |
| 489 | break; |
| 490 | |
| 491 | case 0x1c: /* sprite multicolor mode select */ |
| 492 | if (vic2.reg[offset] != data) |
| 493 | { |
| 494 | vic2.reg[offset] = data; |
| 495 | } |
| 496 | break; |
| 497 | |
| 421 | 498 | case 0x27: |
| 422 | | case 0x28: /* sprite colors */ |
| 499 | case 0x28: |
| 423 | 500 | case 0x29: |
| 424 | 501 | case 0x2a: |
| 425 | 502 | case 0x2b: |
| 426 | 503 | case 0x2c: |
| 427 | 504 | case 0x2d: |
| 428 | 505 | case 0x2e: |
| 506 | /* sprite colors */ |
| 429 | 507 | if (vic2.reg[offset] != data) |
| 430 | 508 | { |
| 431 | | vic2.reg_buffer[offset] = data; |
| 509 | vic2.reg[offset] = data; |
| 432 | 510 | } |
| 433 | 511 | break; |
| 434 | | case 0x25: |
| 512 | |
| 513 | case 0x25: /* sprite multicolor */ |
| 435 | 514 | if (vic2.reg[offset] != data) |
| 436 | 515 | { |
| 437 | | vic2.reg_buffer[offset] = data; |
| 438 | | vic2.spritemulti_buffer[1] = SPRITE_MULTICOLOR1_BUFFER; |
| 516 | vic2.reg[offset] = data; |
| 517 | vic2.spritemulti[1] = SPRITE_MULTICOLOR1; |
| 439 | 518 | } |
| 440 | 519 | break; |
| 441 | | case 0x26: |
| 520 | |
| 521 | case 0x26: /* sprite multicolor */ |
| 442 | 522 | if (vic2.reg[offset] != data) |
| 443 | 523 | { |
| 444 | | vic2.reg_buffer[offset] = data; |
| 445 | | vic2.spritemulti_buffer[3] = SPRITE_MULTICOLOR2_BUFFER; |
| 524 | vic2.reg[offset] = data; |
| 525 | vic2.spritemulti[3] = SPRITE_MULTICOLOR2; |
| 446 | 526 | } |
| 447 | 527 | break; |
| 528 | |
| 448 | 529 | case 0x19: |
| 449 | | vic2_clear_interrupt(space->machine, data & 0xf); |
| 530 | vic2_clear_interrupt(space->machine, data & 0x0f); |
| 450 | 531 | break; |
| 451 | | case 0x1a: /* irq mask */ |
| 532 | |
| 533 | case 0x1a: /* irq mask */ |
| 452 | 534 | vic2.reg[offset] = data; |
| 453 | | vic2_set_interrupt(space->machine, 0); //beamrider needs this |
| 535 | vic2_set_interrupt(space->machine, 0); // beamrider needs this |
| 454 | 536 | break; |
| 537 | |
| 455 | 538 | case 0x11: |
| 456 | 539 | if (vic2.reg[offset] != data) |
| 457 | 540 | { |
| 458 | | // vic2.reg_buffer[offset] = data; |
| 459 | | |
| 460 | 541 | vic2.reg[offset] = data; |
| 461 | 542 | if (LINES25) |
| 462 | 543 | { |
| r5507 | r5508 | |
| 468 | 549 | vic2.y_begin = 4; |
| 469 | 550 | vic2.y_end = vic2.y_begin + 192; |
| 470 | 551 | } |
| 471 | | |
| 552 | if (data & 8) { |
| 553 | dy_start = ROW25_YSTART; |
| 554 | dy_stop = ROW25_YSTOP; |
| 555 | } else { |
| 556 | dy_start = ROW24_YSTART; |
| 557 | dy_stop = ROW24_YSTOP; |
| 558 | } |
| 472 | 559 | } |
| 473 | 560 | break; |
| 561 | |
| 474 | 562 | case 0x12: |
| 475 | 563 | if (data != vic2.reg[offset]) |
| 476 | 564 | { |
| 477 | 565 | vic2.reg[offset] = data; |
| 478 | 566 | } |
| 479 | 567 | break; |
| 568 | |
| 480 | 569 | case 0x16: |
| 481 | 570 | if (vic2.reg[offset] != data) |
| 482 | 571 | { |
| 483 | | // vic2.reg_buffer[offset] = data; |
| 484 | | |
| 485 | 572 | vic2.reg[offset] = data; |
| 486 | 573 | vic2.x_begin = HORIZONTALPOS; |
| 487 | 574 | vic2.x_end = vic2.x_begin + 320; |
| 488 | 575 | } |
| 489 | 576 | break; |
| 577 | |
| 490 | 578 | case 0x18: |
| 491 | 579 | if (vic2.reg[offset] != data) |
| 492 | 580 | { |
| 493 | 581 | vic2.reg[offset] = data; |
| 494 | 582 | vic2.videoaddr = VIDEOADDR; |
| 495 | 583 | vic2.chargenaddr = CHARGENADDR; |
| 584 | vic2.bitmapaddr = BITMAPADDR; |
| 496 | 585 | } |
| 497 | 586 | break; |
| 498 | | case 0x21: /* background color */ |
| 587 | |
| 588 | case 0x21: /* background color */ |
| 499 | 589 | if (vic2.reg[offset] != data) |
| 500 | 590 | { |
| 501 | 591 | vic2.reg[offset] = data; |
| 502 | | vic2.mono[0] = vic2.bitmapmulti[0] = vic2.multi[0] = |
| 503 | | vic2.colors[0] = BACKGROUNDCOLOR; |
| 592 | vic2.mono[0] = vic2.bitmapmulti[0] = vic2.multi[0] = vic2.colors[0] = BACKGROUNDCOLOR; |
| 504 | 593 | } |
| 505 | 594 | break; |
| 506 | | case 0x22: /* background color 1 */ |
| 595 | |
| 596 | case 0x22: /* background color 1 */ |
| 507 | 597 | if (vic2.reg[offset] != data) |
| 508 | 598 | { |
| 509 | 599 | vic2.reg[offset] = data; |
| 510 | 600 | vic2.multi[1] = vic2.colors[1] = MULTICOLOR1; |
| 511 | 601 | } |
| 512 | 602 | break; |
| 513 | | case 0x23: /* background color 2 */ |
| 603 | |
| 604 | case 0x23: /* background color 2 */ |
| 514 | 605 | if (vic2.reg[offset] != data) |
| 515 | 606 | { |
| 516 | 607 | vic2.reg[offset] = data; |
| 517 | 608 | vic2.multi[2] = vic2.colors[2] = MULTICOLOR2; |
| 518 | 609 | } |
| 519 | 610 | break; |
| 520 | | case 0x24: /* background color 3 */ |
| 611 | |
| 612 | case 0x24: /* background color 3 */ |
| 521 | 613 | if (vic2.reg[offset] != data) |
| 522 | 614 | { |
| 523 | 615 | vic2.reg[offset] = data; |
| 524 | 616 | vic2.colors[3] = FOREGROUNDCOLOR; |
| 525 | 617 | } |
| 526 | 618 | break; |
| 527 | | case 0x20: /* framecolor */ |
| 619 | |
| 620 | case 0x20: /* framecolor */ |
| 528 | 621 | if (vic2.reg[offset] != data) |
| 529 | 622 | { |
| 530 | 623 | vic2.reg[offset] = data; |
| 531 | 624 | } |
| 532 | 625 | break; |
| 626 | |
| 533 | 627 | case 0x2f: |
| 534 | 628 | if (vic2.vic2e) |
| 535 | 629 | { |
| r5507 | r5508 | |
| 537 | 631 | vic2.reg[offset] = data; |
| 538 | 632 | } |
| 539 | 633 | break; |
| 634 | |
| 540 | 635 | case 0x30: |
| 541 | 636 | if (vic2.vic2e) |
| 542 | 637 | { |
| 543 | 638 | vic2.reg[offset] = data; |
| 544 | 639 | } |
| 545 | 640 | break; |
| 641 | |
| 546 | 642 | case 0x31: |
| 547 | 643 | case 0x32: |
| 548 | 644 | case 0x33: |
| r5507 | r5508 | |
| 561 | 657 | vic2.reg[offset] = data; |
| 562 | 658 | DBG_LOG (2, "vic write", ("%.2x:%.2x\n", offset, data)); |
| 563 | 659 | break; |
| 660 | |
| 564 | 661 | default: |
| 565 | 662 | vic2.reg[offset] = data; |
| 566 | 663 | break; |
| 567 | 664 | } |
| 568 | | |
| 569 | | cycles = (int)(cpu_get_total_cycles(space->cpu) - vic2.rasterline_start_cpu_cycles); |
| 570 | | |
| 571 | | realx = VIC2_FIRST_X + cycles * 8 * (VIC2_CYCLESPERLINE / vic2.totalcycles); |
| 572 | | if (realx > VIC2_MAX_X) realx -= VIC2_MAX_X; |
| 573 | | |
| 574 | | // sprites chenges are active only from the next raster line |
| 575 | | |
| 576 | | if (vic2.on) |
| 577 | | if ((vic2.rasterline >= VIC2_FIRSTRASTERLINE) && (vic2.rasterline < VIC2_FIRSTRASTERLINE + VIC2_VISIBLELINES)) |
| 578 | | { |
| 579 | | if ((realx >= 0) && (realx <= (VIC2_LAST_VISIBLE_X - VIC2_FIRST_VISIBLE_X))) |
| 580 | | { |
| 581 | | vic2_drawlines (machine, vic2.rasterline, vic2.rasterline + 1, realx, VIC2_LAST_VISIBLE_X - VIC2_FIRST_VISIBLE_X); |
| 582 | | } |
| 583 | | } |
| 584 | | |
| 585 | 665 | } |
| 586 | 666 | |
| 587 | 667 | READ8_HANDLER ( vic2_port_r ) |
| r5507 | r5508 | |
| 589 | 669 | running_machine *machine = space->machine; |
| 590 | 670 | int val = 0; |
| 591 | 671 | offset &= 0x3f; |
| 672 | |
| 592 | 673 | switch (offset) |
| 593 | 674 | { |
| 594 | 675 | case 0x11: |
| 595 | 676 | val = (vic2.reg[offset] & ~0x80) | ((vic2.rasterline & 0x100) >> 1); |
| 596 | 677 | break; |
| 678 | |
| 597 | 679 | case 0x12: |
| 598 | 680 | val = vic2.rasterline & 0xff; |
| 599 | 681 | break; |
| 682 | |
| 600 | 683 | case 0x16: |
| 601 | 684 | val = vic2.reg[offset] | 0xc0; |
| 602 | 685 | break; |
| 686 | |
| 603 | 687 | case 0x18: |
| 604 | | val = vic2.reg[offset] | 1; |
| 688 | val = vic2.reg[offset] | 0x01; |
| 605 | 689 | break; |
| 606 | | case 0x19: /* interrupt flag register */ |
| 607 | | /* vic2_clear_interrupt(0xf); */ |
| 690 | |
| 691 | case 0x19: /* interrupt flag register */ |
| 692 | /* vic2_clear_interrupt(0xf); */ |
| 608 | 693 | val = vic2.reg[offset] | 0x70; |
| 609 | 694 | break; |
| 695 | |
| 610 | 696 | case 0x1a: |
| 611 | 697 | val = vic2.reg[offset] | 0xf0; |
| 612 | 698 | break; |
| 613 | | case 0x1e: /* sprite to sprite collision detect */ |
| 699 | |
| 700 | case 0x1e: /* sprite to sprite collision detect */ |
| 614 | 701 | val = vic2.reg[offset]; |
| 615 | 702 | vic2.reg[offset] = 0; |
| 616 | 703 | vic2_clear_interrupt(space->machine, 4); |
| 617 | 704 | break; |
| 618 | | case 0x1f: /* sprite to background collision detect */ |
| 705 | |
| 706 | case 0x1f: /* sprite to background collision detect */ |
| 619 | 707 | val = vic2.reg[offset]; |
| 620 | 708 | vic2.reg[offset] = 0; |
| 621 | 709 | vic2_clear_interrupt(space->machine, 2); |
| 622 | 710 | break; |
| 711 | |
| 623 | 712 | case 0x20: |
| 624 | 713 | case 0x21: |
| 625 | 714 | case 0x22: |
| r5507 | r5508 | |
| 627 | 716 | case 0x24: |
| 628 | 717 | val = vic2.reg[offset]; |
| 629 | 718 | break; |
| 719 | |
| 630 | 720 | case 0x00: |
| 631 | 721 | case 0x01: |
| 632 | 722 | case 0x02: |
| r5507 | r5508 | |
| 658 | 748 | case 0x2c: |
| 659 | 749 | case 0x2d: |
| 660 | 750 | case 0x2e: |
| 661 | | val = vic2.reg_buffer[offset]; |
| 751 | val = vic2.reg[offset]; |
| 662 | 752 | break; |
| 753 | |
| 663 | 754 | case 0x2f: |
| 664 | 755 | case 0x30: |
| 665 | | if (vic2.vic2e) { |
| 756 | if (vic2.vic2e) |
| 757 | { |
| 666 | 758 | val = vic2.reg[offset]; |
| 667 | 759 | DBG_LOG (2, "vic read", ("%.2x:%.2x\n", offset, val)); |
| 668 | | } else |
| 760 | } |
| 761 | else |
| 669 | 762 | val = 0xff; |
| 670 | 763 | break; |
| 764 | |
| 671 | 765 | case 0x31: |
| 672 | 766 | case 0x32: |
| 673 | 767 | case 0x33: |
| r5507 | r5508 | |
| 682 | 776 | case 0x3c: |
| 683 | 777 | case 0x3d: |
| 684 | 778 | case 0x3e: |
| 685 | | case 0x3f: /* not used */ |
| 779 | case 0x3f: /* not used */ |
| 686 | 780 | // val = vic2.reg[offset]; // |
| 687 | 781 | val = 0xff; |
| 688 | 782 | DBG_LOG (2, "vic read", ("%.2x:%.2x\n", offset, val)); |
| 689 | 783 | break; |
| 784 | |
| 690 | 785 | default: |
| 691 | 786 | val = vic2.reg[offset]; |
| 692 | 787 | } |
| 788 | |
| 693 | 789 | if ((offset != 0x11) && (offset != 0x12)) |
| 694 | 790 | DBG_LOG (2, "vic read", ("%.2x:%.2x\n", offset, val)); |
| 695 | 791 | return val; |
| r5507 | r5508 | |
| 782 | 878 | } |
| 783 | 879 | |
| 784 | 880 | // from 0 to 311 (0 first, PAL) or from 0 to 261 (? first, NTSC 6567R56A) or from 0 to 262 (? first, NTSC 6567R8) |
| 785 | | vic2.rasterline = 0; |
| 881 | vic2.rasterline = 0; // VIC2_LINES - 1; |
| 786 | 882 | |
| 787 | 883 | // from 1 to 63 (PAL) or from 1 to 65 (NTSC) |
| 788 | | vic2.rasterX = 1; |
| 884 | vic2.rasterX = 63; |
| 789 | 885 | |
| 790 | 886 | // immediately call the timer to handle the first line |
| 791 | | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 0), NULL, 0, rz_timer_callback); |
| 887 | if (vic2.pal) |
| 888 | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 0), NULL, 0, PAL_timer_callback); |
| 889 | else |
| 890 | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 0), NULL, 0, NTSC_timer_callback); |
| 792 | 891 | } |
| 793 | 892 | |
| 794 | 893 | static void vic2_draw_character (running_machine *machine, int ybegin, int yend, int ch, int yoff, int xoff, UINT16 *color, int start_x, int end_x) |
| r5507 | r5508 | |
| 1399 | 1498 | } |
| 1400 | 1499 | |
| 1401 | 1500 | #include "vic4567.c" |
| 1402 | | static int is_bad_line = 0; |
| 1403 | 1501 | |
| 1404 | | TIMER_CALLBACK( rz_timer_callback ) |
| 1502 | TIMER_CALLBACK( line_timer_callback ) |
| 1405 | 1503 | { |
| 1406 | 1504 | int i,j; |
| 1407 | 1505 | |
| r5507 | r5508 | |
| 1409 | 1507 | { |
| 1410 | 1508 | |
| 1411 | 1509 | case 1: |
| 1412 | | is_bad_line = ((vic2.rasterline >= 0x30) && (vic2.rasterline <= 0xf7) && ((vic2.rasterline & 0x07) == VERTICALPOS) && SCREENON); |
| 1413 | | |
| 1414 | | vic2.rasterline_start_cpu_cycles = cpu_get_total_cycles(machine->cpu[0]); |
| 1415 | | |
| 1416 | | // update sprites registers |
| 1417 | | for (i=0x00; i <= 0x10; i++) |
| 1418 | | vic2.reg[i] = vic2.reg_buffer[i]; |
| 1419 | | vic2.reg[0x17] = vic2.reg_buffer[0x17]; |
| 1420 | | for (i=0x1b; i <= 0x1d; i++) |
| 1421 | | vic2.reg[i] = vic2.reg_buffer[i]; |
| 1422 | | for (i=0x25; i <= 0x2e; i++) |
| 1423 | | vic2.reg[i] = vic2.reg_buffer[i]; |
| 1424 | | for (i=0; i < 8; i++) |
| 1425 | | { |
| 1426 | | vic2.sprites[i].x = vic2.sprites_buffer[i].x; |
| 1427 | | vic2.sprites[i].y = vic2.sprites_buffer[i].y; |
| 1428 | | } |
| 1429 | | for (i=0; i < 4; i++) |
| 1430 | | vic2.spritemulti[i] = vic2.spritemulti_buffer[i]; |
| 1431 | | |
| 1432 | 1510 | if (vic2.rasterline == vic2.lines) |
| 1433 | 1511 | { |
| 1434 | 1512 | vic2.rasterline = 0; |
| r5507 | r5508 | |
| 1447 | 1525 | } |
| 1448 | 1526 | } |
| 1449 | 1527 | |
| 1450 | | if (vic2.rasterline == C64_2_RASTERLINE(RASTERLINE)) |
| 1528 | if (vic2.rasterline == RASTERLINE) |
| 1451 | 1529 | { |
| 1452 | 1530 | vic2_set_interrupt(machine, 1); |
| 1453 | 1531 | } |
| r5507 | r5508 | |
| 1455 | 1533 | vic2.rasterX++; |
| 1456 | 1534 | break; |
| 1457 | 1535 | |
| 1458 | | case 15: |
| 1536 | case 60: |
| 1459 | 1537 | vic2.rasterX++; |
| 1460 | | if (is_bad_line) cpu_suspend(machine->cpu[0], SUSPEND_REASON_SPIN, 0); |
| 1461 | 1538 | |
| 1462 | 1539 | if (!c64_pal) |
| 1463 | 1540 | if (vic2.rasterline < VIC2_FIRSTRASTERLINE + VIC2_VISIBLELINES - vic2.lines) |
| r5507 | r5508 | |
| 1469 | 1546 | |
| 1470 | 1547 | break; |
| 1471 | 1548 | |
| 1472 | | case 55: |
| 1549 | case 63: |
| 1550 | vic2.rasterline++; |
| 1551 | vic2.rasterX = 1; |
| 1552 | |
| 1553 | break; |
| 1554 | |
| 1555 | default: |
| 1473 | 1556 | vic2.rasterX++; |
| 1557 | |
| 1558 | break; |
| 1559 | } |
| 1474 | 1560 | |
| 1475 | | if (is_bad_line) cpu_resume(machine->cpu[0], SUSPEND_REASON_SPIN); |
| 1561 | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 1), NULL, 0, line_timer_callback); |
| 1562 | } |
| 1476 | 1563 | |
| 1564 | // modified VIC II emulation by Christian Bauer starts here... |
| 1565 | |
| 1566 | // Idle access |
| 1567 | #define IdleAccess \ |
| 1568 | vic2.dma_read(machine, 0x3fff) |
| 1569 | |
| 1570 | // Fetch sprite data pointer |
| 1571 | #define SprPtrAccess(num) \ |
| 1572 | spr_ptr[num] = vic2.dma_read(machine, SPRITE_ADDR(num)) << 6 |
| 1573 | |
| 1574 | // Fetch sprite data, increment data counter |
| 1575 | #define SprDataAccess(num, bytenum) \ |
| 1576 | if (spr_dma_on & (1 << num)) \ |
| 1577 | { \ |
| 1578 | spr_data[num][bytenum] = vic2.dma_read(machine, (mc[num] & 0x3f) | spr_ptr[num]); \ |
| 1579 | mc[num]++; \ |
| 1580 | } \ |
| 1581 | else \ |
| 1582 | if (bytenum == 1) \ |
| 1583 | IdleAccess; |
| 1584 | |
| 1585 | // Turn on display if Bad Line |
| 1586 | #define DisplayIfBadLine \ |
| 1587 | if (is_bad_line) \ |
| 1588 | display_state = 1; |
| 1589 | |
| 1590 | // Suspend CPU |
| 1591 | #define SuspendCPU \ |
| 1592 | { \ |
| 1593 | if (cpu_suspended == 0) \ |
| 1594 | { \ |
| 1595 | first_ba_cycle = vic2.cycles_counter; \ |
| 1596 | cpu_suspend(machine->cpu[0], SUSPEND_REASON_SPIN, 0); \ |
| 1597 | cpu_suspended = 1; \ |
| 1598 | } \ |
| 1599 | } |
| 1600 | |
| 1601 | // Resume CPU |
| 1602 | #define ResumeCPU \ |
| 1603 | { \ |
| 1604 | if (cpu_suspended == 1) \ |
| 1605 | { \ |
| 1606 | cpu_resume(machine->cpu[0], SUSPEND_REASON_SPIN); \ |
| 1607 | cpu_suspended = 0; \ |
| 1608 | } \ |
| 1609 | } |
| 1610 | |
| 1611 | |
| 1612 | // Refresh access |
| 1613 | #define RefreshAccess \ |
| 1614 | { \ |
| 1615 | vic2.dma_read(machine, 0x3f00 | ref_cnt--); \ |
| 1616 | } |
| 1617 | |
| 1618 | #define FetchIfBadLine \ |
| 1619 | if (is_bad_line) \ |
| 1620 | { \ |
| 1621 | display_state = 1; \ |
| 1622 | } |
| 1623 | |
| 1624 | // Turn on display and matrix access and reset RC if Bad Line |
| 1625 | #define RCIfBadLine \ |
| 1626 | if (is_bad_line) \ |
| 1627 | { \ |
| 1628 | display_state = 1; \ |
| 1629 | rc = 0; \ |
| 1630 | } |
| 1631 | |
| 1632 | // Sample border color and increment vic2.graphic_x |
| 1633 | #define SampleBorder \ |
| 1634 | if (draw_this_line) \ |
| 1635 | { \ |
| 1636 | if (border_on) \ |
| 1637 | border_color_sample[vic2.cycle - 13] = FRAMECOLOR; \ |
| 1638 | vic2.graphic_x += 8; \ |
| 1639 | } |
| 1640 | |
| 1641 | // Turn on sprite DMA if necessary |
| 1642 | #define CheckSpriteDMA \ |
| 1643 | mask = 1; \ |
| 1644 | for (i = 0; i < 8; i++, mask <<= 1) \ |
| 1645 | if (SPRITEON(i) && ((vic2.rasterline & 0xff) == SPRITE_Y_POS2(i))) \ |
| 1646 | { \ |
| 1647 | spr_dma_on |= mask; \ |
| 1648 | mc_base[i] = 0; \ |
| 1649 | if (SPRITE_Y_EXPAND(i)) \ |
| 1650 | spr_exp_y &= ~mask; \ |
| 1651 | } |
| 1652 | |
| 1653 | // Video matrix access |
| 1654 | #define MatrixAccess \ |
| 1655 | { \ |
| 1656 | if (cpu_suspended == 1) \ |
| 1657 | { \ |
| 1658 | if ((vic2.cycles_counter - first_ba_cycle) < 0) \ |
| 1659 | matrix_line[ml_index] = color_line[ml_index] = 0xff; \ |
| 1660 | else \ |
| 1661 | { \ |
| 1662 | UINT16 adr = (vc & 0x03ff) | VIDEOADDR; \ |
| 1663 | matrix_line[ml_index] = vic2.dma_read(machine, adr); \ |
| 1664 | color_line[ml_index] = vic2.dma_read_color(machine, (adr & 0x03ff)); \ |
| 1665 | } \ |
| 1666 | } \ |
| 1667 | } |
| 1668 | |
| 1669 | // Graphics data access |
| 1670 | #define GraphicsAccess \ |
| 1671 | { \ |
| 1672 | if (display_state == 1) \ |
| 1673 | { \ |
| 1674 | UINT16 adr; \ |
| 1675 | if (HIRESON) \ |
| 1676 | adr = ((vc & 0x03ff) << 3) | vic2.bitmapaddr | rc; \ |
| 1677 | else \ |
| 1678 | adr = (matrix_line[ml_index] << 3) | vic2.chargenaddr | rc; \ |
| 1679 | if (ECMON) \ |
| 1680 | adr &= 0xf9ff; \ |
| 1681 | gfx_data = vic2.dma_read(machine, adr); \ |
| 1682 | char_data = matrix_line[ml_index]; \ |
| 1683 | color_data = color_line[ml_index]; \ |
| 1684 | ml_index++; \ |
| 1685 | vc++; \ |
| 1686 | } \ |
| 1687 | else \ |
| 1688 | { \ |
| 1689 | gfx_data = vic2.dma_read(machine, (ECMON ? 0x39ff : 0x3fff)); \ |
| 1690 | char_data = 0; \ |
| 1691 | } \ |
| 1692 | } |
| 1693 | |
| 1694 | #define DrawBackground \ |
| 1695 | if (draw_this_line) \ |
| 1696 | { \ |
| 1697 | UINT8 c; \ |
| 1698 | switch (GFXMODE) \ |
| 1699 | { \ |
| 1700 | case 0: \ |
| 1701 | case 1: \ |
| 1702 | case 3: \ |
| 1703 | c = vic2.colors[0]; \ |
| 1704 | break; \ |
| 1705 | case 2: \ |
| 1706 | c = last_char_data & 0x0f; \ |
| 1707 | break; \ |
| 1708 | case 4: \ |
| 1709 | if (last_char_data & 0x80) \ |
| 1710 | if (last_char_data & 0x40) \ |
| 1711 | c = vic2.colors[3]; \ |
| 1712 | else \ |
| 1713 | c = vic2.colors[2]; \ |
| 1714 | else \ |
| 1715 | if (last_char_data & 0x40) \ |
| 1716 | c = vic2.colors[1]; \ |
| 1717 | else \ |
| 1718 | c = vic2.colors[0]; \ |
| 1719 | break; \ |
| 1720 | default: \ |
| 1721 | c = 0; \ |
| 1722 | break; \ |
| 1723 | } \ |
| 1724 | plot_box(vic2.bitmap, vic2.graphic_x, VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, c); \ |
| 1725 | } |
| 1726 | |
| 1727 | #define DrawMono \ |
| 1728 | data = gfx_data; \ |
| 1729 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 7) = c[data & 1]; \ |
| 1730 | fore_coll_buf[p + 7] = data & 1; data >>= 1; \ |
| 1731 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 6) = c[data & 1]; \ |
| 1732 | fore_coll_buf[p + 6] = data & 1; data >>= 1; \ |
| 1733 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 5) = c[data & 1]; \ |
| 1734 | fore_coll_buf[p + 5] = data & 1; data >>= 1; \ |
| 1735 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 4) = c[data & 1]; \ |
| 1736 | fore_coll_buf[p + 4] = data & 1; data >>= 1; \ |
| 1737 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 3) = c[data & 1]; \ |
| 1738 | fore_coll_buf[p + 3] = data & 1; data >>= 1; \ |
| 1739 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 2) = c[data & 1]; \ |
| 1740 | fore_coll_buf[p + 2] = data & 1; data >>= 1; \ |
| 1741 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 1) = c[data & 1]; \ |
| 1742 | fore_coll_buf[p + 1] = data & 1; data >>= 1; \ |
| 1743 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 0) = c[data]; \ |
| 1744 | fore_coll_buf[p + 0] = data & 1; \ |
| 1745 | |
| 1746 | #define DrawMulti \ |
| 1747 | data = gfx_data; \ |
| 1748 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 7) = c[data & 3]; \ |
| 1749 | fore_coll_buf[p + 7] = data & 1; \ |
| 1750 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 6) = c[data & 3]; \ |
| 1751 | fore_coll_buf[p + 6] = data & 1; data >>= 2; \ |
| 1752 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 5) = c[data & 3]; \ |
| 1753 | fore_coll_buf[p + 5] = data & 1; \ |
| 1754 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 4) = c[data & 3]; \ |
| 1755 | fore_coll_buf[p + 4] = data & 1; data >>= 2; \ |
| 1756 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 3) = c[data & 3]; \ |
| 1757 | fore_coll_buf[p + 3] = data & 1; \ |
| 1758 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 2) = c[data & 3]; \ |
| 1759 | fore_coll_buf[p + 2] = data & 1; data >>= 2; \ |
| 1760 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 1) = c[data]; \ |
| 1761 | fore_coll_buf[p + 1] = data & 1; \ |
| 1762 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 0) = c[data]; \ |
| 1763 | fore_coll_buf[p + 0] = data & 1; \ |
| 1764 | |
| 1765 | // Graphics display (8 pixels) |
| 1766 | #define DrawGraphics \ |
| 1767 | if (draw_this_line == 0) \ |
| 1768 | { \ |
| 1769 | ; \ |
| 1770 | } \ |
| 1771 | else if (ud_border_on) \ |
| 1772 | { \ |
| 1773 | DrawBackground; \ |
| 1774 | } \ |
| 1775 | else \ |
| 1776 | { \ |
| 1777 | UINT8 c[4], data; \ |
| 1778 | UINT16 p = vic2.graphic_x + HORIZONTALPOS; \ |
| 1779 | switch (GFXMODE) \ |
| 1780 | { \ |
| 1781 | case 0: \ |
| 1782 | c[0] = vic2.colors[0]; \ |
| 1783 | c[1] = color_data & 0x0f; \ |
| 1784 | DrawMono; \ |
| 1785 | break; \ |
| 1786 | case 1: \ |
| 1787 | if (color_data & 0x08) \ |
| 1788 | { \ |
| 1789 | c[0] = vic2.colors[0]; \ |
| 1790 | c[1] = vic2.colors[1]; \ |
| 1791 | c[2] = vic2.colors[2]; \ |
| 1792 | c[3] = color_data & 0x07; \ |
| 1793 | DrawMulti; \ |
| 1794 | } \ |
| 1795 | else \ |
| 1796 | { \ |
| 1797 | c[0] = vic2.colors[0]; \ |
| 1798 | c[1] = color_data & 0x0f; \ |
| 1799 | DrawMono; \ |
| 1800 | } \ |
| 1801 | break; \ |
| 1802 | case 2: \ |
| 1803 | c[0] = char_data & 0x0f; \ |
| 1804 | c[1] = char_data >> 4; \ |
| 1805 | DrawMono; \ |
| 1806 | break; \ |
| 1807 | case 3: \ |
| 1808 | c[0] = vic2.colors[0]; \ |
| 1809 | c[1] = char_data >> 4; \ |
| 1810 | c[2] = char_data & 0x0f; \ |
| 1811 | c[3] = color_data & 0x0f; \ |
| 1812 | DrawMulti; \ |
| 1813 | break; \ |
| 1814 | case 4: \ |
| 1815 | if (char_data & 0x80) \ |
| 1816 | if (char_data & 0x40) \ |
| 1817 | c[0] = vic2.colors[3]; \ |
| 1818 | else \ |
| 1819 | c[0] = vic2.colors[2]; \ |
| 1820 | else \ |
| 1821 | if (char_data & 0x40) \ |
| 1822 | c[0] = vic2.colors[1]; \ |
| 1823 | else \ |
| 1824 | c[0] = vic2.colors[0]; \ |
| 1825 | c[1] = color_data & 0x0f; \ |
| 1826 | DrawMono; \ |
| 1827 | break; \ |
| 1828 | case 5: \ |
| 1829 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 7) = 0; \ |
| 1830 | fore_coll_buf[p + 7] = 0; \ |
| 1831 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 6) = 0; \ |
| 1832 | fore_coll_buf[p + 6] = 0; \ |
| 1833 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 5) = 0; \ |
| 1834 | fore_coll_buf[p + 5] = 0; \ |
| 1835 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 4) = 0; \ |
| 1836 | fore_coll_buf[p + 4] = 0; \ |
| 1837 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 3) = 0; \ |
| 1838 | fore_coll_buf[p + 3] = 0; \ |
| 1839 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 2) = 0; \ |
| 1840 | fore_coll_buf[p + 2] = 0; \ |
| 1841 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 1) = 0; \ |
| 1842 | fore_coll_buf[p + 1] = 0; \ |
| 1843 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 0) = 0; \ |
| 1844 | fore_coll_buf[p + 0] = 0; \ |
| 1845 | break; \ |
| 1846 | case 6: \ |
| 1847 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 7) = 0; \ |
| 1848 | fore_coll_buf[p + 7] = 0; \ |
| 1849 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 6) = 0; \ |
| 1850 | fore_coll_buf[p + 6] = 0; \ |
| 1851 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 5) = 0; \ |
| 1852 | fore_coll_buf[p + 5] = 0; \ |
| 1853 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 4) = 0; \ |
| 1854 | fore_coll_buf[p + 4] = 0; \ |
| 1855 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 3) = 0; \ |
| 1856 | fore_coll_buf[p + 3] = 0; \ |
| 1857 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 2) = 0; \ |
| 1858 | fore_coll_buf[p + 2] = 0; \ |
| 1859 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 1) = 0; \ |
| 1860 | fore_coll_buf[p + 1] = 0; \ |
| 1861 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 0) = 0; \ |
| 1862 | fore_coll_buf[p + 0] = 0; \ |
| 1863 | break; \ |
| 1864 | case 7: \ |
| 1865 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 7) = 0; \ |
| 1866 | fore_coll_buf[p + 7] = 0; \ |
| 1867 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 6) = 0; \ |
| 1868 | fore_coll_buf[p + 6] = 0; \ |
| 1869 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 5) = 0; \ |
| 1870 | fore_coll_buf[p + 5] = 0; \ |
| 1871 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 4) = 0; \ |
| 1872 | fore_coll_buf[p + 4] = 0; \ |
| 1873 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 3) = 0; \ |
| 1874 | fore_coll_buf[p + 3] = 0; \ |
| 1875 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 2) = 0; \ |
| 1876 | fore_coll_buf[p + 2] = 0; \ |
| 1877 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 1) = 0; \ |
| 1878 | fore_coll_buf[p + 1] = 0; \ |
| 1879 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + 0) = 0; \ |
| 1880 | fore_coll_buf[p + 0] = 0; \ |
| 1881 | break; \ |
| 1882 | } \ |
| 1883 | } |
| 1884 | |
| 1885 | #define DrawSprites \ |
| 1886 | { \ |
| 1887 | int i; \ |
| 1888 | UINT8 snum, sbit; \ |
| 1889 | UINT8 spr_coll = 0, gfx_coll = 0; \ |
| 1890 | UINT32 plane0_l, plane0_r, plane1_l, plane1_r; \ |
| 1891 | UINT32 sdata_l = 0, sdata_r = 0; \ |
| 1892 | for (i = 0; i < 0x400; i++) \ |
| 1893 | spr_coll_buf[i] = 0; \ |
| 1894 | for (snum = 0, sbit = 1; snum < 8; snum++, sbit <<= 1) \ |
| 1895 | { \ |
| 1896 | if ((spr_draw & sbit) && (SPRITE_X_POS2(snum) <= (403 - (VIC2_FIRSTCOLUMN + 1)))) \ |
| 1897 | { \ |
| 1898 | UINT16 p = SPRITE_X_POS2(snum) + VIC2_X_2_EMU(0) + 8; \ |
| 1899 | UINT8 color = SPRITE_COLOR(snum); \ |
| 1900 | UINT32 sdata = (spr_draw_data[snum][0] << 24) | \ |
| 1901 | (spr_draw_data[snum][1] << 16) | \ |
| 1902 | (spr_draw_data[snum][2] << 8); \ |
| 1903 | if (SPRITE_X_EXPAND(snum)) \ |
| 1904 | { \ |
| 1905 | if (SPRITE_X_POS2(snum) > (403 - 24 - (VIC2_FIRSTCOLUMN + 1))) \ |
| 1906 | continue; \ |
| 1907 | if (SPRITE_MULTICOLOR(snum)) \ |
| 1908 | { \ |
| 1909 | sdata_l = (vic2.expandx_multi[(sdata >> 24) & 0xff] << 16) | vic2.expandx_multi[(sdata >> 16) & 0xff]; \ |
| 1910 | sdata_r = vic2.expandx_multi[(sdata >> 8) & 0xff] << 16; \ |
| 1911 | plane0_l = (sdata_l & 0x55555555) | (sdata_l & 0x55555555) << 1; \ |
| 1912 | plane1_l = (sdata_l & 0xaaaaaaaa) | (sdata_l & 0xaaaaaaaa) >> 1; \ |
| 1913 | plane0_r = (sdata_r & 0x55555555) | (sdata_r & 0x55555555) << 1; \ |
| 1914 | plane1_r = (sdata_r & 0xaaaaaaaa) | (sdata_r & 0xaaaaaaaa) >> 1; \ |
| 1915 | for (i = 0; i < 32; i++, plane0_l <<= 1, plane1_l <<= 1) \ |
| 1916 | { \ |
| 1917 | UINT8 col; \ |
| 1918 | if (plane1_l & 0x80000000) \ |
| 1919 | { \ |
| 1920 | if (fore_coll_buf[p + i]) \ |
| 1921 | { \ |
| 1922 | gfx_coll |= sbit; \ |
| 1923 | } \ |
| 1924 | if (plane0_l & 0x80000000) \ |
| 1925 | col = vic2.spritemulti[3]; \ |
| 1926 | else \ |
| 1927 | col = color; \ |
| 1928 | } \ |
| 1929 | else \ |
| 1930 | { \ |
| 1931 | if (plane0_l & 0x80000000) \ |
| 1932 | { \ |
| 1933 | if (fore_coll_buf[p + i]) \ |
| 1934 | { \ |
| 1935 | gfx_coll |= sbit; \ |
| 1936 | } \ |
| 1937 | col = vic2.spritemulti[1]; \ |
| 1938 | } \ |
| 1939 | else \ |
| 1940 | continue; \ |
| 1941 | } \ |
| 1942 | if (spr_coll_buf[p + i]) \ |
| 1943 | spr_coll |= spr_coll_buf[p + i] | sbit; \ |
| 1944 | else \ |
| 1945 | { \ |
| 1946 | if (SPRITE_PRIORITY(snum)) \ |
| 1947 | { \ |
| 1948 | if (fore_coll_buf[p + i] == 0) \ |
| 1949 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = col; \ |
| 1950 | spr_coll_buf[p + i] = sbit; \ |
| 1951 | } \ |
| 1952 | else \ |
| 1953 | { \ |
| 1954 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = col; \ |
| 1955 | spr_coll_buf[p + i] = sbit; \ |
| 1956 | } \ |
| 1957 | } \ |
| 1958 | } \ |
| 1959 | for (; i < 48; i++, plane0_r <<= 1, plane1_r <<= 1) \ |
| 1960 | { \ |
| 1961 | UINT8 col; \ |
| 1962 | if(plane1_r & 0x80000000) \ |
| 1963 | { \ |
| 1964 | if (fore_coll_buf[p + i]) \ |
| 1965 | { \ |
| 1966 | gfx_coll |= sbit; \ |
| 1967 | } \ |
| 1968 | if (plane0_r & 0x80000000) \ |
| 1969 | col = vic2.spritemulti[3]; \ |
| 1970 | else \ |
| 1971 | col = color; \ |
| 1972 | } \ |
| 1973 | else \ |
| 1974 | { \ |
| 1975 | if (plane0_r & 0x80000000) \ |
| 1976 | { \ |
| 1977 | if (fore_coll_buf[p + i]) \ |
| 1978 | { \ |
| 1979 | gfx_coll |= sbit; \ |
| 1980 | } \ |
| 1981 | col = vic2.spritemulti[1]; \ |
| 1982 | } \ |
| 1983 | else \ |
| 1984 | continue; \ |
| 1985 | } \ |
| 1986 | if (spr_coll_buf[p + i]) \ |
| 1987 | spr_coll |= spr_coll_buf[p + i] | sbit; \ |
| 1988 | else \ |
| 1989 | { \ |
| 1990 | if (SPRITE_PRIORITY(snum)) \ |
| 1991 | { \ |
| 1992 | if (fore_coll_buf[p + i] == 0) \ |
| 1993 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = col; \ |
| 1994 | spr_coll_buf[p + i] = sbit; \ |
| 1995 | } \ |
| 1996 | else \ |
| 1997 | { \ |
| 1998 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = col; \ |
| 1999 | spr_coll_buf[p + i] = sbit; \ |
| 2000 | } \ |
| 2001 | } \ |
| 2002 | } \ |
| 2003 | } \ |
| 2004 | else \ |
| 2005 | { \ |
| 2006 | sdata_l = (vic2.expandx[(sdata >> 24) & 0xff] << 16) | vic2.expandx[(sdata >> 16) & 0xff]; \ |
| 2007 | sdata_r = vic2.expandx[(sdata >> 8) & 0xff] << 16; \ |
| 2008 | for (i = 0; i < 32; i++, sdata_l <<= 1) \ |
| 2009 | if (sdata_l & 0x80000000) \ |
| 2010 | { \ |
| 2011 | if (fore_coll_buf[p + i]) \ |
| 2012 | { \ |
| 2013 | gfx_coll |= sbit; \ |
| 2014 | } \ |
| 2015 | if(spr_coll_buf[p + i]) \ |
| 2016 | spr_coll |= spr_coll_buf[p + i] | sbit; \ |
| 2017 | else \ |
| 2018 | { \ |
| 2019 | if (SPRITE_PRIORITY(snum)) \ |
| 2020 | { \ |
| 2021 | if (fore_coll_buf[p + i] == 0) \ |
| 2022 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = color; \ |
| 2023 | spr_coll_buf[p + i] = sbit; \ |
| 2024 | } \ |
| 2025 | else \ |
| 2026 | { \ |
| 2027 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = color; \ |
| 2028 | spr_coll_buf[p + i] = sbit; \ |
| 2029 | } \ |
| 2030 | } \ |
| 2031 | } \ |
| 2032 | for (; i < 48; i++, sdata_r <<= 1) \ |
| 2033 | if (sdata_r & 0x80000000) \ |
| 2034 | { \ |
| 2035 | if (fore_coll_buf[p + i]) \ |
| 2036 | { \ |
| 2037 | gfx_coll |= sbit; \ |
| 2038 | } \ |
| 2039 | if(spr_coll_buf[p + i]) \ |
| 2040 | spr_coll |= spr_coll_buf[p + i] | sbit; \ |
| 2041 | else \ |
| 2042 | { \ |
| 2043 | if (SPRITE_PRIORITY(snum)) \ |
| 2044 | { \ |
| 2045 | if (fore_coll_buf[p + i] == 0) \ |
| 2046 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = color; \ |
| 2047 | spr_coll_buf[p + i] = sbit; \ |
| 2048 | } \ |
| 2049 | else \ |
| 2050 | { \ |
| 2051 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = color; \ |
| 2052 | spr_coll_buf[p + i] = sbit; \ |
| 2053 | } \ |
| 2054 | } \ |
| 2055 | } \ |
| 2056 | } \ |
| 2057 | } \ |
| 2058 | else \ |
| 2059 | { \ |
| 2060 | if (SPRITE_MULTICOLOR(snum)) \ |
| 2061 | { \ |
| 2062 | UINT32 plane0, plane1; \ |
| 2063 | plane0 = (sdata & 0x55555555) | (sdata & 0x55555555) << 1; \ |
| 2064 | plane1 = (sdata & 0xaaaaaaaa) | (sdata & 0xaaaaaaaa) >> 1; \ |
| 2065 | for (i = 0; i < 24; i++, plane0 <<= 1, plane1 <<= 1) \ |
| 2066 | { \ |
| 2067 | UINT8 col; \ |
| 2068 | if (plane1 & 0x80000000) \ |
| 2069 | { \ |
| 2070 | if (fore_coll_buf[p + i]) \ |
| 2071 | { \ |
| 2072 | gfx_coll |= sbit; \ |
| 2073 | } \ |
| 2074 | if (plane0 & 0x80000000) \ |
| 2075 | col = vic2.spritemulti[3]; \ |
| 2076 | else \ |
| 2077 | col = color; \ |
| 2078 | } \ |
| 2079 | else \ |
| 2080 | { \ |
| 2081 | if (fore_coll_buf[p + i]) \ |
| 2082 | { \ |
| 2083 | gfx_coll |= sbit; \ |
| 2084 | } \ |
| 2085 | if (plane0 & 0x80000000) \ |
| 2086 | col = vic2.spritemulti[1]; \ |
| 2087 | else \ |
| 2088 | continue; \ |
| 2089 | } \ |
| 2090 | if (spr_coll_buf[p + i]) \ |
| 2091 | spr_coll |= spr_coll_buf[p + i] | sbit; \ |
| 2092 | else \ |
| 2093 | { \ |
| 2094 | if (SPRITE_PRIORITY(snum)) \ |
| 2095 | { \ |
| 2096 | if (fore_coll_buf[p + i] == 0) \ |
| 2097 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = col; \ |
| 2098 | spr_coll_buf[p + i] = sbit; \ |
| 2099 | } \ |
| 2100 | else \ |
| 2101 | { \ |
| 2102 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = col; \ |
| 2103 | spr_coll_buf[p + i] = sbit; \ |
| 2104 | } \ |
| 2105 | } \ |
| 2106 | } \ |
| 2107 | } \ |
| 2108 | else \ |
| 2109 | { \ |
| 2110 | for (i = 0; i < 24; i++, sdata <<= 1) \ |
| 2111 | { \ |
| 2112 | if (sdata & 0x80000000) \ |
| 2113 | { \ |
| 2114 | if (fore_coll_buf[p + i]) \ |
| 2115 | { \ |
| 2116 | gfx_coll |= sbit; \ |
| 2117 | } \ |
| 2118 | if (spr_coll_buf[p + i]) \ |
| 2119 | { \ |
| 2120 | spr_coll |= spr_coll_buf[p + i] | sbit; \ |
| 2121 | } \ |
| 2122 | else \ |
| 2123 | { \ |
| 2124 | if (SPRITE_PRIORITY(snum)) \ |
| 2125 | { \ |
| 2126 | if (fore_coll_buf[p + i] == 0) \ |
| 2127 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = color; \ |
| 2128 | spr_coll_buf[p + i] = sbit; \ |
| 2129 | } \ |
| 2130 | else \ |
| 2131 | { \ |
| 2132 | *BITMAP_ADDR16(vic2.bitmap, VIC2_RASTER_2_EMU(vic2.rasterline), p + i) = color; \ |
| 2133 | spr_coll_buf[p + i] = sbit; \ |
| 2134 | } \ |
| 2135 | } \ |
| 2136 | } \ |
| 2137 | } \ |
| 2138 | } \ |
| 2139 | } \ |
| 2140 | } \ |
| 2141 | } \ |
| 2142 | if (SPRITE_COLL) \ |
| 2143 | SPRITE_COLL |= spr_coll; \ |
| 2144 | else \ |
| 2145 | { \ |
| 2146 | SPRITE_COLL |= spr_coll; \ |
| 2147 | vic2_set_interrupt(machine, 4); \ |
| 2148 | } \ |
| 2149 | if (SPRITE_BG_COLL) \ |
| 2150 | SPRITE_BG_COLL |= gfx_coll; \ |
| 2151 | else \ |
| 2152 | { \ |
| 2153 | SPRITE_BG_COLL |= gfx_coll; \ |
| 2154 | vic2_set_interrupt(machine, 2); \ |
| 2155 | } \ |
| 2156 | } |
| 2157 | |
| 2158 | TIMER_CALLBACK( PAL_timer_callback ) |
| 2159 | { |
| 2160 | int i; |
| 2161 | UINT8 mask; |
| 2162 | vic2.cycles_counter++; |
| 2163 | |
| 2164 | switch(vic2.cycle) |
| 2165 | { |
| 2166 | |
| 2167 | // Sprite 3, raster counter, raster IRQ, bad line |
| 2168 | case 1: |
| 2169 | if (vic2.rasterline == (VIC2_LINES - 1)) |
| 2170 | { |
| 2171 | vblanking = 1; |
| 2172 | |
| 2173 | if (LIGHTPEN_BUTTON) |
| 2174 | { |
| 2175 | /* lightpen timer starten */ |
| 2176 | timer_set (machine, attotime_make(0, 0), NULL, 1, vic2_timer_timeout); |
| 2177 | } |
| 2178 | } |
| 2179 | else |
| 2180 | { |
| 2181 | vic2.rasterline++; |
| 2182 | |
| 2183 | if (vic2.rasterline == RASTERLINE) |
| 2184 | { |
| 2185 | vic2_set_interrupt(machine, 1); |
| 2186 | } |
| 2187 | |
| 2188 | if (vic2.rasterline == VIC2_FIRST_DMA_LINE) |
| 2189 | bad_lines_enabled = SCREENON; |
| 2190 | |
| 2191 | is_bad_line = ((vic2.rasterline >= VIC2_FIRST_DMA_LINE) && |
| 2192 | (vic2.rasterline <= VIC2_LAST_DMA_LINE) && |
| 2193 | ((vic2.rasterline & 0x07) == VERTICALPOS) && |
| 2194 | bad_lines_enabled); |
| 2195 | |
| 2196 | draw_this_line = ((VIC2_RASTER_2_EMU(vic2.rasterline) >= VIC2_RASTER_2_EMU(VIC2_FIRST_DISP_LINE)) && |
| 2197 | (VIC2_RASTER_2_EMU(vic2.rasterline ) <= VIC2_RASTER_2_EMU(VIC2_LAST_DISP_LINE))); |
| 2198 | } |
| 2199 | |
| 2200 | border_on_sample[0] = border_on; |
| 2201 | SprPtrAccess(3); |
| 2202 | SprDataAccess(3, 0); |
| 2203 | DisplayIfBadLine; |
| 2204 | |
| 2205 | if(spr_dma_on & 0x08) |
| 2206 | SuspendCPU |
| 2207 | else |
| 2208 | ResumeCPU |
| 2209 | |
| 2210 | vic2.cycle++; |
| 1477 | 2211 | break; |
| 1478 | 2212 | |
| 2213 | // Sprite 3 |
| 2214 | case 2: |
| 2215 | if (vblanking) |
| 2216 | { |
| 2217 | // Vertical blank, reset counters |
| 2218 | vic2.rasterline = vc_base = 0; |
| 2219 | ref_cnt = 0xff; |
| 2220 | vblanking = 0; |
| 1479 | 2221 | |
| 2222 | // Trigger raster IRQ if IRQ in line 0 |
| 2223 | if (RASTERLINE == 0) |
| 2224 | { |
| 2225 | vic2_set_interrupt(machine, 1); |
| 2226 | } |
| 2227 | } |
| 2228 | |
| 2229 | vic2.graphic_x = VIC2_X_2_EMU(0); |
| 2230 | |
| 2231 | SprDataAccess(3, 1); |
| 2232 | SprDataAccess(3, 2); |
| 2233 | DisplayIfBadLine; |
| 2234 | |
| 2235 | vic2.cycle++; |
| 2236 | break; |
| 2237 | |
| 2238 | // Sprite 4 |
| 2239 | case 3: |
| 2240 | SprPtrAccess(4); |
| 2241 | SprDataAccess(4, 0); |
| 2242 | DisplayIfBadLine; |
| 2243 | |
| 2244 | if(spr_dma_on & 0x10) |
| 2245 | SuspendCPU |
| 2246 | else |
| 2247 | ResumeCPU |
| 2248 | |
| 2249 | vic2.cycle++; |
| 2250 | break; |
| 2251 | |
| 2252 | // Sprite 4 |
| 2253 | case 4: |
| 2254 | SprDataAccess(4, 1); |
| 2255 | SprDataAccess(4, 2); |
| 2256 | DisplayIfBadLine; |
| 2257 | |
| 2258 | vic2.cycle++; |
| 2259 | break; |
| 2260 | |
| 2261 | // Sprite 5 |
| 2262 | case 5: |
| 2263 | SprPtrAccess(5); |
| 2264 | SprDataAccess(5, 0); |
| 2265 | DisplayIfBadLine; |
| 2266 | |
| 2267 | if(spr_dma_on & 0x20) |
| 2268 | SuspendCPU |
| 2269 | else |
| 2270 | ResumeCPU |
| 2271 | |
| 2272 | vic2.cycle++; |
| 2273 | break; |
| 2274 | |
| 2275 | // Sprite 5 |
| 2276 | case 6: |
| 2277 | SprDataAccess(5, 1); |
| 2278 | SprDataAccess(5, 2); |
| 2279 | DisplayIfBadLine; |
| 2280 | |
| 2281 | vic2.cycle++; |
| 2282 | break; |
| 2283 | |
| 2284 | // Sprite 6 |
| 2285 | case 7: |
| 2286 | SprPtrAccess(6); |
| 2287 | SprDataAccess(6, 0); |
| 2288 | DisplayIfBadLine; |
| 2289 | |
| 2290 | if(spr_dma_on & 0x40) |
| 2291 | SuspendCPU |
| 2292 | else |
| 2293 | ResumeCPU |
| 2294 | |
| 2295 | vic2.cycle++; |
| 2296 | break; |
| 2297 | |
| 2298 | // Sprite 6 |
| 2299 | case 8: |
| 2300 | SprDataAccess(6, 1); |
| 2301 | SprDataAccess(6, 2); |
| 2302 | DisplayIfBadLine; |
| 2303 | |
| 2304 | vic2.cycle++; |
| 2305 | break; |
| 2306 | |
| 2307 | // Sprite 7 |
| 2308 | case 9: |
| 2309 | SprPtrAccess(7); |
| 2310 | SprDataAccess(7, 0); |
| 2311 | DisplayIfBadLine; |
| 2312 | |
| 2313 | if(spr_dma_on & 0x80) |
| 2314 | SuspendCPU |
| 2315 | else |
| 2316 | ResumeCPU |
| 2317 | |
| 2318 | vic2.cycle++; |
| 2319 | break; |
| 2320 | |
| 2321 | // Sprite 7 |
| 2322 | case 10: |
| 2323 | SprDataAccess(7, 1); |
| 2324 | SprDataAccess(7, 2); |
| 2325 | DisplayIfBadLine; |
| 2326 | |
| 2327 | vic2.cycle++; |
| 2328 | break; |
| 2329 | |
| 2330 | // Refresh |
| 2331 | case 11: |
| 2332 | RefreshAccess; |
| 2333 | DisplayIfBadLine; |
| 2334 | |
| 2335 | ResumeCPU |
| 2336 | |
| 2337 | vic2.cycle++; |
| 2338 | break; |
| 2339 | |
| 2340 | // Refresh, fetch if bad line |
| 2341 | case 12: |
| 2342 | RefreshAccess; |
| 2343 | FetchIfBadLine; |
| 2344 | |
| 2345 | vic2.cycle++; |
| 2346 | break; |
| 2347 | |
| 2348 | // Refresh, fetch if bad line, raster_x |
| 2349 | case 13: |
| 2350 | DrawBackground; |
| 2351 | SampleBorder; |
| 2352 | RefreshAccess; |
| 2353 | FetchIfBadLine; |
| 2354 | |
| 2355 | vic2.raster_x = 0xfffc; |
| 2356 | |
| 2357 | vic2.cycle++; |
| 2358 | break; |
| 2359 | |
| 2360 | // Refresh, fetch if bad line, RC, VC |
| 2361 | case 14: |
| 2362 | DrawBackground; |
| 2363 | SampleBorder; |
| 2364 | RefreshAccess; |
| 2365 | RCIfBadLine; |
| 2366 | |
| 2367 | vc = vc_base; |
| 2368 | |
| 2369 | vic2.cycle++; |
| 2370 | break; |
| 2371 | |
| 2372 | // Refresh, fetch if bad line, sprite y expansion |
| 2373 | case 15: |
| 2374 | DrawBackground; |
| 2375 | SampleBorder; |
| 2376 | RefreshAccess; |
| 2377 | FetchIfBadLine; |
| 2378 | |
| 2379 | for (i = 0; i < 8; i++) |
| 2380 | if (spr_exp_y & (1 << i)) |
| 2381 | mc_base[i] += 2; |
| 2382 | |
| 2383 | if (is_bad_line) |
| 2384 | SuspendCPU |
| 2385 | |
| 2386 | ml_index = 0; |
| 2387 | MatrixAccess; |
| 2388 | |
| 2389 | vic2.cycle++; |
| 2390 | break; |
| 2391 | |
| 2392 | // Graphics, sprite y expansion, sprite DMA |
| 2393 | case 16: |
| 2394 | DrawBackground; |
| 2395 | SampleBorder; |
| 2396 | GraphicsAccess; |
| 2397 | FetchIfBadLine; |
| 2398 | |
| 2399 | mask = 1; |
| 2400 | for (i = 0; i < 8; i++, mask <<= 1) |
| 2401 | { |
| 2402 | if (spr_exp_y & mask) |
| 2403 | mc_base[i]++; |
| 2404 | if ((mc_base[i] & 0x3f) == 0x3f) |
| 2405 | spr_dma_on &= ~mask; |
| 2406 | } |
| 2407 | |
| 2408 | MatrixAccess; |
| 2409 | |
| 2410 | vic2.cycle++; |
| 2411 | break; |
| 2412 | |
| 2413 | // Graphics, check border |
| 2414 | case 17: |
| 2415 | if (COLUMNS40) |
| 2416 | { |
| 2417 | if (vic2.rasterline == dy_stop) |
| 2418 | ud_border_on = 1; |
| 2419 | else |
| 2420 | { |
| 2421 | if (SCREENON) |
| 2422 | { |
| 2423 | if (vic2.rasterline == dy_start) |
| 2424 | border_on = ud_border_on = 0; |
| 2425 | else |
| 2426 | if (ud_border_on == 0) |
| 2427 | border_on = 0; |
| 2428 | } else |
| 2429 | if (ud_border_on == 0) |
| 2430 | border_on = 0; |
| 2431 | } |
| 2432 | } |
| 2433 | |
| 2434 | // Second sample of border state |
| 2435 | border_on_sample[1] = border_on; |
| 2436 | |
| 2437 | DrawBackground; |
| 2438 | DrawGraphics; |
| 2439 | SampleBorder; |
| 2440 | GraphicsAccess; |
| 2441 | FetchIfBadLine; |
| 2442 | MatrixAccess; |
| 2443 | |
| 2444 | vic2.cycle++; |
| 2445 | break; |
| 2446 | |
| 2447 | // Check border |
| 2448 | case 18: |
| 2449 | if (!COLUMNS40) |
| 2450 | { |
| 2451 | if (vic2.rasterline == dy_stop) |
| 2452 | ud_border_on = 1; |
| 2453 | else |
| 2454 | { |
| 2455 | if (SCREENON) |
| 2456 | { |
| 2457 | if (vic2.rasterline == dy_start) |
| 2458 | border_on = ud_border_on = 0; |
| 2459 | else |
| 2460 | if (ud_border_on == 0) |
| 2461 | border_on = 0; |
| 2462 | } else |
| 2463 | if (ud_border_on == 0) |
| 2464 | border_on = 0; |
| 2465 | } |
| 2466 | } |
| 2467 | |
| 2468 | // Third sample of border state |
| 2469 | border_on_sample[2] = border_on; |
| 2470 | |
| 2471 | // Graphics |
| 2472 | |
| 2473 | case 19: |
| 2474 | case 20: |
| 2475 | case 21: |
| 2476 | case 22: |
| 2477 | case 23: |
| 2478 | case 24: |
| 2479 | case 25: |
| 2480 | case 26: |
| 2481 | case 27: |
| 2482 | case 28: |
| 2483 | case 29: |
| 2484 | case 30: |
| 2485 | case 31: |
| 2486 | case 32: |
| 2487 | case 33: |
| 2488 | case 34: |
| 2489 | case 35: |
| 2490 | case 36: |
| 2491 | case 37: |
| 2492 | case 38: |
| 2493 | case 39: |
| 2494 | case 40: |
| 2495 | case 41: |
| 2496 | case 42: |
| 2497 | case 43: |
| 2498 | case 44: |
| 2499 | case 45: |
| 2500 | case 46: |
| 2501 | case 47: |
| 2502 | case 48: |
| 2503 | case 49: |
| 2504 | case 50: |
| 2505 | case 51: |
| 2506 | case 52: |
| 2507 | case 53: |
| 2508 | case 54: |
| 2509 | DrawGraphics; |
| 2510 | SampleBorder; |
| 2511 | GraphicsAccess; |
| 2512 | FetchIfBadLine; |
| 2513 | MatrixAccess; |
| 2514 | last_char_data = char_data; |
| 2515 | |
| 2516 | vic2.cycle++; |
| 2517 | break; |
| 2518 | |
| 2519 | // Graphics, sprite y expansion, sprite DMA |
| 2520 | case 55: |
| 2521 | DrawGraphics; |
| 2522 | SampleBorder; |
| 2523 | GraphicsAccess; |
| 2524 | DisplayIfBadLine; |
| 2525 | |
| 2526 | // sprite y expansion |
| 2527 | mask = 1; |
| 2528 | for (i = 0; i < 8; i++, mask <<= 1) |
| 2529 | if (SPRITE_Y_EXPAND (i)) |
| 2530 | spr_exp_y ^= mask; |
| 2531 | |
| 2532 | CheckSpriteDMA; |
| 2533 | |
| 2534 | ResumeCPU |
| 2535 | |
| 2536 | vic2.cycle++; |
| 2537 | break; |
| 2538 | |
| 2539 | // Check border, sprite DMA |
| 2540 | case 56: |
| 2541 | if (!COLUMNS40) |
| 2542 | border_on = 1; |
| 2543 | |
| 2544 | // Fourth sample of border state |
| 2545 | border_on_sample[3] = border_on; |
| 2546 | |
| 2547 | DrawGraphics; |
| 2548 | SampleBorder; |
| 2549 | IdleAccess; |
| 2550 | DisplayIfBadLine; |
| 2551 | CheckSpriteDMA; |
| 2552 | |
| 2553 | vic2.cycle++; |
| 2554 | break; |
| 2555 | |
| 2556 | // Check border, sprites |
| 2557 | case 57: |
| 2558 | if (COLUMNS40) |
| 2559 | border_on = 1; |
| 2560 | |
| 2561 | // Fifth sample of border state |
| 2562 | border_on_sample[4] = border_on; |
| 2563 | |
| 2564 | // Sample spr_disp_on and spr_data for sprite drawing |
| 2565 | spr_draw = spr_disp_on; |
| 2566 | if (spr_draw) |
| 2567 | memcpy(spr_draw_data, spr_data, 8 * 4); |
| 2568 | |
| 2569 | mask = 1; |
| 2570 | for (i = 0; i < 8; i++, mask <<= 1) |
| 2571 | if ((spr_disp_on & mask) && !(spr_dma_on & mask)) |
| 2572 | spr_disp_on &= ~mask; |
| 2573 | |
| 2574 | DrawBackground; |
| 2575 | SampleBorder; |
| 2576 | IdleAccess; |
| 2577 | DisplayIfBadLine; |
| 2578 | |
| 2579 | vic2.cycle++; |
| 2580 | break; |
| 2581 | |
| 2582 | // Sprite 0, sprite DMA, MC, RC |
| 2583 | case 58: |
| 2584 | DrawBackground; |
| 2585 | SampleBorder; |
| 2586 | |
| 2587 | mask = 1; |
| 2588 | for (i = 0; i < 8; i++, mask <<= 1) |
| 2589 | { |
| 2590 | mc[i] = mc_base[i]; |
| 2591 | if ((spr_dma_on & mask) && ((vic2.rasterline & 0xff) == SPRITE_Y_POS2(i))) |
| 2592 | spr_disp_on |= mask; |
| 2593 | } |
| 2594 | |
| 2595 | SprPtrAccess(0); |
| 2596 | SprDataAccess(0, 0); |
| 2597 | |
| 2598 | if (rc == 7) |
| 2599 | { |
| 2600 | vc_base = vc; |
| 2601 | display_state = 0; |
| 2602 | } |
| 2603 | |
| 2604 | if (is_bad_line || display_state) |
| 2605 | { |
| 2606 | display_state = 1; |
| 2607 | rc = (rc + 1) & 7; |
| 2608 | } |
| 2609 | |
| 2610 | if(spr_dma_on & 0x01) |
| 2611 | SuspendCPU |
| 2612 | else |
| 2613 | ResumeCPU |
| 2614 | |
| 2615 | vic2.cycle++; |
| 2616 | break; |
| 2617 | |
| 2618 | // Sprite 0 |
| 2619 | case 59: |
| 2620 | DrawBackground; |
| 2621 | SampleBorder; |
| 2622 | SprDataAccess(0, 1); |
| 2623 | SprDataAccess(0, 2); |
| 2624 | DisplayIfBadLine; |
| 2625 | |
| 2626 | vic2.cycle++; |
| 2627 | break; |
| 2628 | |
| 2629 | // Sprite 1, draw |
| 2630 | case 60: |
| 2631 | DrawBackground; |
| 2632 | SampleBorder; |
| 2633 | |
| 2634 | if (draw_this_line) |
| 2635 | { |
| 2636 | DrawSprites; |
| 2637 | |
| 2638 | if (border_on_sample[0]) |
| 2639 | for (i = 0; i < 4; i++) |
| 2640 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[i]); |
| 2641 | |
| 2642 | if (border_on_sample[1]) |
| 2643 | plot_box(vic2.bitmap, VIC2_X_2_EMU(4 * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[4]); |
| 2644 | |
| 2645 | if (border_on_sample[2]) |
| 2646 | for (i = 5; i < 43; i++) |
| 2647 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[i]); |
| 2648 | |
| 2649 | if (border_on_sample[3]) |
| 2650 | plot_box(vic2.bitmap, VIC2_X_2_EMU(43 * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[43]); |
| 2651 | |
| 2652 | if (border_on_sample[4]) |
| 2653 | { |
| 2654 | for (i = 44; i < 48; i++) |
| 2655 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[i]); |
| 2656 | for (i = 48; i < 51; i++) |
| 2657 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[47]); |
| 2658 | } |
| 2659 | } |
| 2660 | |
| 2661 | SprPtrAccess(1); |
| 2662 | SprDataAccess(1, 0); |
| 2663 | DisplayIfBadLine; |
| 2664 | |
| 2665 | if(spr_dma_on & 0x02) |
| 2666 | SuspendCPU |
| 2667 | else |
| 2668 | ResumeCPU |
| 2669 | |
| 2670 | vic2.cycle++; |
| 2671 | break; |
| 2672 | |
| 2673 | // Sprite 1 |
| 2674 | case 61: |
| 2675 | SprDataAccess(1, 1); |
| 2676 | SprDataAccess(1, 2); |
| 2677 | DisplayIfBadLine; |
| 2678 | |
| 2679 | vic2.cycle++; |
| 2680 | break; |
| 2681 | |
| 2682 | // Sprite 2 |
| 2683 | case 62: |
| 2684 | SprPtrAccess(2); |
| 2685 | SprDataAccess(2, 0); |
| 2686 | DisplayIfBadLine; |
| 2687 | |
| 2688 | if(spr_dma_on & 0x04) |
| 2689 | SuspendCPU |
| 2690 | else |
| 2691 | ResumeCPU |
| 2692 | |
| 2693 | vic2.cycle++; |
| 2694 | break; |
| 2695 | |
| 2696 | // Sprite 2 |
| 1480 | 2697 | case 63: |
| 1481 | | vic2.rasterline++; |
| 1482 | | vic2.rasterX = 1; |
| 2698 | SprDataAccess(2, 1); |
| 2699 | SprDataAccess(2, 2); |
| 2700 | DisplayIfBadLine; |
| 1483 | 2701 | |
| 2702 | if (vic2.rasterline == dy_stop) |
| 2703 | ud_border_on = 1; |
| 2704 | else |
| 2705 | if (SCREENON && (vic2.rasterline == dy_start)) |
| 2706 | ud_border_on = 0; |
| 2707 | |
| 2708 | // Last cycle |
| 2709 | vic2.cycle = 1; |
| 2710 | } |
| 2711 | |
| 2712 | vic2.raster_x += 8; |
| 2713 | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 1), NULL, 0, PAL_timer_callback); |
| 2714 | } |
| 2715 | |
| 2716 | TIMER_CALLBACK( NTSC_timer_callback ) |
| 2717 | { |
| 2718 | int i; |
| 2719 | UINT8 mask; |
| 2720 | vic2.cycles_counter++; |
| 2721 | |
| 2722 | switch(vic2.cycle) |
| 2723 | { |
| 2724 | |
| 2725 | // Sprite 3, raster counter, raster IRQ, bad line |
| 2726 | case 1: |
| 2727 | if (vic2.rasterline == (VIC2_LINES - 1)) |
| 2728 | { |
| 2729 | vblanking = 1; |
| 2730 | |
| 2731 | if (LIGHTPEN_BUTTON) |
| 2732 | { |
| 2733 | /* lightpen timer starten */ |
| 2734 | timer_set (machine, attotime_make(0, 0), NULL, 1, vic2_timer_timeout); |
| 2735 | } |
| 2736 | } |
| 2737 | else |
| 2738 | { |
| 2739 | vic2.rasterline++; |
| 2740 | |
| 2741 | if (vic2.rasterline == RASTERLINE) |
| 2742 | { |
| 2743 | vic2_set_interrupt(machine, 1); |
| 2744 | } |
| 2745 | |
| 2746 | if (vic2.rasterline == VIC2_FIRST_DMA_LINE) |
| 2747 | bad_lines_enabled = SCREENON; |
| 2748 | |
| 2749 | is_bad_line = ((vic2.rasterline >= VIC2_FIRST_DMA_LINE) && |
| 2750 | (vic2.rasterline <= VIC2_LAST_DMA_LINE) && |
| 2751 | ((vic2.rasterline & 0x07) == VERTICALPOS) && |
| 2752 | bad_lines_enabled); |
| 2753 | |
| 2754 | draw_this_line = ((VIC2_RASTER_2_EMU(vic2.rasterline) >= VIC2_RASTER_2_EMU(VIC2_FIRST_DISP_LINE)) && |
| 2755 | (VIC2_RASTER_2_EMU(vic2.rasterline ) <= VIC2_RASTER_2_EMU(VIC2_LAST_DISP_LINE))); |
| 2756 | } |
| 2757 | |
| 2758 | border_on_sample[0] = border_on; |
| 2759 | SprPtrAccess(3); |
| 2760 | SprDataAccess(3, 0); |
| 2761 | DisplayIfBadLine; |
| 2762 | |
| 2763 | if(spr_dma_on & 0x08) |
| 2764 | SuspendCPU |
| 2765 | else |
| 2766 | ResumeCPU |
| 2767 | |
| 2768 | vic2.cycle++; |
| 1484 | 2769 | break; |
| 1485 | 2770 | |
| 1486 | | default: |
| 1487 | | vic2.rasterX++; |
| 1488 | | |
| 2771 | // Sprite 3 |
| 2772 | case 2: |
| 2773 | if (vblanking) |
| 2774 | { |
| 2775 | // Vertical blank, reset counters |
| 2776 | vic2.rasterline = vc_base = 0; |
| 2777 | ref_cnt = 0xff; |
| 2778 | vblanking = 0; |
| 2779 | |
| 2780 | // Trigger raster IRQ if IRQ in line 0 |
| 2781 | if (RASTERLINE == 0) |
| 2782 | { |
| 2783 | vic2_set_interrupt(machine, 1); |
| 2784 | } |
| 2785 | } |
| 2786 | |
| 2787 | vic2.graphic_x = VIC2_X_2_EMU(0); |
| 2788 | |
| 2789 | SprDataAccess(3, 1); |
| 2790 | SprDataAccess(3, 2); |
| 2791 | DisplayIfBadLine; |
| 2792 | |
| 2793 | vic2.cycle++; |
| 1489 | 2794 | break; |
| 2795 | |
| 2796 | // Sprite 4 |
| 2797 | case 3: |
| 2798 | SprPtrAccess(4); |
| 2799 | SprDataAccess(4, 0); |
| 2800 | DisplayIfBadLine; |
| 2801 | |
| 2802 | if(spr_dma_on & 0x10) |
| 2803 | SuspendCPU |
| 2804 | else |
| 2805 | ResumeCPU |
| 2806 | |
| 2807 | vic2.cycle++; |
| 2808 | break; |
| 2809 | |
| 2810 | // Sprite 4 |
| 2811 | case 4: |
| 2812 | SprDataAccess(4, 1); |
| 2813 | SprDataAccess(4, 2); |
| 2814 | DisplayIfBadLine; |
| 2815 | |
| 2816 | vic2.cycle++; |
| 2817 | break; |
| 2818 | |
| 2819 | // Sprite 5 |
| 2820 | case 5: |
| 2821 | SprPtrAccess(5); |
| 2822 | SprDataAccess(5, 0); |
| 2823 | DisplayIfBadLine; |
| 2824 | |
| 2825 | if(spr_dma_on & 0x20) |
| 2826 | SuspendCPU |
| 2827 | else |
| 2828 | ResumeCPU |
| 2829 | |
| 2830 | vic2.cycle++; |
| 2831 | break; |
| 2832 | |
| 2833 | // Sprite 5 |
| 2834 | case 6: |
| 2835 | SprDataAccess(5, 1); |
| 2836 | SprDataAccess(5, 2); |
| 2837 | DisplayIfBadLine; |
| 2838 | |
| 2839 | vic2.cycle++; |
| 2840 | break; |
| 2841 | |
| 2842 | // Sprite 6 |
| 2843 | case 7: |
| 2844 | SprPtrAccess(6); |
| 2845 | SprDataAccess(6, 0); |
| 2846 | DisplayIfBadLine; |
| 2847 | |
| 2848 | if(spr_dma_on & 0x40) |
| 2849 | SuspendCPU |
| 2850 | else |
| 2851 | ResumeCPU |
| 2852 | |
| 2853 | vic2.cycle++; |
| 2854 | break; |
| 2855 | |
| 2856 | // Sprite 6 |
| 2857 | case 8: |
| 2858 | SprDataAccess(6, 1); |
| 2859 | SprDataAccess(6, 2); |
| 2860 | DisplayIfBadLine; |
| 2861 | |
| 2862 | vic2.cycle++; |
| 2863 | break; |
| 2864 | |
| 2865 | // Sprite 7 |
| 2866 | case 9: |
| 2867 | SprPtrAccess(7); |
| 2868 | SprDataAccess(7, 0); |
| 2869 | DisplayIfBadLine; |
| 2870 | |
| 2871 | if(spr_dma_on & 0x80) |
| 2872 | SuspendCPU |
| 2873 | else |
| 2874 | ResumeCPU |
| 2875 | |
| 2876 | vic2.cycle++; |
| 2877 | break; |
| 2878 | |
| 2879 | // Sprite 7 |
| 2880 | case 10: |
| 2881 | SprDataAccess(7, 1); |
| 2882 | SprDataAccess(7, 2); |
| 2883 | DisplayIfBadLine; |
| 2884 | |
| 2885 | vic2.cycle++; |
| 2886 | break; |
| 2887 | |
| 2888 | // Refresh |
| 2889 | case 11: |
| 2890 | RefreshAccess; |
| 2891 | DisplayIfBadLine; |
| 2892 | |
| 2893 | ResumeCPU |
| 2894 | |
| 2895 | vic2.cycle++; |
| 2896 | break; |
| 2897 | |
| 2898 | // Refresh, fetch if bad line |
| 2899 | case 12: |
| 2900 | RefreshAccess; |
| 2901 | FetchIfBadLine; |
| 2902 | |
| 2903 | vic2.cycle++; |
| 2904 | break; |
| 2905 | |
| 2906 | // Refresh, fetch if bad line, raster_x |
| 2907 | case 13: |
| 2908 | DrawBackground; |
| 2909 | SampleBorder; |
| 2910 | RefreshAccess; |
| 2911 | FetchIfBadLine; |
| 2912 | |
| 2913 | vic2.raster_x = 0xfffc; |
| 2914 | |
| 2915 | vic2.cycle++; |
| 2916 | break; |
| 2917 | |
| 2918 | // Refresh, fetch if bad line, RC, VC |
| 2919 | case 14: |
| 2920 | DrawBackground; |
| 2921 | SampleBorder; |
| 2922 | RefreshAccess; |
| 2923 | RCIfBadLine; |
| 2924 | |
| 2925 | vc = vc_base; |
| 2926 | |
| 2927 | vic2.cycle++; |
| 2928 | break; |
| 2929 | |
| 2930 | // Refresh, fetch if bad line, sprite y expansion |
| 2931 | case 15: |
| 2932 | DrawBackground; |
| 2933 | SampleBorder; |
| 2934 | RefreshAccess; |
| 2935 | FetchIfBadLine; |
| 2936 | |
| 2937 | for (i = 0; i < 8; i++) |
| 2938 | if (spr_exp_y & (1 << i)) |
| 2939 | mc_base[i] += 2; |
| 2940 | |
| 2941 | if (is_bad_line) |
| 2942 | SuspendCPU |
| 2943 | |
| 2944 | ml_index = 0; |
| 2945 | MatrixAccess; |
| 2946 | |
| 2947 | vic2.cycle++; |
| 2948 | break; |
| 2949 | |
| 2950 | // Graphics, sprite y expansion, sprite DMA |
| 2951 | case 16: |
| 2952 | DrawBackground; |
| 2953 | SampleBorder; |
| 2954 | GraphicsAccess; |
| 2955 | FetchIfBadLine; |
| 2956 | |
| 2957 | mask = 1; |
| 2958 | for (i = 0; i < 8; i++, mask <<= 1) |
| 2959 | { |
| 2960 | if (spr_exp_y & mask) |
| 2961 | mc_base[i]++; |
| 2962 | if ((mc_base[i] & 0x3f) == 0x3f) |
| 2963 | spr_dma_on &= ~mask; |
| 2964 | } |
| 2965 | |
| 2966 | MatrixAccess; |
| 2967 | |
| 2968 | vic2.cycle++; |
| 2969 | break; |
| 2970 | |
| 2971 | // Graphics, check border |
| 2972 | case 17: |
| 2973 | if (COLUMNS40) |
| 2974 | { |
| 2975 | if (vic2.rasterline == dy_stop) |
| 2976 | ud_border_on = 1; |
| 2977 | else |
| 2978 | { |
| 2979 | if (SCREENON) |
| 2980 | { |
| 2981 | if (vic2.rasterline == dy_start) |
| 2982 | border_on = ud_border_on = 0; |
| 2983 | else |
| 2984 | if (ud_border_on == 0) |
| 2985 | border_on = 0; |
| 2986 | } else |
| 2987 | if (ud_border_on == 0) |
| 2988 | border_on = 0; |
| 2989 | } |
| 2990 | } |
| 2991 | |
| 2992 | // Second sample of border state |
| 2993 | border_on_sample[1] = border_on; |
| 2994 | |
| 2995 | DrawBackground; |
| 2996 | DrawGraphics; |
| 2997 | SampleBorder; |
| 2998 | GraphicsAccess; |
| 2999 | FetchIfBadLine; |
| 3000 | MatrixAccess; |
| 3001 | |
| 3002 | vic2.cycle++; |
| 3003 | break; |
| 3004 | |
| 3005 | // Check border |
| 3006 | case 18: |
| 3007 | if (!COLUMNS40) |
| 3008 | { |
| 3009 | if (vic2.rasterline == dy_stop) |
| 3010 | ud_border_on = 1; |
| 3011 | else |
| 3012 | { |
| 3013 | if (SCREENON) |
| 3014 | { |
| 3015 | if (vic2.rasterline == dy_start) |
| 3016 | border_on = ud_border_on = 0; |
| 3017 | else |
| 3018 | if (ud_border_on == 0) |
| 3019 | border_on = 0; |
| 3020 | } else |
| 3021 | if (ud_border_on == 0) |
| 3022 | border_on = 0; |
| 3023 | } |
| 3024 | } |
| 3025 | |
| 3026 | // Third sample of border state |
| 3027 | border_on_sample[2] = border_on; |
| 3028 | |
| 3029 | // Graphics |
| 3030 | |
| 3031 | case 19: |
| 3032 | case 20: |
| 3033 | case 21: |
| 3034 | case 22: |
| 3035 | case 23: |
| 3036 | case 24: |
| 3037 | case 25: |
| 3038 | case 26: |
| 3039 | case 27: |
| 3040 | case 28: |
| 3041 | case 29: |
| 3042 | case 30: |
| 3043 | case 31: |
| 3044 | case 32: |
| 3045 | case 33: |
| 3046 | case 34: |
| 3047 | case 35: |
| 3048 | case 36: |
| 3049 | case 37: |
| 3050 | case 38: |
| 3051 | case 39: |
| 3052 | case 40: |
| 3053 | case 41: |
| 3054 | case 42: |
| 3055 | case 43: |
| 3056 | case 44: |
| 3057 | case 45: |
| 3058 | case 46: |
| 3059 | case 47: |
| 3060 | case 48: |
| 3061 | case 49: |
| 3062 | case 50: |
| 3063 | case 51: |
| 3064 | case 52: |
| 3065 | case 53: |
| 3066 | case 54: |
| 3067 | DrawGraphics; |
| 3068 | SampleBorder; |
| 3069 | GraphicsAccess; |
| 3070 | FetchIfBadLine; |
| 3071 | MatrixAccess; |
| 3072 | last_char_data = char_data; |
| 3073 | |
| 3074 | vic2.cycle++; |
| 3075 | break; |
| 3076 | |
| 3077 | // Graphics, sprite y expansion, sprite DMA |
| 3078 | case 55: |
| 3079 | DrawGraphics; |
| 3080 | SampleBorder; |
| 3081 | GraphicsAccess; |
| 3082 | DisplayIfBadLine; |
| 3083 | |
| 3084 | // sprite y expansion |
| 3085 | mask = 1; |
| 3086 | for (i = 0; i < 8; i++, mask <<= 1) |
| 3087 | if (SPRITE_Y_EXPAND (i)) |
| 3088 | spr_exp_y ^= mask; |
| 3089 | |
| 3090 | CheckSpriteDMA; |
| 3091 | |
| 3092 | ResumeCPU |
| 3093 | |
| 3094 | vic2.cycle++; |
| 3095 | break; |
| 3096 | |
| 3097 | // Check border, sprite DMA |
| 3098 | case 56: |
| 3099 | if (!COLUMNS40) |
| 3100 | border_on = 1; |
| 3101 | |
| 3102 | // Fourth sample of border state |
| 3103 | border_on_sample[3] = border_on; |
| 3104 | |
| 3105 | DrawGraphics; |
| 3106 | SampleBorder; |
| 3107 | IdleAccess; |
| 3108 | DisplayIfBadLine; |
| 3109 | CheckSpriteDMA; |
| 3110 | |
| 3111 | vic2.cycle++; |
| 3112 | break; |
| 3113 | |
| 3114 | // Check border, sprites |
| 3115 | case 57: |
| 3116 | if (COLUMNS40) |
| 3117 | border_on = 1; |
| 3118 | |
| 3119 | // Fifth sample of border state |
| 3120 | border_on_sample[4] = border_on; |
| 3121 | |
| 3122 | // Sample spr_disp_on and spr_data for sprite drawing |
| 3123 | spr_draw = spr_disp_on; |
| 3124 | if (spr_draw) |
| 3125 | memcpy(spr_draw_data, spr_data, 8 * 4); |
| 3126 | |
| 3127 | mask = 1; |
| 3128 | for (i = 0; i < 8; i++, mask <<= 1) |
| 3129 | if ((spr_disp_on & mask) && !(spr_dma_on & mask)) |
| 3130 | spr_disp_on &= ~mask; |
| 3131 | |
| 3132 | DrawBackground; |
| 3133 | SampleBorder; |
| 3134 | IdleAccess; |
| 3135 | DisplayIfBadLine; |
| 3136 | |
| 3137 | vic2.cycle++; |
| 3138 | break; |
| 3139 | |
| 3140 | // for NTSC 6567R8 |
| 3141 | case 58: |
| 3142 | DrawBackground; |
| 3143 | SampleBorder; |
| 3144 | IdleAccess; |
| 3145 | DisplayIfBadLine; |
| 3146 | |
| 3147 | vic2.cycle++; |
| 3148 | break; |
| 3149 | |
| 3150 | // for NTSC 6567R8 |
| 3151 | case 59: |
| 3152 | DrawBackground; |
| 3153 | SampleBorder; |
| 3154 | IdleAccess; |
| 3155 | DisplayIfBadLine; |
| 3156 | |
| 3157 | vic2.cycle++; |
| 3158 | break; |
| 3159 | |
| 3160 | // Sprite 0, sprite DMA, MC, RC |
| 3161 | case 60: |
| 3162 | DrawBackground; |
| 3163 | SampleBorder; |
| 3164 | |
| 3165 | mask = 1; |
| 3166 | for (i = 0; i < 8; i++, mask <<= 1) |
| 3167 | { |
| 3168 | mc[i] = mc_base[i]; |
| 3169 | if ((spr_dma_on & mask) && ((vic2.rasterline & 0xff) == SPRITE_Y_POS2(i))) |
| 3170 | spr_disp_on |= mask; |
| 3171 | } |
| 3172 | |
| 3173 | SprPtrAccess(0); |
| 3174 | SprDataAccess(0, 0); |
| 3175 | |
| 3176 | if (rc == 7) |
| 3177 | { |
| 3178 | vc_base = vc; |
| 3179 | display_state = 0; |
| 3180 | } |
| 3181 | |
| 3182 | if (is_bad_line || display_state) |
| 3183 | { |
| 3184 | display_state = 1; |
| 3185 | rc = (rc + 1) & 7; |
| 3186 | } |
| 3187 | |
| 3188 | if(spr_dma_on & 0x01) |
| 3189 | SuspendCPU |
| 3190 | else |
| 3191 | ResumeCPU |
| 3192 | |
| 3193 | vic2.cycle++; |
| 3194 | break; |
| 3195 | |
| 3196 | // Sprite 0 |
| 3197 | case 61: |
| 3198 | DrawBackground; |
| 3199 | SampleBorder; |
| 3200 | SprDataAccess(0, 1); |
| 3201 | SprDataAccess(0, 2); |
| 3202 | DisplayIfBadLine; |
| 3203 | |
| 3204 | vic2.cycle++; |
| 3205 | break; |
| 3206 | |
| 3207 | // Sprite 1, draw |
| 3208 | case 62: |
| 3209 | DrawBackground; |
| 3210 | SampleBorder; |
| 3211 | |
| 3212 | if (draw_this_line) |
| 3213 | { |
| 3214 | DrawSprites; |
| 3215 | |
| 3216 | if (border_on_sample[0]) |
| 3217 | for (i = 0; i < 4; i++) |
| 3218 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[i]); |
| 3219 | |
| 3220 | if (border_on_sample[1]) |
| 3221 | plot_box(vic2.bitmap, VIC2_X_2_EMU(4 * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[4]); |
| 3222 | |
| 3223 | if (border_on_sample[2]) |
| 3224 | for (i = 5; i < 43; i++) |
| 3225 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[i]); |
| 3226 | |
| 3227 | if (border_on_sample[3]) |
| 3228 | plot_box(vic2.bitmap, VIC2_X_2_EMU(43 * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[43]); |
| 3229 | |
| 3230 | if (border_on_sample[4]) |
| 3231 | { |
| 3232 | for (i = 44; i < 48; i++) |
| 3233 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[i]); |
| 3234 | for (i = 48; i < 53; i++) |
| 3235 | plot_box(vic2.bitmap, VIC2_X_2_EMU(i * 8), VIC2_RASTER_2_EMU(vic2.rasterline), 8, 1, border_color_sample[47]); |
| 3236 | } |
| 3237 | } |
| 3238 | |
| 3239 | SprPtrAccess(1); |
| 3240 | SprDataAccess(1, 0); |
| 3241 | DisplayIfBadLine; |
| 3242 | |
| 3243 | if(spr_dma_on & 0x02) |
| 3244 | SuspendCPU |
| 3245 | else |
| 3246 | ResumeCPU |
| 3247 | |
| 3248 | vic2.cycle++; |
| 3249 | break; |
| 3250 | |
| 3251 | // Sprite 1 |
| 3252 | case 63: |
| 3253 | SprDataAccess(1, 1); |
| 3254 | SprDataAccess(1, 2); |
| 3255 | DisplayIfBadLine; |
| 3256 | |
| 3257 | vic2.cycle++; |
| 3258 | break; |
| 3259 | |
| 3260 | // Sprite 2 |
| 3261 | case 64: |
| 3262 | SprPtrAccess(2); |
| 3263 | SprDataAccess(2, 0); |
| 3264 | DisplayIfBadLine; |
| 3265 | |
| 3266 | if(spr_dma_on & 0x04) |
| 3267 | SuspendCPU |
| 3268 | else |
| 3269 | ResumeCPU |
| 3270 | |
| 3271 | vic2.cycle++; |
| 3272 | break; |
| 3273 | |
| 3274 | // Sprite 2 |
| 3275 | case 65: |
| 3276 | SprDataAccess(2, 1); |
| 3277 | SprDataAccess(2, 2); |
| 3278 | DisplayIfBadLine; |
| 3279 | |
| 3280 | if (vic2.rasterline == dy_stop) |
| 3281 | ud_border_on = 1; |
| 3282 | else |
| 3283 | if (SCREENON && (vic2.rasterline == dy_start)) |
| 3284 | ud_border_on = 0; |
| 3285 | |
| 3286 | // Last cycle |
| 3287 | vic2.cycle = 1; |
| 1490 | 3288 | } |
| 1491 | 3289 | |
| 1492 | | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 1), NULL, 0, rz_timer_callback); |
| 3290 | vic2.raster_x += 8; |
| 3291 | timer_set(machine, cputag_clocks_to_attotime(machine, "maincpu", 1), NULL, 0, NTSC_timer_callback); |
| 1493 | 3292 | } |
| 1494 | 3293 | |
| 1495 | 3294 | VIDEO_UPDATE( vic2 ) |
| 1496 | 3295 | { |
| 1497 | | //vic2.rasterline = 0; |
| 1498 | 3296 | if (vic2.on) |
| 1499 | 3297 | copybitmap(bitmap, vic2.bitmap, 0, 0, 0, 0, cliprect); |
| 1500 | 3298 | return 0; |
| r5507 | r5508 | |
| 1513 | 3311 | MDRV_SCREEN_ADD("screen", RASTER) |
| 1514 | 3312 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 1515 | 3313 | MDRV_SCREEN_SIZE(VIC6567_COLUMNS, VIC6567_LINES) |
| 1516 | | MDRV_SCREEN_VISIBLE_AREA(VIC6567_STARTVISIBLECOLUMNS ,VIC6567_STARTVISIBLECOLUMNS + VIC6567_VISIBLECOLUMNS - 1, VIC6567_STARTVISIBLELINES, VIC6567_STARTVISIBLELINES + VIC6567_VISIBLELINES - 1) |
| 3314 | MDRV_SCREEN_VISIBLE_AREA(0, VIC6567_VISIBLECOLUMNS - 1, 0, VIC6567_VISIBLELINES - 1) |
| 1517 | 3315 | MDRV_PALETTE_INIT( vic2 ) |
| 1518 | 3316 | MDRV_PALETTE_LENGTH(sizeof (vic2_palette) / sizeof (vic2_palette[0]) / 3) |
| 1519 | 3317 | MDRV_VIDEO_START( vic2 ) |
| r5507 | r5508 | |
| 1524 | 3322 | MDRV_SCREEN_ADD("screen", RASTER) |
| 1525 | 3323 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 1526 | 3324 | MDRV_SCREEN_SIZE(VIC6569_COLUMNS, VIC6569_LINES) |
| 1527 | | MDRV_SCREEN_VISIBLE_AREA(VIC6569_STARTVISIBLECOLUMNS, VIC6569_STARTVISIBLECOLUMNS + VIC6569_VISIBLECOLUMNS - 1, VIC6569_STARTVISIBLELINES, VIC6569_STARTVISIBLELINES + VIC6569_VISIBLELINES - 1) |
| 3325 | MDRV_SCREEN_VISIBLE_AREA(0, VIC6569_VISIBLECOLUMNS - 1, 0, VIC6569_VISIBLELINES - 1) |
| 1528 | 3326 | MDRV_PALETTE_INIT( vic2 ) |
| 1529 | 3327 | MDRV_PALETTE_LENGTH(sizeof (vic2_palette) / sizeof (vic2_palette[0]) / 3) |
| 1530 | 3328 | MDRV_VIDEO_START( vic2 ) |
| 1531 | 3329 | MDRV_VIDEO_UPDATE( vic2 ) |
| 1532 | 3330 | MACHINE_DRIVER_END |
| 3331 | |