src/mess/video/vdc.c
| r916 | r917 | |
| 25 | 25 | int dvssr_write; /* Set when the DVSSR register has been written to */ |
| 26 | 26 | int physical_width; /* Width of the display */ |
| 27 | 27 | int physical_height; /* Height of the display */ |
| 28 | UINT8 vce_control; /* VCE control register */ |
| 28 | 29 | pair vce_address; /* Current address in the palette */ |
| 29 | 30 | pair vce_data[512]; /* Palette data */ |
| 30 | 31 | UINT16 sprite_ram[64*4]; /* Sprite RAM */ |
| r916 | r917 | |
| 76 | 77 | vdc.curline += 1; |
| 77 | 78 | vdc.current_segment_line += 1; |
| 78 | 79 | vdc.raster_count += 1; |
| 80 | vdc.y_scroll++; |
| 79 | 81 | |
| 80 | 82 | if ( vdc.current_bitmap_line == 0 ) { |
| 81 | 83 | vdc.current_segment = STATE_VSW; |
| r916 | r917 | |
| 217 | 219 | |
| 218 | 220 | void vram_write(offs_t offset, UINT8 data) |
| 219 | 221 | { |
| 220 | | if(offset & 0x10000) |
| 221 | | { |
| 222 | | logerror("Write to VRAM offset %05X\n", offset); |
| 223 | | return; |
| 224 | | } |
| 225 | | else |
| 226 | | { |
| 222 | if(offset & 0x10000) |
| 223 | { |
| 224 | logerror("Write to VRAM offset %05X\n", offset); |
| 225 | return; |
| 226 | } |
| 227 | else |
| 228 | { |
| 227 | 229 | vdc.vram[offset] = data; |
| 228 | 230 | } |
| 229 | 231 | } |
| 230 | 232 | |
| 231 | 233 | UINT8 vram_read(offs_t offset) |
| 232 | 234 | { |
| 233 | | UINT8 temp; |
| 235 | UINT8 temp; |
| 234 | 236 | |
| 235 | | if(offset & 0x10000) |
| 236 | | { |
| 237 | | temp = 0x00; |
| 238 | | } |
| 239 | | else |
| 240 | | { |
| 241 | | temp = vdc.vram[offset]; |
| 242 | | } |
| 237 | if(offset & 0x10000) |
| 238 | { |
| 239 | temp = 0x00; |
| 240 | } |
| 241 | else |
| 242 | { |
| 243 | temp = vdc.vram[offset]; |
| 244 | } |
| 243 | 245 | |
| 244 | | return temp; |
| 246 | return temp; |
| 245 | 247 | } |
| 246 | 248 | |
| 247 | 249 | |
| 248 | 250 | WRITE8_HANDLER ( vdc_w ) |
| 249 | 251 | { |
| 250 | | switch(offset&3) |
| 251 | | { |
| 252 | | case 0x00: /* VDC register select */ |
| 253 | | vdc.vdc_register = (data & 0x1F); |
| 254 | | break; |
| 252 | switch(offset&3) |
| 253 | { |
| 254 | case 0x00: /* VDC register select */ |
| 255 | vdc.vdc_register = (data & 0x1F); |
| 256 | break; |
| 255 | 257 | |
| 256 | | case 0x02: /* VDC data (LSB) */ |
| 257 | | vdc.vdc_data[vdc.vdc_register].b.l = data; |
| 258 | | switch(vdc.vdc_register) |
| 259 | | { |
| 260 | | case VxR: /* LSB of data to write to VRAM */ |
| 261 | | vdc.vdc_latch = data; |
| 262 | | break; |
| 258 | case 0x02: /* VDC data (LSB) */ |
| 259 | vdc.vdc_data[vdc.vdc_register].b.l = data; |
| 260 | switch(vdc.vdc_register) |
| 261 | { |
| 262 | case VxR: /* LSB of data to write to VRAM */ |
| 263 | vdc.vdc_latch = data; |
| 264 | break; |
| 263 | 265 | |
| 264 | 266 | case BYR: |
| 265 | 267 | vdc.y_scroll=vdc.vdc_data[BYR].w; |
| 266 | 268 | break; |
| 267 | 269 | |
| 268 | | case HDR: |
| 269 | | vdc.physical_width = ((data & 0x003F) + 1) << 3; |
| 270 | | break; |
| 270 | case HDR: |
| 271 | vdc.physical_width = ((data & 0x003F) + 1) << 3; |
| 272 | break; |
| 271 | 273 | |
| 272 | | case VDW: |
| 273 | | vdc.physical_height &= 0xFF00; |
| 274 | | vdc.physical_height |= (data & 0xFF); |
| 275 | | vdc.physical_height &= 0x01FF; |
| 276 | | break; |
| 274 | case VDW: |
| 275 | vdc.physical_height &= 0xFF00; |
| 276 | vdc.physical_height |= (data & 0xFF); |
| 277 | vdc.physical_height &= 0x01FF; |
| 278 | break; |
| 277 | 279 | |
| 278 | | case LENR: |
| 279 | | // logerror("LENR LSB = %02X\n", data); |
| 280 | | break; |
| 281 | | case SOUR: |
| 282 | | // logerror("SOUR LSB = %02X\n", data); |
| 283 | | break; |
| 284 | | case DESR: |
| 285 | | // logerror("DESR LSB = %02X\n", data); |
| 286 | | break; |
| 287 | | } |
| 288 | | break; |
| 280 | case LENR: |
| 281 | // logerror("LENR LSB = %02X\n", data); |
| 282 | break; |
| 283 | case SOUR: |
| 284 | // logerror("SOUR LSB = %02X\n", data); |
| 285 | break; |
| 286 | case DESR: |
| 287 | // logerror("DESR LSB = %02X\n", data); |
| 288 | break; |
| 289 | } |
| 290 | break; |
| 289 | 291 | |
| 290 | | case 0x03: /* VDC data (MSB) */ |
| 291 | | vdc.vdc_data[vdc.vdc_register].b.h = data; |
| 292 | | switch(vdc.vdc_register) |
| 293 | | { |
| 294 | | case VxR: /* MSB of data to write to VRAM */ |
| 295 | | //vdc.vdc_data[MAWR].w &= 0x7FFF; |
| 296 | | vram_write(vdc.vdc_data[MAWR].w*2+0, vdc.vdc_latch); |
| 297 | | vram_write(vdc.vdc_data[MAWR].w*2+1, data); |
| 298 | | vdc.vdc_data[MAWR].w += vdc.inc; |
| 299 | | //vdc.vdc_data[MAWR].w &= 0x7FFF; |
| 300 | | //vdc.vdc_latch = 0; |
| 301 | | break; |
| 292 | case 0x03: /* VDC data (MSB) */ |
| 293 | vdc.vdc_data[vdc.vdc_register].b.h = data; |
| 294 | switch(vdc.vdc_register) |
| 295 | { |
| 296 | case VxR: /* MSB of data to write to VRAM */ |
| 297 | vram_write(vdc.vdc_data[MAWR].w*2+0, vdc.vdc_latch); |
| 298 | vram_write(vdc.vdc_data[MAWR].w*2+1, data); |
| 299 | vdc.vdc_data[MAWR].w += vdc.inc; |
| 300 | break; |
| 302 | 301 | |
| 303 | | case CR: |
| 304 | | { |
| 302 | case CR: |
| 303 | { |
| 305 | 304 | static unsigned char inctab[] = {1, 32, 64, 128}; |
| 306 | | vdc.inc = inctab[(data >> 3) & 3]; |
| 305 | vdc.inc = inctab[(data >> 3) & 3]; |
| 307 | 306 | } |
| 308 | | break; |
| 307 | break; |
| 309 | 308 | |
| 310 | | case VDW: |
| 311 | | vdc.physical_height &= 0x00FF; |
| 312 | | vdc.physical_height |= (data << 8); |
| 313 | | vdc.physical_height &= 0x01FF; |
| 314 | | break; |
| 309 | case VDW: |
| 310 | vdc.physical_height &= 0x00FF; |
| 311 | vdc.physical_height |= (data << 8); |
| 312 | vdc.physical_height &= 0x01FF; |
| 313 | break; |
| 315 | 314 | |
| 316 | | case DVSSR: |
| 317 | | /* Force VRAM <> SATB DMA for this frame */ |
| 318 | | vdc.dvssr_write = 1; |
| 319 | | break; |
| 315 | case DVSSR: |
| 316 | /* Force VRAM <> SATB DMA for this frame */ |
| 317 | vdc.dvssr_write = 1; |
| 318 | break; |
| 320 | 319 | |
| 321 | | case BYR: |
| 320 | case BYR: |
| 322 | 321 | vdc.y_scroll=vdc.vdc_data[BYR].w; |
| 323 | 322 | break; |
| 324 | 323 | |
| 325 | | case LENR: |
| 326 | | vdc_do_dma(); |
| 327 | | break; |
| 328 | | case SOUR: |
| 329 | | // logerror("SOUR MSB = %02X\n", data); |
| 330 | | break; |
| 331 | | case DESR: |
| 332 | | // logerror("DESR MSB = %02X\n", data); |
| 333 | | break; |
| 334 | | } |
| 335 | | break; |
| 336 | | } |
| 324 | case LENR: |
| 325 | vdc_do_dma(); |
| 326 | break; |
| 327 | case SOUR: |
| 328 | // logerror("SOUR MSB = %02X\n", data); |
| 329 | break; |
| 330 | case DESR: |
| 331 | // logerror("DESR MSB = %02X\n", data); |
| 332 | break; |
| 333 | } |
| 334 | break; |
| 335 | } |
| 337 | 336 | } |
| 338 | 337 | |
| 339 | 338 | |
| 340 | 339 | READ8_HANDLER ( vdc_r ) |
| 341 | 340 | { |
| 342 | | int temp = 0; |
| 343 | | switch(offset&3) |
| 344 | | { |
| 345 | | case 0x00: |
| 346 | | temp = vdc.status; |
| 347 | | vdc.status &= ~(VDC_VD | VDC_RR | VDC_CR | VDC_OR | VDC_DS); |
| 348 | | cpunum_set_input_line(0,0,CLEAR_LINE); |
| 349 | | break; |
| 341 | int temp = 0; |
| 342 | switch(offset&3) |
| 343 | { |
| 344 | case 0x00: |
| 345 | temp = vdc.status; |
| 346 | vdc.status &= ~(VDC_VD | VDC_RR | VDC_CR | VDC_OR | VDC_DS); |
| 347 | cpunum_set_input_line(0,0,CLEAR_LINE); |
| 348 | break; |
| 350 | 349 | |
| 351 | | case 0x02: |
| 352 | | switch(vdc.vdc_register) |
| 353 | | { |
| 354 | | case VxR: |
| 355 | | temp = vram_read(vdc.vdc_data[MARR].w*2+0); |
| 356 | | break; |
| 357 | | } |
| 358 | | break; |
| 350 | case 0x02: |
| 351 | switch(vdc.vdc_register) |
| 352 | { |
| 353 | case VxR: |
| 354 | temp = vram_read(vdc.vdc_data[MARR].w*2+0); |
| 355 | break; |
| 356 | } |
| 357 | break; |
| 359 | 358 | |
| 360 | | case 0x03: |
| 361 | | switch(vdc.vdc_register) |
| 362 | | { |
| 363 | | case VxR: |
| 364 | | temp = vram_read(vdc.vdc_data[MARR].w*2+1); |
| 365 | | vdc.vdc_data[MARR].w += vdc.inc; |
| 366 | | break; |
| 367 | | } |
| 368 | | break; |
| 369 | | } |
| 370 | | return (temp); |
| 359 | case 0x03: |
| 360 | switch(vdc.vdc_register) |
| 361 | { |
| 362 | case VxR: |
| 363 | temp = vram_read(vdc.vdc_data[MARR].w*2+1); |
| 364 | vdc.vdc_data[MARR].w += vdc.inc; |
| 365 | break; |
| 366 | } |
| 367 | break; |
| 368 | } |
| 369 | return (temp); |
| 371 | 370 | } |
| 372 | 371 | |
| 373 | 372 | |
| 374 | 373 | READ8_HANDLER ( vce_r ) |
| 375 | 374 | { |
| 376 | | int temp = 0; |
| 377 | | switch(offset & 7) |
| 378 | | { |
| 379 | | case 0x04: /* color table data (LSB) */ |
| 380 | | temp = vdc.vce_data[vdc.vce_address.w].b.l; |
| 381 | | break; |
| 375 | int temp = 0xFF; |
| 376 | switch(offset & 7) |
| 377 | { |
| 378 | case 0x04: /* color table data (LSB) */ |
| 379 | temp = vdc.vce_data[vdc.vce_address.w].b.l; |
| 380 | break; |
| 382 | 381 | |
| 383 | | case 0x05: /* color table data (MSB) */ |
| 384 | | temp = vdc.vce_data[vdc.vce_address.w].b.h; |
| 385 | | vdc.vce_address.w = (vdc.vce_address.w + 1) & 0x01FF; |
| 386 | | break; |
| 387 | | } |
| 388 | | return (temp); |
| 382 | case 0x05: /* color table data (MSB) */ |
| 383 | temp = vdc.vce_data[vdc.vce_address.w].b.h; |
| 384 | temp |= 0xFE; |
| 385 | vdc.vce_address.w = (vdc.vce_address.w + 1) & 0x01FF; |
| 386 | break; |
| 387 | } |
| 388 | return (temp); |
| 389 | 389 | } |
| 390 | 390 | |
| 391 | 391 | |
| 392 | 392 | WRITE8_HANDLER ( vce_w ) |
| 393 | 393 | { |
| 394 | | switch(offset & 7) |
| 395 | | { |
| 396 | | case 0x00: /* control reg. */ |
| 397 | | break; |
| 394 | switch(offset & 7) |
| 395 | { |
| 396 | case 0x00: /* control reg. */ |
| 397 | vdc.vce_control = data; |
| 398 | break; |
| 398 | 399 | |
| 399 | | case 0x02: /* color table address (LSB) */ |
| 400 | | vdc.vce_address.b.l = data; |
| 401 | | vdc.vce_address.w &= 0x1FF; |
| 402 | | break; |
| 400 | case 0x02: /* color table address (LSB) */ |
| 401 | vdc.vce_address.b.l = data; |
| 402 | vdc.vce_address.w &= 0x1FF; |
| 403 | break; |
| 403 | 404 | |
| 404 | | case 0x03: /* color table address (MSB) */ |
| 405 | | vdc.vce_address.b.h = data; |
| 406 | | vdc.vce_address.w &= 0x1FF; |
| 407 | | break; |
| 405 | case 0x03: /* color table address (MSB) */ |
| 406 | vdc.vce_address.b.h = data; |
| 407 | vdc.vce_address.w &= 0x1FF; |
| 408 | break; |
| 408 | 409 | |
| 409 | | case 0x04: /* color table data (LSB) */ |
| 410 | | vdc.vce_data[vdc.vce_address.w].b.l = data; |
| 411 | | break; |
| 410 | case 0x04: /* color table data (LSB) */ |
| 411 | vdc.vce_data[vdc.vce_address.w].b.l = data; |
| 412 | /* set color */ |
| 413 | { |
| 414 | int r, g, b; |
| 412 | 415 | |
| 413 | | case 0x05: /* color table data (MSB) */ |
| 414 | | vdc.vce_data[vdc.vce_address.w].b.h = data; |
| 416 | r = ((vdc.vce_data[vdc.vce_address.w].w >> 3) & 7) << 5; |
| 417 | g = ((vdc.vce_data[vdc.vce_address.w].w >> 6) & 7) << 5; |
| 418 | b = ((vdc.vce_data[vdc.vce_address.w].w >> 0) & 7) << 5; |
| 419 | palette_set_color_rgb(Machine, vdc.vce_address.w, r, g, b); |
| 420 | } |
| 421 | break; |
| 415 | 422 | |
| 416 | | /* set color */ |
| 417 | | { |
| 418 | | int /*c,*/ i, r, g, b; |
| 419 | | /*pair f;*/ |
| 423 | case 0x05: /* color table data (MSB) */ |
| 424 | vdc.vce_data[vdc.vce_address.w].b.h = data; |
| 420 | 425 | |
| 421 | | i = vdc.vce_address.w; |
| 422 | | r = ((vdc.vce_data[i].w >> 3) & 7) << 5; |
| 423 | | g = ((vdc.vce_data[i].w >> 6) & 7) << 5; |
| 424 | | b = ((vdc.vce_data[i].w >> 0) & 7) << 5; |
| 425 | | palette_set_color_rgb(Machine, i, r, g, b); |
| 426 | | } |
| 426 | /* set color */ |
| 427 | { |
| 428 | int r, g, b; |
| 427 | 429 | |
| 428 | | /* bump internal address */ |
| 429 | | vdc.vce_address.w = (vdc.vce_address.w + 1) & 0x01FF; |
| 430 | | break; |
| 430 | r = ((vdc.vce_data[vdc.vce_address.w].w >> 3) & 7) << 5; |
| 431 | g = ((vdc.vce_data[vdc.vce_address.w].w >> 6) & 7) << 5; |
| 432 | b = ((vdc.vce_data[vdc.vce_address.w].w >> 0) & 7) << 5; |
| 433 | palette_set_color_rgb(Machine, vdc.vce_address.w, r, g, b); |
| 434 | } |
| 435 | |
| 436 | /* bump internal address */ |
| 437 | vdc.vce_address.w = (vdc.vce_address.w + 1) & 0x01FF; |
| 438 | break; |
| 431 | 439 | } |
| 432 | 440 | } |
| 433 | 441 | |
| r916 | r917 | |
| 539 | 547 | { |
| 540 | 548 | pce_refresh_sprites(bitmap_line, line); |
| 541 | 549 | } |
| 542 | | vdc.y_scroll++; |
| 543 | 550 | } |
| 544 | 551 | |
| 545 | 552 | |
| r916 | r917 | |
| 578 | 585 | |
| 579 | 586 | void pce_refresh_sprites(int bitmap_line, int line) |
| 580 | 587 | { |
| 581 | | static int cgx_table[] = {16, 32}; |
| 582 | | static int cgy_table[] = {16, 32, 64, 64}; |
| 583 | | |
| 584 | | int obj_x, obj_y, obj_i, obj_a; |
| 585 | | int obj_w, obj_h, obj_l, cgypos; |
| 586 | | int hf, vf; |
| 587 | | int cgx, cgy, palette; |
| 588 | | int priority; |
| 589 | | int i, x, c /*, b*/; |
| 590 | | char buf[16]; |
| 591 | | |
| 588 | int i; |
| 592 | 589 | UINT8 sprites_drawn=0; |
| 593 | 590 | UINT16 *line_buffer= BITMAP_ADDR16( vdc.bmp, bitmap_line, 86 ); |
| 594 | | |
| 595 | 591 | /* 0 -> no sprite pixels drawn, otherwise is sprite #+1 */ |
| 596 | 592 | UINT8 drawn[VDC_WPF]; |
| 597 | 593 | |
| 598 | | //clear our sprite-to-sprite clipping buffer. |
| 594 | /* clear our sprite-to-sprite clipping buffer. */ |
| 599 | 595 | memset(drawn, 0, VDC_WPF); |
| 600 | 596 | /* count up: Highest priority is Sprite 0 */ |
| 601 | 597 | for(i=0; i<64; i++) |
| 602 | 598 | { |
| 603 | | obj_y = (vdc.sprite_ram[(i<<2)+0] & 0x03FF) - 64; |
| 604 | | obj_x = (vdc.sprite_ram[(i<<2)+1] & 0x03FF) - 32; |
| 599 | static const int cgy_table[] = {16, 32, 64, 64}; |
| 605 | 600 | |
| 606 | | if ( vdc.vdc_data[MWR].w & 0x0040 ) { |
| 607 | | obj_y -= ( vdc.vdc_data[BYR].w & 0x1FF ); |
| 608 | | } |
| 601 | int obj_y = (vdc.sprite_ram[(i<<2)+0] & 0x03FF) - 64; |
| 602 | int obj_x = (vdc.sprite_ram[(i<<2)+1] & 0x03FF) - 32; |
| 603 | int obj_i = (vdc.sprite_ram[(i<<2)+2] & 0x07FE); |
| 604 | int obj_a = (vdc.sprite_ram[(i<<2)+3]); |
| 605 | int cgx = (obj_a >> 8) & 1; /* sprite width */ |
| 606 | int cgy = (obj_a >> 12) & 3; /* sprite height */ |
| 607 | int hf = (obj_a >> 11) & 1; /* horizontal flip */ |
| 608 | int vf = (obj_a >> 15) & 1; /* vertical flip */ |
| 609 | int palette = (obj_a & 0x000F); |
| 610 | int priority = (obj_a >> 7) & 1; |
| 611 | int obj_h = cgy_table[cgy]; |
| 612 | int obj_l = (line - obj_y); |
| 613 | int cgypos; |
| 614 | char buf[16]; |
| 609 | 615 | |
| 610 | 616 | if ((obj_y == -64) || (obj_y > line)) continue; |
| 611 | 617 | if ((obj_x == -32) || (obj_x > vdc.physical_width)) continue; |
| 612 | 618 | |
| 619 | /* no need to draw an object that's ABOVE where we are. */ |
| 620 | if((obj_y + obj_h)<line) continue; |
| 613 | 621 | |
| 614 | | obj_a = (vdc.sprite_ram[(i<<2)+3]); |
| 622 | /* If CGX is set, bit 0 of sprite pattern index is forced to 0 */ |
| 623 | if ( cgx ) |
| 624 | obj_i &= ~1; |
| 615 | 625 | |
| 616 | | // if ((obj_a & 0x80) == 0) continue; |
| 626 | /* If CGY is set to 1, bit 1 of the sprite pattern index is forced to 0. */ |
| 627 | if ( cgy & 1 ) |
| 628 | obj_i &= ~2; |
| 617 | 629 | |
| 618 | | cgx = (obj_a >> 8) & 1; /* sprite width */ |
| 619 | | cgy = (obj_a >> 12) & 3; /* sprite height */ |
| 620 | | hf = (obj_a >> 11) & 1; /* horizontal flip */ |
| 621 | | vf = (obj_a >> 15) & 1; /* vertical flip */ |
| 622 | | palette = (obj_a & 0x000F); |
| 623 | | priority = (obj_a >> 7) & 1; /* why was this not emulated? */ |
| 630 | /* If CGY is set to 2 or 3, bit 1 and 2 of the sprite pattern index are forced to 0. */ |
| 631 | if ( cgy & 2 ) |
| 632 | obj_i &= ~3; |
| 624 | 633 | |
| 625 | | obj_i = (vdc.sprite_ram[(i<<2)+2] & 0x07FE); |
| 626 | | |
| 627 | | obj_w = cgx_table[cgx]; |
| 628 | | obj_h = cgy_table[cgy]; |
| 629 | | obj_l = (line - obj_y); |
| 630 | | |
| 631 | | //no need to draw an object that's ABOVE where we are. |
| 632 | | if((obj_y + obj_h)<line) continue; |
| 633 | | |
| 634 | 634 | sprites_drawn++; |
| 635 | 635 | if(sprites_drawn > 16) |
| 636 | 636 | { |
| r916 | r917 | |
| 647 | 647 | |
| 648 | 648 | if(cgx == 0) |
| 649 | 649 | { |
| 650 | int x; |
| 650 | 651 | int pixel_x = ( ( obj_x * 512 ) / vdc.physical_width ); |
| 651 | 652 | |
| 652 | 653 | conv_obj(obj_i + (cgypos << 2), obj_l, hf, vf, buf); |
| r916 | r917 | |
| 655 | 656 | { |
| 656 | 657 | if(((obj_x + x)<(vdc.physical_width))&&((obj_x + x)>=0)) |
| 657 | 658 | { |
| 658 | | c = buf[x]; |
| 659 | | if(c) |
| 659 | if ( buf[x] ) |
| 660 | 660 | { |
| 661 | 661 | if(!drawn[obj_x+x]) |
| 662 | 662 | { |
| 663 | 663 | if(priority || (line_buffer[pixel_x] == Machine->pens[0])) { |
| 664 | | line_buffer[pixel_x] = Machine->pens[0x100 + (palette << 4) + c]; |
| 664 | line_buffer[pixel_x] = Machine->pens[0x100 + (palette << 4) + buf[x]]; |
| 665 | 665 | if ( vdc.physical_width != 512 ) { |
| 666 | 666 | if ( pixel_x + 1 < ( ( ( obj_x + x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 667 | | line_buffer[pixel_x + 1] = Machine->pens[0x100 + (palette << 4) + c]; |
| 667 | line_buffer[pixel_x + 1] = Machine->pens[0x100 + (palette << 4) + buf[x]]; |
| 668 | 668 | } |
| 669 | 669 | } |
| 670 | 670 | drawn[obj_x+x]=i+1; |
| r916 | r917 | |
| 688 | 688 | } |
| 689 | 689 | else |
| 690 | 690 | { |
| 691 | int x; |
| 691 | 692 | int pixel_x = ( ( obj_x * 512 ) / vdc.physical_width ); |
| 692 | 693 | |
| 693 | 694 | conv_obj(obj_i + (cgypos << 2) + (hf ? 2 : 0), obj_l, hf, vf, buf); |
| r916 | r917 | |
| 696 | 697 | { |
| 697 | 698 | if(((obj_x + x)<(vdc.physical_width))&&((obj_x + x)>=0)) |
| 698 | 699 | { |
| 699 | | c = buf[x]; |
| 700 | | if(c) |
| 700 | if ( buf[x] ) |
| 701 | 701 | { |
| 702 | 702 | if(!drawn[obj_x+x]) |
| 703 | 703 | { |
| 704 | 704 | if(priority || (line_buffer[pixel_x] == Machine->pens[0])) { |
| 705 | | line_buffer[pixel_x] = Machine->pens[0x100 + (palette << 4) + c]; |
| 705 | line_buffer[pixel_x] = Machine->pens[0x100 + (palette << 4) + buf[x]]; |
| 706 | 706 | if ( vdc.physical_width != 512 ) { |
| 707 | 707 | if ( pixel_x + 1 < ( ( ( obj_x + x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 708 | | line_buffer[pixel_x + 1] = Machine->pens[0x100 + (palette << 4) + c]; |
| 708 | line_buffer[pixel_x + 1] = Machine->pens[0x100 + (palette << 4) + buf[x]]; |
| 709 | 709 | } |
| 710 | 710 | } |
| 711 | 711 | drawn[obj_x + x]=i+1; |
| r916 | r917 | |
| 734 | 734 | { |
| 735 | 735 | if(((obj_x + 0x10 + x)<(vdc.physical_width))&&((obj_x + 0x10 + x)>=0)) |
| 736 | 736 | { |
| 737 | | c = buf[x]; |
| 738 | | if(c) |
| 737 | if ( buf[x] ) |
| 739 | 738 | { |
| 740 | 739 | if(!drawn[obj_x+0x10+x]) |
| 741 | 740 | { |
| 742 | 741 | if(priority || (line_buffer[pixel_x] == Machine->pens[0])) { |
| 743 | | line_buffer[pixel_x] = Machine->pens[0x100 + (palette << 4) + c]; |
| 742 | line_buffer[pixel_x] = Machine->pens[0x100 + (palette << 4) + buf[x]]; |
| 744 | 743 | if ( vdc.physical_width != 512 ) { |
| 745 | 744 | if ( pixel_x + 1 < ( ( ( obj_x + x + 17 ) * 512 ) / vdc.physical_width ) ) { |
| 746 | | line_buffer[pixel_x + 1] = Machine->pens[0x100 + (palette << 4) + c]; |
| 745 | line_buffer[pixel_x + 1] = Machine->pens[0x100 + (palette << 4) + buf[x]]; |
| 747 | 746 | } |
| 748 | 747 | } |
| 749 | 748 | drawn[obj_x + 0x10 + x]=i+1; |