void sliver_state::render_jpeg()
{
int x;
int addr = (int)m_jpeg2 + (((int)m_jpeg1) << 16);
m_bitmap_bg.fill(0);
if (addr < 0)
{
return;
}
//printf("access address %04x\n", addr);
/* Access libJPEG */
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPARRAY buffer;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
jpeg_mem_src(&cinfo, memregion("user2")->base()+addr, memregion("user2")->bytes()-addr);
jpeg_read_header(&cinfo, true);
jpeg_start_decompress(&cinfo);
int row_stride = cinfo.output_width * cinfo.output_components;
buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
while (cinfo.output_scanline < cinfo.output_height)
{
jpeg_read_scanlines(&cinfo, buffer, 1);
int y = cinfo.output_scanline;
for (x = 0; x < row_stride/3; x++)
{
uint8_t b = buffer[0][(x*3)];
uint8_t g = buffer[0][(x*3)+1];
uint8_t r = buffer[0][(x*3)+2];
plot_pixel_rgb(x - x_offset + m_jpeg_x, y - y_offset - m_jpeg_y, r, g, b);
}
}
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
}
}
UINT32 midas_state::screen_update_midas(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
// fill with background color first
bitmap.fill(0x0, cliprect);
m_sprgen->draw_sprites(bitmap, cliprect.min_y);
m_sprgen->draw_fixed_layer(bitmap, cliprect.min_y);
return 0;
}
UINT32 cdp1861_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (m_disp)
{
copybitmap(bitmap, m_bitmap, 0, 0, 0, 0, cliprect);
}
else
{
bitmap.fill(rgb_t::black, cliprect);
}
return 0;
}
UINT32 boogwing_state::screen_update_boogwing(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
address_space &space = machine().driver_data()->generic_space();
UINT16 flip = m_deco_tilegen1->pf_control_r(space, 0, 0xffff);
UINT16 priority = m_decocomn->priority_r(space, 0, 0xffff);
/* Draw sprite planes to bitmaps for later mixing */
m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram2->buffer(), 0x400, true);
m_sprgen1->draw_sprites(bitmap, cliprect, m_spriteram->buffer(), 0x400, true);
flip_screen_set(BIT(flip, 7));
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen2->pf_update(m_pf3_rowscroll, m_pf4_rowscroll);
/* Draw playfields */
bitmap.fill(m_palette->pen(0x400), cliprect); /* pen not confirmed */
screen.priority().fill(0);
// bit&0x8 is definitely some kind of palette effect
// bit&0x4 combines playfields
if ((priority & 0x7) == 0x5)
{
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_deco_tilegen2->tilemap_12_combine_draw(screen, bitmap, cliprect, 0, 32);
}
else if ((priority & 0x7) == 0x1 || (priority & 0x7) == 0x2)
{
m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 8);
m_deco_tilegen2->tilemap_1_draw(screen, bitmap, cliprect, 0, 32);
}
else if ((priority & 0x7) == 0x3)
{
m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 8);
// This mode uses playfield 3 to shadow sprites & playfield 2 (instead of
// regular alpha-blending, the destination is inverted). Not yet implemented.
// m_deco_tilegen1->tilemap_3_draw(screen, bitmap, cliprect, TILEMAP_DRAW_ALPHA(0x80), 32);
}
else
{
m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_deco_tilegen2->tilemap_1_draw(screen, bitmap, cliprect, 0, 8);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 32);
}
mix_boogwing(screen,bitmap,cliprect);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
UINT32 cdp1864_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (m_disp)
{
copybitmap(bitmap, m_bitmap, 0, 0, 0, 0, cliprect);
m_bitmap.fill(CDP1864_BACKGROUND_COLOR_SEQUENCE[m_bgcolor] + 8, cliprect);
}
else
{
bitmap.fill(get_black_pen(machine()), cliprect);
}
return 0;
}
UINT32 trs80m2_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (m_blnkvid)
{
bitmap.fill(rgb_t::black, cliprect);
}
else
{
m_crtc->screen_update(screen, bitmap, cliprect);
}
return 0;
}
uint32_t newbrain_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (m_tvp)
{
screen_update(bitmap, cliprect);
}
else
{
bitmap.fill(rgb_t::black(), cliprect);
}
return 0;
}
UINT32 zr107_state::screen_update_zr107(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
bitmap.fill(machine().pens[0], cliprect);
m_k056832->tilemap_draw(screen, bitmap, cliprect, 1, 0, 0);
K001005_draw(bitmap, cliprect);
m_k056832->tilemap_draw(screen, bitmap, cliprect, 0, 0, 0);
draw_7segment_led(bitmap, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1);
sharc_set_flag_input(machine().device("dsp"), 1, ASSERT_LINE);
return 0;
}
UINT32 cdp1864_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (m_disp)
{
copybitmap(bitmap, m_bitmap, 0, 0, 0, 0, cliprect);
m_bitmap.fill(m_palette[bckgnd[m_bgcolor] + 8], cliprect);
}
else
{
bitmap.fill(rgb_t::black, cliprect);
}
return 0;
}
int spbactn_state::draw_video(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, bool alt_sprites)
{
m_tile_bitmap_bg.fill(0, cliprect);
m_tile_bitmap_fg.fill(0, cliprect);
m_sprite_bitmap.fill(0, cliprect);
bitmap.fill(0, cliprect);
m_sprgen->gaiden_draw_sprites(screen, m_gfxdecode, cliprect, m_spvideoram, 0, 0, flip_screen(), m_sprite_bitmap);
m_bg_tilemap->draw(screen, m_tile_bitmap_bg, cliprect, 0, 0);
m_fg_tilemap->draw(screen, m_tile_bitmap_fg, cliprect, 0, 0);
m_mixer->mix_bitmaps(screen, bitmap, cliprect, *m_palette, &m_tile_bitmap_bg, &m_tile_bitmap_fg, (bitmap_ind16*)nullptr, &m_sprite_bitmap);
return 0;
}
UINT32 deco156_state::screen_update_wcvol95(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
//FIXME: flip_screen_x should not be written!
flip_screen_set_no_update(1);
screen.priority().fill(0);
bitmap.fill(0);
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x800);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
uint32_t deco156_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
// sprites are flipped relative to tilemaps
m_sprgen->set_flip_screen(true);
screen.priority().fill(0);
bitmap.fill(0);
m_deco_tilegen->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram.get(), 0x800);
m_deco_tilegen->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
uint32_t nwktr_state::screen_update_rscreen(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
bitmap.fill(m_palette->pen(0), cliprect);
m_voodoo[1]->voodoo_update(bitmap, cliprect);
const rectangle &visarea = screen.visible_area();
const rectangle tilemap_rect(visarea.min_x, visarea.max_x, visarea.min_y + 16, visarea.max_y);
m_k001604->draw_front_layer(screen, bitmap, tilemap_rect);
draw_7segment_led(bitmap, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1);
return 0;
}
UINT32 magicard_state::screen_update_magicard(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
magicard_state *state = machine().driver_data<magicard_state>();
int x,y;
UINT32 count;
bitmap.fill(get_black_pen(machine()), cliprect); //TODO
if(!(SCC_DE_VREG)) //display enable
return 0;
count = ((SCC_VSR_VREG)/2);
if(SCC_FG_VREG) //4bpp gfx
{
for(y=0;y<300;y++)
{
for(x=0;x<84;x++)
{
UINT32 color;
color = ((m_magicram[count]) & 0x000f)>>0;
if(cliprect.contains((x*4)+3, y))
bitmap.pix32(y, (x*4)+3) = machine().pens[color];
color = ((m_magicram[count]) & 0x00f0)>>4;
if(cliprect.contains((x*4)+2, y))
bitmap.pix32(y, (x*4)+2) = machine().pens[color];
color = ((m_magicram[count]) & 0x0f00)>>8;
if(cliprect.contains((x*4)+1, y))
bitmap.pix32(y, (x*4)+1) = machine().pens[color];
color = ((m_magicram[count]) & 0xf000)>>12;
if(cliprect.contains((x*4)+0, y))
bitmap.pix32(y, (x*4)+0) = machine().pens[color];
count++;
}
}
}
else //8bpp gfx
{
for(y=0;y<300;y++)
UINT32 zr107_state::screen_update_jetwave(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
bitmap.fill(machine().pens[0], cliprect);
m_k001604->draw_back_layer(bitmap, cliprect);
K001005_draw(bitmap, cliprect);
m_k001604->draw_front_layer(screen, bitmap, cliprect);
draw_7segment_led(bitmap, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1);
sharc_set_flag_input(machine().device("dsp"), 1, ASSERT_LINE);
return 0;
}
SLOT_INTERFACE_END
//**************************************************************************
// VIDEO EMULATION
//**************************************************************************
uint32_t apricot_state::screen_update_apricot(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (!m_display_on)
m_crtc->screen_update(screen, bitmap, cliprect);
else
bitmap.fill(rgb_t::black(), cliprect);
return 0;
}
SLOT_INTERFACE_END
//**************************************************************************
// VIDEO EMULATION
//**************************************************************************
UINT32 apricot_state::screen_update_apricot(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (!m_display_on)
m_crtc->screen_update(screen, bitmap, cliprect);
else
bitmap.fill(RGB_BLACK, cliprect);
return 0;
}
UINT32 nwktr_state::screen_update_nwktr(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
voodoo_device *voodoo = (voodoo_device*)machine().device("voodoo0");
bitmap.fill(m_palette->pen(0), cliprect);
voodoo->voodoo_update(bitmap, cliprect);
const rectangle &visarea = screen.visible_area();
const rectangle tilemap_rect(visarea.min_x, visarea.max_x, visarea.min_y+16, visarea.max_y);
m_k001604->draw_front_layer(screen, bitmap, tilemap_rect);
draw_7segment_led(bitmap, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1);
return 0;
}
uint32_t gottlieb_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
/* if the background has lower priority, render it first, else clear the screen */
if (!m_background_priority)
m_bg_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
else
bitmap.fill(m_palette->pen(0), cliprect);
/* draw the sprites */
draw_sprites(bitmap, cliprect);
/* if the background has higher priority, render it now */
if (m_background_priority)
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
UINT32 nwktr_state::screen_update_nwktr(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
device_t *voodoo = machine().device("voodoo");
bitmap.fill(machine().pens[0], cliprect);
voodoo_update(voodoo, bitmap, cliprect);
const rectangle &visarea = screen.visible_area();
const rectangle tilemap_rect(visarea.min_x, visarea.max_x, visarea.min_y+16, visarea.max_y);
k001604_draw_front_layer(m_k001604, bitmap, tilemap_rect);
draw_7segment_led(bitmap, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1);
return 0;
}
uint32_t rohga_state::screen_update_nitrobal(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
address_space &space = machine().dummy_space();
uint16_t flip = m_deco_tilegen[0]->pf_control_r(space, 0, 0xffff);
uint16_t priority = m_decocomn->priority_r();
flip_screen_set(BIT(flip, 7));
m_sprgen[0]->set_flip_screen(BIT(flip, 7));
m_sprgen[1]->set_flip_screen(BIT(flip, 7));
/* draw sprite gfx to temp bitmaps */
m_sprgen[0]->set_alt_format(true);
m_sprgen[1]->set_alt_format(true);
m_sprgen[1]->draw_sprites(bitmap, cliprect, m_spriteram[1]->buffer(), 0x400);
m_sprgen[0]->draw_sprites(bitmap, cliprect, m_spriteram[0]->buffer(), 0x400);
/* Update playfields */
m_deco_tilegen[0]->pf_update(m_pf_rowscroll[0], m_pf_rowscroll[1]);
m_deco_tilegen[1]->pf_update(m_pf_rowscroll[2], m_pf_rowscroll[3]);
/* Draw playfields - Palette of 2nd playfield chip visible if playfields turned off */
bitmap.fill(m_palette->pen(512), cliprect);
screen.priority().fill(0);
/* pf3 and pf4 are combined into a single 8bpp bitmap */
m_deco_tilegen[1]->tilemap_12_combine_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
switch (priority)
{
case 0:
default:
m_deco_tilegen[0]->tilemap_2_draw(screen, bitmap, cliprect, 0, 0x008);
break;
case 0x20:
m_deco_tilegen[0]->tilemap_2_draw(screen, bitmap, cliprect, 0, 0x040);
break;
}
/* TODO verify priorities + mixing / alpha */
mixnitroballlayer(screen,bitmap,cliprect);
m_deco_tilegen[0]->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
void k001604_device::draw_back_layer( bitmap_rgb32 &bitmap, const rectangle &cliprect )
{
bitmap.fill(0, cliprect);
if ((m_reg[0x60 / 4] & 0x40000000) == 0)
return;
int tile_size = m_roz_size ? 16 : 8;
INT32 x = (INT16)((m_reg[0x08] >> 16) & 0xffff);
INT32 y = (INT16)((m_reg[0x08] >> 0) & 0xffff);
INT32 xx = (INT16)((m_reg[0x09] >> 0) & 0xffff);
INT32 xy = (INT16)((m_reg[0x09] >> 16) & 0xffff);
INT32 yx = (INT16)((m_reg[0x0a] >> 0) & 0xffff);
INT32 yy = (INT16)((m_reg[0x0a] >> 16) & 0xffff);
int pivotx = (INT16)((m_reg[0x00] >> 16) & 0xffff);
int pivoty = (INT16)((m_reg[0x00] >> 0) & 0xffff);
int startx = ((x - pivotx) * 256) * 32;
int starty = ((y - pivoty) * 256) * 32;
int incxx = (xx) * 32;
int incxy = (-xy) * 32;
int incyx = (-yx) * 32;
int incyy = (yy) * 32;
bitmap_ind16& pixmap = m_layer_roz->pixmap();
// extract start/end points
int sx = cliprect.min_x;
int sy = cliprect.min_y;
int ex = cliprect.max_x;
int ey = cliprect.max_y;
const rgb_t *clut = m_palette->palette()->entry_list_raw();
int window_x, window_y, window_xmask, window_ymask;
int layer_size = (m_reg[0x1b] >> 9) & 3;
if (m_roz_size)
window_x = ((m_reg[0x1b] >> 1) & 3) * 512;
else
UINT32 gaiden_state::screen_update_raiga(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
m_tile_bitmap_bg.fill(0, cliprect);
m_tile_bitmap_fg.fill(0, cliprect);
m_sprite_bitmap.fill(0, cliprect);
bitmap.fill(0, cliprect);
m_sprgen->gaiden_draw_sprites(screen, m_gfxdecode, cliprect, m_spriteram, m_sprite_sizey, m_spr_offset_y, flip_screen(), m_sprite_bitmap);
m_background->draw(screen, m_tile_bitmap_bg, cliprect, 0, 0);
m_foreground->draw(screen, m_tile_bitmap_fg, cliprect, 0, 0);
m_mixer->mix_bitmaps(screen, bitmap, cliprect, m_palette, &m_tile_bitmap_bg, &m_tile_bitmap_fg, (bitmap_ind16*)0, &m_sprite_bitmap);
// todo, this should go through the mixer!
m_text_layer->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
UINT32 miragemi_state::screen_update_mirage(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
address_space &space = machine().driver_data()->generic_space();
UINT16 flip = deco16ic_pf_control_r(m_deco_tilegen1, space, 0, 0xffff);
flip_screen_set(BIT(flip, 7));
machine().device<decospr_device>("spritegen")->draw_sprites(bitmap, cliprect, m_spriteram->buffer(), 0x400);
deco16ic_pf_update(m_deco_tilegen1, m_pf1_rowscroll, m_pf2_rowscroll);
bitmap.fill(256, cliprect); /* not verified */
deco16ic_tilemap_2_draw(m_deco_tilegen1, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
machine().device<decospr_device>("spritegen")->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0800, 0x0800, 0x200, 0x1ff);
deco16ic_tilemap_1_draw(m_deco_tilegen1, bitmap, cliprect, 0, 0);
machine().device<decospr_device>("spritegen")->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0000, 0x0800, 0x200, 0x1ff);
return 0;
}
UINT32 tecmo16_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
m_tile_bitmap_bg.fill(0, cliprect);
m_tile_bitmap_fg.fill(0, cliprect);
m_sprite_bitmap.fill(0, cliprect);
bitmap.fill(0, cliprect);
if (m_game_is_riot) m_sprgen->gaiden_draw_sprites(screen, m_gfxdecode, cliprect, m_spriteram, 0, 0, flip_screen(), m_sprite_bitmap);
else m_sprgen->gaiden_draw_sprites(screen, m_gfxdecode, cliprect, m_spriteram, 2, 0, flip_screen(), m_sprite_bitmap);
m_bg_tilemap->draw(screen, m_tile_bitmap_bg, cliprect, 0, 0);
m_fg_tilemap->draw(screen, m_tile_bitmap_fg, cliprect, 0, 0);
m_mixer->mix_bitmaps(screen, bitmap, cliprect, m_palette, &m_tile_bitmap_bg, &m_tile_bitmap_fg, (bitmap_ind16*)nullptr, &m_sprite_bitmap);
// todo, this should go through the mixer!
m_tx_tilemap->draw(screen, bitmap, cliprect, 0, 0);
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 flipjack_state::screen_update_flipjack(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,count;
bitmap.fill(get_black_pen(machine()), cliprect);
// draw playfield
if (m_layer & 2)
{
const UINT8 *blit_data = memregion("gfx2")->base();
count = 0;
for(y=0;y<192;y++)
{
for(x=0;x<256;x+=8)
{
UINT32 pen_r,pen_g,pen_b,color;
int xi;
pen_r = (blit_data[count] & 0xff)>>0;
pen_g = (blit_data[count+0x2000] & 0xff)>>0;
pen_b = (blit_data[count+0x4000] & 0xff)>>0;
for(xi=0;xi<8;xi++)
{
if(cliprect.contains(x+xi, y))
{
color = ((pen_r >> (7-xi)) & 1)<<0;
color|= ((pen_g >> (7-xi)) & 1)<<1;
color|= ((pen_b >> (7-xi)) & 1)<<2;
bitmap.pix32(y, x+xi) = machine().pens[color+0x80];
}
}
count++;
}
}
}
uint32_t rohga_state::screen_update_wizdfire(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
address_space &space = machine().dummy_space();
uint16_t flip = m_deco_tilegen[0]->pf_control_r(space, 0, 0xffff);
uint16_t priority = m_decocomn->priority_r();
// sprites are flipped relative to tilemaps
flip_screen_set(BIT(flip, 7));
m_sprgen[0]->set_flip_screen(!BIT(flip, 7));
m_sprgen[1]->set_flip_screen(!BIT(flip, 7));
/* draw sprite gfx to temp bitmaps */
m_sprgen[1]->draw_sprites(bitmap, cliprect, m_spriteram[1]->buffer(), 0x400);
m_sprgen[0]->draw_sprites(bitmap, cliprect, m_spriteram[0]->buffer(), 0x400);
/* Update playfields */
m_deco_tilegen[0]->pf_update(nullptr, nullptr);
m_deco_tilegen[1]->pf_update(m_pf_rowscroll[2], m_pf_rowscroll[3]);
/* Draw playfields - Palette of 2nd playfield chip visible if playfields turned off */
bitmap.fill(m_palette->pen(512), cliprect);
m_deco_tilegen[1]->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_sprgen[0]->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0600, 0x0600, 0x400, 0x1ff);
m_deco_tilegen[0]->tilemap_2_draw(screen, bitmap, cliprect, 0, 0);
m_sprgen[0]->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0400, 0x0600, 0x400, 0x1ff);
if ((priority & 0x1f) == 0x1f) /* Wizdfire has bit 0x40 always set, Dark Seal 2 doesn't?! */
m_deco_tilegen[1]->tilemap_1_draw(screen, bitmap, cliprect, TILEMAP_DRAW_ALPHA(0x80), 0);
else
m_deco_tilegen[1]->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
m_sprgen[0]->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0000, 0x0400, 0x400, 0x1ff); // 0x000 and 0x200 of 0x600
mixwizdfirelayer(bitmap, cliprect, 0x000, 0x000);
m_deco_tilegen[0]->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
UINT32 lemmings_state::screen_update_lemmings(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x1 = -m_control_data[0];
int x0 = -m_control_data[2];
int y = 0;
rectangle rect;
rect.max_y = cliprect.max_y;
rect.min_y = cliprect.min_y;
m_sprgen->draw_sprites(bitmap, cliprect, m_sprite_triple_buffer_1, 0x400, true);
m_sprgen2->draw_sprites(bitmap, cliprect, m_sprite_triple_buffer_0, 0x400, true);
bitmap.fill(m_palette->black_pen(), cliprect);
m_sprgen->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0800, 0x0800, 0x300, 0xff);
/* Pixel layer can be windowed in hardware (two player mode) */
if ((m_control_data[6] & 2) == 0)
{
lemmings_copy_bitmap(bitmap, m_bitmap0, &x1, &y, cliprect);
}
else
{
rect.max_x = 159;
rect.min_x = 0;
lemmings_copy_bitmap(bitmap, m_bitmap0, &x0, &y, rect);
rect.max_x = 319;
rect.min_x = 160;
lemmings_copy_bitmap(bitmap, m_bitmap0, &x1, &y, rect);
}
m_sprgen2->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0800, 0x0800, 0x200, 0xff);
m_sprgen->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0000, 0x0800, 0x300, 0xff);
m_vram_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_sprgen2->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0000, 0x0800, 0x200, 0xff);
return 0;
}
UINT32 isa8_cga_tetriskr_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y;
int yi;
const UINT8 *bg_rom = memregion("gfx2")->base();
//popmessage("%04x",m_start_offs);
bitmap.fill(rgb_t::black, cliprect);
for(y=0;y<200/8;y++)
{
for(yi=0;yi<8;yi++)
{
for(x=0;x<320/8;x++)
{
UINT8 color;
int xi,pen_i;
for(xi=0;xi<8;xi++)
{
color = 0;
/* TODO: first byte seems bogus? */
for(pen_i = 0;pen_i<4;pen_i++)
color |= ((bg_rom[y*320/8+x+(pen_i*0x20000)+yi*0x400+m_bg_bank*0x2000+1] >> (7-xi)) & 1) << pen_i;
if(cliprect.contains(x*8+xi, y*8+yi))
bitmap.pix32(y*8+yi, x*8+xi) = m_palette->pen(color);
}
}
}
}
isa8_cga_device::screen_update(screen, bitmap, cliprect);
return 0;
}