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 dleague_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
TC0080VCO_tilemap_update();
#ifdef MAME_DEBUG
taitoh_log_vram();
#endif
palette_init_used_colors();
mark_sprite_colors();
palette_recalc();
fillbitmap(bitmap, palette_transparent_pen, &Machine -> visible_area);
#ifdef MAME_DEBUG
if ( !keyboard_pressed(KEYCODE_A) )
TC0080VCO_tilemap_draw(bitmap,0,TILEMAP_IGNORE_TRANSPARENCY,0);
if ( !keyboard_pressed(KEYCODE_S) )
dleague_draw_sprites(bitmap,0);
if ( !keyboard_pressed(KEYCODE_D) )
TC0080VCO_tilemap_draw(bitmap,1,0,0);
if ( !keyboard_pressed(KEYCODE_F) )
dleague_draw_sprites(bitmap,1);
#else
TC0080VCO_tilemap_draw(bitmap,0,TILEMAP_IGNORE_TRANSPARENCY,0);
dleague_draw_sprites (bitmap,0);
TC0080VCO_tilemap_draw(bitmap,1,0,0);
dleague_draw_sprites (bitmap,1);
#endif
TC0080VCO_tilemap_draw(bitmap,2,0,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);
}
void gundealr_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
tilemap_update(ALL_TILEMAPS);
palette_init_used_colors();
if (palette_recalc())
tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
tilemap_render(ALL_TILEMAPS);
tilemap_draw(bitmap,bg_tilemap,0);
tilemap_draw(bitmap,fg_tilemap,0);
}
int cbasebal_vh_start(void)
{
int i;
cbasebal_textram = (unsigned char*)malloc(0x1000);
cbasebal_scrollram = (unsigned char*)malloc(0x1000);
bg_tilemap = tilemap_create(get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE, 16,16,64,32);
fg_tilemap = tilemap_create(get_fg_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,32);
if (!cbasebal_textram || !cbasebal_scrollram || !bg_tilemap || !fg_tilemap)
{
cbasebal_vh_stop();
return 1;
}
fg_tilemap->transparent_pen = 3;
#define COLORTABLE_START(gfxn,color_code) Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + \
color_code * Machine->gfx[gfxn]->color_granularity
#define GFX_COLOR_CODES(gfxn) Machine->gfx[gfxn]->total_colors
#define GFX_ELEM_COLORS(gfxn) Machine->gfx[gfxn]->color_granularity
palette_init_used_colors();
/* chars */
for (i = 0;i < GFX_COLOR_CODES(0);i++)
{
memset(&palette_used_colors[COLORTABLE_START(0,i)],
PALETTE_COLOR_USED,
GFX_ELEM_COLORS(0)-1);
}
/* bg tiles */
for (i = 0;i < GFX_COLOR_CODES(1);i++)
{
memset(&palette_used_colors[COLORTABLE_START(1,i)],
PALETTE_COLOR_USED,
GFX_ELEM_COLORS(1));
}
/* sprites */
for (i = 0;i < GFX_COLOR_CODES(2);i++)
{
memset(&palette_used_colors[COLORTABLE_START(2,i)],
PALETTE_COLOR_VISIBLE,
GFX_ELEM_COLORS(2)-1);
}
return 0;
}
void shuuz_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
/* mark the used colors */
palette_init_used_colors();
ataripf_mark_palette(0);
atarimo_mark_palette(0);
/* update the palette, and mark things dirty if we need to */
if (palette_recalc())
ataripf_invalidate(0);
/* draw the layers */
ataripf_render(0, bitmap);
atarimo_render(0, bitmap, overrender_callback, NULL);
}
static const UINT8 *update_palette(void)
{
UINT16 mo_map[16], pf_map[48];
int i, j;
/* reset color tracking */
memset(mo_map, 0, sizeof(mo_map));
memset(pf_map, 0, sizeof(pf_map));
palette_init_used_colors();
/* update color usage for the playfields */
atarigen_pf_process(pf_color_callback, pf_map, &Machine->drv->visible_area);
atarigen_pf2_process(pf2_color_callback, pf_map, &Machine->drv->visible_area);
/* update color usage for the mo's */
atarigen_mo_process(mo_color_callback, mo_map);
/* rebuild the playfield palettes */
for (i = 0; i < 48; i++)
{
UINT16 used = pf_map[i];
if (used)
{
if (i < 16)
palette_used_colors[0x000 + i * 16 + 0] = PALETTE_COLOR_TRANSPARENT;
else if (used & 0x0001)
palette_used_colors[0x000 + i * 16 + 0] = PALETTE_COLOR_USED;
for (j = 1; j < 16; j++)
if (used & (1 << j))
palette_used_colors[0x000 + i * 16 + j] = PALETTE_COLOR_USED;
}
}
/* rebuild the motion object palette */
for (i = 0; i < 16; i++)
{
UINT16 used = mo_map[i];
if (used)
{
palette_used_colors[0x100 + i * 16 + 0] = PALETTE_COLOR_TRANSPARENT;
for (j = 1; j < 16; j++)
if (used & (1 << j))
palette_used_colors[0x100 + i * 16 + j] = PALETTE_COLOR_USED;
}
}
return palette_recalc();
}
void syvalion_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
TC0080VCO_tilemap_update();
#ifdef MAME_DEBUG
taitoh_log_vram();
#endif
palette_init_used_colors();
mark_sprite_colors();
palette_recalc();
fillbitmap(bitmap, palette_transparent_pen, &Machine -> visible_area);
TC0080VCO_tilemap_draw(bitmap,0,TILEMAP_IGNORE_TRANSPARENCY,0);
TC0080VCO_tilemap_draw(bitmap,1,0,0);
syvalion_draw_sprites (bitmap);
TC0080VCO_tilemap_draw(bitmap,2,0,0);
}
void tecmo_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
tilemap_update(ALL_TILEMAPS);
palette_init_used_colors();
mark_sprite_colors();
palette_used_colors[0x100] = PALETTE_COLOR_USED;
if (palette_recalc())
tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
tilemap_render(ALL_TILEMAPS);
fillbitmap(priority_bitmap,0,NULL);
fillbitmap(bitmap,Machine->pens[0x100],&Machine->visible_area);
tilemap_draw(bitmap,bg_tilemap,1<<16);
tilemap_draw(bitmap,fg_tilemap,2<<16);
tilemap_draw(bitmap,tx_tilemap,4<<16);
draw_sprites(bitmap);
}
void pang_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int i;
tilemap_update(ALL_TILEMAPS);
palette_init_used_colors();
mark_sprites_palette();
/* the following is required to make the colored background work */
for (i = 15;i < Machine->drv->total_colors;i += 16)
palette_used_colors[i] = PALETTE_COLOR_TRANSPARENT;
if (palette_recalc())
tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
tilemap_render(ALL_TILEMAPS);
tilemap_draw(bitmap,bg_tilemap,0);
draw_sprites(bitmap);
}
void bjtwin_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
static int oldbgstart = -1;
int offs, bgstart;
bgstart = 2048 * (READ_WORD(&bjtwin_videocontrol[0]) & 0x0f);
palette_init_used_colors();
for (offs = (bjtwin_txvideoram_size/2)-1; offs >= 0; offs--)
{
int color = (READ_WORD(&bjtwin_txvideoram[offs*2]) >> 12);
memset(&palette_used_colors[16 * color],PALETTE_COLOR_USED,16);
}
for (offs = 0; offs < 256*16; offs += 16)
{
if (READ_WORD(&bjtwin_spriteram[offs]) != 0)
memset(&palette_used_colors[256 + 16*READ_WORD(&bjtwin_spriteram[offs+14])],PALETTE_COLOR_USED,16);
}
if (palette_recalc() || (oldbgstart != bgstart))
{
oldbgstart = bgstart;
memset(dirtybuffer, 1, bjtwin_txvideoram_size/2);
}
for (offs = (bjtwin_txvideoram_size/2)-1; offs >= 0; offs--)
{
if (dirtybuffer[offs])
{
int sx = offs / 32;
int sy = offs % 32;
int tilecode = READ_WORD(&bjtwin_txvideoram[offs*2]);
int bank = (tilecode & 0x800) ? 1 : 0;
if (flipscreen)
{
sx = 47-sx;
sy = 31-sy;
}
drawgfx(tmpbitmap,Machine->gfx[bank],
(tilecode & 0x7ff) + ((bank) ? bgstart : 0),
tilecode >> 12,
flipscreen, flipscreen,
8*sx,8*sy,
0,TRANSPARENCY_NONE,0);
dirtybuffer[offs] = 0;
}
}
/* copy the character mapped graphics */
copybitmap(bitmap,tmpbitmap,0,0,0,0,&Machine->visible_area,TRANSPARENCY_NONE,0);
for (offs = 0; offs < 256*16; offs += 16)
{
if (READ_WORD(&bjtwin_spriteram[offs]) != 0)
{
int sx = (READ_WORD(&bjtwin_spriteram[offs+8]) & 0x1ff) + 64;
int sy = (READ_WORD(&bjtwin_spriteram[offs+12]) & 0x1ff);
int tilecode = READ_WORD(&bjtwin_spriteram[offs+6]);
int xx = (READ_WORD(&bjtwin_spriteram[offs+2]) & 0x0f) + 1;
int yy = (READ_WORD(&bjtwin_spriteram[offs+2]) >> 4) + 1;
int width = xx;
int delta = 16;
int startx = sx;
if (flipscreen)
{
sx = 367 - sx;
sy = 239 - sy;
delta = -16;
startx = sx;
}
do
{
do
{
drawgfx(bitmap,Machine->gfx[2],
tilecode & 0x1fff,
READ_WORD(&bjtwin_spriteram[offs+14]),
flipscreen, flipscreen,
sx & 0x1ff,sy & 0x1ff,
&Machine->visible_area,TRANSPARENCY_PEN,15);
tilecode++;
sx += delta;
} while (--xx);
sy += delta;
sx = startx;
xx = width;
} while (--yy);
}
}
void namcos1_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int i;
struct gfx_object *object;
unsigned short palette_map[MAX_SPRITES+1];
const unsigned char *remapped;
/* update all tilemaps */
#if NAMCOS1_DIRECT_DRAW
if(namcos1_tilemap_used)
{
#endif
for(i=0;i<MAX_PLAYFIELDS;i++)
update_playfield(i);
#if NAMCOS1_DIRECT_DRAW
}
#endif
/* object list (sprite) update */
gfxobj_update();
/* palette resource marking */
palette_init_used_colors();
memset(palette_map, 0, sizeof(palette_map));
for(object=objectlist->first_object ; object!=0 ; object=object->next)
{
if (object->visible)
{
int color = object->color;
if(object->gfx)
{ /* sprite object */
if (sprite_palette_state[color])
{
if (color != 0x7f) namcos1_palette_refresh(16*color, 16*color, 15);
sprite_palette_state[color] = 0;
}
palette_map[color] |= Machine->gfx[2]->pen_usage[object->code];
}
else
{ /* playfield object */
if (tilemap_palette_state[color])
{
namcos1_palette_refresh(128*16+256*color, 128*16+256*playfields[color].color, 256);
#if NAMCOS1_DIRECT_DRAW
if(!namcos1_tilemap_used)
{
/* mark used flag */
memset(&palette_used_colors[color*256+128*16],PALETTE_COLOR_VISIBLE,256);
}
#endif
tilemap_palette_state[color] = 0;
}
}
}
}
for (i = 0; i < MAX_SPRITES; i++)
{
int usage = palette_map[i], j;
if (usage)
{
for (j = 0; j < 15; j++)
if (usage & (1 << j))
palette_used_colors[i * 16 + j] |= PALETTE_COLOR_VISIBLE;
}
}
/* background color */
palette_used_colors[BACKGROUNDCOLOR] |= PALETTE_COLOR_VISIBLE;
if ( ( remapped = palette_recalc() ) )
{
#if NAMCOS1_DIRECT_DRAW
if(namcos1_tilemap_used)
#endif
for (i = 0;i < MAX_PLAYFIELDS;i++)
{
int j;
const unsigned char *remapped_layer = &remapped[128*16+256*i];
for (j = 0;j < 256;j++)
{
if (remapped_layer[j])
{
tilemap_mark_all_pixels_dirty(playfields[i].tilemap);
break;
}
}
}
}
#if NAMCOS1_DIRECT_DRAW
if(namcos1_tilemap_used)
#endif
tilemap_render(ALL_TILEMAPS);
/* background color */
fillbitmap(bitmap,Machine->pens[BACKGROUNDCOLOR],&Machine->visible_area);
/* draw objects (tilemaps and sprites) */
gfxobj_draw(objectlist);
}
static void screenrefresh(struct osd_bitmap *bitmap,const struct rectangle *clip)
{
int offs,code,scrollx,scrolly,mx,my;
/* Recalculate palette if needed */
palette_init_used_colors();
for (offs=0; offs<256; offs++)
if (!(offs%16))
palette_used_colors[offs] = PALETTE_COLOR_TRANSPARENT;
else
palette_used_colors[offs] = PALETTE_COLOR_USED;
for (offs=256; offs<512; offs++)
palette_used_colors[offs] = PALETTE_COLOR_USED;
if (palette_recalc())
memset(vram_dirty,1,0x1000);
/* Dynamically decode chars if dirty */
for (code = 0x0000;code < 0x1000;code++)
if (tile_dirty[code])
decodechar(Machine->gfx[0],code,HuC6270_vram,Machine->drv->gfxdecodeinfo[0].gfxlayout);
/* Dynamically decode sprites if dirty */
for (code = 0x0000;code < 0x400;code++)
if (sprite_dirty[code])
decodechar(Machine->gfx[1],code,HuC6270_vram,Machine->drv->gfxdecodeinfo[1].gfxlayout);
/* NB: If first 0x1000 byte is always tilemap, no need to decode the first batch of tiles/sprites */
mx=-1;
my=0;
for (offs = 0x0000;offs < 0x2000;offs += 2)
{
mx++;
if (mx==64) {mx=0; my++;}
code=HuC6270_vram[offs+1] + ((HuC6270_vram[offs] & 0x0f) << 8);
/* If this tile was changed OR tilemap was changed, redraw */
if (tile_dirty[code] || vram_dirty[offs/2]) {
vram_dirty[offs/2]=0;
drawgfx(tile_bitmap,Machine->gfx[0],
code,
HuC6270_vram[offs] >> 4,
0,0,
8*mx,8*my,
0,TRANSPARENCY_NONE,0);
drawgfx(front_bitmap,Machine->gfx[2],
0,
0,
0,0,
8*mx,8*my,
0,TRANSPARENCY_NONE,0);
drawgfx(front_bitmap,Machine->gfx[0],
code,
HuC6270_vram[offs] >> 4,
0,0,
8*mx,8*my,
0,TRANSPARENCY_PENS,0x1);
}
}
