UINT32 matmania_state::screen_update_matmania(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT8 *spriteram = m_spriteram;
int offs;
/* Update the tiles in the left tile ram bank */
for (offs = m_videoram.bytes() - 1; offs >= 0; offs--)
{
int sx = 15 - offs / 32;
int sy = offs % 32;
drawgfx_opaque(*m_tmpbitmap, m_tmpbitmap->cliprect(), machine().gfx[1],
m_videoram[offs] + ((m_colorram[offs] & 0x08) << 5),
(m_colorram[offs] & 0x30) >> 4,
0,sy >= 16, /* flip horizontally tiles on the right half of the bitmap */
16 * sx, 16 * sy);
}
/* Update the tiles in the right tile ram bank */
for (offs = m_videoram3.bytes() - 1; offs >= 0; offs--)
{
int sx = 15 - offs / 32;
int sy = offs % 32;
drawgfx_opaque(*m_tmpbitmap2, m_tmpbitmap2->cliprect(), machine().gfx[1],
m_videoram3[offs] + ((m_colorram3[offs] & 0x08) << 5),
(m_colorram3[offs] & 0x30) >> 4,
0,sy >= 16, /* flip horizontally tiles on the right half of the bitmap */
16*sx,16*sy);
}
/* copy the temporary bitmap to the screen */
{
int scrolly = -*m_scroll;
if (m_pageselect[0] & 0x01) // maniach sets 0x20 sometimes, which must have a different meaning
copyscrollbitmap(bitmap, *m_tmpbitmap2, 0, 0, 1, &scrolly, cliprect);
else
copyscrollbitmap(bitmap, *m_tmpbitmap, 0, 0, 1, &scrolly, cliprect);
}
/* Draw the sprites */
for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
{
if (spriteram[offs] & 0x01)
{
drawgfx_transpen(bitmap, cliprect, machine().gfx[2],
spriteram[offs + 1] + ((spriteram[offs] & 0xf0) << 4),
(spriteram[offs] & 0x08) >> 3,
spriteram[offs] & 0x04, spriteram[offs] & 0x02,
239 - spriteram[offs + 3],(240 - spriteram[offs + 2]) & 0xff,0);
}
}
static void tdfever_draw_bg(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int xscroll, int yscroll )
{
const UINT8 *source = snk_rambase + 0x000;
const gfx_element *gfx = machine->gfx[1];
int tile_number, attributes, color, sx, sy;
int offs, x, y;
for(x = 0; x < 32; x++) for(y = 0; y < 32; y++)
{
offs = (x<<6)+(y<<1);
tile_number = source[offs];
attributes = source[offs+1];
tile_number |= (attributes & 0xf) << 8;
color = attributes >> 4;
sx = x << 4;
sy = y << 4;
// intercept overflown tile indices
if(tile_number >= gfx->total_elements)
plot_box(tmpbitmap, sx, sy, gfx->width, gfx->height, get_black_pen(machine));
else
drawgfx(tmpbitmap,gfx,tile_number,color,0,0,sx,sy,0,TRANSPARENCY_NONE,0);
}
copyscrollbitmap(bitmap,tmpbitmap,1,&xscroll,1,&yscroll,cliprect);
}
static void tnk3_draw_background(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int scrollx, int scrolly,
int x_size, int y_size, int bg_type )
{
const gfx_element *gfx = machine->gfx[1];
int tile_number, attributes, color, sx, sy;
int offs, x, y;
/* to be moved to memmap */
for(x=0; x<x_size; x++) for(y=0; y<y_size; y++)
{
offs = (x*y_size + y) << 1;
tile_number = videoram[offs];
attributes = videoram[offs+1];
if(bg_type == 0)
{
/* type tnk3 */
tile_number |= (attributes & 0x30) << 4;
color = (attributes & 0xf) ^ 8;
}
else
{
/* type ikari */
tile_number |= (attributes & 0x03) << 8;
color = attributes >> 4;
}
sx = x * 512 / x_size;
sy = y * 512 / y_size;
drawgfx(tmpbitmap,gfx,tile_number,color,0,0,sx,sy,0,TRANSPARENCY_NONE,0);
}
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect);
}
static void draw_background(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
{
int my,mx,offs,color,tile,fx,fy;
int scrollx=karnov_scroll[0];
int scrolly=karnov_scroll[1];
if (flipscreen) fx=fy=1; else fx=fy=0;
mx=-1; my=0;
for (offs = 0;offs < 0x400; offs ++) {
mx++;
if (mx==32) {mx=0; my++;}
tile=karnov_pf_data[offs];
color = tile >> 12;
tile = tile&0x7ff;
if (flipscreen)
drawgfx(bitmap_f,machine->gfx[1],tile,
color, fx, fy, 496-16*mx,496-16*my,
0,TRANSPARENCY_NONE,0);
else
drawgfx(bitmap_f,machine->gfx[1],tile,
color, fx, fy, 16*mx,16*my,
0,TRANSPARENCY_NONE,0);
}
if (!flipscreen) {
scrolly=-scrolly;
scrollx=-scrollx;
} else {
scrolly=scrolly+256;
scrollx=scrollx+256;
}
copyscrollbitmap(bitmap,bitmap_f,1,&scrollx,1,&scrolly,cliprect);
}
static void draw_bg(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
{
int offs;
int scroll[256];
for (offs = 0;offs < 0x400;offs++)
{
int code = videoram[0x400+offs];
int sx = offs % 32;
int sy = offs / 32;
if (flip_screen_x_get(machine)) sx = 31 - sx;
if (flip_screen_y_get(machine)) sy = 31 - sy;
drawgfx_opaque(tmpbitmap1,NULL,machine->gfx[0],
code,
2,
flip_screen_x_get(machine),flip_screen_y_get(machine),
8*sx,8*sy);
}
/* first copy to a temp bitmap doing column scroll */
for (offs = 0;offs < 256;offs++)
scroll[offs] = -buggychl_scrollv[offs/8];
copyscrollbitmap(tmpbitmap2,tmpbitmap1,1,&bg_scrollx,256,scroll,NULL);
/* then copy to the screen doing row scroll */
for (offs = 0;offs < 256;offs++)
scroll[offs] = -buggychl_scrollh[offs];
copyscrollbitmap_trans(bitmap,tmpbitmap2,256,scroll,0,0,cliprect,32);
}
static void draw_background(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect)
{
int my,mx,offs,color,tile,fx,fy;
int scrollx=karnov_scroll[0];
int scrolly=karnov_scroll[1];
if (flipscreen) fx=fy=1; else fx=fy=0;
/* 1st area is stored along X-axis... */
mx=-1; my=0;
for (offs = 0;offs < 0x400; offs ++) {
mx++;
if (mx==32) {mx=0; my++;}
if (!dirty_f[offs]) continue; else dirty_f[offs]=0;
tile=karnov_pf_data[offs];
color = tile >> 12;
tile = tile&0x7ff;
if (flipscreen)
drawgfx(bitmap_f,machine->gfx[1],tile,
color, fx, fy, 496-16*mx,496-16*my,
0,TRANSPARENCY_NONE,0);
else
drawgfx(bitmap_f,machine->gfx[1],tile,
color, fx, fy, 16*mx,16*my,
0,TRANSPARENCY_NONE,0);
}
/* 2nd area is stored along Y-axis... */
mx=0; my=-1;
for (offs = 0x400 ;offs < 0x800; offs ++) {
my++;
if (my==32) {my=0; mx++;}
if (!dirty_f[offs]) continue; else dirty_f[offs]=0;
tile=karnov_pf_data[offs];
color = tile >> 12;
tile=tile&0x7ff;
if (flipscreen)
drawgfx(bitmap_f,machine->gfx[1],tile,
color, fx, fy, 496-16*mx,496-16*my,
0,TRANSPARENCY_NONE,0);
else
drawgfx(bitmap_f,machine->gfx[1],tile,
color, fx, fy, 16*mx,16*my,
0,TRANSPARENCY_NONE,0);
}
if (!flipscreen) {
scrolly=-scrolly;
scrollx=-scrollx;
} else {
scrolly=scrolly+256;
scrollx=scrollx+256;
}
copyscrollbitmap(bitmap,bitmap_f,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_NONE,0);
}
/***************************************************************************
draw_foreground
???
**************************************************************************/
static void draw_foreground( struct osd_bitmap *bitmap, int priority, int opaque )
{
int offs;
int scroll = -(horiz_scroll_low + horiz_scroll_high);
for (offs = 0; offs<videoram_size; offs+=2 )
{
int sy = 8 * ((offs/2) / 64);
int sx = 8 * ((offs/2) % 64);
int attributes = videoram[offs+1];
int color = attributes & 0x0F;
int tile_number = videoram[offs] | ((attributes & 0xF0) << 4);
if (priority) /* foreground */
{
if ((color & 0x0c) == 0x0c) /* mask sprites */
{
if (sy >= 48)
{
sx = (sx + scroll) & 0x1ff;
if (sx > 16*8-8 && sx < 48*8)
{
drawgfx(bitmap,Machine->gfx[0],
tile_number,
color,
0,0,
sx,sy,
&bottomvisiblearea,TRANSPARENCY_PENS,0x00ff);
}
}
}
}
else /* background */
{
if (dirtybuffer[offs] || dirtybuffer[offs+1])
{
dirtybuffer[offs] = dirtybuffer[offs+1] = 0;
drawgfx(tmpbitmap,Machine->gfx[0],
tile_number,
color,
0,0,
sx,sy,
0,TRANSPARENCY_NONE,0);
}
}
}
if (priority == 0)
{
copybitmap(bitmap,tmpbitmap,0,0,0,0,&topvisiblearea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scroll,0,0,&bottomvisiblearea,
opaque ? TRANSPARENCY_NONE : TRANSPARENCY_PEN,palette_transparent_pen);
}
}
UINT32 epson_lx810l_t::screen_update_lx810l(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int scrolly = -bitmap_line(9);
copyscrollbitmap(bitmap, m_bitmap, 0, nullptr, 1, &scrolly, cliprect);
/* draw "printhead" */
bitmap.plot_box(m_real_cr_pos + CR_OFFSET - 10, PAPER_HEIGHT - 36, 20, 36, 0x888888);
return 0;
}
static void draw_bg(mame_bitmap *bitmap)
{
int offs;
int scroll[256];
for (offs = 0;offs < 0x400;offs++)
{
int code = videoram[0x400+offs];
if (dirtybuffer[0x400+offs] || dirtychar[code])
{
int sx = offs % 32;
int sy = offs / 32;
dirtybuffer[0x400+offs] = 0;
if (flip_screen_x) sx = 31 - sx;
if (flip_screen_y) sy = 31 - sy;
drawgfx(tmpbitmap1,Machine->gfx[0],
code,
2,
flip_screen_x,flip_screen_y,
8*sx,8*sy,
NULL,TRANSPARENCY_NONE,0);
}
}
/* first copy to a temp bitmap doing column scroll */
for (offs = 0;offs < 256;offs++)
scroll[offs] = -buggychl_scrollv[offs/8];
copyscrollbitmap(tmpbitmap2,tmpbitmap1,1,&bg_scrollx,256,scroll,NULL,TRANSPARENCY_NONE,0);
/* then copy to the screen doing row scroll */
for (offs = 0;offs < 256;offs++)
scroll[offs] = -buggychl_scrollh[offs];
copyscrollbitmap(bitmap,tmpbitmap2,256,scroll,0,0,&Machine->screen[0].visarea,TRANSPARENCY_COLOR,32);
}
/***************************************************************************
draw_background
???
**************************************************************************/
static void draw_background( struct osd_bitmap *bitmap )
{
int scrollx = 0x17a + 16*8 - (rear_horiz_scroll_low + rear_horiz_scroll_high);
if (rear_refresh)
{
update_background( );
rear_refresh=0;
}
copyscrollbitmap(bitmap,bg_bitmap,1,&scrollx,0,0,&bottomvisiblearea,TRANSPARENCY_NONE,0);
}
void kangaroo_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int scrollx, scrolly;
if (palette_recalc() || screen_flipped)
{
int x, y;
/* redraw bitmap */
for (x = 0; x < 256; x+=4)
{
for (y = 0; y < 256; y++)
{
kangaroo_redraw_4pixels(x, y);
}
}
screen_flipped = 0;
}
scrollx = kangaroo_scroll[1];
scrolly = kangaroo_scroll[0];
if (*kangaroo_bank_select & 0x01)
{
/* Plane B is primary */
copybitmap(bitmap,tmpbitmap2,0,0,0,0,&Machine->visible_area,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->visible_area,TRANSPARENCY_COLOR,8);
}
else
{
/* Plane A is primary */
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->visible_area,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap2,0,0,0,0,&Machine->visible_area,TRANSPARENCY_COLOR,16);
}
}
void atarifb_state::draw_playfield_and_alpha( bitmap_ind16 &bitmap, const rectangle &cliprect, int playfield_x_offset, int playfield_y_offset )
{
const rectangle bigfield_area(4 * 8, 34 * 8 - 1, 0 * 8, 32 * 8 - 1);
int scroll_x[1];
int scroll_y[1];
scroll_x[0] = - *m_scroll_register + 32 + playfield_x_offset;
scroll_y[0] = 8 + playfield_y_offset;
copybitmap(bitmap, m_alpha1_tilemap->pixmap(), 0, 0, 35*8, 1*8, cliprect);
copybitmap(bitmap, m_alpha2_tilemap->pixmap(), 0, 0, 0*8, 1*8, cliprect);
copyscrollbitmap(bitmap, m_field_tilemap->pixmap(), 1, scroll_x, 1, scroll_y, bigfield_area);
}
// most of this came from pinmame as the diagram doesn't make a lot of sense
uint32_t mrgame_state::screen_update_mrgame(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
uint8_t x,y,ptr=0,col;
int32_t scrolly[32];
uint16_t chr;
bool flipx,flipy;
// text
for (x = 0; x < 32; x++)
{
scrolly[x] = -m_p_objectram[ptr++];
col = m_p_objectram[ptr++];
for (y = 0; y < 32; y++)
{
chr = m_p_videoram[x+y*32] | (m_gfx_bank << 8);
m_gfxdecode->gfx(0)->opaque(*m_tile_bitmap, m_tile_bitmap->cliprect(),
chr,
col,
m_flip,0,
x*8,y*8);
}
}
// scroll each column as needed
copyscrollbitmap(bitmap,*m_tile_bitmap,0,nullptr,32,scrolly,cliprect);
// sprites
for (ptr = 0x40; ptr < 0x60; ptr += 4)
{
x = m_p_objectram[ptr + 3] + 1;
y = 255 - m_p_objectram[ptr];
flipx = BIT(m_p_objectram[ptr + 1], 6);
flipy = BIT(m_p_objectram[ptr + 1], 7);
chr = (m_p_objectram[ptr + 1] & 0x3f) | (m_gfx_bank << 6);
col = m_p_objectram[ptr + 2];
if ((y > 16) && (x > 24))
m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
chr,
col,
flipx,flipy,
x,y-16,0);
}
return 0;
}
static void draw_playfield_and_alpha( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int playfield_x_offset, int playfield_y_offset )
{
atarifb_state *state = machine.driver_data<atarifb_state>();
const rectangle bigfield_area(4 * 8, 34 * 8 - 1, 0 * 8, 32 * 8 - 1);
int scroll_x[1];
int scroll_y[1];
scroll_x[0] = - *state->m_scroll_register + 32 + playfield_x_offset;
scroll_y[0] = 8 + playfield_y_offset;
copybitmap(bitmap, state->m_alpha1_tilemap->pixmap(), 0, 0, 35*8, 1*8, cliprect);
copybitmap(bitmap, state->m_alpha2_tilemap->pixmap(), 0, 0, 0*8, 1*8, cliprect);
copyscrollbitmap(bitmap, state->m_field_tilemap->pixmap(), 1, scroll_x, 1, scroll_y, bigfield_area);
}
static void draw_background( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
karnov_state *state = machine.driver_data<karnov_state>();
int my, mx, offs, color, tile, fx, fy;
int scrollx = state->m_scroll[0];
int scrolly = state->m_scroll[1];
if (state->m_flipscreen)
fx = fy = 1;
else
fx = fy = 0;
mx = -1;
my = 0;
for (offs = 0; offs < 0x400; offs ++)
{
mx++;
if (mx == 32)
{
mx=0;
my++;
}
tile = state->m_pf_data[offs];
color = tile >> 12;
tile = tile & 0x7ff;
if (state->m_flipscreen)
drawgfx_opaque(*state->m_bitmap_f, state->m_bitmap_f->cliprect(), machine.gfx[1],tile,
color, fx, fy, 496-16*mx,496-16*my);
else
drawgfx_opaque(*state->m_bitmap_f, state->m_bitmap_f->cliprect(), machine.gfx[1],tile,
color, fx, fy, 16*mx,16*my);
}
if (!state->m_flipscreen)
{
scrolly = -scrolly;
scrollx = -scrollx;
}
else
{
scrolly = scrolly + 256;
scrollx = scrollx + 256;
}
copyscrollbitmap(bitmap, *state->m_bitmap_f, 1, &scrollx, 1, &scrolly, cliprect);
}
static void draw_background( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect )
{
karnov_state *state = (karnov_state *)machine->driver_data;
int my, mx, offs, color, tile, fx, fy;
int scrollx = state->scroll[0];
int scrolly = state->scroll[1];
if (state->flipscreen)
fx = fy = 1;
else
fx = fy = 0;
mx = -1;
my = 0;
for (offs = 0; offs < 0x400; offs ++)
{
mx++;
if (mx == 32)
{
mx=0;
my++;
}
tile = state->pf_data[offs];
color = tile >> 12;
tile = tile & 0x7ff;
if (state->flipscreen)
drawgfx_opaque(state->bitmap_f, 0, machine->gfx[1],tile,
color, fx, fy, 496-16*mx,496-16*my);
else
drawgfx_opaque(state->bitmap_f, 0, machine->gfx[1],tile,
color, fx, fy, 16*mx,16*my);
}
if (!state->flipscreen)
{
scrolly = -scrolly;
scrollx = -scrollx;
}
else
{
scrolly = scrolly + 256;
scrollx = scrollx + 256;
}
copyscrollbitmap(bitmap, state->bitmap_f, 1, &scrollx, 1, &scrolly, cliprect);
}
int nmk16_state::nmk16_bioshipbg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT16 *tilerom = (UINT16 *)memregion("gfx5")->base();
int scrollx=-(m_bioship_scroll[1] + m_bioship_scroll[0]*256);
int scrolly=-(m_bioship_scroll[3] + m_bioship_scroll[2]*256);
m_tx_tilemap->set_scrollx(0,-m_videoshift);
if (m_redraw_bitmap)
{
int bank = m_bioship_background_bank * 0x2000;
int sx=0, sy=0, offs;
m_redraw_bitmap=0;
/* Draw background from tile rom */
for (offs = 0;offs <0x1000;offs++) {
UINT16 data = tilerom[offs+bank];
int numtile = data&0xfff;
int color = (data&0xf000)>>12;
m_gfxdecode->gfx(3)->opaque(*m_background_bitmap,m_background_bitmap->cliprect(),
numtile,
color,
0,0, /* no flip */
16*sx,16*sy);
data = tilerom[offs+0x1000+bank];
numtile = data&0xfff;
color = (data&0xf000)>>12;
m_gfxdecode->gfx(3)->opaque(*m_background_bitmap,m_background_bitmap->cliprect(),
numtile,
color,
0,0, /* no flip */
16*sx,(16*sy)+256);
sy++;
if (sy==16) {sy=0; sx++;}
}
}
copyscrollbitmap(bitmap,*m_background_bitmap,1,&scrollx,1,&scrolly,cliprect);
m_bg_tilemap0->draw(screen, bitmap, cliprect, 0,0);
nmk16_draw_sprites(bitmap,cliprect);
m_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}
UINT32 pcw_state::screen_update_pcw_printer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
// printer output
INT32 feed;
rectangle rect(0, PCW_PRINTER_WIDTH - 1, 0, PCW_PRINTER_HEIGHT - 1);
feed = -(m_paper_feed / 2);
copyscrollbitmap(bitmap,*m_prn_output,0,NULL,1,&feed,rect);
bitmap.pix16(PCW_PRINTER_HEIGHT-1, m_printer_headpos) = 0;
bitmap.pix16(PCW_PRINTER_HEIGHT-2, m_printer_headpos) = 0;
bitmap.pix16(PCW_PRINTER_HEIGHT-3, m_printer_headpos) = 0;
bitmap.pix16(PCW_PRINTER_HEIGHT-1, m_printer_headpos-1) = 0;
bitmap.pix16(PCW_PRINTER_HEIGHT-2, m_printer_headpos-1) = 0;
bitmap.pix16(PCW_PRINTER_HEIGHT-1, m_printer_headpos+1) = 0;
bitmap.pix16(PCW_PRINTER_HEIGHT-2, m_printer_headpos+1) = 0;
return 0;
}
void buggychl_state::draw_bg( bitmap_ind16 &bitmap, const rectangle &cliprect )
{
int offs;
int scroll[256];
/* prevent wraparound */
rectangle clip = cliprect;
// enable clipping if on (title screen disable this to cover all of the area)
if(m_bg_clip_on)
{
if (flip_screen_x()) clip.min_x += 8*8;
else clip.max_x -= 8*8;
}
for (offs = 0; offs < 0x400; offs++)
{
int code = m_videoram[0x400 + offs];
int sx = offs % 32;
int sy = offs / 32;
if (flip_screen_x())
sx = 31 - sx;
if (flip_screen_y())
sy = 31 - sy;
m_gfxdecode->gfx(0)->opaque(m_tmp_bitmap1,m_tmp_bitmap1.cliprect(),
code,
2,
flip_screen_x(),flip_screen_y(),
8*sx,8*sy);
}
/* first copy to a temp bitmap doing column scroll */
for (offs = 0; offs < 256; offs++)
scroll[offs] = -m_scrollv[offs / 8];
copyscrollbitmap(m_tmp_bitmap2, m_tmp_bitmap1, 1, &m_bg_scrollx, 256, scroll, m_tmp_bitmap2.cliprect());
/* then copy to the screen doing row scroll */
for (offs = 0; offs < 256; offs++)
scroll[offs] = -m_scrollh[offs];
copyscrollbitmap_trans(bitmap, m_tmp_bitmap2, 256, scroll, 0, nullptr, clip, 32);
}
static void pf2_render_callback(const struct rectangle *clip, const struct rectangle *tiles, const struct atarigen_pf_state *state, void *param)
{
const struct GfxElement *gfx = Machine->gfx[0];
struct osd_bitmap *bitmap = param;
int x, y;
/* standard loop over tiles */
for (x = tiles->min_x; x != tiles->max_x; x = (x + 1) & 63)
for (y = tiles->min_y; y != tiles->max_y; y = (y + 1) & 63)
{
int offs = x * 64 + y;
/* update only if dirty */
if (atarigen_pf2_dirty[offs])
{
int data1 = READ_WORD(&atarigen_playfield2ram[offs * 2]);
int data2 = READ_WORD(&atarigen_playfieldram_color[offs * 2]);
int color = (data2 >> 8) & 0x0f;
int code = data1 & 0x7fff;
int hflip = data1 & 0x8000;
drawgfx(atarigen_pf2_bitmap, gfx, code, color, hflip, 0, 8 * x, 8 * y, 0, TRANSPARENCY_NONE, 0);
atarigen_pf2_dirty[offs] = 0;
#if DEBUG_VIDEO
if (show_colors == 2)
{
drawgfx(atarigen_pf2_bitmap, Machine->uifont, "0123456789ABCDEF"[color], 1, 0, 0, 8 * x + 0, 8 * y, 0, TRANSPARENCY_PEN, 0);
drawgfx(atarigen_pf2_bitmap, Machine->uifont, "0123456789ABCDEF"[color], 1, 0, 0, 8 * x + 2, 8 * y, 0, TRANSPARENCY_PEN, 0);
drawgfx(atarigen_pf2_bitmap, Machine->uifont, "0123456789ABCDEF"[color], 0, 0, 0, 8 * x + 1, 8 * y, 0, TRANSPARENCY_PEN, 0);
}
#endif
}
/* track the tiles we've visited */
atarigen_pf2_visit[offs] = 1;
}
/* then blast the result */
x = -state->hscroll;
y = -state->vscroll;
copyscrollbitmap(bitmap, atarigen_pf2_bitmap, 1, &x, 1, &y, clip, TRANSPARENCY_PEN, palette_transparent_pen);
}
static void draw_background( mame_bitmap *bitmap )
{
/*
ROM B1.2C contains 256 tilemaps defining 4x4 configurations of
the tiles in ROM B2.2B
*/
unsigned char *tile_data = memory_region(REGION_GFX2);
const gfx_element *gfx = Machine->gfx[1];
int offs;
for( offs=0; offs<0x100; offs++ )
{
if( dirtybuffer[offs] )
{
int sy = (offs%16)*32;
int sx = (offs/16)*32;
int tile_number = videoram[offs];
int row,col;
dirtybuffer[offs] = 0;
for( row=0; row<4; row++ )
{
for( col=0; col<4; col++ )
{
drawgfx( tmpbitmap,gfx,
tile_data[col+tile_number*4+row*0x400],
mnchmobl_palette_bank,
0,0, /* flip */
sx+col*8, sy+row*8,
0, TRANSPARENCY_NONE, 0 );
}
}
}
}
{
int scrollx = -(mnchmobl_vreg[6]*2+(mnchmobl_vreg[7]>>7))-64-128-16;
int scrolly = 0;
copyscrollbitmap(bitmap,tmpbitmap,
1,&scrollx,1,&scrolly,
&Machine->visible_area,TRANSPARENCY_NONE,0);
}
}
static void draw_bg( running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect )
{
buggychl_state *state = machine.driver_data<buggychl_state>();
int offs;
int scroll[256];
/* prevent wraparound */
rectangle clip = *cliprect;
if (flip_screen_x_get(machine)) clip.min_x += 8*8;
else clip.max_x -= 8*8;
for (offs = 0; offs < 0x400; offs++)
{
int code = state->m_videoram[0x400 + offs];
int sx = offs % 32;
int sy = offs / 32;
if (flip_screen_x_get(machine))
sx = 31 - sx;
if (flip_screen_y_get(machine))
sy = 31 - sy;
drawgfx_opaque(state->m_tmp_bitmap1, NULL, machine.gfx[0],
code,
2,
flip_screen_x_get(machine),flip_screen_y_get(machine),
8*sx,8*sy);
}
/* first copy to a temp bitmap doing column scroll */
for (offs = 0; offs < 256; offs++)
scroll[offs] = -state->m_scrollv[offs / 8];
copyscrollbitmap(state->m_tmp_bitmap2, state->m_tmp_bitmap1, 1, &state->m_bg_scrollx, 256, scroll, NULL);
/* then copy to the screen doing row scroll */
for (offs = 0; offs < 256; offs++)
scroll[offs] = -state->m_scrollh[offs];
copyscrollbitmap_trans(bitmap, state->m_tmp_bitmap2, 256, scroll, 0, 0, &clip, 32);
}
static void sgladiat_draw_background(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int scrollx, int scrolly )
{
const gfx_element *gfx = machine->gfx[1];
int tile_number, color, sx, sy;
int offs, x, y;
for(x = 0; x < 64; x++) for(y = 0; y < 32; y++)
{
offs = (x<<5)+y;
tile_number = videoram[offs];
color = 0;
sx = x << 3;
sy = y << 3;
drawgfx(tmpbitmap,gfx,tile_number,color,0,0,sx,sy,0,TRANSPARENCY_NONE,0);
}
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect);
}
void buggychl_state::draw_bg( bitmap_ind16 &bitmap, const rectangle &cliprect )
{
int offs;
int scroll[256];
/* prevent wraparound */
rectangle clip = cliprect;
if (flip_screen_x()) clip.min_x += 8*8;
else clip.max_x -= 8*8;
for (offs = 0; offs < 0x400; offs++)
{
int code = m_videoram[0x400 + offs];
int sx = offs % 32;
int sy = offs / 32;
if (flip_screen_x())
sx = 31 - sx;
if (flip_screen_y())
sy = 31 - sy;
drawgfx_opaque(m_tmp_bitmap1, m_tmp_bitmap1.cliprect(), machine().gfx[0],
code,
2,
flip_screen_x(),flip_screen_y(),
8*sx,8*sy);
}
/* first copy to a temp bitmap doing column scroll */
for (offs = 0; offs < 256; offs++)
scroll[offs] = -m_scrollv[offs / 8];
copyscrollbitmap(m_tmp_bitmap2, m_tmp_bitmap1, 1, &m_bg_scrollx, 256, scroll, m_tmp_bitmap2.cliprect());
/* then copy to the screen doing row scroll */
for (offs = 0; offs < 256; offs++)
scroll[offs] = -m_scrollh[offs];
copyscrollbitmap_trans(bitmap, m_tmp_bitmap2, 256, scroll, 0, 0, clip, 32);
}
static void draw_background(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
{
/*
ROM B1.2C contains 256 tilemaps defining 4x4 configurations of
the tiles in ROM B2.2B
*/
UINT8 *rom = memory_region(machine, "gfx2");
const gfx_element *gfx = machine->gfx[1];
int offs;
for( offs=0; offs<0x100; offs++ )
{
int sy = (offs%16)*32;
int sx = (offs/16)*32;
int tile_number = videoram[offs];
int row,col;
for( row=0; row<4; row++ )
{
for( col=0; col<4; col++ )
{
drawgfx_opaque( tmpbitmap,0, gfx,
rom[col+tile_number*4+row*0x400],
mnchmobl_palette_bank,
0,0, /* flip */
sx+col*8, sy+row*8 );
}
}
}
{
int scrollx = -(mnchmobl_vreg[6]*2+(mnchmobl_vreg[7]>>7))-64-128-16;
int scrolly = 0;
copyscrollbitmap(bitmap,tmpbitmap, 1,&scrollx,1,&scrolly, cliprect);
}
}
uint32_t megazone_state::screen_update_megazone(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int offs;
int x, y;
/* for every character in the Video RAM */
for (offs = m_videoram.bytes() - 1; offs >= 0; offs--)
{
int sx, sy, flipx, flipy;
sx = offs % 32;
sy = offs / 32;
flipx = m_colorram[offs] & (1 << 6);
flipy = m_colorram[offs] & (1 << 5);
if (m_flipscreen)
{
sx = 31 - sx;
sy = 31 - sy;
flipx = !flipx;
flipy = !flipy;
}
m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
((int)m_videoram[offs]) + ((m_colorram[offs] & (1 << 7) ? 256 : 0) ),
(m_colorram[offs] & 0x0f) + 0x10,
flipx,flipy,
8*sx,8*sy);
}
/* copy the temporary bitmap to the screen */
{
int scrollx;
int scrolly;
if (m_flipscreen)
{
scrollx = *m_scrolly;
scrolly = *m_scrollx;
}
else
{
scrollx = - *m_scrolly + 4 * 8; // leave space for credit&score overlay
scrolly = - *m_scrollx;
}
copyscrollbitmap(bitmap, *m_tmpbitmap, 1, &scrollx, 1, &scrolly, cliprect);
}
/* Draw the sprites. */
{
uint8_t *spriteram = m_spriteram;
for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
{
int sx = spriteram[offs + 3];
int sy = 255 - ((spriteram[offs + 1] + 16) & 0xff);
int color = spriteram[offs + 0] & 0x0f;
int flipx = ~spriteram[offs + 0] & 0x40;
int flipy = spriteram[offs + 0] & 0x80;
if (m_flipscreen)
{
sx = sx - 11;
sy = sy + 2;
}
else
sx = sx + 32;
m_gfxdecode->gfx(0)->transmask(bitmap,cliprect,
spriteram[offs + 2],
color,
flipx,flipy,
sx,sy,
m_palette->transpen_mask(*m_gfxdecode->gfx(0), color, 0));
}
}
for (y = 0; y < 32;y++)
{
offs = y * 32;
for (x = 0; x < 6; x++)
{
int sx, sy, flipx, flipy;
sx = x;
sy = y;
flipx = m_colorram2[offs] & (1 << 6);
flipy = m_colorram2[offs] & (1 << 5);
if (m_flipscreen)
{
sx = 35 - sx;
sy = 31 - sy;
flipx = !flipx;
flipy = !flipy;
}
m_gfxdecode->gfx(1)->opaque(bitmap,cliprect,
((int)m_videoram2[offs]) + ((m_colorram2[offs] & (1 << 7) ? 256 : 0) ),
(m_colorram2[offs] & 0x0f) + 0x10,
flipx,flipy,
8*sx,8*sy);
offs++;
}
}
return 0;
}
/***************************************************************************
Draw the game screen in the given mame_bitmap.
Do NOT call osd_update_display() from this function, it will be called by
the main emulation engine.
***************************************************************************/
static void draw_chars(mame_bitmap *_tmpbitmap, mame_bitmap *bitmap,
int scroll_cols)
{
int offs;
if (get_vh_global_attribute_changed())
{
memset(dirtybuffer,1,videoram_size);
}
/* for every character in the Video RAM, check if it has been modified */
/* since last time and update it accordingly. */
for (offs = videoram_size - 1;offs >= 0;offs--)
{
if (dirtybuffer[offs])
{
int sx,sy,flipx,flipy;
dirtybuffer[offs] = 0;
sx = offs % 32;
sy = offs / 32;
flipx = colorram[offs] & 0x20;
flipy = colorram[offs] & 0x10;
if (flip_screen_y)
{
sy = 31 - sy;
flipy = !flipy;
}
if (flip_screen_x)
{
sx = 31 - sx;
flipx = !flipx;
}
drawgfx(_tmpbitmap,Machine->gfx[0],
videoram[offs] | ((colorram[offs] & 0xc0) << 2),
(colorram[offs] & 0x0f) + 16 * palbank,
flipx,flipy,
8*sx,8*sy,
0,TRANSPARENCY_NONE,0);
}
}
/* copy the temporary bitmap to the screen */
{
int scroll[32];
if (flip_screen_y)
{
for (offs = 0;offs < 32 - scroll_cols;offs++)
scroll[offs] = 0;
for (;offs < 32;offs++)
scroll[offs] = marineb_column_scroll[0];
}
else
{
for (offs = 0;offs < scroll_cols;offs++)
scroll[offs] = -marineb_column_scroll[0];
for (;offs < 32;offs++)
scroll[offs] = 0;
}
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,&Machine->visible_area,TRANSPARENCY_NONE,0);
}
}
void lwings_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int offs;
if (palette_recalc())
{
fast_memset(dirtybuffer2,1,lwings_backgroundram_size);
fast_memset(dirtybuffer4,1,lwings_backgroundram_size);
}
for (offs = lwings_backgroundram_size - 1;offs >= 0;offs--)
{
int sx,sy, colour;
/*
Tiles
=====
0x80 Tile code MSB
0x40 Tile code MSB
0x20 Tile code MSB
0x10 X flip
0x08 Y flip
0x04 Colour
0x02 Colour
0x01 Colour
*/
colour=(lwings_backgroundattribram[offs] & 0x07);
if (dirtybuffer2[offs] != 0 || dirtybuffer4[offs] != 0)
{
int code;
dirtybuffer2[offs] = dirtybuffer4[offs] = 0;
sx = offs / 32;
sy = offs % 32;
code=lwings_backgroundram[offs];
code+=((((int)lwings_backgroundattribram[offs]) &0xe0) <<3);
drawgfx(tmpbitmap2,Machine->gfx[1],
code,
colour,
(lwings_backgroundattribram[offs] & 0x08),
(lwings_backgroundattribram[offs] & 0x10),
16 * sx,16 * sy,
0,TRANSPARENCY_NONE,0);
}
}
/* copy the background graphics */
{
int scrollx,scrolly;
scrolly = -(lwings_scrollx[0] + 256 * lwings_scrollx[1]);
scrollx = -(lwings_scrolly[0] + 256 * lwings_scrolly[1]);
copyscrollbitmap(bitmap,tmpbitmap2,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
}
/* Draw the sprites. */
for (offs = spriteram_size - 4;offs >= 0;offs -= 4)
{
int code,sx,sy;
/*
Sprites
=======
0x80 Sprite code MSB
0x40 Sprite code MSB
0x20 Colour
0x10 Colour
0x08 Colour
0x04 Y flip
0x02 X flip
0x01 X MSB
*/
sx = spriteram[offs + 3] - 0x100 * (spriteram[offs + 1] & 0x01);
sy = spriteram[offs + 2];
if (sx && sy)
{
code = spriteram[offs];
code += (spriteram[offs + 1] & 0xc0) << 2;
drawgfx(bitmap,Machine->gfx[2],
code,
(spriteram[offs + 1] & 0x38) >> 3,
spriteram[offs + 1] & 0x02,spriteram[offs + 1] & 0x04,
sx,sy,
&Machine->drv->visible_area,TRANSPARENCY_PEN,15);
}
}
/***************************************************************************
Draw the game screen in the given osd_bitmap.
Do NOT call osd_update_display() from this function, it will be called by
the main emulation engine.
***************************************************************************/
void pbaction_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int offs;
/* recalc the palette if necessary */
if (palette_recalc())
{
memset(dirtybuffer,1,videoram_size);
memset(dirtybuffer2,1,videoram_size);
}
/* for every character in the Video RAM, check if it has been modified */
/* since last time and update it accordingly. */
for (offs = videoram_size - 1;offs >= 0;offs--)
{
if (dirtybuffer[offs])
{
int sx,sy,flipx,flipy;
dirtybuffer[offs] = 0;
sx = offs % 32;
sy = offs / 32;
flipx = colorram[offs] & 0x40;
flipy = colorram[offs] & 0x80;
if (flipscreen)
{
sx = 31 - sx;
sy = 31 - sy;
flipx = !flipx;
flipy = !flipy;
}
drawgfx(tmpbitmap,Machine->gfx[0],
videoram[offs] + 0x10 * (colorram[offs] & 0x30),
colorram[offs] & 0x0f,
flipx,flipy,
8*sx,8*sy,
&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
}
if (dirtybuffer2[offs])
{
int sx,sy,flipy;
dirtybuffer2[offs] = 0;
sx = offs % 32;
sy = offs / 32;
flipy = pbaction_colorram2[offs] & 0x80;
if (flipscreen)
{
sx = 31 - sx;
sy = 31 - sy;
flipy = !flipy;
}
drawgfx(tmpbitmap2,Machine->gfx[1],
pbaction_videoram2[offs] + 0x10 * (pbaction_colorram2[offs] & 0x70),
pbaction_colorram2[offs] & 0x0f,
flipscreen,flipy,
8*sx,8*sy,
&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
}
}
/* copy the background */
copyscrollbitmap(bitmap,tmpbitmap2,1,&scroll,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
/* Draw the sprites. */
for (offs = spriteram_size - 4;offs >= 0;offs -= 4)
{
int sx,sy,flipx,flipy;
/* if next sprite is double size, skip this one */
if (offs > 0 && spriteram[offs - 4] & 0x80) continue;
sx = spriteram[offs+3];
if (spriteram[offs] & 0x80)
sy = 225-spriteram[offs+2];
else
sy = 241-spriteram[offs+2];
flipx = spriteram[offs+1] & 0x40;
flipy = spriteram[offs+1] & 0x80;
if (flipscreen)
{
if (spriteram[offs] & 0x80)
{
sx = 224 - sx;
sy = 225 - sy;
}
else
{
sx = 240 - sx;
sy = 241 - sy;
}
flipx = !flipx;
flipy = !flipy;
}
drawgfx(bitmap,Machine->gfx[(spriteram[offs] & 0x80) ? 3 : 2], /* normal or double size */
spriteram[offs],
spriteram[offs + 1] & 0x0f,
flipx,flipy,
sx+scroll,sy,
&Machine->drv->visible_area,TRANSPARENCY_PEN,0);
}
/* copy the foreground */
copyscrollbitmap(bitmap,tmpbitmap,1,&scroll,0,0,&Machine->drv->visible_area,TRANSPARENCY_PEN,palette_transparent_pen);
}
static void draw_background( struct mame_bitmap *bitmap )
{
int offs;
const struct GfxElement *gfx = Machine->gfx[0];
for (offs = videoram_size - 2;offs >= 0;offs -= 2)
{
if (dirtybuffer[offs] || dirtybuffer[offs+1])
{
int sx,sy,code,attr,flipx;
dirtybuffer[offs] = dirtybuffer[offs+1] = 0;
sx = (offs/2) % 32;
sy = (offs/2) / 32;
attr = videoram[offs];
code = videoram[offs+1] + ((attr & 0xc0) << 2);
flipx = attr & 0x20;
if (flipscreen)
{
sx = 31 - sx;
sy = 31 - sy;
flipx = !flipx;
}
drawgfx(tmpbitmap,gfx,
code,
attr & 0x1f,
flipx,flipscreen,
8*sx,8*sy,
0,TRANSPARENCY_NONE,0);
}
}
{
int xscroll[256];
if (flipscreen)
{
/* fixed */
for (offs = 0;offs < 64;offs++) xscroll[255-offs] = 0;
/* scroll (wraps around) */
for (offs = 64;offs < 128;offs++) xscroll[255-offs] = troangel_scroll[64];
/* linescroll (no wrap) */
for (offs = 128;offs < 256;offs++) xscroll[255-offs] = troangel_scroll[offs];
}
else
{
/* fixed */
for (offs = 0;offs < 64;offs++) xscroll[offs] = 0;
/* scroll (wraps around) */
for (offs = 64;offs < 128;offs++) xscroll[offs] = -troangel_scroll[64];
/* linescroll (no wrap) */
for (offs = 128;offs < 256;offs++) xscroll[offs] = -troangel_scroll[offs];
}
copyscrollbitmap(bitmap,tmpbitmap,256,xscroll,0,0,&Machine->visible_area,TRANSPARENCY_NONE,0);
}
}