src/mess/video/smsvdp.c
| r1284 | r1285 | |
| 41 | 41 | #include "includes/sms.h" |
| 42 | 42 | #include "video/generic.h" |
| 43 | 43 | |
| 44 | | #define IS_SMS1_VDP ( features & MODEL_315_5124 ) |
| 45 | | #define IS_SMS2_VDP ( features & MODEL_315_5246 ) |
| 46 | | #define IS_GAMEGEAR_VDP ( features & MODEL_315_5378 ) |
| 44 | #define IS_SMS1_VDP ( smsvdp.features & MODEL_315_5124 ) |
| 45 | #define IS_SMS2_VDP ( smsvdp.features & MODEL_315_5246 ) |
| 46 | #define IS_GAMEGEAR_VDP ( smsvdp.features & MODEL_315_5378 ) |
| 47 | 47 | |
| 48 | | #define STATUS_VINT (0x80) /* Pending vertical interrupt flag */ |
| 48 | #define STATUS_VINT (0x80) /* Pending vertical interrupt flag */ |
| 49 | 49 | #define STATUS_SPROVR (0x40) /* Sprite overflow flag */ |
| 50 | 50 | #define STATUS_SPRCOL (0x20) /* Object collision flag */ |
| 51 | | #define STATUS_HINT (0x02) /* Pending horizontal interrupt flag */ |
| 51 | #define STATUS_HINT (0x02) /* Pending horizontal interrupt flag */ |
| 52 | 52 | |
| 53 | 53 | #define GG_CRAM_SIZE (0x40) /* 32 colors x 2 bytes per color = 64 bytes */ |
| 54 | 54 | #define SMS_CRAM_SIZE (0x20) /* 32 colors x 1 bytes per color = 32 bytes */ |
| 55 | 55 | #define MAX_CRAM_SIZE 0x40 |
| 56 | 56 | |
| 57 | | #define VRAM_SIZE (0x4000) |
| 57 | #define VRAM_SIZE (0x4000) |
| 58 | 58 | |
| 59 | 59 | #define PRIORITY_BIT 0x1000 |
| 60 | | #define BACKDROP_COLOR ( ( vdp_mode == 4 ? 0x10 : 0x00 ) + (reg[0x07] & 0x0F)) |
| 60 | #define BACKDROP_COLOR ( ( smsvdp.vdp_mode == 4 ? 0x10 : 0x00 ) + (smsvdp.reg[0x07] & 0x0F)) |
| 61 | 61 | |
| 62 | 62 | #define NUM_OF_REGISTER (0x10) /* 16 registers */ |
| 63 | 63 | |
| 64 | | #define INIT_VCOUNT |
| 64 | #define INIT_VCOUNT |
| 65 | 65 | #define VERTICAL_BLANKING 1 |
| 66 | 66 | #define TOP_BLANKING 2 |
| 67 | | #define TOP_BORDER 3 |
| 67 | #define TOP_BORDER 3 |
| 68 | 68 | #define ACTIVE_DISPLAY_V 4 |
| 69 | 69 | #define BOTTOM_BORDER 5 |
| 70 | 70 | #define BOTTOM_BLANKING 6 |
| 71 | 71 | |
| 72 | | static UINT8 sms_ntsc_192[7] = { 0xD5, 3, 13, 27, 192, 24, 3 }; |
| 73 | | static UINT8 sms_ntsc_224[7] = { 0xE5, 3, 13, 11, 224, 8, 3 }; |
| 74 | | static UINT8 sms_ntsc_240[7] = { 0xEE, 3, 13, 3, 240, 0, 3 }; |
| 75 | | static UINT8 sms_pal_192[7] = { 0xBA, 3, 13, 54, 192, 48, 3 }; |
| 76 | | static UINT8 sms_pal_224[7] = { 0xCA, 3, 13, 38, 224, 32, 3 }; |
| 77 | | static UINT8 sms_pal_240[7] = { 0xD2, 3, 13, 30, 240, 24, 3 }; |
| 72 | static const UINT8 sms_ntsc_192[7] = { 0xD5, 3, 13, 27, 192, 24, 3 }; |
| 73 | static const UINT8 sms_ntsc_224[7] = { 0xE5, 3, 13, 11, 224, 8, 3 }; |
| 74 | static const UINT8 sms_ntsc_240[7] = { 0xEE, 3, 13, 3, 240, 0, 3 }; |
| 75 | static const UINT8 sms_pal_192[7] = { 0xBA, 3, 13, 54, 192, 48, 3 }; |
| 76 | static const UINT8 sms_pal_224[7] = { 0xCA, 3, 13, 38, 224, 32, 3 }; |
| 77 | static const UINT8 sms_pal_240[7] = { 0xD2, 3, 13, 30, 240, 24, 3 }; |
| 78 | 78 | |
| 79 | | UINT8 *sms_frame_timing; |
| 79 | static struct _smsvdp { |
| 80 | UINT32 features; |
| 81 | UINT8 reg[NUM_OF_REGISTER]; /* All the registers */ |
| 82 | UINT8 status; /* Status register */ |
| 83 | UINT8 reg9copy; /* Internal copy of register 9 */ |
| 84 | UINT8 addrmode; /* Type of VDP action */ |
| 85 | UINT16 addr; /* Contents of internal VDP address register */ |
| 86 | UINT8 cram_mask; /* Mask to switch between SMS and GG CRAM sizes */ |
| 87 | int cram_dirty; /* Have there been any changes to the CRAM area */ |
| 88 | int pending; |
| 89 | UINT8 buffer; |
| 90 | int gg_sms_mode; /* Shrunk SMS screen on GG lcd mode flag */ |
| 91 | int irq_state; /* The status of the IRQ line of the VDP */ |
| 92 | int vdp_mode; /* Current mode of the VDP: 0,1,2,3,4 */ |
| 93 | int y_pixels; /* 192, 224, 240 */ |
| 94 | int line_counter; |
| 95 | UINT8 *VRAM; /* Pointer to VRAM */ |
| 96 | UINT8 *CRAM; /* Pointer to CRAM */ |
| 97 | const UINT8 *sms_frame_timing; |
| 98 | mame_bitmap *prev_bitmap; |
| 99 | int prev_bitmap_saved; |
| 100 | UINT8 *collision_buffer; |
| 80 | 101 | |
| 81 | | UINT8 reg[NUM_OF_REGISTER]; |
| 82 | | UINT8 *VRAM = NULL; |
| 83 | | UINT8 *CRAM = NULL; |
| 84 | | int CRAMMask; |
| 85 | | UINT8 *lineCollisionBuffer; |
| 86 | | UINT8 reg9copy; |
| 102 | /* lineBuffer will be used to hold 5 lines of line data. Line #0 is the regular blitting area. |
| 103 | Lines #1-#4 will be used as a kind of cache to be used for vertical scaling in the gamegear |
| 104 | sms compatibility mode. |
| 105 | */ |
| 106 | int *line_buffer; |
| 107 | int current_palette[32]; |
| 108 | void (*int_callback)(int); |
| 109 | mame_timer *smsvdp_display_timer; |
| 110 | } smsvdp; |
| 87 | 111 | |
| 88 | | int addr; |
| 89 | | int code; |
| 90 | | int pending; |
| 91 | | int latch; |
| 92 | | int buffer; |
| 93 | | int statusReg; |
| 94 | | int ggSmsMode; |
| 95 | | UINT32 features; |
| 96 | | |
| 97 | | int isCRAMDirty; |
| 98 | | |
| 99 | | int lineCountDownCounter; |
| 100 | | int irqState; /* The status of the IRQ line, as seen by the VDP */ |
| 101 | | int y_pixels; /* 192, 224, 240 */ |
| 102 | | int vdp_mode; /* current mode of the VDP: 0,1,2,3,4 */ |
| 103 | | |
| 104 | | mame_bitmap *prevBitMap; |
| 105 | | |
| 106 | | /* lineBuffer will be used to hold 5 lines of line data. Line #0 is the regular blitting area. |
| 107 | | Lines #1-#4 will be used as a kind of cache to be used for vertical scaling in the gamegear |
| 108 | | sms compatibility mode. |
| 109 | | */ |
| 110 | | int *lineBuffer = NULL; |
| 111 | | int currentPalette[32]; |
| 112 | | int prevBitMapSaved; |
| 113 | | void (*int_callback)(int); |
| 114 | | mame_timer *smsvdp_display_timer = NULL; |
| 115 | | |
| 116 | 112 | static TIMER_CALLBACK(smsvdp_display_callback); |
| 117 | | void sms_refresh_line(mame_bitmap *bitmap, int offsetx, int offsety, int line); |
| 118 | | void sms_update_palette(void); |
| 113 | static void sms_refresh_line(mame_bitmap *bitmap, int offsetx, int offsety, int line); |
| 114 | static void sms_update_palette(void); |
| 119 | 115 | |
| 120 | 116 | static void set_display_settings( void ) { |
| 121 | 117 | int M1, M2, M3, M4; |
| 122 | | M1 = reg[0x01] & 0x10; |
| 123 | | M2 = reg[0x00] & 0x02; |
| 124 | | M3 = reg[0x01] & 0x08; |
| 125 | | M4 = reg[0x00] & 0x04; |
| 126 | | y_pixels = 192; |
| 118 | M1 = smsvdp.reg[0x01] & 0x10; |
| 119 | M2 = smsvdp.reg[0x00] & 0x02; |
| 120 | M3 = smsvdp.reg[0x01] & 0x08; |
| 121 | M4 = smsvdp.reg[0x00] & 0x04; |
| 122 | smsvdp.y_pixels = 192; |
| 127 | 123 | if ( M4 ) { |
| 128 | 124 | /* mode 4 */ |
| 129 | | vdp_mode = 4; |
| 125 | smsvdp.vdp_mode = 4; |
| 130 | 126 | if ( M2 && ( IS_SMS2_VDP || IS_GAMEGEAR_VDP ) ) { |
| 131 | 127 | /* Is it 224-line display */ |
| 132 | 128 | if ( M1 && ! M3 ) { |
| 133 | | y_pixels = 224; |
| 129 | smsvdp.y_pixels = 224; |
| 134 | 130 | } else if ( ! M1 && M3 ) { |
| 135 | 131 | /* 240-line display */ |
| 136 | | y_pixels = 240; |
| 132 | smsvdp.y_pixels = 240; |
| 137 | 133 | } |
| 138 | 134 | } |
| 139 | 135 | } else { |
| 140 | 136 | /* original TMS9918 mode */ |
| 141 | 137 | if ( ! M1 && ! M2 && ! M3 ) { |
| 142 | | vdp_mode = 0; |
| 138 | smsvdp.vdp_mode = 0; |
| 143 | 139 | } else |
| 144 | 140 | // if ( M1 && ! M2 && ! M3 ) { |
| 145 | | // vdp_mode = 1; |
| 141 | // smsvdp.vdp_mode = 1; |
| 146 | 142 | // } else |
| 147 | 143 | if ( ! M1 && M2 && ! M3 ) { |
| 148 | | vdp_mode = 2; |
| 144 | smsvdp.vdp_mode = 2; |
| 149 | 145 | // } else |
| 150 | 146 | // if ( ! M1 && ! M2 && M3 ) { |
| 151 | | // vdp_mode = 3; |
| 147 | // smsvdp.vdp_mode = 3; |
| 152 | 148 | } else { |
| 153 | 149 | logerror( "Unknown video mode detected (M1=%c, M2=%c, M3=%c, M4=%c)\n", M1 ? '1' : '0', M2 ? '1' : '0', M3 ? '1' : '0', M4 ? '1' : '0'); |
| 154 | 150 | } |
| 155 | 151 | } |
| 156 | | switch( y_pixels ) { |
| 152 | switch( smsvdp.y_pixels ) { |
| 157 | 153 | case 192: |
| 158 | | sms_frame_timing = ( Machine->screen[0].height == PAL_Y_PIXELS ) ? sms_pal_192 : sms_ntsc_192; |
| 154 | smsvdp.sms_frame_timing = ( Machine->screen[0].height == PAL_Y_PIXELS ) ? sms_pal_192 : sms_ntsc_192; |
| 159 | 155 | break; |
| 160 | 156 | case 224: |
| 161 | | sms_frame_timing = ( Machine->screen[0].height == PAL_Y_PIXELS ) ? sms_pal_224 : sms_ntsc_224; |
| 157 | smsvdp.sms_frame_timing = ( Machine->screen[0].height == PAL_Y_PIXELS ) ? sms_pal_224 : sms_ntsc_224; |
| 162 | 158 | break; |
| 163 | 159 | case 240: |
| 164 | | sms_frame_timing = ( Machine->screen[0].height == PAL_Y_PIXELS ) ? sms_pal_240 : sms_ntsc_240; |
| 160 | smsvdp.sms_frame_timing = ( Machine->screen[0].height == PAL_Y_PIXELS ) ? sms_pal_240 : sms_ntsc_240; |
| 165 | 161 | break; |
| 166 | 162 | } |
| 167 | | isCRAMDirty = 1; |
| 163 | smsvdp.cram_dirty = 1; |
| 168 | 164 | } |
| 169 | 165 | |
| 170 | 166 | READ8_HANDLER(sms_vdp_vcount_r) { |
| 171 | | return ( sms_frame_timing[ INIT_VCOUNT ] + video_screen_get_vpos(0) ) & 0xFF; |
| 167 | return ( smsvdp.sms_frame_timing[ INIT_VCOUNT ] + video_screen_get_vpos(0) ) & 0xFF; |
| 172 | 168 | } |
| 173 | 169 | |
| 174 | 170 | READ8_HANDLER(sms_vdp_hcount_r) { |
| r1284 | r1285 | |
| 176 | 172 | } |
| 177 | 173 | |
| 178 | 174 | void sms_set_ggsmsmode( int mode ) { |
| 179 | | ggSmsMode = mode; |
| 175 | smsvdp.gg_sms_mode = mode; |
| 180 | 176 | } |
| 181 | 177 | |
| 182 | 178 | int smsvdp_video_init( const smsvdp_configuration *config ) { |
| 183 | 179 | |
| 184 | | features = config->model; |
| 185 | | int_callback = config->int_callback; |
| 180 | memset( &smsvdp, 0, sizeof smsvdp ); |
| 186 | 181 | |
| 182 | smsvdp.features = config->model; |
| 183 | smsvdp.int_callback = config->int_callback; |
| 184 | |
| 187 | 185 | /* Allocate video RAM |
| 188 | 186 | In theory the driver could have a REGION_GFX1 and/or REGION_GFX2 memory region |
| 189 | 187 | of it's own. So this code could potentially cause a clash. |
| 190 | 188 | */ |
| 191 | | VRAM = new_memory_region( Machine, REGION_GFX1, VRAM_SIZE, ROM_REQUIRED ); |
| 192 | | CRAM = new_memory_region( Machine, REGION_GFX2, MAX_CRAM_SIZE, ROM_REQUIRED ); |
| 193 | | lineBuffer = auto_malloc( 256 * 5 * sizeof(int) ); |
| 194 | | memset( lineBuffer, 0, 256 * 5 * sizeof(int) ); |
| 189 | smsvdp.VRAM = new_memory_region( Machine, REGION_GFX1, VRAM_SIZE, ROM_REQUIRED ); |
| 190 | smsvdp.CRAM = new_memory_region( Machine, REGION_GFX2, MAX_CRAM_SIZE, ROM_REQUIRED ); |
| 191 | smsvdp.line_buffer = auto_malloc( 256 * 5 * sizeof(int) ); |
| 192 | memset( smsvdp.line_buffer, 0, 256 * 5 * sizeof(int) ); |
| 195 | 193 | |
| 196 | 194 | /* Clear RAM */ |
| 197 | | memset(reg, 0, NUM_OF_REGISTER); |
| 198 | | isCRAMDirty = 1; |
| 199 | | memset(VRAM, 0, VRAM_SIZE); |
| 200 | | memset(CRAM, 0, MAX_CRAM_SIZE); |
| 201 | | reg[0x01] |= 0x20; |
| 202 | | reg[0x02] = 0x0E; /* power up default */ |
| 203 | | reg[0x0a] = 0xff; |
| 195 | smsvdp.cram_dirty = 1; |
| 196 | memset(smsvdp.VRAM, 0, VRAM_SIZE); |
| 197 | memset(smsvdp.CRAM, 0, MAX_CRAM_SIZE); |
| 198 | smsvdp.reg[0x01] |= 0x20; |
| 199 | smsvdp.reg[0x02] = 0x0E; /* power up default */ |
| 200 | smsvdp.reg[0x0a] = 0xff; |
| 204 | 201 | |
| 205 | | CRAMMask = ( IS_GAMEGEAR_VDP && ! ggSmsMode ) ? ( GG_CRAM_SIZE - 1 ) : ( SMS_CRAM_SIZE - 1 ); |
| 202 | smsvdp.cram_mask = ( IS_GAMEGEAR_VDP && ! smsvdp.gg_sms_mode ) ? ( GG_CRAM_SIZE - 1 ) : ( SMS_CRAM_SIZE - 1 ); |
| 206 | 203 | |
| 207 | | /* Initialize VDP state variables */ |
| 208 | | addr = code = pending = latch = buffer = statusReg = \ |
| 209 | | lineCountDownCounter = irqState = 0; |
| 204 | smsvdp.collision_buffer = auto_malloc(SMS_X_PIXELS); |
| 210 | 205 | |
| 211 | | lineCollisionBuffer = auto_malloc(SMS_X_PIXELS); |
| 212 | | |
| 213 | 206 | /* Make temp bitmap for rendering */ |
| 214 | 207 | tmpbitmap = auto_bitmap_alloc(Machine->screen[0].width, Machine->screen[0].height, BITMAP_FORMAT_INDEXED32); |
| 215 | 208 | |
| 216 | | prevBitMapSaved = 0; |
| 217 | | prevBitMap = auto_bitmap_alloc(Machine->screen[0].width, Machine->screen[0].height, BITMAP_FORMAT_INDEXED32); |
| 209 | smsvdp.prev_bitmap = auto_bitmap_alloc(Machine->screen[0].width, Machine->screen[0].height, BITMAP_FORMAT_INDEXED32); |
| 218 | 210 | |
| 219 | 211 | set_display_settings(); |
| 220 | 212 | |
| 221 | | smsvdp_display_timer = mame_timer_alloc( smsvdp_display_callback ); |
| 222 | | mame_timer_adjust( smsvdp_display_timer, video_screen_get_time_until_pos( 0, 0, 0 ), 0, video_screen_get_scan_period( 0 ) ); |
| 223 | | return (0); |
| 213 | smsvdp.smsvdp_display_timer = mame_timer_alloc( smsvdp_display_callback ); |
| 214 | mame_timer_adjust( smsvdp.smsvdp_display_timer, video_screen_get_time_until_pos( 0, 0, 0 ), 0, video_screen_get_scan_period( 0 ) ); |
| 215 | return 0; |
| 224 | 216 | } |
| 225 | 217 | |
| 226 | 218 | static TIMER_CALLBACK(smsvdp_set_irq) { |
| 227 | | irqState = 1; |
| 228 | | if ( int_callback ) { |
| 229 | | int_callback( ASSERT_LINE ); |
| 219 | smsvdp.irq_state = 1; |
| 220 | if ( smsvdp.int_callback ) { |
| 221 | smsvdp.int_callback( ASSERT_LINE ); |
| 230 | 222 | } |
| 231 | 223 | } |
| 232 | 224 | |
| r1284 | r1285 | |
| 234 | 226 | { |
| 235 | 227 | rectangle rec; |
| 236 | 228 | int vpos = video_screen_get_vpos(0); |
| 237 | | int vpos_limit = sms_frame_timing[VERTICAL_BLANKING] + sms_frame_timing[TOP_BLANKING] |
| 238 | | + sms_frame_timing[TOP_BORDER] + sms_frame_timing[ACTIVE_DISPLAY_V] |
| 239 | | + sms_frame_timing[BOTTOM_BORDER] + sms_frame_timing[BOTTOM_BLANKING]; |
| 229 | int vpos_limit = smsvdp.sms_frame_timing[VERTICAL_BLANKING] + smsvdp.sms_frame_timing[TOP_BLANKING] |
| 230 | + smsvdp.sms_frame_timing[TOP_BORDER] + smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V] |
| 231 | + smsvdp.sms_frame_timing[BOTTOM_BORDER] + smsvdp.sms_frame_timing[BOTTOM_BLANKING]; |
| 240 | 232 | |
| 241 | 233 | rec.min_y = rec.max_y = vpos; |
| 242 | 234 | |
| r1284 | r1285 | |
| 246 | 238 | return; |
| 247 | 239 | } |
| 248 | 240 | |
| 249 | | vpos_limit -= sms_frame_timing[BOTTOM_BLANKING]; |
| 241 | vpos_limit -= smsvdp.sms_frame_timing[BOTTOM_BLANKING]; |
| 250 | 242 | |
| 251 | 243 | /* Check if we're below the bottom border */ |
| 252 | 244 | if ( vpos >= vpos_limit ) { |
| 253 | 245 | return; |
| 254 | 246 | } |
| 255 | 247 | |
| 256 | | vpos_limit -= sms_frame_timing[BOTTOM_BORDER]; |
| 248 | vpos_limit -= smsvdp.sms_frame_timing[BOTTOM_BORDER]; |
| 257 | 249 | |
| 258 | 250 | /* Check if we're in the bottom border area */ |
| 259 | 251 | if ( vpos >= vpos_limit ) { |
| 260 | 252 | if ( vpos == vpos_limit ) { |
| 261 | | if ( lineCountDownCounter == 0x00 ) { |
| 262 | | lineCountDownCounter = reg[0x0A]; |
| 263 | | statusReg |= STATUS_HINT; |
| 264 | | if ( reg[0x00] & 0x10 ) { |
| 253 | if ( smsvdp.line_counter == 0x00 ) { |
| 254 | smsvdp.line_counter = smsvdp.reg[0x0A]; |
| 255 | smsvdp.status |= STATUS_HINT; |
| 256 | if ( smsvdp.reg[0x00] & 0x10 ) { |
| 265 | 257 | /* Delay triggering of interrupt to allow software to read the status bit before the irq */ |
| 266 | 258 | mame_timer_set( video_screen_get_time_until_pos( 0, video_screen_get_vpos(0), video_screen_get_hpos(0) + 1 ), 0, smsvdp_set_irq ); |
| 267 | 259 | } |
| r1284 | r1285 | |
| 269 | 261 | |
| 270 | 262 | } |
| 271 | 263 | if ( vpos == vpos_limit + 1 ) { |
| 272 | | statusReg |= STATUS_VINT; |
| 273 | | if ( reg[0x01] & 0x20 ) { |
| 264 | smsvdp.status |= STATUS_VINT; |
| 265 | if ( smsvdp.reg[0x01] & 0x20 ) { |
| 274 | 266 | /* Delay triggering of interrupt to allow software to read the status bit before the irq */ |
| 275 | 267 | mame_timer_set( video_screen_get_time_until_pos( 0, video_screen_get_vpos(0), video_screen_get_hpos(0) + 1 ), 0, smsvdp_set_irq ); |
| 276 | 268 | } |
| r1284 | r1285 | |
| 282 | 274 | /* Draw left border */ |
| 283 | 275 | rec.min_x = LBORDER_START; |
| 284 | 276 | rec.max_x = LBORDER_START + LBORDER_X_PIXELS - 1; |
| 285 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 277 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 286 | 278 | /* Draw right border */ |
| 287 | 279 | rec.min_x = LBORDER_START + LBORDER_X_PIXELS + 256; |
| 288 | 280 | rec.max_x = rec.min_x + RBORDER_X_PIXELS - 1; |
| 289 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 281 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 290 | 282 | /* Draw middle of the border */ |
| 291 | 283 | /* We need to do this through the regular drawing function so it will */ |
| 292 | 284 | /* be included in the gamegear scaling functions */ |
| 293 | | sms_refresh_line( tmpbitmap, LBORDER_START + LBORDER_X_PIXELS, vpos_limit - sms_frame_timing[ACTIVE_DISPLAY_V], vpos - ( vpos_limit - sms_frame_timing[ACTIVE_DISPLAY_V] ) ); |
| 285 | sms_refresh_line( tmpbitmap, LBORDER_START + LBORDER_X_PIXELS, vpos_limit - smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V], vpos - ( vpos_limit - smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V] ) ); |
| 294 | 286 | return; |
| 295 | 287 | } |
| 296 | 288 | |
| 297 | | vpos_limit -= sms_frame_timing[ACTIVE_DISPLAY_V]; |
| 289 | vpos_limit -= smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V]; |
| 298 | 290 | |
| 299 | 291 | /* Check if we're in the active display area */ |
| 300 | 292 | if ( vpos >= vpos_limit ) { |
| 301 | 293 | if ( vpos == vpos_limit ) { |
| 302 | | lineCountDownCounter = reg[0x0A]; |
| 303 | | reg9copy = reg[0x09]; |
| 294 | smsvdp.line_counter = smsvdp.reg[0x0A]; |
| 295 | smsvdp.reg9copy = smsvdp.reg[0x09]; |
| 304 | 296 | } |
| 305 | | if ( lineCountDownCounter == 0x00 ) { |
| 306 | | lineCountDownCounter = reg[0x0A]; |
| 307 | | statusReg |= STATUS_HINT; |
| 308 | | if ( reg[0x00] & 0x10 ) { |
| 297 | if ( smsvdp.line_counter == 0x00 ) { |
| 298 | smsvdp.line_counter = smsvdp.reg[0x0A]; |
| 299 | smsvdp.status |= STATUS_HINT; |
| 300 | if ( smsvdp.reg[0x00] & 0x10 ) { |
| 309 | 301 | /* Delay triggering of interrupt to allow software to read the status bit before the irq */ |
| 310 | 302 | mame_timer_set( video_screen_get_time_until_pos( 0, video_screen_get_vpos(0), video_screen_get_hpos(0) + 1 ), 0, smsvdp_set_irq ); |
| 311 | 303 | } |
| 312 | 304 | } else { |
| 313 | | lineCountDownCounter -= 1; |
| 305 | smsvdp.line_counter -= 1; |
| 314 | 306 | } |
| 315 | 307 | if ( video_skip_this_frame() ) { |
| 316 | 308 | return; |
| r1284 | r1285 | |
| 318 | 310 | sms_update_palette(); |
| 319 | 311 | |
| 320 | 312 | /* Check if display is disabled */ |
| 321 | | if ( ! ( reg[0x01] & 0x40 ) ) { |
| 313 | if ( ! ( smsvdp.reg[0x01] & 0x40 ) ) { |
| 322 | 314 | /* set whole line to backdrop color */ |
| 323 | 315 | rec.min_x = LBORDER_START; |
| 324 | 316 | rec.max_x = LBORDER_START + LBORDER_X_PIXELS + 255 + RBORDER_X_PIXELS; |
| 325 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 317 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 326 | 318 | } else { |
| 327 | 319 | /* Draw left border */ |
| 328 | 320 | rec.min_x = LBORDER_START; |
| 329 | 321 | rec.max_x = LBORDER_START + LBORDER_X_PIXELS - 1; |
| 330 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 322 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 331 | 323 | /* Draw right border */ |
| 332 | 324 | rec.min_x = LBORDER_START + LBORDER_X_PIXELS + 256; |
| 333 | 325 | rec.max_x = rec.min_x + RBORDER_X_PIXELS - 1; |
| 334 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 326 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 335 | 327 | sms_refresh_line( tmpbitmap, LBORDER_START + LBORDER_X_PIXELS, vpos_limit, vpos - vpos_limit ); |
| 336 | 328 | } |
| 337 | 329 | return; |
| 338 | 330 | } |
| 339 | 331 | |
| 340 | | vpos_limit -= sms_frame_timing[TOP_BORDER]; |
| 332 | vpos_limit -= smsvdp.sms_frame_timing[TOP_BORDER]; |
| 341 | 333 | |
| 342 | 334 | /* Check if we're in the top border area */ |
| 343 | 335 | if ( vpos >= vpos_limit ) { |
| r1284 | r1285 | |
| 348 | 340 | /* Draw left border */ |
| 349 | 341 | rec.min_x = LBORDER_START; |
| 350 | 342 | rec.max_x = LBORDER_START + LBORDER_X_PIXELS - 1; |
| 351 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 343 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 352 | 344 | /* Draw right border */ |
| 353 | 345 | rec.min_x = LBORDER_START + LBORDER_X_PIXELS + 256; |
| 354 | 346 | rec.max_x = rec.min_x + RBORDER_X_PIXELS - 1; |
| 355 | | fillbitmap( tmpbitmap, Machine->pens[currentPalette[BACKDROP_COLOR]], &rec ); |
| 347 | fillbitmap( tmpbitmap, Machine->pens[smsvdp.current_palette[BACKDROP_COLOR]], &rec ); |
| 356 | 348 | /* Draw middle of the border */ |
| 357 | 349 | /* We need to do this through the regular drawing function so it will */ |
| 358 | 350 | /* be included in the gamegear scaling functions */ |
| 359 | | sms_refresh_line( tmpbitmap, LBORDER_START + LBORDER_X_PIXELS, vpos_limit + sms_frame_timing[TOP_BORDER], vpos - ( vpos_limit + sms_frame_timing[TOP_BORDER] ) ); |
| 351 | sms_refresh_line( tmpbitmap, LBORDER_START + LBORDER_X_PIXELS, vpos_limit + smsvdp.sms_frame_timing[TOP_BORDER], vpos - ( vpos_limit + smsvdp.sms_frame_timing[TOP_BORDER] ) ); |
| 360 | 352 | return; |
| 361 | 353 | } |
| 362 | 354 | } |
| 363 | 355 | |
| 364 | 356 | READ8_HANDLER(sms_vdp_data_r) { |
| 365 | | int temp; |
| 357 | UINT8 temp; |
| 366 | 358 | |
| 367 | 359 | /* SMS 2 & GG behaviour. Seems like the latched data is passed straight through */ |
| 368 | 360 | /* to the address register when in the middle of doing a command. */ |
| 369 | 361 | /* Cosmic Spacehead needs this, among others */ |
| 370 | | if ( pending ) { |
| 371 | | addr = ( addr & 0xff00 ) | latch; |
| 372 | | /* Clear pending write flag */ |
| 373 | | pending = 0; |
| 374 | | } |
| 362 | /* Clear pending write flag */ |
| 363 | smsvdp.pending = 0; |
| 375 | 364 | |
| 376 | 365 | /* Return read buffer contents */ |
| 377 | | temp = buffer; |
| 366 | temp = smsvdp.buffer; |
| 378 | 367 | |
| 379 | 368 | /* Load read buffer */ |
| 380 | | buffer = VRAM[(addr & 0x3FFF)]; |
| 369 | smsvdp.buffer = smsvdp.VRAM[(smsvdp.addr & 0x3FFF)]; |
| 381 | 370 | |
| 382 | 371 | /* Bump internal address register */ |
| 383 | | addr += 1; |
| 372 | smsvdp.addr += 1; |
| 384 | 373 | return (temp); |
| 385 | 374 | } |
| 386 | 375 | |
| 387 | 376 | READ8_HANDLER(sms_vdp_ctrl_r) { |
| 388 | | int temp = statusReg; |
| 377 | UINT8 temp = smsvdp.status; |
| 389 | 378 | |
| 390 | 379 | /* Clear pending write flag */ |
| 391 | | pending = 0; |
| 380 | smsvdp.pending = 0; |
| 392 | 381 | |
| 393 | | statusReg &= ~( STATUS_VINT | STATUS_SPROVR | STATUS_SPRCOL | STATUS_HINT ); |
| 382 | smsvdp.status &= ~( STATUS_VINT | STATUS_SPROVR | STATUS_SPRCOL | STATUS_HINT ); |
| 394 | 383 | |
| 395 | | if (irqState == 1) { |
| 396 | | irqState = 0; |
| 397 | | if ( int_callback ) { |
| 398 | | int_callback( CLEAR_LINE ); |
| 384 | if (smsvdp.irq_state == 1) { |
| 385 | smsvdp.irq_state = 0; |
| 386 | if ( smsvdp.int_callback ) { |
| 387 | smsvdp.int_callback( CLEAR_LINE ); |
| 399 | 388 | } |
| 400 | 389 | } |
| 401 | 390 | |
| r1284 | r1285 | |
| 405 | 394 | WRITE8_HANDLER(sms_vdp_data_w) { |
| 406 | 395 | /* SMS 2 & GG behaviour. Seems like the latched data is passed straight through */ |
| 407 | 396 | /* to the address register when in the middle of doing a command. */ |
| 408 | | /* Cosmic Spacehead needs this, among others */ |
| 409 | | if ( pending ) { |
| 410 | | addr = ( addr & 0xff00 ) | latch; |
| 411 | | /* Clear pending write flag */ |
| 412 | | pending = 0; |
| 413 | | } |
| 397 | /* Cosmic Spacehead needs this, among others */ |
| 398 | /* Clear pending write flag */ |
| 399 | smsvdp.pending = 0; |
| 414 | 400 | |
| 415 | | switch(code) { |
| 401 | switch(smsvdp.addrmode) { |
| 416 | 402 | case 0x00: |
| 417 | 403 | case 0x01: |
| 418 | 404 | case 0x02: { |
| 419 | | int address = (addr & 0x3FFF); |
| 405 | int address = (smsvdp.addr & 0x3FFF); |
| 420 | 406 | |
| 421 | | VRAM[address] = data; |
| 407 | smsvdp.VRAM[address] = data; |
| 422 | 408 | } |
| 423 | 409 | break; |
| 424 | 410 | case 0x03: { |
| 425 | | int address = addr & CRAMMask; |
| 411 | int address = smsvdp.addr & smsvdp.cram_mask; |
| 426 | 412 | |
| 427 | | if (data != CRAM[address]) { |
| 428 | | CRAM[address] = data; |
| 429 | | isCRAMDirty = 1; |
| 413 | if (data != smsvdp.CRAM[address]) { |
| 414 | smsvdp.CRAM[address] = data; |
| 415 | smsvdp.cram_dirty = 1; |
| 430 | 416 | } |
| 431 | 417 | } |
| 432 | 418 | break; |
| 433 | 419 | } |
| 434 | 420 | |
| 435 | | buffer = data; |
| 436 | | addr += 1; |
| 421 | smsvdp.buffer = data; |
| 422 | smsvdp.addr += 1; |
| 437 | 423 | } |
| 438 | 424 | |
| 439 | 425 | WRITE8_HANDLER(sms_vdp_ctrl_w) { |
| 440 | 426 | int regNum; |
| 441 | 427 | |
| 442 | | if (pending == 0) { |
| 443 | | latch = data; |
| 444 | | pending = 1; |
| 428 | if (smsvdp.pending == 0) { |
| 429 | smsvdp.addr = ( smsvdp.addr & 0xff00 ) | data; |
| 430 | smsvdp.pending = 1; |
| 445 | 431 | } else { |
| 446 | 432 | /* Clear pending write flag */ |
| 447 | | pending = 0; |
| 433 | smsvdp.pending = 0; |
| 448 | 434 | |
| 449 | | code = (data >> 6) & 0x03; |
| 450 | | addr = ( data << 8 ) | latch; |
| 451 | | switch( code ) { |
| 435 | smsvdp.addrmode = (data >> 6) & 0x03; |
| 436 | smsvdp.addr = ( data << 8 ) | ( smsvdp.addr & 0xff ); |
| 437 | switch( smsvdp.addrmode ) { |
| 452 | 438 | case 0: /* VRAM reading mode */ |
| 453 | | buffer = VRAM[ addr & 0x3FFF ]; |
| 454 | | addr += 1; |
| 439 | smsvdp.buffer = smsvdp.VRAM[ smsvdp.addr & 0x3FFF ]; |
| 440 | smsvdp.addr += 1; |
| 455 | 441 | break; |
| 456 | 442 | case 1: /* VRAM writing mode */ |
| 457 | 443 | break; |
| 458 | 444 | case 2: /* VDP register write */ |
| 459 | 445 | regNum = data & 0x0F; |
| 460 | | reg[regNum] = latch; |
| 461 | | if (regNum == 0 && latch & 0x02) { |
| 446 | smsvdp.reg[regNum] = smsvdp.addr & 0xff; |
| 447 | if (regNum == 0 && smsvdp.addr & 0x02) { |
| 462 | 448 | logerror("overscan enabled.\n"); |
| 463 | 449 | } |
| 464 | 450 | if ( regNum == 0 || regNum == 1 ) { |
| 465 | 451 | set_display_settings(); |
| 466 | 452 | } |
| 467 | | if ( ( regNum == 1 ) && ( reg[0x01] & 0x20 ) && ( statusReg & STATUS_VINT ) ) { |
| 468 | | int_callback( ASSERT_LINE ); |
| 453 | if ( ( regNum == 1 ) && ( smsvdp.reg[0x01] & 0x20 ) && ( smsvdp.status & STATUS_VINT ) ) { |
| 454 | smsvdp.int_callback( ASSERT_LINE ); |
| 469 | 455 | } |
| 470 | | code = 0; |
| 456 | smsvdp.addrmode = 0; |
| 471 | 457 | break; |
| 472 | 458 | case 3: /* CRAM writing mode */ |
| 473 | 459 | break; |
| r1284 | r1285 | |
| 475 | 461 | } |
| 476 | 462 | } |
| 477 | 463 | |
| 478 | | void sms_refresh_line_mode4(int *lineBuffer, int line) { |
| 464 | static void sms_refresh_line_mode4(int *lineBuffer, int line) { |
| 479 | 465 | int tileColumn; |
| 480 | 466 | int xScroll, yScroll, xScrollStartColumn; |
| 481 | 467 | int spriteIndex; |
| r1284 | r1285 | |
| 485 | 471 | int bitPlane0, bitPlane1, bitPlane2, bitPlane3; |
| 486 | 472 | UINT16 nameTableAddress; |
| 487 | 473 | UINT8 *nameTable; |
| 488 | | UINT8 *spriteTable = &VRAM[(reg[0x05] << 7) & 0x3F00]; |
| 474 | UINT8 *spriteTable = smsvdp.VRAM + ( (smsvdp.reg[0x05] << 7) & 0x3F00 ); |
| 489 | 475 | |
| 490 | | if ( y_pixels != 192 ) { |
| 491 | | nameTableAddress = (((reg[0x02] & 0x0C) << 10) | 0x0700) + ((((line + reg9copy) % 256) >> 3) << 6); |
| 476 | if ( smsvdp.y_pixels != 192 ) { |
| 477 | nameTableAddress = (((smsvdp.reg[0x02] & 0x0C) << 10) | 0x0700) + ((((line + smsvdp.reg9copy) % 256) >> 3) << 6); |
| 492 | 478 | } else { |
| 493 | | nameTableAddress = ((reg[0x02] << 10) & 0x3800) + ((((line + reg9copy) % 224) >> 3) << 6); |
| 479 | nameTableAddress = ((smsvdp.reg[0x02] << 10) & 0x3800) + ((((line + smsvdp.reg9copy) % 224) >> 3) << 6); |
| 494 | 480 | } |
| 495 | 481 | if ( IS_SMS1_VDP ) { |
| 496 | | nameTableAddress = nameTableAddress & (((reg[0x02] & 0x01) << 10) | 0x3BFF); |
| 482 | nameTableAddress = nameTableAddress & (((smsvdp.reg[0x02] & 0x01) << 10) | 0x3BFF); |
| 497 | 483 | } |
| 498 | | nameTable = VRAM + nameTableAddress; |
| 484 | nameTable = smsvdp.VRAM + nameTableAddress; |
| 499 | 485 | |
| 500 | 486 | /* if top 2 rows of screen not affected by horizontal scrolling, then xScroll = 0 */ |
| 501 | 487 | /* else xScroll = reg[0x08] (SMS Only) */ |
| 502 | 488 | if ( IS_GAMEGEAR_VDP ) { |
| 503 | | xScroll = 0x0100 - reg[0x08]; |
| 489 | xScroll = 0x0100 - smsvdp.reg[0x08]; |
| 504 | 490 | } else { |
| 505 | | xScroll = (((reg[0x00] & 0x40) && (line < 16)) ? 0 : 0x0100 - reg[0x08]); |
| 491 | xScroll = (((smsvdp.reg[0x00] & 0x40) && (line < 16)) ? 0 : 0x0100 - smsvdp.reg[0x08]); |
| 506 | 492 | } |
| 507 | 493 | |
| 508 | 494 | xScrollStartColumn = (xScroll >> 3); /* x starting column tile */ |
| r1284 | r1285 | |
| 516 | 502 | /* Rightmost 8 columns for SMS (or 2 columns for GG) not affected by */ |
| 517 | 503 | /* vertical scrolling when bit 7 of reg[0x00] is set */ |
| 518 | 504 | if ( IS_GAMEGEAR_VDP ) { |
| 519 | | yScroll = (((reg[0x00] & 0x80) && (tileColumn > 29)) ? 0 : (reg9copy) % 224); |
| 505 | yScroll = (((smsvdp.reg[0x00] & 0x80) && (tileColumn > 29)) ? 0 : (smsvdp.reg9copy) % 224); |
| 520 | 506 | } else { |
| 521 | | yScroll = (((reg[0x00] & 0x80) && (tileColumn > 23)) ? 0 : (reg9copy) % 224); |
| 507 | yScroll = (((smsvdp.reg[0x00] & 0x80) && (tileColumn > 23)) ? 0 : (smsvdp.reg9copy) % 224); |
| 522 | 508 | } |
| 523 | 509 | |
| 524 | 510 | tileLine = ( ( tileColumn + xScrollStartColumn ) & 0x1F ) * 2; |
| r1284 | r1285 | |
| 534 | 520 | if (vertSelected) { |
| 535 | 521 | tileLine = 0x07 - tileLine; |
| 536 | 522 | } |
| 537 | | bitPlane0 = VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x00]; |
| 538 | | bitPlane1 = VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x01]; |
| 539 | | bitPlane2 = VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x02]; |
| 540 | | bitPlane3 = VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x03]; |
| 523 | bitPlane0 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x00]; |
| 524 | bitPlane1 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x01]; |
| 525 | bitPlane2 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x02]; |
| 526 | bitPlane3 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x03]; |
| 541 | 527 | |
| 542 | 528 | for (pixelX = 0; pixelX < 8 ; pixelX++) { |
| 543 | 529 | UINT8 penBit0, penBit1, penBit2, penBit3; |
| r1284 | r1285 | |
| 561 | 547 | pixelPlotX = (0 - (xScroll & 0x07) + (tileColumn << 3) + pixelPlotX); |
| 562 | 548 | if (pixelPlotX >= 0 && pixelPlotX < 256) { |
| 563 | 549 | // logerror("%x %x\n", pixelPlotX + pixelOffsetX, pixelPlotY); |
| 564 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 550 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 565 | 551 | prioritySelected[pixelPlotX] = prioritySelect | ( penSelected & 0x0F ); |
| 566 | 552 | } |
| 567 | 553 | } |
| 568 | 554 | } |
| 569 | 555 | |
| 570 | 556 | /* Draw sprite layer */ |
| 571 | | spriteHeight = (reg[0x01] & 0x02 ? 16 : 8); |
| 557 | spriteHeight = (smsvdp.reg[0x01] & 0x02 ? 16 : 8); |
| 572 | 558 | spriteZoom = 1; |
| 573 | | if (reg[0x01] & 0x01) { |
| 559 | if (smsvdp.reg[0x01] & 0x01) { |
| 574 | 560 | /* sprite doubling */ |
| 575 | 561 | spriteZoom = 2; |
| 576 | 562 | } |
| 577 | 563 | spriteBufferCount = 0; |
| 578 | | for (spriteIndex = 0; (spriteIndex < 64) && (spriteTable[spriteIndex] != 0xD0 || y_pixels != 192) && (spriteBufferCount < 9); spriteIndex++) { |
| 564 | for (spriteIndex = 0; (spriteIndex < 64) && (spriteTable[spriteIndex] != 0xD0 || smsvdp.y_pixels != 192) && (spriteBufferCount < 9); spriteIndex++) { |
| 579 | 565 | spriteY = spriteTable[spriteIndex] + 1; /* sprite y position starts at line 1 */ |
| 580 | 566 | if (spriteY > 240) { |
| 581 | 567 | spriteY -= 256; /* wrap from top if y position is > 240 */ |
| r1284 | r1285 | |
| 585 | 571 | spriteBuffer[spriteBufferCount] = spriteIndex; |
| 586 | 572 | } else { |
| 587 | 573 | /* Too many sprites per line */ |
| 588 | | statusReg |= STATUS_SPROVR; |
| 574 | smsvdp.status |= STATUS_SPROVR; |
| 589 | 575 | } |
| 590 | 576 | spriteBufferCount++; |
| 591 | 577 | } |
| r1284 | r1285 | |
| 593 | 579 | if ( spriteBufferCount > 8 ) { |
| 594 | 580 | spriteBufferCount = 8; |
| 595 | 581 | } |
| 596 | | memset(lineCollisionBuffer, 0, SMS_X_PIXELS); |
| 582 | memset(smsvdp.collision_buffer, 0, SMS_X_PIXELS); |
| 597 | 583 | spriteBufferCount--; |
| 598 | 584 | for (spriteBufferIndex = spriteBufferCount; spriteBufferIndex >= 0; spriteBufferIndex--) { |
| 599 | 585 | spriteIndex = spriteBuffer[spriteBufferIndex]; |
| r1284 | r1285 | |
| 603 | 589 | } |
| 604 | 590 | |
| 605 | 591 | spriteX = spriteTable[0x80 + (spriteIndex << 1)]; |
| 606 | | if (reg[0x00] & 0x08) { |
| 592 | if (smsvdp.reg[0x00] & 0x08) { |
| 607 | 593 | spriteX -= 0x08; /* sprite shift */ |
| 608 | 594 | } |
| 609 | 595 | spriteTileSelected = spriteTable[0x81 + (spriteIndex << 1)]; |
| 610 | | if (reg[0x06] & 0x04) { |
| 596 | if (smsvdp.reg[0x06] & 0x04) { |
| 611 | 597 | spriteTileSelected += 256; /* pattern table select */ |
| 612 | 598 | } |
| 613 | | if (reg[0x01] & 0x02) { |
| 599 | if (smsvdp.reg[0x01] & 0x02) { |
| 614 | 600 | spriteTileSelected &= 0x01FE; /* force even index */ |
| 615 | 601 | } |
| 616 | 602 | spriteLine = ( line - spriteY ) / spriteZoom; |
| r1284 | r1285 | |
| 619 | 605 | spriteTileSelected += 1; |
| 620 | 606 | } |
| 621 | 607 | |
| 622 | | bitPlane0 = VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x00]; |
| 623 | | bitPlane1 = VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x01]; |
| 624 | | bitPlane2 = VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x02]; |
| 625 | | bitPlane3 = VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x03]; |
| 608 | bitPlane0 = smsvdp.VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x00]; |
| 609 | bitPlane1 = smsvdp.VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x01]; |
| 610 | bitPlane2 = smsvdp.VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x02]; |
| 611 | bitPlane3 = smsvdp.VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x03]; |
| 626 | 612 | |
| 627 | 613 | for (pixelX = 0; pixelX < 8 ; pixelX++) { |
| 628 | 614 | UINT8 penBit0, penBit1, penBit2, penBit3; |
| r1284 | r1285 | |
| 639 | 625 | continue; |
| 640 | 626 | } |
| 641 | 627 | |
| 642 | | if (reg[0x01] & 0x01) { |
| 628 | if (smsvdp.reg[0x01] & 0x01) { |
| 643 | 629 | /* sprite doubling is enabled */ |
| 644 | 630 | pixelPlotX = spriteX + (pixelX << 1); |
| 645 | 631 | |
| r1284 | r1285 | |
| 649 | 635 | } |
| 650 | 636 | |
| 651 | 637 | if ( ! ( prioritySelected[pixelPlotX] & PRIORITY_BIT ) ) { |
| 652 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 653 | | lineBuffer[pixelPlotX+1] = currentPalette[penSelected]; |
| 638 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 639 | lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected]; |
| 654 | 640 | } else { |
| 655 | 641 | if ( prioritySelected[pixelPlotX] == PRIORITY_BIT ) { |
| 656 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 642 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 657 | 643 | } |
| 658 | 644 | if ( prioritySelected[pixelPlotX + 1] == PRIORITY_BIT ) { |
| 659 | | lineBuffer[pixelPlotX+1] = currentPalette[penSelected]; |
| 645 | lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected]; |
| 660 | 646 | } |
| 661 | 647 | } |
| 662 | | if (lineCollisionBuffer[pixelPlotX] != 1) { |
| 663 | | lineCollisionBuffer[pixelPlotX] = 1; |
| 648 | if (smsvdp.collision_buffer[pixelPlotX] != 1) { |
| 649 | smsvdp.collision_buffer[pixelPlotX] = 1; |
| 664 | 650 | } else { |
| 665 | 651 | /* sprite collision occurred */ |
| 666 | | statusReg |= STATUS_SPRCOL; |
| 652 | smsvdp.status |= STATUS_SPRCOL; |
| 667 | 653 | } |
| 668 | | if (lineCollisionBuffer[pixelPlotX + 1] != 1) { |
| 669 | | lineCollisionBuffer[pixelPlotX + 1] = 1; |
| 654 | if (smsvdp.collision_buffer[pixelPlotX + 1] != 1) { |
| 655 | smsvdp.collision_buffer[pixelPlotX + 1] = 1; |
| 670 | 656 | } else { |
| 671 | 657 | /* sprite collision occurred */ |
| 672 | | statusReg |= STATUS_SPRCOL; |
| 658 | smsvdp.status |= STATUS_SPRCOL; |
| 673 | 659 | } |
| 674 | 660 | } else { |
| 675 | 661 | pixelPlotX = spriteX + pixelX; |
| r1284 | r1285 | |
| 680 | 666 | } |
| 681 | 667 | |
| 682 | 668 | if ( ! ( prioritySelected[pixelPlotX] & PRIORITY_BIT ) ) { |
| 683 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 669 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 684 | 670 | } else { |
| 685 | 671 | if ( prioritySelected[pixelPlotX] == PRIORITY_BIT ) { |
| 686 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 672 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 687 | 673 | } |
| 688 | 674 | } |
| 689 | | if (lineCollisionBuffer[pixelPlotX] != 1) { |
| 690 | | lineCollisionBuffer[pixelPlotX] = 1; |
| 675 | if (smsvdp.collision_buffer[pixelPlotX] != 1) { |
| 676 | smsvdp.collision_buffer[pixelPlotX] = 1; |
| 691 | 677 | } else { |
| 692 | 678 | /* sprite collision occurred */ |
| 693 | | statusReg |= STATUS_SPRCOL; |
| 679 | smsvdp.status |= STATUS_SPRCOL; |
| 694 | 680 | } |
| 695 | 681 | } |
| 696 | 682 | } |
| 697 | 683 | } |
| 698 | 684 | |
| 699 | 685 | /* Fill column 0 with overscan color from reg[0x07] */ |
| 700 | | if (reg[0x00] & 0x20) { |
| 701 | | lineBuffer[0] = currentPalette[BACKDROP_COLOR]; |
| 702 | | lineBuffer[1] = currentPalette[BACKDROP_COLOR]; |
| 703 | | lineBuffer[2] = currentPalette[BACKDROP_COLOR]; |
| 704 | | lineBuffer[3] = currentPalette[BACKDROP_COLOR]; |
| 705 | | lineBuffer[4] = currentPalette[BACKDROP_COLOR]; |
| 706 | | lineBuffer[5] = currentPalette[BACKDROP_COLOR]; |
| 707 | | lineBuffer[6] = currentPalette[BACKDROP_COLOR]; |
| 708 | | lineBuffer[7] = currentPalette[BACKDROP_COLOR]; |
| 686 | if (smsvdp.reg[0x00] & 0x20) { |
| 687 | lineBuffer[0] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 688 | lineBuffer[1] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 689 | lineBuffer[2] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 690 | lineBuffer[3] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 691 | lineBuffer[4] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 692 | lineBuffer[5] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 693 | lineBuffer[6] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 694 | lineBuffer[7] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 709 | 695 | } |
| 710 | 696 | } |
| 711 | 697 | |
| 712 | | void sms_refresh_tms9918_sprites(int *lineBuffer, int line) { |
| 698 | static void sms_refresh_tms9918_sprites(int *lineBuffer, int line) { |
| 713 | 699 | int pixelPlotX; |
| 714 | 700 | int spriteHeight, spriteBufferCount, spriteIndex, spriteBuffer[4], spriteBufferIndex; |
| 715 | 701 | UINT8 *spriteTable, *spritePatternTable; |
| 716 | 702 | |
| 717 | 703 | /* Draw sprite layer */ |
| 718 | | spriteTable = VRAM + ( ( reg[0x05] & 0x7F ) << 7 ); |
| 719 | | spritePatternTable = VRAM + ( ( reg[0x06] & 0x07 ) << 11 ); |
| 704 | spriteTable = smsvdp.VRAM + ( ( smsvdp.reg[0x05] & 0x7F ) << 7 ); |
| 705 | spritePatternTable = smsvdp.VRAM + ( ( smsvdp.reg[0x06] & 0x07 ) << 11 ); |
| 720 | 706 | spriteHeight = 8; |
| 721 | | if ( reg[0x01] & 0x02 ) /* Check if SI is set */ |
| 707 | if ( smsvdp.reg[0x01] & 0x02 ) /* Check if SI is set */ |
| 722 | 708 | spriteHeight = spriteHeight * 2; |
| 723 | | if ( reg[0x01] & 0x01 ) /* Check if MAG is set */ |
| 709 | if ( smsvdp.reg[0x01] & 0x01 ) /* Check if MAG is set */ |
| 724 | 710 | spriteHeight = spriteHeight * 2; |
| 725 | 711 | spriteBufferCount = 0; |
| 726 | 712 | for ( spriteIndex = 0; (spriteIndex < 32*4 ) && ( spriteTable[spriteIndex] != 0xD0 ) && ( spriteBufferCount < 5); spriteIndex+= 4 ) { |
| r1284 | r1285 | |
| 733 | 719 | spriteBuffer[spriteBufferCount] = spriteIndex; |
| 734 | 720 | } else { |
| 735 | 721 | /* Too many sprites per line */ |
| 736 | | statusReg |= STATUS_SPROVR; |
| 722 | smsvdp.status |= STATUS_SPROVR; |
| 737 | 723 | } |
| 738 | 724 | spriteBufferCount++; |
| 739 | 725 | } |
| r1284 | r1285 | |
| 741 | 727 | if ( spriteBufferCount > 4 ) { |
| 742 | 728 | spriteBufferCount = 4; |
| 743 | 729 | } |
| 744 | | memset( lineCollisionBuffer, 0, SMS_X_PIXELS ); |
| 730 | memset( smsvdp.collision_buffer, 0, SMS_X_PIXELS ); |
| 745 | 731 | spriteBufferCount--; |
| 746 | 732 | for ( spriteBufferIndex = spriteBufferCount; spriteBufferIndex >= 0; spriteBufferIndex-- ) { |
| 747 | 733 | int penSelected; |
| r1284 | r1285 | |
| 763 | 749 | } |
| 764 | 750 | spriteTileSelected = spriteTable[ spriteIndex + 2 ]; |
| 765 | 751 | spriteLine = line - spriteY; |
| 766 | | if ( reg[0x01] & 0x01 ) { |
| 752 | if ( smsvdp.reg[0x01] & 0x01 ) { |
| 767 | 753 | spriteLine >>= 1; |
| 768 | 754 | } |
| 769 | | if ( reg[0x01] & 0x02 ) { |
| 755 | if ( smsvdp.reg[0x01] & 0x02 ) { |
| 770 | 756 | spriteTileSelected &= 0xFC; |
| 771 | 757 | if ( spriteLine > 0x07 ) { |
| 772 | 758 | spriteTileSelected += 1; |
| r1284 | r1285 | |
| 776 | 762 | pattern = spritePatternTable[ spriteTileSelected * 8 + spriteLine ]; |
| 777 | 763 | |
| 778 | 764 | for ( pixelX = 0; pixelX < 8; pixelX++ ) { |
| 779 | | if ( reg[0x01] & 0x01 ) { |
| 765 | if ( smsvdp.reg[0x01] & 0x01 ) { |
| 780 | 766 | pixelPlotX = spriteX + pixelX * 2; |
| 781 | 767 | if ( pixelPlotX < 0 || pixelPlotX > 255 ) { |
| 782 | 768 | continue; |
| 783 | 769 | } |
| 784 | 770 | if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) { |
| 785 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 786 | | if ( lineCollisionBuffer[pixelPlotX] != 1 ) { |
| 787 | | lineCollisionBuffer[pixelPlotX] = 1; |
| 771 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 772 | if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) { |
| 773 | smsvdp.collision_buffer[pixelPlotX] = 1; |
| 788 | 774 | } else { |
| 789 | | statusReg |= STATUS_SPRCOL; |
| 775 | smsvdp.status |= STATUS_SPRCOL; |
| 790 | 776 | } |
| 791 | | lineBuffer[pixelPlotX+1] = currentPalette[penSelected]; |
| 792 | | if ( lineCollisionBuffer[pixelPlotX + 1] != 1 ) { |
| 793 | | lineCollisionBuffer[pixelPlotX + 1] = 1; |
| 777 | lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected]; |
| 778 | if ( smsvdp.collision_buffer[pixelPlotX + 1] != 1 ) { |
| 779 | smsvdp.collision_buffer[pixelPlotX + 1] = 1; |
| 794 | 780 | } else { |
| 795 | | statusReg |= STATUS_SPRCOL; |
| 781 | smsvdp.status |= STATUS_SPRCOL; |
| 796 | 782 | } |
| 797 | 783 | } |
| 798 | 784 | } else { |
| r1284 | r1285 | |
| 801 | 787 | continue; |
| 802 | 788 | } |
| 803 | 789 | if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) { |
| 804 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 805 | | if ( lineCollisionBuffer[pixelPlotX] != 1 ) { |
| 806 | | lineCollisionBuffer[pixelPlotX] = 1; |
| 790 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 791 | if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) { |
| 792 | smsvdp.collision_buffer[pixelPlotX] = 1; |
| 807 | 793 | } else { |
| 808 | | statusReg |= STATUS_SPRCOL; |
| 794 | smsvdp.status |= STATUS_SPRCOL; |
| 809 | 795 | } |
| 810 | 796 | } |
| 811 | 797 | } |
| 812 | 798 | } |
| 813 | 799 | |
| 814 | | if ( reg[0x01] & 0x02 ) { |
| 800 | if ( smsvdp.reg[0x01] & 0x02 ) { |
| 815 | 801 | spriteTileSelected += 2; |
| 816 | 802 | pattern = spritePatternTable[ spriteTileSelected * 8 + spriteLine ]; |
| 817 | | spriteX += ( reg[0x01] & 0x01 ? 16 : 8 ); |
| 803 | spriteX += ( smsvdp.reg[0x01] & 0x01 ? 16 : 8 ); |
| 818 | 804 | for ( pixelX = 0; pixelX < 8; pixelX++ ) { |
| 819 | | if ( reg[0x01] & 0x01 ) { |
| 805 | if ( smsvdp.reg[0x01] & 0x01 ) { |
| 820 | 806 | pixelPlotX = spriteX + pixelX * 2; |
| 821 | 807 | if ( pixelPlotX < 0 || pixelPlotX > 255 ) { |
| 822 | 808 | continue; |
| 823 | 809 | } |
| 824 | 810 | if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) { |
| 825 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 826 | | if ( lineCollisionBuffer[pixelPlotX] != 1 ) { |
| 827 | | lineCollisionBuffer[pixelPlotX] = 1; |
| 811 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 812 | if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) { |
| 813 | smsvdp.collision_buffer[pixelPlotX] = 1; |
| 828 | 814 | } else { |
| 829 | | statusReg |= STATUS_SPRCOL; |
| 815 | smsvdp.status |= STATUS_SPRCOL; |
| 830 | 816 | } |
| 831 | | lineBuffer[pixelPlotX+1] = currentPalette[penSelected]; |
| 832 | | if ( lineCollisionBuffer[pixelPlotX + 1] != 1 ) { |
| 833 | | lineCollisionBuffer[pixelPlotX + 1] = 1; |
| 817 | lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected]; |
| 818 | if ( smsvdp.collision_buffer[pixelPlotX + 1] != 1 ) { |
| 819 | smsvdp.collision_buffer[pixelPlotX + 1] = 1; |
| 834 | 820 | } else { |
| 835 | | statusReg |= STATUS_SPRCOL; |
| 821 | smsvdp.status |= STATUS_SPRCOL; |
| 836 | 822 | } |
| 837 | 823 | } |
| 838 | 824 | } else { |
| r1284 | r1285 | |
| 841 | 827 | continue; |
| 842 | 828 | } |
| 843 | 829 | if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) { |
| 844 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 845 | | if ( lineCollisionBuffer[pixelPlotX] != 1 ) { |
| 846 | | lineCollisionBuffer[pixelPlotX] = 1; |
| 830 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 831 | if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) { |
| 832 | smsvdp.collision_buffer[pixelPlotX] = 1; |
| 847 | 833 | } else { |
| 848 | | statusReg |= STATUS_SPRCOL; |
| 834 | smsvdp.status |= STATUS_SPRCOL; |
| 849 | 835 | } |
| 850 | 836 | } |
| 851 | 837 | } |
| r1284 | r1285 | |
| 854 | 840 | } |
| 855 | 841 | } |
| 856 | 842 | |
| 857 | | void sms_refresh_line_mode2(int *lineBuffer, int line) { |
| 843 | static void sms_refresh_line_mode2(int *lineBuffer, int line) { |
| 858 | 844 | int tileColumn; |
| 859 | 845 | int pixelX, pixelPlotX; |
| 860 | 846 | UINT8 *nameTable, *colorTable, *patternTable; |
| 861 | 847 | int patternMask, colorMask, patternOffset; |
| 862 | 848 | |
| 863 | 849 | /* Draw background layer */ |
| 864 | | nameTable = VRAM + ( ( reg[0x02] & 0x0F ) << 10 ) + ( ( line >> 3 ) * 32 ); |
| 865 | | colorTable = VRAM + ( ( reg[0x03] & 0x80 ) << 6 ); |
| 866 | | colorMask = ( ( reg[0x03] & 0x7F ) << 3 ) | 0x07; |
| 867 | | patternTable = VRAM + ( ( reg[0x04] & 0x04 ) << 11 ); |
| 868 | | patternMask = ( ( reg[0x04] & 0x03 ) << 8 ) | 0xFF; |
| 850 | nameTable = smsvdp.VRAM + ( ( smsvdp.reg[0x02] & 0x0F ) << 10 ) + ( ( line >> 3 ) * 32 ); |
| 851 | colorTable = smsvdp.VRAM + ( ( smsvdp.reg[0x03] & 0x80 ) << 6 ); |
| 852 | colorMask = ( ( smsvdp.reg[0x03] & 0x7F ) << 3 ) | 0x07; |
| 853 | patternTable = smsvdp.VRAM + ( ( smsvdp.reg[0x04] & 0x04 ) << 11 ); |
| 854 | patternMask = ( ( smsvdp.reg[0x04] & 0x03 ) << 8 ) | 0xFF; |
| 869 | 855 | patternOffset = ( line & 0xC0 ) << 2; |
| 870 | 856 | for ( tileColumn = 0; tileColumn < 32; tileColumn++ ) { |
| 871 | 857 | UINT8 pattern; |
| r1284 | r1285 | |
| 886 | 872 | if ( IS_GAMEGEAR_VDP ) { |
| 887 | 873 | penSelected |= 0x10; |
| 888 | 874 | } |
| 889 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 875 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 890 | 876 | } |
| 891 | 877 | } |
| 892 | 878 | |
| r1284 | r1285 | |
| 894 | 880 | sms_refresh_tms9918_sprites( lineBuffer, line ); |
| 895 | 881 | } |
| 896 | 882 | |
| 897 | | void sms_refresh_line_mode0(int *lineBuffer, int line) { |
| 883 | static void sms_refresh_line_mode0(int *lineBuffer, int line) { |
| 898 | 884 | int tileColumn; |
| 899 | 885 | int pixelX, pixelPlotX; |
| 900 | 886 | UINT8 *nameTable, *colorTable, *patternTable; |
| 901 | 887 | |
| 902 | 888 | /* Draw background layer */ |
| 903 | | nameTable = VRAM + ( ( reg[0x02] & 0x0F ) << 10 ) + ( ( line >> 3 ) * 32 ); |
| 904 | | colorTable = VRAM + ( ( reg[0x03] << 6 ) & ( VRAM_SIZE - 1 ) ); |
| 905 | | patternTable = VRAM + ( ( reg[0x04] << 11 ) & ( VRAM_SIZE - 1 ) ); |
| 889 | nameTable = smsvdp.VRAM + ( ( smsvdp.reg[0x02] & 0x0F ) << 10 ) + ( ( line >> 3 ) * 32 ); |
| 890 | colorTable = smsvdp.VRAM + ( ( smsvdp.reg[0x03] << 6 ) & ( VRAM_SIZE - 1 ) ); |
| 891 | patternTable = smsvdp.VRAM + ( ( smsvdp.reg[0x04] << 11 ) & ( VRAM_SIZE - 1 ) ); |
| 906 | 892 | for ( tileColumn = 0; tileColumn < 32; tileColumn++ ) { |
| 907 | 893 | UINT8 pattern; |
| 908 | 894 | UINT8 colors; |
| r1284 | r1285 | |
| 919 | 905 | penSelected |= 0x10; |
| 920 | 906 | } |
| 921 | 907 | pixelPlotX = ( tileColumn << 3 ) + pixelX; |
| 922 | | lineBuffer[pixelPlotX] = currentPalette[penSelected]; |
| 908 | lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected]; |
| 923 | 909 | } |
| 924 | 910 | } |
| 925 | 911 | |
| r1284 | r1285 | |
| 927 | 913 | sms_refresh_tms9918_sprites( lineBuffer, line ); |
| 928 | 914 | } |
| 929 | 915 | |
| 930 | | void sms_refresh_line( mame_bitmap *bitmap, int pixelOffsetX, int pixelPlotY, int line ) { |
| 916 | static void sms_refresh_line( mame_bitmap *bitmap, int pixelOffsetX, int pixelPlotY, int line ) { |
| 931 | 917 | int x; |
| 932 | | int *blitLineBuffer = lineBuffer; |
| 918 | int *blitLineBuffer = smsvdp.line_buffer; |
| 933 | 919 | |
| 934 | | if ( line >= 0 && line < sms_frame_timing[ACTIVE_DISPLAY_V] ) { |
| 935 | | switch( vdp_mode ) { |
| 920 | if ( line >= 0 && line < smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V] ) { |
| 921 | switch( smsvdp.vdp_mode ) { |
| 936 | 922 | case 0: |
| 937 | 923 | sms_refresh_line_mode0( blitLineBuffer, line ); |
| 938 | 924 | break; |
| r1284 | r1285 | |
| 946 | 932 | } |
| 947 | 933 | } else { |
| 948 | 934 | for ( x = 0; x < 256; x++ ) { |
| 949 | | blitLineBuffer[x] = currentPalette[BACKDROP_COLOR]; |
| 935 | blitLineBuffer[x] = smsvdp.current_palette[BACKDROP_COLOR]; |
| 950 | 936 | } |
| 951 | 937 | } |
| 952 | 938 | |
| 953 | | if ( IS_GAMEGEAR_VDP && ggSmsMode ) { |
| 954 | | int *combineLineBuffer = lineBuffer + ( ( line & 0x03 ) + 1 ) * 256; |
| 939 | if ( IS_GAMEGEAR_VDP && smsvdp.gg_sms_mode ) { |
| 940 | int *combineLineBuffer = smsvdp.line_buffer + ( ( line & 0x03 ) + 1 ) * 256; |
| 955 | 941 | int plotX = 48; |
| 956 | 942 | |
| 957 | 943 | /* Do horizontal scaling */ |
| r1284 | r1285 | |
| 1000 | 986 | pixelPlotY = TBORDER_START + NTSC_192_TBORDER_Y_PIXELS + 24 + ggLine; |
| 1001 | 987 | |
| 1002 | 988 | /* Setup our source lines */ |
| 1003 | | line1 = lineBuffer + ( ( ( myLine - 3 ) & 0x03 ) + 1 ) * 256; |
| 1004 | | line2 = lineBuffer + ( ( ( myLine - 2 ) & 0x03 ) + 1 ) * 256; |
| 1005 | | line3 = lineBuffer + ( ( ( myLine - 1 ) & 0x03 ) + 1 ) * 256; |
| 1006 | | line4 = lineBuffer + ( ( ( myLine - 0 ) & 0x03 ) + 1 ) * 256; |
| 989 | line1 = smsvdp.line_buffer + ( ( ( myLine - 3 ) & 0x03 ) + 1 ) * 256; |
| 990 | line2 = smsvdp.line_buffer + ( ( ( myLine - 2 ) & 0x03 ) + 1 ) * 256; |
| 991 | line3 = smsvdp.line_buffer + ( ( ( myLine - 1 ) & 0x03 ) + 1 ) * 256; |
| 992 | line4 = smsvdp.line_buffer + ( ( ( myLine - 0 ) & 0x03 ) + 1 ) * 256; |
| 1007 | 993 | |
| 1008 | 994 | for( x = 0+48; x < 160+48; x++ ) { |
| 1009 | 995 | rgb_t c1 = Machine->pens[line1[x]]; |
| r1284 | r1285 | |
| 1025 | 1011 | } |
| 1026 | 1012 | } |
| 1027 | 1013 | |
| 1028 | | void sms_update_palette(void) { |
| 1014 | static void sms_update_palette(void) { |
| 1029 | 1015 | int i; |
| 1030 | 1016 | |
| 1031 | 1017 | /* Exit if palette is has no changes */ |
| 1032 | | if (isCRAMDirty == 0) { |
| 1018 | if (smsvdp.cram_dirty == 0) { |
| 1033 | 1019 | return; |
| 1034 | 1020 | } |
| 1035 | | isCRAMDirty = 0; |
| 1021 | smsvdp.cram_dirty = 0; |
| 1036 | 1022 | |
| 1037 | | if ( vdp_mode != 4 && ! IS_GAMEGEAR_VDP ) { |
| 1023 | if ( smsvdp.vdp_mode != 4 && ! IS_GAMEGEAR_VDP ) { |
| 1038 | 1024 | for( i = 0; i < 16; i++ ) { |
| 1039 | | currentPalette[i] = 64+i; |
| 1025 | smsvdp.current_palette[i] = 64+i; |
| 1040 | 1026 | } |
| 1041 | 1027 | return; |
| 1042 | 1028 | } |
| 1043 | 1029 | |
| 1044 | 1030 | if ( IS_GAMEGEAR_VDP ) { |
| 1045 | | if ( ggSmsMode ) { |
| 1031 | if ( smsvdp.gg_sms_mode ) { |
| 1046 | 1032 | for ( i = 0; i < 32; i++ ) { |
| 1047 | | currentPalette[i] = ( ( CRAM[i] & 0x30 ) << 6 ) | ( ( CRAM[i] & 0x0C ) << 4 ) | ( ( CRAM[i] & 0x03 ) << 2 ); |
| 1033 | smsvdp.current_palette[i] = ( ( smsvdp.CRAM[i] & 0x30 ) << 6 ) | ( ( smsvdp.CRAM[i] & 0x0C ) << 4 ) | ( ( smsvdp.CRAM[i] & 0x03 ) << 2 ); |
| 1048 | 1034 | } |
| 1049 | 1035 | } else { |
| 1050 | 1036 | for ( i = 0; i < 32; i++ ) { |
| 1051 | | currentPalette[i] = ( ( CRAM[i*2+1] << 8 ) | CRAM[i*2] ) & 0x0FFF; |
| 1037 | smsvdp.current_palette[i] = ( ( smsvdp.CRAM[i*2+1] << 8 ) | smsvdp.CRAM[i*2] ) & 0x0FFF; |
| 1052 | 1038 | } |
| 1053 | 1039 | } |
| 1054 | 1040 | } else { |
| 1055 | 1041 | for ( i = 0; i < 32; i++ ) { |
| 1056 | | currentPalette[i] = CRAM[i] & 0x3F; |
| 1042 | smsvdp.current_palette[i] = smsvdp.CRAM[i] & 0x3F; |
| 1057 | 1043 | } |
| 1058 | 1044 | } |
| 1059 | 1045 | } |
| r1284 | r1285 | |
| 1061 | 1047 | VIDEO_UPDATE(sms) { |
| 1062 | 1048 | int x, y; |
| 1063 | 1049 | |
| 1064 | | if (prevBitMapSaved) { |
| 1050 | if (smsvdp.prev_bitmap_saved) { |
| 1065 | 1051 | for (y = 0; y < Machine->screen[0].height; y++) { |
| 1066 | 1052 | for (x = 0; x < Machine->screen[0].width; x++) { |
| 1067 | | *BITMAP_ADDR32(bitmap, y, x) = (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(prevBitMap, y, x)) >> 2; |
| 1068 | | logerror("%x %x %x\n", *BITMAP_ADDR32(tmpbitmap, y, x), *BITMAP_ADDR32(prevBitMap, y, x), (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(prevBitMap, y, x)) >> 2); |
| 1053 | *BITMAP_ADDR32(bitmap, y, x) = (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x)) >> 2; |
| 1054 | logerror("%x %x %x\n", *BITMAP_ADDR32(tmpbitmap, y, x), *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x), (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x)) >> 2); |
| 1069 | 1055 | } |
| 1070 | 1056 | } |
| 1071 | 1057 | } else { |
| 1072 | 1058 | copybitmap(bitmap, tmpbitmap, 0, 0, 0, 0, &Machine->screen[0].visarea, TRANSPARENCY_NONE, 0); |
| 1073 | 1059 | } |
| 1074 | | if (!prevBitMapSaved) { |
| 1075 | | copybitmap(prevBitMap, tmpbitmap, 0, 0, 0, 0, &Machine->screen[0].visarea, TRANSPARENCY_NONE, 0); |
| 1076 | | //prevBitMapSaved = 1; |
| 1060 | if (!smsvdp.prev_bitmap_saved) { |
| 1061 | copybitmap(smsvdp.prev_bitmap, tmpbitmap, 0, 0, 0, 0, &Machine->screen[0].visarea, TRANSPARENCY_NONE, 0); |
| 1062 | //smsvdp.prev_bitmap_saved = 1; |
| 1077 | 1063 | } |
| 1078 | 1064 | return 0; |
| 1079 | 1065 | } |