Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-07 23:02:33 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Bulk converted most of the tilemap_* calls into method calls.

Browse Source 
Only thing left is tilemap_create.
This commit is contained in:
Aaron Giles 2012-01-17 00:25:05 +00:00
parent 3fed1d7c44
commit 29ada3c938
587 changed files with 7986 additions and 8160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/emupal.c
View File

@ -476,7 +476,7 @@ void colortable_configure_tilemap_groups(colortable_t *ctable, tilemap_t *tmap,
/* iterate over all colors in the tilemap */
for (color = 0; color < gfx->total_colors; color++)
tilemap_set_transmask(tmap, color, colortable_get_transpen_mask(ctable, gfx, color, transcolor), 0);
tmap->set_transmask(color, colortable_get_transpen_mask(ctable, gfx, color, transcolor), 0);
}

2
src/emu/tilemap.c
View File

@ -739,7 +739,7 @@ g_profiler.start(PROFILER_TILEMAP_UPDATE);
// call the get info callback for the associated memory index
tilemap_memory_index memindex = m_logical_to_memory[logindex];
m_tile_get_info(&m_tileinfo, memindex, m_user_data);
m_tile_get_info(m_tileinfo, memindex, m_user_data);
// apply the global tilemap flip to the returned flip flags
UINT32 flags = m_tileinfo.flags ^ (m_attributes & 0x03);

186
src/emu/tilemap.h
View File

@ -210,7 +210,7 @@
// set the category of each tile based on the high bit; this
// allows us to draw each category independently
tileinfo->category = category;
tileinfo.category = category;
}
VIDEO_START( mydriver )
@ -411,13 +411,13 @@ struct tile_data
// modern delegates
typedef delegate<void (tile_data *, tilemap_memory_index, void *)> tilemap_get_info_delegate;
typedef delegate<void (tile_data &, tilemap_memory_index, void *)> tilemap_get_info_delegate;
typedef delegate<tilemap_memory_index (UINT32, UINT32, UINT32, UINT32)> tilemap_mapper_delegate;
// legacy callbacks
typedef void (*tile_get_info_func)(running_machine &machine, tile_data *tileinfo, tilemap_memory_index tile_index, void *param);
typedef void (*tile_get_info_device_func)(device_t *device, tile_data *tileinfo, tilemap_memory_index tile_index, void *param);
typedef void (*tile_get_info_func)(running_machine &machine, tile_data &tileinfo, tilemap_memory_index tile_index, void *param);
typedef void (*tile_get_info_device_func)(device_t *device, tile_data &tileinfo, tilemap_memory_index tile_index, void *param);
typedef tilemap_memory_index (*tilemap_mapper_func)(running_machine &machine, UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows);
@ -463,9 +463,9 @@ public:
tilemap_memory_index memory_index(UINT32 col, UINT32 row) { return m_mapper(col, row, m_cols, m_rows); }
// setters
void enable(bool enable = true) { m_enable = enable; }
void set_user_data(void *user_data) { m_user_data = user_data; }
void set_palette_offset(UINT32 offset) { m_palette_offset = offset; }
void set_enable(bool enable) { m_enable = enable; }
void set_scrolldx(int dx, int dx_flipped) { m_dx = dx; m_dx_flipped = dx_flipped; }
void set_scrolldy(int dy, int dy_flipped) { m_dy = dy; m_dy_flipped = dy_flipped; }
void set_scrollx(int which, int value) { if (which < m_scrollrows) m_rowscroll[which] = value; }
@ -643,15 +643,15 @@ private:
#define TILEMAP_DRAW_ALPHA(x) (TILEMAP_DRAW_ALPHA_FLAG | (rgb_clamp(x) << 24))
// function definition for a get info callback
#define TILE_GET_INFO(_name) void _name(running_machine &machine, tile_data *tileinfo, tilemap_memory_index tile_index, void *param)
#define TILE_GET_INFO_DEVICE(_name) void _name(device_t *device, tile_data *tileinfo, tilemap_memory_index tile_index, void *param)
#define TILE_GET_INFO(_name) void _name(running_machine &machine, tile_data &tileinfo, tilemap_memory_index tile_index, void *param)
#define TILE_GET_INFO_DEVICE(_name) void _name(device_t *device, tile_data &tileinfo, tilemap_memory_index tile_index, void *param)
// function definition for a logical-to-memory mapper
#define TILEMAP_MAPPER(_name) tilemap_memory_index _name(running_machine &machine, UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows)
// useful macro inside of a TILE_GET_INFO callback to set tile information
#define SET_TILE_INFO(GFX,CODE,COLOR,FLAGS) tileinfo_set(machine, tileinfo, GFX, CODE, COLOR, FLAGS)
#define SET_TILE_INFO_DEVICE(GFX,CODE,COLOR,FLAGS) tileinfo_set(device->machine(), tileinfo, GFX, CODE, COLOR, FLAGS)
#define SET_TILE_INFO(GFX,CODE,COLOR,FLAGS) tileinfo.set(machine, GFX, CODE, COLOR, FLAGS)
#define SET_TILE_INFO_DEVICE(GFX,CODE,COLOR,FLAGS) tileinfo.set(device->machine(), GFX, CODE, COLOR, FLAGS)
// Macros for setting tile attributes in the TILE_GET_INFO callback:
// TILE_FLIP_YX assumes that flipy is in bit 1 and flipx is in bit 0
@ -676,135 +676,6 @@ inline tilemap_t *tilemap_create(running_machine &machine, tile_get_info_func ti
inline tilemap_t *tilemap_create_device(device_t *device, tile_get_info_device_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows)
{ return &device->machine().tilemap().create(tilemap_get_info_delegate(tile_get_info, "", device), tilemap_mapper_delegate(mapper, "", &device->machine()), tilewidth, tileheight, cols, rows); }
// specify a parameter to be passed into the tile_get_info callback
inline void tilemap_set_user_data(tilemap_t *tmap, void *user_data)
{ tmap->set_user_data(user_data); }
// specify an offset to be added to each pixel before looking up the palette.
inline void tilemap_set_palette_offset(tilemap_t *tmap, UINT32 offset)
{ tmap->set_palette_offset(offset); }
// set an enable flag for the tilemap; if 0, requests to draw the tilemap are ignored
inline void tilemap_set_enable(tilemap_t *tmap, int enable)
{ tmap->set_enable(enable); }
// return enable flag for the tilemap
inline int tilemap_get_enable(tilemap_t *tmap)
{ return tmap->enabled(); }
// set a global flip for the tilemap
inline void tilemap_set_flip(tilemap_t *tmap, UINT32 attributes)
{ tmap->set_flip(attributes); }
// set a global flip for all tilemaps
inline void tilemap_set_flip_all(running_machine &machine, UINT32 attributes)
{ machine.tilemap().set_flip_all(attributes); }
// ----- dirty tile marking -----
// mark a single tile dirty based on its memory index
inline void tilemap_mark_tile_dirty(tilemap_t *tmap, tilemap_memory_index memory_index)
{ tmap->mark_tile_dirty(memory_index); }
// mark all the tiles dirty in a tilemap
inline void tilemap_mark_all_tiles_dirty(tilemap_t *tmap)
{ tmap->mark_all_dirty(); }
// mark all the tiles dirty in all tilemaps
inline void tilemap_mark_all_tiles_dirty_all(running_machine &machine)
{ machine.tilemap().mark_all_dirty(); }
// ----- pen-to-layer mapping -----
// specify the mapping of one or more pens (where (<pen> & mask == pen) to a layer
inline void tilemap_map_pens_to_layer(tilemap_t *tmap, int group, pen_t pen, pen_t mask, UINT8 layermask)
{ tmap->map_pens_to_layer(group, pen, mask, layermask); }
// set a single transparent pen into the tilemap, mapping all other pens to layer 0
inline void tilemap_set_transparent_pen(tilemap_t *tmap, pen_t pen)
{ tmap->set_transparent_pen(pen); }
// set up the first 32 pens using a foreground (layer 0) mask and a background (layer 1) mask
inline void tilemap_set_transmask(tilemap_t *tmap, int group, UINT32 fgmask, UINT32 bgmask)
{ tmap->set_transmask(group, fgmask, bgmask); }
// ----- tilemap scrolling -----
// specify the number of independently scrollable row units; each unit covers height/scroll_rows pixels
inline void tilemap_set_scroll_rows(tilemap_t *tmap, UINT32 scroll_rows)
{ tmap->set_scroll_rows(scroll_rows); }
// specify the number of independently scrollable column units; each unit covers width/scroll_cols pixels
inline void tilemap_set_scroll_cols(tilemap_t *tmap, UINT32 scroll_cols)
{ tmap->set_scroll_cols(scroll_cols); }
// specify global horizontal and vertical scroll offsets, for non-flipped and flipped cases
inline void tilemap_set_scrolldx(tilemap_t *tmap, int dx, int dx_if_flipped)
{ tmap->set_scrolldx(dx, dx_if_flipped); }
inline void tilemap_set_scrolldy(tilemap_t *tmap, int dy, int dy_if_flipped)
{ tmap->set_scrolldy(dy, dy_if_flipped); }
// return the global horizontal or vertical scroll offset, based on current flip state
inline int tilemap_get_scrolldx(tilemap_t *tmap)
{ return tmap->scrolldx(); }
inline int tilemap_get_scrolldy(tilemap_t *tmap)
{ return tmap->scrolldy(); }
// specify the scroll value for a row/column unit
inline void tilemap_set_scrollx(tilemap_t *tmap, int row, int value)
{ tmap->set_scrollx(row, value); }
inline void tilemap_set_scrolly(tilemap_t *tmap, int col, int value)
{ tmap->set_scrolly(col, value); }
// return the scroll value for a row/column unit
inline int tilemap_get_scrollx(tilemap_t *tmap, int row)
{ return tmap->scrollx(row); }
inline int tilemap_get_scrolly(tilemap_t *tmap, int col)
{ return tmap->scrolly(col); }
// ----- internal map access -----
// return a pointer to the (updated) internal pixmap for a tilemap
inline bitmap_ind16 &tilemap_get_pixmap(tilemap_t *tmap)
{ return tmap->pixmap(); }
// return a pointer to the (updated) internal flagsmap for a tilemap
inline bitmap_ind8 &tilemap_get_flagsmap(tilemap_t *tmap)
{ return tmap->flagsmap(); }
// return a pointer to the (updated) internal per-tile flags for a tilemap
inline UINT8 *tilemap_get_tile_flags(tilemap_t *tmap)
{ return tmap->tile_flags(); }
// ----- tilemap rendering -----
// draw a tilemap to the destination with clipping; pixels apply priority/priority_mask to the priority bitmap
inline void tilemap_draw_primask(bitmap_ind16 &dest, const rectangle &cliprect, tilemap_t *tmap, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ tmap->draw(dest, cliprect, flags, priority, priority_mask); }
inline void tilemap_draw_primask(bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ tmap->draw(dest, cliprect, flags, priority, priority_mask); }
// draw a tilemap to the destination with clipping and arbitrary rotate/zoom;
// pixels apply priority/priority_mask to the priority bitmap
inline void tilemap_draw_roz_primask(bitmap_ind16 &dest, const rectangle &cliprect, tilemap_t *tmap,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ tmap->draw_roz(dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority, priority_mask); }
inline void tilemap_draw_roz_primask(bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ tmap->draw_roz(dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority, priority_mask); }
// ----- common logical-to-memory mappers -----
@ -827,45 +698,6 @@ TILEMAP_MAPPER( tilemap_scan_cols_flip_xy );
// INLINE FUNCTIONS
//**************************************************************************
/*-------------------------------------------------
tileinfo_set - set the values of a tileinfo
structure
-------------------------------------------------*/
inline void tileinfo_set(running_machine &machine, tile_data *tileinfo, int gfxnum, int rawcode, int rawcolor, int flags)
{ tileinfo->set(machine, gfxnum, rawcode, rawcolor, flags); }
/*-------------------------------------------------
tilemap_map_pen_to_layer - map a single pen
to a layer
-------------------------------------------------*/
inline void tilemap_map_pen_to_layer(tilemap_t *tmap, int group, pen_t pen, UINT8 layermask)
{ tmap->map_pen_to_layer(group, pen, layermask); }
/*-------------------------------------------------
tilemap_draw - shortcut to
tilemap_draw_primask
-------------------------------------------------*/
template<class _BitmapClass>
inline void tilemap_draw(_BitmapClass &dest, const rectangle &cliprect, tilemap_t *tmap, UINT32 flags, UINT8 priority)
{ tmap->draw(dest, cliprect, flags, priority); }
/*-------------------------------------------------
tilemap_draw_roz - shortcut to
tilemap_draw_roz_primask
-------------------------------------------------*/
template<class _BitmapClass>
inline void tilemap_draw_roz(_BitmapClass &dest, const rectangle &cliprect, tilemap_t *tmap,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
int wraparound, UINT32 flags, UINT8 priority)
{ tmap->draw_roz(dest, cliprect, startx, starty, incxx, incxy, incyx, incyy, wraparound, flags, priority); }
inline running_machine &tilemap_t::machine() const
{

2
src/emu/video/generic.c
View File

@ -384,7 +384,7 @@ static void updateflip(running_machine &machine)
attoseconds_t period = machine.primary_screen->frame_period().attoseconds;
rectangle visarea = machine.primary_screen->visible_area();
tilemap_set_flip_all(machine,(TILEMAP_FLIPX & state->flip_screen_x) | (TILEMAP_FLIPY & state->flip_screen_y));
machine.tilemap().set_flip_all((TILEMAP_FLIPX & state->flip_screen_x) | (TILEMAP_FLIPY & state->flip_screen_y));
if (state->flip_screen_x)
{

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

@ -74,7 +74,7 @@ static WRITE16_HANDLER( k3_bgram_w )
{
k3_state *state = space->machine().driver_data<k3_state>();
COMBINE_DATA(&state->m_bgram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_k3_bg_tile_info )
@ -119,7 +119,7 @@ static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const
static SCREEN_UPDATE_IND16(k3)
{
k3_state *state = screen.machine().driver_data<k3_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;
}
@ -128,13 +128,13 @@ static SCREEN_UPDATE_IND16(k3)
static WRITE16_HANDLER( k3_scrollx_w )
{
k3_state *state = space->machine().driver_data<k3_state>();
tilemap_set_scrollx(state->m_bg_tilemap, 0, data);
state->m_bg_tilemap->set_scrollx(0, data);
}
static WRITE16_HANDLER( k3_scrolly_w )
{
k3_state *state = space->machine().driver_data<k3_state>();
tilemap_set_scrolly(state->m_bg_tilemap, 0, data);
state->m_bg_tilemap->set_scrolly(0, data);
}
static WRITE16_HANDLER( k3_soundbanks_w )

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

@ -481,14 +481,14 @@ static WRITE8_HANDLER( fclown_videoram_w )
{
_5clown_state *state = space->machine().driver_data<_5clown_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fclown_colorram_w )
{
_5clown_state *state = space->machine().driver_data<_5clown_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -524,7 +524,7 @@ static VIDEO_START(fclown)
static SCREEN_UPDATE_IND16( fclown )
{
_5clown_state *state = screen.machine().driver_data<_5clown_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -177,7 +177,7 @@ static VIDEO_START( acommand )
state->m_ac_vregs = auto_alloc_array(machine, UINT16, 0x80/2);
tilemap_set_transparent_pen(state->m_tx_tilemap,15);
state->m_tx_tilemap->set_transparent_pen(15);
}
@ -241,9 +241,9 @@ static void draw_led(bitmap_ind16 &bitmap, int x, int y,UINT8 value)
static SCREEN_UPDATE_IND16( acommand )
{
acommand_state *state = screen.machine().driver_data<acommand_state>();
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
draw_sprites(screen.machine(),bitmap,cliprect,0,0);
tilemap_draw(bitmap,cliprect,state->m_tx_tilemap,0,0);
state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
/*Order might be wrong,but these for sure are the led numbers tested*/
draw_led(bitmap, 0, 20, (state->m_led0 & 0x0f00) >> 8);
@ -261,14 +261,14 @@ static WRITE16_HANDLER( ac_bgvram_w )
{
acommand_state *state = space->machine().driver_data<acommand_state>();
COMBINE_DATA(&state->m_ac_bgvram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( ac_txvram_w )
{
acommand_state *state = space->machine().driver_data<acommand_state>();
COMBINE_DATA(&state->m_ac_txvram[offset]);
tilemap_mark_tile_dirty(state->m_tx_tilemap,offset);
state->m_tx_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER(ac_bgscroll_w)
@ -276,8 +276,8 @@ static WRITE16_HANDLER(ac_bgscroll_w)
acommand_state *state = space->machine().driver_data<acommand_state>();
switch(offset)
{
case 0: tilemap_set_scrollx(state->m_bg_tilemap,0,data); break;
case 1: tilemap_set_scrolly(state->m_bg_tilemap,0,data); break;
case 0: state->m_bg_tilemap->set_scrollx(0,data); break;
case 1: state->m_bg_tilemap->set_scrolly(0,data); break;
case 2: /*BG_TILEMAP priority?*/ break;
}
}
@ -287,8 +287,8 @@ static WRITE16_HANDLER(ac_txscroll_w)
acommand_state *state = space->machine().driver_data<acommand_state>();
switch(offset)
{
case 0: tilemap_set_scrollx(state->m_tx_tilemap,0,data); break;
case 1: tilemap_set_scrolly(state->m_tx_tilemap,0,data); break;
case 0: state->m_tx_tilemap->set_scrollx(0,data); break;
case 1: state->m_tx_tilemap->set_scrolly(0,data); break;
case 2: /*TX_TILEMAP priority?*/ break;
}
}

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

@ -86,7 +86,7 @@ static VIDEO_START( yumefuda )
static SCREEN_UPDATE_IND16( yumefuda )
{
albazg_state *state = screen.machine().driver_data<albazg_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -112,14 +112,14 @@ static WRITE8_HANDLER( yumefuda_vram_w )
{
albazg_state *state = space->machine().driver_data<albazg_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( yumefuda_cram_w )
{
albazg_state *state = space->machine().driver_data<albazg_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
/*Custom RAM (Thrash Protection)*/

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

@ -725,7 +725,7 @@ static WRITE8_HANDLER( blitter_txram_w )
armedf_state *state = space->machine().driver_data<armedf_state>();
state->m_text_videoram[offset] = (data & 0xff) | (state->m_text_videoram[offset] & 0xff00);
tilemap_mark_tile_dirty(state->m_tx_tilemap, offset);
state->m_tx_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fg_scrollx_w )

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

@ -467,14 +467,14 @@ public:
WRITE8_MEMBER( avt_state::avt_videoram_w )
{
m_videoram[offset] = data;
tilemap_mark_tile_dirty(m_bg_tilemap, offset);
m_bg_tilemap->mark_tile_dirty(offset);
}
WRITE8_MEMBER( avt_state::avt_colorram_w )
{
m_colorram[offset] = data;
tilemap_mark_tile_dirty(m_bg_tilemap, offset);
m_bg_tilemap->mark_tile_dirty(offset);
}
@ -522,7 +522,7 @@ static SCREEN_UPDATE_IND16( avt )
count++;
}
}
//tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
//state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -113,7 +113,7 @@ static WRITE16_HANDLER( latch_w )
if ((oldword ^ state->m_latch_data) & 0x7000)
{
space->machine().primary_screen->update_partial(space->machine().primary_screen->vpos());
tilemap_mark_all_tiles_dirty(state->m_alpha_tilemap);
state->m_alpha_tilemap->mark_all_dirty();
state->m_alpha_tile_bank = (state->m_latch_data >> 12) & 7;
}
}

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

@ -98,8 +98,8 @@ static VIDEO_START(bestleag)
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,bsb_bg_scan,16,16,128, 64);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,bsb_bg_scan,16,16,128, 64);
tilemap_set_transparent_pen(state->m_tx_tilemap,15);
tilemap_set_transparent_pen(state->m_fg_tilemap,15);
state->m_tx_tilemap->set_transparent_pen(15);
state->m_fg_tilemap->set_transparent_pen(15);
}
/*
@ -166,34 +166,34 @@ static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const r
static SCREEN_UPDATE_IND16(bestleag)
{
bestleag_state *state = screen.machine().driver_data<bestleag_state>();
tilemap_set_scrollx(state->m_bg_tilemap,0,(state->m_vregs[0x00/2] & 0xfff) + (state->m_vregs[0x08/2] & 0x7) - 3);
tilemap_set_scrolly(state->m_bg_tilemap,0,state->m_vregs[0x02/2]);
tilemap_set_scrollx(state->m_tx_tilemap,0,state->m_vregs[0x04/2]);
tilemap_set_scrolly(state->m_tx_tilemap,0,state->m_vregs[0x06/2]);
tilemap_set_scrollx(state->m_fg_tilemap,0,state->m_vregs[0x08/2] & 0xfff8);
tilemap_set_scrolly(state->m_fg_tilemap,0,state->m_vregs[0x0a/2]);
state->m_bg_tilemap->set_scrollx(0,(state->m_vregs[0x00/2] & 0xfff) + (state->m_vregs[0x08/2] & 0x7) - 3);
state->m_bg_tilemap->set_scrolly(0,state->m_vregs[0x02/2]);
state->m_tx_tilemap->set_scrollx(0,state->m_vregs[0x04/2]);
state->m_tx_tilemap->set_scrolly(0,state->m_vregs[0x06/2]);
state->m_fg_tilemap->set_scrollx(0,state->m_vregs[0x08/2] & 0xfff8);
state->m_fg_tilemap->set_scrolly(0,state->m_vregs[0x0a/2]);
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0,0);
draw_sprites(screen.machine(),bitmap,cliprect);
tilemap_draw(bitmap,cliprect,state->m_tx_tilemap,0,0);
state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}
static SCREEN_UPDATE_IND16(bestleaw)
{
bestleag_state *state = screen.machine().driver_data<bestleag_state>();
tilemap_set_scrollx(state->m_bg_tilemap,0,state->m_vregs[0x08/2]);
tilemap_set_scrolly(state->m_bg_tilemap,0,state->m_vregs[0x0a/2]);
tilemap_set_scrollx(state->m_tx_tilemap,0,state->m_vregs[0x00/2]);
tilemap_set_scrolly(state->m_tx_tilemap,0,state->m_vregs[0x02/2]);
tilemap_set_scrollx(state->m_fg_tilemap,0,state->m_vregs[0x04/2]);
tilemap_set_scrolly(state->m_fg_tilemap,0,state->m_vregs[0x06/2]);
state->m_bg_tilemap->set_scrollx(0,state->m_vregs[0x08/2]);
state->m_bg_tilemap->set_scrolly(0,state->m_vregs[0x0a/2]);
state->m_tx_tilemap->set_scrollx(0,state->m_vregs[0x00/2]);
state->m_tx_tilemap->set_scrolly(0,state->m_vregs[0x02/2]);
state->m_fg_tilemap->set_scrollx(0,state->m_vregs[0x04/2]);
state->m_fg_tilemap->set_scrolly(0,state->m_vregs[0x06/2]);
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0,0);
draw_sprites(screen.machine(),bitmap,cliprect);
tilemap_draw(bitmap,cliprect,state->m_tx_tilemap,0,0);
state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}
@ -201,21 +201,21 @@ static WRITE16_HANDLER( bestleag_txram_w )
{
bestleag_state *state = space->machine().driver_data<bestleag_state>();
state->m_txram[offset] = data;
tilemap_mark_tile_dirty(state->m_tx_tilemap,offset);
state->m_tx_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( bestleag_bgram_w )
{
bestleag_state *state = space->machine().driver_data<bestleag_state>();
state->m_bgram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( bestleag_fgram_w )
{
bestleag_state *state = space->machine().driver_data<bestleag_state>();
state->m_fgram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_DEVICE_HANDLER( oki_bank_w )

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

@ -315,14 +315,14 @@ static WRITE8_HANDLER( megadpkr_videoram_w )
{
blitz_state *state = space->machine().driver_data<blitz_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( megadpkr_colorram_w )
{
blitz_state *state = space->machine().driver_data<blitz_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -355,7 +355,7 @@ static VIDEO_START( megadpkr )
static SCREEN_UPDATE_IND16( megadpkr )
{
blitz_state *state = screen.machine().driver_data<blitz_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -150,14 +150,14 @@ static WRITE32_HANDLER( ms32_tx0_ram_w )
{
bnstars_state *state = space->machine().driver_data<bnstars_state>();
COMBINE_DATA(&state->m_ms32_tx0_ram[offset]);
tilemap_mark_tile_dirty(state->m_ms32_tx_tilemap[0],offset/2);
state->m_ms32_tx_tilemap[0]->mark_tile_dirty(offset/2);
}
static WRITE32_HANDLER( ms32_tx1_ram_w )
{
bnstars_state *state = space->machine().driver_data<bnstars_state>();
COMBINE_DATA(&state->m_ms32_tx1_ram[offset]);
tilemap_mark_tile_dirty(state->m_ms32_tx_tilemap[1],offset/2);
state->m_ms32_tx_tilemap[1]->mark_tile_dirty(offset/2);
}
/* BG Layers */
@ -188,14 +188,14 @@ static WRITE32_HANDLER( ms32_bg0_ram_w )
{
bnstars_state *state = space->machine().driver_data<bnstars_state>();
COMBINE_DATA(&state->m_ms32_bg0_ram[offset]);
tilemap_mark_tile_dirty(state->m_ms32_bg_tilemap[0],offset/2);
state->m_ms32_bg_tilemap[0]->mark_tile_dirty(offset/2);
}
static WRITE32_HANDLER( ms32_bg1_ram_w )
{
bnstars_state *state = space->machine().driver_data<bnstars_state>();
COMBINE_DATA(&state->m_ms32_bg1_ram[offset]);
tilemap_mark_tile_dirty(state->m_ms32_bg_tilemap[1],offset/2);
state->m_ms32_bg_tilemap[1]->mark_tile_dirty(offset/2);
}
/* ROZ Layers */
@ -245,7 +245,7 @@ static void draw_roz(running_machine &machine, bitmap_ind16 &bitmap, const recta
if (incxx & 0x10000) incxx |= ~0x1ffff;
if (incxy & 0x10000) incxy |= ~0x1ffff;
tilemap_draw_roz(bitmap, &my_clip, state->m_ms32_roz_tilemap,
state->m_ms32_roz_tilemap->draw_roz(bitmap, &my_clip,
(start2x+startx+offsx)<<16, (start2y+starty+offsy)<<16,
incxx<<8, incxy<<8, 0, 0,
1, // Wrap
@ -277,7 +277,7 @@ static void draw_roz(running_machine &machine, bitmap_ind16 &bitmap, const recta
if (incyy & 0x10000) incyy |= ~0x1ffff;
if (incyx & 0x10000) incyx |= ~0x1ffff;
tilemap_draw_roz(bitmap, cliprect, state->m_ms32_roz_tilemap[chip],
state->m_ms32_roz_tilemap[chip]->draw_roz(bitmap, cliprect,
(startx+offsx)<<16, (starty+offsy)<<16,
incxx<<8, incxy<<8, incyx<<8, incyy<<8,
1, // Wrap
@ -312,14 +312,14 @@ static WRITE32_HANDLER( ms32_roz0_ram_w )
{
bnstars_state *state = space->machine().driver_data<bnstars_state>();
COMBINE_DATA(&state->m_ms32_roz0_ram[offset]);
tilemap_mark_tile_dirty(state->m_ms32_roz_tilemap[0],offset/2);
state->m_ms32_roz_tilemap[0]->mark_tile_dirty(offset/2);
}
static WRITE32_HANDLER( ms32_roz1_ram_w )
{
bnstars_state *state = space->machine().driver_data<bnstars_state>();
COMBINE_DATA(&state->m_ms32_roz1_ram[offset]);
tilemap_mark_tile_dirty(state->m_ms32_roz_tilemap[1],offset/2);
state->m_ms32_roz_tilemap[1]->mark_tile_dirty(offset/2);
}
@ -491,18 +491,18 @@ static VIDEO_START(bnstars)
bnstars_state *state = machine.driver_data<bnstars_state>();
state->m_ms32_tx_tilemap[0] = tilemap_create(machine, get_ms32_tx0_tile_info,tilemap_scan_rows, 8, 8,64,64);
state->m_ms32_tx_tilemap[1] = tilemap_create(machine, get_ms32_tx1_tile_info,tilemap_scan_rows, 8, 8,64,64);
tilemap_set_transparent_pen(state->m_ms32_tx_tilemap[0],0);
tilemap_set_transparent_pen(state->m_ms32_tx_tilemap[1],0);
state->m_ms32_tx_tilemap[0]->set_transparent_pen(0);
state->m_ms32_tx_tilemap[1]->set_transparent_pen(0);
state->m_ms32_bg_tilemap[0] = tilemap_create(machine, get_ms32_bg0_tile_info,tilemap_scan_rows,16,16,64,64);
state->m_ms32_bg_tilemap[1] = tilemap_create(machine, get_ms32_bg1_tile_info,tilemap_scan_rows,16,16,64,64);
tilemap_set_transparent_pen(state->m_ms32_bg_tilemap[0],0);
tilemap_set_transparent_pen(state->m_ms32_bg_tilemap[1],0);
state->m_ms32_bg_tilemap[0]->set_transparent_pen(0);
state->m_ms32_bg_tilemap[1]->set_transparent_pen(0);
state->m_ms32_roz_tilemap[0] = tilemap_create(machine, get_ms32_roz0_tile_info,tilemap_scan_rows,16,16,128,128);
state->m_ms32_roz_tilemap[1] = tilemap_create(machine, get_ms32_roz1_tile_info,tilemap_scan_rows,16,16,128,128);
tilemap_set_transparent_pen(state->m_ms32_roz_tilemap[0],0);
tilemap_set_transparent_pen(state->m_ms32_roz_tilemap[1],0);
state->m_ms32_roz_tilemap[0]->set_transparent_pen(0);
state->m_ms32_roz_tilemap[1]->set_transparent_pen(0);
}
@ -520,15 +520,15 @@ static SCREEN_UPDATE_IND16(bnstars_left)
bitmap.fill(0, cliprect); /* bg color */
tilemap_set_scrollx(state->m_ms32_bg_tilemap[0], 0, state->m_ms32_bg0_scroll[0x00/4] + state->m_ms32_bg0_scroll[0x08/4] + 0x10 );
tilemap_set_scrolly(state->m_ms32_bg_tilemap[0], 0, state->m_ms32_bg0_scroll[0x0c/4] + state->m_ms32_bg0_scroll[0x14/4] );
tilemap_draw(bitmap,cliprect,state->m_ms32_bg_tilemap[0],0,1);
state->m_ms32_bg_tilemap[0]->set_scrollx(0, state->m_ms32_bg0_scroll[0x00/4] + state->m_ms32_bg0_scroll[0x08/4] + 0x10 );
state->m_ms32_bg_tilemap[0]->set_scrolly(0, state->m_ms32_bg0_scroll[0x0c/4] + state->m_ms32_bg0_scroll[0x14/4] );
state->m_ms32_bg_tilemap[0]->draw(bitmap, cliprect, 0,1);
draw_roz(screen.machine(),bitmap,cliprect,2,0);
tilemap_set_scrollx(state->m_ms32_tx_tilemap[0], 0, state->m_ms32_tx0_scroll[0x00/4] + state->m_ms32_tx0_scroll[0x08/4] + 0x18);
tilemap_set_scrolly(state->m_ms32_tx_tilemap[0], 0, state->m_ms32_tx0_scroll[0x0c/4] + state->m_ms32_tx0_scroll[0x14/4]);
tilemap_draw(bitmap,cliprect,state->m_ms32_tx_tilemap[0],0,4);
state->m_ms32_tx_tilemap[0]->set_scrollx(0, state->m_ms32_tx0_scroll[0x00/4] + state->m_ms32_tx0_scroll[0x08/4] + 0x18);
state->m_ms32_tx_tilemap[0]->set_scrolly(0, state->m_ms32_tx0_scroll[0x0c/4] + state->m_ms32_tx0_scroll[0x14/4]);
state->m_ms32_tx_tilemap[0]->draw(bitmap, cliprect, 0,4);
draw_sprites(screen.machine(),bitmap,cliprect, state->m_ms32_spram, 0x20000, 0);
@ -545,15 +545,15 @@ static SCREEN_UPDATE_IND16(bnstars_right)
bitmap.fill(0x8000+0, cliprect); /* bg color */
tilemap_set_scrollx(state->m_ms32_bg_tilemap[1], 0, state->m_ms32_bg1_scroll[0x00/4] + state->m_ms32_bg1_scroll[0x08/4] + 0x10 );
tilemap_set_scrolly(state->m_ms32_bg_tilemap[1], 0, state->m_ms32_bg1_scroll[0x0c/4] + state->m_ms32_bg1_scroll[0x14/4] );
tilemap_draw(bitmap,cliprect,state->m_ms32_bg_tilemap[1],0,1);
state->m_ms32_bg_tilemap[1]->set_scrollx(0, state->m_ms32_bg1_scroll[0x00/4] + state->m_ms32_bg1_scroll[0x08/4] + 0x10 );
state->m_ms32_bg_tilemap[1]->set_scrolly(0, state->m_ms32_bg1_scroll[0x0c/4] + state->m_ms32_bg1_scroll[0x14/4] );
state->m_ms32_bg_tilemap[1]->draw(bitmap, cliprect, 0,1);
draw_roz(screen.machine(),bitmap,cliprect,2,1);
tilemap_set_scrollx(state->m_ms32_tx_tilemap[1], 0, state->m_ms32_tx1_scroll[0x00/4] + state->m_ms32_tx1_scroll[0x08/4] + 0x18);
tilemap_set_scrolly(state->m_ms32_tx_tilemap[1], 0, state->m_ms32_tx1_scroll[0x0c/4] + state->m_ms32_tx1_scroll[0x14/4]);
tilemap_draw(bitmap,cliprect,state->m_ms32_tx_tilemap[1],0,4);
state->m_ms32_tx_tilemap[1]->set_scrollx(0, state->m_ms32_tx1_scroll[0x00/4] + state->m_ms32_tx1_scroll[0x08/4] + 0x18);
state->m_ms32_tx_tilemap[1]->set_scrolly(0, state->m_ms32_tx1_scroll[0x0c/4] + state->m_ms32_tx1_scroll[0x14/4]);
state->m_ms32_tx_tilemap[1]->draw(bitmap, cliprect, 0,4);
draw_sprites(screen.machine(),bitmap,cliprect, state->m_ms32_spram+(0x20000/4), 0x20000, 4);

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

@ -227,7 +227,7 @@ static WRITE8_DEVICE_HANDLER( bogeyman_colbank_w )
if((data & 1) != (state->m_colbank & 1))
{
state->m_colbank = data & 1;
tilemap_mark_all_tiles_dirty(state->m_fg_tilemap);
state->m_fg_tilemap->mark_all_dirty();
}
}

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

@ -55,14 +55,14 @@ static WRITE8_HANDLER( bg_scroll_w )
{
cabaret_state *state = space->machine().driver_data<cabaret_state>();
state->m_bg_scroll[offset] = data;
tilemap_set_scrolly(state->m_bg_tilemap,offset,data);
state->m_bg_tilemap->set_scrolly(offset,data);
}
static WRITE8_HANDLER( bg_tile_w )
{
cabaret_state *state = space->machine().driver_data<cabaret_state>();
state->m_bg_tile_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_bg_tile_info )
@ -84,14 +84,14 @@ static WRITE8_HANDLER( fg_tile_w )
{
cabaret_state *state = space->machine().driver_data<cabaret_state>();
state->m_fg_tile_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fg_color_w )
{
cabaret_state *state = space->machine().driver_data<cabaret_state>();
state->m_fg_color_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static VIDEO_START(cabaret)
@ -99,8 +99,8 @@ static VIDEO_START(cabaret)
cabaret_state *state = machine.driver_data<cabaret_state>();
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 32, 64, 8);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 64, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
tilemap_set_scroll_cols(state->m_bg_tilemap, 64);
state->m_fg_tilemap->set_transparent_pen(0);
state->m_bg_tilemap->set_scroll_cols(64);
}
@ -109,9 +109,9 @@ static SCREEN_UPDATE_IND16(cabaret)
cabaret_state *state = screen.machine().driver_data<cabaret_state>();
bitmap.fill(get_black_pen(screen.machine()), cliprect);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -136,7 +136,7 @@ static VIDEO_START( calorie )
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 16, 16, 16, 16);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( calorie )
@ -146,12 +146,12 @@ static SCREEN_UPDATE_IND16( calorie )
if (state->m_bg_bank & 0x10)
{
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
}
else
{
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, TILEMAP_DRAW_OPAQUE, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
}
@ -202,14 +202,14 @@ static WRITE8_HANDLER( fg_ram_w )
{
calorie_state *state = space->machine().driver_data<calorie_state>();
state->m_fg_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset & 0x3ff);
state->m_fg_tilemap->mark_tile_dirty(offset & 0x3ff);
}
static WRITE8_HANDLER( bg_bank_w )
{
calorie_state *state = space->machine().driver_data<calorie_state>();
if((state->m_bg_bank & ~0x10) != (data & ~0x10))
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
state->m_bg_bank = data;
}

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

@ -82,7 +82,7 @@ static VIDEO_START(vvillage)
static SCREEN_UPDATE_IND16(vvillage)
{
caswin_state *state = screen.machine().driver_data<caswin_state>();
tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
state->m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}
@ -90,14 +90,14 @@ static WRITE8_HANDLER( sc0_vram_w )
{
caswin_state *state = space->machine().driver_data<caswin_state>();
state->m_sc0_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( sc0_attr_w )
{
caswin_state *state = space->machine().driver_data<caswin_state>();
state->m_sc0_attr[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
}
/*These two are tested during the two cherry sub-games.I really don't know what is supposed to do...*/

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

@ -365,21 +365,21 @@ static SCREEN_UPDATE_RGB32(cb2001)
scroll >>=8;
scroll &=0xff;
tilemap_set_scrolly(state->m_reel2_tilemap, i, scroll);
state->m_reel2_tilemap->set_scrolly(i, scroll);
scroll = state->m_vram_bg[0x800/2 + i/2];
if (i&1)
scroll >>=8;
scroll &=0xff;
tilemap_set_scrolly(state->m_reel1_tilemap, i, scroll);
state->m_reel1_tilemap->set_scrolly(i, scroll);
scroll = state->m_vram_bg[0xc00/2 + i/2];
if (i&1)
scroll >>=8;
scroll &=0xff;
tilemap_set_scrolly(state->m_reel3_tilemap, i, scroll);
state->m_reel3_tilemap->set_scrolly(i, scroll);
}
@ -388,9 +388,9 @@ static SCREEN_UPDATE_RGB32(cb2001)
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);
tilemap_draw(bitmap, visible1, state->m_reel1_tilemap, 0, 0);
tilemap_draw(bitmap, visible2, state->m_reel2_tilemap, 0, 0);
tilemap_draw(bitmap, visible3, state->m_reel3_tilemap, 0, 0);
state->m_reel1_tilemap->draw(bitmap, visible1, 0, 0);
state->m_reel2_tilemap->draw(bitmap, visible2, 0, 0);
state->m_reel3_tilemap->draw(bitmap, visible3, 0, 0);
}
}
@ -518,9 +518,9 @@ static VIDEO_START(cb2001)
state->m_reel2_tilemap = tilemap_create(machine,get_cb2001_reel2_tile_info,tilemap_scan_rows, 8, 32, 64, 8);
state->m_reel3_tilemap = tilemap_create(machine,get_cb2001_reel3_tile_info,tilemap_scan_rows, 8, 32, 64, 8);
tilemap_set_scroll_cols(state->m_reel1_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel2_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel3_tilemap, 64);
state->m_reel1_tilemap->set_scroll_cols(64);
state->m_reel2_tilemap->set_scroll_cols(64);
state->m_reel3_tilemap->set_scroll_cols(64);
}
WRITE16_HANDLER( cb2001_bg_w )
@ -532,24 +532,24 @@ WRITE16_HANDLER( cb2001_bg_w )
/*
if (offset<0x200/2)
{
tilemap_mark_tile_dirty(state->m_reel1_tilemap,(offset&0xff)/2);
state->m_reel1_tilemap->mark_tile_dirty((offset&0xff)/2);
}
else if (offset<0x400/2)
{
tilemap_mark_tile_dirty(state->m_reel2_tilemap,(offset&0xff)/2);
state->m_reel2_tilemap->mark_tile_dirty((offset&0xff)/2);
}
else if (offset<0x600/2)
{
tilemap_mark_tile_dirty(state->m_reel3_tilemap,(offset&0xff)/2);
state->m_reel3_tilemap->mark_tile_dirty((offset&0xff)/2);
}
else if (offset<0x800/2)
{
// tilemap_mark_tile_dirty(reel4_tilemap,(offset&0xff)/2);
// reel4_tilemap->mark_tile_dirty((offset&0xff)/2);
}
*/
tilemap_mark_all_tiles_dirty (state->m_reel1_tilemap);
tilemap_mark_all_tiles_dirty (state->m_reel2_tilemap);
tilemap_mark_all_tiles_dirty (state->m_reel3_tilemap);
state->m_reel1_tilemap->mark_all_dirty();
state->m_reel2_tilemap->mark_all_dirty();
state->m_reel3_tilemap->mark_all_dirty();
}

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

@ -39,7 +39,7 @@ static WRITE8_HANDLER( cball_vram_w )
cball_state *state = space->machine().driver_data<cball_state>();
state->m_video_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -55,7 +55,7 @@ static SCREEN_UPDATE_IND16( cball )
cball_state *state = screen.machine().driver_data<cball_state>();
/* draw playfield */
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
/* draw sprite */
drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[1],

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

@ -94,7 +94,7 @@ static WRITE8_HANDLER( chanbara_videoram_w )
chanbara_state *state = space->machine().driver_data<chanbara_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( chanbara_colorram_w )
@ -102,7 +102,7 @@ static WRITE8_HANDLER( chanbara_colorram_w )
chanbara_state *state = space->machine().driver_data<chanbara_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( chanbara_videoram2_w )
@ -110,7 +110,7 @@ static WRITE8_HANDLER( chanbara_videoram2_w )
chanbara_state *state = space->machine().driver_data<chanbara_state>();
state->m_videoram2[offset] = data;
tilemap_mark_tile_dirty(state->m_bg2_tilemap, offset);
state->m_bg2_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( chanbara_colorram2_w )
@ -118,7 +118,7 @@ static WRITE8_HANDLER( chanbara_colorram2_w )
chanbara_state *state = space->machine().driver_data<chanbara_state>();
state->m_colorram2[offset] = data;
tilemap_mark_tile_dirty(state->m_bg2_tilemap, offset);
state->m_bg2_tilemap->mark_tile_dirty(offset);
}
@ -145,7 +145,7 @@ static VIDEO_START(chanbara )
chanbara_state *state = machine.driver_data<chanbara_state>();
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows,8, 8, 32, 32);
state->m_bg2_tilemap = tilemap_create(machine, get_bg2_tile_info, tilemap_scan_rows,16, 16, 16, 32);
tilemap_set_transparent_pen(state->m_bg_tilemap, 0);
state->m_bg_tilemap->set_transparent_pen(0);
}
static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
@ -196,10 +196,10 @@ static SCREEN_UPDATE_IND16( chanbara )
{
chanbara_state *state = screen.machine().driver_data<chanbara_state>();
tilemap_set_scrolly(state->m_bg2_tilemap, 0, state->m_scroll | (state->m_scrollhi << 8));
tilemap_draw(bitmap, cliprect, state->m_bg2_tilemap, 0, 0);
state->m_bg2_tilemap->set_scrolly(0, state->m_scroll | (state->m_scrollhi << 8));
state->m_bg2_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -117,9 +117,9 @@ static VIDEO_START( cntsteer )
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_cols, 16, 16, 64, 64);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows_flip_x, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
//tilemap_set_flip(state->m_bg_tilemap, TILEMAP_FLIPX | TILEMAP_FLIPY);
//state->m_bg_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
}
static VIDEO_START( zerotrgt )
@ -128,9 +128,9 @@ static VIDEO_START( zerotrgt )
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 16, 16, 64, 64);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows_flip_x, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
//tilemap_set_flip(state->m_bg_tilemap, TILEMAP_FLIPX | TILEMAP_FLIPY);
//state->m_bg_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
}
/*
@ -290,7 +290,7 @@ static SCREEN_UPDATE_IND16( zerotrgt )
x = -256 - (state->m_scrollx | state->m_scrollx_hi);
y = 256 + (state->m_scrolly | state->m_scrolly_hi);
tilemap_draw_roz(bitmap, cliprect, state->m_bg_tilemap,
state->m_bg_tilemap->draw_roz(bitmap, cliprect,
(x << 16), (y << 16),
p1, p2,
p3, p4,
@ -299,7 +299,7 @@ static SCREEN_UPDATE_IND16( zerotrgt )
}
zerotrgt_draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -339,7 +339,7 @@ static SCREEN_UPDATE_IND16( cntsteer )
x = 256 + (state->m_scrollx | state->m_scrollx_hi);
y = 256 - (state->m_scrolly | state->m_scrolly_hi);
tilemap_draw_roz(bitmap, cliprect, state->m_bg_tilemap,
state->m_bg_tilemap->draw_roz(bitmap, cliprect,
(x << 16), (y << 16),
p1, p2,
p3, p4,
@ -348,7 +348,7 @@ static SCREEN_UPDATE_IND16( cntsteer )
}
cntsteer_draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -380,7 +380,7 @@ static WRITE8_HANDLER(zerotrgt_vregs_w)
case 2: state->m_bg_bank = (data & 0x30) << 4;
state->m_bg_color_bank = (data & 7);
state->m_disable_roz = (data & 0x40);
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
break;
case 3: state->m_rotation_sign = (data & 1);
flip_screen_set(space->machine(), !(data & 4));
@ -405,7 +405,7 @@ static WRITE8_HANDLER(cntsteer_vregs_w)
case 1: state->m_scrollx = data; break;
case 2: state->m_bg_bank = (data & 0x01) << 8;
state->m_bg_color_bank = (data & 6) >> 1;
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
break;
case 3: state->m_rotation_sign = (data & 7);
state->m_disable_roz = (~data & 0x08);
@ -420,21 +420,21 @@ static WRITE8_HANDLER( cntsteer_foreground_vram_w )
{
cntsteer_state *state = space->machine().driver_data<cntsteer_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( cntsteer_foreground_attr_w )
{
cntsteer_state *state = space->machine().driver_data<cntsteer_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( cntsteer_background_w )
{
cntsteer_state *state = space->machine().driver_data<cntsteer_state>();
state->m_videoram2[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
/*************************************

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

@ -51,7 +51,7 @@ static WRITE8_HANDLER( quizmstr_bg_w )
videoram[offset] = data;
if(offset >= 0x0240)
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset - 0x0240);
state->m_bg_tilemap->mark_tile_dirty(offset - 0x0240);
}
@ -97,7 +97,7 @@ static WRITE8_HANDLER( quizmstr_attr1_w )
{
// the later games also use attr3 for something..
UINT32 paldata = (state->m_attr_ram1[offset] & 0x7f) | ((state->m_attr_ram2[offset] & 0x7f) << 7);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset - 0x0240);
state->m_bg_tilemap->mark_tile_dirty(offset - 0x0240);
coinmstr_set_pal(space->machine(), paldata, offset - 0x240);
@ -113,7 +113,7 @@ static WRITE8_HANDLER( quizmstr_attr2_w )
{
// the later games also use attr3 for something..
UINT32 paldata = (state->m_attr_ram1[offset] & 0x7f) | ((state->m_attr_ram2[offset] & 0x7f) << 7);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset - 0x0240);
state->m_bg_tilemap->mark_tile_dirty(offset - 0x0240);
coinmstr_set_pal(space->machine(), paldata, offset - 0x240);
@ -126,7 +126,7 @@ static WRITE8_HANDLER( quizmstr_attr3_w )
state->m_attr_ram3[offset] = data;
if(offset >= 0x0240)
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset - 0x0240);
state->m_bg_tilemap->mark_tile_dirty(offset - 0x0240);
}
@ -917,7 +917,7 @@ static VIDEO_START( coinmstr )
static SCREEN_UPDATE_IND16( coinmstr )
{
coinmstr_state *state = screen.machine().driver_data<coinmstr_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -140,11 +140,11 @@ static WRITE8_HANDLER( combatsc_vreg_w )
combatsc_state *state = space->machine().driver_data<combatsc_state>();
if (data != state->m_vreg)
{
tilemap_mark_all_tiles_dirty(state->m_textlayer);
state->m_textlayer->mark_all_dirty();
if ((data & 0x0f) != (state->m_vreg & 0x0f))
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap[0]);
state->m_bg_tilemap[0]->mark_all_dirty();
if ((data >> 4) != (state->m_vreg >> 4))
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap[1]);
state->m_bg_tilemap[1]->mark_all_dirty();
state->m_vreg = data;
}
}

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

@ -125,21 +125,21 @@ static WRITE8_HANDLER(cshooter_txram_w)
{
cshooter_state *state = space->machine().driver_data<cshooter_state>();
state->m_txram[offset] = data;
tilemap_mark_tile_dirty(state->m_txtilemap,offset/2);
state->m_txtilemap->mark_tile_dirty(offset/2);
}
static VIDEO_START(cshooter)
{
cshooter_state *state = machine.driver_data<cshooter_state>();
state->m_txtilemap = tilemap_create(machine, get_cstx_tile_info,tilemap_scan_rows, 8,8,32, 32);
tilemap_set_transparent_pen(state->m_txtilemap, 3);
state->m_txtilemap->set_transparent_pen(3);
}
static SCREEN_UPDATE_IND16(cshooter)
{
cshooter_state *state = screen.machine().driver_data<cshooter_state>();
bitmap.fill(0/*get_black_pen(screen.screen.machine(, cliprect))*/);
tilemap_mark_all_tiles_dirty(state->m_txtilemap);
state->m_txtilemap->mark_all_dirty();
//sprites
{
@ -178,8 +178,8 @@ static SCREEN_UPDATE_IND16(cshooter)
}
}
tilemap_mark_all_tiles_dirty(state->m_txtilemap);
tilemap_draw(bitmap,cliprect,state->m_txtilemap,0,0);
state->m_txtilemap->mark_all_dirty();
state->m_txtilemap->draw(bitmap, cliprect, 0,0);
return 0;
}

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

@ -73,16 +73,16 @@ static VIDEO_START( cultures )
state->m_bg1_tilemap = tilemap_create(machine, get_bg1_tile_info,tilemap_scan_rows, 8, 8, 512, 512);
state->m_bg2_tilemap = tilemap_create(machine, get_bg2_tile_info,tilemap_scan_rows, 8, 8, 512, 512);
tilemap_set_transparent_pen(state->m_bg1_tilemap, 0);
tilemap_set_transparent_pen(state->m_bg0_tilemap, 0);
state->m_bg1_tilemap->set_transparent_pen(0);
state->m_bg0_tilemap->set_transparent_pen(0);
tilemap_set_scrolldx(state->m_bg0_tilemap, 502, 10);
tilemap_set_scrolldx(state->m_bg1_tilemap, 502, 10);
tilemap_set_scrolldx(state->m_bg2_tilemap, 502, 10);
state->m_bg0_tilemap->set_scrolldx(502, 10);
state->m_bg1_tilemap->set_scrolldx(502, 10);
state->m_bg2_tilemap->set_scrolldx(502, 10);
tilemap_set_scrolldy(state->m_bg0_tilemap, 255, 0);
tilemap_set_scrolldy(state->m_bg1_tilemap, 255, 0);
tilemap_set_scrolldy(state->m_bg2_tilemap, 255, 0);
state->m_bg0_tilemap->set_scrolldy(255, 0);
state->m_bg1_tilemap->set_scrolldy(255, 0);
state->m_bg2_tilemap->set_scrolldy(255, 0);
}
static SCREEN_UPDATE_IND16( cultures )
@ -92,25 +92,25 @@ static SCREEN_UPDATE_IND16( cultures )
// tilemaps attributes
attr = (state->m_bg0_regs_x[3] & 1 ? TILEMAP_FLIPX : 0) | (state->m_bg0_regs_y[3] & 1 ? TILEMAP_FLIPY : 0);
tilemap_set_flip(state->m_bg0_tilemap, attr);
state->m_bg0_tilemap->set_flip(attr);
attr = (state->m_bg1_regs_x[3] & 1 ? TILEMAP_FLIPX : 0) | (state->m_bg1_regs_y[3] & 1 ? TILEMAP_FLIPY : 0);
tilemap_set_flip(state->m_bg1_tilemap, attr);
state->m_bg1_tilemap->set_flip(attr);
attr = (state->m_bg2_regs_x[3] & 1 ? TILEMAP_FLIPX : 0) | (state->m_bg2_regs_y[3] & 1 ? TILEMAP_FLIPY : 0);
tilemap_set_flip(state->m_bg2_tilemap, attr);
state->m_bg2_tilemap->set_flip(attr);
// tilemaps scrolls
tilemap_set_scrollx(state->m_bg0_tilemap, 0, (state->m_bg0_regs_x[2] << 8) + state->m_bg0_regs_x[0]);
tilemap_set_scrollx(state->m_bg1_tilemap, 0, (state->m_bg1_regs_x[2] << 8) + state->m_bg1_regs_x[0]);
tilemap_set_scrollx(state->m_bg2_tilemap, 0, (state->m_bg2_regs_x[2] << 8) + state->m_bg2_regs_x[0]);
tilemap_set_scrolly(state->m_bg0_tilemap, 0, (state->m_bg0_regs_y[2] << 8) + state->m_bg0_regs_y[0]);
tilemap_set_scrolly(state->m_bg1_tilemap, 0, (state->m_bg1_regs_y[2] << 8) + state->m_bg1_regs_y[0]);
tilemap_set_scrolly(state->m_bg2_tilemap, 0, (state->m_bg2_regs_y[2] << 8) + state->m_bg2_regs_y[0]);
state->m_bg0_tilemap->set_scrollx(0, (state->m_bg0_regs_x[2] << 8) + state->m_bg0_regs_x[0]);
state->m_bg1_tilemap->set_scrollx(0, (state->m_bg1_regs_x[2] << 8) + state->m_bg1_regs_x[0]);
state->m_bg2_tilemap->set_scrollx(0, (state->m_bg2_regs_x[2] << 8) + state->m_bg2_regs_x[0]);
state->m_bg0_tilemap->set_scrolly(0, (state->m_bg0_regs_y[2] << 8) + state->m_bg0_regs_y[0]);
state->m_bg1_tilemap->set_scrolly(0, (state->m_bg1_regs_y[2] << 8) + state->m_bg1_regs_y[0]);
state->m_bg2_tilemap->set_scrolly(0, (state->m_bg2_regs_y[2] << 8) + state->m_bg2_regs_y[0]);
tilemap_draw(bitmap, cliprect, state->m_bg2_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_bg0_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_bg1_tilemap, 0, 0);
state->m_bg2_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_bg0_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_bg1_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -141,7 +141,7 @@ static WRITE8_HANDLER( bg0_videoram_w )
else
{
state->m_bg0_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg0_tilemap, offset >> 1);
state->m_bg0_tilemap->mark_tile_dirty(offset >> 1);
}
}
@ -169,13 +169,13 @@ static WRITE8_HANDLER( bg_bank_w )
if (state->m_bg1_bank != (data & 3))
{
state->m_bg1_bank = data & 3;
tilemap_mark_all_tiles_dirty(state->m_bg1_tilemap);
state->m_bg1_tilemap->mark_all_dirty();
}
if (state->m_bg2_bank != ((data & 0xc) >> 2))
{
state->m_bg2_bank = (data & 0xc) >> 2;
tilemap_mark_all_tiles_dirty(state->m_bg2_tilemap);
state->m_bg2_tilemap->mark_all_dirty();
}
coin_counter_w(space->machine(), 0, data & 0x10);
}

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

@ -203,7 +203,7 @@ static VIDEO_START( cybertnk )
{
cybertnk_state *state = machine.driver_data<cybertnk_state>();
state->m_tx_tilemap = tilemap_create(machine, get_tx_tile_info,tilemap_scan_rows,8,8,128,32);
tilemap_set_transparent_pen(state->m_tx_tilemap,0);
state->m_tx_tilemap->set_transparent_pen(0);
}
static void draw_pixel( bitmap_ind16 &bitmap, const rectangle &cliprect, int y, int x, int pen)
@ -216,7 +216,7 @@ static UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const r
{
cybertnk_state *state = screen.machine().driver_data<cybertnk_state>();
tilemap_set_scrolldx(state->m_tx_tilemap, screen_shift, screen_shift);
state->m_tx_tilemap->set_scrolldx(screen_shift, screen_shift);
bitmap.fill(get_black_pen(screen.machine()), cliprect);
@ -405,7 +405,7 @@ static UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const r
}
}
tilemap_draw(bitmap,cliprect,state->m_tx_tilemap,0,0);
state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
//0x62 0x9a 1c2d0
@ -514,7 +514,7 @@ static WRITE16_HANDLER( tx_vram_w )
{
cybertnk_state *state = space->machine().driver_data<cybertnk_state>();
COMBINE_DATA(&state->m_tx_vram[offset]);
tilemap_mark_tile_dirty(state->m_tx_tilemap,offset);
state->m_tx_tilemap->mark_tile_dirty(offset);
}
static READ16_HANDLER( io_r )

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

@ -60,7 +60,7 @@ static VIDEO_START(d9final)
static SCREEN_UPDATE_IND16(d9final)
{
d9final_state *state = screen.machine().driver_data<d9final_state>();
tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
state->m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}
@ -68,21 +68,21 @@ static WRITE8_HANDLER( sc0_lovram )
{
d9final_state *state = space->machine().driver_data<d9final_state>();
state->m_lo_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( sc0_hivram )
{
d9final_state *state = space->machine().driver_data<d9final_state>();
state->m_hi_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( sc0_cram )
{
d9final_state *state = space->machine().driver_data<d9final_state>();
state->m_cram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( d9final_bank_w )

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

@ -89,7 +89,7 @@ static VIDEO_START( dacholer )
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
}
static WRITE8_HANDLER( bg_scroll_x_w )
@ -142,18 +142,18 @@ static SCREEN_UPDATE_IND16(dacholer)
if (flip_screen_get(screen.machine()))
{
tilemap_set_scrollx(state->m_bg_tilemap, 0, 256 - state->m_scroll_x);
tilemap_set_scrolly(state->m_bg_tilemap, 0, 256 - state->m_scroll_y);
state->m_bg_tilemap->set_scrollx(0, 256 - state->m_scroll_x);
state->m_bg_tilemap->set_scrolly(0, 256 - state->m_scroll_y);
}
else
{
tilemap_set_scrollx(state->m_bg_tilemap, 0, state->m_scroll_x);
tilemap_set_scrolly(state->m_bg_tilemap, 0, state->m_scroll_y);
state->m_bg_tilemap->set_scrollx(0, state->m_scroll_x);
state->m_bg_tilemap->set_scrolly(0, state->m_scroll_y);
}
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -161,14 +161,14 @@ static WRITE8_HANDLER( background_w )
{
dacholer_state *state = space->machine().driver_data<dacholer_state>();
state->m_bgvideoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( foreground_w )
{
dacholer_state *state = space->machine().driver_data<dacholer_state>();
state->m_fgvideoram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( bg_bank_w )
@ -177,7 +177,7 @@ static WRITE8_HANDLER( bg_bank_w )
if ((data & 3) != state->m_bg_bank)
{
state->m_bg_bank = data & 3;
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
}
flip_screen_set(space->machine(), data & 0xc); // probably one bit for flipx and one for flipy

20
src/mame/drivers/darkhors.c
View File

@ -120,13 +120,13 @@ static WRITE32_HANDLER( darkhors_tmapram_w )
{
darkhors_state *state = space->machine().driver_data<darkhors_state>();
COMBINE_DATA(&state->m_tmapram[offset]);
tilemap_mark_tile_dirty(state->m_tmap, offset);
state->m_tmap->mark_tile_dirty(offset);
}
static WRITE32_HANDLER( darkhors_tmapram2_w )
{
darkhors_state *state = space->machine().driver_data<darkhors_state>();
COMBINE_DATA(&state->m_tmapram2[offset]);
tilemap_mark_tile_dirty(state->m_tmap2, offset);
state->m_tmap2->mark_tile_dirty(offset);
}
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
@ -173,8 +173,8 @@ static VIDEO_START( darkhors )
state->m_tmap2 = tilemap_create( machine, get_tile_info_1, tilemap_scan_rows,
16,16, 0x40,0x40 );
tilemap_set_transparent_pen(state->m_tmap, 0);
tilemap_set_transparent_pen(state->m_tmap2, 0);
state->m_tmap->set_transparent_pen(0);
state->m_tmap2->set_transparent_pen(0);
machine.gfx[0]->color_granularity = 64; /* 256 colour sprites with palette selectable on 64 colour boundaries */
}
@ -197,13 +197,13 @@ static SCREEN_UPDATE_IND16( darkhors )
bitmap.fill(get_black_pen(screen.machine()), cliprect);
tilemap_set_scrollx(state->m_tmap,0, (state->m_tmapscroll[0] >> 16) - 5);
tilemap_set_scrolly(state->m_tmap,0, (state->m_tmapscroll[0] & 0xffff) - 0xff );
if (layers_ctrl & 1) tilemap_draw(bitmap,cliprect, state->m_tmap, TILEMAP_DRAW_OPAQUE, 0);
state->m_tmap->set_scrollx(0, (state->m_tmapscroll[0] >> 16) - 5);
state->m_tmap->set_scrolly(0, (state->m_tmapscroll[0] & 0xffff) - 0xff );
if (layers_ctrl & 1) state->m_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
tilemap_set_scrollx(state->m_tmap2,0, (state->m_tmapscroll2[0] >> 16) - 5);
tilemap_set_scrolly(state->m_tmap2,0, (state->m_tmapscroll2[0] & 0xffff) - 0xff );
if (layers_ctrl & 2) tilemap_draw(bitmap,cliprect, state->m_tmap2, 0, 0);
state->m_tmap2->set_scrollx(0, (state->m_tmapscroll2[0] >> 16) - 5);
state->m_tmap2->set_scrolly(0, (state->m_tmapscroll2[0] & 0xffff) - 0xff );
if (layers_ctrl & 2) state->m_tmap2->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 4) draw_sprites(screen.machine(),bitmap,cliprect);

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

@ -151,10 +151,10 @@ static WRITE8_HANDLER( ddayjlc_bgram_w )
ddayjlc_state *state = space->machine().driver_data<ddayjlc_state>();
if (!offset)
tilemap_set_scrollx(state->m_bg_tilemap, 0, data + 8);
state->m_bg_tilemap->set_scrollx(0, data + 8);
state->m_bgram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset & 0x3ff);
state->m_bg_tilemap->mark_tile_dirty(offset & 0x3ff);
}
static WRITE8_HANDLER( ddayjlc_videoram_w )
@ -384,7 +384,7 @@ static SCREEN_UPDATE_IND16( ddayjlc )
{
ddayjlc_state *state = screen.machine().driver_data<ddayjlc_state>();
UINT32 i;
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
for (i = 0; i < 0x400; i += 4)
{

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

@ -252,9 +252,9 @@ static void ddealer_draw_video_layer( running_machine &machine, UINT16* vreg_bas
static SCREEN_UPDATE_IND16( ddealer )
{
ddealer_state *state = screen.machine().driver_data<ddealer_state>();
tilemap_set_scrollx(state->m_back_tilemap, 0, state->m_flipscreen ? -192 : -64);
tilemap_set_flip(state->m_back_tilemap, state->m_flipscreen ? TILEMAP_FLIPY | TILEMAP_FLIPX : 0);
tilemap_draw(bitmap, cliprect, state->m_back_tilemap, 0, 0);
state->m_back_tilemap->set_scrollx(0, state->m_flipscreen ? -192 : -64);
state->m_back_tilemap->set_flip(state->m_flipscreen ? TILEMAP_FLIPY | TILEMAP_FLIPX : 0);
state->m_back_tilemap->draw(bitmap, cliprect, 0, 0);
/* the fg tilemap handling is a little hacky right now,
i'm not sure if it should be a single tilemap with
@ -362,7 +362,7 @@ static WRITE16_HANDLER( back_vram_w )
{
ddealer_state *state = space->machine().driver_data<ddealer_state>();
COMBINE_DATA(&state->m_back_vram[offset]);
tilemap_mark_tile_dirty(state->m_back_tilemap, offset);
state->m_back_tilemap->mark_tile_dirty(offset);
}

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

@ -334,7 +334,7 @@ static VIDEO_START(dderby)
dmndrby_state *state = machine.driver_data<dmndrby_state>();
state->m_racetrack_tilemap_rom = machine.region("user1")->base();
state->m_racetrack_tilemap = tilemap_create(machine,get_dmndrby_tile_info,tilemap_scan_rows,16,16, 16, 512);
tilemap_mark_all_tiles_dirty(state->m_racetrack_tilemap);
state->m_racetrack_tilemap->mark_all_dirty();
}

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

@ -219,8 +219,8 @@ static WRITE32_HANDLER( dreamwld_bg_videoram_w )
{
dreamwld_state *state = space->machine().driver_data<dreamwld_state>();
COMBINE_DATA(&state->m_bg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset * 2);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset * 2 + 1);
state->m_bg_tilemap->mark_tile_dirty(offset * 2);
state->m_bg_tilemap->mark_tile_dirty(offset * 2 + 1);
}
static TILE_GET_INFO( get_dreamwld_bg_tile_info )
@ -238,8 +238,8 @@ static WRITE32_HANDLER( dreamwld_bg2_videoram_w )
{
dreamwld_state *state = space->machine().driver_data<dreamwld_state>();
COMBINE_DATA(&state->m_bg2_videoram[offset]);
tilemap_mark_tile_dirty(state->m_bg2_tilemap, offset * 2);
tilemap_mark_tile_dirty(state->m_bg2_tilemap, offset * 2 + 1);
state->m_bg2_tilemap->mark_tile_dirty(offset * 2);
state->m_bg2_tilemap->mark_tile_dirty(offset * 2 + 1);
}
static TILE_GET_INFO( get_dreamwld_bg2_tile_info )
@ -258,13 +258,13 @@ static VIDEO_START( dreamwld )
state->m_bg_tilemap = tilemap_create(machine, get_dreamwld_bg_tile_info,tilemap_scan_rows, 16, 16, 64,32);
state->m_bg2_tilemap = tilemap_create(machine, get_dreamwld_bg2_tile_info,tilemap_scan_rows, 16, 16, 64,32);
tilemap_set_transparent_pen(state->m_bg2_tilemap,0);
state->m_bg2_tilemap->set_transparent_pen(0);
tilemap_set_scroll_rows(state->m_bg_tilemap, 256); // line scrolling
tilemap_set_scroll_cols(state->m_bg_tilemap, 1);
state->m_bg_tilemap->set_scroll_rows(256); // line scrolling
state->m_bg_tilemap->set_scroll_cols(1);
tilemap_set_scroll_rows(state->m_bg2_tilemap, 256); // line scrolling
tilemap_set_scroll_cols(state->m_bg2_tilemap, 1);
state->m_bg2_tilemap->set_scroll_rows(256); // line scrolling
state->m_bg2_tilemap->set_scroll_cols(1);
state->m_spritebuf1 = auto_alloc_array(machine, UINT32, 0x2000 / 4);
state->m_spritebuf2 = auto_alloc_array(machine, UINT32, 0x2000 / 4);
@ -302,8 +302,8 @@ static SCREEN_UPDATE_IND16( dreamwld )
UINT32 layer0_ctrl = state->m_vregs[0x412 / 4];
UINT32 layer1_ctrl = state->m_vregs[0x416 / 4];
tilemap_set_scrolly(tmptilemap0, 0, layer0_scrolly);
tilemap_set_scrolly(tmptilemap1, 0, layer1_scrolly);
tmptilemap0->set_scrolly(0, layer0_scrolly);
tmptilemap1->set_scrolly(0, layer1_scrolly);
// not on this hw?
#if 0
@ -340,8 +340,8 @@ static SCREEN_UPDATE_IND16( dreamwld )
x0 = ((UINT16 *)state->m_vregs)[BYTE_XOR_BE(0x000/2 + ((i + layer0_scrolly)&0xff))]; // different handling to psikyo.c? ( + scrolly )
}
tilemap_set_scrollx(
tmptilemap0,
tmptilemap0->set_scrollx(
(i + layer0_scrolly) % 256 /*tilemap_width(tm0size) */,
layer0_scrollx + x0 );
@ -357,8 +357,8 @@ static SCREEN_UPDATE_IND16( dreamwld )
x1 = ((UINT16 *)state->m_vregs)[BYTE_XOR_BE(0x200/2 + ((i + layer1_scrolly)&0xff))]; // different handling to psikyo.c? ( + scrolly )
}
tilemap_set_scrollx(
tmptilemap1,
tmptilemap1->set_scrollx(
(i + layer1_scrolly) % 256 /* tilemap_width(tm1size) */,
layer1_scrollx + x1 );
}
@ -370,17 +370,17 @@ static SCREEN_UPDATE_IND16( dreamwld )
if (state->m_tilebank[0] != state->m_tilebankold[0])
{
state->m_tilebankold[0] = state->m_tilebank[0];
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
}
if (state->m_tilebank[1] != state->m_tilebankold[1])
{
state->m_tilebankold[1] = state->m_tilebank[1];
tilemap_mark_all_tiles_dirty(state->m_bg2_tilemap);
state->m_bg2_tilemap->mark_all_dirty();
}
tilemap_draw(bitmap, cliprect, tmptilemap0, 0, 0);
tilemap_draw(bitmap, cliprect, tmptilemap1, 0, 0);
tmptilemap0->draw(bitmap, cliprect, 0, 0);
tmptilemap1->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);

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

@ -120,15 +120,15 @@ static VIDEO_START( drtomy )
state->m_tilemap_bg = tilemap_create(machine, get_tile_info_bg, tilemap_scan_rows, 16, 16, 32, 32);
state->m_tilemap_fg = tilemap_create(machine, get_tile_info_fg, tilemap_scan_rows, 16, 16, 32, 32);
tilemap_set_transparent_pen(state->m_tilemap_fg, 0);
state->m_tilemap_fg->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( drtomy )
{
drtomy_state *state = screen.machine().driver_data<drtomy_state>();
tilemap_draw(bitmap, cliprect, state->m_tilemap_bg, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_tilemap_fg, 0, 0);
state->m_tilemap_bg->draw(bitmap, cliprect, 0, 0);
state->m_tilemap_fg->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;
}
@ -137,14 +137,14 @@ static WRITE16_HANDLER( drtomy_vram_fg_w )
{
drtomy_state *state = space->machine().driver_data<drtomy_state>();
COMBINE_DATA(&state->m_videoram_fg[offset]);
tilemap_mark_tile_dirty(state->m_tilemap_fg, offset);
state->m_tilemap_fg->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( drtomy_vram_bg_w )
{
drtomy_state *state = space->machine().driver_data<drtomy_state>();
COMBINE_DATA(&state->m_videoram_bg[offset]);
tilemap_mark_tile_dirty(state->m_tilemap_bg, offset);
state->m_tilemap_bg->mark_tile_dirty(offset);
}
static WRITE16_DEVICE_HANDLER( drtomy_okibank_w )

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

@ -134,7 +134,7 @@ static WRITE8_HANDLER( drw80pkr_io_w )
state->m_video_ram[n_offs] += ((data & 0xf0) << 4 ); // high address
}
tilemap_mark_tile_dirty(state->m_bg_tilemap, n_offs);
state->m_bg_tilemap->mark_tile_dirty(n_offs);
}
if (state->m_p2 == 0xc7)
@ -340,7 +340,7 @@ static VIDEO_START( drw80pkr )
static SCREEN_UPDATE_IND16( drw80pkr )
{
drw80pkr_state *state = screen.machine().driver_data<drw80pkr_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -122,8 +122,8 @@ static VIDEO_START(dunhuang)
state->m_tmap = tilemap_create(machine, get_tile_info, tilemap_scan_rows, 8,8, 0x40,0x20);
state->m_tmap2 = tilemap_create(machine, get_tile_info2, tilemap_scan_rows, 8,32, 0x40,0x8);
tilemap_set_transparent_pen(state->m_tmap, 0);
tilemap_set_transparent_pen(state->m_tmap2, 0);
state->m_tmap->set_transparent_pen(0);
state->m_tmap2->set_transparent_pen(0);
state->save_item(NAME(state->m_videoram));
state->save_item(NAME(state->m_colorram));
@ -152,16 +152,16 @@ if (screen.machine().input().code_pressed(KEYCODE_Z))
switch (state->m_layers)
{
case 0x04: // girl select: bg over fg
if (layers_ctrl & 2) tilemap_draw(bitmap,cliprect, state->m_tmap2, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) tilemap_draw(bitmap,cliprect, state->m_tmap, 0, 0);
if (layers_ctrl & 2) state->m_tmap2->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) state->m_tmap->draw(bitmap, cliprect, 0, 0);
break;
case 0x05: // dips: must hide fg
if (layers_ctrl & 1) tilemap_draw(bitmap,cliprect, state->m_tmap, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) state->m_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
break;
case 0x07: // game,demo: fg over bg
default:
if (layers_ctrl & 1) tilemap_draw(bitmap,cliprect, state->m_tmap, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 2) tilemap_draw(bitmap,cliprect, state->m_tmap2, 0, 0);
if (layers_ctrl & 1) state->m_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 2) state->m_tmap2->draw(bitmap, cliprect, 0, 0);
break;
}
@ -210,7 +210,7 @@ static WRITE8_HANDLER( dunhuang_tile_w )
case 1: state->m_videoram[addr] = (state->m_videoram[addr] & 0x00ff) | (data<<8); break;
case 2: state->m_colorram[addr] = data; break;
}
tilemap_mark_tile_dirty(state->m_tmap, addr);
state->m_tmap->mark_tile_dirty(addr);
}
static WRITE8_HANDLER( dunhuang_tile2_w )
@ -237,7 +237,7 @@ static WRITE8_HANDLER( dunhuang_tile2_w )
case 1: state->m_videoram2[addr] = (state->m_videoram2[addr] & 0x00ff) | (data<<8); break;
case 2: state->m_colorram2[addr] = data; break;
}
tilemap_mark_tile_dirty(state->m_tmap2, addr);
state->m_tmap2->mark_tile_dirty(addr);
}
// Clear a row of tiles (videoram)
@ -258,7 +258,7 @@ static WRITE8_HANDLER( dunhuang_horiz_clear_w )
state->m_videoram[addr] = 0;
state->m_colorram[addr] = 0;
tilemap_mark_tile_dirty(state->m_tmap, addr);
state->m_tmap->mark_tile_dirty(addr);
}
}
@ -275,7 +275,7 @@ static WRITE8_HANDLER( dunhuang_vert_clear_w )
state->m_videoram2[addr] = 1;
state->m_colorram2[addr] = 0;
tilemap_mark_tile_dirty(state->m_tmap2, addr);
state->m_tmap2->mark_tile_dirty(addr);
}
}
@ -351,7 +351,7 @@ static WRITE8_HANDLER( dunhuang_block_h_w )
state->m_videoram[addr] = (tile_addr[1] << 8) | tile_addr[0];
state->m_colorram[addr] = state->m_block_c;
tilemap_mark_tile_dirty(state->m_tmap, addr);
state->m_tmap->mark_tile_dirty(addr);
tile_addr += 4;
}
}
@ -366,7 +366,7 @@ static WRITE8_HANDLER( dunhuang_block_h_w )
state->m_videoram2[addr] = (tile_addr[1] << 8) | tile_addr[0];
state->m_colorram2[addr] = state->m_block_c;
tilemap_mark_tile_dirty(state->m_tmap2, addr);
state->m_tmap2->mark_tile_dirty(addr);
tile_addr += 4;
}
}

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

@ -62,8 +62,8 @@ static WRITE8_HANDLER( dynadice_videoram_w )
{
dynadice_state *state = space->machine().driver_data<dynadice_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
tilemap_mark_all_tiles_dirty(state->m_top_tilemap);
state->m_bg_tilemap->mark_tile_dirty(offset);
state->m_top_tilemap->mark_all_dirty();
}
static WRITE8_HANDLER( sound_data_w )
@ -203,7 +203,7 @@ static VIDEO_START( dynadice )
/* pacman - style videoram layout */
state->m_bg_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
state->m_top_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_cols, 8, 8, 2, 32);
tilemap_set_scrollx(state->m_bg_tilemap, 0, -16);
state->m_bg_tilemap->set_scrollx(0, -16);
}
static SCREEN_UPDATE_IND16( dynadice )
@ -211,8 +211,8 @@ static SCREEN_UPDATE_IND16( dynadice )
dynadice_state *state = screen.machine().driver_data<dynadice_state>();
rectangle myclip = cliprect;
myclip.max_x = 15;
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
tilemap_draw(bitmap, myclip, state->m_top_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_top_tilemap->draw(bitmap, myclip, 0, 0);
return 0;
}

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

@ -150,7 +150,7 @@ static WRITE8_HANDLER( egghunt_bgram_w )
else
{
state->m_bgram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset / 2);
state->m_bg_tilemap->mark_tile_dirty(offset / 2);
}
}
@ -158,7 +158,7 @@ static WRITE8_HANDLER( egghunt_atram_w )
{
egghunt_state *state = space->machine().driver_data<egghunt_state>();
state->m_atram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -175,7 +175,7 @@ static VIDEO_START(egghunt)
static SCREEN_UPDATE_IND16(egghunt)
{
egghunt_state *state = screen.machine().driver_data<egghunt_state>();
tilemap_draw(bitmap,cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;
}
@ -187,7 +187,7 @@ static WRITE8_HANDLER( egghunt_gfx_banking_w )
// data & 0x30 is used for sprites banking
state->m_gfx_banking = data & 0x33;
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
}
static WRITE8_HANDLER( egghunt_vidram_bank_w )

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

@ -109,7 +109,7 @@ static WRITE16_HANDLER(hedpanic_platform_w)
int offsets = state->m_headpanic_platform_x[0] + 0x40 * state->m_headpanic_platform_y[0];
state->m_vram_1[offsets] = data;
tilemap_mark_tile_dirty(state->m_tilemap_1_16x16, offsets);
state->m_tilemap_1_16x16->mark_tile_dirty(offsets);
}

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

@ -54,20 +54,20 @@ static WRITE8_HANDLER( ettrivia_fg_w )
{
ettrivia_state *state = space->machine().driver_data<ettrivia_state>();
state->m_fg_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( ettrivia_bg_w )
{
ettrivia_state *state = space->machine().driver_data<ettrivia_state>();
state->m_bg_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( ettrivia_control_w )
{
ettrivia_state *state = space->machine().driver_data<ettrivia_state>();
tilemap_mark_all_tiles_dirty_all(space->machine());
space->machine().tilemap().mark_all_dirty();
state->m_palreg = (data >> 1) & 3;
state->m_gfx_bank = (data >> 2) & 1;
@ -188,7 +188,7 @@ static GFXDECODE_START( ettrivia )
GFXDECODE_ENTRY( "gfx2", 0, charlayout, 32*4, 32 )
GFXDECODE_END
INLINE void get_tile_info(running_machine &machine, tile_data *tileinfo, int tile_index, UINT8 *vidram, int gfx_code)
INLINE void get_tile_info(running_machine &machine, tile_data &tileinfo, int tile_index, UINT8 *vidram, int gfx_code)
{
ettrivia_state *state = machine.driver_data<ettrivia_state>();
int code = vidram[tile_index];
@ -253,14 +253,14 @@ static VIDEO_START( ettrivia )
state->m_bg_tilemap = tilemap_create( machine, get_tile_info_bg,tilemap_scan_rows,8,8,64,32 );
state->m_fg_tilemap = tilemap_create( machine, get_tile_info_fg,tilemap_scan_rows,8,8,64,32 );
tilemap_set_transparent_pen(state->m_fg_tilemap,0);
state->m_fg_tilemap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( ettrivia )
{
ettrivia_state *state = screen.machine().driver_data<ettrivia_state>();
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}

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

@ -120,9 +120,9 @@ static void fcrash_update_transmasks( running_machine &machine )
else
mask = 0xffff; /* completely transparent if priority masks not defined (mercs, qad) */
tilemap_set_transmask(state->m_bg_tilemap[0], i, mask, 0x8000);
tilemap_set_transmask(state->m_bg_tilemap[1], i, mask, 0x8000);
tilemap_set_transmask(state->m_bg_tilemap[2], i, mask, 0x8000);
state->m_bg_tilemap[0]->set_transmask(i, mask, 0x8000);
state->m_bg_tilemap[1]->set_transmask(i, mask, 0x8000);
state->m_bg_tilemap[2]->set_transmask(i, mask, 0x8000);
}
}
@ -171,7 +171,7 @@ static void fcrash_render_layer( running_machine &machine, bitmap_ind16 &bitmap,
case 1:
case 2:
case 3:
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap[layer - 1], TILEMAP_DRAW_LAYER1, primask);
state->m_bg_tilemap[layer - 1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, primask);
break;
}
}
@ -189,7 +189,7 @@ static void fcrash_render_high_layer( running_machine &machine, bitmap_ind16 &bi
case 1:
case 2:
case 3:
tilemap_draw(dummy_bitmap, cliprect, state->m_bg_tilemap[layer - 1], TILEMAP_DRAW_LAYER0, 1);
state->m_bg_tilemap[layer - 1]->draw(dummy_bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
break;
}
}
@ -236,8 +236,8 @@ static SCREEN_UPDATE_IND16( fcrash )
fcrash_update_transmasks(screen.machine());
tilemap_set_scrollx(state->m_bg_tilemap[0], 0, state->m_scroll1x - 62);
tilemap_set_scrolly(state->m_bg_tilemap[0], 0, state->m_scroll1y);
state->m_bg_tilemap[0]->set_scrollx(0, state->m_scroll1x - 62);
state->m_bg_tilemap[0]->set_scrolly(0, state->m_scroll1y);
if (videocontrol & 0x01) /* linescroll enable */
{
@ -245,28 +245,28 @@ static SCREEN_UPDATE_IND16( fcrash )
int i;
int otheroffs;
tilemap_set_scroll_rows(state->m_bg_tilemap[1], 1024);
state->m_bg_tilemap[1]->set_scroll_rows(1024);
otheroffs = state->m_cps_a_regs[CPS1_ROWSCROLL_OFFS];
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_bg_tilemap[1], (i - scrly) & 0x3ff, state->m_scroll2x + state->m_other[(i + otheroffs) & 0x3ff]);
state->m_bg_tilemap[1]->set_scrollx((i - scrly) & 0x3ff, state->m_scroll2x + state->m_other[(i + otheroffs) & 0x3ff]);
}
else
{
tilemap_set_scroll_rows(state->m_bg_tilemap[1], 1);
tilemap_set_scrollx(state->m_bg_tilemap[1], 0, state->m_scroll2x - 60);
state->m_bg_tilemap[1]->set_scroll_rows(1);
state->m_bg_tilemap[1]->set_scrollx(0, state->m_scroll2x - 60);
}
tilemap_set_scrolly(state->m_bg_tilemap[1], 0, state->m_scroll2y);
tilemap_set_scrollx(state->m_bg_tilemap[2], 0, state->m_scroll3x - 64);
tilemap_set_scrolly(state->m_bg_tilemap[2], 0, state->m_scroll3y);
state->m_bg_tilemap[1]->set_scrolly(0, state->m_scroll2y);
state->m_bg_tilemap[2]->set_scrollx(0, state->m_scroll3x - 64);
state->m_bg_tilemap[2]->set_scrolly(0, state->m_scroll3y);
/* turn all tilemaps on regardless of settings in get_video_base() */
/* write a custom get_video_base for this bootleg hardware? */
tilemap_set_enable(state->m_bg_tilemap[0], 1);
tilemap_set_enable(state->m_bg_tilemap[1], 1);
tilemap_set_enable(state->m_bg_tilemap[2], 1);
state->m_bg_tilemap[0]->enable(1);
state->m_bg_tilemap[1]->enable(1);
state->m_bg_tilemap[2]->enable(1);
/* Blank screen */
bitmap.fill(0xbff, cliprect);
@ -316,8 +316,8 @@ static SCREEN_UPDATE_IND16( kodb )
fcrash_update_transmasks(screen.machine());
tilemap_set_scrollx(state->m_bg_tilemap[0], 0, state->m_scroll1x);
tilemap_set_scrolly(state->m_bg_tilemap[0], 0, state->m_scroll1y);
state->m_bg_tilemap[0]->set_scrollx(0, state->m_scroll1x);
state->m_bg_tilemap[0]->set_scrolly(0, state->m_scroll1y);
if (videocontrol & 0x01) /* linescroll enable */
{
@ -325,29 +325,29 @@ static SCREEN_UPDATE_IND16( kodb )
int i;
int otheroffs;
tilemap_set_scroll_rows(state->m_bg_tilemap[1], 1024);
state->m_bg_tilemap[1]->set_scroll_rows(1024);
otheroffs = state->m_cps_a_regs[CPS1_ROWSCROLL_OFFS];
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_bg_tilemap[1], (i - scrly) & 0x3ff, state->m_scroll2x + state->m_other[(i + otheroffs) & 0x3ff]);
state->m_bg_tilemap[1]->set_scrollx((i - scrly) & 0x3ff, state->m_scroll2x + state->m_other[(i + otheroffs) & 0x3ff]);
}
else
{
tilemap_set_scroll_rows(state->m_bg_tilemap[1], 1);
tilemap_set_scrollx(state->m_bg_tilemap[1], 0, state->m_scroll2x);
state->m_bg_tilemap[1]->set_scroll_rows(1);
state->m_bg_tilemap[1]->set_scrollx(0, state->m_scroll2x);
}
tilemap_set_scrolly(state->m_bg_tilemap[1], 0, state->m_scroll2y);
tilemap_set_scrollx(state->m_bg_tilemap[2], 0, state->m_scroll3x);
tilemap_set_scrolly(state->m_bg_tilemap[2], 0, state->m_scroll3y);
state->m_bg_tilemap[1]->set_scrolly(0, state->m_scroll2y);
state->m_bg_tilemap[2]->set_scrollx(0, state->m_scroll3x);
state->m_bg_tilemap[2]->set_scrolly(0, state->m_scroll3y);
/* turn all tilemaps on regardless of settings in get_video_base() */
/* write a custom get_video_base for this bootleg hardware? */
tilemap_set_enable(state->m_bg_tilemap[0], 1);
tilemap_set_enable(state->m_bg_tilemap[1], 1);
tilemap_set_enable(state->m_bg_tilemap[2], 1);
state->m_bg_tilemap[0]->enable(1);
state->m_bg_tilemap[1]->enable(1);
state->m_bg_tilemap[2]->enable(1);
/* Blank screen */
bitmap.fill(0xbff, cliprect);

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

@ -171,7 +171,7 @@ static WRITE8_HANDLER( tileram_w )
{
firefox_state *state = space->machine().driver_data<firefox_state>();
state->m_tileram[offset] = data;
tilemap_mark_tile_dirty(state->m_bgtiles, offset);
state->m_bgtiles->mark_tile_dirty(offset);
}
@ -179,8 +179,8 @@ static VIDEO_START( firefox )
{
firefox_state *state = machine.driver_data<firefox_state>();
state->m_bgtiles = tilemap_create(machine, bgtile_get_info, tilemap_scan_rows, 8,8, 64,64);
tilemap_set_transparent_pen(state->m_bgtiles, 0);
tilemap_set_scrolldy(state->m_bgtiles, machine.primary_screen->visible_area().min_y, 0);
state->m_bgtiles->set_transparent_pen(0);
state->m_bgtiles->set_scrolldy(machine.primary_screen->visible_area().min_y, 0);
}
@ -215,7 +215,7 @@ static SCREEN_UPDATE_RGB32( firefox )
}
}
tilemap_draw( bitmap, cliprect, state->m_bgtiles, 0, 0 );
state->m_bgtiles->draw(bitmap, cliprect, 0, 0 );
return 0;
}

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

@ -95,10 +95,10 @@ static SCREEN_UPDATE_IND16( flyball )
int x;
int y;
tilemap_mark_all_tiles_dirty(state->m_tmap);
state->m_tmap->mark_all_dirty();
/* draw playfield */
tilemap_draw(bitmap, cliprect, state->m_tmap, 0, 0);
state->m_tmap->draw(bitmap, cliprect, 0, 0);
/* draw pitcher */
drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[1], state->m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1);

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

@ -80,7 +80,7 @@ static WRITE16_HANDLER( gaelco_vram_encrypted_w )
data = gaelco_decrypt(space, offset, data, 0x0f, 0x4228);
COMBINE_DATA(&state->m_videoram[offset]);
tilemap_mark_tile_dirty(state->m_tilemap[offset >> 11], ((offset << 1) & 0x0fff) >> 2);
state->m_tilemap[offset >> 11]->mark_tile_dirty(((offset << 1) & 0x0fff) >> 2);
}
@ -103,7 +103,7 @@ static WRITE16_HANDLER( thoop_vram_encrypted_w )
data = gaelco_decrypt(space, offset, data, 0x0e, 0x4228);
COMBINE_DATA(&state->m_videoram[offset]);
tilemap_mark_tile_dirty(state->m_tilemap[offset >> 11], ((offset << 1) & 0x0fff) >> 2);
state->m_tilemap[offset >> 11]->mark_tile_dirty(((offset << 1) & 0x0fff) >> 2);
}
static WRITE16_HANDLER(thoop_encrypted_w)

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

@ -117,35 +117,35 @@ static WRITE16_HANDLER( galaxi_bg1_w )
{
galaxi_state *state = space->machine().driver_data<galaxi_state>();
COMBINE_DATA(&state->m_bg1_ram[offset]);
tilemap_mark_tile_dirty(state->m_bg1_tmap, offset);
state->m_bg1_tmap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( galaxi_bg2_w )
{
galaxi_state *state = space->machine().driver_data<galaxi_state>();
COMBINE_DATA(&state->m_bg2_ram[offset]);
tilemap_mark_tile_dirty(state->m_bg2_tmap, offset);
state->m_bg2_tmap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( galaxi_bg3_w )
{
galaxi_state *state = space->machine().driver_data<galaxi_state>();
COMBINE_DATA(&state->m_bg3_ram[offset]);
tilemap_mark_tile_dirty(state->m_bg3_tmap, offset);
state->m_bg3_tmap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( galaxi_bg4_w )
{
galaxi_state *state = space->machine().driver_data<galaxi_state>();
COMBINE_DATA(&state->m_bg4_ram[offset]);
tilemap_mark_tile_dirty(state->m_bg4_tmap, offset);
state->m_bg4_tmap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( galaxi_fg_w )
{
galaxi_state *state = space->machine().driver_data<galaxi_state>();
COMBINE_DATA(&state->m_fg_ram[offset]);
tilemap_mark_tile_dirty(state->m_fg_tmap, offset);
state->m_fg_tmap->mark_tile_dirty(offset);
}
static VIDEO_START(galaxi)
@ -159,14 +159,14 @@ static VIDEO_START(galaxi)
state->m_fg_tmap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 0x40, 0x20);
tilemap_set_transparent_pen(state->m_bg1_tmap, 0);
tilemap_set_transparent_pen(state->m_bg2_tmap, 0);
tilemap_set_transparent_pen(state->m_bg3_tmap, 0);
tilemap_set_transparent_pen(state->m_bg4_tmap, 0);
state->m_bg1_tmap->set_transparent_pen(0);
state->m_bg2_tmap->set_transparent_pen(0);
state->m_bg3_tmap->set_transparent_pen(0);
state->m_bg4_tmap->set_transparent_pen(0);
tilemap_set_transparent_pen(state->m_fg_tmap, 0);
state->m_fg_tmap->set_transparent_pen(0);
tilemap_set_scrolldx(state->m_bg3_tmap, -8, 0);
state->m_bg3_tmap->set_scrolldx(-8, 0);
}
static SCREEN_UPDATE_IND16(galaxi)
@ -187,13 +187,13 @@ static SCREEN_UPDATE_IND16(galaxi)
}
#endif
if (layers_ctrl & 1) tilemap_draw(bitmap, cliprect, state->m_bg1_tmap, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) state->m_bg1_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
else bitmap.fill(get_black_pen(screen.machine()), cliprect);
if (layers_ctrl & 2) tilemap_draw(bitmap, cliprect, state->m_bg2_tmap, 0, 0);
if (layers_ctrl & 4) tilemap_draw(bitmap, cliprect, state->m_bg3_tmap, 0, 0);
if (layers_ctrl & 8) tilemap_draw(bitmap, cliprect, state->m_bg4_tmap, 0, 0);
if (layers_ctrl & 2) state->m_bg2_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 4) state->m_bg3_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 8) state->m_bg4_tmap->draw(bitmap, cliprect, 0, 0);
if (layers_ctrl & 16) tilemap_draw(bitmap, cliprect, state->m_fg_tmap, 0, 0);
if (layers_ctrl & 16) state->m_fg_tmap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -32,7 +32,7 @@ static WRITE8_HANDLER( goindol_bankswitch_w )
if (state->m_char_bank != ((data & 0x10) >> 4))
{
state->m_char_bank = (data & 0x10) >> 4;
tilemap_mark_all_tiles_dirty_all(space->machine());
space->machine().tilemap().mark_all_dirty();
}
flip_screen_set(space->machine(), data & 0x20);

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

@ -739,14 +739,14 @@ static WRITE8_HANDLER( goldnpkr_videoram_w )
{
goldnpkr_state *state = space->machine().driver_data<goldnpkr_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( goldnpkr_colorram_w )
{
goldnpkr_state *state = space->machine().driver_data<goldnpkr_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_bg_tile_info )
@ -803,7 +803,7 @@ static VIDEO_START( wcrdxtnd )
static SCREEN_UPDATE_IND16( goldnpkr )
{
goldnpkr_state *state = screen.machine().driver_data<goldnpkr_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -396,7 +396,7 @@ static WRITE8_HANDLER( magodds_outb850_w )
//popmessage("magodds_outb850_w %02x\n", data);
tilemap_mark_all_tiles_dirty (state->m_fg_tilemap);
state->m_fg_tilemap->mark_all_dirty();
}

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

@ -57,7 +57,7 @@ static WRITE16_HANDLER( fg_tilemapram_w )
{
good_state *state = space->machine().driver_data<good_state>();
COMBINE_DATA(&state->m_fg_tilemapram[offset]);
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset / 2);
state->m_fg_tilemap->mark_tile_dirty(offset / 2);
}
static TILE_GET_INFO( get_fg_tile_info )
@ -72,7 +72,7 @@ static WRITE16_HANDLER( bg_tilemapram_w )
{
good_state *state = space->machine().driver_data<good_state>();
COMBINE_DATA(&state->m_bg_tilemapram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset / 2);
state->m_bg_tilemap->mark_tile_dirty(offset / 2);
}
static TILE_GET_INFO( get_bg_tile_info )
@ -90,14 +90,14 @@ static VIDEO_START( good )
good_state *state = machine.driver_data<good_state>();
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 16, 16, 32, 32);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 16, 16, 32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0xf);
state->m_fg_tilemap->set_transparent_pen(0xf);
}
static SCREEN_UPDATE_IND16( good )
{
good_state *state = screen.machine().driver_data<good_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -216,15 +216,15 @@ static WRITE32_HANDLER( gstream_vram_w )
{
if (offset >= 0x000 / 4 && offset < 0x400 / 4)
{
tilemap_mark_tile_dirty(state->m_tilemap1, offset - (0x000 / 4));
state->m_tilemap1->mark_tile_dirty(offset - (0x000 / 4));
}
else if (offset >= 0x400 / 4 && offset < 0x800 / 4)
{
tilemap_mark_tile_dirty(state->m_tilemap2, offset - (0x400 / 4));
state->m_tilemap2->mark_tile_dirty(offset - (0x400 / 4));
}
else if (offset >= 0x800 / 4 && offset < 0xc00 / 4)
{
tilemap_mark_tile_dirty(state->m_tilemap3, offset - (0x800 / 4));
state->m_tilemap3->mark_tile_dirty(offset - (0x800 / 4));
}
}
}
@ -469,8 +469,8 @@ static VIDEO_START(gstream)
state->m_tilemap2 = tilemap_create(machine, get_gs2_tile_info, tilemap_scan_rows, 32, 32, 16, 16);
state->m_tilemap3 = tilemap_create(machine, get_gs3_tile_info, tilemap_scan_rows, 32, 32, 16, 16);
tilemap_set_transparent_pen(state->m_tilemap1, 0);
tilemap_set_transparent_pen(state->m_tilemap2, 0);
state->m_tilemap1->set_transparent_pen(0);
state->m_tilemap2->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16(gstream)
@ -494,18 +494,18 @@ static SCREEN_UPDATE_IND16(gstream)
//popmessage("(1) %08x %08x (2) %08x %08x (3) %08x %08x", state->m_tmap1_scrollx, state->m_tmap1_scrolly, state->m_tmap2_scrollx, state->m_tmap2_scrolly, state->m_tmap3_scrollx, state->m_tmap3_scrolly );
tilemap_set_scrollx(state->m_tilemap3, 0, state->m_tmap3_scrollx >> 16);
tilemap_set_scrolly(state->m_tilemap3, 0, state->m_tmap3_scrolly >> 16);
state->m_tilemap3->set_scrollx(0, state->m_tmap3_scrollx >> 16);
state->m_tilemap3->set_scrolly(0, state->m_tmap3_scrolly >> 16);
tilemap_set_scrollx(state->m_tilemap1, 0, state->m_tmap1_scrollx >> 16);
tilemap_set_scrolly(state->m_tilemap1, 0, state->m_tmap1_scrolly >> 16);
state->m_tilemap1->set_scrollx(0, state->m_tmap1_scrollx >> 16);
state->m_tilemap1->set_scrolly(0, state->m_tmap1_scrolly >> 16);
tilemap_set_scrollx(state->m_tilemap2, 0, state->m_tmap2_scrollx >> 16);
tilemap_set_scrolly(state->m_tilemap2, 0, state->m_tmap2_scrolly >> 16);
state->m_tilemap2->set_scrollx(0, state->m_tmap2_scrollx >> 16);
state->m_tilemap2->set_scrolly(0, state->m_tmap2_scrolly >> 16);
tilemap_draw(bitmap, cliprect, state->m_tilemap3, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_tilemap2, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_tilemap1, 0, 0);
state->m_tilemap3->draw(bitmap, cliprect, 0, 0);
state->m_tilemap2->draw(bitmap, cliprect, 0, 0);
state->m_tilemap1->draw(bitmap, cliprect, 0, 0);
for (i = 0x0000 / 4; i < 0x4000 / 4; i += 4)
{

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

@ -44,7 +44,7 @@ static WRITE8_HANDLER( hitme_vidram_w )
/* mark this tile dirty */
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_tilemap, offset);
state->m_tilemap->mark_tile_dirty(offset);
}
@ -84,7 +84,7 @@ static SCREEN_UPDATE_IND16( hitme )
offs_t offs = 0;
/* start by drawing the tilemap */
tilemap_draw(bitmap, cliprect, state->m_tilemap, 0, 0);
state->m_tilemap->draw(bitmap, cliprect, 0, 0);
/* now loop over and invert anything */
for (y = 0; y < 19; y++)
@ -120,7 +120,7 @@ static SCREEN_UPDATE_IND16( hitme )
static SCREEN_UPDATE_IND16( barricad )
{
hitme_state *state = screen.machine().driver_data<hitme_state>();
tilemap_draw(bitmap, cliprect, state->m_tilemap, 0, 0);
state->m_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -160,10 +160,10 @@ static SCREEN_UPDATE_IND16( hvyunit )
#define SY_POS 0
hvyunit_state *state = screen.machine().driver_data<hvyunit_state>();
tilemap_set_scrollx(state->m_bg_tilemap, 0, ((state->m_port0_data & 0x40) << 2) + state->m_scrollx + SX_POS); // TODO
tilemap_set_scrolly(state->m_bg_tilemap, 0, ((state->m_port0_data & 0x80) << 1) + state->m_scrolly + SY_POS); // TODO
state->m_bg_tilemap->set_scrollx(0, ((state->m_port0_data & 0x40) << 2) + state->m_scrollx + SX_POS); // TODO
state->m_bg_tilemap->set_scrolly(0, ((state->m_port0_data & 0x80) << 1) + state->m_scrolly + SY_POS); // TODO
bitmap.fill(get_black_pen(screen.machine()), cliprect);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
pandora_update(state->m_pandora, bitmap, cliprect);
return 0;
@ -245,7 +245,7 @@ static WRITE8_HANDLER( hu_videoram_w )
hvyunit_state *state = space->machine().driver_data<hvyunit_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( hu_colorram_w )
@ -253,7 +253,7 @@ static WRITE8_HANDLER( hu_colorram_w )
hvyunit_state *state = space->machine().driver_data<hvyunit_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( slave_bankswitch_w )

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

@ -60,7 +60,7 @@ static WRITE8_HANDLER( gp98_reel1_ram_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_gp98_reel1_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_gp98_reel1_tilemap,offset);
state->m_gp98_reel1_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel1_tile_info )
@ -93,7 +93,7 @@ static WRITE8_HANDLER( gp98_reel2_ram_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_gp98_reel2_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_gp98_reel2_tilemap,offset);
state->m_gp98_reel2_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel2_tile_info )
@ -126,7 +126,7 @@ static WRITE8_HANDLER( gp98_reel3_ram_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_gp98_reel3_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_gp98_reel3_tilemap,offset);
state->m_gp98_reel3_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel3_tile_info )
@ -159,7 +159,7 @@ static WRITE8_HANDLER( gp98_reel4_ram_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_gp98_reel4_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_gp98_reel4_tilemap,offset);
state->m_gp98_reel4_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jingbell_reel4_tile_info )
@ -196,7 +196,7 @@ static WRITE8_HANDLER( bg_scroll_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_bg_scroll[offset] = data;
// tilemap_set_scrolly(bg_tilemap,offset,data);
// bg_tilemap->set_scrolly(offset,data);
}
@ -211,31 +211,31 @@ static WRITE8_HANDLER( fg_tile_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_fg_tile_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fg_color_w )
{
igs009_state *state = space->machine().driver_data<igs009_state>();
state->m_fg_color_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static VIDEO_START(jingbell)
{
igs009_state *state = machine.driver_data<igs009_state>();
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 0x80,0x20);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
state->m_gp98_reel1_tilemap = tilemap_create(machine,get_jingbell_reel1_tile_info,tilemap_scan_rows,8,32, 128, 8);
state->m_gp98_reel2_tilemap = tilemap_create(machine,get_jingbell_reel2_tile_info,tilemap_scan_rows,8,32, 128, 8);
state->m_gp98_reel3_tilemap = tilemap_create(machine,get_jingbell_reel3_tile_info,tilemap_scan_rows,8,32, 128, 8);
state->m_gp98_reel4_tilemap = tilemap_create(machine,get_jingbell_reel4_tile_info,tilemap_scan_rows,8,32, 128, 8);
tilemap_set_scroll_cols(state->m_gp98_reel1_tilemap, 128);
tilemap_set_scroll_cols(state->m_gp98_reel2_tilemap, 128);
tilemap_set_scroll_cols(state->m_gp98_reel3_tilemap, 128);
tilemap_set_scroll_cols(state->m_gp98_reel4_tilemap, 128);
state->m_gp98_reel1_tilemap->set_scroll_cols(128);
state->m_gp98_reel2_tilemap->set_scroll_cols(128);
state->m_gp98_reel3_tilemap->set_scroll_cols(128);
state->m_gp98_reel4_tilemap->set_scroll_cols(128);
}
@ -243,17 +243,17 @@ static VIDEO_START(gp98)
{
igs009_state *state = machine.driver_data<igs009_state>();
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 0x80,0x20);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
state->m_gp98_reel1_tilemap = tilemap_create(machine,get_gp98_reel1_tile_info,tilemap_scan_rows,8,32, 128, 8);
state->m_gp98_reel2_tilemap = tilemap_create(machine,get_gp98_reel2_tile_info,tilemap_scan_rows,8,32, 128, 8);
state->m_gp98_reel3_tilemap = tilemap_create(machine,get_gp98_reel3_tile_info,tilemap_scan_rows,8,32, 128, 8);
state->m_gp98_reel4_tilemap = tilemap_create(machine,get_gp98_reel4_tile_info,tilemap_scan_rows,8,32, 128, 8);
tilemap_set_scroll_cols(state->m_gp98_reel1_tilemap, 128);
tilemap_set_scroll_cols(state->m_gp98_reel2_tilemap, 128);
tilemap_set_scroll_cols(state->m_gp98_reel3_tilemap, 128);
tilemap_set_scroll_cols(state->m_gp98_reel4_tilemap, 128);
state->m_gp98_reel1_tilemap->set_scroll_cols(128);
state->m_gp98_reel2_tilemap->set_scroll_cols(128);
state->m_gp98_reel3_tilemap->set_scroll_cols(128);
state->m_gp98_reel4_tilemap->set_scroll_cols(128);
}
@ -283,10 +283,10 @@ static SCREEN_UPDATE_IND16(jingbell)
for (i= 0;i < 0x80;i++)
{
tilemap_set_scrolly(state->m_gp98_reel1_tilemap, i, state->m_bg_scroll[i]*2);
tilemap_set_scrolly(state->m_gp98_reel2_tilemap, i, state->m_bg_scroll[i+0x80]*2);
tilemap_set_scrolly(state->m_gp98_reel3_tilemap, i, state->m_bg_scroll[i+0x100]*2);
tilemap_set_scrolly(state->m_gp98_reel4_tilemap, i, state->m_bg_scroll[i+0x180]*2);
state->m_gp98_reel1_tilemap->set_scrolly(i, state->m_bg_scroll[i]*2);
state->m_gp98_reel2_tilemap->set_scrolly(i, state->m_bg_scroll[i+0x80]*2);
state->m_gp98_reel3_tilemap->set_scrolly(i, state->m_bg_scroll[i+0x100]*2);
state->m_gp98_reel4_tilemap->set_scrolly(i, state->m_bg_scroll[i+0x180]*2);
}
@ -304,19 +304,19 @@ static SCREEN_UPDATE_IND16(jingbell)
if (rowenable==0)
{ // 0 and 1 are the same? or is there a global switchoff?
tilemap_draw(bitmap,clip,state->m_gp98_reel1_tilemap,0,0);
state->m_gp98_reel1_tilemap->draw(bitmap, clip, 0,0);
}
else if (rowenable==1)
{
tilemap_draw(bitmap,clip,state->m_gp98_reel2_tilemap,0,0);
state->m_gp98_reel2_tilemap->draw(bitmap, clip, 0,0);
}
else if (rowenable==2)
{
tilemap_draw(bitmap,clip,state->m_gp98_reel3_tilemap,0,0);
state->m_gp98_reel3_tilemap->draw(bitmap, clip, 0,0);
}
else if (rowenable==3)
{
tilemap_draw(bitmap,clip,state->m_gp98_reel4_tilemap,0,0);
state->m_gp98_reel4_tilemap->draw(bitmap, clip, 0,0);
}
@ -327,7 +327,7 @@ static SCREEN_UPDATE_IND16(jingbell)
else bitmap.fill(get_black_pen(screen.machine()), cliprect);
if (layers_ctrl & 2) tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
if (layers_ctrl & 2) state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -128,14 +128,14 @@ static WRITE8_HANDLER( fg_w )
{
igs017_state *state = space->machine().driver_data<igs017_state>();
state->m_fg_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset/4);
state->m_fg_tilemap->mark_tile_dirty(offset/4);
}
static WRITE8_HANDLER( bg_w )
{
igs017_state *state = space->machine().driver_data<igs017_state>();
state->m_bg_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset/4);
state->m_bg_tilemap->mark_tile_dirty(offset/4);
}
// 16-bit handlers for an 8-bit chip
@ -204,8 +204,8 @@ static VIDEO_START( igs017 )
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,tilemap_scan_rows,8,8,64,32);
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,tilemap_scan_rows,8,8,64,32);
tilemap_set_transparent_pen(state->m_fg_tilemap,0xf);
tilemap_set_transparent_pen(state->m_bg_tilemap,0xf);
state->m_fg_tilemap->set_transparent_pen(0xf);
state->m_bg_tilemap->set_transparent_pen(0xf);
state->m_toggle = 0;
state->m_debug_addr = 0;
@ -368,11 +368,11 @@ static SCREEN_UPDATE_IND16( igs017 )
if (state->m_video_disable)
return 0;
if (layers_ctrl & 1) tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 1) state->m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
if (layers_ctrl & 4) draw_sprites(screen.machine(), bitmap, cliprect);
if (layers_ctrl & 2) tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
if (layers_ctrl & 2) state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -100,7 +100,7 @@ static WRITE32_HANDLER( igs_tx_videoram_w )
{
igs_m027_state *state = space->machine().driver_data<igs_m027_state>();
COMBINE_DATA(&state->m_igs_tx_videoram[offset]);
tilemap_mark_tile_dirty(state->m_igs_tx_tilemap,offset);
state->m_igs_tx_tilemap->mark_tile_dirty(offset);
//if(data!=0)
//logerror( "TX VIDEO RAM OFFSET %x ,data %x!\n",offset ,state->m_igs_tx_videoram[offset]);
}
@ -121,7 +121,7 @@ static WRITE32_HANDLER( igs_bg_videoram_w )
{
igs_m027_state *state = space->machine().driver_data<igs_m027_state>();
COMBINE_DATA(&state->m_igs_bg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_igs_bg_tilemap,offset);
state->m_igs_bg_tilemap->mark_tile_dirty(offset);
//if(data!=0)
logerror("BG VIDEO RAM OFFSET %x ,data %x!\n",offset ,state->m_igs_bg_videoram[offset]);
}
@ -156,10 +156,10 @@ static VIDEO_START(igs_majhong)
{
igs_m027_state *state = machine.driver_data<igs_m027_state>();
state->m_igs_tx_tilemap= tilemap_create(machine, get_tx_tilemap_tile_info,tilemap_scan_rows, 8, 8,64,32);
tilemap_set_transparent_pen(state->m_igs_tx_tilemap,15);
state->m_igs_tx_tilemap->set_transparent_pen(15);
state->m_igs_bg_tilemap= tilemap_create(machine, get_bg_tilemap_tile_info,tilemap_scan_rows, 8, 8,64,32);
//state->m_igs_bg_tilemap= tilemap_create(machine, get_bg_tilemap_tile_info,tilemap_scan_rows, 8, 8,64,32);
//tilemap_set_transparent_pen(state->m_igs_bg_tilemap,15);
//state->m_igs_bg_tilemap->set_transparent_pen(15);
logerror("Video START OK!\n");
}
@ -170,12 +170,12 @@ static SCREEN_UPDATE_IND16(igs_majhong)
bitmap.fill(get_black_pen(screen.machine()), cliprect);
//??????
tilemap_draw(bitmap,cliprect,state->m_igs_bg_tilemap,0,0);
state->m_igs_bg_tilemap->draw(bitmap, cliprect, 0,0);
//CG??????
//??????
tilemap_draw(bitmap,cliprect,state->m_igs_tx_tilemap,0,0);
state->m_igs_tx_tilemap->draw(bitmap, cliprect, 0,0);
//fprintf(stdout,"Video UPDATE OK!\n");
return 0;
}

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

@ -151,21 +151,21 @@ static WRITE8_HANDLER( bg_tile_w )
{
igspoker_state *state = space->machine().driver_data<igspoker_state>();
state->m_bg_tile_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fg_tile_w )
{
igspoker_state *state = space->machine().driver_data<igspoker_state>();
state->m_fg_tile_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fg_color_w )
{
igspoker_state *state = space->machine().driver_data<igspoker_state>();
state->m_fg_color_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static VIDEO_START(igs_video)
@ -174,7 +174,7 @@ static VIDEO_START(igs_video)
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 64, 32);
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 32, 64, 8);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16(igs_video)
@ -183,9 +183,9 @@ static SCREEN_UPDATE_IND16(igs_video)
bitmap.fill(get_black_pen(screen.machine()), cliprect);
// FIX: CSK227IT must have some way to disable background, or wrong gfx?
if (state->m_bg_enable) tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
if (state->m_bg_enable) state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -199,7 +199,7 @@ static VIDEO_START(cpokerpk)
static SCREEN_UPDATE_IND16(cpokerpk)
{
igspoker_state *state = screen.machine().driver_data<igspoker_state>();
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -93,14 +93,14 @@ static WRITE8_HANDLER( fg_tile_w )
{
jackie_state *state = space->machine().driver_data<jackie_state>();
state->m_fg_tile_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( fg_color_w )
{
jackie_state *state = space->machine().driver_data<jackie_state>();
state->m_fg_color_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
@ -117,7 +117,7 @@ static WRITE8_HANDLER( jackie_reel1_ram_w )
{
jackie_state *state = space->machine().driver_data<jackie_state>();
state->m_reel1_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel1_tilemap,offset);
state->m_reel1_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jackie_reel1_tile_info )
@ -133,7 +133,7 @@ static WRITE8_HANDLER( jackie_reel2_ram_w )
{
jackie_state *state = space->machine().driver_data<jackie_state>();
state->m_reel2_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel2_tilemap,offset);
state->m_reel2_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jackie_reel2_tile_info )
@ -148,7 +148,7 @@ static WRITE8_HANDLER( jackie_reel3_ram_w )
{
jackie_state *state = space->machine().driver_data<jackie_state>();
state->m_reel3_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel3_tilemap,offset);
state->m_reel3_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_jackie_reel3_tile_info )
@ -165,12 +165,12 @@ static VIDEO_START(jackie)
state->m_reel2_tilemap = tilemap_create(machine,get_jackie_reel2_tile_info,tilemap_scan_rows,8,32, 64, 8);
state->m_reel3_tilemap = tilemap_create(machine,get_jackie_reel3_tile_info,tilemap_scan_rows,8,32, 64, 8);
tilemap_set_scroll_cols(state->m_reel1_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel2_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel3_tilemap, 64);
state->m_reel1_tilemap->set_scroll_cols(64);
state->m_reel2_tilemap->set_scroll_cols(64);
state->m_reel3_tilemap->set_scroll_cols(64);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 64, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
}
@ -185,9 +185,9 @@ static SCREEN_UPDATE_IND16(jackie)
for (i=0;i < 0x40;i++)
{
tilemap_set_scrolly(state->m_reel1_tilemap, i, state->m_bg_scroll[i+0x000]);
tilemap_set_scrolly(state->m_reel2_tilemap, i, state->m_bg_scroll[i+0x040]);
tilemap_set_scrolly(state->m_reel3_tilemap, i, state->m_bg_scroll[i+0x080]);
state->m_reel1_tilemap->set_scrolly(i, state->m_bg_scroll[i+0x000]);
state->m_reel2_tilemap->set_scrolly(i, state->m_bg_scroll[i+0x040]);
state->m_reel3_tilemap->set_scrolly(i, state->m_bg_scroll[i+0x080]);
}
for (j=0; j < 0x100-1; j++)
@ -200,15 +200,15 @@ static SCREEN_UPDATE_IND16(jackie)
if (rowenable==0)
{
tilemap_draw(bitmap,clip,state->m_reel1_tilemap,0,0);
state->m_reel1_tilemap->draw(bitmap, clip, 0,0);
}
else if (rowenable==1)
{
tilemap_draw(bitmap,clip,state->m_reel2_tilemap,0,0);
state->m_reel2_tilemap->draw(bitmap, clip, 0,0);
}
else if (rowenable==2)
{
tilemap_draw(bitmap,clip,state->m_reel3_tilemap,0,0);
state->m_reel3_tilemap->draw(bitmap, clip, 0,0);
}
else if (rowenable==3)
{
@ -217,7 +217,7 @@ static SCREEN_UPDATE_IND16(jackie)
startclipmin+=1;
}
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -278,25 +278,25 @@ static VIDEO_START( jalmah )
state->m_jm_scrollram = auto_alloc_array(machine, UINT16, 0x80/2);
state->m_jm_vregs = auto_alloc_array(machine, UINT16, 0x40/2);
tilemap_set_transparent_pen(state->m_sc0_tilemap_0,15);
tilemap_set_transparent_pen(state->m_sc0_tilemap_1,15);
tilemap_set_transparent_pen(state->m_sc0_tilemap_2,15);
tilemap_set_transparent_pen(state->m_sc0_tilemap_3,15);
state->m_sc0_tilemap_0->set_transparent_pen(15);
state->m_sc0_tilemap_1->set_transparent_pen(15);
state->m_sc0_tilemap_2->set_transparent_pen(15);
state->m_sc0_tilemap_3->set_transparent_pen(15);
tilemap_set_transparent_pen(state->m_sc1_tilemap_0,15);
tilemap_set_transparent_pen(state->m_sc1_tilemap_1,15);
tilemap_set_transparent_pen(state->m_sc1_tilemap_2,15);
tilemap_set_transparent_pen(state->m_sc1_tilemap_3,15);
state->m_sc1_tilemap_0->set_transparent_pen(15);
state->m_sc1_tilemap_1->set_transparent_pen(15);
state->m_sc1_tilemap_2->set_transparent_pen(15);
state->m_sc1_tilemap_3->set_transparent_pen(15);
tilemap_set_transparent_pen(state->m_sc2_tilemap_0,15);
tilemap_set_transparent_pen(state->m_sc2_tilemap_1,15);
tilemap_set_transparent_pen(state->m_sc2_tilemap_2,15);
tilemap_set_transparent_pen(state->m_sc2_tilemap_3,15);
state->m_sc2_tilemap_0->set_transparent_pen(15);
state->m_sc2_tilemap_1->set_transparent_pen(15);
state->m_sc2_tilemap_2->set_transparent_pen(15);
state->m_sc2_tilemap_3->set_transparent_pen(15);
tilemap_set_transparent_pen(state->m_sc3_tilemap_0,15);
//tilemap_set_transparent_pen(state->m_sc3_tilemap_1,15);
tilemap_set_transparent_pen(state->m_sc3_tilemap_2,15);
tilemap_set_transparent_pen(state->m_sc3_tilemap_3,15);
state->m_sc3_tilemap_0->set_transparent_pen(15);
//state->m_sc3_tilemap_1->set_transparent_pen(15);
state->m_sc3_tilemap_2->set_transparent_pen(15);
state->m_sc3_tilemap_3->set_transparent_pen(15);
}
static VIDEO_START( urashima )
@ -308,8 +308,8 @@ static VIDEO_START( urashima )
state->m_jm_scrollram = auto_alloc_array(machine, UINT16, 0x80/2);
state->m_jm_vregs = auto_alloc_array(machine, UINT16, 0x40/2);
tilemap_set_transparent_pen(state->m_sc0_tilemap_0,15);
tilemap_set_transparent_pen(state->m_sc3_tilemap_0,15);
state->m_sc0_tilemap_0->set_transparent_pen(15);
state->m_sc3_tilemap_0->set_transparent_pen(15);
}
@ -352,10 +352,10 @@ static void draw_sc0_layer(running_machine &machine, bitmap_ind16 &bitmap, const
jalmah_state *state = machine.driver_data<jalmah_state>();
switch(state->m_jm_vregs[0] & 3)
{
case 0: tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap_0,0,0); break;
case 1: tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap_1,0,0); break;
case 2: tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap_2,0,0); break;
case 3: tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap_3,0,0); break;
case 0: state->m_sc0_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: state->m_sc0_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc0_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc0_tilemap_3->draw(bitmap, cliprect, 0,0); break;
}
}
@ -364,10 +364,10 @@ static void draw_sc1_layer(running_machine &machine, bitmap_ind16 &bitmap, const
jalmah_state *state = machine.driver_data<jalmah_state>();
switch(state->m_jm_vregs[1] & 3)
{
case 0: tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap_0,0,0); break;
case 1: tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap_1,0,0); break;
case 2: tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap_2,0,0); break;
case 3: tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap_3,0,0); break;
case 0: state->m_sc1_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: state->m_sc1_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc1_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc1_tilemap_3->draw(bitmap, cliprect, 0,0); break;
}
}
@ -376,10 +376,10 @@ static void draw_sc2_layer(running_machine &machine, bitmap_ind16 &bitmap, const
jalmah_state *state = machine.driver_data<jalmah_state>();
switch(state->m_jm_vregs[2] & 3)
{
case 0: tilemap_draw(bitmap,cliprect,state->m_sc2_tilemap_0,0,0); break;
case 1: tilemap_draw(bitmap,cliprect,state->m_sc2_tilemap_1,0,0); break;
case 2: tilemap_draw(bitmap,cliprect,state->m_sc2_tilemap_2,0,0); break;
case 3: tilemap_draw(bitmap,cliprect,state->m_sc2_tilemap_3,0,0); break;
case 0: state->m_sc2_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: state->m_sc2_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc2_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc2_tilemap_3->draw(bitmap, cliprect, 0,0); break;
}
}
@ -389,9 +389,9 @@ static void draw_sc3_layer(running_machine &machine, bitmap_ind16 &bitmap, const
switch(state->m_jm_vregs[3] & 3)
{
case 0:
case 1: tilemap_draw(bitmap,cliprect,state->m_sc3_tilemap_0,0,0); break;
case 2: tilemap_draw(bitmap,cliprect,state->m_sc3_tilemap_2,0,0); break;
case 3: tilemap_draw(bitmap,cliprect,state->m_sc3_tilemap_3,0,0); break;
case 1: state->m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc3_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc3_tilemap_3->draw(bitmap, cliprect, 0,0); break;
}
}
@ -402,46 +402,46 @@ static SCREEN_UPDATE_IND16( jalmah )
UINT8 cur_prin;
jalmah_priority_system(screen.machine());
tilemap_set_scrollx(state->m_sc0_tilemap_0, 0, jm_scrollram[0] & 0xfff);
tilemap_set_scrollx(state->m_sc0_tilemap_1, 0, jm_scrollram[0] & 0x7ff);
tilemap_set_scrollx(state->m_sc0_tilemap_2, 0, jm_scrollram[0] & 0x3ff);
tilemap_set_scrollx(state->m_sc0_tilemap_3, 0, jm_scrollram[0] & 0x1ff);
state->m_sc0_tilemap_0->set_scrollx(0, jm_scrollram[0] & 0xfff);
state->m_sc0_tilemap_1->set_scrollx(0, jm_scrollram[0] & 0x7ff);
state->m_sc0_tilemap_2->set_scrollx(0, jm_scrollram[0] & 0x3ff);
state->m_sc0_tilemap_3->set_scrollx(0, jm_scrollram[0] & 0x1ff);
tilemap_set_scrollx(state->m_sc1_tilemap_0, 0, jm_scrollram[1] & 0xfff);
tilemap_set_scrollx(state->m_sc1_tilemap_1, 0, jm_scrollram[1] & 0x7ff);
tilemap_set_scrollx(state->m_sc1_tilemap_2, 0, jm_scrollram[1] & 0x3ff);
tilemap_set_scrollx(state->m_sc1_tilemap_3, 0, jm_scrollram[1] & 0x1ff);
state->m_sc1_tilemap_0->set_scrollx(0, jm_scrollram[1] & 0xfff);
state->m_sc1_tilemap_1->set_scrollx(0, jm_scrollram[1] & 0x7ff);
state->m_sc1_tilemap_2->set_scrollx(0, jm_scrollram[1] & 0x3ff);
state->m_sc1_tilemap_3->set_scrollx(0, jm_scrollram[1] & 0x1ff);
tilemap_set_scrollx(state->m_sc2_tilemap_0, 0, jm_scrollram[2] & 0xfff);
tilemap_set_scrollx(state->m_sc2_tilemap_1, 0, jm_scrollram[2] & 0x7ff);
tilemap_set_scrollx(state->m_sc2_tilemap_2, 0, jm_scrollram[2] & 0x3ff);
tilemap_set_scrollx(state->m_sc2_tilemap_3, 0, jm_scrollram[2] & 0x1ff);
state->m_sc2_tilemap_0->set_scrollx(0, jm_scrollram[2] & 0xfff);
state->m_sc2_tilemap_1->set_scrollx(0, jm_scrollram[2] & 0x7ff);
state->m_sc2_tilemap_2->set_scrollx(0, jm_scrollram[2] & 0x3ff);
state->m_sc2_tilemap_3->set_scrollx(0, jm_scrollram[2] & 0x1ff);
tilemap_set_scrollx(state->m_sc3_tilemap_0, 0, jm_scrollram[3] & 0x7ff);
state->m_sc3_tilemap_0->set_scrollx(0, jm_scrollram[3] & 0x7ff);
// empty
tilemap_set_scrollx(state->m_sc3_tilemap_2, 0, jm_scrollram[3] & 0x3ff);
tilemap_set_scrollx(state->m_sc3_tilemap_3, 0, jm_scrollram[3] & 0x1ff);
state->m_sc3_tilemap_2->set_scrollx(0, jm_scrollram[3] & 0x3ff);
state->m_sc3_tilemap_3->set_scrollx(0, jm_scrollram[3] & 0x1ff);
tilemap_set_scrolly(state->m_sc0_tilemap_0, 0, jm_scrollram[4] & 0x1ff);
tilemap_set_scrolly(state->m_sc0_tilemap_1, 0, jm_scrollram[4] & 0x3ff);
tilemap_set_scrolly(state->m_sc0_tilemap_2, 0, jm_scrollram[4] & 0x7ff);
tilemap_set_scrolly(state->m_sc0_tilemap_3, 0, jm_scrollram[4] & 0xfff);
state->m_sc0_tilemap_0->set_scrolly(0, jm_scrollram[4] & 0x1ff);
state->m_sc0_tilemap_1->set_scrolly(0, jm_scrollram[4] & 0x3ff);
state->m_sc0_tilemap_2->set_scrolly(0, jm_scrollram[4] & 0x7ff);
state->m_sc0_tilemap_3->set_scrolly(0, jm_scrollram[4] & 0xfff);
tilemap_set_scrolly(state->m_sc1_tilemap_0, 0, jm_scrollram[5] & 0x1ff);
tilemap_set_scrolly(state->m_sc1_tilemap_1, 0, jm_scrollram[5] & 0x3ff);
tilemap_set_scrolly(state->m_sc1_tilemap_2, 0, jm_scrollram[5] & 0x7ff);
tilemap_set_scrolly(state->m_sc1_tilemap_3, 0, jm_scrollram[5] & 0xfff);
state->m_sc1_tilemap_0->set_scrolly(0, jm_scrollram[5] & 0x1ff);
state->m_sc1_tilemap_1->set_scrolly(0, jm_scrollram[5] & 0x3ff);
state->m_sc1_tilemap_2->set_scrolly(0, jm_scrollram[5] & 0x7ff);
state->m_sc1_tilemap_3->set_scrolly(0, jm_scrollram[5] & 0xfff);
tilemap_set_scrolly(state->m_sc2_tilemap_0, 0, jm_scrollram[6] & 0x1ff);
tilemap_set_scrolly(state->m_sc2_tilemap_1, 0, jm_scrollram[6] & 0x3ff);
tilemap_set_scrolly(state->m_sc2_tilemap_2, 0, jm_scrollram[6] & 0x7ff);
tilemap_set_scrolly(state->m_sc2_tilemap_3, 0, jm_scrollram[6] & 0xfff);
state->m_sc2_tilemap_0->set_scrolly(0, jm_scrollram[6] & 0x1ff);
state->m_sc2_tilemap_1->set_scrolly(0, jm_scrollram[6] & 0x3ff);
state->m_sc2_tilemap_2->set_scrolly(0, jm_scrollram[6] & 0x7ff);
state->m_sc2_tilemap_3->set_scrolly(0, jm_scrollram[6] & 0xfff);
tilemap_set_scrolly(state->m_sc3_tilemap_0, 0, jm_scrollram[7] & 0xff);
state->m_sc3_tilemap_0->set_scrolly(0, jm_scrollram[7] & 0xff);
// empty
tilemap_set_scrolly(state->m_sc3_tilemap_2, 0, jm_scrollram[7] & 0x1ff);
tilemap_set_scrolly(state->m_sc3_tilemap_3, 0, jm_scrollram[7] & 0x3ff);
state->m_sc3_tilemap_2->set_scrolly(0, jm_scrollram[7] & 0x1ff);
state->m_sc3_tilemap_3->set_scrolly(0, jm_scrollram[7] & 0x3ff);
bitmap.fill(screen.machine().pens[0xff], cliprect); //selectable by a ram address?
@ -461,14 +461,14 @@ static SCREEN_UPDATE_IND16( urashima )
jalmah_state *state = screen.machine().driver_data<jalmah_state>();
UINT16 *jm_scrollram = state->m_jm_scrollram;
/*this game doesn't use the RANGE register at all.*/
tilemap_set_scrollx(state->m_sc0_tilemap_0, 0, jm_scrollram[0]);
tilemap_set_scrollx(state->m_sc3_tilemap_0, 0, jm_scrollram[3]);
tilemap_set_scrolly(state->m_sc0_tilemap_0, 0, jm_scrollram[4]);
tilemap_set_scrolly(state->m_sc3_tilemap_0, 0, jm_scrollram[7]);
state->m_sc0_tilemap_0->set_scrollx(0, jm_scrollram[0]);
state->m_sc3_tilemap_0->set_scrollx(0, jm_scrollram[3]);
state->m_sc0_tilemap_0->set_scrolly(0, jm_scrollram[4]);
state->m_sc3_tilemap_0->set_scrolly(0, jm_scrollram[7]);
bitmap.fill(screen.machine().pens[0x1ff], cliprect);//selectable by a ram address?
if(state->m_jm_vregs[0] & 1) { tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap_0,0,0); }
if(state->m_jm_vregs[3] & 1) { tilemap_draw(bitmap,cliprect,state->m_sc3_tilemap_0,0,0); }
if(state->m_jm_vregs[0] & 1) { state->m_sc0_tilemap_0->draw(bitmap, cliprect, 0,0); }
if(state->m_jm_vregs[3] & 1) { state->m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); }
return 0;
}
@ -477,13 +477,13 @@ static WRITE16_HANDLER( sc0_vram_w )
jalmah_state *state = space->machine().driver_data<jalmah_state>();
COMBINE_DATA(&state->m_sc0_vram[offset]);
/*2048x256 tilemap*/
tilemap_mark_tile_dirty(state->m_sc0_tilemap_0,offset);
state->m_sc0_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
tilemap_mark_tile_dirty(state->m_sc0_tilemap_1,offset);
state->m_sc0_tilemap_1->mark_tile_dirty(offset);
/*512x1024 tilemap*/
tilemap_mark_tile_dirty(state->m_sc0_tilemap_2,offset);
state->m_sc0_tilemap_2->mark_tile_dirty(offset);
/*256x2048 tilemap*/
tilemap_mark_tile_dirty(state->m_sc0_tilemap_3,offset);
state->m_sc0_tilemap_3->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( sc3_vram_w )
@ -491,11 +491,11 @@ static WRITE16_HANDLER( sc3_vram_w )
jalmah_state *state = space->machine().driver_data<jalmah_state>();
COMBINE_DATA(&state->m_sc3_vram[offset]);
/*2048x256 tilemap*/
tilemap_mark_tile_dirty(state->m_sc3_tilemap_0,offset);
state->m_sc3_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
tilemap_mark_tile_dirty(state->m_sc3_tilemap_2,offset);
state->m_sc3_tilemap_2->mark_tile_dirty(offset);
/*512x1024 tilemap*/
tilemap_mark_tile_dirty(state->m_sc3_tilemap_3,offset);
state->m_sc3_tilemap_3->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( sc1_vram_w )
@ -503,13 +503,13 @@ static WRITE16_HANDLER( sc1_vram_w )
jalmah_state *state = space->machine().driver_data<jalmah_state>();
COMBINE_DATA(&state->m_sc1_vram[offset]);
/*2048x256 tilemap*/
tilemap_mark_tile_dirty(state->m_sc1_tilemap_0,offset);
state->m_sc1_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
tilemap_mark_tile_dirty(state->m_sc1_tilemap_1,offset);
state->m_sc1_tilemap_1->mark_tile_dirty(offset);
/*512x1024 tilemap*/
tilemap_mark_tile_dirty(state->m_sc1_tilemap_2,offset);
state->m_sc1_tilemap_2->mark_tile_dirty(offset);
/*256x2048 tilemap*/
tilemap_mark_tile_dirty(state->m_sc1_tilemap_3,offset);
state->m_sc1_tilemap_3->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( sc2_vram_w )
@ -517,13 +517,13 @@ static WRITE16_HANDLER( sc2_vram_w )
jalmah_state *state = space->machine().driver_data<jalmah_state>();
COMBINE_DATA(&state->m_sc2_vram[offset]);
/*2048x256 tilemap*/
tilemap_mark_tile_dirty(state->m_sc2_tilemap_0,offset);
state->m_sc2_tilemap_0->mark_tile_dirty(offset);
/*1024x512 tilemap*/
tilemap_mark_tile_dirty(state->m_sc2_tilemap_1,offset);
state->m_sc2_tilemap_1->mark_tile_dirty(offset);
/*512x1024 tilemap*/
tilemap_mark_tile_dirty(state->m_sc2_tilemap_2,offset);
state->m_sc2_tilemap_2->mark_tile_dirty(offset);
/*256x2048 tilemap*/
tilemap_mark_tile_dirty(state->m_sc2_tilemap_3,offset);
state->m_sc2_tilemap_3->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( jalmah_tilebank_w )
@ -539,10 +539,10 @@ static WRITE16_HANDLER( jalmah_tilebank_w )
if (state->m_sc0bank != ((data & 0xf0) >> 4))
{
state->m_sc0bank = (data & 0xf0) >> 4;
tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_0);
tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_1);
tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_2);
tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_3);
state->m_sc0_tilemap_0->mark_all_dirty();
state->m_sc0_tilemap_1->mark_all_dirty();
state->m_sc0_tilemap_2->mark_all_dirty();
state->m_sc0_tilemap_3->mark_all_dirty();
}
if (state->m_pri != (data & 0x0f))
state->m_pri = data & 0x0f;
@ -587,9 +587,9 @@ static WRITE16_HANDLER( urashima_bank_w )
if (state->m_sc0bank != (data & 0x0f))
{
state->m_sc0bank = (data & 0x0f);
tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_0);
//tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_2);
//tilemap_mark_all_tiles_dirty(state->m_sc0_tilemap_3);
state->m_sc0_tilemap_0->mark_all_dirty();
//state->m_sc0_tilemap_2->mark_all_dirty();
//state->m_sc0_tilemap_3->mark_all_dirty();
}
}
}
@ -598,14 +598,14 @@ static WRITE16_HANDLER( urashima_sc0_vram_w )
{
jalmah_state *state = space->machine().driver_data<jalmah_state>();
COMBINE_DATA(&state->m_sc0_vram[offset]);
tilemap_mark_tile_dirty(state->m_sc0_tilemap_0,offset);
state->m_sc0_tilemap_0->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( urashima_sc3_vram_w )
{
jalmah_state *state = space->machine().driver_data<jalmah_state>();
COMBINE_DATA(&state->m_sc3_vram[offset]);
tilemap_mark_tile_dirty(state->m_sc3_tilemap_0,offset);
state->m_sc3_tilemap_0->mark_tile_dirty(offset);
}
/*Urashima Mahjong uses a bigger (and mostly unused/wasted) video register ram.*/

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

@ -118,7 +118,7 @@ static WRITE8_HANDLER( jokrwild_videoram_w )
{
jokrwild_state *state = space->machine().driver_data<jokrwild_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -126,7 +126,7 @@ static WRITE8_HANDLER( jokrwild_colorram_w )
{
jokrwild_state *state = space->machine().driver_data<jokrwild_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -156,7 +156,7 @@ static VIDEO_START( jokrwild )
static SCREEN_UPDATE_IND16( jokrwild )
{
jokrwild_state *state = screen.machine().driver_data<jokrwild_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -138,7 +138,7 @@ static WRITE8_HANDLER( jollyjgr_videoram_w )
{
jollyjgr_state *state = space->machine().driver_data<jollyjgr_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( jollyjgr_attrram_w )
@ -151,11 +151,11 @@ static WRITE8_HANDLER( jollyjgr_attrram_w )
int i;
for (i = offset >> 1; i < 0x0400; i += 32)
tilemap_mark_tile_dirty(state->m_bg_tilemap, i);
state->m_bg_tilemap->mark_tile_dirty(i);
}
else
{
tilemap_set_scrolly(state->m_bg_tilemap, offset >> 1, data);
state->m_bg_tilemap->set_scrolly(offset >> 1, data);
}
state->m_colorram[offset] = data;
@ -175,7 +175,7 @@ static WRITE8_HANDLER( jollyjgr_misc_w )
state->m_pri = data & 4;
tilemap_set_flip(state->m_bg_tilemap, (state->m_flip_x ? TILEMAP_FLIPX : 0) | (state->m_flip_y ? TILEMAP_FLIPY : 0));
state->m_bg_tilemap->set_flip((state->m_flip_x ? TILEMAP_FLIPX : 0) | (state->m_flip_y ? TILEMAP_FLIPY : 0));
state->m_nmi_enable = data & 0x80;
}
@ -441,8 +441,8 @@ static VIDEO_START( jollyjgr )
jollyjgr_state *state = machine.driver_data<jollyjgr_state>();
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->m_bg_tilemap, 0);
tilemap_set_scroll_cols(state->m_bg_tilemap, 32);
state->m_bg_tilemap->set_transparent_pen(0);
state->m_bg_tilemap->set_scroll_cols(32);
}
static void draw_bitmap( running_machine &machine, bitmap_ind16 &bitmap )
@ -495,11 +495,11 @@ static SCREEN_UPDATE_IND16( jollyjgr )
if(!(state->m_bitmap_disable))
draw_bitmap(screen.machine(), bitmap);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
}
else
{
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
if(!(state->m_bitmap_disable))
draw_bitmap(screen.machine(), bitmap);

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

@ -110,7 +110,7 @@ static WRITE8_HANDLER( jubileep_videoram_w )
{
jubilee_state *state = space->machine().driver_data<jubilee_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -134,7 +134,7 @@ static VIDEO_START( jubileep )
static SCREEN_UPDATE_IND16( jubileep )
{
jubilee_state *state = screen.machine().driver_data<jubilee_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -146,7 +146,7 @@ static TILE_GET_INFO( get_sc1_tile_info )
color|0x40,
0);
tileinfo->category = (state->m_attr[tile_index] & 0x08)>>3;
tileinfo.category = (state->m_attr[tile_index] & 0x08)>>3;
}
static VIDEO_START(kingdrby)
@ -156,7 +156,7 @@ static VIDEO_START(kingdrby)
state->m_sc1_tilemap = tilemap_create(machine, get_sc1_tile_info,tilemap_scan_rows,8,8,32,24);
state->m_sc0w_tilemap = tilemap_create(machine, get_sc0_tile_info,tilemap_scan_rows,8,8,32,32);
tilemap_set_transparent_pen(state->m_sc1_tilemap,0);
state->m_sc1_tilemap->set_transparent_pen(0);
}
static const UINT8 hw_sprite[16] =
@ -215,20 +215,20 @@ static SCREEN_UPDATE_IND16(kingdrby)
kingdrby_state *state = screen.machine().driver_data<kingdrby_state>();
const rectangle &visarea = screen.visible_area();
rectangle clip;
tilemap_set_scrollx( state->m_sc0_tilemap,0, state->m_vram[0x342]);
tilemap_set_scrolly( state->m_sc0_tilemap,0, state->m_vram[0x341]);
tilemap_set_scrollx( state->m_sc1_tilemap,0, state->m_vram[0x342]);
tilemap_set_scrolly( state->m_sc1_tilemap,0, state->m_vram[0x341]);
tilemap_set_scrolly( state->m_sc0w_tilemap,0, 32);
state->m_sc0_tilemap->set_scrollx(0, state->m_vram[0x342]);
state->m_sc0_tilemap->set_scrolly(0, state->m_vram[0x341]);
state->m_sc1_tilemap->set_scrollx(0, state->m_vram[0x342]);
state->m_sc1_tilemap->set_scrolly(0, state->m_vram[0x341]);
state->m_sc0w_tilemap->set_scrolly(0, 32);
/* maybe it needs two window tilemaps? (one at the top, the other at the bottom)*/
clip.set(visarea.min_x, 256, 192, visarea.max_y);
/*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/
tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
state->m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
draw_sprites(screen.machine(),bitmap,cliprect);
tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap,TILEMAP_DRAW_CATEGORY(1),0);
tilemap_draw(bitmap,clip,state->m_sc0w_tilemap,0,0);
state->m_sc1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
state->m_sc0w_tilemap->draw(bitmap, clip, 0,0);
return 0;
}
@ -237,18 +237,18 @@ static WRITE8_HANDLER( sc0_vram_w )
{
kingdrby_state *state = space->machine().driver_data<kingdrby_state>();
state->m_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
tilemap_mark_tile_dirty(state->m_sc0w_tilemap,offset);
tilemap_mark_tile_dirty(state->m_sc1_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
state->m_sc0w_tilemap->mark_tile_dirty(offset);
state->m_sc1_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( sc0_attr_w )
{
kingdrby_state *state = space->machine().driver_data<kingdrby_state>();
state->m_attr[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset);
tilemap_mark_tile_dirty(state->m_sc0w_tilemap,offset);
tilemap_mark_tile_dirty(state->m_sc1_tilemap,offset);
state->m_sc0_tilemap->mark_tile_dirty(offset);
state->m_sc0w_tilemap->mark_tile_dirty(offset);
state->m_sc1_tilemap->mark_tile_dirty(offset);
}
/*************************************

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

@ -82,14 +82,14 @@ static VIDEO_START( koftball )
state->m_tilemap_1 = tilemap_create(machine, get_t1_tile_info,tilemap_scan_rows,8,8,64,32);
state->m_tilemap_2 = tilemap_create(machine, get_t2_tile_info,tilemap_scan_rows,8,8,64,32);
tilemap_set_transparent_pen(state->m_tilemap_1,0);
state->m_tilemap_1->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( koftball )
{
koftball_state *state = screen.machine().driver_data<koftball_state>();
tilemap_draw( bitmap, cliprect, state->m_tilemap_2, 0, 0);
tilemap_draw( bitmap, cliprect, state->m_tilemap_1, 0, 0);
state->m_tilemap_2->draw(bitmap, cliprect, 0, 0);
state->m_tilemap_1->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -144,14 +144,14 @@ static WRITE16_HANDLER(bmc_1_videoram_w)
{
koftball_state *state = space->machine().driver_data<koftball_state>();
COMBINE_DATA(&state->m_bmc_1_videoram[offset]);
tilemap_mark_tile_dirty(state->m_tilemap_1, offset);
state->m_tilemap_1->mark_tile_dirty(offset);
}
static WRITE16_HANDLER(bmc_2_videoram_w)
{
koftball_state *state = space->machine().driver_data<koftball_state>();
COMBINE_DATA(&state->m_bmc_2_videoram[offset]);
tilemap_mark_tile_dirty(state->m_tilemap_2, offset);
state->m_tilemap_2->mark_tile_dirty(offset);
}
static ADDRESS_MAP_START( koftball_mem, AS_PROGRAM, 16 )

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

@ -135,7 +135,7 @@ static VIDEO_START(koikoi)
static SCREEN_UPDATE_IND16(koikoi)
{
koikoi_state *state = screen.machine().driver_data<koikoi_state>();
tilemap_draw(bitmap, cliprect, state->m_tmap, 0, 0);
state->m_tmap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -149,7 +149,7 @@ static WRITE8_HANDLER( vram_w )
{
koikoi_state *state = space->machine().driver_data<koikoi_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_tmap, offset & 0x3ff);
state->m_tmap->mark_tile_dirty(offset & 0x3ff);
}
static READ8_DEVICE_HANDLER( input_r )

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

@ -34,12 +34,12 @@ static WRITE8_HANDLER( laserbat_videoram_w )
if (state->m_video_page == 0)
{
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
else if (state->m_video_page == 1)
{
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset); // wrong!
state->m_bg_tilemap->mark_tile_dirty(offset); // wrong!
}
}
@ -508,7 +508,7 @@ static SCREEN_UPDATE_IND16( laserbat )
laserbat_state *state = screen.machine().driver_data<laserbat_state>();
int y;
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
/* update the S2636 chips */
bitmap_ind16 &s2636_1_bitmap = s2636_update(state->m_s2636_1, cliprect);

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

@ -88,21 +88,21 @@ static WRITE32_HANDLER( bg_videoram_w )
{
limenko_state *state = space->machine().driver_data<limenko_state>();
COMBINE_DATA(&state->m_bg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE32_HANDLER( md_videoram_w )
{
limenko_state *state = space->machine().driver_data<limenko_state>();
COMBINE_DATA(&state->m_md_videoram[offset]);
tilemap_mark_tile_dirty(state->m_md_tilemap,offset);
state->m_md_tilemap->mark_tile_dirty(offset);
}
static WRITE32_HANDLER( fg_videoram_w )
{
limenko_state *state = space->machine().driver_data<limenko_state>();
COMBINE_DATA(&state->m_fg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE32_HANDLER( spotty_soundlatch_w )
@ -441,8 +441,8 @@ static VIDEO_START( limenko )
state->m_md_tilemap = tilemap_create(machine, get_md_tile_info,tilemap_scan_rows,8,8,128,64);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,tilemap_scan_rows,8,8,128,64);
tilemap_set_transparent_pen(state->m_md_tilemap,0);
tilemap_set_transparent_pen(state->m_fg_tilemap,0);
state->m_md_tilemap->set_transparent_pen(0);
state->m_fg_tilemap->set_transparent_pen(0);
state->m_sprites_bitmap.allocate(384,240);
state->m_sprites_bitmap_pri.allocate(384,240);
@ -455,21 +455,21 @@ static SCREEN_UPDATE_IND16( limenko )
screen.machine().priority_bitmap.fill(0, cliprect);
tilemap_set_enable(state->m_bg_tilemap, state->m_videoreg[0] & 4);
tilemap_set_enable(state->m_md_tilemap, state->m_videoreg[0] & 2);
tilemap_set_enable(state->m_fg_tilemap, state->m_videoreg[0] & 1);
state->m_bg_tilemap->enable(state->m_videoreg[0] & 4);
state->m_md_tilemap->enable(state->m_videoreg[0] & 2);
state->m_fg_tilemap->enable(state->m_videoreg[0] & 1);
tilemap_set_scrolly(state->m_bg_tilemap, 0, state->m_videoreg[3] & 0xffff);
tilemap_set_scrolly(state->m_md_tilemap, 0, state->m_videoreg[2] & 0xffff);
tilemap_set_scrolly(state->m_fg_tilemap, 0, state->m_videoreg[1] & 0xffff);
state->m_bg_tilemap->set_scrolly(0, state->m_videoreg[3] & 0xffff);
state->m_md_tilemap->set_scrolly(0, state->m_videoreg[2] & 0xffff);
state->m_fg_tilemap->set_scrolly(0, state->m_videoreg[1] & 0xffff);
tilemap_set_scrollx(state->m_bg_tilemap, 0, (state->m_videoreg[3] & 0xffff0000) >> 16);
tilemap_set_scrollx(state->m_md_tilemap, 0, (state->m_videoreg[2] & 0xffff0000) >> 16);
tilemap_set_scrollx(state->m_fg_tilemap, 0, (state->m_videoreg[1] & 0xffff0000) >> 16);
state->m_bg_tilemap->set_scrollx(0, (state->m_videoreg[3] & 0xffff0000) >> 16);
state->m_md_tilemap->set_scrollx(0, (state->m_videoreg[2] & 0xffff0000) >> 16);
state->m_fg_tilemap->set_scrollx(0, (state->m_videoreg[1] & 0xffff0000) >> 16);
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_md_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,1);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
state->m_md_tilemap->draw(bitmap, cliprect, 0,0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0,1);
if(state->m_videoreg[0] & 8)
copy_sprites(screen.machine(), bitmap, state->m_sprites_bitmap, screen.machine().priority_bitmap, cliprect);

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

@ -184,7 +184,7 @@ static VIDEO_START( looping )
state->m_bg_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_rows, 8,8, 32,32);
tilemap_set_scroll_cols(state->m_bg_tilemap, 0x20);
state->m_bg_tilemap->set_scroll_cols(0x20);
}
@ -199,7 +199,7 @@ static WRITE8_HANDLER( flip_screen_x_w )
{
looping_state *state = space->machine().driver_data<looping_state>();
flip_screen_x_set(space->machine(), ~data & 0x01);
tilemap_set_scrollx(state->m_bg_tilemap, 0, flip_screen_get(space->machine()) ? 128 : 0);
state->m_bg_tilemap->set_scrollx(0, flip_screen_get(space->machine()) ? 128 : 0);
}
@ -207,7 +207,7 @@ static WRITE8_HANDLER( flip_screen_y_w )
{
looping_state *state = space->machine().driver_data<looping_state>();
flip_screen_y_set(space->machine(), ~data & 0x01);
tilemap_set_scrollx(state->m_bg_tilemap, 0, flip_screen_get(space->machine()) ? 128 : 0);
state->m_bg_tilemap->set_scrollx(0, flip_screen_get(space->machine()) ? 128 : 0);
}
@ -215,7 +215,7 @@ static WRITE8_HANDLER( looping_videoram_w )
{
looping_state *state = space->machine().driver_data<looping_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -232,12 +232,12 @@ static WRITE8_HANDLER( looping_colorram_w )
/* mark the whole column dirty */
offs_t offs = (offset/2);
for (i = 0; i < 0x20; i++)
tilemap_mark_tile_dirty(state->m_bg_tilemap, i * 0x20 + offs);
state->m_bg_tilemap->mark_tile_dirty(i * 0x20 + offs);
}
/* even bytes are column scroll */
else
tilemap_set_scrolly(state->m_bg_tilemap, offset/2, data);
state->m_bg_tilemap->set_scrolly(offset/2, data);
}
@ -282,7 +282,7 @@ static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const r
static SCREEN_UPDATE_IND16( looping )
{
looping_state *state = screen.machine().driver_data<looping_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;

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

@ -56,14 +56,14 @@ static WRITE8_HANDLER( ltcasino_tile_num_w )
{
ltcasino_state *state = space->machine().driver_data<ltcasino_state>();
state->m_tile_num_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_tilemap,offset);
state->m_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( ltcasino_tile_atr_w )
{
ltcasino_state *state = space->machine().driver_data<ltcasino_state>();
state->m_tile_atr_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_tilemap,offset);
state->m_tilemap->mark_tile_dirty(offset);
}
@ -635,7 +635,7 @@ GFXDECODE_END
static SCREEN_UPDATE_IND16(ltcasino)
{
ltcasino_state *state = screen.machine().driver_data<ltcasino_state>();
tilemap_draw(bitmap,cliprect,state->m_tilemap,0,0);
state->m_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}

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

@ -118,14 +118,14 @@ static WRITE8_HANDLER( luckgrln_reel1_ram_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel1_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel1_tilemap,offset);
state->m_reel1_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( luckgrln_reel1_attr_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel1_attr[offset] = data;
tilemap_mark_tile_dirty(state->m_reel1_tilemap,offset);
state->m_reel1_tilemap->mark_tile_dirty(offset);
}
@ -152,14 +152,14 @@ static WRITE8_HANDLER( luckgrln_reel2_ram_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel2_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel2_tilemap,offset);
state->m_reel2_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( luckgrln_reel2_attr_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel2_attr[offset] = data;
tilemap_mark_tile_dirty(state->m_reel2_tilemap,offset);
state->m_reel2_tilemap->mark_tile_dirty(offset);
}
@ -184,14 +184,14 @@ static WRITE8_HANDLER( luckgrln_reel3_ram_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel3_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel3_tilemap,offset);
state->m_reel3_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( luckgrln_reel3_attr_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel3_attr[offset] = data;
tilemap_mark_tile_dirty(state->m_reel3_tilemap,offset);
state->m_reel3_tilemap->mark_tile_dirty(offset);
}
@ -215,14 +215,14 @@ static WRITE8_HANDLER( luckgrln_reel4_ram_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel4_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_reel4_tilemap,offset);
state->m_reel4_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( luckgrln_reel4_attr_w )
{
luckgrln_state *state = space->machine().driver_data<luckgrln_state>();
state->m_reel4_attr[offset] = data;
tilemap_mark_tile_dirty(state->m_reel4_tilemap,offset);
state->m_reel4_tilemap->mark_tile_dirty(offset);
}
@ -250,15 +250,15 @@ static VIDEO_START(luckgrln)
state->m_reel3_tilemap = tilemap_create(machine,get_luckgrln_reel3_tile_info,tilemap_scan_rows, 8, 32, 64, 8);
state->m_reel4_tilemap = tilemap_create(machine,get_luckgrln_reel4_tile_info,tilemap_scan_rows, 8, 32, 64, 8);
tilemap_set_scroll_cols(state->m_reel1_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel2_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel3_tilemap, 64);
tilemap_set_scroll_cols(state->m_reel4_tilemap, 64);
state->m_reel1_tilemap->set_scroll_cols(64);
state->m_reel2_tilemap->set_scroll_cols(64);
state->m_reel3_tilemap->set_scroll_cols(64);
state->m_reel4_tilemap->set_scroll_cols(64);
tilemap_set_transparent_pen( state->m_reel1_tilemap, 0 );
tilemap_set_transparent_pen( state->m_reel2_tilemap, 0 );
tilemap_set_transparent_pen( state->m_reel3_tilemap, 0 );
tilemap_set_transparent_pen( state->m_reel4_tilemap, 0 );
state->m_reel1_tilemap->set_transparent_pen(0 );
state->m_reel2_tilemap->set_transparent_pen(0 );
state->m_reel3_tilemap->set_transparent_pen(0 );
state->m_reel4_tilemap->set_transparent_pen(0 );
}
static SCREEN_UPDATE_IND16(luckgrln)
@ -275,10 +275,10 @@ static SCREEN_UPDATE_IND16(luckgrln)
for (i= 0;i < 64;i++)
{
tilemap_set_scrolly(state->m_reel1_tilemap, i, state->m_reel1_scroll[i]);
tilemap_set_scrolly(state->m_reel2_tilemap, i, state->m_reel2_scroll[i]);
tilemap_set_scrolly(state->m_reel3_tilemap, i, state->m_reel3_scroll[i]);
tilemap_set_scrolly(state->m_reel4_tilemap, i, state->m_reel4_scroll[i]);
state->m_reel1_tilemap->set_scrolly(i, state->m_reel1_scroll[i]);
state->m_reel2_tilemap->set_scrolly(i, state->m_reel2_scroll[i]);
state->m_reel3_tilemap->set_scrolly(i, state->m_reel3_scroll[i]);
state->m_reel4_tilemap->set_scrolly(i, state->m_reel4_scroll[i]);
}
@ -330,10 +330,10 @@ static SCREEN_UPDATE_IND16(luckgrln)
#if 0 // treat bit as fg enable
if (tileattr&0x04)
{
if (bgenable==0) tilemap_draw(bitmap, clip, state->m_reel1_tilemap, 0, 0);
if (bgenable==1) tilemap_draw(bitmap, clip, state->m_reel2_tilemap, 0, 0);
if (bgenable==2) tilemap_draw(bitmap, clip, state->m_reel3_tilemap, 0, 0);
if (bgenable==3) tilemap_draw(bitmap, clip, state->m_reel4_tilemap, 0, 0);
if (bgenable==0) state->m_reel1_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==1) state->m_reel2_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==2) state->m_reel3_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==3) state->m_reel4_tilemap->draw(bitmap, clip, 0, 0);
}
if (tileattr&0x08) drawgfx_transpen(bitmap,clip,screen.machine().gfx[region],tile,col,0,0,x*8,y*8, 0);
@ -343,10 +343,10 @@ static SCREEN_UPDATE_IND16(luckgrln)
if (tileattr&0x04)
{
if (bgenable==0) tilemap_draw(bitmap, clip, state->m_reel1_tilemap, 0, 0);
if (bgenable==1) tilemap_draw(bitmap, clip, state->m_reel2_tilemap, 0, 0);
if (bgenable==2) tilemap_draw(bitmap, clip, state->m_reel3_tilemap, 0, 0);
if (bgenable==3) tilemap_draw(bitmap, clip, state->m_reel4_tilemap, 0, 0);
if (bgenable==0) state->m_reel1_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==1) state->m_reel2_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==2) state->m_reel3_tilemap->draw(bitmap, clip, 0, 0);
if (bgenable==3) state->m_reel4_tilemap->draw(bitmap, clip, 0, 0);
}
if ((tileattr&0x08)) drawgfx_transpen(bitmap,clip,screen.machine().gfx[region],tile,col,0,0,x*8,y*8, 0);

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

@ -124,7 +124,7 @@ static SCREEN_UPDATE_IND16( m14 )
{
m14_state *state = screen.machine().driver_data<m14_state>();
tilemap_draw(bitmap, cliprect, state->m_m14_tilemap, 0, 0);
state->m_m14_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -134,7 +134,7 @@ static WRITE8_HANDLER( m14_vram_w )
m14_state *state = space->machine().driver_data<m14_state>();
state->m_video_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_m14_tilemap, offset);
state->m_m14_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( m14_cram_w )
@ -142,7 +142,7 @@ static WRITE8_HANDLER( m14_cram_w )
m14_state *state = space->machine().driver_data<m14_state>();
state->m_color_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_m14_tilemap, offset);
state->m_m14_tilemap->mark_tile_dirty(offset);
}
/*************************************

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

@ -218,7 +218,7 @@ static WRITE8_HANDLER( m63_videoram_w )
m63_state *state = space->machine().driver_data<m63_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( m63_colorram_w )
@ -226,7 +226,7 @@ static WRITE8_HANDLER( m63_colorram_w )
m63_state *state = space->machine().driver_data<m63_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( m63_videoram2_w )
@ -234,7 +234,7 @@ static WRITE8_HANDLER( m63_videoram2_w )
m63_state *state = space->machine().driver_data<m63_state>();
state->m_videoram2[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( m63_palbank_w )
@ -244,7 +244,7 @@ static WRITE8_HANDLER( m63_palbank_w )
if (state->m_pal_bank != (data & 0x01))
{
state->m_pal_bank = data & 0x01;
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
}
}
@ -253,7 +253,7 @@ static WRITE8_HANDLER( m63_flipscreen_w )
if (flip_screen_get(space->machine()) != (~data & 0x01))
{
flip_screen_set(space->machine(), ~data & 0x01);
tilemap_mark_all_tiles_dirty_all(space->machine());
space->machine().tilemap().mark_all_dirty();
}
}
@ -293,8 +293,8 @@ static VIDEO_START( m63 )
state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
tilemap_set_scroll_cols(state->m_bg_tilemap, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_bg_tilemap->set_scroll_cols(32);
state->m_fg_tilemap->set_transparent_pen(0);
}
static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
@ -345,11 +345,11 @@ static SCREEN_UPDATE_IND16( m63 )
int col;
for (col = 0; col < 32; col++)
tilemap_set_scrolly(state->m_bg_tilemap, col, state->m_scrollram[col * 8]);
state->m_bg_tilemap->set_scrolly(col, state->m_scrollram[col * 8]);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -111,21 +111,21 @@ static WRITE16_HANDLER( layer0_videoram_w )
{
magic10_state *state = space->machine().driver_data<magic10_state>();
COMBINE_DATA(&state->m_layer0_videoram[offset]);
tilemap_mark_tile_dirty( state->m_layer0_tilemap, offset >> 1);
state->m_layer0_tilemap->mark_tile_dirty(offset >> 1);
}
static WRITE16_HANDLER( layer1_videoram_w )
{
magic10_state *state = space->machine().driver_data<magic10_state>();
COMBINE_DATA(&state->m_layer1_videoram[offset]);
tilemap_mark_tile_dirty( state->m_layer1_tilemap, offset >> 1);
state->m_layer1_tilemap->mark_tile_dirty(offset >> 1);
}
static WRITE16_HANDLER( layer2_videoram_w )
{
magic10_state *state = space->machine().driver_data<magic10_state>();
COMBINE_DATA(&state->m_layer2_videoram[offset]);
tilemap_mark_tile_dirty( state->m_layer2_tilemap, offset >> 1);
state->m_layer2_tilemap->mark_tile_dirty(offset >> 1);
}
static WRITE16_HANDLER( paletteram_w )
@ -179,27 +179,27 @@ static VIDEO_START( magic10 )
state->m_layer1_tilemap = tilemap_create(machine, get_layer1_tile_info, tilemap_scan_rows, 16, 16, 32, 32);
state->m_layer2_tilemap = tilemap_create(machine, get_layer2_tile_info, tilemap_scan_rows, 8, 8, 64, 64);
tilemap_set_transparent_pen(state->m_layer1_tilemap, 0);
tilemap_set_transparent_pen(state->m_layer2_tilemap, 0);
state->m_layer1_tilemap->set_transparent_pen(0);
state->m_layer2_tilemap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( magic10 )
{
magic10_state *state = screen.machine().driver_data<magic10_state>();
/*TODO: understand where this comes from. */
tilemap_set_scrollx(state->m_layer2_tilemap, 0, state->m_layer2_offset[0]);
tilemap_set_scrolly(state->m_layer2_tilemap, 0, state->m_layer2_offset[1]);
state->m_layer2_tilemap->set_scrollx(0, state->m_layer2_offset[0]);
state->m_layer2_tilemap->set_scrolly(0, state->m_layer2_offset[1]);
/*
4 and 6 are y/x global register writes.
0 and 2 are y/x writes for the scrolling layer.
*/
tilemap_set_scrolly(state->m_layer1_tilemap, 0, (state->m_vregs[0/2] - state->m_vregs[4/2])+0);
tilemap_set_scrollx(state->m_layer1_tilemap, 0, (state->m_vregs[2/2] - state->m_vregs[6/2])+4);
state->m_layer1_tilemap->set_scrolly(0, (state->m_vregs[0/2] - state->m_vregs[4/2])+0);
state->m_layer1_tilemap->set_scrollx(0, (state->m_vregs[2/2] - state->m_vregs[6/2])+4);
tilemap_draw(bitmap, cliprect, state->m_layer0_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_layer1_tilemap, 0, 0);
tilemap_draw(bitmap, cliprect, state->m_layer2_tilemap, 0, 0);
state->m_layer0_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_layer1_tilemap->draw(bitmap, cliprect, 0, 0);
state->m_layer2_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -439,14 +439,14 @@ static WRITE8_HANDLER( magicfly_videoram_w )
{
magicfly_state *state = space->machine().driver_data<magicfly_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( magicfly_colorram_w )
{
magicfly_state *state = space->machine().driver_data<magicfly_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_magicfly_tile_info )
@ -516,7 +516,7 @@ static VIDEO_START( 7mezzo )
static SCREEN_UPDATE_IND16( magicfly )
{
magicfly_state *state = screen.machine().driver_data<magicfly_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -513,7 +513,7 @@ static VIDEO_START(majorpkr)
state->m_bg_tilemap = tilemap_create(machine, bg_get_tile_info, tilemap_scan_rows, 16, 8, 36, 28);
state->m_fg_tilemap = tilemap_create(machine, fg_get_tile_info, tilemap_scan_rows, 16, 8, 36, 28);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
state->machine().generic.paletteram.u8 = auto_alloc_array(machine, UINT8, 4 * 0x800);
@ -535,13 +535,13 @@ static SCREEN_UPDATE_IND16(majorpkr)
custom_clip = cliprect;
custom_clip.max_x -= 16;
tilemap_draw(bitmap, custom_clip, state->m_bg_tilemap, 0, 0);
tilemap_draw(bitmap, custom_clip, state->m_fg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, custom_clip, 0, 0);
state->m_fg_tilemap->draw(bitmap, custom_clip, 0, 0);
if (state->m_flip_state == 1)
{
tilemap_set_flip(state->m_bg_tilemap, TILEMAP_FLIPX | TILEMAP_FLIPY);
tilemap_set_flip(state->m_fg_tilemap, TILEMAP_FLIPX | TILEMAP_FLIPY);
state->m_bg_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
state->m_fg_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
}
return 0;
@ -602,13 +602,13 @@ static WRITE8_HANDLER(vram_w)
if (state->m_vram_bank == 0)
{
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset >> 1);
state->m_fg_tilemap->mark_tile_dirty(offset >> 1);
}
else
{
if (state->m_vram_bank == 1)
{
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset >> 1);
state->m_bg_tilemap->mark_tile_dirty(offset >> 1);
}
else
{

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

@ -138,7 +138,7 @@ static WRITE8_HANDLER( tx_tileram_w )
marinedt_state *state = space->machine().driver_data<marinedt_state>();
state->m_tx_tileram[offset] = data;
tilemap_mark_tile_dirty(state->m_tx_tilemap, offset);
state->m_tx_tilemap->mark_tile_dirty(offset);
}
static READ8_HANDLER( marinedt_port1_r )
@ -287,9 +287,9 @@ static WRITE8_HANDLER( marinedt_pf_w )
mame_printf_debug("tile non-flip\n");
if (data & 0x02)
tilemap_set_flip(state->m_tx_tilemap, TILEMAP_FLIPX | TILEMAP_FLIPY);
state->m_tx_tilemap->set_flip(TILEMAP_FLIPX | TILEMAP_FLIPY);
else
tilemap_set_flip(state->m_tx_tilemap, 0);
state->m_tx_tilemap->set_flip(0);
}
state->m_pf = data;
@ -483,9 +483,9 @@ static VIDEO_START( marinedt )
marinedt_state *state = machine.driver_data<marinedt_state>();
state->m_tx_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
tilemap_set_transparent_pen(state->m_tx_tilemap, 0);
tilemap_set_scrolldx(state->m_tx_tilemap, 0, 4*8);
tilemap_set_scrolldy(state->m_tx_tilemap, 0, -4*8);
state->m_tx_tilemap->set_transparent_pen(0);
state->m_tx_tilemap->set_scrolldx(0, 4*8);
state->m_tx_tilemap->set_scrolldy(0, -4*8);
state->m_tile = auto_bitmap_ind16_alloc(machine, 32 * 8, 32 * 8);
state->m_obj1 = auto_bitmap_ind16_alloc(machine, 32, 32);
@ -512,7 +512,7 @@ static SCREEN_UPDATE_IND16( marinedt )
int sx, sy;
state->m_tile->fill(0);
tilemap_draw(*state->m_tile, cliprect, state->m_tx_tilemap, 0, 0);
state->m_tx_tilemap->draw(*state->m_tile, cliprect, 0, 0);
state->m_obj1->fill(0);
drawgfx_transpen(*state->m_obj1, state->m_obj1->cliprect(), screen.machine().gfx[1],

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

@ -58,13 +58,13 @@ static WRITE8_HANDLER( mayumi_videoram_w )
{
mayumi_state *state = space->machine().driver_data<mayumi_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_tilemap, offset & 0x7ff);
state->m_tilemap->mark_tile_dirty(offset & 0x7ff);
}
static SCREEN_UPDATE_IND16( mayumi )
{
mayumi_state *state = screen.machine().driver_data<mayumi_state>();
tilemap_draw(bitmap, cliprect, state->m_tilemap, 0, 0);
state->m_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -43,7 +43,7 @@ static WRITE8_HANDLER( mgolf_vram_w )
{
mgolf_state *state = space->machine().driver_data<mgolf_state>();
state->m_video_ram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -60,7 +60,7 @@ static SCREEN_UPDATE_IND16( mgolf )
int i;
/* draw playfield */
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
/* draw sprites */
for (i = 0; i < 2; i++)

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

@ -88,7 +88,7 @@ static VIDEO_START( midas )
state->m_tmap = tilemap_create( machine, get_tile_info, tilemap_scan_cols,
8,8, 0x80,0x20 );
tilemap_set_transparent_pen(state->m_tmap, 0);
state->m_tmap->set_transparent_pen(0);
}
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
@ -193,7 +193,7 @@ static SCREEN_UPDATE_IND16( midas )
bitmap.fill(4095, cliprect);
if (layers_ctrl & 2) draw_sprites(screen.machine(), bitmap,cliprect);
if (layers_ctrl & 1) tilemap_draw(bitmap,cliprect, state->m_tmap, 0, 0);
if (layers_ctrl & 1) state->m_tmap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -232,7 +232,7 @@ static WRITE16_HANDLER( midas_gfxregs_w )
state->m_gfxram[addr] = data;
state->m_gfxregs[0] += state->m_gfxregs[2];
if ( addr >= 0x7000 && addr <= 0x7fff ) tilemap_mark_tile_dirty(state->m_tmap, addr - 0x7000);
if ( addr >= 0x7000 && addr <= 0x7fff ) state->m_tmap->mark_tile_dirty(addr - 0x7000);
break;
}

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

@ -174,18 +174,18 @@ static VIDEO_START(mil4000)
state->m_sc2_tilemap = tilemap_create(machine, get_sc2_tile_info,tilemap_scan_rows,8,8,64,64);
state->m_sc3_tilemap = tilemap_create(machine, get_sc3_tile_info,tilemap_scan_rows,8,8,64,64);
tilemap_set_transparent_pen(state->m_sc1_tilemap,0);
tilemap_set_transparent_pen(state->m_sc2_tilemap,0);
tilemap_set_transparent_pen(state->m_sc3_tilemap,0);
state->m_sc1_tilemap->set_transparent_pen(0);
state->m_sc2_tilemap->set_transparent_pen(0);
state->m_sc3_tilemap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16(mil4000)
{
mil4000_state *state = screen.machine().driver_data<mil4000_state>();
tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_sc2_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_sc3_tilemap,0,0);
state->m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
state->m_sc1_tilemap->draw(bitmap, cliprect, 0,0);
state->m_sc2_tilemap->draw(bitmap, cliprect, 0,0);
state->m_sc3_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}
@ -216,28 +216,28 @@ static WRITE16_HANDLER( sc0_vram_w )
{
mil4000_state *state = space->machine().driver_data<mil4000_state>();
state->m_sc0_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc0_tilemap,offset/2);
state->m_sc0_tilemap->mark_tile_dirty(offset/2);
}
static WRITE16_HANDLER( sc1_vram_w )
{
mil4000_state *state = space->machine().driver_data<mil4000_state>();
state->m_sc1_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc1_tilemap,offset/2);
state->m_sc1_tilemap->mark_tile_dirty(offset/2);
}
static WRITE16_HANDLER( sc2_vram_w )
{
mil4000_state *state = space->machine().driver_data<mil4000_state>();
state->m_sc2_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc2_tilemap,offset/2);
state->m_sc2_tilemap->mark_tile_dirty(offset/2);
}
static WRITE16_HANDLER( sc3_vram_w )
{
mil4000_state *state = space->machine().driver_data<mil4000_state>();
state->m_sc3_vram[offset] = data;
tilemap_mark_tile_dirty(state->m_sc3_tilemap,offset/2);
state->m_sc3_tilemap->mark_tile_dirty(offset/2);
}
/*end of video stuff*/

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

@ -172,14 +172,14 @@ static WRITE8_HANDLER( miniboy7_videoram_w )
{
miniboy7_state *state = space->machine().driver_data<miniboy7_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( miniboy7_colorram_w )
{
miniboy7_state *state = space->machine().driver_data<miniboy7_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static TILE_GET_INFO( get_bg_tile_info )
@ -211,7 +211,7 @@ static VIDEO_START( miniboy7 )
static SCREEN_UPDATE_IND16( miniboy7 )
{
miniboy7_state *state = screen.machine().driver_data<miniboy7_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -86,13 +86,13 @@ static SCREEN_UPDATE_IND16( mogura )
/* tilemap layout is a bit strange ... */
rectangle clip = visarea;
clip.max_x = 256 - 1;
tilemap_set_scrollx(state->m_tilemap, 0, 256);
tilemap_draw(bitmap, clip, state->m_tilemap, 0, 0);
state->m_tilemap->set_scrollx(0, 256);
state->m_tilemap->draw(bitmap, clip, 0, 0);
clip.min_x = 256;
clip.max_x = 512 - 1;
tilemap_set_scrollx(state->m_tilemap, 0, -128);
tilemap_draw(bitmap, clip, state->m_tilemap, 0, 0);
state->m_tilemap->set_scrollx(0, -128);
state->m_tilemap->draw(bitmap, clip, 0, 0);
return 0;
}
@ -101,7 +101,7 @@ static WRITE8_HANDLER( mogura_tileram_w )
{
mogura_state *state = space->machine().driver_data<mogura_state>();
state->m_tileram[offset] = data;
tilemap_mark_tile_dirty(state->m_tilemap, offset & 0x7ff);
state->m_tilemap->mark_tile_dirty(offset & 0x7ff);
}
static WRITE8_HANDLER(mogura_dac_w)

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

@ -104,7 +104,7 @@ static WRITE8_HANDLER( mole_videoram_w )
mole_state *state = space->machine().driver_data<mole_state>();
state->m_tileram[offset] = data | (state->m_tile_bank << 8);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( mole_tilebank_w )
@ -112,7 +112,7 @@ static WRITE8_HANDLER( mole_tilebank_w )
mole_state *state = space->machine().driver_data<mole_state>();
state->m_tile_bank = data;
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
}
static WRITE8_HANDLER( mole_flipscreen_w )
@ -124,7 +124,7 @@ static SCREEN_UPDATE_IND16( mole )
{
mole_state *state = screen.machine().driver_data<mole_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -290,7 +290,7 @@ static WRITE16_HANDLER( ms32_rozram_w16 )
{
ms32_state *state = space->machine().driver_data<ms32_state>();
COMBINE_DATA(&state->m_rozram_16[offset]);
tilemap_mark_tile_dirty(state->m_roz_tilemap,offset/2);
state->m_roz_tilemap->mark_tile_dirty(offset/2);
}
static READ16_HANDLER( ms32_lineram_r16 )
@ -327,7 +327,7 @@ static WRITE16_HANDLER( ms32_txram_w16 )
{
ms32_state *state = space->machine().driver_data<ms32_state>();
COMBINE_DATA(&state->m_txram_16[offset]);
tilemap_mark_tile_dirty(state->m_tx_tilemap,offset/2);
state->m_tx_tilemap->mark_tile_dirty(offset/2);
}
static READ16_HANDLER( ms32_bgram_r16 )
@ -340,8 +340,8 @@ static WRITE16_HANDLER( ms32_bgram_w16 )
{
ms32_state *state = space->machine().driver_data<ms32_state>();
COMBINE_DATA(&state->m_bgram_16[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset/2);
tilemap_mark_tile_dirty(state->m_bg_tilemap_alt,offset/2);
state->m_bg_tilemap->mark_tile_dirty(offset/2);
state->m_bg_tilemap_alt->mark_tile_dirty(offset/2);
}
static WRITE32_HANDLER( pip_w )
@ -402,7 +402,7 @@ static WRITE16_HANDLER( ms32_extra_w16 )
{
ms32_state *state = space->machine().driver_data<ms32_state>();
COMBINE_DATA(&state->m_f1superb_extraram_16[offset]);
tilemap_mark_tile_dirty(state->m_extra_tilemap,offset/2);
state->m_extra_tilemap->mark_tile_dirty(offset/2);
}
static READ16_HANDLER( ms32_extra_r16 )
{

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

@ -205,7 +205,7 @@ static TILE_GET_INFO( get_multfish_tile_info )
int code = state->m_vid[tile_index*2+0x0000] | (state->m_vid[tile_index*2+0x0001] << 8);
int attr = state->m_vid[tile_index*2+0x1000] | (state->m_vid[tile_index*2+0x1001] << 8);
tileinfo->category = (attr&0x100)>>8;
tileinfo.category = (attr&0x100)>>8;
SET_TILE_INFO(
0,
@ -234,11 +234,11 @@ static VIDEO_START(multfish)
state->save_item(NAME(state->m_vid));
state->m_tilemap = tilemap_create(machine,get_multfish_tile_info,tilemap_scan_rows,16,16, 64, 32);
tilemap_set_transparent_pen(state->m_tilemap,255);
state->m_tilemap->set_transparent_pen(255);
state->m_reel_tilemap = tilemap_create(machine,get_multfish_reel_tile_info,tilemap_scan_rows,16,16, 64, 64);
tilemap_set_transparent_pen(state->m_reel_tilemap,255);
tilemap_set_scroll_cols(state->m_reel_tilemap, 64);
state->m_reel_tilemap->set_transparent_pen(255);
state->m_reel_tilemap->set_scroll_cols(64);
}
static SCREEN_UPDATE_IND16(multfish)
@ -251,18 +251,18 @@ static SCREEN_UPDATE_IND16(multfish)
if (!state->m_disp_enable) return 0;
/* Draw lower part of static tilemap (low pri tiles) */
tilemap_draw(bitmap,cliprect,state->m_tilemap,TILEMAP_DRAW_CATEGORY(1),0);
state->m_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
/* Setup the column scroll and draw the reels */
for (i=0;i<64;i++)
{
int colscroll = (state->m_vid[i*2] | state->m_vid[i*2+1] << 8);
tilemap_set_scrolly(state->m_reel_tilemap, i, colscroll );
state->m_reel_tilemap->set_scrolly(i, colscroll );
}
tilemap_draw(bitmap,cliprect,state->m_reel_tilemap,0,0);
state->m_reel_tilemap->draw(bitmap, cliprect, 0,0);
/* Draw upper part of static tilemap (high pri tiles) */
tilemap_draw(bitmap,cliprect,state->m_tilemap,TILEMAP_DRAW_CATEGORY(0),0);
state->m_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(0),0);
return 0;
}
@ -276,13 +276,13 @@ static WRITE8_HANDLER( multfish_vid_w )
// 0x0000 - 0x1fff is normal tilemap
if (offset < 0x2000)
{
tilemap_mark_tile_dirty(state->m_tilemap,(offset&0xfff)/2);
state->m_tilemap->mark_tile_dirty((offset&0xfff)/2);
}
// 0x2000 - 0x2fff is for the reels
else if (offset < 0x4000)
{
tilemap_mark_tile_dirty(state->m_reel_tilemap,(offset&0x1fff)/2);
state->m_reel_tilemap->mark_tile_dirty((offset&0x1fff)/2);
}
else if (offset < 0x6000)
{

50
src/mame/drivers/mwarr.c
View File

@ -89,7 +89,7 @@ static WRITE16_HANDLER( bg_videoram_w )
mwarr_state *state = space->machine().driver_data<mwarr_state>();
COMBINE_DATA(&state->m_bg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( mlow_videoram_w )
@ -97,7 +97,7 @@ static WRITE16_HANDLER( mlow_videoram_w )
mwarr_state *state = space->machine().driver_data<mwarr_state>();
COMBINE_DATA(&state->m_mlow_videoram[offset]);
tilemap_mark_tile_dirty(state->m_mlow_tilemap,offset);
state->m_mlow_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( mhigh_videoram_w )
@ -105,7 +105,7 @@ static WRITE16_HANDLER( mhigh_videoram_w )
mwarr_state *state = space->machine().driver_data<mwarr_state>();
COMBINE_DATA(&state->m_mhigh_videoram[offset]);
tilemap_mark_tile_dirty(state->m_mhigh_tilemap,offset);
state->m_mhigh_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( tx_videoram_w )
@ -113,7 +113,7 @@ static WRITE16_HANDLER( tx_videoram_w )
mwarr_state *state = space->machine().driver_data<mwarr_state>();
COMBINE_DATA(&state->m_tx_videoram[offset]);
tilemap_mark_tile_dirty(state->m_tx_tilemap,offset);
state->m_tx_tilemap->mark_tile_dirty(offset);
}
static WRITE16_DEVICE_HANDLER( oki1_bank_w )
@ -384,13 +384,13 @@ static VIDEO_START( mwarr )
state->m_mhigh_tilemap = tilemap_create(machine, get_mhigh_tile_info, tilemap_scan_cols, 16, 16, 64, 16);
state->m_tx_tilemap = tilemap_create(machine, get_tx_tile_info, tilemap_scan_rows, 8, 8, 64, 32);
tilemap_set_transparent_pen(state->m_mlow_tilemap, 0);
tilemap_set_transparent_pen(state->m_mhigh_tilemap, 0);
tilemap_set_transparent_pen(state->m_tx_tilemap, 0);
state->m_mlow_tilemap->set_transparent_pen(0);
state->m_mhigh_tilemap->set_transparent_pen(0);
state->m_tx_tilemap->set_transparent_pen(0);
tilemap_set_scroll_rows(state->m_bg_tilemap, 256);
tilemap_set_scroll_rows(state->m_mlow_tilemap, 256);
tilemap_set_scroll_rows(state->m_mhigh_tilemap, 256);
state->m_bg_tilemap->set_scroll_rows(256);
state->m_mlow_tilemap->set_scroll_rows(256);
state->m_mhigh_tilemap->set_scroll_rows(256);
state->save_item(NAME(state->m_sprites_buffer));
}
@ -476,47 +476,47 @@ static SCREEN_UPDATE_IND16( mwarr )
if (BIT(state->m_vidattrram[6], 0))
{
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_bg_tilemap, i, state->m_bg_scrollram[i] + 20);
state->m_bg_tilemap->set_scrollx(i, state->m_bg_scrollram[i] + 20);
}
else
{
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_bg_tilemap, i, state->m_bg_scrollram[0] + 19);
state->m_bg_tilemap->set_scrollx(i, state->m_bg_scrollram[0] + 19);
}
if (BIT(state->m_vidattrram[6], 2))
{
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_mlow_tilemap, i, state->m_mlow_scrollram[i] + 19);
state->m_mlow_tilemap->set_scrollx(i, state->m_mlow_scrollram[i] + 19);
}
else
{
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_mlow_tilemap, i, state->m_mlow_scrollram[0] + 19);
state->m_mlow_tilemap->set_scrollx(i, state->m_mlow_scrollram[0] + 19);
}
if (BIT(state->m_vidattrram[6], 4))
{
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_mhigh_tilemap, i, state->m_mhigh_scrollram[i] + 19);
state->m_mhigh_tilemap->set_scrollx(i, state->m_mhigh_scrollram[i] + 19);
}
else
{
for (i = 0; i < 256; i++)
tilemap_set_scrollx(state->m_mhigh_tilemap, i, state->m_mhigh_scrollram[0] + 19);
state->m_mhigh_tilemap->set_scrollx(i, state->m_mhigh_scrollram[0] + 19);
}
tilemap_set_scrolly(state->m_bg_tilemap, 0, state->m_vidattrram[1] + 1);
tilemap_set_scrolly(state->m_mlow_tilemap, 0, state->m_vidattrram[2] + 1);
tilemap_set_scrolly(state->m_mhigh_tilemap, 0, state->m_vidattrram[3] + 1);
state->m_bg_tilemap->set_scrolly(0, state->m_vidattrram[1] + 1);
state->m_mlow_tilemap->set_scrolly(0, state->m_vidattrram[2] + 1);
state->m_mhigh_tilemap->set_scrolly(0, state->m_vidattrram[3] + 1);
tilemap_set_scrollx(state->m_tx_tilemap, 0, state->m_vidattrram[0] + 16);
tilemap_set_scrolly(state->m_tx_tilemap, 0, state->m_vidattrram[4] + 1);
state->m_tx_tilemap->set_scrollx(0, state->m_vidattrram[0] + 16);
state->m_tx_tilemap->set_scrolly(0, state->m_vidattrram[4] + 1);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0x01);
tilemap_draw(bitmap, cliprect, state->m_mlow_tilemap, 0, 0x02);
tilemap_draw(bitmap, cliprect, state->m_mhigh_tilemap, 0, 0x04);
tilemap_draw(bitmap, cliprect, state->m_tx_tilemap, 0, 0x10);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0x01);
state->m_mlow_tilemap->draw(bitmap, cliprect, 0, 0x02);
state->m_mhigh_tilemap->draw(bitmap, cliprect, 0, 0x04);
state->m_tx_tilemap->draw(bitmap, cliprect, 0, 0x10);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;
}

67
src/mame/drivers/namcoic.c
View File

@ -32,15 +32,15 @@ void namco_tilemap_invalidate( void )
int i;
for( i=0; i<6; i++ )
{
tilemap_mark_all_tiles_dirty( mTilemapInfo.tmap[i] );
mTilemapInfo.tmap[i]->mark_all_dirty();
}
} /* namco_tilemap_invalidate */
INLINE void get_tile_info(running_machine &machine,tile_data *tileinfo,int tile_index,UINT16 *vram)
INLINE void get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,UINT16 *vram)
{
int tile, mask;
mTilemapInfo.cb( machine, vram[tile_index], &tile, &mask );
tileinfo->mask_data = mTilemapInfo.maskBaseAddr+mask*8;
tileinfo.mask_data = mTilemapInfo.maskBaseAddr+mask*8;
SET_TILE_INFO(mTilemapInfo.gfxbank,tile,0,0);
} /* get_tile_info */
@ -76,15 +76,15 @@ namco_tilemap_init( running_machine &machine, int gfxbank, void *maskBaseAddr,
{
static const int adj[4] = { 4,2,1,0 };
int dx = 44+adj[i];
tilemap_set_scrolldx( mTilemapInfo.tmap[i], -dx, -(-384-dx) );
tilemap_set_scrolldy( mTilemapInfo.tmap[i], -24, 288 );
mTilemapInfo.tmap[i]->set_scrolldx( -dx, -(-384-dx) );
mTilemapInfo.tmap[i]->set_scrolldy( -24, 288 );
}
tilemap_set_scrolldx( mTilemapInfo.tmap[4], 0, 96 );
tilemap_set_scrolldy( mTilemapInfo.tmap[4], 0, 40 );
mTilemapInfo.tmap[4]->set_scrolldx( 0, 96 );
mTilemapInfo.tmap[4]->set_scrolldy( 0, 40 );
tilemap_set_scrolldx( mTilemapInfo.tmap[5], 0, 96 );
tilemap_set_scrolldy( mTilemapInfo.tmap[5], 0, 40 );
mTilemapInfo.tmap[5]->set_scrolldx( 0, 96 );
mTilemapInfo.tmap[5]->set_scrolldy( 0, 40 );
} /* namco_tilemap_init */
@ -98,8 +98,8 @@ namco_tilemap_draw( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
if( (mTilemapInfo.control[0x20/2+i]&0xf) == pri )
{
int color = mTilemapInfo.control[0x30/2+i] & 0x07;
tilemap_set_palette_offset( mTilemapInfo.tmap[i], color*256 );
tilemap_draw(bitmap,cliprect,mTilemapInfo.tmap[i],0,0);
mTilemapInfo.tmap[i]->set_palette_offset( color*256 );
mTilemapInfo.tmap[i]->draw(bitmap,cliprect,0,0);
}
}
} /* namco_tilemap_draw */
@ -110,17 +110,17 @@ SetTilemapVideoram( int offset, UINT16 newword )
mTilemapInfo.videoram[offset] = newword;
if( offset<0x4000 )
{
tilemap_mark_tile_dirty(mTilemapInfo.tmap[offset>>12],offset&0xfff);
mTilemapInfo.tmap[offset>>12]->mark_tile_dirty(offset&0xfff);
}
else if( offset>=0x8010/2 && offset<0x87f0/2 )
{ /* fixed plane#1 */
offset-=0x8010/2;
tilemap_mark_tile_dirty( mTilemapInfo.tmap[4], offset );
mTilemapInfo.tmap[4]->mark_tile_dirty( offset );
}
else if( offset>=0x8810/2 && offset<0x8ff0/2 )
{ /* fixed plane#2 */
offset-=0x8810/2;
tilemap_mark_tile_dirty( mTilemapInfo.tmap[5], offset );
mTilemapInfo.tmap[5]->mark_tile_dirty( offset );
}
} /* SetTilemapVideoram */
@ -149,7 +149,7 @@ SetTilemapControl( int offset, UINT16 newword )
int i;
for( i=0; i<=5; i++ )
{
tilemap_set_flip(mTilemapInfo.tmap[i],attrs);
mTilemapInfo.tmap[i]->set_flip(attrs);
}
}
}
@ -161,28 +161,28 @@ SetTilemapControl( int offset, UINT16 newword )
switch( offset )
{
case 0x02/2:
tilemap_set_scrollx( mTilemapInfo.tmap[0], 0, newword );
mTilemapInfo.tmap[0]->set_scrollx( 0, newword );
break;
case 0x06/2:
tilemap_set_scrolly( mTilemapInfo.tmap[0], 0, newword );
mTilemapInfo.tmap[0]->set_scrolly( 0, newword );
break;
case 0x0a/2:
tilemap_set_scrollx( mTilemapInfo.tmap[1], 0, newword );
mTilemapInfo.tmap[1]->set_scrollx( 0, newword );
break;
case 0x0e/2:
tilemap_set_scrolly( mTilemapInfo.tmap[1], 0, newword );
mTilemapInfo.tmap[1]->set_scrolly( 0, newword );
break;
case 0x12/2:
tilemap_set_scrollx( mTilemapInfo.tmap[2], 0, newword );
mTilemapInfo.tmap[2]->set_scrollx( 0, newword );
break;
case 0x16/2:
tilemap_set_scrolly( mTilemapInfo.tmap[2], 0, newword );
mTilemapInfo.tmap[2]->set_scrolly( 0, newword );
break;
case 0x1a/2:
tilemap_set_scrollx( mTilemapInfo.tmap[3], 0, newword );
mTilemapInfo.tmap[3]->set_scrollx( 0, newword );
break;
case 0x1e/2:
tilemap_set_scrolly( mTilemapInfo.tmap[3], 0, newword );
mTilemapInfo.tmap[3]->set_scrolly( 0, newword );
break;
}
} /* SetTilemapControl */
@ -1039,7 +1039,7 @@ static const char * mRozMaskRegion;
* Graphics ROM addressing varies across games.
*/
static void
roz_get_info( running_machine &machine, tile_data *tileinfo, int tile_index, int which)
roz_get_info( running_machine &machine, tile_data &tileinfo, int tile_index, int which)
{
UINT16 tile = rozvideoram16[tile_index];
int bank, mangle;
@ -1100,7 +1100,7 @@ roz_get_info( running_machine &machine, tile_data *tileinfo, int tile_index, int
break;
}
SET_TILE_INFO( mRozGfxBank,mangle,0/*color*/,0/*flag*/ );
tileinfo->mask_data = 32*tile + (UINT8 *)machine.region( mRozMaskRegion )->base();
tileinfo.mask_data = 32*tile + (UINT8 *)machine.region( mRozMaskRegion )->base();
} /* roz_get_info */
static
@ -1233,8 +1233,8 @@ DrawRozHelper(
(namcos2_gametype != NAMCOFL_FINAL_LAP_R))
{
UINT32 size_mask = rozInfo->size-1;
bitmap_ind16 &srcbitmap = tilemap_get_pixmap( tmap );
bitmap_ind8 &flagsbitmap = tilemap_get_flagsmap( tmap );
bitmap_ind16 &srcbitmap = tmap->pixmap();
bitmap_ind8 &flagsbitmap = tmap->flagsmap();
UINT32 startx = rozInfo->startx + clip.min_x * rozInfo->incxx + clip.min_y * rozInfo->incyx;
UINT32 starty = rozInfo->starty + clip.min_x * rozInfo->incxy + clip.min_y * rozInfo->incyy;
int sx = clip.min_x;
@ -1266,12 +1266,11 @@ DrawRozHelper(
else
{
tilemap_set_palette_offset( tmap, rozInfo->color );
tmap->set_palette_offset( rozInfo->color );
tilemap_draw_roz(
tmap->draw_roz(
bitmap,
clip,
tmap,
rozInfo->startx, rozInfo->starty,
rozInfo->incxx, rozInfo->incxy,
rozInfo->incyx, rozInfo->incyy,
@ -1366,7 +1365,7 @@ WRITE16_HANDLER( namco_rozbank16_w )
int i;
for( i=0; i<ROZ_TILEMAP_COUNT; i++ )
{
tilemap_mark_all_tiles_dirty( mRozTilemap[i] );
mRozTilemap[i]->mark_all_dirty();
}
}
} /* namco_rozbank16_w */
@ -1379,7 +1378,7 @@ writerozvideo( int offset, UINT16 data )
rozvideoram16[offset] = data;
for( i=0; i<ROZ_TILEMAP_COUNT; i++ )
{
tilemap_mark_tile_dirty( mRozTilemap[i], offset );
mRozTilemap[i]->mark_tile_dirty( offset );
}
} /* writerozvideo */
@ -1564,7 +1563,7 @@ WRITE16_HANDLER( namco_road16_w )
COMBINE_DATA( &mpRoadRAM[offset] );
if( offset<0x10000/2 )
{
tilemap_mark_tile_dirty( mpRoadTilemap, offset );
mpRoadTilemap->mark_tile_dirty( offset );
}
else
{
@ -1608,7 +1607,7 @@ namco_road_draw(running_machine &machine, bitmap_ind16 &bitmap, const rectangle
unsigned yscroll;
int i;
bitmap_ind16 &SourceBitmap = tilemap_get_pixmap(mpRoadTilemap);
bitmap_ind16 &SourceBitmap = mpRoadTilemap->pixmap();
yscroll = mpRoadRAM[0x1fdfe/2];
for( i=cliprect.min_y; i<=cliprect.max_y; i++ )

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

@ -1154,8 +1154,8 @@ static WRITE32_HANDLER( namcos23_textram_w )
{
namcos23_state *state = space->machine().driver_data<namcos23_state>();
COMBINE_DATA( &state->m_textram[offset] );
tilemap_mark_tile_dirty(state->m_bgtilemap, offset*2);
tilemap_mark_tile_dirty(state->m_bgtilemap, (offset*2)+1);
state->m_bgtilemap->mark_tile_dirty(offset*2);
state->m_bgtilemap->mark_tile_dirty((offset*2)+1);
}
static WRITE32_HANDLER( s23_txtchar_w )
@ -1470,11 +1470,11 @@ static WRITE16_HANDLER(s23_c361_w)
switch(offset) {
case 0:
tilemap_set_scrollx(state->m_bgtilemap, 0, data&0xfff);
state->m_bgtilemap->set_scrollx(0, data&0xfff);
break;
case 1:
tilemap_set_scrolly(state->m_bgtilemap, 0, data&0xfff);
state->m_bgtilemap->set_scrolly(0, data&0xfff);
break;
case 4: // interrupt control
@ -2117,18 +2117,18 @@ static VIDEO_START( ss23 )
namcos23_state *state = machine.driver_data<namcos23_state>();
gfx_element_set_source(machine.gfx[0], (UINT8 *)state->m_charram);
state->m_bgtilemap = tilemap_create(machine, TextTilemapGetInfo, tilemap_scan_rows, 16, 16, 64, 64);
tilemap_set_transparent_pen(state->m_bgtilemap, 0xf);
state->m_bgtilemap->set_transparent_pen(0xf);
// Gorgon's tilemap offset is 0, S23/SS23's is 860
if ((!strcmp(machine.system().name, "rapidrvr")) ||
(!strcmp(machine.system().name, "rapidrvr2")) ||
(!strcmp(machine.system().name, "finlflng")))
{
tilemap_set_scrolldx(state->m_bgtilemap, 0, 0);
state->m_bgtilemap->set_scrolldx(0, 0);
}
else
{
tilemap_set_scrolldx(state->m_bgtilemap, 860, 860);
state->m_bgtilemap->set_scrolldx(860, 860);
}
state->m_render.polymgr = poly_alloc(machine, 10000, sizeof(namcos23_render_data), POLYFLAG_NO_WORK_QUEUE);
}
@ -2143,7 +2143,7 @@ static SCREEN_UPDATE_RGB32( ss23 )
gfx_element *gfx = screen.machine().gfx[0];
memset(gfx->dirty, 1, gfx->total_elements);
tilemap_draw( bitmap, cliprect, state->m_bgtilemap, 0/*flags*/, 0/*priority*/ ); /* opaque */
state->m_bgtilemap->draw(bitmap, cliprect, 0/*flags*/, 0/*priority*/ ); /* opaque */
return 0;
}

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

@ -262,14 +262,14 @@ static WRITE16_HANDLER( fg_videoram_w )
{
nmg5_state *state = space->machine().driver_data<nmg5_state>();
COMBINE_DATA(&state->m_fg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset);
state->m_fg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( bg_videoram_w )
{
nmg5_state *state = space->machine().driver_data<nmg5_state>();
COMBINE_DATA(&state->m_bg_videoram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( nmg5_soundlatch_w )
@ -302,7 +302,7 @@ static WRITE16_HANDLER( gfx_bank_w )
if (state->m_gfx_bank != (data & 3))
{
state->m_gfx_bank = data & 3;
tilemap_mark_all_tiles_dirty_all(space->machine());
space->machine().tilemap().mark_all_dirty();
}
}
@ -827,7 +827,7 @@ static INPUT_PORTS_START( wondstck )
INPUT_PORTS_END
INLINE void get_tile_info( running_machine &machine, tile_data *tileinfo, int tile_index, UINT16 *vram, int color )
INLINE void get_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, UINT16 *vram, int color )
{
nmg5_state *state = machine.driver_data<nmg5_state>();
SET_TILE_INFO(0, vram[tile_index] | (state->m_gfx_bank << 16), color, 0);
@ -842,7 +842,7 @@ static VIDEO_START( nmg5 )
state->m_bg_tilemap = tilemap_create(machine, bg_get_tile_info, tilemap_scan_rows, 8, 8, 64, 64);
state->m_fg_tilemap = tilemap_create(machine, fg_get_tile_info, tilemap_scan_rows, 8, 8, 64, 64);
tilemap_set_transparent_pen(state->m_fg_tilemap, 0);
state->m_fg_tilemap->set_transparent_pen(0);
}
static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
@ -915,40 +915,40 @@ static SCREEN_UPDATE_IND16( nmg5 )
{
nmg5_state *state = screen.machine().driver_data<nmg5_state>();
tilemap_set_scrolly(state->m_bg_tilemap, 0, state->m_scroll_ram[3] + 9);
tilemap_set_scrollx(state->m_bg_tilemap, 0, state->m_scroll_ram[2] + 3);
tilemap_set_scrolly(state->m_fg_tilemap, 0, state->m_scroll_ram[1] + 9);
tilemap_set_scrollx(state->m_fg_tilemap, 0, state->m_scroll_ram[0] - 1);
state->m_bg_tilemap->set_scrolly(0, state->m_scroll_ram[3] + 9);
state->m_bg_tilemap->set_scrollx(0, state->m_scroll_ram[2] + 3);
state->m_fg_tilemap->set_scrolly(0, state->m_scroll_ram[1] + 9);
state->m_fg_tilemap->set_scrollx(0, state->m_scroll_ram[0] - 1);
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
if (state->m_priority_reg == 0)
{
draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_bitmap(screen.machine(), bitmap);
}
else if (state->m_priority_reg == 1)
{
draw_bitmap(screen.machine(), bitmap);
draw_sprites(screen.machine(), bitmap, cliprect);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
}
else if (state->m_priority_reg == 2)
{
draw_sprites(screen.machine(), bitmap, cliprect);
draw_bitmap(screen.machine(), bitmap);
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
}
else if (state->m_priority_reg == 3)
{
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
draw_bitmap(screen.machine(), bitmap);
}
else if (state->m_priority_reg == 7)
{
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_bitmap(screen.machine(), bitmap);
draw_sprites(screen.machine(), bitmap, cliprect);
}

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

@ -85,7 +85,7 @@ static WRITE8_HANDLER( nsmpoker_videoram_w )
{
nsmpoker_state *state = space->machine().driver_data<nsmpoker_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -93,7 +93,7 @@ static WRITE8_HANDLER( nsmpoker_colorram_w )
{
nsmpoker_state *state = space->machine().driver_data<nsmpoker_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
@ -125,7 +125,7 @@ static VIDEO_START( nsmpoker )
static SCREEN_UPDATE_IND16( nsmpoker )
{
nsmpoker_state *state = screen.machine().driver_data<nsmpoker_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -120,14 +120,14 @@ static WRITE8_HANDLER( olibochu_videoram_w )
{
olibochu_state *state = space->machine().driver_data<olibochu_state>();
state->m_videoram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( olibochu_colorram_w )
{
olibochu_state *state = space->machine().driver_data<olibochu_state>();
state->m_colorram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE8_HANDLER( olibochu_flipscreen_w )
@ -135,7 +135,7 @@ static WRITE8_HANDLER( olibochu_flipscreen_w )
if (flip_screen_get(space->machine()) != (data & 0x80))
{
flip_screen_set(space->machine(), data & 0x80);
tilemap_mark_all_tiles_dirty_all(space->machine());
space->machine().tilemap().mark_all_dirty();
}
/* other bits are used, but unknown */
@ -221,7 +221,7 @@ static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const
static SCREEN_UPDATE_IND16( olibochu )
{
olibochu_state *state = screen.machine().driver_data<olibochu_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;
}

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

@ -93,7 +93,7 @@ static VIDEO_START( onetwo )
static SCREEN_UPDATE_IND16( onetwo )
{
onetwo_state *state = screen.machine().driver_data<onetwo_state>();
tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}
@ -107,7 +107,7 @@ static WRITE8_HANDLER( onetwo_fgram_w )
{
onetwo_state *state = space->machine().driver_data<onetwo_state>();
state->m_fgram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset / 2);
state->m_fg_tilemap->mark_tile_dirty(offset / 2);
}
static WRITE8_HANDLER( onetwo_cpubank_w )

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

@ -189,7 +189,7 @@ static WRITE8_HANDLER( pacland_flipscreen_w )
int bit = !BIT(offset,11);
/* can't use flip_screen_set(space->machine(), ) because the visible area is asymmetrical */
flip_screen_set_no_update(space->machine(), bit);
tilemap_set_flip_all(space->machine(),flip_screen_get(space->machine()) ? (TILEMAP_FLIPX | TILEMAP_FLIPY) : 0);
space->machine().tilemap().set_flip_all(flip_screen_get(space->machine()) ? (TILEMAP_FLIPX | TILEMAP_FLIPY) : 0);
}

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

@ -162,7 +162,7 @@ static TILE_GET_INFO( get_txttile_info )
int attr=videoram[tile_index*4+2];
int color = attr & 0x07;
tileinfo->group = color;
tileinfo.group = color;
SET_TILE_INFO(
0,
@ -243,11 +243,11 @@ static SCREEN_UPDATE_IND16( panicr)
{
panicr_state *state = screen.machine().driver_data<panicr_state>();
bitmap.fill(get_black_pen(screen.machine()), cliprect);
tilemap_mark_all_tiles_dirty( state->m_txttilemap );
tilemap_set_scrollx( state->m_bgtilemap,0, ((state->m_scrollram[0x02]&0x0f)<<12)+((state->m_scrollram[0x02]&0xf0)<<4)+((state->m_scrollram[0x04]&0x7f)<<1)+((state->m_scrollram[0x04]&0x80)>>7) );
tilemap_draw(bitmap,cliprect,state->m_bgtilemap,0,0);
state->m_txttilemap ->mark_all_dirty();
state->m_bgtilemap->set_scrollx(0, ((state->m_scrollram[0x02]&0x0f)<<12)+((state->m_scrollram[0x02]&0xf0)<<4)+((state->m_scrollram[0x04]&0x7f)<<1)+((state->m_scrollram[0x04]&0x80)>>7) );
state->m_bgtilemap->draw(bitmap, cliprect, 0,0);
draw_sprites(screen.machine(),bitmap,cliprect);
tilemap_draw(bitmap,cliprect,state->m_txttilemap,0,0);
state->m_txttilemap->draw(bitmap, cliprect, 0,0);
return 0;
}

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

@ -341,7 +341,7 @@ static WRITE8_HANDLER( peplus_crtc_display_w )
state->m_palette_ram[state->m_vid_address] = state->m_io_port[1];
state->m_palette_ram2[state->m_vid_address] = state->m_io_port[3];
tilemap_mark_tile_dirty(state->m_bg_tilemap, state->m_vid_address);
state->m_bg_tilemap->mark_tile_dirty(state->m_vid_address);
/* An access here triggers a device read !*/
space->machine().device<mc6845_device>("crtc")->register_r(*space, 0);
@ -675,7 +675,7 @@ static VIDEO_START( peplus )
static SCREEN_UPDATE_IND16( peplus )
{
peplus_state *state = screen.machine().driver_data<peplus_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
return 0;
}

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

@ -121,14 +121,14 @@ static VIDEO_START ( pipeline )
state->m_palram=auto_alloc_array(machine, UINT8, 0x1000);
state->m_tilemap1 = tilemap_create( machine, get_tile_info,tilemap_scan_rows,8,8,64,32 );
state->m_tilemap2 = tilemap_create( machine, get_tile_info2,tilemap_scan_rows,8,8,64,32 );
tilemap_set_transparent_pen(state->m_tilemap2,0);
state->m_tilemap2->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( pipeline )
{
pipeline_state *state = screen.machine().driver_data<pipeline_state>();
tilemap_draw(bitmap,cliprect,state->m_tilemap1, 0,0);
tilemap_draw(bitmap,cliprect,state->m_tilemap2, 0,0);
state->m_tilemap1->draw(bitmap, cliprect, 0,0);
state->m_tilemap2->draw(bitmap, cliprect, 0,0);
return 0;
}
@ -144,7 +144,7 @@ static WRITE8_HANDLER(vram2_w)
pipeline_state *state = space->machine().driver_data<pipeline_state>();
if(!(state->m_vidctrl&1))
{
tilemap_mark_tile_dirty(state->m_tilemap1,offset&0x7ff);
state->m_tilemap1->mark_tile_dirty(offset&0x7ff);
state->m_vram2[offset]=data;
}
else
@ -161,7 +161,7 @@ static WRITE8_HANDLER(vram2_w)
static WRITE8_HANDLER(vram1_w)
{
pipeline_state *state = space->machine().driver_data<pipeline_state>();
tilemap_mark_tile_dirty(state->m_tilemap2,offset&0x7ff);
state->m_tilemap2->mark_tile_dirty(offset&0x7ff);
state->m_vram1[offset]=data;
}

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

@ -41,21 +41,21 @@ static WRITE16_HANDLER( pkscramble_fgtilemap_w )
{
pkscram_state *state = space->machine().driver_data<pkscram_state>();
COMBINE_DATA(&state->m_pkscramble_fgtilemap_ram[offset]);
tilemap_mark_tile_dirty(state->m_fg_tilemap, offset >> 1);
state->m_fg_tilemap->mark_tile_dirty(offset >> 1);
}
static WRITE16_HANDLER( pkscramble_mdtilemap_w )
{
pkscram_state *state = space->machine().driver_data<pkscram_state>();
COMBINE_DATA(&state->m_pkscramble_mdtilemap_ram[offset]);
tilemap_mark_tile_dirty(state->m_md_tilemap, offset >> 1);
state->m_md_tilemap->mark_tile_dirty(offset >> 1);
}
static WRITE16_HANDLER( pkscramble_bgtilemap_w )
{
pkscram_state *state = space->machine().driver_data<pkscram_state>();
COMBINE_DATA(&state->m_pkscramble_bgtilemap_ram[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset >> 1);
state->m_bg_tilemap->mark_tile_dirty(offset >> 1);
}
// input bit 0x20 in port1 should stay low until bit 0x20 is written here, then
@ -234,16 +234,16 @@ static VIDEO_START( pkscramble )
state->m_md_tilemap = tilemap_create(machine, get_md_tile_info, tilemap_scan_rows, 8, 8,32,32);
state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, tilemap_scan_rows, 8, 8,32,32);
tilemap_set_transparent_pen(state->m_md_tilemap,15);
tilemap_set_transparent_pen(state->m_fg_tilemap,15);
state->m_md_tilemap->set_transparent_pen(15);
state->m_fg_tilemap->set_transparent_pen(15);
}
static SCREEN_UPDATE_IND16( pkscramble )
{
pkscram_state *state = screen.machine().driver_data<pkscram_state>();
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_md_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
state->m_md_tilemap->draw(bitmap, cliprect, 0,0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}

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

@ -50,7 +50,7 @@ static WRITE16_HANDLER( magicstk_bgvideoram_w )
playmark_state *state = space->machine().driver_data<playmark_state>();
COMBINE_DATA(&state->m_videoram1[offset]);
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
state->m_bg_tilemap->mark_tile_dirty(offset);
}
static WRITE16_HANDLER( tile_banking_w )
@ -60,7 +60,7 @@ static WRITE16_HANDLER( tile_banking_w )
if (((data >> 12) & 0x0f) != state->m_tilebank)
{
state->m_tilebank = (data >> 12) & 0x0f;
tilemap_mark_all_tiles_dirty(state->m_bg_tilemap);
state->m_bg_tilemap->mark_all_dirty();
}
}
@ -425,14 +425,14 @@ static VIDEO_START( powerbal )
state->m_xoffset = -20;
tilemap_set_scrolly(state->m_bg_tilemap, 0, state->m_bg_yoffset);
state->m_bg_tilemap->set_scrolly(0, state->m_bg_yoffset);
}
static SCREEN_UPDATE_IND16( powerbal )
{
playmark_state *state = screen.machine().driver_data<playmark_state>();
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_sprites(screen.machine(), bitmap, cliprect);
return 0;
}

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

@ -155,14 +155,14 @@ static WRITE8_HANDLER( ppmast93_fgram_w )
{
ppmast93_state *state = space->machine().driver_data<ppmast93_state>();
state->m_fgram[offset] = data;
tilemap_mark_tile_dirty(state->m_fg_tilemap,offset/2);
state->m_fg_tilemap->mark_tile_dirty(offset/2);
}
static WRITE8_HANDLER( ppmast93_bgram_w )
{
ppmast93_state *state = space->machine().driver_data<ppmast93_state>();
state->m_bgram[offset] = data;
tilemap_mark_tile_dirty(state->m_bg_tilemap,offset/2);
state->m_bg_tilemap->mark_tile_dirty(offset/2);
}
static WRITE8_HANDLER( ppmast93_port4_w )
@ -346,14 +346,14 @@ static VIDEO_START( ppmast93 )
state->m_bg_tilemap = tilemap_create(machine, get_ppmast93_bg_tile_info,tilemap_scan_rows,8,8,32, 32);
state->m_fg_tilemap = tilemap_create(machine, get_ppmast93_fg_tile_info,tilemap_scan_rows,8,8,32, 32);
tilemap_set_transparent_pen(state->m_fg_tilemap,0);
state->m_fg_tilemap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16( ppmast93 )
{
ppmast93_state *state = screen.machine().driver_data<ppmast93_state>();
tilemap_draw(bitmap,cliprect,state->m_bg_tilemap,0,0);
tilemap_draw(bitmap,cliprect,state->m_fg_tilemap,0,0);
state->m_bg_tilemap->draw(bitmap, cliprect, 0,0);
state->m_fg_tilemap->draw(bitmap, cliprect, 0,0);
return 0;
}

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

@ -141,9 +141,9 @@ static VIDEO_START(pturn)
{
pturn_state *state = machine.driver_data<pturn_state>();
state->m_fgmap = tilemap_create(machine, get_pturn_tile_info,tilemap_scan_rows,8, 8,32,32);
tilemap_set_transparent_pen(state->m_fgmap,0);
state->m_fgmap->set_transparent_pen(0);
state->m_bgmap = tilemap_create(machine, get_pturn_bg_tile_info,tilemap_scan_rows,8, 8,32,32*8);
tilemap_set_transparent_pen(state->m_bgmap,0);
state->m_bgmap->set_transparent_pen(0);
}
static SCREEN_UPDATE_IND16(pturn)
@ -155,7 +155,7 @@ static SCREEN_UPDATE_IND16(pturn)
int flipx, flipy;
bitmap.fill(state->m_bgcolor, cliprect);
tilemap_draw(bitmap,cliprect,state->m_bgmap,0,0);
state->m_bgmap->draw(bitmap, cliprect, 0,0);
for ( offs = 0x80-4 ; offs >=0 ; offs -= 4)
{
sy=256-spriteram[offs]-16 ;
@ -186,7 +186,7 @@ static SCREEN_UPDATE_IND16(pturn)
sx,sy,0);
}
}
tilemap_draw(bitmap,cliprect,state->m_fgmap,0,0);
state->m_fgmap->draw(bitmap, cliprect, 0,0);
return 0;
}
@ -207,7 +207,7 @@ static WRITE8_HANDLER( pturn_videoram_w )
pturn_state *state = space->machine().driver_data<pturn_state>();
UINT8 *videoram = state->m_videoram;
videoram[offset]=data;
tilemap_mark_tile_dirty(state->m_fgmap,offset);
state->m_fgmap->mark_tile_dirty(offset);
}
@ -238,36 +238,36 @@ static WRITE8_HANDLER(bgcolor_w)
static WRITE8_HANDLER(bg_scrollx_w)
{
pturn_state *state = space->machine().driver_data<pturn_state>();
tilemap_set_scrolly(state->m_bgmap, 0, (data>>5)*32*8);
state->m_bgmap->set_scrolly(0, (data>>5)*32*8);
state->m_bgpalette=data&0x1f;
tilemap_mark_all_tiles_dirty(state->m_bgmap);
state->m_bgmap->mark_all_dirty();
}
static WRITE8_HANDLER(fgpalette_w)
{
pturn_state *state = space->machine().driver_data<pturn_state>();
state->m_fgpalette=data&0x1f;
tilemap_mark_all_tiles_dirty(state->m_fgmap);
state->m_fgmap->mark_all_dirty();
}
static WRITE8_HANDLER(bg_scrolly_w)
{
pturn_state *state = space->machine().driver_data<pturn_state>();
tilemap_set_scrollx(state->m_bgmap, 0, data);
state->m_bgmap->set_scrollx(0, data);
}
static WRITE8_HANDLER(fgbank_w)
{
pturn_state *state = space->machine().driver_data<pturn_state>();
state->m_fgbank=data&1;
tilemap_mark_all_tiles_dirty(state->m_fgmap);
state->m_fgmap->mark_all_dirty();
}
static WRITE8_HANDLER(bgbank_w)
{
pturn_state *state = space->machine().driver_data<pturn_state>();
state->m_bgbank=data&1;
tilemap_mark_all_tiles_dirty(state->m_bgmap);
state->m_bgmap->mark_all_dirty();
}
static WRITE8_HANDLER(flip_w)

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