Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-22 00:11:58 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix long-standing architectural wart: the priority bitmap is no longer owned

Browse Source 
by the tilemap system, and no longer exists globally in the machine. Instead
it is allocated per-screen for all systems. This has several side-effects:

1. Previously, the pdrawgfx* functions were already changed to take the priority
bitmap as a parameter. Now all other hand-crafted functions that mess with
the priority bitmap generally must do so as well, and have been updated.

2. Calls to the tilemap system now need to provide a screen_device. This is not
just for the priority_bitmap, but also for screen flipping, which previously
always assumed the "primary screen" when doing flipping calculations.

3. All devices that implemented tilemap-like functionality have been updated
to follow the same pattern, since they largely tend to call through to the
core tilemap system at some point.
This commit is contained in:
Aaron Giles 2013-07-26 08:15:05 +00:00
parent b5e744c477
commit ec07fb1022
805 changed files with 4011 additions and 4014 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/emu/cpu/tms32031/32031ops.c
View File

@ -120,8 +120,7 @@ inline void tms3203x_device::execute_one()
m_icount -= 2; // 2 clocks per cycle
m_pc++;
#if (TMS_3203X_LOG_OPCODE_USAGE)
if (machine.primary_screen->frame_number() == 2003)
m_hits[op >> 21]++;
m_hits[op >> 21]++;
#endif
(this->*s_tms32031ops[op >> 21])(op);
}

10
src/emu/driver.c
View File

@ -550,9 +550,9 @@ void driver_device::updateflip()
machine().tilemap().set_flip_all((TILEMAP_FLIPX & m_flip_screen_x) | (TILEMAP_FLIPY & m_flip_screen_y));
// flip the visible area within the screen width/height
int width = machine().primary_screen->width();
int height = machine().primary_screen->height();
rectangle visarea = machine().primary_screen->visible_area();
int width = m_screen->width();
int height = m_screen->height();
rectangle visarea = m_screen->visible_area();
if (m_flip_screen_x)
{
int temp = width - visarea.min_x - 1;
@ -567,8 +567,8 @@ void driver_device::updateflip()
}
// reconfigure the screen with the new visible area
attoseconds_t period = machine().primary_screen->frame_period().attoseconds;
machine().primary_screen->configure(width, height, visarea, period);
attoseconds_t period = m_screen->frame_period().attoseconds;
m_screen->configure(width, height, visarea, period);
}

1
src/emu/machine.h
View File

@ -302,7 +302,6 @@ public:
const pen_t * pens; // remapped palette pen numbers
colortable_t * colortable; // global colortable for remapping
pen_t * shadow_table; // table for looking up a shadowed pen
bitmap_ind8 priority_bitmap; // priority bitmap
// debugger-related information
UINT32 debug_flags; // the current debug flags

18
src/emu/machine/tc009xlvc.c
View File

@ -286,9 +286,9 @@ const address_space_config *tc0091lvc_device::memory_space_config(address_spacen
}
void tc0091lvc_device::draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 global_flip )
void tc0091lvc_device::draw_sprites( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 global_flip )
{
gfx_element *gfx = machine.gfx[1];
gfx_element *gfx = screen.machine().gfx[1];
int count;
for(count=0;count<0x3e7;count+=8)
@ -312,7 +312,7 @@ void tc0091lvc_device::draw_sprites( running_machine &machine, bitmap_ind16 &bit
fy = !fy;
}
pdrawgfx_transpen(bitmap,cliprect,gfx,spr_offs,col,fx,fy,x,y,machine.priority_bitmap,(col & 0x08) ? 0xaa : 0x00,0);
pdrawgfx_transpen(bitmap,cliprect,gfx,spr_offs,col,fx,fy,x,y,screen.priority(),(col & 0x08) ? 0xaa : 0x00,0);
}
}
@ -342,7 +342,7 @@ UINT32 tc0091lvc_device::screen_update(screen_device &screen, bitmap_ind16 &bitm
res_x = (global_flip) ? 320-x : x;
res_y = (global_flip) ? 256-y : y;
if(machine().primary_screen->visible_area().contains(res_x, res_y))
if(screen.visible_area().contains(res_x, res_y))
bitmap.pix16(res_y, res_x) = screen.machine().pens[m_bitmap_ram[count]];
count++;
@ -371,11 +371,11 @@ UINT32 tc0091lvc_device::screen_update(screen_device &screen, bitmap_ind16 &bitm
tx_tilemap->set_scrollx(0, (global_flip) ? -192 : 0);
machine().priority_bitmap.fill(0, cliprect);
bg1_tilemap->draw(bitmap, cliprect, 0,0);
bg0_tilemap->draw(bitmap, cliprect, 0,(m_vregs[4] & 0x8) ? 0 : 1);
draw_sprites(machine(), bitmap, cliprect, global_flip);
tx_tilemap->draw(bitmap, cliprect, 0,0);
screen.priority().fill(0, cliprect);
bg1_tilemap->draw(screen, bitmap, cliprect, 0,0);
bg0_tilemap->draw(screen, bitmap, cliprect, 0,(m_vregs[4] & 0x8) ? 0 : 1);
draw_sprites(screen, bitmap, cliprect, global_flip);
tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
}
return 0;
}

2
src/emu/machine/tc009xlvc.h
View File

@ -66,7 +66,7 @@ public:
int m_gfx_index; // for RAM tiles
UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 global_flip);
void draw_sprites( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 global_flip);
void screen_eof(void);
protected:

1
src/emu/screen.c
View File

@ -287,6 +287,7 @@ void screen_device::device_start()
m_bitmap[index].set_format(format(), texformat);
register_screen_bitmap(m_bitmap[index]);
}
register_screen_bitmap(m_priority);
// allocate raw textures
m_texture[0] = machine().render().texture_alloc();

2
src/emu/screen.h
View File

@ -197,6 +197,7 @@ public:
// information getters
render_container &container() const { assert(m_container != NULL); return *m_container; }
bitmap_ind8 &priority() { return m_priority; }
// dynamic configuration
void configure(int width, int height, const rectangle &visarea, attoseconds_t frame_period);
@ -286,6 +287,7 @@ private:
texture_format m_texformat; // texture format
render_texture * m_texture[2]; // 2x textures for the screen bitmap
screen_bitmap m_bitmap[2]; // 2x bitmaps for rendering
bitmap_ind8 m_priority; // priority bitmap
bitmap_ind64 m_burnin; // burn-in bitmap
UINT8 m_curbitmap; // current bitmap index
UINT8 m_curtexture; // current texture index

43
src/emu/tilemap.c
View File

@ -905,9 +905,10 @@ UINT8 tilemap_t::tile_apply_bitmask(const UINT8 *maskdata, UINT32 x0, UINT32 y0,
// and indexed drawing code
//-------------------------------------------------
void tilemap_t::configure_blit_parameters(blit_parameters &blit, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
void tilemap_t::configure_blit_parameters(blit_parameters &blit, bitmap_ind8 &priority_bitmap, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{
// set the target bitmap
blit.priority = &priority_bitmap;
blit.cliprect = cliprect;
// set the priority code and alpha
@ -949,7 +950,7 @@ void tilemap_t::configure_blit_parameters(blit_parameters &blit, const rectangle
//-------------------------------------------------
template<class _BitmapClass>
void tilemap_t::draw_common(_BitmapClass &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
void tilemap_t::draw_common(screen_device &screen, _BitmapClass &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{
// skip if disabled
if (!m_enable)
@ -958,13 +959,13 @@ void tilemap_t::draw_common(_BitmapClass &dest, const rectangle &cliprect, UINT3
g_profiler.start(PROFILER_TILEMAP_DRAW);
// configure the blit parameters based on the input parameters
blit_parameters blit;
configure_blit_parameters(blit, cliprect, flags, priority, priority_mask);
configure_blit_parameters(blit, screen.priority(), cliprect, flags, priority, priority_mask);
// flush the dirty state to all tiles as appropriate
realize_all_dirty_tiles();
UINT32 width = machine().primary_screen->width();
UINT32 height = machine().primary_screen->height();
UINT32 width = screen.width();
UINT32 height = screen.height();
// XY scrolling playfield
if (m_scrollrows == 1 && m_scrollcols == 1)
@ -1054,11 +1055,11 @@ g_profiler.start(PROFILER_TILEMAP_DRAW);
g_profiler.stop();
}
void tilemap_t::draw(bitmap_ind16 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_common(dest, cliprect, flags, priority, priority_mask); }
void tilemap_t::draw(screen_device &screen, bitmap_ind16 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_common(screen, dest, cliprect, flags, priority, priority_mask); }
void tilemap_t::draw(bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_common(dest, cliprect, flags, priority, priority_mask); }
void tilemap_t::draw(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_common(screen, dest, cliprect, flags, priority, priority_mask); }
//-------------------------------------------------
@ -1069,7 +1070,7 @@ void tilemap_t::draw(bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags
//-------------------------------------------------
template<class _BitmapClass>
void tilemap_t::draw_roz_common(_BitmapClass &dest, const rectangle &cliprect,
void tilemap_t::draw_roz_common(screen_device &screen, _BitmapClass &dest, const rectangle &cliprect,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{
@ -1086,14 +1087,14 @@ void tilemap_t::draw_roz_common(_BitmapClass &dest, const rectangle &cliprect,
{
set_scrollx(0, startx >> 16);
set_scrolly(0, starty >> 16);
draw(dest, cliprect, flags, priority, priority_mask);
draw(screen, dest, cliprect, flags, priority, priority_mask);
return;
}
g_profiler.start(PROFILER_TILEMAP_DRAW_ROZ);
// configure the blit parameters
blit_parameters blit;
configure_blit_parameters(blit, cliprect, flags, priority, priority_mask);
configure_blit_parameters(blit, screen.priority(), cliprect, flags, priority, priority_mask);
// get the full pixmap for the tilemap
pixmap();
@ -1103,15 +1104,15 @@ g_profiler.start(PROFILER_TILEMAP_DRAW_ROZ);
g_profiler.stop();
}
void tilemap_t::draw_roz(bitmap_ind16 &dest, const rectangle &cliprect,
void tilemap_t::draw_roz(screen_device &screen, bitmap_ind16 &dest, const rectangle &cliprect,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_roz_common(dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority, priority_mask); }
{ draw_roz_common(screen, dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority, priority_mask); }
void tilemap_t::draw_roz(bitmap_rgb32 &dest, const rectangle &cliprect,
void tilemap_t::draw_roz(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_roz_common(dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority, priority_mask); }
{ draw_roz_common(screen, dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority, priority_mask); }
//-------------------------------------------------
@ -1135,7 +1136,7 @@ void tilemap_t::draw_instance(_BitmapClass &dest, const blit_parameters &blit, i
return;
// look up priority and destination base addresses for y1
bitmap_ind8 &priority_bitmap = machine().priority_bitmap;
bitmap_ind8 &priority_bitmap = *blit.priority;
UINT8 *priority_baseaddr = &priority_bitmap.pix8(y1, xpos);
typename _BitmapClass::pixel_t *dest_baseaddr = NULL;
int dest_rowpixels = 0;
@ -1304,7 +1305,7 @@ void tilemap_t::draw_roz_core(_BitmapClass &destbitmap, const blit_parameters &b
{
// pre-cache all the inner loop values
const rgb_t *clut = ((destbitmap.palette() != NULL) ? palette_entry_list_raw(destbitmap.palette()) : machine().pens) + (blit.tilemap_priority_code >> 16);
bitmap_ind8 &priority_bitmap = machine().priority_bitmap;
bitmap_ind8 &priority_bitmap = *blit.priority;
const int xmask = m_pixmap.width() - 1;
const int ymask = m_pixmap.height() - 1;
const int widthshifted = m_pixmap.width() << 16;
@ -1471,7 +1472,8 @@ void tilemap_t::draw_debug(bitmap_rgb32 &dest, UINT32 scrollx, UINT32 scrolly)
{
// set up for the blit, using hard-coded parameters (no priority, etc)
blit_parameters blit;
configure_blit_parameters(blit, dest.cliprect(), TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES, 0, 0xff);
bitmap_ind8 dummy_priority;
configure_blit_parameters(blit, dummy_priority, dest.cliprect(), TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES, 0, 0xff);
// compute the effective scroll positions
scrollx = m_width - scrollx % m_width;
@ -1664,9 +1666,6 @@ tilemap_manager::tilemap_manager(running_machine &machine)
: m_machine(machine),
m_instance(0)
{
if (machine.primary_screen == NULL || machine.primary_screen->width() == 0)
return;
machine.primary_screen->register_screen_bitmap(machine.priority_bitmap);
}

15
src/emu/tilemap.h
View File

@ -628,10 +628,10 @@ public:
void set_transmask(int group, UINT32 fgmask, UINT32 bgmask);
// drawing
void draw(bitmap_ind16 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask = 0xff);
void draw(bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask = 0xff);
void draw_roz(bitmap_ind16 &dest, const rectangle &cliprect, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask = 0xff);
void draw_roz(bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask = 0xff);
void draw(screen_device &screen, bitmap_ind16 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority = 0, UINT8 priority_mask = 0xff);
void draw(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority = 0, UINT8 priority_mask = 0xff);
void draw_roz(screen_device &screen, bitmap_ind16 &dest, const rectangle &cliprect, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound, UINT32 flags, UINT8 priority = 0, UINT8 priority_mask = 0xff);
void draw_roz(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound, UINT32 flags, UINT8 priority = 0, UINT8 priority_mask = 0xff);
void draw_debug(bitmap_rgb32 &dest, UINT32 scrollx, UINT32 scrolly);
// mappers
@ -665,6 +665,7 @@ private:
// blitting parameters for rendering
struct blit_parameters
{
bitmap_ind8 * priority;
rectangle cliprect;
UINT32 tilemap_priority_code;
UINT8 mask;
@ -698,9 +699,9 @@ private:
void tile_update(logical_index logindex, UINT32 col, UINT32 row);
UINT8 tile_draw(const UINT8 *pendata, UINT32 x0, UINT32 y0, UINT32 palette_base, UINT8 category, UINT8 group, UINT8 flags, UINT8 pen_mask);
UINT8 tile_apply_bitmask(const UINT8 *maskdata, UINT32 x0, UINT32 y0, UINT8 category, UINT8 flags);
void configure_blit_parameters(blit_parameters &blit, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask);
template<class _BitmapClass> void draw_common(_BitmapClass &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask);
template<class _BitmapClass> void draw_roz_common(_BitmapClass &dest, const rectangle &cliprect, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask);
void configure_blit_parameters(blit_parameters &blit, bitmap_ind8 &priority_bitmap, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask);
template<class _BitmapClass> void draw_common(screen_device &screen, _BitmapClass &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask);
template<class _BitmapClass> void draw_roz_common(screen_device &screen, _BitmapClass &dest, const rectangle &cliprect, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask);
template<class _BitmapClass> void draw_instance(_BitmapClass &dest, const blit_parameters &blit, int xpos, int ypos);
template<class _BitmapClass> void draw_roz_core(_BitmapClass &destbitmap, const blit_parameters &blit, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound);

4
src/emu/video/k053250.c
View File

@ -221,7 +221,7 @@ inline void k053250_device::pdraw_scanline32(bitmap_rgb32 &bitmap, const pen_t *
#undef FIXPOINT_PRECISION_HALF
}
void k053250_device::draw( bitmap_rgb32 &bitmap, const rectangle &cliprect, int colorbase, int flags, int priority )
void k053250_device::draw( bitmap_rgb32 &bitmap, const rectangle &cliprect, int colorbase, int flags, bitmap_ind8 &priority_bitmap, int priority )
{
UINT8 *pix_ptr;
const pen_t *pal_base, *pal_ptr;
@ -414,7 +414,7 @@ void k053250_device::draw( bitmap_rgb32 &bitmap, const rectangle &cliprect, int
priority : value to be written to the priority bitmap, no effect when equals 0
*/
pdraw_scanline32(bitmap, pal_ptr, pix_ptr, cliprect,
line_pos, scroll, zoom, src_clipmask, src_wrapmask, orientation, machine().priority_bitmap, (UINT8)priority);
line_pos, scroll, zoom, src_clipmask, src_wrapmask, orientation, priority_bitmap, (UINT8)priority);
// shift scanline position one virtual screen upward to render the wrapped end if necessary
scroll -= dst_height;

2
src/emu/video/k053250.h
View File

@ -26,7 +26,7 @@ public:
DECLARE_WRITE16_MEMBER(ram_w);
DECLARE_READ16_MEMBER(rom_r);
void draw( bitmap_rgb32 &bitmap, const rectangle &cliprect, int colorbase, int flags, int priority );
void draw( bitmap_rgb32 &bitmap, const rectangle &cliprect, int colorbase, int flags, bitmap_ind8 &priority_bitmap, int priority );
protected:
virtual void device_start();

2
src/mame/drivers/1945kiii.c
View File

@ -128,7 +128,7 @@ void k3_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
UINT32 k3_state::screen_update_k3(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
return 0;
}

6
src/mame/drivers/3x3puzzl.c
View File

@ -172,9 +172,9 @@ void _3x3puzzle_state::video_start()
UINT32 _3x3puzzle_state::screen_update( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
m_tilemap1->draw(bitmap, cliprect, 0, 1);
m_tilemap2->draw(bitmap, cliprect, 0, 2);
m_tilemap3->draw(bitmap, cliprect, 0, 3);
m_tilemap1->draw(screen, bitmap, cliprect, 0, 1);
m_tilemap2->draw(screen, bitmap, cliprect, 0, 2);
m_tilemap3->draw(screen, bitmap, cliprect, 0, 3);
return 0;
}

2
src/mame/drivers/5clown.c
View File

@ -546,7 +546,7 @@ void _5clown_state::video_start()
UINT32 _5clown_state::screen_update_fclown(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/acommand.c
View File

@ -260,9 +260,9 @@ void acommand_state::draw_led(bitmap_ind16 &bitmap, int x, int y,UINT8 value)
UINT32 acommand_state::screen_update_acommand(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0,0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
draw_sprites(bitmap,cliprect,0,0);
m_tx_tilemap->draw(bitmap, cliprect, 0,0);
m_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
/*Order might be wrong,but these for sure are the led numbers tested*/
draw_led(bitmap, 0, 20, (m_led0 & 0x0f00) >> 8);

2
src/mame/drivers/albazg.c
View File

@ -101,7 +101,7 @@ void albazg_state::video_start()
UINT32 albazg_state::screen_update_yumefuda(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/avt.c
View File

@ -526,7 +526,7 @@ UINT32 avt_state::screen_update_avt(screen_device &screen, bitmap_ind16 &bitmap,
count++;
}
}
//m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
//m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

22
src/mame/drivers/backfire.c
View File

@ -139,19 +139,19 @@ UINT32 backfire_state::screen_update_backfire_left(screen_device &screen, bitmap
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen2->pf_update(m_pf3_rowscroll, m_pf4_rowscroll);
machine().priority_bitmap.fill(0);
screen.priority().fill(0);
bitmap.fill(0x100, cliprect);
if (m_left_priority[0] == 0)
{
m_deco_tilegen2->tilemap_1_draw(bitmap, cliprect, 0, 1);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_1_draw(screen, bitmap, cliprect, 0, 1);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 2);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram_1, 0x800);
}
else if (m_left_priority[0] == 2)
{
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_1_draw(bitmap, cliprect, 0, 4);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_1_draw(screen, bitmap, cliprect, 0, 4);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram_1, 0x800);
}
else
@ -170,19 +170,19 @@ UINT32 backfire_state::screen_update_backfire_right(screen_device &screen, bitma
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen2->pf_update(m_pf3_rowscroll, m_pf4_rowscroll);
machine().priority_bitmap.fill(0);
screen.priority().fill(0);
bitmap.fill(0x500, cliprect);
if (m_right_priority[0] == 0)
{
m_deco_tilegen2->tilemap_2_draw(bitmap, cliprect, 0, 1);
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, 0, 1);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 2);
m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram_2, 0x800);
}
else if (m_right_priority[0] == 2)
{
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_2_draw(bitmap, cliprect, 0, 4);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, 0, 4);
m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram_2, 0x800);
}
else
@ -528,10 +528,12 @@ static MACHINE_CONFIG_START( backfire, backfire_state )
MCFG_DECO16IC_SET_SCREEN("lscreen")
MCFG_DEVICE_ADD("spritegen", DECO_SPRITE, 0)
MCFG_VIDEO_SET_SCREEN("lscreen")
decospr_device::set_gfx_region(*device, 4);
decospr_device::set_pri_callback(*device, backfire_pri_callback);
MCFG_DEVICE_ADD("spritegen2", DECO_SPRITE, 0)
MCFG_VIDEO_SET_SCREEN("rscreen")
decospr_device::set_gfx_region(*device, 5);
decospr_device::set_pri_callback(*device, backfire_pri_callback);

12
src/mame/drivers/bestleag.c
View File

@ -187,10 +187,10 @@ UINT32 bestleag_state::screen_update_bestleag(screen_device &screen, bitmap_ind1
m_fg_tilemap->set_scrollx(0,m_vregs[0x08/2] & 0xfff8);
m_fg_tilemap->set_scrolly(0,m_vregs[0x0a/2]);
m_bg_tilemap->draw(bitmap, cliprect, 0,0);
m_fg_tilemap->draw(bitmap, cliprect, 0,0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0,0);
draw_sprites(bitmap,cliprect);
m_tx_tilemap->draw(bitmap, cliprect, 0,0);
m_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}
@ -203,10 +203,10 @@ UINT32 bestleag_state::screen_update_bestleaw(screen_device &screen, bitmap_ind1
m_fg_tilemap->set_scrollx(0,m_vregs[0x04/2]);
m_fg_tilemap->set_scrolly(0,m_vregs[0x06/2]);
m_bg_tilemap->draw(bitmap, cliprect, 0,0);
m_fg_tilemap->draw(bitmap, cliprect, 0,0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0,0);
draw_sprites(bitmap,cliprect);
m_tx_tilemap->draw(bitmap, cliprect, 0,0);
m_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

2
src/mame/drivers/blitz.c
View File

@ -364,7 +364,7 @@ void blitz_state::video_start()
UINT32 blitz_state::screen_update_megadpkr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

34
src/mame/drivers/bnstars.c
View File

@ -159,9 +159,9 @@ public:
UINT32 screen_update_bnstars_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
UINT32 screen_update_bnstars_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(ms32_interrupt);
void draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int chip);
void draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int chip);
void update_color(int color, int screen);
void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *sprram_top, size_t sprram_size, int region);
void draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *sprram_top, size_t sprram_size, int region);
void irq_init();
void irq_raise(int level);
IRQ_CALLBACK_MEMBER(irq_callback);
@ -238,7 +238,7 @@ WRITE32_MEMBER(bnstars_state::ms32_bg1_ram_w)
/* ROZ Layers */
void bnstars_state::draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int chip)
void bnstars_state::draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int chip)
{
/* TODO: registers 0x40/4 / 0x44/4 and 0x50/4 / 0x54/4 are used, meaning unknown */
@ -282,7 +282,7 @@ void bnstars_state::draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect, in
if (incxx & 0x10000) incxx |= ~0x1ffff;
if (incxy & 0x10000) incxy |= ~0x1ffff;
m_ms32_roz_tilemap->draw_roz(bitmap, &my_clip,
m_ms32_roz_tilemap->draw_roz(screen, bitmap, &my_clip,
(start2x+startx+offsx)<<16, (start2y+starty+offsy)<<16,
incxx<<8, incxy<<8, 0, 0,
1, // Wrap
@ -314,7 +314,7 @@ void bnstars_state::draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect, in
if (incyy & 0x10000) incyy |= ~0x1ffff;
if (incyx & 0x10000) incyx |= ~0x1ffff;
m_ms32_roz_tilemap[chip]->draw_roz(bitmap, cliprect,
m_ms32_roz_tilemap[chip]->draw_roz(screen, bitmap, cliprect,
(startx+offsx)<<16, (starty+offsy)<<16,
incxx<<8, incxy<<8, incyx<<8, incyy<<8,
1, // Wrap
@ -381,7 +381,7 @@ WRITE32_MEMBER(bnstars_state::ms32_pal1_ram_w)
/* SPRITES based on tetrisp2 for now, readd priority bits later */
void bnstars_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *sprram_top, size_t sprram_size, int region)
void bnstars_state::draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *sprram_top, size_t sprram_size, int region)
{
/***************************************************************************
@ -502,7 +502,7 @@ void bnstars_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect
color,
flipx, flipy,
sx,sy,
xzoom, yzoom, machine().priority_bitmap,pri_mask, 0);
xzoom, yzoom, screen.priority(),pri_mask, 0);
} /* end sprite loop */
}
@ -540,45 +540,45 @@ void bnstars_state::video_start()
UINT32 bnstars_state::screen_update_bnstars_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
machine().priority_bitmap.fill(0, cliprect);
screen.priority().fill(0, cliprect);
bitmap.fill(0, cliprect); /* bg color */
m_ms32_bg_tilemap[0]->set_scrollx(0, m_ms32_bg0_scroll[0x00/4] + m_ms32_bg0_scroll[0x08/4] + 0x10 );
m_ms32_bg_tilemap[0]->set_scrolly(0, m_ms32_bg0_scroll[0x0c/4] + m_ms32_bg0_scroll[0x14/4] );
m_ms32_bg_tilemap[0]->draw(bitmap, cliprect, 0,1);
m_ms32_bg_tilemap[0]->draw(screen, bitmap, cliprect, 0,1);
draw_roz(bitmap,cliprect,2,0);
draw_roz(screen,bitmap,cliprect,2,0);
m_ms32_tx_tilemap[0]->set_scrollx(0, m_ms32_tx0_scroll[0x00/4] + m_ms32_tx0_scroll[0x08/4] + 0x18);
m_ms32_tx_tilemap[0]->set_scrolly(0, m_ms32_tx0_scroll[0x0c/4] + m_ms32_tx0_scroll[0x14/4]);
m_ms32_tx_tilemap[0]->draw(bitmap, cliprect, 0,4);
m_ms32_tx_tilemap[0]->draw(screen, bitmap, cliprect, 0,4);
draw_sprites(bitmap,cliprect, m_ms32_spram, 0x20000, 0);
draw_sprites(screen,bitmap,cliprect, m_ms32_spram, 0x20000, 0);
return 0;
}
UINT32 bnstars_state::screen_update_bnstars_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
machine().priority_bitmap.fill(0, cliprect);
screen.priority().fill(0, cliprect);
bitmap.fill(0x8000+0, cliprect); /* bg color */
m_ms32_bg_tilemap[1]->set_scrollx(0, m_ms32_bg1_scroll[0x00/4] + m_ms32_bg1_scroll[0x08/4] + 0x10 );
m_ms32_bg_tilemap[1]->set_scrolly(0, m_ms32_bg1_scroll[0x0c/4] + m_ms32_bg1_scroll[0x14/4] );
m_ms32_bg_tilemap[1]->draw(bitmap, cliprect, 0,1);
m_ms32_bg_tilemap[1]->draw(screen, bitmap, cliprect, 0,1);
draw_roz(bitmap,cliprect,2,1);
draw_roz(screen,bitmap,cliprect,2,1);
m_ms32_tx_tilemap[1]->set_scrollx(0, m_ms32_tx1_scroll[0x00/4] + m_ms32_tx1_scroll[0x08/4] + 0x18);
m_ms32_tx_tilemap[1]->set_scrolly(0, m_ms32_tx1_scroll[0x0c/4] + m_ms32_tx1_scroll[0x14/4]);
m_ms32_tx_tilemap[1]->draw(bitmap, cliprect, 0,4);
m_ms32_tx_tilemap[1]->draw(screen, bitmap, cliprect, 0,4);
draw_sprites(bitmap,cliprect, m_ms32_spram+(0x20000/4), 0x20000, 4);
draw_sprites(screen,bitmap,cliprect, m_ms32_spram+(0x20000/4), 0x20000, 4);
return 0;
}

4
src/mame/drivers/cabaret.c
View File

@ -120,9 +120,9 @@ UINT32 cabaret_state::screen_update_cabaret(screen_device &screen, bitmap_ind16
{
bitmap.fill(get_black_pen(machine()), cliprect);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/calorie.c
View File

@ -158,12 +158,12 @@ UINT32 calorie_state::screen_update_calorie(screen_device &screen, bitmap_ind16
if (m_bg_bank & 0x10)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
}
else
{
m_fg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
}

2
src/mame/drivers/caswin.c
View File

@ -118,7 +118,7 @@ void caswin_state::video_start()
UINT32 caswin_state::screen_update_vvillage(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
m_sc0_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

6
src/mame/drivers/cb2001.c
View File

@ -401,9 +401,9 @@ UINT32 cb2001_state::screen_update_cb2001(screen_device &screen, bitmap_rgb32 &b
const rectangle visible2(0*8, (14+48)*8-1, 10*8, (10+7)*8-1);
const rectangle visible3(0*8, (14+48)*8-1, 17*8, (17+7)*8-1);
m_reel1_tilemap->draw(bitmap, visible1, 0, 0);
m_reel2_tilemap->draw(bitmap, visible2, 0, 0);
m_reel3_tilemap->draw(bitmap, visible3, 0, 0);
m_reel1_tilemap->draw(screen, bitmap, visible1, 0, 0);
m_reel2_tilemap->draw(screen, bitmap, visible2, 0, 0);
m_reel3_tilemap->draw(screen, bitmap, visible3, 0, 0);
}
}

2
src/mame/drivers/cball.c
View File

@ -70,7 +70,7 @@ void cball_state::video_start()
UINT32 cball_state::screen_update_cball(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
/* draw playfield */
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* draw sprite */
drawgfx_transpen(bitmap, cliprect, machine().gfx[1],

4
src/mame/drivers/chanbara.c
View File

@ -208,9 +208,9 @@ void chanbara_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
UINT32 chanbara_state::screen_update_chanbara(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg2_tilemap->set_scrolly(0, m_scroll | (m_scrollhi << 8));
m_bg2_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/chance32.c
View File

@ -109,8 +109,8 @@ UINT32 chance32_state::screen_update_chance32(screen_device &screen, bitmap_ind1
m_fg_tilemap->set_scrollx(0, 352);
m_fg_tilemap->set_scrolly(0, 160);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

8
src/mame/drivers/cntsteer.c
View File

@ -320,7 +320,7 @@ UINT32 cntsteer_state::screen_update_zerotrgt(screen_device &screen, bitmap_ind1
x = -256 - (m_scrollx | m_scrollx_hi);
y = 256 + (m_scrolly | m_scrolly_hi);
m_bg_tilemap->draw_roz(bitmap, cliprect,
m_bg_tilemap->draw_roz(screen, bitmap, cliprect,
(x << 16), (y << 16),
p1, p2,
p3, p4,
@ -329,7 +329,7 @@ UINT32 cntsteer_state::screen_update_zerotrgt(screen_device &screen, bitmap_ind1
}
zerotrgt_draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
@ -367,7 +367,7 @@ UINT32 cntsteer_state::screen_update_cntsteer(screen_device &screen, bitmap_ind1
x = 256 + (m_scrollx | m_scrollx_hi);
y = 256 - (m_scrolly | m_scrolly_hi);
m_bg_tilemap->draw_roz(bitmap, cliprect,
m_bg_tilemap->draw_roz(screen, bitmap, cliprect,
(x << 16), (y << 16),
p1, p2,
p3, p4,
@ -376,7 +376,7 @@ UINT32 cntsteer_state::screen_update_cntsteer(screen_device &screen, bitmap_ind1
}
cntsteer_draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/cobra.c
View File

@ -1008,7 +1008,7 @@ UINT32 cobra_state::screen_update_cobra(screen_device &screen, bitmap_rgb32 &bit
if (m_has_psac)
{
m_k001604->draw_back_layer(bitmap, cliprect);
m_k001604->draw_front_layer(bitmap, cliprect);
m_k001604->draw_front_layer(screen, bitmap, cliprect);
}
m_renderer->display(&bitmap, cliprect);

2
src/mame/drivers/coinmstr.c
View File

@ -925,7 +925,7 @@ void coinmstr_state::video_start()
UINT32 coinmstr_state::screen_update_coinmstr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/cshooter.c
View File

@ -205,7 +205,7 @@ UINT32 cshooter_state::screen_update_cshooter(screen_device &screen, bitmap_ind1
//draw_sprites(bitmap, cliprect);
m_txtilemap->draw(bitmap, cliprect, 0,0);
m_txtilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}
@ -226,7 +226,7 @@ UINT32 cshooter_state::screen_update_airraid(screen_device &screen, bitmap_ind16
draw_sprites(bitmap, cliprect);
m_txtilemap->draw(bitmap, cliprect, 0,0);
m_txtilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

6
src/mame/drivers/cultures.c
View File

@ -124,9 +124,9 @@ UINT32 cultures_state::screen_update_cultures(screen_device &screen, bitmap_ind1
m_bg1_tilemap->set_scrolly(0, (m_bg1_regs_y[2] << 8) + m_bg1_regs_y[0]);
m_bg2_tilemap->set_scrolly(0, (m_bg2_regs_y[2] << 8) + m_bg2_regs_y[0]);
m_bg2_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg0_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg1_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_bg0_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_bg1_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/cybertnk.c
View File

@ -490,14 +490,14 @@ static UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const r
draw_road(screen,bitmap,cliprect,screen_shift, 0x00);
state->m_tilemap2_tilemap->draw(bitmap, cliprect, 0,0);
state->m_tilemap1_tilemap->draw(bitmap, cliprect, 0,0);
state->m_tilemap2_tilemap->draw(screen, bitmap, cliprect, 0,0);
state->m_tilemap1_tilemap->draw(screen, bitmap, cliprect, 0,0);
draw_road(screen,bitmap,cliprect,screen_shift, 0x80);
draw_sprites(screen,bitmap,cliprect,screen_shift);
state->m_tilemap0_tilemap->draw(bitmap, cliprect, 0,0);
state->m_tilemap0_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;

2
src/mame/drivers/d9final.c
View File

@ -71,7 +71,7 @@ void d9final_state::video_start()
UINT32 d9final_state::screen_update_d9final(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
m_sc0_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

4
src/mame/drivers/dacholer.c
View File

@ -170,9 +170,9 @@ UINT32 dacholer_state::screen_update_dacholer(screen_device &screen, bitmap_ind1
m_bg_tilemap->set_scrolly(0, m_scroll_y);
}
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/dblewing.c
View File

@ -93,10 +93,10 @@ UINT32 dblewing_state::screen_update_dblewing(screen_device &screen, bitmap_ind1
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
bitmap.fill(0, cliprect); /* not Confirmed */
machine().priority_bitmap.fill(0);
screen.priority().fill(0);
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, 0, 2);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 4);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 4);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
return 0;
}

2
src/mame/drivers/ddayjlc.c
View File

@ -392,7 +392,7 @@ void ddayjlc_state::video_start()
UINT32 ddayjlc_state::screen_update_ddayjlc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT32 i;
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
for (i = 0; i < 0x400; i += 4)
{

2
src/mame/drivers/ddealer.c
View File

@ -275,7 +275,7 @@ UINT32 ddealer_state::screen_update_ddealer(screen_device &screen, bitmap_ind16
{
m_back_tilemap->set_scrollx(0, m_flipscreen ? -192 : -64);
m_back_tilemap->set_flip(m_flipscreen ? TILEMAP_FLIPY | TILEMAP_FLIPX : 0);
m_back_tilemap->draw(bitmap, cliprect, 0, 0);
m_back_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* the fg tilemap handling is a little hacky right now,
i'm not sure if it should be a single tilemap with

6
src/mame/drivers/deco156.c
View File

@ -82,14 +82,14 @@ UINT32 deco156_state::screen_update_wcvol95(screen_device &screen, bitmap_rgb32
//FIXME: flip_screen_x should not be written!
flip_screen_set_no_update(1);
machine().priority_bitmap.fill(0);
screen.priority().fill(0);
bitmap.fill(0);
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x800);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 0);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/dreambal.c
View File

@ -80,10 +80,10 @@ UINT32 dreambal_state::screen_update_dreambal(screen_device &screen, bitmap_ind1
m_deco_tilegen1->pf_update(NULL, NULL);
bitmap.fill(0, cliprect); /* not Confirmed */
machine().priority_bitmap.fill(0);
screen.priority().fill(0);
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, 0, 2);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 4);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 4);
return 0;
}

4
src/mame/drivers/dreamwld.c
View File

@ -393,8 +393,8 @@ UINT32 dreamwld_state::screen_update_dreamwld(screen_device &screen, bitmap_ind1
m_bg2_tilemap->mark_all_dirty();
}
tmptilemap0->draw(bitmap, cliprect, 0, 0);
tmptilemap1->draw(bitmap, cliprect, 0, 0);
tmptilemap0->draw(screen, bitmap, cliprect, 0, 0);
tmptilemap1->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);

4
src/mame/drivers/drtomy.c
View File

@ -136,8 +136,8 @@ void drtomy_state::video_start()
UINT32 drtomy_state::screen_update_drtomy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tilemap_bg->draw(bitmap, cliprect, 0, 0);
m_tilemap_fg->draw(bitmap, cliprect, 0, 0);
m_tilemap_bg->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap_fg->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
return 0;
}

2
src/mame/drivers/drw80pkr.c
View File

@ -343,7 +343,7 @@ void drw80pkr_state::video_start()
UINT32 drw80pkr_state::screen_update_drw80pkr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

10
src/mame/drivers/dunhuang.c
View File

@ -180,16 +180,16 @@ if (machine().input().code_pressed(KEYCODE_Z))
switch (m_layers)
{
case 0x04: // girl select: bg over fg
if (layers_ctrl & 2) m_tmap2->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 2) m_tmap2->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_tmap->draw(screen, bitmap, cliprect, 0, 0);
break;
case 0x05: // dips: must hide fg
if (layers_ctrl & 1) m_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_tmap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
break;
case 0x07: // game,demo: fg over bg
default:
if (layers_ctrl & 1) m_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 2) m_tmap2->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 1) m_tmap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 2) m_tmap2->draw(screen, bitmap, cliprect, 0, 0);
break;
}

4
src/mame/drivers/dynadice.c
View File

@ -218,8 +218,8 @@ UINT32 dynadice_state::screen_update_dynadice(screen_device &screen, bitmap_ind1
{
rectangle myclip = cliprect;
myclip.max_x = 15;
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_top_tilemap->draw(bitmap, myclip, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_top_tilemap->draw(screen, bitmap, myclip, 0, 0);
return 0;
}

2
src/mame/drivers/egghunt.c
View File

@ -187,7 +187,7 @@ void egghunt_state::video_start()
UINT32 egghunt_state::screen_update_egghunt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
return 0;
}

4
src/mame/drivers/ettrivia.c
View File

@ -266,8 +266,8 @@ void ettrivia_state::video_start()
UINT32 ettrivia_state::screen_update_ettrivia(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0,0);
m_fg_tilemap->draw(bitmap, cliprect, 0,0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

6
src/mame/drivers/expro02.c
View File

@ -240,16 +240,16 @@ UINT32 expro02_state::screen_update_galsnew(screen_device &screen, bitmap_ind16
int i;
machine().priority_bitmap.fill(0, cliprect);
screen.priority().fill(0, cliprect);
m_view2_0->kaneko16_prepare(bitmap, cliprect);
for ( i = 0; i < 8; i++ )
{
m_view2_0->render_tilemap_chip(bitmap,cliprect,i);
m_view2_0->render_tilemap_chip(screen,bitmap,cliprect,i);
}
m_kaneko_spr->kaneko16_render_sprites(machine(),bitmap,cliprect, m_spriteram, m_spriteram.bytes());
m_kaneko_spr->kaneko16_render_sprites(machine(),bitmap,cliprect, screen.priority(), m_spriteram, m_spriteram.bytes());
return 0;
}

30
src/mame/drivers/fcrash.c
View File

@ -492,7 +492,7 @@ void cps_state::fcrash_update_transmasks()
}
}
void cps_state::fcrash_render_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
void cps_state::fcrash_render_sprites( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
int pos;
int base = m_sprite_base / 2;
@ -523,27 +523,27 @@ void cps_state::fcrash_render_sprites( bitmap_ind16 &bitmap, const rectangle &cl
ypos = 256 - ypos - 16;
xpos = xpos + m_sprite_x_offset + 49;
pdrawgfx_transpen(bitmap, cliprect, machine().gfx[2], tileno, colour, flipx, flipy, xpos, ypos, machine().priority_bitmap, 0x02, 15);
pdrawgfx_transpen(bitmap, cliprect, machine().gfx[2], tileno, colour, flipx, flipy, xpos, ypos, screen.priority(), 0x02, 15);
}
}
}
void cps_state::fcrash_render_layer( bitmap_ind16 &bitmap, const rectangle &cliprect, int layer, int primask )
void cps_state::fcrash_render_layer( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int layer, int primask )
{
switch (layer)
{
case 0:
fcrash_render_sprites(bitmap, cliprect);
fcrash_render_sprites(screen, bitmap, cliprect);
break;
case 1:
case 2:
case 3:
m_bg_tilemap[layer - 1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, primask);
m_bg_tilemap[layer - 1]->draw(screen, bitmap, cliprect, TILEMAP_DRAW_LAYER1, primask);
break;
}
}
void cps_state::fcrash_render_high_layer( bitmap_ind16 &bitmap, const rectangle &cliprect, int layer )
void cps_state::fcrash_render_high_layer( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int layer )
{
bitmap_ind16 dummy_bitmap;
@ -555,7 +555,7 @@ void cps_state::fcrash_render_high_layer( bitmap_ind16 &bitmap, const rectangle
case 1:
case 2:
case 3:
m_bg_tilemap[layer - 1]->draw(dummy_bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
m_bg_tilemap[layer - 1]->draw(screen, dummy_bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
break;
}
}
@ -637,28 +637,28 @@ UINT32 cps_state::screen_update_fcrash(screen_device &screen, bitmap_ind16 &bitm
/* Blank screen */
bitmap.fill(0xbff, cliprect);
machine().priority_bitmap.fill(0, cliprect);
screen.priority().fill(0, cliprect);
l0 = (layercontrol >> 0x06) & 03;
l1 = (layercontrol >> 0x08) & 03;
l2 = (layercontrol >> 0x0a) & 03;
l3 = (layercontrol >> 0x0c) & 03;
fcrash_render_layer(bitmap, cliprect, l0, 0);
fcrash_render_layer(screen, bitmap, cliprect, l0, 0);
if (l1 == 0)
fcrash_render_high_layer(bitmap, cliprect, l0);
fcrash_render_high_layer(screen, bitmap, cliprect, l0);
fcrash_render_layer(bitmap, cliprect, l1, 0);
fcrash_render_layer(screen, bitmap, cliprect, l1, 0);
if (l2 == 0)
fcrash_render_high_layer(bitmap, cliprect, l1);
fcrash_render_high_layer(screen, bitmap, cliprect, l1);
fcrash_render_layer(bitmap, cliprect, l2, 0);
fcrash_render_layer(screen, bitmap, cliprect, l2, 0);
if (l3 == 0)
fcrash_render_high_layer(bitmap, cliprect, l2);
fcrash_render_high_layer(screen, bitmap, cliprect, l2);
fcrash_render_layer(bitmap, cliprect, l3, 0);
fcrash_render_layer(screen, bitmap, cliprect, l3, 0);
return 0;
}

2
src/mame/drivers/firefox.c
View File

@ -252,7 +252,7 @@ UINT32 firefox_state::screen_update_firefox(screen_device &screen, bitmap_rgb32
}
}
m_bgtiles->draw(bitmap, cliprect, 0, 0 );
m_bgtiles->draw(screen, bitmap, cliprect, 0, 0 );
return 0;
}

2
src/mame/drivers/flyball.c
View File

@ -126,7 +126,7 @@ UINT32 flyball_state::screen_update_flyball(screen_device &screen, bitmap_ind16
m_tmap->mark_all_dirty();
/* draw playfield */
m_tmap->draw(bitmap, cliprect, 0, 0);
m_tmap->draw(screen, bitmap, cliprect, 0, 0);
/* draw pitcher */
drawgfx_transpen(bitmap, cliprect, machine().gfx[1], m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1);

4
src/mame/drivers/fresh.c
View File

@ -180,8 +180,8 @@ void fresh_state::video_start()
UINT32 fresh_state::screen_update_fresh(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_2_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/gal3.c
View File

@ -207,14 +207,14 @@ UINT32 gal3_state::screen_update_gal3(screen_device &screen, bitmap_rgb32 &bitma
for( pri=0; pri<pivot; pri++ )
{
c355_obj_draw(bitmap, cliprect, pri);
c355_obj_draw(screen, bitmap, cliprect, pri);
}
/* CopyVisiblePolyFrameBuffer( bitmap, cliprect,0,0x7fbf );
for( pri=pivot; pri<15; pri++ )
{
c355_obj_draw(bitmap, cliprect, pri);
c355_obj_draw(screen, bitmap, cliprect, pri);
}*/
// CPU Diag LEDs

10
src/mame/drivers/galaxi.c
View File

@ -201,13 +201,13 @@ UINT32 galaxi_state::screen_update_galaxi(screen_device &screen, bitmap_ind16 &b
}
#endif
if (layers_ctrl & 1) m_bg1_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_bg1_tmap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
else bitmap.fill(get_black_pen(machine()), cliprect);
if (layers_ctrl & 2) m_bg2_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 4) m_bg3_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 8) m_bg4_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 2) m_bg2_tmap->draw(screen, bitmap, cliprect, 0, 0);
if (layers_ctrl & 4) m_bg3_tmap->draw(screen, bitmap, cliprect, 0, 0);
if (layers_ctrl & 8) m_bg4_tmap->draw(screen, bitmap, cliprect, 0, 0);
if (layers_ctrl & 16) m_fg_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 16) m_fg_tmap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/gluck2.c
View File

@ -265,7 +265,7 @@ void gluck2_state::video_start()
UINT32 gluck2_state::screen_update_gluck2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/goldnpkr.c
View File

@ -1144,7 +1144,7 @@ VIDEO_START_MEMBER(goldnpkr_state,wcrdxtnd)
UINT32 goldnpkr_state::screen_update_goldnpkr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/good.c
View File

@ -100,8 +100,8 @@ void good_state::video_start()
UINT32 good_state::screen_update_good(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

8
src/mame/drivers/goodejan.c
View File

@ -350,13 +350,13 @@ UINT32 goodejan_state::screen_update_goodejan(screen_device &screen, bitmap_ind1
m_sc3_tilemap->set_scrollx(0, (0) & 0x1ff );
m_sc3_tilemap->set_scrolly(0, (0) & 0x1ff );
if(SEIBU_CRTC_ENABLE_SC0) { m_sc0_tilemap->draw(bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SC0) { m_sc0_tilemap->draw(screen, bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SPR) { draw_sprites(screen.machine(), bitmap,cliprect, 2); }
if(SEIBU_CRTC_ENABLE_SC2) { m_sc2_tilemap->draw(bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SC2) { m_sc2_tilemap->draw(screen, bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SPR) { draw_sprites(screen.machine(), bitmap,cliprect, 1); }
if(SEIBU_CRTC_ENABLE_SC1) { m_sc1_tilemap->draw(bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SC1) { m_sc1_tilemap->draw(screen, bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SPR) { draw_sprites(screen.machine(), bitmap,cliprect, 0); }
if(SEIBU_CRTC_ENABLE_SC3) { m_sc3_tilemap->draw(bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SC3) { m_sc3_tilemap->draw(screen, bitmap, cliprect, 0,0); }
if(SEIBU_CRTC_ENABLE_SPR) { draw_sprites(screen.machine(), bitmap,cliprect, 3); }
return 0;

6
src/mame/drivers/gstream.c
View File

@ -510,9 +510,9 @@ UINT32 gstream_state::screen_update_gstream(screen_device &screen, bitmap_ind16
m_tilemap2->set_scrollx(0, m_tmap2_scrollx >> 16);
m_tilemap2->set_scrolly(0, m_tmap2_scrolly >> 16);
m_tilemap3->draw(bitmap, cliprect, 0, 0);
m_tilemap2->draw(bitmap, cliprect, 0, 0);
m_tilemap1->draw(bitmap, cliprect, 0, 0);
m_tilemap3->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap2->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap1->draw(screen, bitmap, cliprect, 0, 0);
for (i = 0x0000 / 4; i < 0x4000 / 4; i += 4)
{

6
src/mame/drivers/gticlub.c
View File

@ -870,7 +870,7 @@ UINT32 gticlub_state::screen_update_gticlub(screen_device &screen, bitmap_rgb32
K001005_draw(bitmap, cliprect);
k001604->draw_front_layer(bitmap, cliprect);
k001604->draw_front_layer(screen, bitmap, cliprect);
#if 0
tick++;
@ -943,7 +943,7 @@ UINT32 gticlub_state::screen_update_hangplt(screen_device &screen, bitmap_rgb32
voodoo_update(voodoo, bitmap, cliprect);
k001604->draw_front_layer(bitmap, cliprect);
k001604->draw_front_layer(screen, bitmap, cliprect);
}
else if (strcmp(screen.tag(), ":rscreen") == 0)
{
@ -954,7 +954,7 @@ UINT32 gticlub_state::screen_update_hangplt(screen_device &screen, bitmap_rgb32
voodoo_update(voodoo, bitmap, cliprect);
k001604->draw_front_layer(bitmap, cliprect);
k001604->draw_front_layer(screen, bitmap, cliprect);
}
draw_7segment_led(bitmap, 3, 3, gticlub_led_reg[0]);

2
src/mame/drivers/headonb.c
View File

@ -77,7 +77,7 @@ void headonb_state::video_start()
UINT32 headonb_state::screen_update_headonb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tilemap->draw(bitmap, cliprect, 0, 0);
m_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/hitme.c
View File

@ -79,7 +79,7 @@ UINT32 hitme_state::screen_update_hitme(screen_device &screen, bitmap_ind16 &bit
offs_t offs = 0;
/* start by drawing the tilemap */
m_tilemap->draw(bitmap, cliprect, 0, 0);
m_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* now loop over and invert anything */
for (y = 0; y < 19; y++)
@ -114,7 +114,7 @@ UINT32 hitme_state::screen_update_hitme(screen_device &screen, bitmap_ind16 &bit
UINT32 hitme_state::screen_update_barricad(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tilemap->draw(bitmap, cliprect, 0, 0);
m_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/hornet.c
View File

@ -454,7 +454,7 @@ UINT32 hornet_state::screen_update_hornet(screen_device &screen, bitmap_rgb32 &b
voodoo_update(voodoo, bitmap, cliprect);
m_k037122_1->tile_draw(bitmap, cliprect);
m_k037122_1->tile_draw(screen, bitmap, cliprect);
draw_7segment_led(bitmap, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1);
@ -469,7 +469,7 @@ UINT32 hornet_state::screen_update_hornet_2board(screen_device &screen, bitmap_r
voodoo_update(voodoo, bitmap, cliprect);
/* TODO: tilemaps per screen */
m_k037122_1->tile_draw(bitmap, cliprect);
m_k037122_1->tile_draw(screen, bitmap, cliprect);
}
else if (strcmp(screen.tag(), ":rscreen") == 0)
{
@ -477,7 +477,7 @@ UINT32 hornet_state::screen_update_hornet_2board(screen_device &screen, bitmap_r
voodoo_update(voodoo, bitmap, cliprect);
/* TODO: tilemaps per screen */
m_k037122_2->tile_draw(bitmap, cliprect);
m_k037122_2->tile_draw(screen, bitmap, cliprect);
}
draw_7segment_led(bitmap, 3, 3, m_led_reg0);

2
src/mame/drivers/hvyunit.c
View File

@ -185,7 +185,7 @@ UINT32 hvyunit_state::screen_update_hvyunit(screen_device &screen, bitmap_ind16
m_bg_tilemap->set_scrollx(0, ((m_port0_data & 0x40) << 2) + m_scrollx + SX_POS); // TODO
m_bg_tilemap->set_scrolly(0, ((m_port0_data & 0x80) << 1) + m_scrolly + SY_POS); // TODO
bitmap.fill(get_black_pen(machine()), cliprect);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_pandora->update(bitmap, cliprect);
return 0;

10
src/mame/drivers/igs009.c
View File

@ -330,19 +330,19 @@ UINT32 igs009_state::screen_update_jingbell(screen_device &screen, bitmap_ind16
if (rowenable==0)
{ // 0 and 1 are the same? or is there a global switchoff?
m_gp98_reel1_tilemap->draw(bitmap, clip, 0,0);
m_gp98_reel1_tilemap->draw(screen, bitmap, clip, 0,0);
}
else if (rowenable==1)
{
m_gp98_reel2_tilemap->draw(bitmap, clip, 0,0);
m_gp98_reel2_tilemap->draw(screen, bitmap, clip, 0,0);
}
else if (rowenable==2)
{
m_gp98_reel3_tilemap->draw(bitmap, clip, 0,0);
m_gp98_reel3_tilemap->draw(screen, bitmap, clip, 0,0);
}
else if (rowenable==3)
{
m_gp98_reel4_tilemap->draw(bitmap, clip, 0,0);
m_gp98_reel4_tilemap->draw(screen, bitmap, clip, 0,0);
}
@ -353,7 +353,7 @@ UINT32 igs009_state::screen_update_jingbell(screen_device &screen, bitmap_ind16
else bitmap.fill(get_black_pen(machine()), cliprect);
if (layers_ctrl & 2) m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 2) m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/igs017.c
View File

@ -455,11 +455,11 @@ UINT32 igs017_state::screen_update_igs017(screen_device &screen, bitmap_ind16 &b
if (m_video_disable)
return 0;
if (layers_ctrl & 1) m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_bg_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 4) draw_sprites(bitmap, cliprect);
if (layers_ctrl & 2) m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 2) m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/igs_m027.c
View File

@ -201,12 +201,12 @@ UINT32 igs_m027_state::screen_update_igs_majhong(screen_device &screen, bitmap_i
bitmap.fill(get_black_pen(machine()), cliprect);
//??????
m_igs_bg_tilemap->draw(bitmap, cliprect, 0,0);
m_igs_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
//CG??????
//??????
m_igs_tx_tilemap->draw(bitmap, cliprect, 0,0);
m_igs_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
//fprintf(stdout,"Video UPDATE OK!\n");
return 0;
}

6
src/mame/drivers/igspoker.c
View File

@ -204,9 +204,9 @@ UINT32 igspoker_state::screen_update_igs_video(screen_device &screen, bitmap_ind
bitmap.fill(get_black_pen(machine()), cliprect);
// FIX: CSK227IT must have some way to disable background, or wrong gfx?
if (m_bg_enable) m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
if (m_bg_enable) m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}
@ -218,7 +218,7 @@ VIDEO_START_MEMBER(igspoker_state,cpokerpk)
UINT32 igspoker_state::screen_update_cpokerpk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

8
src/mame/drivers/jackie.c
View File

@ -224,15 +224,15 @@ UINT32 jackie_state::screen_update_jackie(screen_device &screen, bitmap_ind16 &b
if (rowenable==0)
{
m_reel1_tilemap->draw(bitmap, clip, 0,0);
m_reel1_tilemap->draw(screen, bitmap, clip, 0,0);
}
else if (rowenable==1)
{
m_reel2_tilemap->draw(bitmap, clip, 0,0);
m_reel2_tilemap->draw(screen, bitmap, clip, 0,0);
}
else if (rowenable==2)
{
m_reel3_tilemap->draw(bitmap, clip, 0,0);
m_reel3_tilemap->draw(screen, bitmap, clip, 0,0);
}
else if (rowenable==3)
{
@ -241,7 +241,7 @@ UINT32 jackie_state::screen_update_jackie(screen_device &screen, bitmap_ind16 &b
startclipmin+=1;
}
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

58
src/mame/drivers/jalmah.c
View File

@ -209,10 +209,10 @@ public:
UINT32 screen_update_urashima(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(jalmah_mcu_sim);
void jalmah_priority_system();
void draw_sc0_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc1_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc2_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc3_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc0_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc1_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc2_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc3_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void daireika_palette_dma(UINT16 val);
void daireika_mcu_run();
void mjzoomin_mcu_run();
@ -402,47 +402,47 @@ void jalmah_state::jalmah_priority_system()
//popmessage("%02x %02x %02x %02x",m_sc0_prin,m_sc1_prin,m_sc2_prin,m_sc3_prin);
}
void jalmah_state::draw_sc0_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
void jalmah_state::draw_sc0_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
switch(m_jm_vregs[0] & 3)
{
case 0: m_sc0_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: m_sc0_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: m_sc0_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: m_sc0_tilemap_3->draw(bitmap, cliprect, 0,0); break;
case 0: m_sc0_tilemap_0->draw(screen, bitmap, cliprect, 0,0); break;
case 1: m_sc0_tilemap_1->draw(screen, bitmap, cliprect, 0,0); break;
case 2: m_sc0_tilemap_2->draw(screen, bitmap, cliprect, 0,0); break;
case 3: m_sc0_tilemap_3->draw(screen, bitmap, cliprect, 0,0); break;
}
}
void jalmah_state::draw_sc1_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
void jalmah_state::draw_sc1_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
switch(m_jm_vregs[1] & 3)
{
case 0: m_sc1_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: m_sc1_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: m_sc1_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: m_sc1_tilemap_3->draw(bitmap, cliprect, 0,0); break;
case 0: m_sc1_tilemap_0->draw(screen, bitmap, cliprect, 0,0); break;
case 1: m_sc1_tilemap_1->draw(screen, bitmap, cliprect, 0,0); break;
case 2: m_sc1_tilemap_2->draw(screen, bitmap, cliprect, 0,0); break;
case 3: m_sc1_tilemap_3->draw(screen, bitmap, cliprect, 0,0); break;
}
}
void jalmah_state::draw_sc2_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
void jalmah_state::draw_sc2_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
switch(m_jm_vregs[2] & 3)
{
case 0: m_sc2_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: m_sc2_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: m_sc2_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: m_sc2_tilemap_3->draw(bitmap, cliprect, 0,0); break;
case 0: m_sc2_tilemap_0->draw(screen, bitmap, cliprect, 0,0); break;
case 1: m_sc2_tilemap_1->draw(screen, bitmap, cliprect, 0,0); break;
case 2: m_sc2_tilemap_2->draw(screen, bitmap, cliprect, 0,0); break;
case 3: m_sc2_tilemap_3->draw(screen, bitmap, cliprect, 0,0); break;
}
}
void jalmah_state::draw_sc3_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
void jalmah_state::draw_sc3_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
switch(m_jm_vregs[3] & 3)
{
case 0:
case 1: m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 2: m_sc3_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: m_sc3_tilemap_3->draw(bitmap, cliprect, 0,0); break;
case 1: m_sc3_tilemap_0->draw(screen, bitmap, cliprect, 0,0); break;
case 2: m_sc3_tilemap_2->draw(screen, bitmap, cliprect, 0,0); break;
case 3: m_sc3_tilemap_3->draw(screen, bitmap, cliprect, 0,0); break;
}
}
@ -497,10 +497,10 @@ UINT32 jalmah_state::screen_update_jalmah(screen_device &screen, bitmap_ind16 &b
for(cur_prin=1;cur_prin<=0x8;cur_prin<<=1)
{
if(cur_prin==m_sc0_prin) { draw_sc0_layer(bitmap,cliprect); }
if(cur_prin==m_sc1_prin) { draw_sc1_layer(bitmap,cliprect); }
if(cur_prin==m_sc2_prin) { draw_sc2_layer(bitmap,cliprect); }
if(cur_prin==m_sc3_prin) { draw_sc3_layer(bitmap,cliprect); }
if(cur_prin==m_sc0_prin) { draw_sc0_layer(screen,bitmap,cliprect); }
if(cur_prin==m_sc1_prin) { draw_sc1_layer(screen,bitmap,cliprect); }
if(cur_prin==m_sc2_prin) { draw_sc2_layer(screen,bitmap,cliprect); }
if(cur_prin==m_sc3_prin) { draw_sc3_layer(screen,bitmap,cliprect); }
}
return 0;
@ -516,8 +516,8 @@ UINT32 jalmah_state::screen_update_urashima(screen_device &screen, bitmap_ind16
m_sc3_tilemap_0->set_scrolly(0, jm_scrollram[7]);
bitmap.fill(machine().pens[0x1ff], cliprect);//selectable by a ram address?
if(m_jm_vregs[0] & 1) { m_sc0_tilemap_0->draw(bitmap, cliprect, 0,0); }
if(m_jm_vregs[3] & 1) { m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); }
if(m_jm_vregs[0] & 1) { m_sc0_tilemap_0->draw(screen, bitmap, cliprect, 0,0); }
if(m_jm_vregs[3] & 1) { m_sc3_tilemap_0->draw(screen, bitmap, cliprect, 0,0); }
return 0;
}

4
src/mame/drivers/jchan.c
View File

@ -307,13 +307,13 @@ UINT32 jchan_state::screen_update_jchan(screen_device &screen, bitmap_ind16 &bit
bitmap.fill(get_black_pen(machine()), cliprect);
machine().priority_bitmap.fill(0, cliprect);
screen.priority().fill(0, cliprect);
m_view2_0->kaneko16_prepare(bitmap, cliprect);
for ( int i = 0; i < 8; i++ )
{
m_view2_0->render_tilemap_chip(bitmap,cliprect,i);
m_view2_0->render_tilemap_chip(screen,bitmap,cliprect,i);
}
m_sprite_bitmap_1->fill(0x0000, cliprect);

4
src/mame/drivers/jclub2.c
View File

@ -255,11 +255,11 @@ UINT32 darkhors_state::screen_update_darkhors(screen_device &screen, bitmap_ind1
m_tmap->set_scrollx(0, (m_tmapscroll[0] >> 16) - 5);
m_tmap->set_scrolly(0, (m_tmapscroll[0] & 0xffff) - 0xff );
if (layers_ctrl & 1) m_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_tmap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_tmap2->set_scrollx(0, (m_tmapscroll2[0] >> 16) - 5);
m_tmap2->set_scrolly(0, (m_tmapscroll2[0] & 0xffff) - 0xff );
if (layers_ctrl & 2) m_tmap2->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 2) m_tmap2->draw(screen, bitmap, cliprect, 0, 0);
if (layers_ctrl & 4) draw_sprites_darkhors(bitmap,cliprect);

2
src/mame/drivers/jokrwild.c
View File

@ -165,7 +165,7 @@ void jokrwild_state::video_start()
UINT32 jokrwild_state::screen_update_jokrwild(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/jollyjgr.c
View File

@ -507,11 +507,11 @@ UINT32 jollyjgr_state::screen_update_jollyjgr(screen_device &screen, bitmap_ind1
if(!(m_bitmap_disable))
draw_bitmap(bitmap);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
}
else
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
if(!(m_bitmap_disable))
draw_bitmap(bitmap);

2
src/mame/drivers/jubilee.c
View File

@ -140,7 +140,7 @@ void jubilee_state::video_start()
UINT32 jubilee_state::screen_update_jubileep(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/kingdrby.c
View File

@ -244,10 +244,10 @@ UINT32 kingdrby_state::screen_update_kingdrby(screen_device &screen, bitmap_ind1
clip.set(visarea.min_x, 256, 192, visarea.max_y);
/*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/
m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
m_sc0_tilemap->draw(screen, bitmap, cliprect, 0,0);
draw_sprites(bitmap,cliprect);
m_sc1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
m_sc0w_tilemap->draw(bitmap, clip, 0,0);
m_sc1_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
m_sc0w_tilemap->draw(screen, bitmap, clip, 0,0);
return 0;
}

4
src/mame/drivers/koftball.c
View File

@ -100,8 +100,8 @@ void koftball_state::video_start()
UINT32 koftball_state::screen_update_koftball(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tilemap_2->draw(bitmap, cliprect, 0, 0);
m_tilemap_1->draw(bitmap, cliprect, 0, 0);
m_tilemap_2->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap_1->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/koikoi.c
View File

@ -147,7 +147,7 @@ void koikoi_state::video_start()
UINT32 koikoi_state::screen_update_koikoi(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tmap->draw(bitmap, cliprect, 0, 0);
m_tmap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/laserbat.c
View File

@ -495,7 +495,7 @@ UINT32 laserbat_state::screen_update_laserbat(screen_device &screen, bitmap_ind1
{
int y;
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* update the S2636 chips */
bitmap_ind16 &s2636_1_bitmap = s2636_update(m_s2636_1, cliprect);

10
src/mame/drivers/limenko.c
View File

@ -519,7 +519,7 @@ UINT32 limenko_state::screen_update_limenko(screen_device &screen, bitmap_ind16
{
// m_videoreg[4] ???? It always has this value: 0xffeffff8 (2 signed bytes? values: -17 and -8 ?)
machine().priority_bitmap.fill(0, cliprect);
screen.priority().fill(0, cliprect);
m_bg_tilemap->enable(m_videoreg[0] & 4);
m_md_tilemap->enable(m_videoreg[0] & 2);
@ -533,12 +533,12 @@ UINT32 limenko_state::screen_update_limenko(screen_device &screen, bitmap_ind16
m_md_tilemap->set_scrollx(0, (m_videoreg[2] & 0xffff0000) >> 16);
m_fg_tilemap->set_scrollx(0, (m_videoreg[1] & 0xffff0000) >> 16);
m_bg_tilemap->draw(bitmap, cliprect, 0,0);
m_md_tilemap->draw(bitmap, cliprect, 0,0);
m_fg_tilemap->draw(bitmap, cliprect, 0,1);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_md_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0,1);
if(m_videoreg[0] & 8)
copy_sprites(bitmap, m_sprites_bitmap, machine().priority_bitmap, cliprect);
copy_sprites(bitmap, m_sprites_bitmap, screen.priority(), cliprect);
return 0;
}

2
src/mame/drivers/looping.c
View File

@ -312,7 +312,7 @@ void looping_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect
UINT32 looping_state::screen_update_looping(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
return 0;

2
src/mame/drivers/ltcasino.c
View File

@ -640,7 +640,7 @@ GFXDECODE_END
UINT32 ltcasino_state::screen_update_ltcasino(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tilemap->draw(bitmap, cliprect, 0,0);
m_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

16
src/mame/drivers/luckgrln.c
View File

@ -359,10 +359,10 @@ UINT32 luckgrln_state::screen_update_luckgrln(screen_device &screen, bitmap_ind1
#if 0 // treat bit as fg enable
if (tileattr&0x04)
{
if (bgenable==0) m_reel1_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==1) m_reel2_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==2) m_reel3_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==3) m_reel4_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==0) m_reel1_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==1) m_reel2_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==2) m_reel3_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==3) m_reel4_tilemap->draw(screen, bitmap, clip, 0, 0);
}
if (tileattr&0x08) drawgfx_transpen(bitmap,clip,machine().gfx[region],tile,col,0,0,x*8,y*8, 0);
@ -372,10 +372,10 @@ UINT32 luckgrln_state::screen_update_luckgrln(screen_device &screen, bitmap_ind1
if (tileattr&0x04)
{
if (bgenable==0) m_reel1_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==1) m_reel2_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==2) m_reel3_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==3) m_reel4_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==0) m_reel1_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==1) m_reel2_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==2) m_reel3_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==3) m_reel4_tilemap->draw(screen, bitmap, clip, 0, 0);
}
if ((tileattr&0x08)) drawgfx_transpen(bitmap,clip,machine().gfx[region],tile,col,0,0,x*8,y*8, 0);

2
src/mame/drivers/m14.c
View File

@ -136,7 +136,7 @@ void m14_state::video_start()
UINT32 m14_state::screen_update_m14(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_m14_tilemap->draw(bitmap, cliprect, 0, 0);
m_m14_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/m63.c
View File

@ -369,9 +369,9 @@ UINT32 m63_state::screen_update_m63(screen_device &screen, bitmap_ind16 &bitmap,
for (col = 0; col < 32; col++)
m_bg_tilemap->set_scrolly(col, m_scrollram[col * 8]);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/magic10.c
View File

@ -214,9 +214,9 @@ UINT32 magic10_state::screen_update_magic10(screen_device &screen, bitmap_ind16
m_layer1_tilemap->set_scrolly(0, (m_vregs[0/2] - m_vregs[4/2])+0);
m_layer1_tilemap->set_scrollx(0, (m_vregs[2/2] - m_vregs[6/2])+4);
m_layer0_tilemap->draw(bitmap, cliprect, 0, 0);
m_layer1_tilemap->draw(bitmap, cliprect, 0, 0);
m_layer2_tilemap->draw(bitmap, cliprect, 0, 0);
m_layer0_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_layer1_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_layer2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/magicfly.c
View File

@ -554,7 +554,7 @@ VIDEO_START_MEMBER(magicfly_state,7mezzo)
UINT32 magicfly_state::screen_update_magicfly(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/majorpkr.c
View File

@ -548,8 +548,8 @@ UINT32 majorpkr_state::screen_update_majorpkr(screen_device &screen, bitmap_ind1
custom_clip = cliprect;
custom_clip.max_x -= 16;
m_bg_tilemap->draw(bitmap, custom_clip, 0, 0);
m_fg_tilemap->draw(bitmap, custom_clip, 0, 0);
m_bg_tilemap->draw(screen, bitmap, custom_clip, 0, 0);
m_fg_tilemap->draw(screen, bitmap, custom_clip, 0, 0);
if (m_flip_state == 1)
{

2
src/mame/drivers/marinedt.c
View File

@ -524,7 +524,7 @@ UINT32 marinedt_state::screen_update_marinedt(screen_device &screen, bitmap_ind1
int sx, sy;
m_tile->fill(0);
m_tx_tilemap->draw(*m_tile, cliprect, 0, 0);
m_tx_tilemap->draw(screen, *m_tile, cliprect, 0, 0);
m_obj1->fill(0);
drawgfx_transpen(*m_obj1, m_obj1->cliprect(), machine().gfx[1],

2
src/mame/drivers/mayumi.c
View File

@ -78,7 +78,7 @@ WRITE8_MEMBER(mayumi_state::mayumi_videoram_w)
UINT32 mayumi_state::screen_update_mayumi(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_tilemap->draw(bitmap, cliprect, 0, 0);
m_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/mgolf.c
View File

@ -80,7 +80,7 @@ UINT32 mgolf_state::screen_update_mgolf(screen_device &screen, bitmap_ind16 &bit
int i;
/* draw playfield */
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* draw sprites */
for (i = 0; i < 2; i++)

2
src/mame/drivers/midas.c
View File

@ -207,7 +207,7 @@ UINT32 midas_state::screen_update_midas(screen_device &screen, bitmap_ind16 &bit
bitmap.fill(4095, cliprect);
if (layers_ctrl & 2) draw_sprites(bitmap,cliprect);
if (layers_ctrl & 1) m_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 1) m_tmap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

8
src/mame/drivers/mil4000.c
View File

@ -210,10 +210,10 @@ void mil4000_state::video_start()
UINT32 mil4000_state::screen_update_mil4000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
m_sc1_tilemap->draw(bitmap, cliprect, 0,0);
m_sc2_tilemap->draw(bitmap, cliprect, 0,0);
m_sc3_tilemap->draw(bitmap, cliprect, 0,0);
m_sc0_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_sc1_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_sc2_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_sc3_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 0;
}

2
src/mame/drivers/miniboy7.c
View File

@ -216,7 +216,7 @@ void miniboy7_state::video_start()
UINT32 miniboy7_state::screen_update_miniboy7(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

4
src/mame/drivers/mirage.c
View File

@ -100,9 +100,9 @@ UINT32 miragemi_state::screen_update_mirage(screen_device &screen, bitmap_rgb32
bitmap.fill(256, cliprect); /* not verified */
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
m_sprgen->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0800, 0x0800, 0x200, 0x1ff);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 0);
m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 0);
m_sprgen->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0000, 0x0800, 0x200, 0x1ff);
return 0;

4
src/mame/drivers/mogura.c
View File

@ -95,12 +95,12 @@ UINT32 mogura_state::screen_update_mogura(screen_device &screen, bitmap_ind16 &b
rectangle clip = visarea;
clip.max_x = 256 - 1;
m_tilemap->set_scrollx(0, 256);
m_tilemap->draw(bitmap, clip, 0, 0);
m_tilemap->draw(screen, bitmap, clip, 0, 0);
clip.min_x = 256;
clip.max_x = 512 - 1;
m_tilemap->set_scrollx(0, -128);
m_tilemap->draw(bitmap, clip, 0, 0);
m_tilemap->draw(screen, bitmap, clip, 0, 0);
return 0;
}

2
src/mame/drivers/mole.c
View File

@ -127,7 +127,7 @@ WRITE8_MEMBER(mole_state::mole_flipscreen_w)
UINT32 mole_state::screen_update_mole(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

2
src/mame/drivers/mpu12wbk.c
View File

@ -279,7 +279,7 @@ void mpu12wbk_state::video_start()
UINT32 mpu12wbk_state::screen_update_mpu12wbk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 0;
}

6
src/mame/drivers/multfish.c
View File

@ -303,7 +303,7 @@ UINT32 multfish_state::screen_update_multfish(screen_device &screen, bitmap_ind1
if (!m_disp_enable) return 0;
/* Draw lower part of static tilemap (low pri tiles) */
m_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
m_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
/* Setup the column scroll and draw the reels */
for (i=0;i<64;i++)
@ -311,10 +311,10 @@ UINT32 multfish_state::screen_update_multfish(screen_device &screen, bitmap_ind1
int colscroll = (m_vid[i*2] | m_vid[i*2+1] << 8);
m_reel_tilemap->set_scrolly(i, colscroll );
}
m_reel_tilemap->draw(bitmap, cliprect, 0,0);
m_reel_tilemap->draw(screen, bitmap, cliprect, 0,0);
/* Draw upper part of static tilemap (high pri tiles) */
m_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(0),0);
m_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_CATEGORY(0),0);
return 0;
}

Some files were not shown because too many files have changed in this diff Show More