UINT32 pv1000_state::screen_update_pv1000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x, y;
bitmap.fill(m_border_col); // TODO: might be either black or colored by this register
for ( y = 0; y < 24; y++ )
{
for ( x = 2; x < 30; x++ ) // left-right most columns are definitely masked by the border color
{
UINT16 tile = m_p_videoram[ y * 32 + x ];
if ( tile < 0xe0 || m_force_pattern )
{
tile += ( m_pcg_bank << 8);
drawgfx_opaque( bitmap, cliprect, machine().gfx[0], tile, 0, 0, 0, x*8, y*8 );
}
else
{
tile -= 0xe0;
drawgfx_opaque( bitmap, cliprect, machine().gfx[1], tile, 0, 0, 0, x*8, y*8 );
}
}
}
return 0;
}
UINT32 pv1000_state::screen_update_pv1000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x, y;
for ( y = 0; y < 24; y++ )
{
for ( x = 0; x < 32; x++ )
{
UINT16 tile = m_p_videoram[ y * 32 + x ];
if ( tile < 0xe0 )
{
tile += ( m_io_regs[7] * 8 );
drawgfx_opaque( bitmap, cliprect, machine().gfx[0], tile, 0, 0, 0, x*8, y*8 );
}
else
{
tile -= 0xe0;
drawgfx_opaque( bitmap, cliprect, machine().gfx[1], tile, 0, 0, 0, x*8, y*8 );
}
}
}
return 0;
}
UINT32 pc1251_state::screen_update_pc1251(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x, y, i, j;
int color[2];
running_machine &machine = screen.machine();
bitmap.fill(11, cliprect);
/* HJB: we cannot initialize array with values from other arrays, thus... */
color[0] = 7; //pocketc_colortable[PC1251_CONTRAST][0];
color[1] = 8; //pocketc_colortable[PC1251_CONTRAST][1];
for (x=RIGHT,y=DOWN, i=0; i<60; x+=3)
{
for (j=0; j<5; j++, i++, x+=3)
drawgfx_opaque(bitmap, cliprect, screen.machine().gfx[0], m_reg[i],
PC1251_CONTRAST,0,0,
x,y);
}
for (i=0x7b; i>=0x40; x+=3)
{
for (j=0; j<5; j++, i--, x+=3)
drawgfx_opaque(bitmap, cliprect, screen.machine().gfx[0], m_reg[i],
PC1251_CONTRAST,0,0,
x,y);
}
pocketc_draw_special(bitmap, RIGHT+134, DOWN-10, de,
m_reg[0x3c] & 0x08 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT+142, DOWN-10, g,
m_reg[0x3c] & 0x04 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT+146, DOWN-10, rad,
m_reg[0x3d] & 0x04 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT+18, DOWN-10, def,
m_reg[0x3c] & 0x01 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT, DOWN-10, shift,
m_reg[0x3d] & 0x02 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT+38, DOWN-10, pro,
m_reg[0x3e] & 0x01 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT+53, DOWN-10, run,
m_reg[0x3e] & 0x02 ? color[1] : color[0]);
pocketc_draw_special(bitmap, RIGHT+68, DOWN-10, rsv,
m_reg[0x3e] & 0x04 ? color[1] : color[0]);
/* 0x3c 1 def?, 4 g, 8 de
0x3d 2 shift, 4 rad, 8 error
0x3e 1 pro?, 2 run?, 4rsv?*/
return 0;
}
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);
}
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);
}
UINT32 poker72_state::screen_update_poker72(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x,y,count;
count = 0;
for (y=0;y<32;y++)
{
for (x=0;x<64;x++)
{
int tile = ((m_vram[count+1] & 0x0f) << 8 ) | (m_vram[count+0] & 0xff); //TODO: tile bank
int fx = (m_vram[count+1] & 0x10);
int fy = (m_vram[count+1] & 0x20);
int color = (m_vram[count+1] & 0xc0) >> 6;
tile|= m_tile_bank << 12;
drawgfx_opaque(bitmap,cliprect,machine().gfx[0],tile,color,fx,fy,x*8,y*8);
count+=2;
}
}
return 0;
}
static SCREEN_UPDATE(ti99_2)
{
ti99_2_state *state = screen->machine().driver_data<ti99_2_state>();
UINT8 *videoram = state->m_videoram;
int i, sx, sy;
sx = sy = 0;
for (i = 0; i < 768; i++)
{
/* Is the char code masked or not ??? */
drawgfx_opaque(bitmap, cliprect, screen->machine().gfx[0], videoram[i] & 0x7F, 0,
0, 0, sx, sy);
sx += 8;
if (sx == 256)
{
sx = 0;
sy += 8;
}
}
return 0;
}
static void draw_background( running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect )
{
mrflea_state *state = machine.driver_data<mrflea_state>();
const UINT8 *source = state->m_videoram;
const gfx_element *gfx = machine.gfx[1];
int sx, sy;
int base = 0;
if (BIT(state->m_gfx_bank, 2))
base |= 0x400;
if (BIT(state->m_gfx_bank, 4))
base |= 0x200;
for (sy = 0; sy < 256; sy += 8)
{
for (sx = 0; sx < 256; sx += 8)
{
int tile_number = base + source[0] + source[0x400] * 0x100;
source++;
drawgfx_opaque( bitmap, cliprect,
gfx,
tile_number,
0, /* color */
0,0, /* no flip */
sx,sy );
}
}
}
static SCREEN_UPDATE_IND16(poker72)
{
poker72_state *state = screen.machine().driver_data<poker72_state>();
int x,y,count;
count = 0;
for (y=0;y<32;y++)
{
for (x=0;x<64;x++)
{
int tile = ((state->m_vram[count+1] & 0x0f) << 8 ) | (state->m_vram[count+0] & 0xff); //TODO: tile bank
int fx = (state->m_vram[count+1] & 0x10);
int fy = (state->m_vram[count+1] & 0x20);
int color = (state->m_vram[count+1] & 0xc0) >> 6;
tile|= state->m_tile_bank << 12;
drawgfx_opaque(bitmap,cliprect,screen.machine().gfx[0],tile,color,fx,fy,x*8,y*8);
count+=2;
}
}
return 0;
}
static void draw_status(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
{
const gfx_element *gfx = machine->gfx[0];
int row;
for( row=0; row<4; row++ )
{
int sy,sx = (row&1)*8;
const UINT8 *source = mnchmobl_status_vram + (~row&1)*32;
if( row<=1 )
{
source+=2*32;
sx+=256+32+16;
}
for( sy=0; sy<256; sy+=8 )
{
drawgfx_opaque( bitmap, cliprect,
gfx,
*source++,
0, /* color */
0,0, /* no flip */
sx,sy );
}
}
}
UINT32 hitpoker_state::screen_update_hitpoker(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int count = 0;
int y,x;
bitmap.fill(0, cliprect);
for (y=0;y<31;y++)
{
for (x=0;x<81;x++) //it's probably 80 + 1 global line attribute at the start of each line
{
int tile,color,gfx_bpp;
tile = (((m_videoram[count]<<8)|(m_videoram[count+1])) & 0x3fff);
gfx_bpp = (m_colorram[count] & 0x80)>>7; //flag between 4 and 8 bpp
color = gfx_bpp ? ((m_colorram[count] & 0x70)>>4) : (m_colorram[count] & 0xf);
drawgfx_opaque(bitmap,cliprect,machine().gfx[gfx_bpp],tile,color,0,0,x*8,y*8);
count+=2;
}
}
return 0;
}
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 SCREEN_UPDATE_IND16(hitpoker)
{
hitpoker_state *state = screen.machine().driver_data<hitpoker_state>();
int count = 0;
int y,x;
bitmap.fill(0, cliprect);
for (y=0;y<31;y++)
{
for (x=0;x<81;x++) //it's probably 80 + 1 global line attribute at the start of each line
{
int tile,color,gfx_bpp;
tile = (((state->m_videoram[count]<<8)|(state->m_videoram[count+1])) & 0x3fff);
gfx_bpp = (state->m_colorram[count] & 0x80)>>7; //flag between 4 and 8 bpp
color = gfx_bpp ? ((state->m_colorram[count] & 0x70)>>4) : (state->m_colorram[count] & 0xf);
drawgfx_opaque(bitmap,cliprect,screen.machine().gfx[gfx_bpp],tile,color,0,0,x*8,y*8);
count+=2;
}
}
return 0;
}
/* this looks like an exotic I/O-based tilemap / sprite blitter, very unusual from Sega... */
static WRITE32_HANDLER( sysh1_txt_blit_w )
{
coolridr_state *state = space->machine().driver_data<coolridr_state>();
COMBINE_DATA(&state->m_sysh1_txt_blit[offset]);
switch(offset)
{
case 0x10/4: //state->m_cmd + state->m_param?
state->m_cmd = (state->m_sysh1_txt_blit[offset] & 0xffff0000) >> 16;
state->m_param = (state->m_sysh1_txt_blit[offset] & 0x0000ffff) >> 0;
state->m_dst_addr = 0x3f40000;
state->m_txt_index = 0;
state->m_attr_index = 0;
break;
case 0x14/4: //data
/* "THIS MACHINE IS STAND-ALONE." / disclaimer written with this CMD */
if((state->m_cmd & 0xff) == 0xf4)
{
state->m_txt_buff[state->m_txt_index++] = data;
//printf("CMD = %04x PARAM = %04x | %c%c%c%c\n",state->m_cmd,state->m_param,(data >> 24) & 0xff,(data >> 16) & 0xff,(data >> 8) & 0xff,(data >> 0) & 0xff);
}
else if((state->m_cmd & 0xff) == 0x90 || (state->m_cmd & 0xff) == 0x30)
{
state->m_attr_buff[state->m_attr_index++] = data;
if(state->m_attr_index == 0xa)
{
UINT16 x,y;
y = (state->m_attr_buff[9] & 0x01f00000) >> 20;
x = (state->m_attr_buff[9] & 0x1f0) >> 4;
state->m_dst_addr = 0x3f40000 | y*0x40 | x;
{
int x2,y2;
const gfx_element *gfx = space->machine().gfx[1];
rectangle clip;
y2 = (state->m_attr_buff[9] & 0x01ff0000) >> 16;
x2 = (state->m_attr_buff[9] & 0x000001ff);
clip = state->m_temp_bitmap_sprites.cliprect();
drawgfx_opaque(state->m_temp_bitmap_sprites,clip,gfx,1,1,0,0,x2,y2);
}
}
if(state->m_attr_index == 0xc)
{
UINT8 size;
size = (state->m_attr_buff[6] / 4)+1;
for(state->m_txt_index = 0;state->m_txt_index < size; state->m_txt_index++)
{
space->write_dword((state->m_dst_addr),state->m_txt_buff[state->m_txt_index]);
state->m_dst_addr+=4;
}
}
}
VIDEO_START_MEMBER(madalien_state,madalien)
{
int i;
static const tilemap_mapper_delegate scan_functions[4] =
{
tilemap_mapper_delegate(FUNC(madalien_state::scan_mode0),this),
tilemap_mapper_delegate(FUNC(madalien_state::scan_mode1),this),
tilemap_mapper_delegate(FUNC(madalien_state::scan_mode2),this),
tilemap_mapper_delegate(FUNC(madalien_state::scan_mode3),this)
};
static const int tilemap_cols[4] =
{
16, 16, 32, 32
};
m_tilemap_fg = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(madalien_state::get_tile_info_FG),this), TILEMAP_SCAN_COLS_FLIP_X, 8, 8, 32, 32);
m_tilemap_fg->set_transparent_pen(0);
m_tilemap_fg->set_scrolldx(0, 0x50);
m_tilemap_fg->set_scrolldy(0, 0x20);
for (i = 0; i < 4; i++)
{
m_tilemap_edge1[i] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(madalien_state::get_tile_info_BG_1),this), scan_functions[i], 16, 16, tilemap_cols[i], 8);
m_tilemap_edge1[i]->set_scrolldx(0, 0x50);
m_tilemap_edge1[i]->set_scrolldy(0, 0x20);
m_tilemap_edge2[i] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(madalien_state::get_tile_info_BG_2),this), scan_functions[i], 16, 16, tilemap_cols[i], 8);
m_tilemap_edge2[i]->set_scrolldx(0, 0x50);
m_tilemap_edge2[i]->set_scrolldy(0, machine().primary_screen->height() - 256);
}
m_headlight_bitmap = auto_bitmap_ind16_alloc(machine(), 128, 128);
machine().gfx[0]->set_source(m_charram);
drawgfx_opaque(*m_headlight_bitmap, m_headlight_bitmap->cliprect(), machine().gfx[2], 0, 0, 0, 0, 0x00, 0x00);
drawgfx_opaque(*m_headlight_bitmap, m_headlight_bitmap->cliprect(), machine().gfx[2], 0, 0, 0, 1, 0x00, 0x40);
}
static SCREEN_UPDATE_IND16(kongambl)
{
#if CUSTOM_DRAW
kongambl_state *state = screen.machine().driver_data<kongambl_state>();
const gfx_element *gfx = screen.machine().gfx[0];
UINT32 count;
count = 0;
for (int y=0;y<64;y++)
{
for (int x=0;x<128;x++)
{
UINT32 tile = state->m_vram[count] & 0xffff;
if(screen.machine().primary_screen->visible_area().contains(x*8, y*8))
drawgfx_opaque(bitmap,cliprect,gfx,tile,0,0,0,x*8,y*8);
count++;
}
}
count = 0x8000/4;
for (int y=0;y<64;y++)
{
for (int x=0;x<128;x++)
{
UINT32 tile = state->m_vram[count] & 0xffff;
if(screen.machine().primary_screen->visible_area().contains(x*8, y*8))
drawgfx_transpen(bitmap,cliprect,gfx,tile,0,0,0,x*8,y*8,0);
count++;
}
}
#else
device_t *k056832 = screen.machine().device("k056832");
bitmap.fill(0, cliprect);
screen.machine().priority_bitmap.fill(0, cliprect);
k056832_tilemap_draw(k056832, bitmap, cliprect, 3, 0, 0);
k056832_tilemap_draw(k056832, bitmap, cliprect, 2, 0, 0);
k056832_tilemap_draw(k056832, bitmap, cliprect, 1, 0, 0);
k056832_tilemap_draw(k056832, bitmap, cliprect, 0, 0, 0);
#endif
return 0;
}
static VIDEO_START( madalien )
{
madalien_state *state = machine->driver_data<madalien_state>();
int i;
static const tilemap_mapper_func scan_functions[4] =
{
scan_mode0, scan_mode1, scan_mode2, scan_mode3
};
static const int tilemap_cols[4] =
{
16, 16, 32, 32
};
state->tilemap_fg = tilemap_create(machine, get_tile_info_FG, tilemap_scan_cols_flip_x, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->tilemap_fg, 0);
tilemap_set_scrolldx(state->tilemap_fg, 0, 0x50);
tilemap_set_scrolldy(state->tilemap_fg, 0, 0x20);
for (i = 0; i < 4; i++)
{
state->tilemap_edge1[i] = tilemap_create(machine, get_tile_info_BG_1, scan_functions[i], 16, 16, tilemap_cols[i], 8);
tilemap_set_scrolldx(state->tilemap_edge1[i], 0, 0x50);
tilemap_set_scrolldy(state->tilemap_edge1[i], 0, 0x20);
state->tilemap_edge2[i] = tilemap_create(machine, get_tile_info_BG_2, scan_functions[i], 16, 16, tilemap_cols[i], 8);
tilemap_set_scrolldx(state->tilemap_edge2[i], 0, 0x50);
tilemap_set_scrolldy(state->tilemap_edge2[i], 0, machine->primary_screen->height() - 256);
}
state->headlight_bitmap = auto_bitmap_alloc(machine, 128, 128, BITMAP_FORMAT_INDEXED16);
gfx_element_set_source(machine->gfx[0], state->charram);
drawgfx_opaque(state->headlight_bitmap, NULL, machine->gfx[2], 0, 0, 0, 0, 0x00, 0x00);
drawgfx_opaque(state->headlight_bitmap, NULL, machine->gfx[2], 0, 0, 0, 1, 0x00, 0x40);
}
UINT32 nascom1_state::screen_update_nascom2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT8 *videoram = m_videoram;
int sy, sx;
for (sx = 0; sx < 48; sx++)
{
drawgfx_opaque (bitmap, cliprect,
machine().gfx[0], videoram[0x03ca + sx],
1, 0, 0, sx * 8, 0);
}
for (sy = 0; sy < 15; sy++)
{
for (sx = 0; sx < 48; sx++)
{
drawgfx_opaque (bitmap, cliprect,
machine().gfx[0], videoram[0x000a + (sy * 64) + sx],
1, 0, 0, sx * 8, (sy + 1) * 14);
}
}
return 0;
}
UINT32 ax20_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
for ( int y = 0; y < 24; y++ )
{
for ( int x = 0; x < 80; x++ )
{
UINT16 tile = m_p_vram[24 + y * 128 + x ] & 0x7f;
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], tile, 0, 0, 0, x*8, y*12);
}
}
return 0;
}
UINT32 kongambl_state::screen_update_kongambl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
#if CUSTOM_DRAW
gfx_element *gfx = machine().gfx[0];
UINT32 count;
count = 0;
for (int y=0;y<64;y++)
{
for (int x=0;x<128;x++)
{
UINT32 tile = m_vram[count] & 0xffff;
if(machine().primary_screen->visible_area().contains(x*8, y*8))
drawgfx_opaque(bitmap,cliprect,gfx,tile,0,0,0,x*8,y*8);
count++;
}
}
count = 0x8000/4;
for (int y=0;y<64;y++)
{
for (int x=0;x<128;x++)
{
UINT32 tile = m_vram[count] & 0xffff;
if(machine().primary_screen->visible_area().contains(x*8, y*8))
drawgfx_transpen(bitmap,cliprect,gfx,tile,0,0,0,x*8,y*8,0);
count++;
}
}
#else
device_t *k056832 = machine().device("k056832");
bitmap.fill(0, cliprect);
machine().priority_bitmap.fill(0, cliprect);
k056832_tilemap_draw(k056832, bitmap, cliprect, 3, 0, 0);
k056832_tilemap_draw(k056832, bitmap, cliprect, 2, 0, 0);
k056832_tilemap_draw(k056832, bitmap, cliprect, 1, 0, 0);
k056832_tilemap_draw(k056832, bitmap, cliprect, 0, 0, 0);
#endif
return 0;
}
UINT32 galeb_state::screen_update_galeb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x,y;
for(y = 0; y < 16; y++ )
{
for(x = 0; x < 48; x++ )
{
int code = m_video_ram[15 + x + y*64];
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], code , 0, 0,0, x*8,y*8);
}
}
return 0;
}
static SCREEN_UPDATE_IND16( ace )
{
ace_state *state = screen.machine().driver_data<ace_state>();
int offs;
/* first of all, fill the screen with the background color */
bitmap.fill(0, cliprect);
drawgfx_opaque(bitmap, cliprect, screen.machine().gfx[1],
0,
0,
0, 0,
state->m_objpos[0], state->m_objpos[1]);
drawgfx_opaque(bitmap, cliprect, screen.machine().gfx[2],
0,
0,
0, 0,
state->m_objpos[2], state->m_objpos[3]);
drawgfx_opaque(bitmap, cliprect, screen.machine().gfx[3],
0,
0,
0, 0,
state->m_objpos[4], state->m_objpos[5]);
for (offs = 0; offs < 8; offs++)
{
drawgfx_opaque(bitmap,/* ?? */
cliprect, screen.machine().gfx[4],
offs,
0,
0, 0,
10 * 8 + offs * 16, 256 - 16);
}
return 0;
}
static VIDEO_UPDATE( ace )
{
ace_state *state = (ace_state *)screen->machine->driver_data;
int offs;
/* first of all, fill the screen with the background color */
bitmap_fill(bitmap, cliprect, 0);
drawgfx_opaque(bitmap, cliprect, screen->machine->gfx[1],
0,
0,
0, 0,
state->objpos[0], state->objpos[1]);
drawgfx_opaque(bitmap, cliprect, screen->machine->gfx[2],
0,
0,
0, 0,
state->objpos[2], state->objpos[3]);
drawgfx_opaque(bitmap, cliprect, screen->machine->gfx[3],
0,
0,
0, 0,
state->objpos[4], state->objpos[5]);
for (offs = 0; offs < 8; offs++)
{
drawgfx_opaque(bitmap,/* ?? */
cliprect, screen->machine->gfx[4],
offs,
0,
0, 0,
10 * 8 + offs * 16, 256 - 16);
}
return 0;
}
UINT32 ut88_state::screen_update_ut88(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x,y;
for(y = 0; y < 28; y++ )
{
for(x = 0; x < 64; x++ )
{
int code = m_p_videoram[ x + y*64 ] & 0x7f;
int attr = m_p_videoram[ x+1 + y*64 ] & 0x80;
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], code | attr, 0, 0,0, x*8,y*8);
}
}
return 0;
}
UINT32 kramermc_state::screen_update_kramermc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x,y;
address_space &space = m_maincpu->space(AS_PROGRAM);
for(y = 0; y < 16; y++ )
{
for(x = 0; x < 64; x++ )
{
int code = space.read_byte(KRAMERMC_VIDEO_MEMORY + x + y*64);
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], code , 0, 0,0, x*8,y*8);
}
}
return 0;
}
UINT32 itt3030_state::screen_update( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
address_space &space = m_maincpu->space(AS_PROGRAM);
for(int y = 0; y < 24; y++ )
{
for(int x = 0; x < 80; x++ )
{
UINT8 code = space.read_byte(0x3000 + x + y*128);
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], code , 0, 0,0, x*8,y*16);
}
}
return 0;
}
UINT32 dlair_state::screen_update_dleuro(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT8 *videoram = m_videoram;
int x, y;
/* redraw the overlay */
for (y = 0; y < 32; y++)
for (x = 0; x < 32; x++)
{
UINT8 *base = &videoram[y * 64 + x * 2 + 1];
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], base[0], base[1], 0, 0, 10 * x, 16 * y);
}
return 0;
}
UINT32 ac1_state::screen_update_ac1_32(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x,y;
address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
for(y = 0; y < 32; y++ )
{
for(x = 0; x < 64; x++ )
{
int code = space.read_byte(AC1_VIDEO_MEMORY + x + y*64);
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], code , 0, 0,0, 63*6-x*6,31*8-y*8);
}
}
return 0;
}
static SCREEN_UPDATE( dleuro )
{
dlair_state *state = screen->machine->driver_data<dlair_state>();
UINT8 *videoram = state->videoram;
int x, y;
/* redraw the overlay */
for (y = 0; y < 32; y++)
for (x = 0; x < 32; x++)
{
UINT8 *base = &videoram[y * 64 + x * 2 + 1];
drawgfx_opaque(bitmap, cliprect, screen->machine->gfx[0], base[0], base[1], 0, 0, 10 * x, 16 * y);
}
return 0;
}
GFXDECODE_END
UINT32 modellot_state::screen_update_modellot(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x,y;
for(y = 0; y < 16; y++ )
{
for(x = 0; x < 64; x++ )
{
int code = m_video_ram[x + y*64];
drawgfx_opaque(bitmap, cliprect, machine().gfx[0], code, 0, 0, 0, x*8, y*16);
}
}
return 0;
}