src/mess/video/cbmb.c
| r2028 | r2029 | |
| 75 | 75 | |
| 76 | 76 | for( i = 0; i < x_count; i++ ) { |
| 77 | 77 | if ( i == cursor_x ) { |
| 78 | | plot_box( bitmap, device->machine->gfx[cbmb_font]->width * i, y, device->machine->gfx[cbmb_font]->width, 1, device->machine->pens[1] ); |
| 78 | plot_box( bitmap, device->machine->gfx[cbmb_font]->width * i, y, device->machine->gfx[cbmb_font]->width, 1, 1 ); |
| 79 | 79 | } else { |
| 80 | 80 | drawgfx( bitmap, device->machine->gfx[cbmb_font], videoram[(ma+i )& 0x7ff], 0, 0, 0, device->machine->gfx[cbmb_font]->width * i, y-ra, cliprect, TRANSPARENCY_NONE, 0 ); |
| 81 | 81 | } |
| r2028 | r2029 | |
| 88 | 88 | |
| 89 | 89 | for( i = 0; i < x_count; i++ ) { |
| 90 | 90 | if ( i == cursor_x ) { |
| 91 | | plot_box( bitmap, device->machine->gfx[cbmb_font]->width * i, y, device->machine->gfx[cbmb_font]->width, 1, device->machine->pens[1] ); |
| 91 | plot_box( bitmap, device->machine->gfx[cbmb_font]->width * i, y, device->machine->gfx[cbmb_font]->width, 1, 1 ); |
| 92 | 92 | } else { |
| 93 | 93 | drawgfx( bitmap, device->machine->gfx[cbmb_font], videoram[(ma+i) & 0x7ff], 0, 0, 0, device->machine->gfx[cbmb_font]->width * i, y-ra, cliprect, TRANSPARENCY_NONE, 0 ); |
| 94 | 94 | } |
src/mess/video/arcadia.c
| r2028 | r2029 | |
| 655 | 655 | int c; |
| 656 | 656 | if (color&0x40) c=arcadia_video.reg.d.pal[1]; |
| 657 | 657 | else c=arcadia_video.reg.d.pal[0]; |
| 658 | | /*imachine->gfx[0]->colortable[1]=machine->pens[(c>>3)&7];*/ |
| 658 | /*imachine->gfx[0]->colortable[1]=(c>>3)&7;*/ |
| 659 | 659 | |
| 660 | 660 | if (color&0x80) c=arcadia_video.reg.d.pal[1]; |
| 661 | 661 | else c=arcadia_video.reg.d.pal[0]; |
| 662 | | /*machine->gfx[0]->colortable[0]=machine->pens[c&7];*/ |
| 662 | /*machine->gfx[0]->colortable[0]=c&7;*/ |
| 663 | 663 | |
| 664 | 664 | } else { |
| 665 | 665 | /*machine->gfx[0]->colortable[1]= |
| 666 | | machine->pens[((arcadia_video.reg.d.pal[1]>>3)&1)|((color>>5)&6)];*/ |
| 666 | ((arcadia_video.reg.d.pal[1]>>3)&1)|((color>>5)&6);*/ |
| 667 | 667 | } |
| 668 | 668 | |
| 669 | 669 | if (arcadia_video.doublescan) { |
| r2028 | r2029 | |
| 763 | 763 | * to survive the 0.118u5 transition */ |
| 764 | 764 | switch (i) { |
| 765 | 765 | case 0: |
| 766 | | /*machine->gfx[0]->colortable[1]=machine->pens[(arcadia_video.reg.d.pal[3]>>3)&7];*/ |
| 766 | /*machine->gfx[0]->colortable[1]=(arcadia_video.reg.d.pal[3]>>3)&7;*/ |
| 767 | 767 | doublescan=arcadia_video.reg.d.pal[3]&0x80?FALSE:TRUE; |
| 768 | 768 | break; |
| 769 | 769 | case 1: |
| 770 | | /*machine->gfx[0]->colortable[1]=machine->pens[arcadia_video.reg.d.pal[3]&7];*/ |
| 770 | /*machine->gfx[0]->colortable[1]=arcadia_video.reg.d.pal[3]&7;*/ |
| 771 | 771 | doublescan=arcadia_video.reg.d.pal[3]&0x40?FALSE:TRUE; |
| 772 | 772 | break; |
| 773 | 773 | case 2: |
| 774 | | /*machine->gfx[0]->colortable[1]=machine->pens[(arcadia_video.reg.d.pal[2]>>3)&7];*/ |
| 774 | /*machine->gfx[0]->colortable[1]=(arcadia_video.reg.d.pal[2]>>3)&7;*/ |
| 775 | 775 | doublescan=arcadia_video.reg.d.pal[2]&0x80?FALSE:TRUE; |
| 776 | 776 | break; |
| 777 | 777 | case 3: |
| 778 | | /*machine->gfx[0]->colortable[1]=machine->pens[arcadia_video.reg.d.pal[2]&7];*/ |
| 778 | /*machine->gfx[0]->colortable[1]=arcadia_video.reg.d.pal[2]&7;*/ |
| 779 | 779 | doublescan=arcadia_video.reg.d.pal[2]&0x40?FALSE:TRUE; |
| 780 | 780 | break; |
| 781 | 781 | } |
| r2028 | r2029 | |
| 828 | 828 | /* 7-Sep-2007 - whomever wrote this crap code was dynamically remapping |
| 829 | 829 | * the color table, a vile gross hack. Doesn't look like this is going |
| 830 | 830 | * to survive the 0.118u5 transition */ |
| 831 | | /*machine->gfx[0]->colortable[0]=machine->pens[arcadia_video.reg.d.pal[1]&7];*/ |
| 831 | /*machine->gfx[0]->colortable[0]=arcadia_video.reg.d.pal[1]&7;*/ |
| 832 | 832 | |
| 833 | 833 | if (arcadia_video.line<arcadia_video.ypos) |
| 834 | 834 | { |
src/mess/video/a7800.c
| r2028 | r2029 | |
| 475 | 475 | switch (offset) |
| 476 | 476 | { |
| 477 | 477 | case 0x00: |
| 478 | | maria_backcolor = machine->pens[data]; |
| 478 | maria_backcolor = data; |
| 479 | 479 | // 20030621 ericball added maria_palette[pal][0] to make kanagroo mode easier |
| 480 | 480 | maria_palette[0][0]=maria_backcolor; |
| 481 | 481 | maria_palette[1][0]=maria_backcolor; |
| r2028 | r2029 | |
| 487 | 487 | maria_palette[7][0]=maria_backcolor; |
| 488 | 488 | break; |
| 489 | 489 | case 0x01: |
| 490 | | maria_palette[0][1] = machine->pens[data]; |
| 490 | maria_palette[0][1] = data; |
| 491 | 491 | break; |
| 492 | 492 | case 0x02: |
| 493 | | maria_palette[0][2] = machine->pens[data]; |
| 493 | maria_palette[0][2] = data; |
| 494 | 494 | break; |
| 495 | 495 | case 0x03: |
| 496 | | maria_palette[0][3] = machine->pens[data]; |
| 496 | maria_palette[0][3] = data; |
| 497 | 497 | break; |
| 498 | 498 | case 0x04: |
| 499 | 499 | cpu_spinuntil_trigger(TRIGGER_HSYNC); |
| r2028 | r2029 | |
| 501 | 501 | break; |
| 502 | 502 | |
| 503 | 503 | case 0x05: |
| 504 | | maria_palette[1][1] = machine->pens[data]; |
| 504 | maria_palette[1][1] = data; |
| 505 | 505 | break; |
| 506 | 506 | case 0x06: |
| 507 | | maria_palette[1][2] = machine->pens[data]; |
| 507 | maria_palette[1][2] = data; |
| 508 | 508 | break; |
| 509 | 509 | case 0x07: |
| 510 | | maria_palette[1][3] = machine->pens[data]; |
| 510 | maria_palette[1][3] = data; |
| 511 | 511 | break; |
| 512 | 512 | |
| 513 | 513 | case 0x09: |
| 514 | | maria_palette[2][1] = machine->pens[data]; |
| 514 | maria_palette[2][1] = data; |
| 515 | 515 | break; |
| 516 | 516 | case 0x0A: |
| 517 | | maria_palette[2][2] = machine->pens[data]; |
| 517 | maria_palette[2][2] = data; |
| 518 | 518 | break; |
| 519 | 519 | case 0x0B: |
| 520 | | maria_palette[2][3] = machine->pens[data]; |
| 520 | maria_palette[2][3] = data; |
| 521 | 521 | break; |
| 522 | 522 | |
| 523 | 523 | case 0x0D: |
| 524 | | maria_palette[3][1] = machine->pens[data]; |
| 524 | maria_palette[3][1] = data; |
| 525 | 525 | break; |
| 526 | 526 | case 0x0E: |
| 527 | | maria_palette[3][2] = machine->pens[data]; |
| 527 | maria_palette[3][2] = data; |
| 528 | 528 | break; |
| 529 | 529 | case 0x0F: |
| 530 | | maria_palette[3][3] = machine->pens[data]; |
| 530 | maria_palette[3][3] = data; |
| 531 | 531 | break; |
| 532 | 532 | |
| 533 | 533 | case 0x11: |
| 534 | | maria_palette[4][1] = machine->pens[data]; |
| 534 | maria_palette[4][1] = data; |
| 535 | 535 | break; |
| 536 | 536 | case 0x12: |
| 537 | | maria_palette[4][2] = machine->pens[data]; |
| 537 | maria_palette[4][2] = data; |
| 538 | 538 | break; |
| 539 | 539 | case 0x13: |
| 540 | | maria_palette[4][3] = machine->pens[data]; |
| 540 | maria_palette[4][3] = data; |
| 541 | 541 | break; |
| 542 | 542 | case 0x14: |
| 543 | 543 | maria_charbase = (data << 8); |
| 544 | 544 | break; |
| 545 | 545 | case 0x15: |
| 546 | | maria_palette[5][1] = machine->pens[data]; |
| 546 | maria_palette[5][1] = data; |
| 547 | 547 | break; |
| 548 | 548 | case 0x16: |
| 549 | | maria_palette[5][2] = machine->pens[data]; |
| 549 | maria_palette[5][2] = data; |
| 550 | 550 | break; |
| 551 | 551 | case 0x17: |
| 552 | | maria_palette[5][3] = machine->pens[data]; |
| 552 | maria_palette[5][3] = data; |
| 553 | 553 | break; |
| 554 | 554 | |
| 555 | 555 | case 0x19: |
| 556 | | maria_palette[6][1] = machine->pens[data]; |
| 556 | maria_palette[6][1] = data; |
| 557 | 557 | break; |
| 558 | 558 | case 0x1A: |
| 559 | | maria_palette[6][2] = machine->pens[data]; |
| 559 | maria_palette[6][2] = data; |
| 560 | 560 | break; |
| 561 | 561 | case 0x1B: |
| 562 | | maria_palette[6][3] = machine->pens[data]; |
| 562 | maria_palette[6][3] = data; |
| 563 | 563 | break; |
| 564 | 564 | |
| 565 | 565 | case 0x1C: |
| r2028 | r2029 | |
| 585 | 585 | |
| 586 | 586 | break; |
| 587 | 587 | case 0x1D: |
| 588 | | maria_palette[7][1] = machine->pens[data]; |
| 588 | maria_palette[7][1] = data; |
| 589 | 589 | break; |
| 590 | 590 | case 0x1E: |
| 591 | | maria_palette[7][2] = machine->pens[data]; |
| 591 | maria_palette[7][2] = data; |
| 592 | 592 | break; |
| 593 | 593 | case 0x1F: |
| 594 | | maria_palette[7][3] = machine->pens[data]; |
| 594 | maria_palette[7][3] = data; |
| 595 | 595 | break; |
| 596 | 596 | } |
| 597 | 597 | ROM[ 0x20 + offset ] = data; |
src/mess/video/amstrad.c
| r2028 | r2029 | |
| 76 | 76 | static int display_y; |
| 77 | 77 | static int display_update; // flag to get location at first DE |
| 78 | 78 | |
| 79 | | /* this contains the colours in Machine->pens form.*/ |
| 79 | /* this contains the colours in machine->pens form.*/ |
| 80 | 80 | /* this is updated from the eventlist and reflects the current state |
| 81 | 81 | of the render colours - these may be different to the current colour palette values */ |
| 82 | 82 | /* colours can be changed at any time and will take effect immediatly */ |
| r2028 | r2029 | |
| 335 | 335 | } |
| 336 | 336 | } |
| 337 | 337 | /* Set the new colour from the GateArray */ |
| 338 | | void amstrad_vh_update_colour(running_machine *machine, int PenIndex, int hw_colour_index) |
| 338 | void amstrad_vh_update_colour(int PenIndex, int hw_colour_index) |
| 339 | 339 | { |
| 340 | 340 | int val; |
| 341 | 341 | /* int cpu_cycles = ((cycles_currently_ran()>>2)-1) & 63; |
| 342 | 342 | |
| 343 | | logerror("color is changed(%d,%d) = %d\n",PenIndex, cpu_cycles, machine->pens[hw_colour_index]); |
| 343 | logerror("color is changed(%d,%d) = %d\n",PenIndex, cpu_cycles, hw_colour_index); |
| 344 | 344 | amstrad_GateArray_colours_ischanged++; |
| 345 | | amstrad_GateArray_changed_colours[cpu_cycles][PenIndex] = machine->pens[hw_colour_index]; |
| 345 | amstrad_GateArray_changed_colours[cpu_cycles][PenIndex] = hw_colour_index; |
| 346 | 346 | */ |
| 347 | | amstrad_GateArray_render_colours[PenIndex] = machine->pens[hw_colour_index]; |
| 347 | amstrad_GateArray_render_colours[PenIndex] = hw_colour_index; |
| 348 | 348 | if(amstrad_system_type != 0) |
| 349 | 349 | { // CPC+/GX4000 - normal palette changes through the Gate Array also makes the corresponding change in the ASIC palette |
| 350 | 350 | val = (amstrad_palette[hw_colour_index] & 0xf00000) >> 16; // red |
| r2028 | r2029 | |
| 355 | 355 | } |
| 356 | 356 | } |
| 357 | 357 | |
| 358 | | void aleste_vh_update_colour(running_machine *machine, int PenIndex, int hw_colour_index) |
| 358 | void aleste_vh_update_colour(int PenIndex, int hw_colour_index) |
| 359 | 359 | { |
| 360 | 360 | /* int cpu_cycles = ((cycles_currently_ran()>>2)-1) & 63; |
| 361 | 361 | |
| 362 | | logerror("color is changed(%d,%d) = %d\n",PenIndex, cpu_cycles, machine->pens[hw_colour_index]); |
| 362 | logerror("color is changed(%d,%d) = %d\n",PenIndex, cpu_cycles, hw_colour_index); |
| 363 | 363 | amstrad_GateArray_colours_ischanged++; |
| 364 | | amstrad_GateArray_changed_colours[cpu_cycles][PenIndex] = machine->pens[hw_colour_index]; |
| 364 | amstrad_GateArray_changed_colours[cpu_cycles][PenIndex] = hw_colour_index; |
| 365 | 365 | */ |
| 366 | | amstrad_GateArray_render_colours[PenIndex] = machine->pens[hw_colour_index+32]; |
| 366 | amstrad_GateArray_render_colours[PenIndex] = hw_colour_index+32; |
| 367 | 367 | } |
| 368 | 368 | |
| 369 | 369 | /* Set the new screen mode (0,1,2,4) from the GateArray */ |
src/mess/video/coupe.c
| r2028 | r2029 | |
| 14 | 14 | |
| 15 | 15 | unsigned char *sam_screen; |
| 16 | 16 | |
| 17 | | void drawMode4_line(running_machine *machine, bitmap_t *bitmap,int y) |
| 17 | void drawMode4_line(bitmap_t *bitmap,int y) |
| 18 | 18 | { |
| 19 | 19 | int x; |
| 20 | 20 | unsigned char tmp=0; |
| r2028 | r2029 | |
| 25 | 25 | #ifdef MONO |
| 26 | 26 | if (tmp>>4) |
| 27 | 27 | { |
| 28 | | plot_pixel(bitmap, x*2, y, machine->pens[127]); |
| 29 | | plot_pixel(bitmap, x*2+1, y, machine->pens[127]); |
| 28 | plot_pixel(bitmap, x*2, y, 127); |
| 29 | plot_pixel(bitmap, x*2+1, y, 127); |
| 30 | 30 | } |
| 31 | 31 | else |
| 32 | 32 | { |
| 33 | | plot_pixel(bitmap, x*2, y, machine->pens[0]); |
| 34 | | plot_pixel(bitmap, x*2+1, y, machine->pens[0]); |
| 33 | plot_pixel(bitmap, x*2, y, 0); |
| 34 | plot_pixel(bitmap, x*2+1, y, 0); |
| 35 | 35 | } |
| 36 | 36 | x++; |
| 37 | 37 | if (tmp&0x0F) |
| 38 | 38 | { |
| 39 | | plot_pixel(bitmap, x*2, y, machine->pens[127]); |
| 40 | | plot_pixel(bitmap, x*2+1, y, machine->pens[127]); |
| 39 | plot_pixel(bitmap, x*2, y, 127); |
| 40 | plot_pixel(bitmap, x*2+1, y, 127); |
| 41 | 41 | } |
| 42 | 42 | else |
| 43 | 43 | { |
| 44 | | plot_pixel(bitmap, x*2, y, machine->pens[0]); |
| 45 | | plot_pixel(bitmap, x*2+1, y, machine->pens[0]); |
| 44 | plot_pixel(bitmap, x*2, y, 0); |
| 45 | plot_pixel(bitmap, x*2+1, y, 0); |
| 46 | 46 | } |
| 47 | 47 | x++; |
| 48 | 48 | #else |
| 49 | | *BITMAP_ADDR16(bitmap, y, x*2+0) = machine->pens[CLUT[tmp>>4]]; |
| 50 | | *BITMAP_ADDR16(bitmap, y, x*2+1) = machine->pens[CLUT[tmp>>4]]; |
| 49 | *BITMAP_ADDR16(bitmap, y, x*2+0) = CLUT[tmp>>4]; |
| 50 | *BITMAP_ADDR16(bitmap, y, x*2+1) = CLUT[tmp>>4]; |
| 51 | 51 | x++; |
| 52 | | *BITMAP_ADDR16(bitmap, y, x*2+0) = machine->pens[CLUT[tmp&0x0F]]; |
| 53 | | *BITMAP_ADDR16(bitmap, y, x*2+1) = machine->pens[CLUT[tmp&0x0F]]; |
| 52 | *BITMAP_ADDR16(bitmap, y, x*2+0) = CLUT[tmp&0x0F]; |
| 53 | *BITMAP_ADDR16(bitmap, y, x*2+1) = CLUT[tmp&0x0F]; |
| 54 | 54 | x++; |
| 55 | 55 | #endif |
| 56 | 56 | } |
| 57 | 57 | } |
| 58 | 58 | |
| 59 | | void drawMode3_line(running_machine *machine, bitmap_t *bitmap,int y) |
| 59 | void drawMode3_line(bitmap_t *bitmap,int y) |
| 60 | 60 | { |
| 61 | 61 | int x; |
| 62 | 62 | unsigned char tmp=0; |
| r2028 | r2029 | |
| 66 | 66 | tmp=*(sam_screen + (x/4) + (y*128)); |
| 67 | 67 | #ifdef MONO |
| 68 | 68 | if (tmp>>6) |
| 69 | | plot_pixel(bitmap,x,y,machine->pens[127]); |
| 69 | plot_pixel(bitmap,x,y,127); |
| 70 | 70 | else |
| 71 | | plot_pixel(bitmap,x,y,machine->pens[0]); |
| 71 | plot_pixel(bitmap,x,y,0); |
| 72 | 72 | x++; |
| 73 | 73 | if ((tmp>>4)&0x03) |
| 74 | | plot_pixel(bitmap,x,y,machine->pens[127]); |
| 74 | plot_pixel(bitmap,x,y,127); |
| 75 | 75 | else |
| 76 | | plot_pixel(bitmap,x,y,machine->pens[0]); |
| 76 | plot_pixel(bitmap,x,y,0); |
| 77 | 77 | x++; |
| 78 | 78 | if ((tmp>>2)&0x03) |
| 79 | | plot_pixel(bitmap,x,y,machine->pens[127]); |
| 79 | plot_pixel(bitmap,x,y,127); |
| 80 | 80 | else |
| 81 | | plot_pixel(bitmap,x,y,machine->pens[0]); |
| 81 | plot_pixel(bitmap,x,y,0); |
| 82 | 82 | x++; |
| 83 | 83 | if (tmp&0x03) |
| 84 | | plot_pixel(bitmap,x,y,machine->pens[127]); |
| 84 | plot_pixel(bitmap,x,y,127); |
| 85 | 85 | else |
| 86 | | plot_pixel(bitmap,x,y,machine->pens[0]); |
| 86 | plot_pixel(bitmap,x,y,0); |
| 87 | 87 | x++; |
| 88 | 88 | #else |
| 89 | | *BITMAP_ADDR16(bitmap, y, x) = machine->pens[CLUT[tmp>>6]]; |
| 89 | *BITMAP_ADDR16(bitmap, y, x) = CLUT[tmp>>6]; |
| 90 | 90 | x++; |
| 91 | | *BITMAP_ADDR16(bitmap, y, x) = machine->pens[CLUT[(tmp>>4)&0x03]]; |
| 91 | *BITMAP_ADDR16(bitmap, y, x) = CLUT[(tmp>>4)&0x03]; |
| 92 | 92 | x++; |
| 93 | | *BITMAP_ADDR16(bitmap, y, x) = machine->pens[CLUT[(tmp>>2)&0x03]]; |
| 93 | *BITMAP_ADDR16(bitmap, y, x) = CLUT[(tmp>>2)&0x03]; |
| 94 | 94 | x++; |
| 95 | | *BITMAP_ADDR16(bitmap, y, x) = machine->pens[CLUT[tmp&0x03]]; |
| 95 | *BITMAP_ADDR16(bitmap, y, x) = CLUT[tmp&0x03]; |
| 96 | 96 | x++; |
| 97 | 97 | #endif |
| 98 | 98 | } |
| 99 | 99 | } |
| 100 | 100 | |
| 101 | | void drawMode2_line(running_machine *machine, bitmap_t *bitmap,int y) |
| 101 | void drawMode2_line(bitmap_t *bitmap,int y) |
| 102 | 102 | { |
| 103 | 103 | int x,b,scrx; |
| 104 | 104 | unsigned char tmp=0; |
| r2028 | r2029 | |
| 122 | 122 | |
| 123 | 123 | for (b=0x80;b!=0;b>>=1) |
| 124 | 124 | { |
| 125 | | *BITMAP_ADDR16(bitmap, y, scrx++) = (tmp&b) ? machine->pens[ink] : machine->pens[pap]; |
| 126 | | *BITMAP_ADDR16(bitmap, y, scrx++) = (tmp&b) ? machine->pens[ink] : machine->pens[pap]; |
| 125 | *BITMAP_ADDR16(bitmap, y, scrx++) = (tmp&b) ? ink : pap; |
| 126 | *BITMAP_ADDR16(bitmap, y, scrx++) = (tmp&b) ? ink : pap; |
| 127 | 127 | } |
| 128 | 128 | } |
| 129 | 129 | } |
| 130 | 130 | |
| 131 | | void drawMode1_line(running_machine *machine, bitmap_t *bitmap,int y) |
| 131 | void drawMode1_line(bitmap_t *bitmap,int y) |
| 132 | 132 | { |
| 133 | 133 | int x,b,scrx,scry; |
| 134 | 134 | unsigned char tmp=0; |
| r2028 | r2029 | |
| 152 | 152 | attr++; |
| 153 | 153 | for (b=0x80;b!=0;b>>=1) |
| 154 | 154 | { |
| 155 | | *BITMAP_ADDR16(bitmap, scry, scrx++) = (tmp&b) ? machine->pens[ink] : machine->pens[pap]; |
| 156 | | *BITMAP_ADDR16(bitmap, scry, scrx++) = (tmp&b) ? machine->pens[ink] : machine->pens[pap]; |
| 155 | *BITMAP_ADDR16(bitmap, scry, scrx++) = (tmp&b) ? ink : pap; |
| 156 | *BITMAP_ADDR16(bitmap, scry, scrx++) = (tmp&b) ? ink : pap; |
| 157 | 157 | } |
| 158 | 158 | } |
| 159 | 159 | } |
src/mess/video/bbc.c
| r2028 | r2029 | |
| 14 | 14 | #include "saa505x.h" |
| 15 | 15 | |
| 16 | 16 | |
| 17 | | static void BBC_draw_hi_res(running_machine *machine); |
| 17 | static void BBC_draw_hi_res(running_machine* machine); |
| 18 | 18 | static void BBC_draw_teletext(running_machine *machine); |
| 19 | 19 | |
| 20 | | static void (*draw_function)(running_machine *machine); |
| 20 | static void (*draw_function)(running_machine* machine); |
| 21 | 21 | |
| 22 | 22 | static void BBC_draw_RGB_in(running_machine *machine, int offset,int data); |
| 23 | 23 | |
| r2028 | r2029 | |
| 359 | 359 | |
| 360 | 360 | // This is the actual output of the Video ULA this fuction does all the output to the screen in the BBC emulator |
| 361 | 361 | |
| 362 | | static void BBC_ula_drawpixel(running_machine *machine, int col,int number_of_pixels) |
| 362 | static void BBC_ula_drawpixel(int col,int number_of_pixels) |
| 363 | 363 | { |
| 364 | 364 | int pixel_count; |
| 365 | 365 | int pixel_temp; |
| 366 | 366 | if ((BBC_display>=BBC_display_left) && ((BBC_display+number_of_pixels)<BBC_display_right)) |
| 367 | 367 | { |
| 368 | 368 | |
| 369 | | pixel_temp=machine->pens[col^cursor_state]; |
| 369 | pixel_temp=col^cursor_state; |
| 370 | 370 | for(pixel_count=0;pixel_count<number_of_pixels;pixel_count++) |
| 371 | 371 | { |
| 372 | 372 | *(BBC_display++) = pixel_temp; |
| r2028 | r2029 | |
| 401 | 401 | |
| 402 | 402 | for(sc1=0;sc1<pixels_per_byte;sc1++) |
| 403 | 403 | { |
| 404 | | BBC_ula_drawpixel(machine, videoULA_pallet_lookup[pixel_bits[i]],emulation_pixels_per_real_pixel); |
| 404 | BBC_ula_drawpixel(videoULA_pallet_lookup[pixel_bits[i]],emulation_pixels_per_real_pixel); |
| 405 | 405 | i=(i<<1)|1; |
| 406 | 406 | } |
| 407 | 407 | } else { |
| r2028 | r2029 | |
| 411 | 411 | if (video_refresh) |
| 412 | 412 | { |
| 413 | 413 | // if the display is not enable, just draw a blank area. |
| 414 | | BBC_ula_drawpixel(machine, 0, emulation_pixels_per_byte); |
| 414 | BBC_ula_drawpixel(0, emulation_pixels_per_byte); |
| 415 | 415 | } else { |
| 416 | 416 | BBC_display += emulation_pixels_per_byte; |
| 417 | 417 | } |
| r2028 | r2029 | |
| 423 | 423 | // Just pass on the output at the correct pixel size. |
| 424 | 424 | static void BBC_draw_RGB_in(running_machine *machine, int offset,int data) |
| 425 | 425 | { |
| 426 | | BBC_ula_drawpixel(machine, data,emulation_pixels_per_real_pixel); |
| 426 | BBC_ula_drawpixel(data,emulation_pixels_per_real_pixel); |
| 427 | 427 | } |
| 428 | 428 | |
| 429 | 429 | |