void pc1512_state::draw_alpha(bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT16 ma, UINT8 ra, UINT16 y, UINT8 x_count, INT8 cursor_x, void *param)
{
offs_t char_rom_offset = get_char_rom_offset();
UINT32 *p = &bitmap.pix32(y + VFP_HIRES, HFP_HIRES);
if (get_display_mode(m_vdu_mode) == ALPHA_40)
p = &bitmap.pix32(y + VFP_LORES, HFP_LORES);
if (y > 199) return;
for (int column = 0; column < x_count; column++)
{
UINT8 code = m_video_ram[(ma + column) << 1];
UINT8 attr = m_video_ram[((ma + column) << 1) + 1];
int fg = attr & 0x0f;
int bg = attr >> 4;
if (m_vdu_mode & MODE_BLINK)
{
bg &= 0x07;
if (BIT(attr, 7) && !m_blink)
{
fg = bg;
}
}
offs_t addr = char_rom_offset | (code << 3) | (ra & 0x07);
UINT8 data = m_char_rom[addr & 0x1fff];
if ((column == cursor_x) && m_cursor)
{
data = 0xff;
}
for (int bit = 0; bit < 8; bit++)
{
int color = BIT(data, 7) ? fg : bg;
*p = PALETTE[color]; p++;
data <<= 1;
}
}
}
UINT32 decodmd_type1_device::screen_update( screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect )
{
UINT8 ptr = 0;
UINT8 x,y,dot;
UINT32 data1,data2,data3,data4;
UINT32 col;
if(m_frameswap)
ptr = 0x80;
for(y=0;y<16;y++) // scanline
{
for(x=0;x<128;x+=64)
{
data1 = m_pixels[ptr];
data2 = m_pixels[ptr+1];
data3 = m_pixels[ptr+2];
data4 = m_pixels[ptr+3];
for(dot=0;dot<64;dot+=2)
{
if((data1 & 0x01) != (data3 & 0x01))
col = rgb_t(0x7f,0x55,0x00);
else if (data1 & 0x01) // both are the same, so either high intensity or none at all
col = rgb_t(0xff,0xaa,0x00);
else
col = rgb_t::black;
bitmap.pix32(y,x+dot) = col;
if((data2 & 0x01) != (data4 & 0x01))
col = rgb_t(0x7f,0x55,0x00);
else if (data2 & 0x01) // both are the same, so either high intensity or none at all
col = rgb_t(0xff,0xaa,0x00);
else
col = rgb_t::black;
bitmap.pix32(y,x+dot+1) = col;
data1 >>= 1;
data2 >>= 1;
data3 >>= 1;
data4 >>= 1;
}
ptr+=4;
}
}
return 0;
}
static void draw_hline_moired(bitmap_rgb32 &bitmap, int x1, int x2, int y, int color)
{
UINT32 *base = &bitmap.pix32(y);
while(x1 <= x2) {
if((x1^y)&1)
base[x1] = color;
x1++;
}
}
void sliver_state::plot_pixel_rgb(int x, int y, UINT32 r, UINT32 g, UINT32 b)
{
// printf("plot %d %d %d\n", r,g,b);
if (y < 0 || x < 0 || x > 383 || y > 255)
return;
m_bitmap_bg.pix32(y, x) = r | (g<<8) | (b<<16);
}
void model1_state::draw_hline(bitmap_rgb32 &bitmap, int x1, int x2, int y, int color)
{
UINT32 *base = &bitmap.pix32(y);
while(x1 <= x2)
{
base[x1] = color;
x1++;
}
}
/* this is needed as this driver doesn't emulate the shift register like mw8080bw does */
static void clear_extra_columns( running_machine &machine, bitmap_rgb32 &bitmap, pen_t *pens, UINT8 color )
{
_8080bw_state *state = machine.driver_data<_8080bw_state>();
UINT8 x;
for (x = 0; x < 4; x++)
{
UINT8 y;
for (y = MW8080BW_VCOUNTER_START_NO_VBLANK; y != 0; y++)
{
if (state->m_c8080bw_flip_screen)
bitmap.pix32(MW8080BW_VBSTART - 1 - (y - MW8080BW_VCOUNTER_START_NO_VBLANK), MW8080BW_HPIXCOUNT - 1 - (256 + x)) = pens[color];
else
bitmap.pix32(y - MW8080BW_VCOUNTER_START_NO_VBLANK, 256 + x) = pens[color];
}
}
}
UINT32 vixen_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
const pen_t *pen = m_palette->pens();
for (int txadr = 0; txadr < 26; txadr++)
{
for (int scan = 0; scan < 10; scan++)
{
for (int chadr = 0; chadr < 128; chadr++)
{
UINT16 sync_addr = (txadr << 7) | chadr;
UINT8 sync_data = m_sync_rom->base()[sync_addr];
int blank = BIT(sync_data, 4);
/*
int clrchadr = BIT(sync_data, 7);
int hsync = BIT(sync_data, 6);
int clrtxadr = BIT(sync_data, 5);
int vsync = BIT(sync_data, 3);
int comp_sync = BIT(sync_data, 2);
logerror("SYNC %03x:%02x TXADR %u SCAN %u CHADR %u : COMPSYNC %u VSYNC %u BLANK %u CLRTXADR %u HSYNC %u CLRCHADR %u\n",
sync_addr,sync_data,txadr,scan,chadr,comp_sync,vsync,blank,clrtxadr,hsync,clrchadr);
*/
int reverse = 0;
UINT16 video_addr = (txadr << 7) | chadr;
UINT8 video_data = m_video_ram[video_addr];
UINT16 char_addr = 0;
if (m_256)
{
char_addr = (BIT(video_data, 7) << 11) | (scan << 7) | (video_data & 0x7f);
reverse = m_alt;
}
else
{
char_addr = (scan << 7) | (video_data & 0x7f);
reverse = BIT(video_data, 7);
}
UINT8 char_data = m_char_rom->base()[char_addr];
for (int x = 0; x < 8; x++)
{
int color = (BIT(char_data, 7 - x) ^ reverse) & !blank;
bitmap.pix32((txadr * 10) + scan, (chadr * 8) + x) = pen[color];
}
}
}
}
return 0;
}
UINT32 cirrus_gd5428_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,bit;
UINT32 ptr = (vga.svga_intf.vram_size - 0x4000); // cursor patterns are stored in the last 16kB of VRAM
svga_device::screen_update(screen, bitmap, cliprect);
/*UINT8 cur_mode =*/ pc_vga_choosevideomode();
if(m_cursor_attr & 0x01) // hardware cursor enabled
{
// draw hardware graphics cursor
if(m_cursor_attr & 0x04) // 64x64
{
ptr += ((m_cursor_addr & 0x3c) * 256);
for(y=0;y<64;y++)
{
for(x=0;x<64;x+=8)
{
for(bit=0;bit<8;bit++)
{
UINT8 pixel1 = vga.memory[ptr % vga.svga_intf.vram_size] >> (7-bit);
UINT8 pixel2 = vga.memory[(ptr+512) % vga.svga_intf.vram_size] >> (7-bit);
UINT8 output = ((pixel1 & 0x01) << 1) | (pixel2 & 0x01);
switch(output)
{
case 0: // transparent - do nothing
break;
case 1: // background
bitmap.pix32(m_cursor_y+y,m_cursor_x+x+bit) = (m_ext_palette[0].red << 16) | (m_ext_palette[0].green << 8) | (m_ext_palette[0].blue);
break;
case 2: // XOR
bitmap.pix32(m_cursor_y+y,m_cursor_x+x+bit) = ~bitmap.pix32(m_cursor_y+y,m_cursor_x+x+bit);
break;
case 3: // foreground
bitmap.pix32(m_cursor_y+y,m_cursor_x+x+bit) = (m_ext_palette[15].red << 16) | (m_ext_palette[15].green << 8) | (m_ext_palette[15].blue);
break;
}
}
}
}
}
else
{
INLINE void draw_pixel(running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
{
if (flip)
{
x = bitmap.width() - x - 1;
y = bitmap.height() - y - 1;
}
if (cliprect.contains(x, y))
bitmap.pix32(y, x) = machine.pens[color];
}
void gpworld_state::draw_pixel(bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
{
if (flip)
{
x = bitmap.width() - x - 1;
y = bitmap.height() - y - 1;
}
if (cliprect.contains(x, y))
bitmap.pix32(y, x) = m_palette->pen(color);
}
uint32_t calcune_state::screen_update_calcune(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
const pen_t *paldata = m_palette->pens();
for (int y = cliprect.min_y; y <= cliprect.max_y; y++)
{
uint32_t *dst = &bitmap.pix32(y);
for (int x = cliprect.min_x; x <= cliprect.max_x; x++)
{
int pix;
pix = m_vdp2->m_render_line_raw[x] & 0x3f;
switch (pix & 0xc0)
{
case 0x00:
dst[x] = paldata[pix + 0x0000 + 0xc0];
break;
case 0x40:
case 0x80:
dst[x] = paldata[pix + 0x0040 + 0xc0];
break;
case 0xc0:
dst[x] = paldata[pix + 0x0080 + 0xc0];
break;
}
if (m_vdp->m_render_line_raw[x] & 0x100)
{
pix = m_vdp->m_render_line_raw[x] & 0x3f;
if (pix & 0xf)
{
switch (pix & 0xc0)
{
case 0x00:
dst[x] = paldata[pix + 0x0000];
break;
case 0x40:
case 0x80:
dst[x] = paldata[pix + 0x0040];
break;
case 0xc0:
dst[x] = paldata[pix + 0x0080];
break;
}
}
}
}
}
return 0;
}
uint32_t mmagic_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
// draw playfield
for (int y = 0; y < 192 / 12; y++)
{
for (int x = 0; x < 256 / 8; x++)
{
uint8_t code = m_vram[(y * 32) + x] & 0x7f;
// normal palette 00..7f, alternate palette 80..ff
uint8_t color = m_colors[code | (BIT(m_color, 6) << 7)];
// draw one tile
for (int tx = 0; tx < 12; tx++)
{
uint8_t gfx = m_tiles[(code << 4) + tx];
bitmap.pix32(y * 12 + tx, x * 8 + 0) = BIT(gfx, 4) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 1) = BIT(gfx, 5) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 2) = BIT(gfx, 6) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 3) = BIT(gfx, 7) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 4) = BIT(gfx, 0) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 5) = BIT(gfx, 1) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 6) = BIT(gfx, 2) ? rgb_t::black() : m_palette->pen_color(color);
bitmap.pix32(y * 12 + tx, x * 8 + 7) = BIT(gfx, 3) ? rgb_t::black() : m_palette->pen_color(color);
}
}
}
// draw ball (if not disabled)
if (m_ball_x != 0xff)
{
static const int BALL_SIZE = 4;
int ball_y = (m_ball_y >> 4) * 12 + (m_ball_y & 0x0f);
bitmap.plot_box(m_ball_x - BALL_SIZE + 1, ball_y - BALL_SIZE + 1, BALL_SIZE, BALL_SIZE, rgb_t::white());
}
return 0;
}
UINT32 bingor_state::screen_update_bingor(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,count;
bitmap.fill(get_black_pen(machine()), cliprect);
count = (0x2000/2);
for(y=0;y<256;y++)
{
for(x=0;x<286;x+=4)
{
UINT32 color;
color = (m_blit_ram[count] & 0xf000)>>12;
if(cliprect.contains(x+3, y))
bitmap.pix32(y, x+3) = machine().pens[color];
color = (m_blit_ram[count] & 0x0f00)>>8;
if(cliprect.contains(x+2, y))
bitmap.pix32(y, x+2) = machine().pens[color];
color = (m_blit_ram[count] & 0x00f0)>>4;
if(cliprect.contains(x+1, y))
bitmap.pix32(y, x+1) = machine().pens[color];
color = (m_blit_ram[count] & 0x000f)>>0;
if(cliprect.contains(x+0, y))
bitmap.pix32(y, x+0) = machine().pens[color];
count++;
}
}
return 0;
}
UINT32 mw8080bw_state::screen_update_mw8080bw(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT8 x = 0;
UINT8 y = MW8080BW_VCOUNTER_START_NO_VBLANK;
UINT8 video_data = 0;
while (1)
{
/* plot the current pixel */
pen_t pen = (video_data & 0x01) ? rgb_t::white : rgb_t::black;
bitmap.pix32(y - MW8080BW_VCOUNTER_START_NO_VBLANK, x) = pen;
/* next pixel */
video_data = video_data >> 1;
x = x + 1;
/* end of line? */
if (x == 0)
{
/* yes, flush out the shift register */
int i;
for (i = 0; i < 4; i++)
{
pen = (video_data & 0x01) ? rgb_t::white : rgb_t::black;
bitmap.pix32(y - MW8080BW_VCOUNTER_START_NO_VBLANK, 256 + i) = pen;
video_data = video_data >> 1;
}
/* next row, video_data is now 0, so the next line will start
with 4 blank pixels */
y = y + 1;
/* end of screen? */
if (y == 0)
break;
}
/* the video RAM is read at every 8 pixels starting with pixel 4 */
else if ((x & 0x07) == 0x04)
uint32_t vixen_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
const pen_t *pen = m_palette->pens();
uint8_t x, y, chr, gfx, inv, ra;
for (y = 0; y < 26; y++)
{
for (ra = 0; ra < 10; ra++)
{
for (x = 0; x < 128; x++)
{
uint16_t sync_addr = ((y+1) << 7) + x + 1; // it's out by a row and a column
uint8_t sync_data = m_sync_rom[sync_addr & 0xfff];
bool blank = BIT(sync_data, 4);
/*
int clrchadr = BIT(sync_data, 7);
int hsync = BIT(sync_data, 6);
int clrtxadr = BIT(sync_data, 5);
int vsync = BIT(sync_data, 3);
int comp_sync = BIT(sync_data, 2);
logerror("SYNC %03x:%02x TXADR %u SCAN %u CHADR %u : COMPSYNC %u VSYNC %u BLANK %u CLRTXADR %u HSYNC %u CLRCHADR %u\n",
sync_addr,sync_data,txadr,scan,chadr,comp_sync,vsync,blank,clrtxadr,hsync,clrchadr);
*/
chr = m_video_ram[(y<<7) + x];
if (m_256)
{
gfx = m_char_rom[(BIT(chr, 7) << 11) | (ra << 7) | (chr & 0x7f)];
inv = m_alt ? 0xff : 0;
}
else
{
gfx = m_char_rom[(ra << 7) | (chr & 0x7f)];
inv = BIT(chr, 7) ? 0xff : 0;
}
gfx = (blank) ? 0 : (gfx ^ inv);
for (int b = 0; b < 8; b++)
{
int color = BIT(gfx, 7 - b);
bitmap.pix32((y * 10) + ra, (x * 8) + b) = pen[color];
}
}
}
}
return 0;
}
INPUT_PORTS_END
/****************************************************\
* Video hardware *
\****************************************************/
void uzebox_state::line_update()
{
uint32_t cycles = (uint32_t)(m_maincpu->get_elapsed_cycles() - m_line_start_cycles) / 2;
rgb_t color = rgb_t(pal3bit(m_port_c >> 0), pal3bit(m_port_c >> 3), pal2bit(m_port_c >> 6));
for (uint32_t x = m_line_pos_cycles; x < cycles; x++)
{
if (m_bitmap.cliprect().contains(x, m_vpos))
m_bitmap.pix32(m_vpos, x) = color;
if (!INTERLACED)
if (m_bitmap.cliprect().contains(x, m_vpos + 1))
m_bitmap.pix32(m_vpos + 1, x) = color;
}
m_line_pos_cycles = cycles;
}
void sliver_state::plot_pixel_pal(int x, int y, int addr)
{
UINT32 r,g,b;
if (y < 0 || x < 0 || x > 383 || y > 255)
return;
b=(m_colorram[addr] << 2) | (m_colorram[addr] & 0x3);
g=(m_colorram[addr+0x100] << 2) | (m_colorram[addr+0x100] & 3);
r=(m_colorram[addr+0x200] << 2) | (m_colorram[addr+0x200] & 3);
m_bitmap_fg.pix32(y, x) = r | (g<<8) | (b<<16);
}
void dassault_state::mixdassaultlayer(bitmap_rgb32 &bitmap, bitmap_ind16* sprite_bitmap, const rectangle &cliprect, uint16_t pri, uint16_t primask, uint16_t penbase, uint8_t alpha)
{
int y, x;
const pen_t *paldata = &m_palette->pen(0);
uint16_t* srcline;
uint32_t* dstline;
for (y=cliprect.top();y<=cliprect.bottom();y++)
{
srcline=&sprite_bitmap->pix16(y,0);
dstline=&bitmap.pix32(y,0);
for (x=cliprect.left();x<=cliprect.right();x++)
{
uint16_t pix = srcline[x];
if ((pix & primask) != pri)
continue;
if (pix&0xf)
{
uint16_t pen = pix&0x1ff;
if (pix & 0x800) pen += 0x200;
if (alpha!=0xff)
{
if (pix&0x400) // TODO, Additive/Subtractive Blending?
{
uint32_t base = dstline[x];
dstline[x] = alpha_blend_r32(base, paldata[pen+penbase], alpha);
}
else if (pix&0x200)
{
uint32_t base = dstline[x];
dstline[x] = alpha_blend_r32(base, paldata[pen+penbase], alpha);
}
else
{
dstline[x] = paldata[pen+penbase];
}
}
else
{
dstline[x] = paldata[pen+penbase];
}
}
}
}
}
uint32_t monty_state::lcd_update(screen_device& screen, bitmap_rgb32& bitmap, const rectangle& cliprect)
{
if (!m_dirty)
return 1;
uint8_t x,y,z;
m_dirty = false;
for (y = 0; y < 32; y++)
{
for (z = 0; z < 8; z++)
{
for (x = 0; x < 5; x++)
{
bitmap.pix32(y, x+z*6) = m_pixels[y*42 + z*5 + x];
}
bitmap.pix32(y, 5+z*6) = 0; // space between letters
}
bitmap.pix32(y, 48) = m_pixels[y*42 + 40];
bitmap.pix32(y, 49) = m_pixels[y*42 + 41];
}
return 0;
}
UINT32 toobin_state::screen_update_toobin(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
bitmap_ind8 &priority_bitmap = machine().priority_bitmap;
const rgb_t *palette = palette_entry_list_adjusted(machine().palette);
atarimo_rect_list rectlist;
bitmap_ind16 *mobitmap;
int x, y;
/* draw the playfield */
priority_bitmap.fill(0, cliprect);
m_playfield_tilemap->draw(m_pfbitmap, cliprect, 0, 0);
m_playfield_tilemap->draw(m_pfbitmap, cliprect, 1, 1);
m_playfield_tilemap->draw(m_pfbitmap, cliprect, 2, 2);
m_playfield_tilemap->draw(m_pfbitmap, cliprect, 3, 3);
/* draw and merge the MO */
mobitmap = atarimo_render(0, cliprect, &rectlist);
for (y = cliprect.min_y; y <= cliprect.max_y; y++)
{
UINT32 *dest = &bitmap.pix32(y);
UINT16 *mo = &mobitmap->pix16(y);
UINT16 *pf = &m_pfbitmap.pix16(y);
UINT8 *pri = &priority_bitmap.pix8(y);
for (x = cliprect.min_x; x <= cliprect.max_x; x++)
{
UINT16 pix = pf[x];
if (mo[x])
{
/* not verified: logic is all controlled in a PAL
factors: LBPRI1-0, LBPIX3, ANPIX1-0, PFPIX3, PFPRI1-0,
(~LBPIX3 & ~LBPIX2 & ~LBPIX1 & ~LBPIX0)
*/
/* only draw if not high priority PF */
if (!pri[x] || !(pix & 8))
pix = mo[x];
/* erase behind ourselves */
mo[x] = 0;
}
dest[x] = palette[pix];
}
}
/* add the alpha on top */
m_alpha_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
UINT32 gf4500_device::screen_update(screen_device &device, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT16 *vram = (UINT16 *)(m_data + GF4500_FRAMEBUF_OFFSET / 4);
int x, y;
for (y = 0; y < 240; y++)
{
UINT32 *scanline = &bitmap.pix32(y);
for (x = 0; x < 320; x++)
{
*scanline++ = gf4500_get_color_16(*vram++);
}
vram += 1;
}
return 0;
}
uint32_t kontest_state::screen_update( screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect )
{
int x,y;
int xi,yi;
uint16_t tile;
uint8_t attr;
for(y=0;y<32;y++)
{
for(x=0;x<64;x++)
{
tile = m_ram[(x+y*64)|0x800];
attr = m_ram[(x+((y >> 1)*64))|0x000] & 7;
tile *= 0x10;
tile += 0x1000;
for(yi=0;yi<8;yi++)
{
for(xi=0;xi<8;xi++)
{
uint8_t color,pen[2];
uint8_t x_step;
int res_x,res_y;
x_step = xi >> 2;
pen[0] = m_ram[(x_step+yi*2)|(tile)];
pen[0] >>= 3-((xi & 3));
pen[0] &= 1;
pen[1] = m_ram[(x_step+yi*2)|(tile)];
pen[1] >>= 7-((xi & 3));
pen[1] &= 1;
color = pen[0];
color|= pen[1]<<1;
res_x = x*8+xi-256;
res_y = y*8+yi;
if (cliprect.contains(res_x, res_y))
bitmap.pix32(res_y, res_x) = m_palette->pen(color|attr*4);
}
}
}
}
return 0;
}
static UINT32 update_screen(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, int index)
{
vcombat_state *state = screen.machine().driver_data<vcombat_state>();
int y;
const rgb_t *const pens = tlc34076_get_pens(screen.machine().device("tlc34076"));
UINT16 *m68k_buf = state->m_m68k_framebuffer[(*state->m_framebuffer_ctrl & 0x20) ? 1 : 0];
UINT16 *i860_buf = state->m_i860_framebuffer[index][0];
/* TODO: It looks like the leftmost chunk of the ground should really be on the right side? */
/* But the i860 draws the background correctly, so it may be an original game issue. */
/* There's also some garbage in the upper-left corner. Might be related to this 'wraparound'. */
/* Or maybe it's related to the 68k's alpha? It might come from the 68k side of the house. */
for (y = cliprect.min_y; y <= cliprect.max_y; ++y)
{
int x;
int src_addr = 256/2 * y;
const UINT16 *m68k_src = &m68k_buf[src_addr];
const UINT16 *i860_src = &i860_buf[src_addr];
UINT32 *dst = &bitmap.pix32(y, cliprect.min_x);
for (x = cliprect.min_x; x <= cliprect.max_x; x += 2)
{
int i;
UINT16 m68k_pix = *m68k_src++;
UINT16 i860_pix = *i860_src++;
/* Draw two pixels */
for (i = 0; i < 2; ++i)
{
/* Vcombat's screen renders 'flopped' - very likely because VR headset displays may reflect off mirrors.
Shadfgtr isn't flopped, so it's not a constant feature of the hardware. */
/* Combine the two layers */
if ((m68k_pix & 0xff) == 0)
*dst++ = pens[i860_pix & 0xff];
else
*dst++ = pens[m68k_pix & 0xff];
m68k_pix >>= 8;
i860_pix >>= 8;
}
}
}
return 0;
}
static void cirrus_update_8bpp(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *line;
const UINT8 *vram;
int y, x;
vram = (const UINT8 *) pc_vga_memory();
for (y = 0; y < 480; y++)
{
line = &bitmap.pix32(y);
for (x = 0; x < 640; x++)
*line++ = machine.pens[*vram++];
}
}
static void skeetsht_scanline_update(screen_device &screen, bitmap_rgb32 &bitmap, int scanline, const tms34010_display_params *params)
{
skeetsht_state *state = screen.machine().driver_data<skeetsht_state>();
const rgb_t *const pens = tlc34076_get_pens(screen.machine().device("tlc34076"));
UINT16 *vram = &state->m_tms_vram[(params->rowaddr << 8) & 0x3ff00];
UINT32 *dest = &bitmap.pix32(scanline);
int coladdr = params->coladdr;
int x;
for (x = params->heblnk; x < params->hsblnk; x += 2)
{
UINT16 pixels = vram[coladdr++ & 0xff];
dest[x + 0] = pens[pixels & 0xff];
dest[x + 1] = pens[pixels >> 8];
}
}
// apply shadowing to underlying layers
// TODO: it might mix up with the lower palette bank instead (color bank 0x1400?)
void tatsumi_state::apply_shadow_bitmap(bitmap_rgb32 &bitmap, const rectangle &cliprect, bitmap_ind8 &shadow_bitmap, uint8_t xor_output)
{
for(int y=cliprect.min_y;y<cliprect.max_y;y++)
{
for(int x=cliprect.min_x;x<cliprect.max_x;x++)
{
uint8_t shadow = shadow_bitmap.pix8(y, x);
// xor_output is enabled during Chen boss fight (where shadows have more brightness than everything else)
// TODO: transition before fighting him should also black out all the background tilemaps too!?
// (more evidence that we need to mix with color bank 0x1400 instead of doing true RGB mixing).
if(shadow ^ xor_output)
{
rgb_t shadow_pen = bitmap.pix32(y, x);
bitmap.pix32(y, x) = rgb_t(shadow_pen.r() >> 1,shadow_pen.g() >> 1, shadow_pen.b() >> 1);
}
}
}
UINT32 gameplan_state::screen_update_gameplan(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
pen_t pens[GAMEPLAN_NUM_PENS];
offs_t offs;
gameplan_get_pens(pens);
for (offs = 0; offs < m_videoram_size; offs++)
{
UINT8 y = offs >> 8;
UINT8 x = offs & 0xff;
bitmap.pix32(y, x) = pens[m_videoram[offs] & 0x07];
}
return 0;
}
uint32_t stuntcyc_state::screen_update_stuntcyc(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
m_last_hpos = 0;
m_last_vpos = 0;
uint32_t pixindex = 0;
for (int y = 0; y < SC_VTOTAL; y++)
{
uint32_t *scanline = &bitmap.pix32(y);
pixindex = y * SC_HTOTAL;
for (int x = 0; x < SC_HTOTAL; x++)
*scanline++ = 0xff000000 | (m_probe_data[pixindex++] * 0x010101);
//*scanline++ = 0xff000000 | (uint8_t(m_screen_buf[pixindex++] * 63.0) * 0x010101);
}
return 0;
}
static void gfxset_draw_item(running_machine &machine, gfx_element &gfx, int index, bitmap_rgb32 &bitmap, int dstx, int dsty, int color, int rotate, device_palette_interface *dpalette)
{
int width = (rotate & ORIENTATION_SWAP_XY) ? gfx.height() : gfx.width();
int height = (rotate & ORIENTATION_SWAP_XY) ? gfx.width() : gfx.height();
const rgb_t *palette = dpalette->palette()->entry_list_raw() + gfx.colorbase() + color * gfx.granularity();
int x, y;
// loop over rows in the cell
for (y = 0; y < height; y++)
{
uint32_t *dest = &bitmap.pix32(dsty + y, dstx);
const uint8_t *src = gfx.get_data(index);
// loop over columns in the cell
for (x = 0; x < width; x++)
{
int effx = x, effy = y;
const uint8_t *s;
// compute effective x,y values after rotation
if (!(rotate & ORIENTATION_SWAP_XY))
{
if (rotate & ORIENTATION_FLIP_X)
effx = gfx.width() - 1 - effx;
if (rotate & ORIENTATION_FLIP_Y)
effy = gfx.height() - 1 - effy;
}
else
{
if (rotate & ORIENTATION_FLIP_X)
effx = gfx.height() - 1 - effx;
if (rotate & ORIENTATION_FLIP_Y)
effy = gfx.width() - 1 - effy;
std::swap(effx, effy);
}
// get a pointer to the start of this source row
s = src + effy * gfx.rowbytes();
// extract the pixel
*dest++ = 0xff000000 | palette[s[effx]];
}
}
}
uint32_t toobin_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
// start drawing
m_mob->draw_async(cliprect);
/* draw the playfield */
bitmap_ind8 &priority_bitmap = screen.priority();
priority_bitmap.fill(0, cliprect);
m_playfield_tilemap->draw(screen, m_pfbitmap, cliprect, 0, 0);
m_playfield_tilemap->draw(screen, m_pfbitmap, cliprect, 1, 1);
m_playfield_tilemap->draw(screen, m_pfbitmap, cliprect, 2, 2);
m_playfield_tilemap->draw(screen, m_pfbitmap, cliprect, 3, 3);
/* draw and merge the MO */
bitmap_ind16 &mobitmap = m_mob->bitmap();
const pen_t *palette = m_palette->pens();
for (int y = cliprect.min_y; y <= cliprect.max_y; y++)
{
uint32_t *dest = &bitmap.pix32(y);
uint16_t *mo = &mobitmap.pix16(y);
uint16_t *pf = &m_pfbitmap.pix16(y);
uint8_t *pri = &priority_bitmap.pix8(y);
for (int x = cliprect.min_x; x <= cliprect.max_x; x++)
{
uint16_t pix = pf[x];
if (mo[x] != 0xffff)
{
/* not verified: logic is all controlled in a PAL
factors: LBPRI1-0, LBPIX3, ANPIX1-0, PFPIX3, PFPRI1-0,
(~LBPIX3 & ~LBPIX2 & ~LBPIX1 & ~LBPIX0)
*/
/* only draw if not high priority PF */
if (!pri[x] || !(pix & 8))
pix = mo[x];
}
dest[x] = palette[pix];
}
}
/* add the alpha on top */
m_alpha_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
