Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-05 08:41:31 +03:00
Code Issues Actions 3 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_icount -= 2; // 2 clocks per cycle
m_pc++; m_pc++;
#if (TMS_3203X_LOG_OPCODE_USAGE) #if (TMS_3203X_LOG_OPCODE_USAGE)
if (machine.primary_screen->frame_number() == 2003) m_hits[op >> 21]++;
m_hits[op >> 21]++;
#endif #endif
(this->*s_tms32031ops[op >> 21])(op); (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)); 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 // flip the visible area within the screen width/height
int width = machine().primary_screen->width(); int width = m_screen->width();
int height = machine().primary_screen->height(); int height = m_screen->height();
rectangle visarea = machine().primary_screen->visible_area(); rectangle visarea = m_screen->visible_area();
if (m_flip_screen_x) if (m_flip_screen_x)
{ {
int temp = width - visarea.min_x - 1; int temp = width - visarea.min_x - 1;
@ -567,8 +567,8 @@ void driver_device::updateflip()
} }
// reconfigure the screen with the new visible area // reconfigure the screen with the new visible area
attoseconds_t period = machine().primary_screen->frame_period().attoseconds; attoseconds_t period = m_screen->frame_period().attoseconds;
machine().primary_screen->configure(width, height, visarea, period); 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 const pen_t * pens; // remapped palette pen numbers
colortable_t * colortable; // global colortable for remapping colortable_t * colortable; // global colortable for remapping
pen_t * shadow_table; // table for looking up a shadowed pen pen_t * shadow_table; // table for looking up a shadowed pen
bitmap_ind8 priority_bitmap; // priority bitmap
// debugger-related information // debugger-related information
UINT32 debug_flags; // the current debug flags 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; int count;
for(count=0;count<0x3e7;count+=8) for(count=0;count<0x3e7;count+=8)
@ -312,7 +312,7 @@ void tc0091lvc_device::draw_sprites( running_machine &machine, bitmap_ind16 &bit
fy = !fy; 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_x = (global_flip) ? 320-x : x;
res_y = (global_flip) ? 256-y : y; 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]]; bitmap.pix16(res_y, res_x) = screen.machine().pens[m_bitmap_ram[count]];
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); tx_tilemap->set_scrollx(0, (global_flip) ? -192 : 0);
machine().priority_bitmap.fill(0, cliprect); screen.priority().fill(0, cliprect);
bg1_tilemap->draw(bitmap, cliprect, 0,0); bg1_tilemap->draw(screen, bitmap, cliprect, 0,0);
bg0_tilemap->draw(bitmap, cliprect, 0,(m_vregs[4] & 0x8) ? 0 : 1); bg0_tilemap->draw(screen, bitmap, cliprect, 0,(m_vregs[4] & 0x8) ? 0 : 1);
draw_sprites(machine(), bitmap, cliprect, global_flip); draw_sprites(screen, bitmap, cliprect, global_flip);
tx_tilemap->draw(bitmap, cliprect, 0,0); tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
} }
return 0; return 0;
} }

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

@ -66,7 +66,7 @@ public:
int m_gfx_index; // for RAM tiles int m_gfx_index; // for RAM tiles
UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); 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); void screen_eof(void);
protected: protected:

1
src/emu/screen.c
View File

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

2
src/emu/screen.h
View File

@ -197,6 +197,7 @@ public:
// information getters // information getters
render_container &container() const { assert(m_container != NULL); return *m_container; } render_container &container() const { assert(m_container != NULL); return *m_container; }
bitmap_ind8 &priority() { return m_priority; }
// dynamic configuration // dynamic configuration
void configure(int width, int height, const rectangle &visarea, attoseconds_t frame_period); void configure(int width, int height, const rectangle &visarea, attoseconds_t frame_period);
@ -286,6 +287,7 @@ private:
texture_format m_texformat; // texture format texture_format m_texformat; // texture format
render_texture * m_texture[2]; // 2x textures for the screen bitmap render_texture * m_texture[2]; // 2x textures for the screen bitmap
screen_bitmap m_bitmap[2]; // 2x bitmaps for rendering screen_bitmap m_bitmap[2]; // 2x bitmaps for rendering
bitmap_ind8 m_priority; // priority bitmap
bitmap_ind64 m_burnin; // burn-in bitmap bitmap_ind64 m_burnin; // burn-in bitmap
UINT8 m_curbitmap; // current bitmap index UINT8 m_curbitmap; // current bitmap index
UINT8 m_curtexture; // current texture 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 // 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 // set the target bitmap
blit.priority = &priority_bitmap;
blit.cliprect = cliprect; blit.cliprect = cliprect;
// set the priority code and alpha // set the priority code and alpha
@ -949,7 +950,7 @@ void tilemap_t::configure_blit_parameters(blit_parameters &blit, const rectangle
//------------------------------------------------- //-------------------------------------------------
template<class _BitmapClass> 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 // skip if disabled
if (!m_enable) if (!m_enable)
@ -958,13 +959,13 @@ void tilemap_t::draw_common(_BitmapClass &dest, const rectangle &cliprect, UINT3
g_profiler.start(PROFILER_TILEMAP_DRAW); g_profiler.start(PROFILER_TILEMAP_DRAW);
// configure the blit parameters based on the input parameters // configure the blit parameters based on the input parameters
blit_parameters blit; 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 // flush the dirty state to all tiles as appropriate
realize_all_dirty_tiles(); realize_all_dirty_tiles();
UINT32 width = machine().primary_screen->width(); UINT32 width = screen.width();
UINT32 height = machine().primary_screen->height(); UINT32 height = screen.height();
// XY scrolling playfield // XY scrolling playfield
if (m_scrollrows == 1 && m_scrollcols == 1) if (m_scrollrows == 1 && m_scrollcols == 1)
@ -1054,11 +1055,11 @@ g_profiler.start(PROFILER_TILEMAP_DRAW);
g_profiler.stop(); g_profiler.stop();
} }
void tilemap_t::draw(bitmap_ind16 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask) void tilemap_t::draw(screen_device &screen, bitmap_ind16 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_common(dest, cliprect, flags, priority, 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) void tilemap_t::draw(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ draw_common(dest, cliprect, flags, priority, 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> 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, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask) 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_scrollx(0, startx >> 16);
set_scrolly(0, starty >> 16); set_scrolly(0, starty >> 16);
draw(dest, cliprect, flags, priority, priority_mask); draw(screen, dest, cliprect, flags, priority, priority_mask);
return; return;
} }
g_profiler.start(PROFILER_TILEMAP_DRAW_ROZ); g_profiler.start(PROFILER_TILEMAP_DRAW_ROZ);
// configure the blit parameters // configure the blit parameters
blit_parameters blit; 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 // get the full pixmap for the tilemap
pixmap(); pixmap();
@ -1103,15 +1104,15 @@ g_profiler.start(PROFILER_TILEMAP_DRAW_ROZ);
g_profiler.stop(); 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, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask) 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, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
bool wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask) 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; return;
// look up priority and destination base addresses for y1 // 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); UINT8 *priority_baseaddr = &priority_bitmap.pix8(y1, xpos);
typename _BitmapClass::pixel_t *dest_baseaddr = NULL; typename _BitmapClass::pixel_t *dest_baseaddr = NULL;
int dest_rowpixels = 0; 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 // 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); 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 xmask = m_pixmap.width() - 1;
const int ymask = m_pixmap.height() - 1; const int ymask = m_pixmap.height() - 1;
const int widthshifted = m_pixmap.width() << 16; 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) // set up for the blit, using hard-coded parameters (no priority, etc)
blit_parameters blit; 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 // compute the effective scroll positions
scrollx = m_width - scrollx % m_width; scrollx = m_width - scrollx % m_width;
@ -1664,9 +1666,6 @@ tilemap_manager::tilemap_manager(running_machine &machine)
: m_machine(machine), : m_machine(machine),
m_instance(0) 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); void set_transmask(int group, UINT32 fgmask, UINT32 bgmask);
// drawing // drawing
void draw(bitmap_ind16 &dest, const rectangle &cliprect, 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(bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, 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(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(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(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_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); void draw_debug(bitmap_rgb32 &dest, UINT32 scrollx, UINT32 scrolly);
// mappers // mappers
@ -665,6 +665,7 @@ private:
// blitting parameters for rendering // blitting parameters for rendering
struct blit_parameters struct blit_parameters
{ {
bitmap_ind8 * priority;
rectangle cliprect; rectangle cliprect;
UINT32 tilemap_priority_code; UINT32 tilemap_priority_code;
UINT8 mask; UINT8 mask;
@ -698,9 +699,9 @@ private:
void tile_update(logical_index logindex, UINT32 col, UINT32 row); 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_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); 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); 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(_BitmapClass &dest, 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(_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_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_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); 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 #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; UINT8 *pix_ptr;
const pen_t *pal_base, *pal_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 priority : value to be written to the priority bitmap, no effect when equals 0
*/ */
pdraw_scanline32(bitmap, pal_ptr, pix_ptr, cliprect, 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 // shift scanline position one virtual screen upward to render the wrapped end if necessary
scroll -= dst_height; scroll -= dst_height;

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

@ -26,7 +26,7 @@ public:
DECLARE_WRITE16_MEMBER(ram_w); DECLARE_WRITE16_MEMBER(ram_w);
DECLARE_READ16_MEMBER(rom_r); 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: protected:
virtual void device_start(); 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) 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); draw_sprites(bitmap, cliprect);
return 0; 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 ) UINT32 _3x3puzzle_state::screen_update( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
{ {
m_tilemap1->draw(bitmap, cliprect, 0, 1); m_tilemap1->draw(screen, bitmap, cliprect, 0, 1);
m_tilemap2->draw(bitmap, cliprect, 0, 2); m_tilemap2->draw(screen, bitmap, cliprect, 0, 2);
m_tilemap3->draw(bitmap, cliprect, 0, 3); m_tilemap3->draw(screen, bitmap, cliprect, 0, 3);
return 0; 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) 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; 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) 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); 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*/ /*Order might be wrong,but these for sure are the led numbers tested*/
draw_led(bitmap, 0, 20, (m_led0 & 0x0f00) >> 8); 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) 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; 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++; count++;
} }
} }
//m_bg_tilemap->draw(bitmap, cliprect, 0, 0); //m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen2->pf_update(m_pf3_rowscroll, m_pf4_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); bitmap.fill(0x100, cliprect);
if (m_left_priority[0] == 0) if (m_left_priority[0] == 0)
{ {
m_deco_tilegen2->tilemap_1_draw(bitmap, cliprect, 0, 1); m_deco_tilegen2->tilemap_1_draw(screen, bitmap, cliprect, 0, 1);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 2); m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 2);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram_1, 0x800); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram_1, 0x800);
} }
else if (m_left_priority[0] == 2) else if (m_left_priority[0] == 2)
{ {
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 2); m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_1_draw(bitmap, cliprect, 0, 4); m_deco_tilegen2->tilemap_1_draw(screen, bitmap, cliprect, 0, 4);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram_1, 0x800); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram_1, 0x800);
} }
else 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_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
m_deco_tilegen2->pf_update(m_pf3_rowscroll, m_pf4_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); bitmap.fill(0x500, cliprect);
if (m_right_priority[0] == 0) if (m_right_priority[0] == 0)
{ {
m_deco_tilegen2->tilemap_2_draw(bitmap, cliprect, 0, 1); m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, 0, 1);
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, 0, 2); m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 2);
m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram_2, 0x800); m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram_2, 0x800);
} }
else if (m_right_priority[0] == 2) else if (m_right_priority[0] == 2)
{ {
m_deco_tilegen1->tilemap_2_draw(bitmap, cliprect, 0, 2); m_deco_tilegen1->tilemap_2_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen2->tilemap_2_draw(bitmap, cliprect, 0, 4); m_deco_tilegen2->tilemap_2_draw(screen, bitmap, cliprect, 0, 4);
m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram_2, 0x800); m_sprgen2->draw_sprites(bitmap, cliprect, m_spriteram_2, 0x800);
} }
else else
@ -528,10 +528,12 @@ static MACHINE_CONFIG_START( backfire, backfire_state )
MCFG_DECO16IC_SET_SCREEN("lscreen") MCFG_DECO16IC_SET_SCREEN("lscreen")
MCFG_DEVICE_ADD("spritegen", DECO_SPRITE, 0) MCFG_DEVICE_ADD("spritegen", DECO_SPRITE, 0)
MCFG_VIDEO_SET_SCREEN("lscreen")
decospr_device::set_gfx_region(*device, 4); decospr_device::set_gfx_region(*device, 4);
decospr_device::set_pri_callback(*device, backfire_pri_callback); decospr_device::set_pri_callback(*device, backfire_pri_callback);
MCFG_DEVICE_ADD("spritegen2", DECO_SPRITE, 0) MCFG_DEVICE_ADD("spritegen2", DECO_SPRITE, 0)
MCFG_VIDEO_SET_SCREEN("rscreen")
decospr_device::set_gfx_region(*device, 5); decospr_device::set_gfx_region(*device, 5);
decospr_device::set_pri_callback(*device, backfire_pri_callback); 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_scrollx(0,m_vregs[0x08/2] & 0xfff8);
m_fg_tilemap->set_scrolly(0,m_vregs[0x0a/2]); m_fg_tilemap->set_scrolly(0,m_vregs[0x0a/2]);
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);
draw_sprites(bitmap,cliprect); draw_sprites(bitmap,cliprect);
m_tx_tilemap->draw(bitmap, cliprect, 0,0); m_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 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_scrollx(0,m_vregs[0x04/2]);
m_fg_tilemap->set_scrolly(0,m_vregs[0x06/2]); m_fg_tilemap->set_scrolly(0,m_vregs[0x06/2]);
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);
draw_sprites(bitmap,cliprect); draw_sprites(bitmap,cliprect);
m_tx_tilemap->draw(bitmap, cliprect, 0,0); m_tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 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) 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; 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_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
UINT32 screen_update_bnstars_right(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); 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 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_init();
void irq_raise(int level); void irq_raise(int level);
IRQ_CALLBACK_MEMBER(irq_callback); IRQ_CALLBACK_MEMBER(irq_callback);
@ -238,7 +238,7 @@ WRITE32_MEMBER(bnstars_state::ms32_bg1_ram_w)
/* ROZ Layers */ /* 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 */ /* 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 (incxx & 0x10000) incxx |= ~0x1ffff;
if (incxy & 0x10000) incxy |= ~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, (start2x+startx+offsx)<<16, (start2y+starty+offsy)<<16,
incxx<<8, incxy<<8, 0, 0, incxx<<8, incxy<<8, 0, 0,
1, // Wrap 1, // Wrap
@ -314,7 +314,7 @@ void bnstars_state::draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect, in
if (incyy & 0x10000) incyy |= ~0x1ffff; if (incyy & 0x10000) incyy |= ~0x1ffff;
if (incyx & 0x10000) incyx |= ~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, (startx+offsx)<<16, (starty+offsy)<<16,
incxx<<8, incxy<<8, incyx<<8, incyy<<8, incxx<<8, incxy<<8, incyx<<8, incyy<<8,
1, // Wrap 1, // Wrap
@ -381,7 +381,7 @@ WRITE32_MEMBER(bnstars_state::ms32_pal1_ram_w)
/* SPRITES based on tetrisp2 for now, readd priority bits later */ /* 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, color,
flipx, flipy, flipx, flipy,
sx,sy, sx,sy,
xzoom, yzoom, machine().priority_bitmap,pri_mask, 0); xzoom, yzoom, screen.priority(),pri_mask, 0);
} /* end sprite loop */ } /* 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) 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 */ 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_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]->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_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]->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; return 0;
} }
UINT32 bnstars_state::screen_update_bnstars_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) 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 */ 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_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]->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_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]->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; 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); 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; 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) if (m_bg_bank & 0x10)
{ {
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);
} }
else 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) 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; 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 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); const rectangle visible3(0*8, (14+48)*8-1, 17*8, (17+7)*8-1);
m_reel1_tilemap->draw(bitmap, visible1, 0, 0); m_reel1_tilemap->draw(screen, bitmap, visible1, 0, 0);
m_reel2_tilemap->draw(bitmap, visible2, 0, 0); m_reel2_tilemap->draw(screen, bitmap, visible2, 0, 0);
m_reel3_tilemap->draw(bitmap, visible3, 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) UINT32 cball_state::screen_update_cball(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
/* draw playfield */ /* draw playfield */
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* draw sprite */ /* draw sprite */
drawgfx_transpen(bitmap, cliprect, machine().gfx[1], 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) 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->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); draw_sprites(bitmap, cliprect);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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_scrollx(0, 352);
m_fg_tilemap->set_scrolly(0, 160); m_fg_tilemap->set_scrolly(0, 160);
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; 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); x = -256 - (m_scrollx | m_scrollx_hi);
y = 256 + (m_scrolly | m_scrolly_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), (x << 16), (y << 16),
p1, p2, p1, p2,
p3, p4, p3, p4,
@ -329,7 +329,7 @@ UINT32 cntsteer_state::screen_update_zerotrgt(screen_device &screen, bitmap_ind1
} }
zerotrgt_draw_sprites(bitmap, cliprect); zerotrgt_draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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); x = 256 + (m_scrollx | m_scrollx_hi);
y = 256 - (m_scrolly | m_scrolly_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), (x << 16), (y << 16),
p1, p2, p1, p2,
p3, p4, p3, p4,
@ -376,7 +376,7 @@ UINT32 cntsteer_state::screen_update_cntsteer(screen_device &screen, bitmap_ind1
} }
cntsteer_draw_sprites(bitmap, cliprect); cntsteer_draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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) if (m_has_psac)
{ {
m_k001604->draw_back_layer(bitmap, cliprect); 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); 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) 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; 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); //draw_sprites(bitmap, cliprect);
m_txtilemap->draw(bitmap, cliprect, 0,0); m_txtilemap->draw(screen, bitmap, cliprect, 0,0);
return 0; return 0;
} }
@ -226,7 +226,7 @@ UINT32 cshooter_state::screen_update_airraid(screen_device &screen, bitmap_ind16
draw_sprites(bitmap, cliprect); draw_sprites(bitmap, cliprect);
m_txtilemap->draw(bitmap, cliprect, 0,0); m_txtilemap->draw(screen, bitmap, cliprect, 0,0);
return 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_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->set_scrolly(0, (m_bg2_regs_y[2] << 8) + m_bg2_regs_y[0]);
m_bg2_tilemap->draw(bitmap, cliprect, 0, 0); m_bg2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_bg0_tilemap->draw(bitmap, cliprect, 0, 0); m_bg0_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_bg1_tilemap->draw(bitmap, cliprect, 0, 0); m_bg1_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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); draw_road(screen,bitmap,cliprect,screen_shift, 0x00);
state->m_tilemap2_tilemap->draw(bitmap, cliprect, 0,0); state->m_tilemap2_tilemap->draw(screen, bitmap, cliprect, 0,0);
state->m_tilemap1_tilemap->draw(bitmap, cliprect, 0,0); state->m_tilemap1_tilemap->draw(screen, bitmap, cliprect, 0,0);
draw_road(screen,bitmap,cliprect,screen_shift, 0x80); draw_road(screen,bitmap,cliprect,screen_shift, 0x80);
draw_sprites(screen,bitmap,cliprect,screen_shift); 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; 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) 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; 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->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); draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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); m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll);
bitmap.fill(0, cliprect); /* not Confirmed */ 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_2_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 4); m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 4);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
return 0; 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 ddayjlc_state::screen_update_ddayjlc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
UINT32 i; 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) 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_scrollx(0, m_flipscreen ? -192 : -64);
m_back_tilemap->set_flip(m_flipscreen ? TILEMAP_FLIPY | TILEMAP_FLIPX : 0); 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, /* the fg tilemap handling is a little hacky right now,
i'm not sure if it should be a single tilemap with 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! //FIXME: flip_screen_x should not be written!
flip_screen_set_no_update(1); flip_screen_set_no_update(1);
machine().priority_bitmap.fill(0); screen.priority().fill(0);
bitmap.fill(0); bitmap.fill(0);
m_deco_tilegen1->pf_update(m_pf1_rowscroll, m_pf2_rowscroll); 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_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; 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); m_deco_tilegen1->pf_update(NULL, NULL);
bitmap.fill(0, cliprect); /* not Confirmed */ 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_2_draw(screen, bitmap, cliprect, 0, 2);
m_deco_tilegen1->tilemap_1_draw(bitmap, cliprect, 0, 4); m_deco_tilegen1->tilemap_1_draw(screen, bitmap, cliprect, 0, 4);
return 0; 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(); m_bg2_tilemap->mark_all_dirty();
} }
tmptilemap0->draw(bitmap, cliprect, 0, 0); tmptilemap0->draw(screen, bitmap, cliprect, 0, 0);
tmptilemap1->draw(bitmap, cliprect, 0, 0); tmptilemap1->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect); 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) 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_bg->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap_fg->draw(bitmap, cliprect, 0, 0); m_tilemap_fg->draw(screen, bitmap, cliprect, 0, 0);
draw_sprites(bitmap, cliprect); draw_sprites(bitmap, cliprect);
return 0; 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) 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; return 0;
} }

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

@ -180,16 +180,16 @@ if (machine().input().code_pressed(KEYCODE_Z))
switch (m_layers) switch (m_layers)
{ {
case 0x04: // girl select: bg over fg case 0x04: // girl select: bg over fg
if (layers_ctrl & 2) m_tmap2->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0); if (layers_ctrl & 2) m_tmap2->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) m_tmap->draw(bitmap, cliprect, 0, 0); if (layers_ctrl & 1) m_tmap->draw(screen, bitmap, cliprect, 0, 0);
break; break;
case 0x05: // dips: must hide fg 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; break;
case 0x07: // game,demo: fg over bg case 0x07: // game,demo: fg over bg
default: default:
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);
if (layers_ctrl & 2) m_tmap2->draw(bitmap, cliprect, 0, 0); if (layers_ctrl & 2) m_tmap2->draw(screen, bitmap, cliprect, 0, 0);
break; 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; rectangle myclip = cliprect;
myclip.max_x = 15; myclip.max_x = 15;
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_top_tilemap->draw(bitmap, myclip, 0, 0); m_top_tilemap->draw(screen, bitmap, myclip, 0, 0);
return 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) 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); draw_sprites(bitmap, cliprect);
return 0; 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) UINT32 ettrivia_state::screen_update_ettrivia(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);
m_fg_tilemap->draw(bitmap, cliprect, 0,0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 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; int i;
machine().priority_bitmap.fill(0, cliprect); screen.priority().fill(0, cliprect);
m_view2_0->kaneko16_prepare(bitmap, cliprect); m_view2_0->kaneko16_prepare(bitmap, cliprect);
for ( i = 0; i < 8; i++ ) 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; 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 pos;
int base = m_sprite_base / 2; 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; ypos = 256 - ypos - 16;
xpos = xpos + m_sprite_x_offset + 49; 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) switch (layer)
{ {
case 0: case 0:
fcrash_render_sprites(bitmap, cliprect); fcrash_render_sprites(screen, bitmap, cliprect);
break; break;
case 1: case 1:
case 2: case 2:
case 3: 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; 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; bitmap_ind16 dummy_bitmap;
@ -555,7 +555,7 @@ void cps_state::fcrash_render_high_layer( bitmap_ind16 &bitmap, const rectangle
case 1: case 1:
case 2: case 2:
case 3: 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; break;
} }
} }
@ -637,28 +637,28 @@ UINT32 cps_state::screen_update_fcrash(screen_device &screen, bitmap_ind16 &bitm
/* Blank screen */ /* Blank screen */
bitmap.fill(0xbff, cliprect); bitmap.fill(0xbff, cliprect);
machine().priority_bitmap.fill(0, cliprect); screen.priority().fill(0, cliprect);
l0 = (layercontrol >> 0x06) & 03; l0 = (layercontrol >> 0x06) & 03;
l1 = (layercontrol >> 0x08) & 03; l1 = (layercontrol >> 0x08) & 03;
l2 = (layercontrol >> 0x0a) & 03; l2 = (layercontrol >> 0x0a) & 03;
l3 = (layercontrol >> 0x0c) & 03; l3 = (layercontrol >> 0x0c) & 03;
fcrash_render_layer(bitmap, cliprect, l0, 0); fcrash_render_layer(screen, bitmap, cliprect, l0, 0);
if (l1 == 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) 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) 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; 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; 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(); m_tmap->mark_all_dirty();
/* draw playfield */ /* draw playfield */
m_tmap->draw(bitmap, cliprect, 0, 0); m_tmap->draw(screen, bitmap, cliprect, 0, 0);
/* draw pitcher */ /* draw pitcher */
drawgfx_transpen(bitmap, cliprect, machine().gfx[1], m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1); 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) 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_2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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++ ) for( pri=0; pri<pivot; pri++ )
{ {
c355_obj_draw(bitmap, cliprect, pri); c355_obj_draw(screen, bitmap, cliprect, pri);
} }
/* CopyVisiblePolyFrameBuffer( bitmap, cliprect,0,0x7fbf ); /* CopyVisiblePolyFrameBuffer( bitmap, cliprect,0,0x7fbf );
for( pri=pivot; pri<15; pri++ ) for( pri=pivot; pri<15; pri++ )
{ {
c355_obj_draw(bitmap, cliprect, pri); c355_obj_draw(screen, bitmap, cliprect, pri);
}*/ }*/
// CPU Diag LEDs // 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 #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); else bitmap.fill(get_black_pen(machine()), cliprect);
if (layers_ctrl & 2) m_bg2_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(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(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; 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) 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; 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) 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; 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) UINT32 good_state::screen_update_good(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);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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_scrollx(0, (0) & 0x1ff );
m_sc3_tilemap->set_scrolly(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_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_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_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); } if(SEIBU_CRTC_ENABLE_SPR) { draw_sprites(screen.machine(), bitmap,cliprect, 3); }
return 0; 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_scrollx(0, m_tmap2_scrollx >> 16);
m_tilemap2->set_scrolly(0, m_tmap2_scrolly >> 16); m_tilemap2->set_scrolly(0, m_tmap2_scrolly >> 16);
m_tilemap3->draw(bitmap, cliprect, 0, 0); m_tilemap3->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap2->draw(bitmap, cliprect, 0, 0); m_tilemap2->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap1->draw(bitmap, cliprect, 0, 0); m_tilemap1->draw(screen, bitmap, cliprect, 0, 0);
for (i = 0x0000 / 4; i < 0x4000 / 4; i += 4) 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); K001005_draw(bitmap, cliprect);
k001604->draw_front_layer(bitmap, cliprect); k001604->draw_front_layer(screen, bitmap, cliprect);
#if 0 #if 0
tick++; tick++;
@ -943,7 +943,7 @@ UINT32 gticlub_state::screen_update_hangplt(screen_device &screen, bitmap_rgb32
voodoo_update(voodoo, bitmap, cliprect); 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) 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); 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]); 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) 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; 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; offs_t offs = 0;
/* start by drawing the tilemap */ /* 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 */ /* now loop over and invert anything */
for (y = 0; y < 19; y++) 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) 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; 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); 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, 3, 3, m_led_reg0);
draw_7segment_led(bitmap, 9, 3, m_led_reg1); 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); voodoo_update(voodoo, bitmap, cliprect);
/* TODO: tilemaps per screen */ /* 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) 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); voodoo_update(voodoo, bitmap, cliprect);
/* TODO: tilemaps per screen */ /* 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); 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_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 m_bg_tilemap->set_scrolly(0, ((m_port0_data & 0x80) << 1) + m_scrolly + SY_POS); // TODO
bitmap.fill(get_black_pen(machine()), cliprect); 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); m_pandora->update(bitmap, cliprect);
return 0; 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) if (rowenable==0)
{ // 0 and 1 are the same? or is there a global switchoff? { // 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) 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) 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) 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); 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; 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) if (m_video_disable)
return 0; 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 & 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; 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); 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?????? //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"); //fprintf(stdout,"Video UPDATE OK!\n");
return 0; 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); bitmap.fill(get_black_pen(machine()), cliprect);
// FIX: CSK227IT must have some way to disable background, or wrong gfx? // 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; 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) 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; 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) if (rowenable==0)
{ {
m_reel1_tilemap->draw(bitmap, clip, 0,0); m_reel1_tilemap->draw(screen, bitmap, clip, 0,0);
} }
else if (rowenable==1) 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) 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) else if (rowenable==3)
{ {
@ -241,7 +241,7 @@ UINT32 jackie_state::screen_update_jackie(screen_device &screen, bitmap_ind16 &b
startclipmin+=1; startclipmin+=1;
} }
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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); UINT32 screen_update_urashima(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(jalmah_mcu_sim); TIMER_DEVICE_CALLBACK_MEMBER(jalmah_mcu_sim);
void jalmah_priority_system(); void jalmah_priority_system();
void draw_sc0_layer(bitmap_ind16 &bitmap, const rectangle &cliprect); void draw_sc0_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc1_layer(bitmap_ind16 &bitmap, const rectangle &cliprect); void draw_sc1_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc2_layer(bitmap_ind16 &bitmap, const rectangle &cliprect); void draw_sc2_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc3_layer(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_palette_dma(UINT16 val);
void daireika_mcu_run(); void daireika_mcu_run();
void mjzoomin_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); //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) switch(m_jm_vregs[0] & 3)
{ {
case 0: m_sc0_tilemap_0->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(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(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(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) switch(m_jm_vregs[1] & 3)
{ {
case 0: m_sc1_tilemap_0->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(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(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(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) switch(m_jm_vregs[2] & 3)
{ {
case 0: m_sc2_tilemap_0->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(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(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(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) switch(m_jm_vregs[3] & 3)
{ {
case 0: case 0:
case 1: m_sc3_tilemap_0->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(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(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) 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_sc0_prin) { draw_sc0_layer(screen,bitmap,cliprect); }
if(cur_prin==m_sc1_prin) { draw_sc1_layer(bitmap,cliprect); } if(cur_prin==m_sc1_prin) { draw_sc1_layer(screen,bitmap,cliprect); }
if(cur_prin==m_sc2_prin) { draw_sc2_layer(bitmap,cliprect); } if(cur_prin==m_sc2_prin) { draw_sc2_layer(screen,bitmap,cliprect); }
if(cur_prin==m_sc3_prin) { draw_sc3_layer(bitmap,cliprect); } if(cur_prin==m_sc3_prin) { draw_sc3_layer(screen,bitmap,cliprect); }
} }
return 0; 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]); m_sc3_tilemap_0->set_scrolly(0, jm_scrollram[7]);
bitmap.fill(machine().pens[0x1ff], cliprect);//selectable by a ram address? 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[0] & 1) { m_sc0_tilemap_0->draw(screen, bitmap, cliprect, 0,0); }
if(m_jm_vregs[3] & 1) { m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); } if(m_jm_vregs[3] & 1) { m_sc3_tilemap_0->draw(screen, bitmap, cliprect, 0,0); }
return 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); 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); m_view2_0->kaneko16_prepare(bitmap, cliprect);
for ( int i = 0; i < 8; i++ ) 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); 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_scrollx(0, (m_tmapscroll[0] >> 16) - 5);
m_tmap->set_scrolly(0, (m_tmapscroll[0] & 0xffff) - 0xff ); 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_scrollx(0, (m_tmapscroll2[0] >> 16) - 5);
m_tmap2->set_scrolly(0, (m_tmapscroll2[0] & 0xffff) - 0xff ); 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); 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) 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; 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)) if(!(m_bitmap_disable))
draw_bitmap(bitmap); draw_bitmap(bitmap);
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
} }
else else
{ {
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
if(!(m_bitmap_disable)) if(!(m_bitmap_disable))
draw_bitmap(bitmap); 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) 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; 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); clip.set(visarea.min_x, 256, 192, visarea.max_y);
/*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/ /*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); draw_sprites(bitmap,cliprect);
m_sc1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0); m_sc1_tilemap->draw(screen, bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
m_sc0w_tilemap->draw(bitmap, clip, 0,0); m_sc0w_tilemap->draw(screen, bitmap, clip, 0,0);
return 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) 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_2->draw(screen, bitmap, cliprect, 0, 0);
m_tilemap_1->draw(bitmap, cliprect, 0, 0); m_tilemap_1->draw(screen, bitmap, cliprect, 0, 0);
return 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) 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; 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; int y;
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* update the S2636 chips */ /* update the S2636 chips */
bitmap_ind16 &s2636_1_bitmap = s2636_update(m_s2636_1, cliprect); 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 ?) // 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_bg_tilemap->enable(m_videoreg[0] & 4);
m_md_tilemap->enable(m_videoreg[0] & 2); 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_md_tilemap->set_scrollx(0, (m_videoreg[2] & 0xffff0000) >> 16);
m_fg_tilemap->set_scrollx(0, (m_videoreg[1] & 0xffff0000) >> 16); m_fg_tilemap->set_scrollx(0, (m_videoreg[1] & 0xffff0000) >> 16);
m_bg_tilemap->draw(bitmap, cliprect, 0,0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_md_tilemap->draw(bitmap, cliprect, 0,0); m_md_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_fg_tilemap->draw(bitmap, cliprect, 0,1); m_fg_tilemap->draw(screen, bitmap, cliprect, 0,1);
if(m_videoreg[0] & 8) 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; 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) 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); draw_sprites(bitmap, cliprect);
return 0; 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) 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; 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 0 // treat bit as fg enable
if (tileattr&0x04) if (tileattr&0x04)
{ {
if (bgenable==0) m_reel1_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(bitmap, clip, 0, 0); if (bgenable==1) m_reel2_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==2) m_reel3_tilemap->draw(bitmap, clip, 0, 0); if (bgenable==2) m_reel3_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==3) m_reel4_tilemap->draw(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); 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 (tileattr&0x04)
{ {
if (bgenable==0) m_reel1_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(bitmap, clip, 0, 0); if (bgenable==1) m_reel2_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==2) m_reel3_tilemap->draw(bitmap, clip, 0, 0); if (bgenable==2) m_reel3_tilemap->draw(screen, bitmap, clip, 0, 0);
if (bgenable==3) m_reel4_tilemap->draw(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); 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) 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; 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++) for (col = 0; col < 32; col++)
m_bg_tilemap->set_scrolly(col, m_scrollram[col * 8]); 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); draw_sprites(bitmap, cliprect);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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_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_layer1_tilemap->set_scrollx(0, (m_vregs[2/2] - m_vregs[6/2])+4);
m_layer0_tilemap->draw(bitmap, cliprect, 0, 0); m_layer0_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_layer1_tilemap->draw(bitmap, cliprect, 0, 0); m_layer1_tilemap->draw(screen, bitmap, cliprect, 0, 0);
m_layer2_tilemap->draw(bitmap, cliprect, 0, 0); m_layer2_tilemap->draw(screen, bitmap, cliprect, 0, 0);
return 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) 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; 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 = cliprect;
custom_clip.max_x -= 16; custom_clip.max_x -= 16;
m_bg_tilemap->draw(bitmap, custom_clip, 0, 0); m_bg_tilemap->draw(screen, bitmap, custom_clip, 0, 0);
m_fg_tilemap->draw(bitmap, custom_clip, 0, 0); m_fg_tilemap->draw(screen, bitmap, custom_clip, 0, 0);
if (m_flip_state == 1) 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; int sx, sy;
m_tile->fill(0); 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); m_obj1->fill(0);
drawgfx_transpen(*m_obj1, m_obj1->cliprect(), machine().gfx[1], 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) 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; 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; int i;
/* draw playfield */ /* draw playfield */
m_bg_tilemap->draw(bitmap, cliprect, 0, 0); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* draw sprites */ /* draw sprites */
for (i = 0; i < 2; i++) 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); bitmap.fill(4095, cliprect);
if (layers_ctrl & 2) draw_sprites(bitmap,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; 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) UINT32 mil4000_state::screen_update_mil4000(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);
m_sc1_tilemap->draw(bitmap, cliprect, 0,0); m_sc1_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_sc2_tilemap->draw(bitmap, cliprect, 0,0); m_sc2_tilemap->draw(screen, bitmap, cliprect, 0,0);
m_sc3_tilemap->draw(bitmap, cliprect, 0,0); m_sc3_tilemap->draw(screen, bitmap, cliprect, 0,0);
return 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) 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; 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 */ 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_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); m_sprgen->inefficient_copy_sprite_bitmap(bitmap, cliprect, 0x0000, 0x0800, 0x200, 0x1ff);
return 0; 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; rectangle clip = visarea;
clip.max_x = 256 - 1; clip.max_x = 256 - 1;
m_tilemap->set_scrollx(0, 256); 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.min_x = 256;
clip.max_x = 512 - 1; clip.max_x = 512 - 1;
m_tilemap->set_scrollx(0, -128); m_tilemap->set_scrollx(0, -128);
m_tilemap->draw(bitmap, clip, 0, 0); m_tilemap->draw(screen, bitmap, clip, 0, 0);
return 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) 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; 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) 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; 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; if (!m_disp_enable) return 0;
/* Draw lower part of static tilemap (low pri tiles) */ /* 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 */ /* Setup the column scroll and draw the reels */
for (i=0;i<64;i++) 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); int colscroll = (m_vid[i*2] | m_vid[i*2+1] << 8);
m_reel_tilemap->set_scrolly(i, colscroll ); 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) */ /* 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; return 0;
} }

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