Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-10 00:01:52 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Renamed tilemap -> tilemap_t, as the name 'tilemap' is too commonly

Browse Source 
used for statics and structure members, and some compilers (esp. C++
compilers) don't allow that.
This commit is contained in:
Aaron Giles 2009-12-28 05:45:20 +00:00
parent 922d9fabc9
commit 4e9be151f7
529 changed files with 876 additions and 876 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/emupal.c
View File

@ -465,7 +465,7 @@ UINT32 colortable_get_transpen_mask(colortable_t *ctable, const gfx_element *gfx
(each group maps to a gfx color) (each group maps to a gfx color)
-------------------------------------------------*/ -------------------------------------------------*/
void colortable_configure_tilemap_groups(colortable_t *ctable, tilemap *tmap, const gfx_element *gfx, int transcolor) void colortable_configure_tilemap_groups(colortable_t *ctable, tilemap_t *tmap, const gfx_element *gfx, int transcolor)
{ {
int color; int color;

2
src/emu/emupal.h
View File

@ -169,7 +169,7 @@ rgb_t colortable_palette_get_color(colortable_t *ctable, UINT32 entry);
UINT32 colortable_get_transpen_mask(colortable_t *ctable, const gfx_element *gfx, int color, int transcolor); UINT32 colortable_get_transpen_mask(colortable_t *ctable, const gfx_element *gfx, int color, int transcolor);
/* configure groups in a tilemap to represent transparency based on colortable entries (each group maps to a gfx color) */ /* configure groups in a tilemap to represent transparency based on colortable entries (each group maps to a gfx color) */
void colortable_configure_tilemap_groups(colortable_t *ctable, tilemap *tmap, const gfx_element *gfx, int transcolor); void colortable_configure_tilemap_groups(colortable_t *ctable, tilemap_t *tmap, const gfx_element *gfx, int transcolor);
/* return the number of entries in a colortable */ /* return the number of entries in a colortable */
UINT32 colortable_palette_get_size(colortable_t *ctable); UINT32 colortable_palette_get_size(colortable_t *ctable);

134
src/emu/tilemap.c
View File

@ -66,9 +66,9 @@ struct _blit_parameters
/* core tilemap structure */ /* core tilemap structure */
struct _tilemap struct _tilemap_t
{ {
tilemap * next; /* pointer to next tilemap */ tilemap_t * next; /* pointer to next tilemap */
running_machine * machine; /* pointer back to the owning machine */ running_machine * machine; /* pointer back to the owning machine */
/* basic tilemap metrics */ /* basic tilemap metrics */
@ -124,8 +124,8 @@ struct _tilemap
struct _tilemap_private struct _tilemap_private
{ {
tilemap * list; tilemap_t * list;
tilemap ** tailptr; tilemap_t ** tailptr;
int instance; int instance;
}; };
@ -136,25 +136,25 @@ struct _tilemap_private
***************************************************************************/ ***************************************************************************/
/* system management helpers */ /* system management helpers */
static tilemap *tilemap_create_common(running_machine *machine, void *get_info_object, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows); static tilemap_t *tilemap_create_common(running_machine *machine, void *get_info_object, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows);
static void tilemap_exit(running_machine *machine); static void tilemap_exit(running_machine *machine);
static STATE_POSTLOAD( tilemap_postload ); static STATE_POSTLOAD( tilemap_postload );
static void tilemap_dispose(tilemap *tmap); static void tilemap_dispose(tilemap_t *tmap);
/* logical <-> memory index mapping */ /* logical <-> memory index mapping */
static void mappings_create(tilemap *tmap); static void mappings_create(tilemap_t *tmap);
static void mappings_update(tilemap *tmap); static void mappings_update(tilemap_t *tmap);
/* tile rendering */ /* tile rendering */
static void pixmap_update(tilemap *tmap, const rectangle *cliprect); static void pixmap_update(tilemap_t *tmap, const rectangle *cliprect);
static void tile_update(tilemap *tmap, tilemap_logical_index logindex, UINT32 cached_col, UINT32 cached_row); static void tile_update(tilemap_t *tmap, tilemap_logical_index logindex, UINT32 cached_col, UINT32 cached_row);
static UINT8 tile_draw(tilemap *tmap, const UINT8 *pendata, UINT32 x0, UINT32 y0, UINT32 palette_base, UINT8 category, UINT8 group, UINT8 flags, UINT8 pen_mask); static UINT8 tile_draw(tilemap_t *tmap, const UINT8 *pendata, UINT32 x0, UINT32 y0, UINT32 palette_base, UINT8 category, UINT8 group, UINT8 flags, UINT8 pen_mask);
static UINT8 tile_apply_bitmask(tilemap *tmap, const UINT8 *maskdata, UINT32 x0, UINT32 y0, UINT8 category, UINT8 flags); static UINT8 tile_apply_bitmask(tilemap_t *tmap, const UINT8 *maskdata, UINT32 x0, UINT32 y0, UINT8 category, UINT8 flags);
/* drawing helpers */ /* drawing helpers */
static void configure_blit_parameters(blit_parameters *blit, tilemap *tmap, bitmap_t *dest, const rectangle *cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask); static void configure_blit_parameters(blit_parameters *blit, tilemap_t *tmap, bitmap_t *dest, const rectangle *cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask);
static void tilemap_draw_instance(tilemap *tmap, const blit_parameters *blit, int xpos, int ypos); static void tilemap_draw_instance(tilemap_t *tmap, const blit_parameters *blit, int xpos, int ypos);
static void tilemap_draw_roz_core(tilemap *tmap, const blit_parameters *blit, static void tilemap_draw_roz_core(tilemap_t *tmap, const blit_parameters *blit,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound); UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound);
/* scanline rasterizers for drawing to the pixmap */ /* scanline rasterizers for drawing to the pixmap */
@ -183,7 +183,7 @@ static void scanline_draw_masked_rgb32_alpha(void *dest, const UINT16 *source, c
account tilemap flip states account tilemap flip states
-------------------------------------------------*/ -------------------------------------------------*/
INLINE INT32 effective_rowscroll(tilemap *tmap, int index, UINT32 screen_width) INLINE INT32 effective_rowscroll(tilemap_t *tmap, int index, UINT32 screen_width)
{ {
INT32 value; INT32 value;
@ -212,7 +212,7 @@ INLINE INT32 effective_rowscroll(tilemap *tmap, int index, UINT32 screen_width)
account tilemap flip states account tilemap flip states
-------------------------------------------------*/ -------------------------------------------------*/
INLINE INT32 effective_colscroll(tilemap *tmap, int index, UINT32 screen_height) INLINE INT32 effective_colscroll(tilemap_t *tmap, int index, UINT32 screen_height)
{ {
INT32 value; INT32 value;
@ -239,9 +239,9 @@ INLINE INT32 effective_colscroll(tilemap *tmap, int index, UINT32 screen_height)
indexed_tilemap - return a tilemap by index indexed_tilemap - return a tilemap by index
-------------------------------------------------*/ -------------------------------------------------*/
INLINE tilemap *indexed_tilemap(running_machine *machine, int index) INLINE tilemap_t *indexed_tilemap(running_machine *machine, int index)
{ {
tilemap *tmap; tilemap_t *tmap;
/* find by the tilemap index */ /* find by the tilemap index */
for (tmap = machine->tilemap_data->list; tmap != NULL; tmap = tmap->next) for (tmap = machine->tilemap_data->list; tmap != NULL; tmap = tmap->next)
@ -258,7 +258,7 @@ INLINE tilemap *indexed_tilemap(running_machine *machine, int index)
changed changed
-------------------------------------------------*/ -------------------------------------------------*/
INLINE int gfx_elements_changed(tilemap *tmap) INLINE int gfx_elements_changed(tilemap_t *tmap)
{ {
UINT32 usedmask = tmap->gfx_used; UINT32 usedmask = tmap->gfx_used;
int isdirty = FALSE; int isdirty = FALSE;
@ -312,7 +312,7 @@ void tilemap_init(running_machine *machine)
tilemap_create - create a new tilemap tilemap_create - create a new tilemap
-------------------------------------------------*/ -------------------------------------------------*/
tilemap *tilemap_create(running_machine *machine, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows) tilemap_t *tilemap_create(running_machine *machine, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows)
{ {
return tilemap_create_common(machine, (void *)machine, tile_get_info, mapper, tilewidth, tileheight, cols, rows); return tilemap_create_common(machine, (void *)machine, tile_get_info, mapper, tilewidth, tileheight, cols, rows);
} }
@ -323,7 +323,7 @@ tilemap *tilemap_create(running_machine *machine, tile_get_info_func tile_get_in
is owned by a device is owned by a device
-------------------------------------------------*/ -------------------------------------------------*/
tilemap *tilemap_create_device(const device_config *device, tile_get_info_device_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows) tilemap_t *tilemap_create_device(const device_config *device, tile_get_info_device_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows)
{ {
return tilemap_create_common(device->machine, (void *)device, (tile_get_info_func)tile_get_info, mapper, tilewidth, tileheight, cols, rows); return tilemap_create_common(device->machine, (void *)device, (tile_get_info_func)tile_get_info, mapper, tilewidth, tileheight, cols, rows);
} }
@ -334,9 +334,9 @@ tilemap *tilemap_create_device(const device_config *device, tile_get_info_device
function function
-------------------------------------------------*/ -------------------------------------------------*/
static tilemap *tilemap_create_common(running_machine *machine, void *get_info_object, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows) static tilemap_t *tilemap_create_common(running_machine *machine, void *get_info_object, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows)
{ {
tilemap *tmap; tilemap_t *tmap;
int tilemap_instance; int tilemap_instance;
int group; int group;
@ -349,7 +349,7 @@ static tilemap *tilemap_create_common(running_machine *machine, void *get_info_o
tilemap_instance = machine->tilemap_data->instance; tilemap_instance = machine->tilemap_data->instance;
/* allocate the tilemap itself */ /* allocate the tilemap itself */
tmap = alloc_clear_or_die(tilemap); tmap = alloc_clear_or_die(tilemap_t);
/* fill in the basic metrics */ /* fill in the basic metrics */
tmap->machine = machine; tmap->machine = machine;
@ -422,7 +422,7 @@ static tilemap *tilemap_create_common(running_machine *machine, void *get_info_o
to be passed into the tile_get_info callback to be passed into the tile_get_info callback
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_user_data(tilemap *tmap, void *user_data) void tilemap_set_user_data(tilemap_t *tmap, void *user_data)
{ {
tmap->user_data = user_data; tmap->user_data = user_data;
} }
@ -434,7 +434,7 @@ void tilemap_set_user_data(tilemap *tmap, void *user_data)
the palette the palette
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_palette_offset(tilemap *tmap, UINT32 offset) void tilemap_set_palette_offset(tilemap_t *tmap, UINT32 offset)
{ {
tmap->palette_offset = offset; tmap->palette_offset = offset;
} }
@ -446,7 +446,7 @@ void tilemap_set_palette_offset(tilemap *tmap, UINT32 offset)
tilemap are ignored tilemap are ignored
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_enable(tilemap *tmap, int enable) void tilemap_set_enable(tilemap_t *tmap, int enable)
{ {
tmap->enable = (enable != 0); tmap->enable = (enable != 0);
} }
@ -457,7 +457,7 @@ void tilemap_set_enable(tilemap *tmap, int enable)
tilemap tilemap
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_flip(tilemap *tmap, UINT32 attributes) void tilemap_set_flip(tilemap_t *tmap, UINT32 attributes)
{ {
/* if we're changing things, force a refresh of the mappings and mark it all dirty */ /* if we're changing things, force a refresh of the mappings and mark it all dirty */
if (tmap->attributes != attributes) if (tmap->attributes != attributes)
@ -475,7 +475,7 @@ void tilemap_set_flip(tilemap *tmap, UINT32 attributes)
void tilemap_set_flip_all(running_machine *machine, UINT32 attributes) void tilemap_set_flip_all(running_machine *machine, UINT32 attributes)
{ {
tilemap *tmap; tilemap_t *tmap;
if (machine->tilemap_data == NULL) if (machine->tilemap_data == NULL)
return; return;
@ -495,7 +495,7 @@ void tilemap_set_flip_all(running_machine *machine, UINT32 attributes)
dirty based on its memory index dirty based on its memory index
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_mark_tile_dirty(tilemap *tmap, tilemap_memory_index memindex) void tilemap_mark_tile_dirty(tilemap_t *tmap, tilemap_memory_index memindex)
{ {
/* only mark if within range */ /* only mark if within range */
if (memindex < tmap->max_memory_index) if (memindex < tmap->max_memory_index)
@ -517,7 +517,7 @@ void tilemap_mark_tile_dirty(tilemap *tmap, tilemap_memory_index memindex)
tiles in a tilemap dirty tiles in a tilemap dirty
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_mark_all_tiles_dirty(tilemap *tmap) void tilemap_mark_all_tiles_dirty(tilemap_t *tmap)
{ {
/* mark all tiles dirty and clear the clean flag */ /* mark all tiles dirty and clear the clean flag */
tmap->all_tiles_dirty = TRUE; tmap->all_tiles_dirty = TRUE;
@ -532,7 +532,7 @@ void tilemap_mark_all_tiles_dirty(tilemap *tmap)
void tilemap_mark_all_tiles_dirty_all(running_machine *machine) void tilemap_mark_all_tiles_dirty_all(running_machine *machine)
{ {
tilemap *tmap; tilemap_t *tmap;
for (tmap = machine->tilemap_data->list; tmap != NULL; tmap = tmap->next) for (tmap = machine->tilemap_data->list; tmap != NULL; tmap = tmap->next)
tilemap_mark_all_tiles_dirty(tmap); tilemap_mark_all_tiles_dirty(tmap);
} }
@ -548,7 +548,7 @@ void tilemap_mark_all_tiles_dirty_all(running_machine *machine)
(<pen> & mask) == pen) to a layer (<pen> & mask) == pen) to a layer
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_map_pens_to_layer(tilemap *tmap, int group, pen_t pen, pen_t mask, UINT8 layermask) void tilemap_map_pens_to_layer(tilemap_t *tmap, int group, pen_t pen, pen_t mask, UINT8 layermask)
{ {
UINT8 *array = tmap->pen_to_flags + group * MAX_PEN_TO_FLAGS; UINT8 *array = tmap->pen_to_flags + group * MAX_PEN_TO_FLAGS;
pen_t start, stop, cur; pen_t start, stop, cur;
@ -586,7 +586,7 @@ void tilemap_map_pens_to_layer(tilemap *tmap, int group, pen_t pen, pen_t mask,
all other pens to layer 0 all other pens to layer 0
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_transparent_pen(tilemap *tmap, pen_t pen) void tilemap_set_transparent_pen(tilemap_t *tmap, pen_t pen)
{ {
/* reset the whole pen map to opaque */ /* reset the whole pen map to opaque */
tilemap_map_pens_to_layer(tmap, 0, 0, 0, TILEMAP_PIXEL_LAYER0); tilemap_map_pens_to_layer(tmap, 0, 0, 0, TILEMAP_PIXEL_LAYER0);
@ -603,7 +603,7 @@ void tilemap_set_transparent_pen(tilemap *tmap, pen_t pen)
layer 1) layer 1)
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_transmask(tilemap *tmap, int group, UINT32 fgmask, UINT32 bgmask) void tilemap_set_transmask(tilemap_t *tmap, int group, UINT32 fgmask, UINT32 bgmask)
{ {
pen_t pen; pen_t pen;
@ -628,7 +628,7 @@ void tilemap_set_transmask(tilemap *tmap, int group, UINT32 fgmask, UINT32 bgmas
covers height/scroll_rows pixels covers height/scroll_rows pixels
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_scroll_rows(tilemap *tmap, UINT32 scroll_rows) void tilemap_set_scroll_rows(tilemap_t *tmap, UINT32 scroll_rows)
{ {
assert(scroll_rows <= tmap->height); assert(scroll_rows <= tmap->height);
tmap->scrollrows = scroll_rows; tmap->scrollrows = scroll_rows;
@ -641,7 +641,7 @@ void tilemap_set_scroll_rows(tilemap *tmap, UINT32 scroll_rows)
unit covers width/scroll_cols pixels unit covers width/scroll_cols pixels
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_scroll_cols(tilemap *tmap, UINT32 scroll_cols) void tilemap_set_scroll_cols(tilemap_t *tmap, UINT32 scroll_cols)
{ {
assert(scroll_cols <= tmap->width); assert(scroll_cols <= tmap->width);
tmap->scrollcols = scroll_cols; tmap->scrollcols = scroll_cols;
@ -654,7 +654,7 @@ void tilemap_set_scroll_cols(tilemap *tmap, UINT32 scroll_cols)
flipped cases flipped cases
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_scrolldx(tilemap *tmap, int dx, int dx_flipped) void tilemap_set_scrolldx(tilemap_t *tmap, int dx, int dx_flipped)
{ {
tmap->dx = dx; tmap->dx = dx;
tmap->dx_flipped = dx_flipped; tmap->dx_flipped = dx_flipped;
@ -667,7 +667,7 @@ void tilemap_set_scrolldx(tilemap *tmap, int dx, int dx_flipped)
flipped cases flipped cases
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_scrolldy(tilemap *tmap, int dy, int dy_flipped) void tilemap_set_scrolldy(tilemap_t *tmap, int dy, int dy_flipped)
{ {
tmap->dy = dy; tmap->dy = dy;
tmap->dy_flipped = dy_flipped; tmap->dy_flipped = dy_flipped;
@ -680,7 +680,7 @@ void tilemap_set_scrolldy(tilemap *tmap, int dy, int dy_flipped)
flip state flip state
-------------------------------------------------*/ -------------------------------------------------*/
int tilemap_get_scrolldx(tilemap *tmap) int tilemap_get_scrolldx(tilemap_t *tmap)
{ {
return (tmap->attributes & TILEMAP_FLIPX) ? tmap->dx_flipped : tmap->dx; return (tmap->attributes & TILEMAP_FLIPX) ? tmap->dx_flipped : tmap->dx;
} }
@ -692,7 +692,7 @@ int tilemap_get_scrolldx(tilemap *tmap)
flip state flip state
-------------------------------------------------*/ -------------------------------------------------*/
int tilemap_get_scrolldy(tilemap *tmap) int tilemap_get_scrolldy(tilemap_t *tmap)
{ {
return (tmap->attributes & TILEMAP_FLIPY) ? tmap->dy_flipped : tmap->dy; return (tmap->attributes & TILEMAP_FLIPY) ? tmap->dy_flipped : tmap->dy;
} }
@ -703,7 +703,7 @@ int tilemap_get_scrolldy(tilemap *tmap)
for a row unit for a row unit
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_scrollx(tilemap *tmap, int which, int value) void tilemap_set_scrollx(tilemap_t *tmap, int which, int value)
{ {
if (which < tmap->scrollrows) if (which < tmap->scrollrows)
tmap->rowscroll[which] = value; tmap->rowscroll[which] = value;
@ -715,7 +715,7 @@ void tilemap_set_scrollx(tilemap *tmap, int which, int value)
for a column unit for a column unit
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_set_scrolly(tilemap *tmap, int which, int value) void tilemap_set_scrolly(tilemap_t *tmap, int which, int value)
{ {
if (which < tmap->scrollcols) if (which < tmap->scrollcols)
tmap->colscroll[which] = value; tmap->colscroll[which] = value;
@ -727,7 +727,7 @@ void tilemap_set_scrolly(tilemap *tmap, int which, int value)
for a row unit for a row unit
-------------------------------------------------*/ -------------------------------------------------*/
int tilemap_get_scrollx(tilemap *tmap, int which) int tilemap_get_scrollx(tilemap_t *tmap, int which)
{ {
if (which < tmap->scrollrows) if (which < tmap->scrollrows)
return tmap->rowscroll[which]; return tmap->rowscroll[which];
@ -741,7 +741,7 @@ int tilemap_get_scrollx(tilemap *tmap, int which)
for a column unit for a column unit
-------------------------------------------------*/ -------------------------------------------------*/
int tilemap_get_scrolly(tilemap *tmap, int which) int tilemap_get_scrolly(tilemap_t *tmap, int which)
{ {
if (which < tmap->scrollcols) if (which < tmap->scrollcols)
return tmap->colscroll[which]; return tmap->colscroll[which];
@ -760,7 +760,7 @@ int tilemap_get_scrolly(tilemap *tmap, int which)
(updated) internal pixmap for a tilemap (updated) internal pixmap for a tilemap
-------------------------------------------------*/ -------------------------------------------------*/
bitmap_t *tilemap_get_pixmap(tilemap *tmap) bitmap_t *tilemap_get_pixmap(tilemap_t *tmap)
{ {
/* ensure all the tiles are up-to-date and then return the pixmap */ /* ensure all the tiles are up-to-date and then return the pixmap */
pixmap_update(tmap, NULL); pixmap_update(tmap, NULL);
@ -773,7 +773,7 @@ bitmap_t *tilemap_get_pixmap(tilemap *tmap)
(updated) internal flagsmap for a tilemap (updated) internal flagsmap for a tilemap
-------------------------------------------------*/ -------------------------------------------------*/
bitmap_t *tilemap_get_flagsmap(tilemap *tmap) bitmap_t *tilemap_get_flagsmap(tilemap_t *tmap)
{ {
/* ensure all the tiles are up-to-date and then return the pixmap */ /* ensure all the tiles are up-to-date and then return the pixmap */
pixmap_update(tmap, NULL); pixmap_update(tmap, NULL);
@ -786,7 +786,7 @@ bitmap_t *tilemap_get_flagsmap(tilemap *tmap)
(updated) internal per-tile flags for a tilemap (updated) internal per-tile flags for a tilemap
-------------------------------------------------*/ -------------------------------------------------*/
UINT8 *tilemap_get_tile_flags(tilemap *tmap) UINT8 *tilemap_get_tile_flags(tilemap_t *tmap)
{ {
/* ensure all the tiles are up-to-date and then return the pixmap */ /* ensure all the tiles are up-to-date and then return the pixmap */
pixmap_update(tmap, NULL); pixmap_update(tmap, NULL);
@ -805,7 +805,7 @@ UINT8 *tilemap_get_tile_flags(tilemap *tmap)
priority/priority_mask to the priority bitmap priority/priority_mask to the priority bitmap
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_draw_primask(bitmap_t *dest, const rectangle *cliprect, tilemap *tmap, UINT32 flags, UINT8 priority, UINT8 priority_mask) void tilemap_draw_primask(bitmap_t *dest, const rectangle *cliprect, tilemap_t *tmap, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ {
UINT32 width, height; UINT32 width, height;
blit_parameters blit; blit_parameters blit;
@ -929,7 +929,7 @@ profiler_mark_end();
priority_mask to the priority bitmap priority_mask to the priority bitmap
-------------------------------------------------*/ -------------------------------------------------*/
void tilemap_draw_roz_primask(bitmap_t *dest, const rectangle *cliprect, tilemap *tmap, void tilemap_draw_roz_primask(bitmap_t *dest, const rectangle *cliprect, tilemap_t *tmap,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask) int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ {
@ -977,7 +977,7 @@ profiler_mark_end();
int tilemap_count(running_machine *machine) int tilemap_count(running_machine *machine)
{ {
tilemap *tmap; tilemap_t *tmap;
int count = 0; int count = 0;
if (machine->tilemap_data == NULL) if (machine->tilemap_data == NULL)
@ -997,7 +997,7 @@ int tilemap_count(running_machine *machine)
void tilemap_size_by_index(running_machine *machine, int number, UINT32 *width, UINT32 *height) void tilemap_size_by_index(running_machine *machine, int number, UINT32 *width, UINT32 *height)
{ {
tilemap *tmap = indexed_tilemap(machine, number); tilemap_t *tmap = indexed_tilemap(machine, number);
*width = tmap->width; *width = tmap->width;
*height = tmap->height; *height = tmap->height;
} }
@ -1011,7 +1011,7 @@ void tilemap_size_by_index(running_machine *machine, int number, UINT32 *width,
void tilemap_draw_by_index(running_machine *machine, bitmap_t *dest, int number, UINT32 scrollx, UINT32 scrolly) void tilemap_draw_by_index(running_machine *machine, bitmap_t *dest, int number, UINT32 scrollx, UINT32 scrolly)
{ {
tilemap *tmap = indexed_tilemap(machine, number); tilemap_t *tmap = indexed_tilemap(machine, number);
blit_parameters blit; blit_parameters blit;
int xpos,ypos; int xpos,ypos;
@ -1118,7 +1118,7 @@ static void tilemap_exit(running_machine *machine)
if (tilemap_data != NULL) if (tilemap_data != NULL)
while (tilemap_data->list != NULL) while (tilemap_data->list != NULL)
{ {
tilemap *next = tilemap_data->list->next; tilemap_t *next = tilemap_data->list->next;
tilemap_dispose(tilemap_data->list); tilemap_dispose(tilemap_data->list);
tilemap_data->list = next; tilemap_data->list = next;
} }
@ -1133,7 +1133,7 @@ static void tilemap_exit(running_machine *machine)
static STATE_POSTLOAD( tilemap_postload ) static STATE_POSTLOAD( tilemap_postload )
{ {
/* recompute the mappings for this tilemap */ /* recompute the mappings for this tilemap */
tilemap *tmap = (tilemap *)param; tilemap_t *tmap = (tilemap_t *)param;
mappings_update(tmap); mappings_update(tmap);
} }
@ -1142,9 +1142,9 @@ static STATE_POSTLOAD( tilemap_postload )
tilemap_dispose - dispose of a tilemap tilemap_dispose - dispose of a tilemap
-------------------------------------------------*/ -------------------------------------------------*/
static void tilemap_dispose(tilemap *tmap) static void tilemap_dispose(tilemap_t *tmap)
{ {
tilemap **tmapptr; tilemap_t **tmapptr;
/* walk the list of tilemaps; when we find ourself, remove it */ /* walk the list of tilemaps; when we find ourself, remove it */
for (tmapptr = &tmap->machine->tilemap_data->list; *tmapptr != NULL; tmapptr = &(*tmapptr)->next) for (tmapptr = &tmap->machine->tilemap_data->list; *tmapptr != NULL; tmapptr = &(*tmapptr)->next)
@ -1177,7 +1177,7 @@ static void tilemap_dispose(tilemap *tmap)
mapping tables and compute their extents mapping tables and compute their extents
-------------------------------------------------*/ -------------------------------------------------*/
static void mappings_create(tilemap *tmap) static void mappings_create(tilemap_t *tmap)
{ {
UINT32 col, row; UINT32 col, row;
@ -1208,7 +1208,7 @@ static void mappings_create(tilemap *tmap)
a major change (flip x/y changes) a major change (flip x/y changes)
-------------------------------------------------*/ -------------------------------------------------*/
static void mappings_update(tilemap *tmap) static void mappings_update(tilemap_t *tmap)
{ {
tilemap_logical_index logindex; tilemap_logical_index logindex;
tilemap_memory_index memindex; tilemap_memory_index memindex;
@ -1252,7 +1252,7 @@ static void mappings_update(tilemap *tmap)
pixmap described by the cliprect pixmap described by the cliprect
-------------------------------------------------*/ -------------------------------------------------*/
static void pixmap_update(tilemap *tmap, const rectangle *cliprect) static void pixmap_update(tilemap_t *tmap, const rectangle *cliprect)
{ {
int mincol, maxcol, minrow, maxrow; int mincol, maxcol, minrow, maxrow;
int row, col; int row, col;
@ -1313,7 +1313,7 @@ profiler_mark_end();
tile_update - update a single dirty tile tile_update - update a single dirty tile
-------------------------------------------------*/ -------------------------------------------------*/
static void tile_update(tilemap *tmap, tilemap_logical_index logindex, UINT32 col, UINT32 row) static void tile_update(tilemap_t *tmap, tilemap_logical_index logindex, UINT32 col, UINT32 row)
{ {
UINT32 x0 = tmap->tilewidth * col; UINT32 x0 = tmap->tilewidth * col;
UINT32 y0 = tmap->tileheight * row; UINT32 y0 = tmap->tileheight * row;
@ -1355,7 +1355,7 @@ profiler_mark_end();
the palette_base the palette_base
-------------------------------------------------*/ -------------------------------------------------*/
static UINT8 tile_draw(tilemap *tmap, const UINT8 *pendata, UINT32 x0, UINT32 y0, UINT32 palette_base, UINT8 category, UINT8 group, UINT8 flags, UINT8 pen_mask) static UINT8 tile_draw(tilemap_t *tmap, const UINT8 *pendata, UINT32 x0, UINT32 y0, UINT32 palette_base, UINT8 category, UINT8 group, UINT8 flags, UINT8 pen_mask)
{ {
const UINT8 *penmap = tmap->pen_to_flags + group * MAX_PEN_TO_FLAGS; const UINT8 *penmap = tmap->pen_to_flags + group * MAX_PEN_TO_FLAGS;
bitmap_t *flagsmap = tmap->flagsmap; bitmap_t *flagsmap = tmap->flagsmap;
@ -1451,7 +1451,7 @@ static UINT8 tile_draw(tilemap *tmap, const UINT8 *pendata, UINT32 x0, UINT32 y0
flagsmap appropriately flagsmap appropriately
-------------------------------------------------*/ -------------------------------------------------*/
static UINT8 tile_apply_bitmask(tilemap *tmap, const UINT8 *maskdata, UINT32 x0, UINT32 y0, UINT8 category, UINT8 flags) static UINT8 tile_apply_bitmask(tilemap_t *tmap, const UINT8 *maskdata, UINT32 x0, UINT32 y0, UINT8 category, UINT8 flags)
{ {
bitmap_t *flagsmap = tmap->flagsmap; bitmap_t *flagsmap = tmap->flagsmap;
int height = tmap->tileheight; int height = tmap->tileheight;
@ -1513,7 +1513,7 @@ static UINT8 tile_apply_bitmask(tilemap *tmap, const UINT8 *maskdata, UINT32 x0,
and indexed drawing code and indexed drawing code
-------------------------------------------------*/ -------------------------------------------------*/
static void configure_blit_parameters(blit_parameters *blit, tilemap *tmap, bitmap_t *dest, const rectangle *cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask) static void configure_blit_parameters(blit_parameters *blit, tilemap_t *tmap, bitmap_t *dest, const rectangle *cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask)
{ {
/* start with nothing */ /* start with nothing */
memset(blit, 0, sizeof(*blit)); memset(blit, 0, sizeof(*blit));
@ -1604,7 +1604,7 @@ static void configure_blit_parameters(blit_parameters *blit, tilemap *tmap, bitm
pixmap at the given xpos,ypos pixmap at the given xpos,ypos
-------------------------------------------------*/ -------------------------------------------------*/
static void tilemap_draw_instance(tilemap *tmap, const blit_parameters *blit, int xpos, int ypos) static void tilemap_draw_instance(tilemap_t *tmap, const blit_parameters *blit, int xpos, int ypos)
{ {
bitmap_t *priority_bitmap = tmap->machine->priority_bitmap; bitmap_t *priority_bitmap = tmap->machine->priority_bitmap;
bitmap_t *dest = blit->bitmap; bitmap_t *dest = blit->bitmap;
@ -1782,7 +1782,7 @@ do { \
*(UINT16 *)dest = alpha_blend_r16(*(UINT16 *)dest, clut[INPUT_VAL], alpha); \ *(UINT16 *)dest = alpha_blend_r16(*(UINT16 *)dest, clut[INPUT_VAL], alpha); \
} while (0) } while (0)
static void tilemap_draw_roz_core(tilemap *tmap, const blit_parameters *blit, static void tilemap_draw_roz_core(tilemap_t *tmap, const blit_parameters *blit,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound) UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound)
{ {
const pen_t *clut = &tmap->machine->pens[blit->tilemap_priority_code >> 16]; const pen_t *clut = &tmap->machine->pens[blit->tilemap_priority_code >> 16];

62
src/emu/tilemap.h
View File

@ -159,7 +159,7 @@
order. Based on bits in the tile memory, tiles can be drawn either order. Based on bits in the tile memory, tiles can be drawn either
behind or in front of sprites. behind or in front of sprites.
tilemap *tmap; tilemap_t *tmap;
UINT16 *my_tmap_memory; UINT16 *my_tmap_memory;
TILE_GET_INFO( my_get_info ) TILE_GET_INFO( my_get_info )
@ -379,7 +379,7 @@
typedef UINT32 tilemap_memory_index; typedef UINT32 tilemap_memory_index;
/* opaque tilemap definition */ /* opaque tilemap definition */
typedef struct _tilemap tilemap; typedef struct _tilemap_t tilemap_t;
/* tile_data is filled in by the get_tile_info callback */ /* tile_data is filled in by the get_tile_info callback */
@ -421,25 +421,25 @@ void tilemap_init(running_machine *machine);
/* ----- tilemap creation and configuration ----- */ /* ----- tilemap creation and configuration ----- */
/* create a new tilemap; note that tilemaps are tracked by the core so there is no dispose */ /* create a new tilemap; note that tilemaps are tracked by the core so there is no dispose */
tilemap *tilemap_create(running_machine *machine, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows); tilemap_t *tilemap_create(running_machine *machine, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows);
/* create a new tilemap that is owned by a device */ /* create a new tilemap that is owned by a device */
tilemap *tilemap_create_device(const device_config *device, tile_get_info_device_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows); tilemap_t *tilemap_create_device(const device_config *device, tile_get_info_device_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows);
/* specify a parameter to be passed into the tile_get_info callback */ /* specify a parameter to be passed into the tile_get_info callback */
void tilemap_set_user_data(tilemap *tmap, void *user_data); void tilemap_set_user_data(tilemap_t *tmap, void *user_data);
/* specify an offset to be added to each pixel before looking up the palette. /* specify an offset to be added to each pixel before looking up the palette.
* The offset only applies at final rendering time (e.g., tilemap_draw()) * The offset only applies at final rendering time (e.g., tilemap_draw())
* It does not apply to the cached pixmap, which is provided by tilemap_get_pixmap(). * It does not apply to the cached pixmap, which is provided by tilemap_get_pixmap().
*/ */
void tilemap_set_palette_offset(tilemap *tmap, UINT32 offset); void tilemap_set_palette_offset(tilemap_t *tmap, UINT32 offset);
/* set an enable flag for the tilemap; if 0, requests to draw the tilemap are ignored */ /* set an enable flag for the tilemap; if 0, requests to draw the tilemap are ignored */
void tilemap_set_enable(tilemap *tmap, int enable); void tilemap_set_enable(tilemap_t *tmap, int enable);
/* set a global flip for the tilemap */ /* set a global flip for the tilemap */
void tilemap_set_flip(tilemap *tmap, UINT32 attributes); void tilemap_set_flip(tilemap_t *tmap, UINT32 attributes);
/* set a global flip for all tilemaps */ /* set a global flip for all tilemaps */
void tilemap_set_flip_all(running_machine *machine, UINT32 attributes); void tilemap_set_flip_all(running_machine *machine, UINT32 attributes);
@ -449,10 +449,10 @@ void tilemap_set_flip_all(running_machine *machine, UINT32 attributes);
/* ----- dirty tile marking ----- */ /* ----- dirty tile marking ----- */
/* mark a single tile dirty based on its memory index */ /* mark a single tile dirty based on its memory index */
void tilemap_mark_tile_dirty(tilemap *tmap, tilemap_memory_index memory_index); void tilemap_mark_tile_dirty(tilemap_t *tmap, tilemap_memory_index memory_index);
/* mark all the tiles dirty in a tilemap */ /* mark all the tiles dirty in a tilemap */
void tilemap_mark_all_tiles_dirty(tilemap *tmap); void tilemap_mark_all_tiles_dirty(tilemap_t *tmap);
/* mark all the tiles dirty in all tilemaps */ /* mark all the tiles dirty in all tilemaps */
void tilemap_mark_all_tiles_dirty_all(running_machine *machine); void tilemap_mark_all_tiles_dirty_all(running_machine *machine);
@ -462,63 +462,63 @@ void tilemap_mark_all_tiles_dirty_all(running_machine *machine);
/* ----- pen-to-layer mapping ----- */ /* ----- pen-to-layer mapping ----- */
/* specify the mapping of one or more pens (where (<pen> & mask == pen) to a layer */ /* specify the mapping of one or more pens (where (<pen> & mask == pen) to a layer */
void tilemap_map_pens_to_layer(tilemap *tmap, int group, pen_t pen, pen_t mask, UINT8 layermask); void tilemap_map_pens_to_layer(tilemap_t *tmap, int group, pen_t pen, pen_t mask, UINT8 layermask);
/* set a single transparent pen into the tilemap, mapping all other pens to layer 0 */ /* set a single transparent pen into the tilemap, mapping all other pens to layer 0 */
void tilemap_set_transparent_pen(tilemap *tmap, pen_t pen); void tilemap_set_transparent_pen(tilemap_t *tmap, pen_t pen);
/* set up the first 32 pens using a foreground (layer 0) mask and a background (layer 1) mask */ /* set up the first 32 pens using a foreground (layer 0) mask and a background (layer 1) mask */
void tilemap_set_transmask(tilemap *tmap, int group, UINT32 fgmask, UINT32 bgmask); void tilemap_set_transmask(tilemap_t *tmap, int group, UINT32 fgmask, UINT32 bgmask);
/* ----- tilemap scrolling ----- */ /* ----- tilemap scrolling ----- */
/* specify the number of independently scrollable row units; each unit covers height/scroll_rows pixels */ /* specify the number of independently scrollable row units; each unit covers height/scroll_rows pixels */
void tilemap_set_scroll_rows(tilemap *tmap, UINT32 scroll_rows); void tilemap_set_scroll_rows(tilemap_t *tmap, UINT32 scroll_rows);
/* specify the number of independently scrollable column units; each unit covers width/scroll_cols pixels */ /* specify the number of independently scrollable column units; each unit covers width/scroll_cols pixels */
void tilemap_set_scroll_cols(tilemap *tmap, UINT32 scroll_cols); void tilemap_set_scroll_cols(tilemap_t *tmap, UINT32 scroll_cols);
/* specify global horizontal and vertical scroll offsets, for non-flipped and flipped cases */ /* specify global horizontal and vertical scroll offsets, for non-flipped and flipped cases */
void tilemap_set_scrolldx(tilemap *tmap, int dx, int dx_if_flipped); void tilemap_set_scrolldx(tilemap_t *tmap, int dx, int dx_if_flipped);
void tilemap_set_scrolldy(tilemap *tmap, int dy, int dy_if_flipped); void tilemap_set_scrolldy(tilemap_t *tmap, int dy, int dy_if_flipped);
/* return the global horizontal or vertical scroll offset, based on current flip state */ /* return the global horizontal or vertical scroll offset, based on current flip state */
int tilemap_get_scrolldx(tilemap *tmap); int tilemap_get_scrolldx(tilemap_t *tmap);
int tilemap_get_scrolldy(tilemap *tmap); int tilemap_get_scrolldy(tilemap_t *tmap);
/* specify the scroll value for a row/column unit */ /* specify the scroll value for a row/column unit */
void tilemap_set_scrollx(tilemap *tmap, int row, int value); void tilemap_set_scrollx(tilemap_t *tmap, int row, int value);
void tilemap_set_scrolly(tilemap *tmap, int col, int value); void tilemap_set_scrolly(tilemap_t *tmap, int col, int value);
/* return the scroll value for a row/column unit */ /* return the scroll value for a row/column unit */
int tilemap_get_scrollx(tilemap *tmap, int row); int tilemap_get_scrollx(tilemap_t *tmap, int row);
int tilemap_get_scrolly(tilemap *tmap, int col); int tilemap_get_scrolly(tilemap_t *tmap, int col);
/* ----- internal map access ----- */ /* ----- internal map access ----- */
/* return a pointer to the (updated) internal pixmap for a tilemap */ /* return a pointer to the (updated) internal pixmap for a tilemap */
bitmap_t *tilemap_get_pixmap(tilemap *tmap); bitmap_t *tilemap_get_pixmap(tilemap_t *tmap);
/* return a pointer to the (updated) internal flagsmap for a tilemap */ /* return a pointer to the (updated) internal flagsmap for a tilemap */
bitmap_t *tilemap_get_flagsmap(tilemap *tmap); bitmap_t *tilemap_get_flagsmap(tilemap_t *tmap);
/* return a pointer to the (updated) internal per-tile flags for a tilemap */ /* return a pointer to the (updated) internal per-tile flags for a tilemap */
UINT8 *tilemap_get_tile_flags(tilemap *tmap); UINT8 *tilemap_get_tile_flags(tilemap_t *tmap);
/* ----- tilemap rendering ----- */ /* ----- tilemap rendering ----- */
/* draw a tilemap to the destination with clipping; pixels apply priority/priority_mask to the priority bitmap */ /* draw a tilemap to the destination with clipping; pixels apply priority/priority_mask to the priority bitmap */
void tilemap_draw_primask(bitmap_t *dest, const rectangle *cliprect, tilemap *tmap, UINT32 flags, UINT8 priority, UINT8 priority_mask); void tilemap_draw_primask(bitmap_t *dest, const rectangle *cliprect, tilemap_t *tmap, UINT32 flags, UINT8 priority, UINT8 priority_mask);
/* draw a tilemap to the destination with clipping and arbitrary rotate/zoom; */ /* draw a tilemap to the destination with clipping and arbitrary rotate/zoom; */
/* pixels apply priority/priority_mask to the priority bitmap */ /* pixels apply priority/priority_mask to the priority bitmap */
void tilemap_draw_roz_primask(bitmap_t *dest, const rectangle *cliprect, tilemap *tmap, void tilemap_draw_roz_primask(bitmap_t *dest, const rectangle *cliprect, tilemap_t *tmap,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask); int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask);
@ -580,7 +580,7 @@ INLINE void tileinfo_set(running_machine *machine, tile_data *tileinfo, int gfxn
to a layer to a layer
-------------------------------------------------*/ -------------------------------------------------*/
INLINE void tilemap_map_pen_to_layer(tilemap *tmap, int group, pen_t pen, UINT8 layermask) INLINE void tilemap_map_pen_to_layer(tilemap_t *tmap, int group, pen_t pen, UINT8 layermask)
{ {
tilemap_map_pens_to_layer(tmap, group, pen, ~0, layermask); tilemap_map_pens_to_layer(tmap, group, pen, ~0, layermask);
} }
@ -591,7 +591,7 @@ INLINE void tilemap_map_pen_to_layer(tilemap *tmap, int group, pen_t pen, UINT8
tilemap_draw_primask tilemap_draw_primask
-------------------------------------------------*/ -------------------------------------------------*/
INLINE void tilemap_draw(bitmap_t *dest, const rectangle *cliprect, tilemap *tmap, UINT32 flags, UINT8 priority) INLINE void tilemap_draw(bitmap_t *dest, const rectangle *cliprect, tilemap_t *tmap, UINT32 flags, UINT8 priority)
{ {
tilemap_draw_primask(dest, cliprect, tmap, flags, priority, 0xff); tilemap_draw_primask(dest, cliprect, tmap, flags, priority, 0xff);
} }
@ -602,7 +602,7 @@ INLINE void tilemap_draw(bitmap_t *dest, const rectangle *cliprect, tilemap *tma
tilemap_draw_roz_primask tilemap_draw_roz_primask
-------------------------------------------------*/ -------------------------------------------------*/
INLINE void tilemap_draw_roz(bitmap_t *dest, const rectangle *cliprect, tilemap *tmap, INLINE void tilemap_draw_roz(bitmap_t *dest, const rectangle *cliprect, tilemap_t *tmap,
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
int wraparound, UINT32 flags, UINT8 priority) int wraparound, UINT32 flags, UINT8 priority)
{ {

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

@ -47,7 +47,7 @@ The rationale for saving/not saving are as follows:
static UINT16* k3_spriteram_1; Saved via reference to AM_BASE static UINT16* k3_spriteram_1; Saved via reference to AM_BASE
static UINT16* k3_spriteram_2; Saved via reference to AM_BASE static UINT16* k3_spriteram_2; Saved via reference to AM_BASE
static UINT16* k3_bgram; Saved via reference to AM_BASE static UINT16* k3_bgram; Saved via reference to AM_BASE
static tilemap *k3_bg_tilemap; Saved due to tilemap supporting save static tilemap_t *k3_bg_tilemap; Saved due to tilemap supporting save
There are no static local variables. There are no static local variables.
@ -70,7 +70,7 @@ struct _k3_state
// UINT16 * paletteram16; // currently this uses generic palette handling // UINT16 * paletteram16; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap_t *bg_tilemap;
/* devices */ /* devices */
const device_config *oki1; const device_config *oki1;

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

@ -60,7 +60,7 @@ JALCF1 BIN 1,048,576 02-07-99 1:11a JALCF1.BIN
#include "deprecat.h" #include "deprecat.h"
#include "sound/okim6295.h" #include "sound/okim6295.h"
static tilemap *tx_tilemap,*bg_tilemap; static tilemap_t *tx_tilemap,*bg_tilemap;
static UINT16 *ac_txvram,*ac_bgvram; static UINT16 *ac_txvram,*ac_bgvram;
static UINT16 *ac_vregs; static UINT16 *ac_vregs;

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

@ -72,7 +72,7 @@ struct _albazg_state
// UINT8 * paletteram_2; // currently this uses generic palette handling // UINT8 * paletteram_2; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap_t *bg_tilemap;
/* misc */ /* misc */
UINT8 mux_data; UINT8 mux_data;

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

@ -26,7 +26,7 @@ Dip Locations added according to Service Mode
/* Video Handling */ /* Video Handling */
static UINT16 *bestleag_txram,*bestleag_bgram,*bestleag_fgram,*bestleag_vregs; static UINT16 *bestleag_txram,*bestleag_bgram,*bestleag_fgram,*bestleag_vregs;
static tilemap *tx_tilemap,*bg_tilemap,*fg_tilemap; static tilemap_t *tx_tilemap,*bg_tilemap,*fg_tilemap;
static TILE_GET_INFO( get_tx_tile_info ) static TILE_GET_INFO( get_tx_tile_info )
{ {

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

@ -129,7 +129,7 @@ struct _bigfghtr_state
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap, *fg_tilemap, *tx_tilemap; tilemap_t *bg_tilemap, *fg_tilemap, *tx_tilemap;
UINT16 fg_scrollx, fg_scrolly; UINT16 fg_scrollx, fg_scrolly;
UINT16 vreg; UINT16 vreg;
UINT16 scroll_x, scroll_y; UINT16 scroll_x, scroll_y;

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

@ -46,8 +46,8 @@ static UINT8 *bishjan_colorram;
static UINT8 *bishjan_videoram_1_lo, *bishjan_videoram_1_hi; static UINT8 *bishjan_videoram_1_lo, *bishjan_videoram_1_hi;
static UINT8 *bishjan_videoram_2_lo, *bishjan_videoram_2_hi; static UINT8 *bishjan_videoram_2_lo, *bishjan_videoram_2_hi;
static tilemap *tmap_1; static tilemap_t *tmap_1;
static tilemap *tmap_2; static tilemap_t *tmap_2;
static TILE_GET_INFO( get_tile_info_1 ) { SET_TILE_INFO(0, (bishjan_videoram_1_hi[ tile_index ] << 8) + bishjan_videoram_1_lo[ tile_index ], 0, 0); } static TILE_GET_INFO( get_tile_info_1 ) { SET_TILE_INFO(0, (bishjan_videoram_1_hi[ tile_index ] << 8) + bishjan_videoram_1_lo[ tile_index ], 0, 0); }
static TILE_GET_INFO( get_tile_info_2 ) { SET_TILE_INFO(0, (bishjan_videoram_2_hi[ tile_index ] << 8) + bishjan_videoram_2_lo[ tile_index ], 0, 0); } static TILE_GET_INFO( get_tile_info_2 ) { SET_TILE_INFO(0, (bishjan_videoram_2_hi[ tile_index ] << 8) + bishjan_videoram_2_lo[ tile_index ], 0, 0); }

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

@ -100,9 +100,9 @@ ROMs : MR96004-10.1 [125661cd] (IC5 - Samples)
#define ms32_bg_tilemap bnstars_bg_tilemap #define ms32_bg_tilemap bnstars_bg_tilemap
#define ms32_roz_tilemap bnstars_tx_tilemap #define ms32_roz_tilemap bnstars_tx_tilemap
static tilemap *ms32_tx_tilemap[2]; static tilemap_t *ms32_tx_tilemap[2];
static tilemap *ms32_bg_tilemap[2]; static tilemap_t *ms32_bg_tilemap[2];
static tilemap *ms32_roz_tilemap[2]; static tilemap_t *ms32_roz_tilemap[2];
static UINT32 *ms32_tx0_ram, *ms32_tx1_ram; static UINT32 *ms32_tx0_ram, *ms32_tx1_ram;
static UINT32 *ms32_bg0_ram, *ms32_bg1_ram; static UINT32 *ms32_bg0_ram, *ms32_bg1_ram;

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

@ -32,11 +32,11 @@ are the same of IGS. AMT may be previous IGS name.
static UINT8 *bg_tile_ram; static UINT8 *bg_tile_ram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT8 *bg_scroll; static UINT8 *bg_scroll;
static UINT8 *fg_tile_ram, *fg_color_ram; static UINT8 *fg_tile_ram, *fg_color_ram;
static tilemap *fg_tilemap; static tilemap_t *fg_tilemap;
static WRITE8_HANDLER( bg_scroll_w ) static WRITE8_HANDLER( bg_scroll_w )
{ {

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

@ -92,7 +92,7 @@ struct _calorie_state
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap,*fg_tilemap; tilemap_t *bg_tilemap,*fg_tilemap;
UINT8 bg_bank; UINT8 bg_bank;
}; };

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

@ -46,7 +46,7 @@ TODO:
#include "sound/ay8910.h" #include "sound/ay8910.h"
static UINT8 *sc0_vram,*sc0_attr; static UINT8 *sc0_vram,*sc0_attr;
static tilemap *sc0_tilemap; static tilemap_t *sc0_tilemap;
static TILE_GET_INFO( get_sc0_tile_info ) static TILE_GET_INFO( get_sc0_tile_info )
{ {

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

@ -15,7 +15,7 @@ struct _cball_state
UINT8 * video_ram; UINT8 * video_ram;
/* video-related */ /* video-related */
tilemap* bg_tilemap; tilemap_t* bg_tilemap;
/* devices */ /* devices */
const device_config *maincpu; const device_config *maincpu;

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

@ -62,7 +62,7 @@ struct _chanbara_state
UINT8 * spriteram; UINT8 * spriteram;
/* video-related */ /* video-related */
tilemap *bg_tilemap,*bg2_tilemap; tilemap_t *bg_tilemap,*bg2_tilemap;
UINT8 scroll, scrollhi; UINT8 scroll, scrollhi;
/* devices */ /* devices */

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

@ -40,7 +40,7 @@ struct _cntsteer_state
UINT8 * spriteram; UINT8 * spriteram;
/* video-related */ /* video-related */
tilemap *bg_tilemap,*fg_tilemap; tilemap_t *bg_tilemap,*fg_tilemap;
int bg_bank, bg_color_bank; int bg_bank, bg_color_bank;
int flipscreen; int flipscreen;
int scrolly, scrolly_hi; int scrolly, scrolly_hi;

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

@ -30,7 +30,7 @@ x
static UINT8 *attr_ram1, *attr_ram2, *attr_ram3; static UINT8 *attr_ram1, *attr_ram2, *attr_ram3;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT8 question_adr[4]; static UINT8 question_adr[4];

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

@ -11,7 +11,7 @@
#include "sound/okim6295.h" #include "sound/okim6295.h"
#include "sound/2203intf.h" #include "sound/2203intf.h"
static tilemap *tmap; static tilemap_t *tmap;
static UINT8 *colorram; static UINT8 *colorram;
static UINT8 *videoram; static UINT8 *videoram;

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

@ -89,7 +89,7 @@ Stephh's notes (based on the game Z80 code and some tests) :
#include "audio/seibu.h" #include "audio/seibu.h"
static UINT8* cshooter_txram; static UINT8* cshooter_txram;
static tilemap *cshooter_txtilemap; static tilemap_t *cshooter_txtilemap;
static int coin_stat=0; static int coin_stat=0;
static UINT8 *mainram; static UINT8 *mainram;

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

@ -28,7 +28,7 @@ struct _cultures_state
UINT8 * bg2_regs_y; UINT8 * bg2_regs_y;
/* video-related */ /* video-related */
tilemap *bg0_tilemap, *bg1_tilemap, *bg2_tilemap; tilemap_t *bg0_tilemap, *bg1_tilemap, *bg2_tilemap;
int video_bank; int video_bank;
int irq_enable; int irq_enable;
int bg1_bank, bg2_bank; int bg1_bank, bg2_bank;

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

@ -175,7 +175,7 @@ lev 7 : 0x7c : 0000 07e0 - input device clear?
#include "deprecat.h" #include "deprecat.h"
#include "sound/8950intf.h" #include "sound/8950intf.h"
static tilemap *tx_tilemap; static tilemap_t *tx_tilemap;
static UINT16 *tx_vram; static UINT16 *tx_vram;
static UINT16 *shared_ram; static UINT16 *shared_ram;
static UINT16 *io_ram; static UINT16 *io_ram;

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

@ -24,7 +24,7 @@
#include "sound/2413intf.h" #include "sound/2413intf.h"
static UINT8 *lo_vram,*hi_vram,*cram; static UINT8 *lo_vram,*hi_vram,*cram;
static tilemap *sc0_tilemap; static tilemap_t *sc0_tilemap;
static TILE_GET_INFO( get_sc0_tile_info ) static TILE_GET_INFO( get_sc0_tile_info )
{ {

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

@ -34,7 +34,7 @@ struct _dacholer_state
size_t spriteram_size; size_t spriteram_size;
/* video-related */ /* video-related */
tilemap *bg_tilemap,*fg_tilemap; tilemap_t *bg_tilemap,*fg_tilemap;
int bg_bank; int bg_bank;
/* sound-related */ /* sound-related */

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

@ -76,7 +76,7 @@ To do:
static VIDEO_START( darkhors ); static VIDEO_START( darkhors );
static VIDEO_UPDATE( darkhors ); static VIDEO_UPDATE( darkhors );
static tilemap *darkhors_tmap, *darkhors_tmap2; static tilemap_t *darkhors_tmap, *darkhors_tmap2;
static UINT32 *darkhors_tmapram, *darkhors_tmapscroll; static UINT32 *darkhors_tmapram, *darkhors_tmapscroll;
static UINT32 *darkhors_tmapram2, *darkhors_tmapscroll2; static UINT32 *darkhors_tmapram2, *darkhors_tmapscroll2;

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

@ -66,7 +66,7 @@ struct _ddayjlc_state
UINT8 * spriteram; UINT8 * spriteram;
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap_t *bg_tilemap;
INT32 char_bank; INT32 char_bank;
INT32 bgadr; INT32 bgadr;

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

@ -128,7 +128,7 @@ struct _ddealer_state
// UINT16 * paletteram16; // currently this uses generic palette handling // UINT16 * paletteram16; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *back_tilemap; tilemap_t *back_tilemap;
int respcount; int respcount;
int flipscreen; int flipscreen;

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

@ -62,7 +62,7 @@ static UINT8* sprite_ram;
static UINT8 *nvram; static UINT8 *nvram;
static size_t nvram_size; static size_t nvram_size;
static UINT8 *racetrack_tilemap_rom; static UINT8 *racetrack_tilemap_rom;
static tilemap *racetrack_tilemap; static tilemap_t *racetrack_tilemap;
static NVRAM_HANDLER( dderby ) static NVRAM_HANDLER( dderby )
{ {

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

@ -101,7 +101,7 @@ struct _dreamwld_state
UINT32 * spriteram; UINT32 * spriteram;
/* video-related */ /* video-related */
tilemap *bg_tilemap,*bg2_tilemap; tilemap_t *bg_tilemap,*bg2_tilemap;
int tilebank[2], tilebankold[2]; int tilebank[2], tilebankold[2];
/* misc */ /* misc */

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

@ -21,7 +21,7 @@ struct _drtomy_state
// UINT16 * paletteram16; // currently this uses generic palette handling // UINT16 * paletteram16; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *tilemap_bg,*tilemap_fg; tilemap_t *tilemap_bg,*tilemap_fg;
/* misc */ /* misc */
int oki_bank; int oki_bank;

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

@ -32,7 +32,7 @@
#define CPU_CLOCK XTAL_8MHz #define CPU_CLOCK XTAL_8MHz
#define DATA_NVRAM_SIZE 0x100 #define DATA_NVRAM_SIZE 0x100
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT8 t0, t1, p0, p1, p2, prog, bus; static UINT8 t0, t1, p0, p1, p2, prog, bus;
static UINT8 attract_mode = 0; static UINT8 attract_mode = 0;

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

@ -69,7 +69,7 @@ struct _dunhuang_state
UINT8 * paldata; UINT8 * paldata;
/* video-related */ /* video-related */
tilemap *tmap,*tmap2; tilemap_t *tmap,*tmap2;
int written, written2; int written, written2;
UINT8 pos_x, pos_y, clear_y; UINT8 pos_x, pos_y, clear_y;
UINT8 block_x, block_y, block_w, block_h; UINT8 block_x, block_y, block_w, block_h;

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

@ -46,7 +46,7 @@ struct _dynadice_state
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap,*top_tilemap; tilemap_t *bg_tilemap,*top_tilemap;
/* misc */ /* misc */
int ay_data; int ay_data;

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

@ -55,7 +55,7 @@ struct _egghunt_state
// UINT8 * paletteram; // currently this uses generic palette handling // UINT8 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap_t *bg_tilemap;
UINT8 vidram_bank; UINT8 vidram_bank;
/* misc */ /* misc */

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

@ -40,7 +40,7 @@ static int b000_ret = 0;
static int b800_prev = 0; static int b800_prev = 0;
static UINT8 *bg_videoram, *fg_videoram; static UINT8 *bg_videoram, *fg_videoram;
static tilemap *bg_tilemap, *fg_tilemap; static tilemap_t *bg_tilemap, *fg_tilemap;
static WRITE8_HANDLER( ettrivia_fg_w ) static WRITE8_HANDLER( ettrivia_fg_w )
{ {

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

@ -128,7 +128,7 @@ static unsigned char *tile_palette;
static unsigned char *sprite_palette; static unsigned char *sprite_palette;
static const device_config *nvram_1c; static const device_config *nvram_1c;
static const device_config *nvram_1d; static const device_config *nvram_1d;
static tilemap *bgtiles; static tilemap_t *bgtiles;
static int control_num; static int control_num;
static UINT8 sound_to_main_flag; static UINT8 sound_to_main_flag;

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

@ -19,7 +19,7 @@ struct _flyball_state
UINT8 * playfield_ram; UINT8 * playfield_ram;
/* video-related */ /* video-related */
tilemap *tmap; tilemap_t *tmap;
UINT8 pitcher_vert; UINT8 pitcher_vert;
UINT8 pitcher_horz; UINT8 pitcher_horz;
UINT8 pitcher_pic; UINT8 pitcher_pic;

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

@ -57,7 +57,7 @@ struct _galaxi_state
// UINT16 * nvram; // currently this uses generic nvram handling // UINT16 * nvram; // currently this uses generic nvram handling
/* video-related */ /* video-related */
tilemap *bg1_tmap, *bg2_tmap, *bg3_tmap, *bg4_tmap, *fg_tmap; tilemap_t *bg1_tmap, *bg2_tmap, *bg3_tmap, *bg4_tmap, *fg_tmap;
/* misc */ /* misc */
int hopper, ticket; int hopper, ticket;

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

@ -632,7 +632,7 @@
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static WRITE8_HANDLER( goldnpkr_videoram_w ) static WRITE8_HANDLER( goldnpkr_videoram_w )
{ {

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

@ -45,7 +45,7 @@ struct _good_state
// UINT16 * paletteram; // currently this uses generic palette handling // UINT16 * paletteram; // currently this uses generic palette handling
/* video-related */ /* video-related */
tilemap *bg_tilemap,*fg_tilemap; tilemap_t *bg_tilemap,*fg_tilemap;
}; };

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

@ -136,7 +136,7 @@ struct _gstream_state
// UINT32 * nvram; // currently this uses generic nvram handling // UINT32 * nvram; // currently this uses generic nvram handling
/* video-related */ /* video-related */
tilemap *tilemap1, *tilemap2, *tilemap3; tilemap_t *tilemap1, *tilemap2, *tilemap3;
UINT32 tmap1_scrollx, tmap2_scrollx, tmap3_scrollx; UINT32 tmap1_scrollx, tmap2_scrollx, tmap3_scrollx;
UINT32 tmap1_scrolly, tmap2_scrolly, tmap3_scrolly; UINT32 tmap1_scrolly, tmap2_scrolly, tmap3_scrolly;

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

@ -335,7 +335,7 @@ static UINT32 jvs_sdata_ptr = 0;
static UINT32 *K037122_tile_ram[MAX_K037122_CHIPS]; static UINT32 *K037122_tile_ram[MAX_K037122_CHIPS];
static UINT32 *K037122_char_ram[MAX_K037122_CHIPS]; static UINT32 *K037122_char_ram[MAX_K037122_CHIPS];
static int K037122_gfx_index[MAX_K037122_CHIPS]; static int K037122_gfx_index[MAX_K037122_CHIPS];
static tilemap *K037122_layer[MAX_K037122_CHIPS][2]; static tilemap_t *K037122_layer[MAX_K037122_CHIPS][2];
static UINT32 *K037122_reg[MAX_K037122_CHIPS]; static UINT32 *K037122_reg[MAX_K037122_CHIPS];
#define K037122_NUM_TILES 16384 #define K037122_NUM_TILES 16384

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

@ -62,7 +62,7 @@ Notes:
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT16 hu_scrollx, hu_scrolly; static UINT16 hu_scrollx, hu_scrolly;
static UINT16 port0_data; static UINT16 port0_data;

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

@ -26,7 +26,7 @@ NVRAM : Battery for main RAM
***************************************************************************/ ***************************************************************************/
static tilemap *gp98_reel1_tilemap; static tilemap_t *gp98_reel1_tilemap;
static UINT8 *gp98_reel1_ram; static UINT8 *gp98_reel1_ram;
static WRITE8_HANDLER( gp98_reel1_ram_w ) static WRITE8_HANDLER( gp98_reel1_ram_w )
@ -58,7 +58,7 @@ static TILE_GET_INFO( get_gp98_reel1_tile_info )
0); 0);
} }
static tilemap *gp98_reel2_tilemap; static tilemap_t *gp98_reel2_tilemap;
static UINT8 *gp98_reel2_ram; static UINT8 *gp98_reel2_ram;
static WRITE8_HANDLER( gp98_reel2_ram_w ) static WRITE8_HANDLER( gp98_reel2_ram_w )
@ -90,7 +90,7 @@ static TILE_GET_INFO( get_gp98_reel2_tile_info )
} }
static tilemap *gp98_reel3_tilemap; static tilemap_t *gp98_reel3_tilemap;
static UINT8 *gp98_reel3_ram; static UINT8 *gp98_reel3_ram;
static WRITE8_HANDLER( gp98_reel3_ram_w ) static WRITE8_HANDLER( gp98_reel3_ram_w )
@ -122,7 +122,7 @@ static TILE_GET_INFO( get_gp98_reel3_tile_info )
} }
static tilemap *gp98_reel4_tilemap; static tilemap_t *gp98_reel4_tilemap;
static UINT8 *gp98_reel4_ram; static UINT8 *gp98_reel4_ram;
static WRITE8_HANDLER( gp98_reel4_ram_w ) static WRITE8_HANDLER( gp98_reel4_ram_w )
@ -159,7 +159,7 @@ static TILE_GET_INFO( get_gp98_reel4_tile_info )
static UINT8 *fg_tile_ram, *fg_color_ram; static UINT8 *fg_tile_ram, *fg_color_ram;
static UINT8 *bg_scroll, *bg_scroll2; static UINT8 *bg_scroll, *bg_scroll2;
static tilemap *fg_tilemap; static tilemap_t *fg_tilemap;
static int video_enable; static int video_enable;

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

@ -75,7 +75,7 @@ static VIDEO_RESET( igs017 )
} }
static UINT8 *fg_videoram, *bg_videoram; static UINT8 *fg_videoram, *bg_videoram;
static tilemap *fg_tilemap, *bg_tilemap; static tilemap_t *fg_tilemap, *bg_tilemap;
#define COLOR(_X) (((_X)>>2)&7) #define COLOR(_X) (((_X)>>2)&7)

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

@ -32,7 +32,7 @@
***************************************************************************/ ***************************************************************************/
static UINT32 *igs_mainram,*igs_cg_videoram,*igs_tx_videoram,*igs_bg_videoram; static UINT32 *igs_mainram,*igs_cg_videoram,*igs_tx_videoram,*igs_bg_videoram;
static UINT32 *igs_pallete32; static UINT32 *igs_pallete32;
static tilemap *igs_tx_tilemap,*igs_bg_tilemap; static tilemap_t *igs_tx_tilemap,*igs_bg_tilemap;

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

@ -107,7 +107,7 @@ static WRITE8_HANDLER( igs_irqack_w )
static UINT8 *fg_tile_ram, *fg_color_ram, *bg_tile_ram; static UINT8 *fg_tile_ram, *fg_color_ram, *bg_tile_ram;
static tilemap *fg_tilemap, *bg_tilemap; static tilemap_t *fg_tilemap, *bg_tilemap;
static TILE_GET_INFO( get_bg_tile_info ) static TILE_GET_INFO( get_bg_tile_info )
{ {

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

@ -6,7 +6,7 @@
static int exp_bank = 0; static int exp_bank = 0;
static UINT8 *fg_tile_ram, *fg_color_ram; static UINT8 *fg_tile_ram, *fg_color_ram;
static tilemap *fg_tilemap; static tilemap_t *fg_tilemap;
static TILE_GET_INFO( get_fg_tile_info ) static TILE_GET_INFO( get_fg_tile_info )
{ {
@ -36,7 +36,7 @@ static WRITE8_HANDLER( bg_scroll_w )
bg_scroll[offset] = data; bg_scroll[offset] = data;
} }
static tilemap *jackie_reel1_tilemap; static tilemap_t *jackie_reel1_tilemap;
static UINT8 *jackie_reel1_ram; static UINT8 *jackie_reel1_ram;
static WRITE8_HANDLER( jackie_reel1_ram_w ) static WRITE8_HANDLER( jackie_reel1_ram_w )
@ -52,7 +52,7 @@ static TILE_GET_INFO( get_jackie_reel1_tile_info )
} }
static tilemap *jackie_reel2_tilemap; static tilemap_t *jackie_reel2_tilemap;
static UINT8 *jackie_reel2_ram; static UINT8 *jackie_reel2_ram;
static WRITE8_HANDLER( jackie_reel2_ram_w ) static WRITE8_HANDLER( jackie_reel2_ram_w )
@ -67,7 +67,7 @@ static TILE_GET_INFO( get_jackie_reel2_tile_info )
SET_TILE_INFO(1, code, 0, 0); SET_TILE_INFO(1, code, 0, 0);
} }
static tilemap *jackie_reel3_tilemap; static tilemap_t *jackie_reel3_tilemap;
static UINT8 *jackie_reel3_ram; static UINT8 *jackie_reel3_ram;
static WRITE8_HANDLER( jackie_reel3_ram_w ) static WRITE8_HANDLER( jackie_reel3_ram_w )

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

@ -119,7 +119,7 @@ Video Hardware start
******************************************************************************************/ ******************************************************************************************/
static tilemap *sc3_tilemap_0,*sc3_tilemap_2,*sc3_tilemap_3, static tilemap_t *sc3_tilemap_0,*sc3_tilemap_2,*sc3_tilemap_3,
*sc0_tilemap_0,*sc0_tilemap_1,*sc0_tilemap_2,*sc0_tilemap_3, *sc0_tilemap_0,*sc0_tilemap_1,*sc0_tilemap_2,*sc0_tilemap_3,
*sc1_tilemap_0,*sc1_tilemap_1,*sc1_tilemap_2,*sc1_tilemap_3, *sc1_tilemap_0,*sc1_tilemap_1,*sc1_tilemap_2,*sc1_tilemap_3,
*sc2_tilemap_0,*sc2_tilemap_1,*sc2_tilemap_2,*sc2_tilemap_3; *sc2_tilemap_0,*sc2_tilemap_1,*sc2_tilemap_2,*sc2_tilemap_3;

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

@ -102,7 +102,7 @@
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static WRITE8_HANDLER( jokrwild_videoram_w ) static WRITE8_HANDLER( jokrwild_videoram_w )

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

@ -112,7 +112,7 @@ struct _jollyjgr_state
UINT8 * bitmap; UINT8 * bitmap;
/* video-related */ /* video-related */
tilemap *bg_tilemap; tilemap_t *bg_tilemap;
/* misc */ /* misc */
int nmi_enable, flip_x, flip_y; int nmi_enable, flip_x, flip_y;

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

@ -78,7 +78,7 @@ static UINT8 sound_cmd;
*************************************/ *************************************/
static UINT8 *kingdrby_vram,*kingdrby_attr; static UINT8 *kingdrby_vram,*kingdrby_attr;
static tilemap *sc0_tilemap,*sc0w_tilemap,*sc1_tilemap; static tilemap_t *sc0_tilemap,*sc0w_tilemap,*sc1_tilemap;
/* /*
tile tile

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

@ -35,7 +35,7 @@ ft5_v6_c4.u58 /
static UINT16 *bmc_1_videoram, *bmc_2_videoram,*main_ram; static UINT16 *bmc_1_videoram, *bmc_2_videoram,*main_ram;
static tilemap *tilemap_1,*tilemap_2; static tilemap_t *tilemap_1,*tilemap_2;
static UINT8 *bmc_colorram; static UINT8 *bmc_colorram;
static int clr_offset=0; static int clr_offset=0;

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

@ -52,7 +52,7 @@ struct _koikoi_state
UINT8 * videoram; UINT8 * videoram;
/* video-related */ /* video-related */
tilemap *tmap; tilemap_t *tmap;
/* misc */ /* misc */
int inputcnt; int inputcnt;

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

@ -29,7 +29,7 @@
#include "sound/okim6295.h" #include "sound/okim6295.h"
#include "cpu/mcs51/mcs51.h" #include "cpu/mcs51/mcs51.h"
static tilemap *bg_tilemap, *md_tilemap, *fg_tilemap; static tilemap_t *bg_tilemap, *md_tilemap, *fg_tilemap;
static UINT32 *bg_videoram, *md_videoram, *fg_videoram, *limenko_videoreg; static UINT32 *bg_videoram, *md_videoram, *fg_videoram, *limenko_videoreg;
static UINT32 *mainram; static UINT32 *mainram;

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

@ -104,7 +104,7 @@ struct _looping_state
UINT8 * spriteram; UINT8 * spriteram;
/* tilemaps */ /* tilemaps */
tilemap * bg_tilemap; tilemap_t * bg_tilemap;
/* sound state */ /* sound state */
UINT8 sound[8]; UINT8 sound[8];

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

@ -19,7 +19,7 @@ etc.
static UINT8 *ltcasino_tile_num_ram, *ltcasino_tile_atr_ram; static UINT8 *ltcasino_tile_num_ram, *ltcasino_tile_atr_ram;
static tilemap *ltcasino_tilemap; static tilemap_t *ltcasino_tilemap;
/* Video */ /* Video */

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

@ -58,7 +58,7 @@ typedef struct _m14_state m14_state;
struct _m14_state struct _m14_state
{ {
/* video-related */ /* video-related */
tilemap *m14_tilemap; tilemap_t *m14_tilemap;
UINT8 * video_ram; UINT8 * video_ram;
UINT8 * color_ram; UINT8 * color_ram;

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

@ -132,7 +132,7 @@ struct _m63_state
size_t spriteram_size; size_t spriteram_size;
/* video-related */ /* video-related */
tilemap *bg_tilemap, *fg_tilemap; tilemap_t *bg_tilemap, *fg_tilemap;
int pal_bank, fg_flag, sy_offset; int pal_bank, fg_flag, sy_offset;
/* sound-related */ /* sound-related */

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

@ -80,7 +80,7 @@
#include "sound/okim6295.h" #include "sound/okim6295.h"
#include "sgsafari.lh" #include "sgsafari.lh"
static tilemap *layer0_tilemap, *layer1_tilemap, *layer2_tilemap; static tilemap_t *layer0_tilemap, *layer1_tilemap, *layer2_tilemap;
static UINT16 *layer0_videoram, *layer1_videoram, *layer2_videoram; static UINT16 *layer0_videoram, *layer1_videoram, *layer2_videoram;
static int layer2_offset[2]; static int layer2_offset[2];
static UINT16 *magic10_vregs; static UINT16 *magic10_vregs;

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

@ -407,7 +407,7 @@
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static WRITE8_HANDLER( magicfly_videoram_w ) static WRITE8_HANDLER( magicfly_videoram_w )
{ {

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

@ -98,7 +98,7 @@ p2 ink doesn't always light up in test mode
#include "cpu/z80/z80.h" #include "cpu/z80/z80.h"
static bitmap_t *tile, *obj1, *obj2; static bitmap_t *tile, *obj1, *obj2;
static tilemap *tx_tilemap; static tilemap_t *tx_tilemap;
static UINT8 *tx_tileram; static UINT8 *tx_tileram;

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

@ -15,7 +15,7 @@ static attotime time_released;
static UINT8 prev = 0; static UINT8 prev = 0;
static UINT8 mask = 0; static UINT8 mask = 0;
static tilemap* bg_tilemap; static tilemap_t* bg_tilemap;
static TILE_GET_INFO( get_tile_info ) static TILE_GET_INFO( get_tile_info )

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

@ -57,7 +57,7 @@ static UINT16 *livequiz_gfxram, *livequiz_gfxregs;
static VIDEO_START( livequiz ); static VIDEO_START( livequiz );
static VIDEO_UPDATE( livequiz ); static VIDEO_UPDATE( livequiz );
static tilemap *tmap; static tilemap_t *tmap;
static TILE_GET_INFO( get_tile_info ) static TILE_GET_INFO( get_tile_info )
{ {

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

@ -91,7 +91,7 @@ Changes (2008-12-10, Roberto Fresca):
static UINT16 *sc0_vram,*sc1_vram,*sc2_vram,*sc3_vram; static UINT16 *sc0_vram,*sc1_vram,*sc2_vram,*sc3_vram;
static tilemap *sc0_tilemap,*sc1_tilemap,*sc2_tilemap,*sc3_tilemap; static tilemap_t *sc0_tilemap,*sc1_tilemap,*sc2_tilemap,*sc3_tilemap;
static TILE_GET_INFO( get_sc0_tile_info ) static TILE_GET_INFO( get_sc0_tile_info )
{ {

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

@ -134,7 +134,7 @@
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static WRITE8_HANDLER( miniboy7_videoram_w ) static WRITE8_HANDLER( miniboy7_videoram_w )
{ {

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

@ -7,7 +7,7 @@
static UINT8 *mogura_tileram; static UINT8 *mogura_tileram;
static UINT8* mogura_gfxram; static UINT8* mogura_gfxram;
static tilemap *mogura_tilemap; static tilemap_t *mogura_tilemap;
static PALETTE_INIT( mogura ) static PALETTE_INIT( mogura )
{ {

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

@ -140,8 +140,8 @@ static int multfish_disp_enable;
/* Video Part */ /* Video Part */
static tilemap *multfish_tilemap; static tilemap_t *multfish_tilemap;
static tilemap *multfish_reel_tilemap; static tilemap_t *multfish_reel_tilemap;
static TILE_GET_INFO( get_multfish_tile_info ) static TILE_GET_INFO( get_multfish_tile_info )

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

@ -45,7 +45,7 @@ Notes:
#define MASTER_CLOCK XTAL_12MHz #define MASTER_CLOCK XTAL_12MHz
#define SOUND_CLOCK XTAL_45MHz #define SOUND_CLOCK XTAL_45MHz
static tilemap *bg_tilemap, *mlow_tilemap, *mhigh_tilemap, *tx_tilemap; static tilemap_t *bg_tilemap, *mlow_tilemap, *mhigh_tilemap, *tx_tilemap;
static UINT16 *bg_videoram, *mlow_videoram, *mhigh_videoram, *tx_videoram, *sprites_buffer; static UINT16 *bg_videoram, *mlow_videoram, *mhigh_videoram, *tx_videoram, *sprites_buffer;
static UINT16 *bg_scrollram, *mlow_scrollram, *mhigh_scrollram, *vidattrram; static UINT16 *bg_scrollram, *mlow_scrollram, *mhigh_scrollram, *vidattrram;
static UINT16 *mwarr_ram; static UINT16 *mwarr_ram;

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

@ -20,7 +20,7 @@ static struct
* 0x20/2 priority * 0x20/2 priority
* 0x30/2 color * 0x30/2 color
*/ */
tilemap *tmap[6]; tilemap_t *tmap[6];
UINT16 *videoram; UINT16 *videoram;
int gfxbank; int gfxbank;
UINT8 *maskBaseAddr; UINT8 *maskBaseAddr;
@ -1019,7 +1019,7 @@ READ32_HANDLER( namco_obj32_le_r )
* Namco System FL - Final Lap R, Speed Racer * Namco System FL - Final Lap R, Speed Racer
*/ */
#define ROZ_TILEMAP_COUNT 2 #define ROZ_TILEMAP_COUNT 2
static tilemap *mRozTilemap[ROZ_TILEMAP_COUNT]; static tilemap_t *mRozTilemap[ROZ_TILEMAP_COUNT];
static UINT16 *rozbank16; static UINT16 *rozbank16;
static UINT16 *rozvideoram16; static UINT16 *rozvideoram16;
static UINT16 *rozcontrol16; static UINT16 *rozcontrol16;
@ -1214,7 +1214,7 @@ UnpackRozParam( const UINT16 *pSource, struct RozParam *pRozParam )
static void static void
DrawRozHelper( DrawRozHelper(
bitmap_t *bitmap, bitmap_t *bitmap,
tilemap *tmap, tilemap_t *tmap,
const rectangle *clip, const rectangle *clip,
const struct RozParam *rozInfo ) const struct RozParam *rozInfo )
{ {
@ -1509,7 +1509,7 @@ WRITE32_HANDLER( namco_rozvideoram32_le_w )
*/ */
static UINT16 *mpRoadRAM; /* at 0x880000 in Final Lap; at 0xa00000 in Lucky&Wild */ static UINT16 *mpRoadRAM; /* at 0x880000 in Final Lap; at 0xa00000 in Lucky&Wild */
static int mRoadGfxBank; static int mRoadGfxBank;
static tilemap *mpRoadTilemap; static tilemap_t *mpRoadTilemap;
static pen_t mRoadTransparentColor; static pen_t mRoadTransparentColor;
static int mbRoadNeedTransparent; static int mbRoadNeedTransparent;

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

@ -743,7 +743,7 @@ Notes:
#include "sound/c352.h" #include "sound/c352.h"
static int ss23_vstat = 0, hstat = 0, vstate = 0; static int ss23_vstat = 0, hstat = 0, vstate = 0;
static tilemap *bgtilemap; static tilemap_t *bgtilemap;
static UINT32 *namcos23_textram, *namcos23_shared_ram; static UINT32 *namcos23_textram, *namcos23_shared_ram;
static UINT32 *namcos23_charram; static UINT32 *namcos23_charram;
static UINT8 namcos23_jvssense; static UINT8 namcos23_jvssense;

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

@ -225,7 +225,7 @@ Stephh's notes (based on the games M68000 code and some tests) :
#include "sound/okim6295.h" #include "sound/okim6295.h"
#include "sound/3812intf.h" #include "sound/3812intf.h"
static tilemap *fg_tilemap,*bg_tilemap; static tilemap_t *fg_tilemap,*bg_tilemap;
static UINT16 *nmg5_bitmap; static UINT16 *nmg5_bitmap;
static UINT16 *fg_videoram,*bg_videoram,*scroll_ram; static UINT16 *fg_videoram,*bg_videoram,*scroll_ram;
static UINT8 prot_val, input_data, priority_reg, gfx_bank; static UINT8 prot_val, input_data, priority_reg, gfx_bank;

4
src/mame/drivers/nwk-tr.c
View File

@ -245,9 +245,9 @@ static WRITE32_HANDLER( paletteram32_w )
static UINT32 *K001604_tile_ram[MAX_K001604_CHIPS]; static UINT32 *K001604_tile_ram[MAX_K001604_CHIPS];
static UINT32 *K001604_char_ram[MAX_K001604_CHIPS]; static UINT32 *K001604_char_ram[MAX_K001604_CHIPS];
static int K001604_gfx_index[MAX_K001604_CHIPS][2]; static int K001604_gfx_index[MAX_K001604_CHIPS][2];
static tilemap *K001604_layer_8x8[MAX_K001604_CHIPS][2]; static tilemap_t *K001604_layer_8x8[MAX_K001604_CHIPS][2];
static int K001604_tilemap_offset; static int K001604_tilemap_offset;
static tilemap *K001604_layer_roz[MAX_K001604_CHIPS][2]; static tilemap_t *K001604_layer_roz[MAX_K001604_CHIPS][2];
static int K001604_roz_size[MAX_K001604_CHIPS]; static int K001604_roz_size[MAX_K001604_CHIPS];
static UINT32 *K001604_reg[MAX_K001604_CHIPS]; static UINT32 *K001604_reg[MAX_K001604_CHIPS];

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

@ -58,7 +58,7 @@ $7004 writes, related to $7000 reads
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static PALETTE_INIT( olibochu ) static PALETTE_INIT( olibochu )
{ {

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

@ -44,7 +44,7 @@ Note: this is quite clearly a 'Korean bootleg' of Shisensho - Joshiryo-Hen / Mat
#include "sound/okim6295.h" #include "sound/okim6295.h"
#include "sound/3812intf.h" #include "sound/3812intf.h"
static tilemap *fg_tilemap; static tilemap_t *fg_tilemap;
static UINT8 *fgram; static UINT8 *fgram;
#define MASTER_CLOCK (XTAL_4MHz) #define MASTER_CLOCK (XTAL_4MHz)

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

@ -69,7 +69,7 @@ D.9B [f99cac4b] /
#define SOUND_CLOCK XTAL_14_31818MHz #define SOUND_CLOCK XTAL_14_31818MHz
#define TC15_CLOCK XTAL_12MHz #define TC15_CLOCK XTAL_12MHz
static tilemap *bgtilemap, *txttilemap; static tilemap_t *bgtilemap, *txttilemap;
static UINT8 *scrollram; static UINT8 *scrollram;
static UINT8 *mainram; static UINT8 *mainram;

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

@ -180,7 +180,7 @@ Stephh's log (2007.11.28) :
static UINT16 autohold_addr; /* address to patch in program RAM to enable autohold feature */ static UINT16 autohold_addr; /* address to patch in program RAM to enable autohold feature */
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT8 wingboard; static UINT8 wingboard;
static UINT8 jumper_e16_e17; /* Set this to TRUE when CG chips are 27c512 instead of 27c256 */ static UINT8 jumper_e16_e17; /* Set this to TRUE when CG chips are 27c512 instead of 27c256 */

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

@ -55,8 +55,8 @@ Notes:
#include "cpu/z80/z80daisy.h" #include "cpu/z80/z80daisy.h"
#include "cpu/m6805/m6805.h" #include "cpu/m6805/m6805.h"
static tilemap *tilemap1; static tilemap_t *tilemap1;
static tilemap *tilemap2; static tilemap_t *tilemap2;
static UINT8 *vram1; static UINT8 *vram1;
static UINT8 *vram2; static UINT8 *vram2;

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

@ -24,7 +24,7 @@ static UINT16* pkscramble_fgtilemap_ram;
static UINT16* pkscramble_mdtilemap_ram; static UINT16* pkscramble_mdtilemap_ram;
static UINT16* pkscramble_bgtilemap_ram; static UINT16* pkscramble_bgtilemap_ram;
static tilemap *fg_tilemap, *md_tilemap, *bg_tilemap; static tilemap_t *fg_tilemap, *md_tilemap, *bg_tilemap;
static const device_config *scanline_timer; static const device_config *scanline_timer;
static WRITE16_HANDLER( pkscramble_fgtilemap_w ) static WRITE16_HANDLER( pkscramble_fgtilemap_w )

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

@ -19,7 +19,7 @@ Magic Sticks:
#include "sound/okim6295.h" #include "sound/okim6295.h"
#include "includes/playmark.h" #include "includes/playmark.h"
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT16 *magicstk_videoram; static UINT16 *magicstk_videoram;
static int magicstk_tilebank; static int magicstk_tilebank;

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

@ -136,7 +136,7 @@ Dip locations added based on the notes above.
#include "sound/dac.h" #include "sound/dac.h"
static tilemap *ppmast93_fg_tilemap, *ppmast93_bg_tilemap; static tilemap_t *ppmast93_fg_tilemap, *ppmast93_bg_tilemap;
static UINT8 *ppmast93_fgram, *ppmast93_bgram; static UINT8 *ppmast93_fgram, *ppmast93_bgram;
static WRITE8_HANDLER( ppmast93_fgram_w ) static WRITE8_HANDLER( ppmast93_fgram_w )

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

@ -79,7 +79,7 @@ ROMS: All ROM labels say only "PROM" and a number.
#include "deprecat.h" #include "deprecat.h"
#include "sound/ay8910.h" #include "sound/ay8910.h"
static tilemap *pturn_fgmap,*pturn_bgmap; static tilemap_t *pturn_fgmap,*pturn_bgmap;
static int bgbank=0; static int bgbank=0;
static int fgbank=0; static int fgbank=0;
static int bgpalette=0; static int bgpalette=0;

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

@ -20,7 +20,7 @@
#include "machine/eeprom.h" #include "machine/eeprom.h"
static UINT16 *bg_videoram, *mid_videoram, *txt_videoram, *tilemap_regs, *video_regs; static UINT16 *bg_videoram, *mid_videoram, *txt_videoram, *tilemap_regs, *video_regs;
static tilemap *mid_tilemap, *txt_tilemap; static tilemap_t *mid_tilemap, *txt_tilemap;
static int ticket = 0; static int ticket = 0;
static TILE_GET_INFO( get_mid_tile_info ) static TILE_GET_INFO( get_mid_tile_info )

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

@ -49,7 +49,7 @@ Notes:
***************************************************************************/ ***************************************************************************/
static UINT8 *bg_ram, *fg_ram; static UINT8 *bg_ram, *fg_ram;
static tilemap *bg_tmap, *fg_tmap; static tilemap_t *bg_tmap, *fg_tmap;
static TILE_GET_INFO( get_bg_tile_info ) static TILE_GET_INFO( get_bg_tile_info )
{ {

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

@ -101,7 +101,7 @@ static int rabbit_vblirqlevel, rabbit_bltirqlevel, rabbit_banking;
static UINT32 *rabbit_tilemap_ram[4]; static UINT32 *rabbit_tilemap_ram[4];
static UINT32 *rabbit_spriteram; static UINT32 *rabbit_spriteram;
static tilemap *rabbit_tilemap[4]; static tilemap_t *rabbit_tilemap[4];
/* call with tilesize = 0 for 8x8 or 1 for 16x16 */ /* call with tilesize = 0 for 8x8 or 1 for 16x16 */
INLINE void get_rabbit_tilemap_info(running_machine *machine, tile_data *tileinfo, int tile_index, int whichtilemap, int tilesize) INLINE void get_rabbit_tilemap_info(running_machine *machine, tile_data *tileinfo, int tile_index, int whichtilemap, int tilesize)

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

@ -145,7 +145,7 @@ Current Problem(s) - in order of priority
#include "includes/raiden2.h" #include "includes/raiden2.h"
static tilemap *background_layer,*midground_layer,*foreground_layer,*text_layer; static tilemap_t *background_layer,*midground_layer,*foreground_layer,*text_layer;
static UINT16 *back_data,*fore_data,*mid_data, *w1ram; static UINT16 *back_data,*fore_data,*mid_data, *w1ram;
static int bg_bank, fg_bank, mid_bank; static int bg_bank, fg_bank, mid_bank;
static int bg_col, fg_col, mid_col; static int bg_col, fg_col, mid_col;
@ -329,7 +329,7 @@ static TILE_GET_INFO( get_text_tile_info )
} }
#if 0 #if 0
static void set_scroll(tilemap *tm, int plane) static void set_scroll(tilemap_t *tm, int plane)
{ {
int x = mainram[0x620/2+plane*2+0]; int x = mainram[0x620/2+plane*2+0];
int y = mainram[0x620/2+plane*2+1]; int y = mainram[0x620/2+plane*2+1];

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

@ -36,7 +36,7 @@ TODO:
static int gfxbank; static int gfxbank;
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static WRITE8_HANDLER( rmhaihai_videoram_w ) static WRITE8_HANDLER( rmhaihai_videoram_w )
{ {

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

@ -54,7 +54,7 @@ modified by Hau
static UINT8 *ram_1, *ram_2; static UINT8 *ram_1, *ram_2;
static size_t ram_size; static size_t ram_size;
static UINT8 ram_bank; static UINT8 ram_bank;
static tilemap *bg_tilemap, *fg_tilemap; static tilemap_t *bg_tilemap, *fg_tilemap;
static UINT8 *bg_scroll; static UINT8 *bg_scroll;

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

@ -48,7 +48,7 @@ PROMs : NEC B406 (1kx4) x2
static int bgmap = 0; static int bgmap = 0;
static int sbw_system = 0; static int sbw_system = 0;
static tilemap *sb_tilemap; static tilemap_t *sb_tilemap;
static UINT32 color_prom_address = 0; static UINT32 color_prom_address = 0;
static UINT8 pix_sh = 0; static UINT8 pix_sh = 0;
static UINT8 pix[2] = {0, 0}; static UINT8 pix[2] = {0, 0};

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

@ -58,7 +58,7 @@
static emu_timer *scanline_timer; static emu_timer *scanline_timer;
static emu_timer *pot_timer; static emu_timer *pot_timer;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT8 sync2_value; static UINT8 sync2_value;
static UINT8 pot_mask[2]; static UINT8 pot_mask[2];

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

@ -56,11 +56,11 @@ In a couple of cases, due to too many older revisions, I used: parent + version
static bitmap_t *temp_reel_bitmap; static bitmap_t *temp_reel_bitmap;
static tilemap *sfbonus_tilemap; static tilemap_t *sfbonus_tilemap;
static tilemap *sfbonus_reel_tilemap; static tilemap_t *sfbonus_reel_tilemap;
static tilemap *sfbonus_reel2_tilemap; static tilemap_t *sfbonus_reel2_tilemap;
static tilemap *sfbonus_reel3_tilemap; static tilemap_t *sfbonus_reel3_tilemap;
static tilemap *sfbonus_reel4_tilemap; static tilemap_t *sfbonus_reel4_tilemap;
static UINT8 *sfbonus_tilemap_ram; static UINT8 *sfbonus_tilemap_ram;
static UINT8 *sfbonus_reel_ram; static UINT8 *sfbonus_reel_ram;
static UINT8 *sfbonus_reel2_ram; static UINT8 *sfbonus_reel2_ram;

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

@ -27,7 +27,7 @@
static UINT8 *skyarmy_videoram; static UINT8 *skyarmy_videoram;
static UINT8 *skyarmy_colorram; static UINT8 *skyarmy_colorram;
static UINT8 *skyarmy_scrollram; static UINT8 *skyarmy_scrollram;
static tilemap* skyarmy_tilemap; static tilemap_t* skyarmy_tilemap;
static TILE_GET_INFO( get_skyarmy_tile_info ) static TILE_GET_INFO( get_skyarmy_tile_info )
{ {

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

@ -37,7 +37,7 @@
#include "sound/ay8910.h" #include "sound/ay8910.h"
#include "machine/8255ppi.h" #include "machine/8255ppi.h"
static tilemap *tmap; static tilemap_t *tmap;
static UINT8 *skylncr_videoram,*skylncr_colorram; static UINT8 *skylncr_videoram,*skylncr_colorram;
@ -49,10 +49,10 @@ static UINT8* reeltileshigh_1_ram;
static UINT8* reeltileshigh_2_ram; static UINT8* reeltileshigh_2_ram;
static UINT8* reeltileshigh_3_ram; static UINT8* reeltileshigh_3_ram;
static UINT8* reeltileshigh_4_ram; static UINT8* reeltileshigh_4_ram;
static tilemap *reel_1_tilemap; static tilemap_t *reel_1_tilemap;
static tilemap *reel_2_tilemap; static tilemap_t *reel_2_tilemap;
static tilemap *reel_3_tilemap; static tilemap_t *reel_3_tilemap;
static tilemap *reel_4_tilemap; static tilemap_t *reel_4_tilemap;
static UINT8* reelscroll1; static UINT8* reelscroll1;
static UINT8* reelscroll2; static UINT8* reelscroll2;
static UINT8* reelscroll3; static UINT8* reelscroll3;

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

@ -20,10 +20,10 @@ TODO:
static UINT8 *bg_tile_ram; static UINT8 *bg_tile_ram;
static tilemap *bg_tilemap; static tilemap_t *bg_tilemap;
static UINT8 *fg_tile_ram, *fg_color_ram; static UINT8 *fg_tile_ram, *fg_color_ram;
static tilemap *fg_tilemap; static tilemap_t *fg_tilemap;
static int video_enable; static int video_enable;

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

@ -93,7 +93,7 @@ Note
#include "machine/eeprom.h" #include "machine/eeprom.h"
static UINT8 *spool99_main; static UINT8 *spool99_main;
static tilemap *sc0_tilemap; static tilemap_t *sc0_tilemap;
static UINT8 *spool99_cram; static UINT8 *spool99_cram;
static UINT8 *spool99_vram; static UINT8 *spool99_vram;

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

@ -73,7 +73,7 @@ quaquiz2 - no inputs, needs NVRAM
#define MASTER_CLOCK 12440000 #define MASTER_CLOCK 12440000
static tilemap *statriv2_tilemap; static tilemap_t *statriv2_tilemap;
static UINT8 *question_offset; static UINT8 *question_offset;
static UINT8 question_offset_low; static UINT8 question_offset_low;

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

@ -28,7 +28,7 @@ To enter test mode in smoto, keep F2 pressed during boot.
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *tmap; static tilemap_t *tmap;
static int tiles_offset; static int tiles_offset;
static WRITE8_HANDLER( subsino_tiles_offset_w ) static WRITE8_HANDLER( subsino_tiles_offset_w )

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

@ -31,7 +31,7 @@ static const device_config *laserdisc;
static UINT8 superdq_ld_in_latch; static UINT8 superdq_ld_in_latch;
static UINT8 superdq_ld_out_latch; static UINT8 superdq_ld_out_latch;
static tilemap *superdq_tilemap; static tilemap_t *superdq_tilemap;
static int superdq_color_bank = 0; static int superdq_color_bank = 0;
static TILE_GET_INFO( get_tile_info ) static TILE_GET_INFO( get_tile_info )

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

@ -24,7 +24,7 @@
#include "sound/2203intf.h" #include "sound/2203intf.h"
#include "sound/msm5205.h" #include "sound/msm5205.h"
static tilemap *suprgolf_tilemap; static tilemap_t *suprgolf_tilemap;
static UINT8 *suprgolf_bg_vram; static UINT8 *suprgolf_bg_vram;
static UINT16 *suprgolf_bg_fb,*suprgolf_fg_fb; static UINT16 *suprgolf_bg_fb,*suprgolf_fg_fb;
static int suprgolf_rom_bank; static int suprgolf_rom_bank;

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

@ -24,7 +24,7 @@
static UINT8 *videoram; static UINT8 *videoram;
static UINT8 *colorram; static UINT8 *colorram;
static tilemap *tmap; static tilemap_t *tmap;
static TILE_GET_INFO( get_tile_info ) static TILE_GET_INFO( get_tile_info )
{ {

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