void cave_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int pri;
int layers_ctrl = -1;
int glob_flipx = READ_WORD(&cave_videoregs[0]) & 0x8000;
int glob_flipy = READ_WORD(&cave_videoregs[2]) & 0x8000;
tilemap_set_flip(ALL_TILEMAPS, (glob_flipx ? TILEMAP_FLIPX : 0) | (glob_flipy ? TILEMAP_FLIPY : 0) );
tilemap_set_enable( tilemap_0, READ_WORD(&cave_vctrl_0[4]) & 1 );
tilemap_set_scrollx(tilemap_0, 0, READ_WORD(&cave_vctrl_0[0]) );
tilemap_set_scrolly(tilemap_0, 0, READ_WORD(&cave_vctrl_0[2]) );
if (tilemap_1)
{
tilemap_set_enable( tilemap_1, READ_WORD(&cave_vctrl_1[4]) & 1 );
tilemap_set_scrollx(tilemap_1, 0, READ_WORD(&cave_vctrl_1[0]) );
tilemap_set_scrolly(tilemap_1, 0, READ_WORD(&cave_vctrl_1[2]) );
}
if (tilemap_2)
{
tilemap_set_enable( tilemap_2, READ_WORD(&cave_vctrl_2[4]) & 1 );
tilemap_set_scrollx(tilemap_2, 0, READ_WORD(&cave_vctrl_2[0]) );
tilemap_set_scrolly(tilemap_2, 0, READ_WORD(&cave_vctrl_2[2]) );
}
tilemap_update(ALL_TILEMAPS);
palette_init_used_colors();
get_sprite_info();
sprite_update();
if (palette_recalc()) tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
tilemap_render(ALL_TILEMAPS);
/* Clear the background if at least one of layer 0's tile priorities
is lacking */
if ((layers_ctrl & 0xf) != 0xf) osd_clearbitmap(Machine->scrbitmap);
/* Pen 0 of layer 0's tiles (any priority) goes below anything else */
for ( pri = 0; pri < 4; pri++ )
if ((layers_ctrl&(1<<(pri+0)))&&tilemap_0) tilemap_draw(bitmap, tilemap_0, TILEMAP_IGNORE_TRANSPARENCY | pri);
/* Draw the rest with transparency */
for ( pri = 0; pri < 4; pri++ )
{
if ((layers_ctrl&(1<<(pri+12)))) sprite_draw(sprite_list, pri);
if ((layers_ctrl&(1<<(pri+0)))&&tilemap_0) tilemap_draw(bitmap, tilemap_0, pri);
if ((layers_ctrl&(1<<(pri+4)))&&tilemap_1) tilemap_draw(bitmap, tilemap_1, pri);
if ((layers_ctrl&(1<<(pri+8)))&&tilemap_2) tilemap_draw(bitmap, tilemap_2, pri);
}
}
void maniacsq_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
/* set scroll registers */
tilemap_set_scrolly(pant[0], 0, gaelco_vregs[0]);
tilemap_set_scrollx(pant[0], 0, gaelco_vregs[1]+4);
tilemap_set_scrolly(pant[1], 0, gaelco_vregs[2]);
tilemap_set_scrollx(pant[1], 0, gaelco_vregs[3]);
tilemap_update(ALL_TILEMAPS);
gaelco_sort_sprites();
palette_recalc();
fillbitmap( bitmap, Machine->pens[0], &Machine->visible_area );
tilemap_draw(bitmap,pant[1],3,0);
tilemap_draw(bitmap,pant[0],3,0);
gaelco_draw_sprites(bitmap,3);
tilemap_draw(bitmap,pant[1],2,0);
tilemap_draw(bitmap,pant[0],2,0);
gaelco_draw_sprites(bitmap,2);
tilemap_draw(bitmap,pant[1],1,0);
tilemap_draw(bitmap,pant[0],1,0);
gaelco_draw_sprites(bitmap,1);
tilemap_draw(bitmap,pant[1],0,0);
tilemap_draw(bitmap,pant[0],0,0);
gaelco_draw_sprites(bitmap,0);
}
static void draw_background( struct mame_bitmap *bitmap, const struct rectangle *cliprect )
{
int dx = -48;
int dy = 16;
int attributes = grchamp_vreg1[0x3];
/* ----xxxx Analog Tachometer output
** ---x---- palette select
** --x----- enables msb of bg#3 xscroll
** xx------ unused
*/
int color = (attributes&0x10)?1:0;
if( color!=palette_bank )
{
palette_bank = color;
tilemap_mark_all_tiles_dirty( ALL_TILEMAPS );
}
tilemap_set_scrollx( tilemap[0], 0, dx-(grchamp_vreg1[0x0]+grchamp_vreg1[0x1]*256) );
tilemap_set_scrolly( tilemap[0], 0, dy - grchamp_vreg1[0x2] );
tilemap_set_scrollx( tilemap[1], 0, dx-(grchamp_vreg1[0x5]+grchamp_vreg1[0x6]*256) );
tilemap_set_scrolly( tilemap[1], 0, dy - grchamp_vreg1[0x7] );
tilemap_set_scrollx( tilemap[2], 0, dx-(grchamp_vreg1[0x9]+ ((attributes&0x20)?256:(grchamp_vreg1[0xa]*256))));
tilemap_set_scrolly( tilemap[2], 0, dy - grchamp_vreg1[0xb] );
tilemap_draw(bitmap,cliprect,tilemap[0],0,0);
tilemap_draw(bitmap,cliprect,tilemap[1],0,0);
tilemap_draw(bitmap,cliprect,tilemap[2],0,0);
}
static SCREEN_UPDATE(kingdrby)
{
kingdrby_state *state = screen->machine().driver_data<kingdrby_state>();
const rectangle &visarea = screen->visible_area();
rectangle clip;
tilemap_set_scrollx( state->m_sc0_tilemap,0, state->m_vram[0x342]);
tilemap_set_scrolly( state->m_sc0_tilemap,0, state->m_vram[0x341]);
tilemap_set_scrollx( state->m_sc1_tilemap,0, state->m_vram[0x342]);
tilemap_set_scrolly( state->m_sc1_tilemap,0, state->m_vram[0x341]);
tilemap_set_scrolly( state->m_sc0w_tilemap,0, 32);
/* maybe it needs two window tilemaps? (one at the top, the other at the bottom)*/
clip.min_x = visarea.min_x;
clip.max_x = 256;
clip.min_y = 192;
clip.max_y = visarea.max_y;
/*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/
tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
draw_sprites(screen->machine(),bitmap,cliprect);
tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap,TILEMAP_DRAW_CATEGORY(1),0);
tilemap_draw(bitmap,&clip,state->m_sc0w_tilemap,0,0);
return 0;
}
void maniacsq_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
/* set scroll registers */
tilemap_set_scrolly(pant[0], 0, READ_WORD(&gaelco_vregs[0]));
tilemap_set_scrollx(pant[0], 0, READ_WORD(&gaelco_vregs[2])+4);
tilemap_set_scrolly(pant[1], 0, READ_WORD(&gaelco_vregs[4]));
tilemap_set_scrollx(pant[1], 0, READ_WORD(&gaelco_vregs[6]));
tilemap_update(ALL_TILEMAPS);
gaelco_sort_sprites();
if (palette_recalc())
tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
tilemap_render(ALL_TILEMAPS);
fillbitmap( bitmap, Machine->pens[0], &Machine->visible_area );
tilemap_draw(bitmap,pant[1],3);
tilemap_draw(bitmap,pant[0],3);
gaelco_draw_sprites(bitmap,3);
tilemap_draw(bitmap,pant[1],2);
tilemap_draw(bitmap,pant[0],2);
gaelco_draw_sprites(bitmap,2);
tilemap_draw(bitmap,pant[1],1);
tilemap_draw(bitmap,pant[0],1);
gaelco_draw_sprites(bitmap,1);
tilemap_draw(bitmap,pant[1],0);
tilemap_draw(bitmap,pant[0],0);
gaelco_draw_sprites(bitmap,0);
}
void raiden_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int color,offs,sprite;
int colmask[16],i,pal_base;
/* Setup the tilemaps, alternate version has different scroll positions */
if (!ALTERNATE) {
tilemap_set_scrollx( background_layer,0, ((raiden_scroll_ram[1]<<8)+raiden_scroll_ram[0]) );
tilemap_set_scrolly( background_layer,0, ((raiden_scroll_ram[3]<<8)+raiden_scroll_ram[2]) );
tilemap_set_scrollx( foreground_layer,0, ((raiden_scroll_ram[5]<<8)+raiden_scroll_ram[4]) );
tilemap_set_scrolly( foreground_layer,0, ((raiden_scroll_ram[7]<<8)+raiden_scroll_ram[6]) );
}
else {
tilemap_set_scrolly( background_layer,0, ((raiden_scroll_ram[0x02]&0x30)<<4)+((raiden_scroll_ram[0x04]&0x7f)<<1)+((raiden_scroll_ram[0x04]&0x80)>>7) );
tilemap_set_scrollx( background_layer,0, ((raiden_scroll_ram[0x12]&0x30)<<4)+((raiden_scroll_ram[0x14]&0x7f)<<1)+((raiden_scroll_ram[0x14]&0x80)>>7) );
tilemap_set_scrolly( foreground_layer,0, ((raiden_scroll_ram[0x22]&0x30)<<4)+((raiden_scroll_ram[0x24]&0x7f)<<1)+((raiden_scroll_ram[0x24]&0x80)>>7) );
tilemap_set_scrollx( foreground_layer,0, ((raiden_scroll_ram[0x32]&0x30)<<4)+((raiden_scroll_ram[0x34]&0x7f)<<1)+((raiden_scroll_ram[0x34]&0x80)>>7) );
}
tilemap_update(ALL_TILEMAPS);
/* Build the dynamic palette */
palette_init_used_colors();
/* Sprites */
pal_base = Machine->drv->gfxdecodeinfo[3].color_codes_start;
for (color = 0;color < 16;color++) colmask[color] = 0;
for (offs = 0;offs <0x1000;offs += 8)
{
color = buffered_spriteram[offs+1]&0xf;
sprite = buffered_spriteram[offs+2]+(buffered_spriteram[offs+3]<<8);
sprite &= 0x0fff;
colmask[color] |= Machine->gfx[3]->pen_usage[sprite];
}
for (color = 0;color < 16;color++)
{
for (i = 0;i < 15;i++)
{
if (colmask[color] & (1 << i))
palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
}
}
if (palette_recalc())
tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
tilemap_render(ALL_TILEMAPS);
tilemap_draw(bitmap,background_layer,0);
/* Draw sprites underneath foreground */
draw_sprites(bitmap,0x40);
tilemap_draw(bitmap,foreground_layer,0);
/* Rest of sprites */
draw_sprites(bitmap,0x80);
/* Text layer */
tilemap_draw(bitmap,text_layer,0);
}
static void set_scroll(void)
{
int i;
for (i = 0;i <= 2;i++)
tilemap_set_scrollx(bg_tilemap,i,scrollx[0] + 256 * scrollx[1]);
tilemap_set_scrollx(bg_tilemap,3,0);
}
static void set_scroll( running_machine &machine )
{
travrusa_state *state = machine.driver_data<travrusa_state>();
int i;
for (i = 0; i <= 2; i++)
tilemap_set_scrollx(state->m_bg_tilemap, i, state->m_scrollx[0] + 256 * state->m_scrollx[1]);
tilemap_set_scrollx(state->m_bg_tilemap, 3, 0);
}
void batman_scanline_update(int scanline)
{
/* update the scanline parameters */
if (scanline <= Machine->visible_area.max_y && atarivc_state.rowscroll_enable)
{
data16_t *base = &atarigen_alpha[scanline / 8 * 64 + 48];
int scan, i;
for (scan = 0; scan < 8; scan++, scanline++)
for (i = 0; i < 2; i++)
{
int data = *base++;
switch (data & 15)
{
case 9:
force_partial_update(scanline - 1);
atarivc_state.mo_xscroll = (data >> 7) & 0x1ff;
atarimo_set_xscroll(0, atarivc_state.mo_xscroll);
break;
case 10:
force_partial_update(scanline - 1);
atarivc_state.pf1_xscroll_raw = (data >> 7) & 0x1ff;
atarivc_update_pf_xscrolls();
tilemap_set_scrollx(atarigen_playfield_tilemap, 0, atarivc_state.pf0_xscroll);
tilemap_set_scrollx(atarigen_playfield2_tilemap, 0, atarivc_state.pf1_xscroll);
break;
case 11:
force_partial_update(scanline - 1);
atarivc_state.pf0_xscroll_raw = (data >> 7) & 0x1ff;
atarivc_update_pf_xscrolls();
tilemap_set_scrollx(atarigen_playfield_tilemap, 0, atarivc_state.pf0_xscroll);
break;
case 13:
force_partial_update(scanline - 1);
atarivc_state.mo_yscroll = (data >> 7) & 0x1ff;
atarimo_set_yscroll(0, atarivc_state.mo_yscroll);
break;
case 14:
force_partial_update(scanline - 1);
atarivc_state.pf1_yscroll = (data >> 7) & 0x1ff;
tilemap_set_scrolly(atarigen_playfield2_tilemap, 0, atarivc_state.pf1_yscroll);
break;
case 15:
force_partial_update(scanline - 1);
atarivc_state.pf0_yscroll = (data >> 7) & 0x1ff;
tilemap_set_scrolly(atarigen_playfield_tilemap, 0, atarivc_state.pf0_yscroll);
break;
}
}
}
static VIDEO_UPDATE(bestleag)
{
tilemap_set_scrollx(bg_tilemap,0,(bestleag_vregs[0x00/2] & 0xfff) + (bestleag_vregs[0x08/2] & 0x7) - 3);
tilemap_set_scrolly(bg_tilemap,0,bestleag_vregs[0x02/2]);
tilemap_set_scrollx(tx_tilemap,0,bestleag_vregs[0x04/2]);
tilemap_set_scrolly(tx_tilemap,0,bestleag_vregs[0x06/2]);
tilemap_set_scrollx(fg_tilemap,0,bestleag_vregs[0x08/2] & 0xfff8);
tilemap_set_scrolly(fg_tilemap,0,bestleag_vregs[0x0a/2]);
tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,fg_tilemap,0,0);
draw_sprites(screen->machine,bitmap,cliprect);
tilemap_draw(bitmap,cliprect,tx_tilemap,0,0);
return 0;
}
static VIDEO_START( dynadice )
{
/* pacman - style videoram layout */
bg_tilemap = tilemap_create(get_tile_info,tilemap_scan_rows,TILEMAP_TYPE_PEN,8,8,32,32);
top_tilemap = tilemap_create(get_tile_info,tilemap_scan_cols,TILEMAP_TYPE_PEN,8,8,2,32);
tilemap_set_scrollx(bg_tilemap, 0, -16 );
}
static SCREEN_UPDATE(bestleaw)
{
bestleag_state *state = screen->machine().driver_data<bestleag_state>();
tilemap_set_scrollx(state->m_bg_tilemap,0,state->m_vregs[0x08/2]);
tilemap_set_scrolly(state->m_bg_tilemap,0,state->m_vregs[0x0a/2]);
tilemap_set_scrollx(state->m_tx_tilemap,0,state->m_vregs[0x00/2]);
tilemap_set_scrolly(state->m_tx_tilemap,0,state->m_vregs[0x02/2]);
tilemap_set_scrollx(state->m_fg_tilemap,0,state->m_vregs[0x04/2]);
tilemap_set_scrolly(state->m_fg_tilemap,0,state->m_vregs[0x06/2]);
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
draw_sprites(screen->machine(),bitmap,cliprect);
tilemap_draw(bitmap,cliprect,state->m_tx_tilemap,0,0);
return 0;
}
static void scroll_w(int layer,int offset,int data)
{
int xdisp[4] = { 36,34,37,35 };
int ydisp = 9;
int scrollx,scrolly;
switch (offset)
{
case 0:
xscroll[layer] = (xscroll[layer]&0xff)|(data<<8);
break;
case 1:
xscroll[layer] = (xscroll[layer]&0xff00)|data;
break;
case 2:
yscroll[layer] = data;
break;
}
scrollx = xscroll[layer]+xdisp[layer];
scrolly = yscroll[layer]+ydisp;
if (flipscreen)
{
scrollx = -scrollx+256;
scrolly = -scrolly;
}
tilemap_set_scrollx(tilemap[layer],0,scrollx-16);
tilemap_set_scrolly(tilemap[layer],0,scrolly+16);
}
void bionicc_scroll_w(int offset,int data)
{
switch( offset )
{
case 0:
tilemap_set_scrollx(fg_tilemap,0,data);
break;
case 2:
tilemap_set_scrolly(fg_tilemap,0,data);
break;
case 4:
tilemap_set_scrollx(bg_tilemap,0,data);
break;
case 6:
tilemap_set_scrolly(bg_tilemap,0,data);
break;
}
}
static void m107_update_scroll_positions(void)
{
int i;
/* Playfield 4 rowscroll data is 0xde800 - 0xdebff???
Playfield 3 rowscroll data is 0xdf800 - 0xdfbff
Playfield 2 rowscroll data is 0xdf400 - 0xdf7ff
Playfield 1 rowscroll data is 0xde800 - 0xdebff ??
*/
if (pf1_rowscroll) {
tilemap_set_scroll_rows(pf1_layer,512);
for (i=0; i<1024; i+=2)
tilemap_set_scrollx( pf1_layer,i/2, (m107_vram_data[0xe800+i]+(m107_vram_data[0xe801+i]<<8)));
} else {
tilemap_set_scroll_rows(pf1_layer,1);
tilemap_set_scrollx( pf1_layer,0, (m107_control[3]<<8)+m107_control[2]+3 );
}
if (pf2_rowscroll) {
tilemap_set_scroll_rows(pf2_layer,512);
for (i=0; i<1024; i+=2)
tilemap_set_scrollx( pf2_layer,i/2, (m107_vram_data[0xf400+i]+(m107_vram_data[0xf401+i]<<8)));
} else {
tilemap_set_scroll_rows(pf2_layer,1);
tilemap_set_scrollx( pf2_layer,0, (m107_control[7]<<8)+m107_control[6]+1 );
}
if (pf3_rowscroll) {
tilemap_set_scroll_rows(pf3_layer,512);
for (i=0; i<1024; i+=2)
tilemap_set_scrollx( pf3_layer,i/2, (m107_vram_data[0xf800+i]+(m107_vram_data[0xf801+i]<<8)));
} else {
tilemap_set_scroll_rows(pf3_layer,1);
tilemap_set_scrollx( pf3_layer,0, (m107_control[11]<<8)+m107_control[10]-1 );
}
if (pf4_rowscroll) {
tilemap_set_scroll_rows(pf4_layer,512);
for (i=0; i<1024; i+=2)
tilemap_set_scrollx( pf4_layer,i/2, (m107_vram_data[0xfc00+i]+(m107_vram_data[0xfc01+i]<<8)));
} else {
tilemap_set_scroll_rows(pf4_layer,1);
tilemap_set_scrollx( pf4_layer,0, (m107_control[15]<<8)+m107_control[14]-3 );
}
tilemap_set_scrolly( pf1_layer,0, (m107_control[1]<<8)+m107_control[0] );
tilemap_set_scrolly( pf2_layer,0, (m107_control[5]<<8)+m107_control[4] );
tilemap_set_scrolly( pf3_layer,0, (m107_control[9]<<8)+m107_control[8] );
tilemap_set_scrolly( pf4_layer,0, (m107_control[13]<<8)+m107_control[12] );
// pf4_layer->scrolled=1;
// pf3_layer->scrolled=1;
// pf2_layer->scrolled=1;
// pf1_layer->scrolled=1;
}
static WRITE8_HANDLER( ddayjlc_bgram_w )
{
if(!offset)
tilemap_set_scrollx(bg_tilemap,0,data+8);
if( bgram[offset] != data )
{
bgram[offset] = data;
tilemap_mark_tile_dirty(bg_tilemap,offset&0x3ff);
}
}
void atarig1_scanline_update(screen_device &screen, int scanline)
{
atarig1_state *state = (atarig1_state *)screen.machine->driver_data;
UINT16 *base = &state->atarigen.alpha[(scanline / 8) * 64 + 48];
int i;
//if (scanline == 0) logerror("-------\n");
/* keep in range */
if (base >= &state->atarigen.alpha[0x800])
return;
screen.update_partial(MAX(scanline - 1, 0));
/* update the playfield scrolls */
for (i = 0; i < 8; i++)
{
UINT16 word;
/* first word controls horizontal scroll */
word = *base++;
if (word & 0x8000)
{
int newscroll = ((word >> 6) + state->pfscroll_xoffset) & 0x1ff;
if (newscroll != state->playfield_xscroll)
{
screen.update_partial(MAX(scanline + i - 1, 0));
tilemap_set_scrollx(state->atarigen.playfield_tilemap, 0, newscroll);
state->playfield_xscroll = newscroll;
}
}
/* second word controls vertical scroll and tile bank */
word = *base++;
if (word & 0x8000)
{
int newscroll = ((word >> 6) - (scanline + i)) & 0x1ff;
int newbank = word & 7;
if (newscroll != state->playfield_yscroll)
{
screen.update_partial(MAX(scanline + i - 1, 0));
tilemap_set_scrolly(state->atarigen.playfield_tilemap, 0, newscroll);
state->playfield_yscroll = newscroll;
}
if (newbank != state->playfield_tile_bank)
{
screen.update_partial(MAX(scanline + i - 1, 0));
tilemap_mark_all_tiles_dirty(state->atarigen.playfield_tilemap);
state->playfield_tile_bank = newbank;
}
}
static SCREEN_UPDATE( hvyunit )
{
#define SX_POS 96
#define SY_POS 0
hvyunit_state *state = screen->machine().driver_data<hvyunit_state>();
tilemap_set_scrollx(state->m_bg_tilemap, 0, ((state->m_port0_data & 0x40) << 2) + state->m_scrollx + SX_POS); // TODO
tilemap_set_scrolly(state->m_bg_tilemap, 0, ((state->m_port0_data & 0x80) << 1) + state->m_scrolly + SY_POS); // TODO
bitmap_fill(bitmap,cliprect,get_black_pen(screen->machine()));
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
pandora_update(state->m_pandora, bitmap, cliprect);
return 0;
}
static void draw_edges(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int flip, int scroll_mode)
{
madalien_state *state = machine->driver_data<madalien_state>();
rectangle clip_edge1;
rectangle clip_edge2;
clip_edge1 = *cliprect;
clip_edge2 = *cliprect;
if (flip)
{
clip_edge1.min_y = *state->edge1_pos | 0x80;
clip_edge2.max_y = (*state->edge2_pos & 0x7f) ^ 0x7f;
}
else
{
clip_edge1.max_y = (*state->edge1_pos & 0x7f) ^ 0x7f;
clip_edge2.min_y = *state->edge2_pos | 0x80;
}
sect_rect(&clip_edge1, cliprect);
sect_rect(&clip_edge2, cliprect);
tilemap_mark_all_tiles_dirty(state->tilemap_edge1[scroll_mode]);
tilemap_mark_all_tiles_dirty(state->tilemap_edge2[scroll_mode]);
tilemap_set_flip(state->tilemap_edge1[scroll_mode], flip ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);
tilemap_set_scrollx(state->tilemap_edge1[scroll_mode], 0, -(*state->scroll & 0xfc));
tilemap_set_scrolly(state->tilemap_edge1[scroll_mode], 0, *state->edge1_pos & 0x7f);
tilemap_set_flip(state->tilemap_edge2[scroll_mode], flip ? TILEMAP_FLIPX : TILEMAP_FLIPY);
tilemap_set_scrollx(state->tilemap_edge2[scroll_mode], 0, -(*state->scroll & 0xfc));
tilemap_set_scrolly(state->tilemap_edge2[scroll_mode], 0, *state->edge2_pos & 0x7f);
tilemap_draw(bitmap, &clip_edge1, state->tilemap_edge1[scroll_mode], 0, 0);
tilemap_draw(bitmap, &clip_edge2, state->tilemap_edge2[scroll_mode], 0, 0);
}
static void set_scroll(int layer)
{
int xdisp[4] = { 20, 18, 21, 19 };
int scrollx,scrolly;
scrollx = xscroll[layer] + xdisp[layer];
scrolly = yscroll[layer] + 9;
if (flip_screen)
{
scrollx = -scrollx;
scrolly = -scrolly;
}
tilemap_set_scrollx(tilemap[layer], 0, scrollx);
tilemap_set_scrolly(tilemap[layer], 0, scrolly);
}
static void draw_edges(bitmap_t *bitmap, const rectangle *cliprect, int flip, int scroll_mode)
{
rectangle clip_edge1;
rectangle clip_edge2;
clip_edge1 = *cliprect;
clip_edge2 = *cliprect;
if (flip)
{
clip_edge1.min_y = *madalien_edge1_pos | 0x80;
clip_edge2.max_y = (*madalien_edge2_pos & 0x7f) ^ 0x7f;
}
else
{
clip_edge1.max_y = (*madalien_edge1_pos & 0x7f) ^ 0x7f;
clip_edge2.min_y = *madalien_edge2_pos | 0x80;
}
sect_rect(&clip_edge1, cliprect);
sect_rect(&clip_edge2, cliprect);
tilemap_mark_all_tiles_dirty(tilemap_edge1[scroll_mode]);
tilemap_mark_all_tiles_dirty(tilemap_edge2[scroll_mode]);
tilemap_set_flip(tilemap_edge1[scroll_mode], flip ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);
tilemap_set_scrollx(tilemap_edge1[scroll_mode], 0, -(*madalien_scroll & 0xfc));
tilemap_set_scrolly(tilemap_edge1[scroll_mode], 0, *madalien_edge1_pos & 0x7f);
tilemap_set_flip(tilemap_edge2[scroll_mode], flip ? TILEMAP_FLIPX : TILEMAP_FLIPY);
tilemap_set_scrollx(tilemap_edge2[scroll_mode], 0, -(*madalien_scroll & 0xfc));
tilemap_set_scrolly(tilemap_edge2[scroll_mode], 0, *madalien_edge2_pos & 0x7f);
tilemap_draw(bitmap, &clip_edge1, tilemap_edge1[scroll_mode], 0, 0);
tilemap_draw(bitmap, &clip_edge2, tilemap_edge2[scroll_mode], 0, 0);
}
void atarig1_scanline_update(int scanline)
{
UINT16 *base = &atarigen_alpha[(scanline / 8) * 64 + 48];
int i;
//if (scanline == 0) logerror("-------\n");
/* keep in range */
if (base >= &atarigen_alpha[0x800])
return;
/* update the playfield scrolls */
for (i = 0; i < 8; i++)
{
UINT16 word;
/* first word controls horizontal scroll */
word = *base++;
if (word & 0x8000)
{
int newscroll = ((word >> 6) + pfscroll_xoffset) & 0x1ff;
if (newscroll != playfield_xscroll)
{
video_screen_update_partial(0, scanline + i - 1);
tilemap_set_scrollx(atarigen_playfield_tilemap, 0, newscroll);
playfield_xscroll = newscroll;
}
}
/* second word controls vertical scroll and tile bank */
word = *base++;
if (word & 0x8000)
{
int newscroll = ((word >> 6) - (scanline + i)) & 0x1ff;
int newbank = word & 7;
if (newscroll != playfield_yscroll)
{
video_screen_update_partial(0, scanline + i - 1);
tilemap_set_scrolly(atarigen_playfield_tilemap, 0, newscroll);
playfield_yscroll = newscroll;
}
if (newbank != playfield_tile_bank)
{
video_screen_update_partial(0, scanline + i - 1);
tilemap_mark_all_tiles_dirty(atarigen_playfield_tilemap);
playfield_tile_bank = newbank;
}
}
static void set_scroll(int layer)
{
static const int xdisp[2] = { 26, 24 };
int scrollx, scrolly;
scrollx = xscroll[layer] + xdisp[layer];
scrolly = yscroll[layer] + 9;
if (flip_screen)
{
scrollx = -scrollx + 3;
scrolly = -scrolly;
}
tilemap_set_scrollx(bg_tilemap[layer], 0, scrollx);
tilemap_set_scrolly(bg_tilemap[layer], 0, scrolly);
}
int splash_vh_start(void)
{
screen[0] = tilemap_create(get_tile_info_splash_screen0,tilemap_scan_rows,TILEMAP_TRANSPARENT, 8, 8,64,32);
screen[1] = tilemap_create(get_tile_info_splash_screen1,tilemap_scan_rows,TILEMAP_TRANSPARENT,16,16,32,32);
screen2 = bitmap_alloc (512, 256);
if (!screen[0] || !screen[1] || !screen2)
return 1;
tilemap_set_transparent_pen(screen[0],0);
tilemap_set_transparent_pen(screen[1],0);
tilemap_set_scrollx(screen[0], 0, 4);
return 0;
}
static void set_scroll(running_machine *machine, int layer)
{
static const int xdisp[2] = { 26, 24 };
int scrollx, scrolly;
scrollx = xscroll[layer] + xdisp[layer];
scrolly = yscroll[layer] + 9;
if (flip_screen_get(machine))
{
scrollx = -scrollx + 3;
scrolly = -scrolly;
}
tilemap_set_scrollx(bg_tilemap[layer], 0, scrollx);
tilemap_set_scrolly(bg_tilemap[layer], 0, scrolly);
}
static void bg_ctrl(int offset, int data, tilemap_t* tilemap)
{
int scrollx = tilemap_get_scrollx(tilemap, 0);
int scrolly = tilemap_get_scrolly(tilemap, 0);
switch (offset)
{
case 0: scrollx = ((scrollx & 0x100) | data); break;
case 1: scrollx = ((scrollx & 0x0ff) | (data << 8)); break;
case 2: scrolly = ((scrolly & 0x100) | data); break;
case 3: scrolly = ((scrolly & 0x0ff) | (data << 8)); break;
case 4: tilemap_set_enable(tilemap, data & 1); break;
}
tilemap_set_scrollx(tilemap, 0, scrollx);
tilemap_set_scrolly(tilemap, 0, scrolly);
}
static void
video_update_common( struct mame_bitmap *bitmap, const struct rectangle *cliprect, int bROZ )
{
const int xadjust[4] = { 0,2,3,4 };
int i,pri;
handle_mcu();
namconb1_install_palette();
fillbitmap(priority_bitmap,0,NULL); /* not actually used (yet) */
/* I have no idea what the background color should be, but I doubt it ever pokes through. */
fillbitmap( bitmap, 0, 0 );
for( i=0; i<6; i++ )
{
int tilemap_color = nth_word32( &namconb1_scrollram32[0x30/4], i )&7;
if( tilemap_palette_bank[i]!= tilemap_color )
{
tilemap_palette_bank[i] = tilemap_color;
tilemap_mark_all_tiles_dirty( background[i] );
}
if( i<4 )
{
tilemap_set_scrollx( background[i],0,namconb1_scrollram32[i*2]+48-xadjust[i] );
tilemap_set_scrolly( background[i],0,namconb1_scrollram32[i*2+1]+24 );
}
}
for( pri=0; pri<8; pri++ )
{
if( bROZ )
{
namco_roz_draw( bitmap,cliprect,pri );
}
for( i=0; i<6; i++ )
{
if( nth_word32( &namconb1_scrollram32[0x20/4],i ) == pri )
{
tilemap_draw( bitmap,cliprect,background[i],0,0/*1<<pri*/ );
}
}
namco_obj_draw( bitmap, cliprect, pri );
}
} /* video_update_common */
static void update_playfield( int layer )
{
struct tilemap *tilemap = playfields[layer].tilemap;
/* for background , set scroll position */
if( layer < 4 )
{
int scrollx = -playfields[layer].scroll_x + scrolloffsX[layer];
int scrolly = -playfields[layer].scroll_y + scrolloffsY[layer];
if ( flipscreen ) {
scrollx = -scrollx;
scrolly = -scrolly;
}
/* set scroll */
tilemap_set_scrollx(tilemap,0,scrollx);
tilemap_set_scrolly(tilemap,0,scrolly);
}
info_vram = (unsigned char *)playfields[layer].base;
info_color = objects[layer].color;
tilemap_update( tilemap );
}
INLINE void dooyong_scroll8_w(offs_t offset, UINT8 data, UINT8 *scroll, tilemap_t *map)
{
UINT8 old = scroll[offset];
if (old != data)
{
scroll[offset] = data;
if (map != NULL) switch (offset)
{
case 0: /* Low byte of x scroll - scroll tilemap */
tilemap_set_scrollx(map, 0, data);
break;
case 1: /* High byte of x scroll - mark tilemap dirty so new tile gfx will be loaded */
tilemap_mark_all_tiles_dirty(map);
break;
case 3: /* Low byte of y scroll */
case 4: /* High byte of y scroll */
tilemap_set_scrolly(map, 0, (int)scroll[3] | ((int)scroll[4] << 8));
break;
case 6: /* Tilemap enable and mode control */
tilemap_set_enable(map, !(data & 0x10));
if ((data & 0x20) != (old & 0x20)) // This sets the tilemap data format
tilemap_mark_all_tiles_dirty(map);
break;
default: /* Other addresses are used but function is unknown */
/* 0x05 and 0x07 are initialised on startup */
/* 0x02 is initialised on startup by some games and written to continuously by others */
/*{
const char *name;
if (scroll == state->bgscroll8) name = "bg";
else if (scroll == state->bg2scroll8) name = "bg2";
else if (scroll == state->fgscroll8) name = "fg";
else if (scroll == state->fg2scroll8) name = "fg2";
else name = "unknown";
printf("Unknown %s tilemap control: 0x%02x = 0x%02x\n", name, (unsigned)offset, (unsigned)data);
}*/
break;
}
}
}
static void draw_background(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect)
{
m57_state *state = machine.driver_data<m57_state>();
int y,x;
INT16 scrolly;
// from 64 to 127: not wrapped
for (y = 64; y < 128; y++)
tilemap_set_scrollx(state->m_bg_tilemap, y, state->m_scrollram[0x40]);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
// from 128 to 255: wrapped
for (y = 128; y <= cliprect->max_y; y++)
{
scrolly = state->m_scrollram[y] + (state->m_scrollram[y + 0x100] << 8);
if (scrolly >= 0)
{
for (x = cliprect->min_x; x <= cliprect->max_x; x++)
{
if ((x + scrolly) <= cliprect->max_x)
*BITMAP_ADDR16(bitmap, y, x) = *BITMAP_ADDR16(bitmap, y, x + scrolly);
else
*BITMAP_ADDR16(bitmap, y, x) = *BITMAP_ADDR16(bitmap, y, cliprect->max_x);
}
} else {
for (x = cliprect->max_x; x >= cliprect->min_x; x--)
{
if ((x + scrolly) >= cliprect->min_x)
*BITMAP_ADDR16(bitmap, y, x) = *BITMAP_ADDR16(bitmap, y, x + scrolly);
else
*BITMAP_ADDR16(bitmap, y, x) = *BITMAP_ADDR16(bitmap, y, cliprect->min_x);
}
}
}
}
