Previous

199869 Revisions

Next

r17675 Thursday 6th September, 2012 at 13:27:34 UTC by Miodrag Milanović
TILE/TILEMAP modernization part 3 (no whatsnew)

[src/mame/drivers]	namcoic.c powerbal.c
[src/mame/includes]	galaga.h ladybug.h m10.h megadriv.h namcoic.h namcos2.h playmark.h
[src/mame/machine]	decocass.h megacd.c
[src/mame/video]	bosco.c decocass.c digdug.c m10.c namcofl.c namconb1.c namcos2.c redclash.c xevious.c
[src/mess/includes]	apple1.h aquarius.h microtan.h x68k.h
[src/mess/video]	apple1.c aquarius.c microtan.c x68k.c

trunk/src/mame/machine/megacd.c

r17674	r17675
2011	2011
2012	2012
2013	2013
2014		static TILE_GET_INFO( get_stampmap_16x16_1x1_tile_info )
	2014	TILE_GET_INFO_MEMBER( md_base_state::get_stampmap_16x16_1x1_tile_info )
2015	2015	{
2016	2016	int tile_region, tileno;
2017	2017	SCD_GET_TILE_INFO_16x16_1x1(tile_region,tileno,(int)tile_index);
2018		SET_TILE_INFO(tile_region, tileno, 0, 0);
	2018	SET_TILE_INFO_MEMBER(tile_region, tileno, 0, 0);
2019	2019	}
2020	2020
2021		static TILE_GET_INFO( get_stampmap_32x32_1x1_tile_info )
	2021	TILE_GET_INFO_MEMBER( md_base_state::get_stampmap_32x32_1x1_tile_info )
2022	2022	{
2023	2023	int tile_region, tileno;
2024	2024	SCD_GET_TILE_INFO_32x32_1x1(tile_region,tileno,(int)tile_index);
2025		SET_TILE_INFO(tile_region, tileno, 0, 0);
	2025	SET_TILE_INFO_MEMBER(tile_region, tileno, 0, 0);
2026	2026	}
2027	2027
2028	2028
2029		static TILE_GET_INFO( get_stampmap_16x16_16x16_tile_info )
	2029	TILE_GET_INFO_MEMBER( md_base_state::get_stampmap_16x16_16x16_tile_info )
2030	2030	{
2031	2031	int tile_region, tileno;
2032	2032	SCD_GET_TILE_INFO_16x16_16x16(tile_region,tileno,(int)tile_index);
2033		SET_TILE_INFO(tile_region, tileno, 0, 0);
	2033	SET_TILE_INFO_MEMBER(tile_region, tileno, 0, 0);
2034	2034	}
2035	2035
2036		static TILE_GET_INFO( get_stampmap_32x32_16x16_tile_info )
	2036	TILE_GET_INFO_MEMBER( md_base_state::get_stampmap_32x32_16x16_tile_info )
2037	2037	{
2038	2038	int tile_region, tileno;
2039	2039	SCD_GET_TILE_INFO_32x32_16x16(tile_region,tileno,(int)tile_index);
2040		SET_TILE_INFO(tile_region, tileno, 0, 0);
	2040	SET_TILE_INFO_MEMBER(tile_region, tileno, 0, 0);
2041	2041	}
2042	2042
2043	2043	// non-tilemap functions to get a pixel from a 'tilemap' based on the above, but looking up each pixel, as to avoid the heavy cache bitmap
r17674	r17675
2304	2304	machine.gfx[14]= auto_alloc(machine, gfx_element(machine, sega_32x32_r10_f1_layout, (UINT8 *)segacd_dataram, 0, 0));
2305	2305	machine.gfx[15]= auto_alloc(machine, gfx_element(machine, sega_32x32_r01_f1_layout, (UINT8 *)segacd_dataram, 0, 0));
2306	2306
2307		segacd_stampmap[0] = tilemap_create(machine, get_stampmap_16x16_1x1_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 16, 16);
2308		segacd_stampmap[1] = tilemap_create(machine, get_stampmap_32x32_1x1_tile_info, TILEMAP_SCAN_ROWS, 32, 32, 8, 8);
2309		segacd_stampmap[2] = tilemap_create(machine, get_stampmap_16x16_16x16_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 256, 256); // 128kb!
2310		segacd_stampmap[3] = tilemap_create(machine, get_stampmap_32x32_16x16_tile_info, TILEMAP_SCAN_ROWS, 32, 32, 128, 128); // 32kb!
	2307	md_base_state *state = machine.driver_data<md_base_state>();
	2308	segacd_stampmap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(md_base_state::get_stampmap_16x16_1x1_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 16, 16);
	2309	segacd_stampmap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(md_base_state::get_stampmap_32x32_1x1_tile_info),state), TILEMAP_SCAN_ROWS, 32, 32, 8, 8);
	2310	segacd_stampmap[2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(md_base_state::get_stampmap_16x16_16x16_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 256, 256); // 128kb!
	2311	segacd_stampmap[3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(md_base_state::get_stampmap_32x32_16x16_tile_info),state), TILEMAP_SCAN_ROWS, 32, 32, 128, 128); // 32kb!
2311	2312	}
2312	2313
2313	2314

trunk/src/mame/machine/decocass.h

r17674	r17675
138	138	DECLARE_DRIVER_INIT(decocass);
139	139	DECLARE_DRIVER_INIT(decocrom);
140	140	DECLARE_DRIVER_INIT(cdsteljn);
	141	TILEMAP_MAPPER_MEMBER(fgvideoram_scan_cols);
	142	TILEMAP_MAPPER_MEMBER(bgvideoram_scan_cols);
	143	TILE_GET_INFO_MEMBER(get_bg_l_tile_info);
	144	TILE_GET_INFO_MEMBER(get_bg_r_tile_info);
	145	TILE_GET_INFO_MEMBER(get_fg_tile_info);
141	146	};
142	147
143	148

trunk/src/mame/includes/m10.h

r17674	r17675
79	79	DECLARE_INPUT_CHANGED_MEMBER(coin_inserted);
80	80	DECLARE_DRIVER_INIT(andromed);
81	81	DECLARE_DRIVER_INIT(ipminva1);
	82	TILEMAP_MAPPER_MEMBER(tilemap_scan);
	83	TILE_GET_INFO_MEMBER(get_tile_info);
82	84	};
83	85
84	86

trunk/src/mame/includes/megadriv.h

r17674	r17675
107	107	DECLARE_DRIVER_INIT(megadriv);
108	108	DECLARE_DRIVER_INIT(megadrij);
109	109	DECLARE_DRIVER_INIT(mpnew);
	110
	111	TILE_GET_INFO_MEMBER( get_stampmap_16x16_1x1_tile_info );
	112	TILE_GET_INFO_MEMBER( get_stampmap_32x32_1x1_tile_info );
	113	TILE_GET_INFO_MEMBER( get_stampmap_16x16_16x16_tile_info );
	114	TILE_GET_INFO_MEMBER( get_stampmap_32x32_16x16_tile_info );
110	115	};
111	116
112	117	class md_boot_state : public md_base_state

trunk/src/mame/includes/playmark.h

r17674	r17675
87	87	TILE_GET_INFO_MEMBER(bigtwinb_get_tx_tile_info);
88	88	TILE_GET_INFO_MEMBER(hrdtimes_get_fg_tile_info);
89	89	TILE_GET_INFO_MEMBER(hrdtimes_get_bg_tile_info);
	90	TILE_GET_INFO_MEMBER(powerbal_get_bg_tile_info);
90	91	};
91	92
92	93	/*----------- defined in video/playmark.c -----------*/

trunk/src/mame/includes/galaga.h

r17674	r17675
79	79	DECLARE_DRIVER_INIT(xevious);
80	80	DECLARE_DRIVER_INIT(xevios);
81	81	DECLARE_DRIVER_INIT(battles);
	82	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	83	TILE_GET_INFO_MEMBER(get_bg_tile_info);
82	84	};
83	85
84	86
r17674	r17675
103	105	UINT8 *m_spriteram2;
104	106	UINT32 m_spriteram_size;
105	107	DECLARE_WRITE8_MEMBER(bosco_flip_screen_w);
	108	TILEMAP_MAPPER_MEMBER(fg_tilemap_scan);
	109	TILE_GET_INFO_MEMBER(bg_get_tile_info);
	110	TILE_GET_INFO_MEMBER(fg_get_tile_info);
106	111	};
107	112
108	113	class digdug_state : public galaga_state
r17674	r17675
123	128	UINT8 m_bg_disable;
124	129	UINT8 m_bg_color_bank;
125	130	DECLARE_CUSTOM_INPUT_MEMBER(shifted_port_r);
	131	TILEMAP_MAPPER_MEMBER(tilemap_scan);
	132	TILE_GET_INFO_MEMBER(bg_get_tile_info);
	133	TILE_GET_INFO_MEMBER(tx_get_tile_info);
126	134	};
127	135
128	136

trunk/src/mame/includes/namcos2.h

r17674	r17675
117	117	DECLARE_WRITE16_MEMBER( c169_roz_bank_w );
118	118	DECLARE_READ16_MEMBER( c169_roz_videoram_r );
119	119	DECLARE_WRITE16_MEMBER( c169_roz_videoram_w );
120
	120	TILE_GET_INFO_MEMBER( get_tile_info0 );
	121	TILE_GET_INFO_MEMBER( get_tile_info1 );
	122	TILE_GET_INFO_MEMBER( get_tile_info2 );
	123	TILE_GET_INFO_MEMBER( get_tile_info3 );
	124	TILE_GET_INFO_MEMBER( get_tile_info4 );
	125	TILE_GET_INFO_MEMBER( get_tile_info5 );
	126	void namco_tilemap_init(int gfxbank, void *pMaskROM, void (*cb)( running_machine &machine, UINT16 code, int *gfx, int *mask) );
121	127	protected:
122	128	struct roz_parameters
123	129	{

trunk/src/mame/includes/namcoic.h

r17674	r17675
158	158
159	159	/*----------- defined in drivers/namcoic.c -----------*/
160	160
161		void namco_tilemap_init(
162		running_machine &machine, int gfxbank, void *pMaskROM,
163		void (*cb)( running_machine &machine, UINT16 code, int *gfx, int *mask) );
164	161	void namco_tilemap_draw( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
165	162	void namco_tilemap_invalidate( void );
166	163	WRITE16_HANDLER( namco_tilemapvideoram16_w );

trunk/src/mame/includes/ladybug.h

r17674	r17675
64	64	DECLARE_DRIVER_INIT(redclash);
65	65	TILE_GET_INFO_MEMBER(get_bg_tile_info);
66	66	TILE_GET_INFO_MEMBER(get_grid_tile_info);
	67	TILE_GET_INFO_MEMBER(get_fg_tile_info);
67	68	};
68	69
69	70

trunk/src/mame/video/xevious.c

r17674	r17675
176	176
177	177	***************************************************************************/
178	178
179		static TILE_GET_INFO( get_fg_tile_info )
	179	TILE_GET_INFO_MEMBER(xevious_state::get_fg_tile_info)
180	180	{
181		xevious_state *state = machine.driver_data<xevious_state>();
	181	UINT8 attr = m_xevious_fg_colorram[tile_index];
182	182
183		UINT8 attr = state->m_xevious_fg_colorram[tile_index];
184
185	183	/* the hardware has two character sets, one normal and one x-flipped. When
186	184	screen is flipped, character y flip is done by the hardware inverting the
187	185	timing signals, while x flip is done by selecting the 2nd character set.
188	186	We reproduce this here, but since the tilemap system automatically flips
189	187	characters when screen is flipped, we have to flip them back. */
190	188	UINT8 color = ((attr & 0x03) << 4) | ((attr & 0x3c) >> 2);
191		SET_TILE_INFO(
	189	SET_TILE_INFO_MEMBER(
192	190	0,
193		state->m_xevious_fg_videoram[tile_index] | (state->flip_screen() ? 0x100 : 0),
	191	m_xevious_fg_videoram[tile_index] | (flip_screen() ? 0x100 : 0),
194	192	color,
195		TILE_FLIPYX((attr & 0xc0) >> 6) ^ (state->flip_screen() ? TILE_FLIPX : 0));
	193	TILE_FLIPYX((attr & 0xc0) >> 6) ^ (flip_screen() ? TILE_FLIPX : 0));
196	194	}
197	195
198		static TILE_GET_INFO( get_bg_tile_info )
	196	TILE_GET_INFO_MEMBER(xevious_state::get_bg_tile_info)
199	197	{
200		xevious_state *state =  machine.driver_data<xevious_state>();
201
202		UINT8 code = state->m_xevious_bg_videoram[tile_index];
203		UINT8 attr = state->m_xevious_bg_colorram[tile_index];
	198	UINT8 code = m_xevious_bg_videoram[tile_index];
	199	UINT8 attr = m_xevious_bg_colorram[tile_index];
204	200	UINT8 color = ((attr & 0x3c) >> 2) | ((code & 0x80) >> 3) | ((attr & 0x03) << 5);
205		SET_TILE_INFO(
	201	SET_TILE_INFO_MEMBER(
206	202	1,
207	203	code + ((attr & 0x01) << 8),
208	204	color,
r17674	r17675
221	217	{
222	218	xevious_state *state =  machine.driver_data<xevious_state>();
223	219
224		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,TILEMAP_SCAN_ROWS,     8,8,64,32);
225		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32);
	220	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(xevious_state::get_bg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	221	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(xevious_state::get_fg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
226	222
227	223	state->m_bg_tilemap->set_scrolldx(-20,288+27);
228	224	state->m_bg_tilemap->set_scrolldy(-16,-16);

trunk/src/mame/video/namcofl.c

r17674	r17675
120	120	VIDEO_START( namcofl )
121	121	{
122	122	namcofl_state *state = machine.driver_data<namcofl_state>();
123		namco_tilemap_init( machine, NAMCOFL_TILEGFX, machine.root_device().memregion(NAMCOFL_TILEMASKREGION)->base(), TilemapCB );
	123	state->namco_tilemap_init(NAMCOFL_TILEGFX, machine.root_device().memregion(NAMCOFL_TILEMASKREGION)->base(), TilemapCB );
124	124	state->c355_obj_init(NAMCOFL_SPRITEGFX,0x0,namcos2_shared_state::c355_obj_code2tile_delegate(FUNC(FLobjcode2tile), &machine));
125	125	state->c169_roz_init(NAMCOFL_ROTGFX,NAMCOFL_ROTMASKREGION);
126	126	}

trunk/src/mame/video/namconb1.c

r17674	r17675
165	165	VIDEO_START( namconb1 )
166	166	{
167	167	namconb1_state *state = machine.driver_data<namconb1_state>();
168		namco_tilemap_init( machine, NAMCONB1_TILEGFX, machine.root_device().memregion(NAMCONB1_TILEMASKREGION)->base(), NB1TilemapCB );
	168	state->namco_tilemap_init(NAMCONB1_TILEGFX, machine.root_device().memregion(NAMCONB1_TILEMASKREGION)->base(), NB1TilemapCB );
169	169	state->c355_obj_init(NAMCONB1_SPRITEGFX,0x0,namcos2_shared_state::c355_obj_code2tile_delegate(FUNC(NB1objcode2tile), &machine));
170	170	} /* namconb1 */
171	171
r17674	r17675
227	227	VIDEO_START( namconb2 )
228	228	{
229	229	namconb1_state *state = machine.driver_data<namconb1_state>();
230		namco_tilemap_init(machine, NAMCONB1_TILEGFX, machine.root_device().memregion(NAMCONB1_TILEMASKREGION)->base(), NB2TilemapCB );
	230	state->namco_tilemap_init(NAMCONB1_TILEGFX, machine.root_device().memregion(NAMCONB1_TILEMASKREGION)->base(), NB2TilemapCB );
231	231	state->c355_obj_init(NAMCONB1_SPRITEGFX,0x0,namcos2_shared_state::c355_obj_code2tile_delegate(FUNC(NB2objcode2tile), &machine));
232	232	state->c169_roz_init(NAMCONB1_ROTGFX,NAMCONB1_ROTMASKREGION);
233	233	} /* namconb2_vh_start */

trunk/src/mame/video/bosco.c

r17674	r17675
86	86	***************************************************************************/
87	87
88	88	/* the video RAM has space for 32x32 tiles and is only partially used for the radar */
89		static TILEMAP_MAPPER( fg_tilemap_scan )
	89	TILEMAP_MAPPER_MEMBER(bosco_state::fg_tilemap_scan )
90	90	{
91	91	return col + (row << 5);
92	92	}
93	93
94	94
95		INLINE void get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,int ram_offs)
	95	INLINE void get_tile_info_bosco(running_machine &machine,tile_data &tileinfo,int tile_index,int ram_offs)
96	96	{
97	97	bosco_state *state =  machine.driver_data<bosco_state>();
98	98
r17674	r17675
106	106	TILE_FLIPYX(attr >> 6) ^ TILE_FLIPX);
107	107	}
108	108
109		static TILE_GET_INFO( bg_get_tile_info )
	109	TILE_GET_INFO_MEMBER(bosco_state::bg_get_tile_info )
110	110	{
111		get_tile_info(machine,tileinfo,tile_index,0x400);
	111	get_tile_info_bosco(machine(),tileinfo,tile_index,0x400);
112	112	}
113	113
114		static TILE_GET_INFO( fg_get_tile_info )
	114	TILE_GET_INFO_MEMBER(bosco_state::fg_get_tile_info )
115	115	{
116		get_tile_info(machine,tileinfo,tile_index,0x000);
	116	get_tile_info_bosco(machine(),tileinfo,tile_index,0x000);
117	117	}
118	118
119	119
r17674	r17675
128	128	{
129	129	bosco_state *state =  machine.driver_data<bosco_state>();
130	130
131		state->m_bg_tilemap = tilemap_create(machine, bg_get_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32);
132		state->m_fg_tilemap = tilemap_create(machine, fg_get_tile_info,fg_tilemap_scan,  8,8, 8,32);
	131	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bosco_state::bg_get_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32);
	132	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bosco_state::fg_get_tile_info),state),tilemap_mapper_delegate(FUNC(bosco_state::fg_tilemap_scan),state),  8,8, 8,32);
133	133
134	134	colortable_configure_tilemap_groups(machine.colortable, state->m_bg_tilemap, machine.gfx[0], 0x1f);
135	135	colortable_configure_tilemap_groups(machine.colortable, state->m_fg_tilemap, machine.gfx[0], 0x1f);

trunk/src/mame/video/redclash.c

r17674	r17675
168	168	redclash_set_stars_enable(space->machine(), 1);
169	169	}
170	170
171		static TILE_GET_INFO( get_fg_tile_info )
	171	TILE_GET_INFO_MEMBER(ladybug_state::get_fg_tile_info)
172	172	{
173		ladybug_state *state = machine.driver_data<ladybug_state>();
174		int code = state->m_videoram[tile_index];
175		int color = (state->m_videoram[tile_index] & 0x70) >> 4; // ??
	173	int code = m_videoram[tile_index];
	174	int color = (m_videoram[tile_index] & 0x70) >> 4; // ??
176	175
177		SET_TILE_INFO(0, code, color, 0);
	176	SET_TILE_INFO_MEMBER(0, code, color, 0);
178	177	}
179	178
180	179	VIDEO_START( redclash )
181	180	{
182	181	ladybug_state *state = machine.driver_data<ladybug_state>();
183	182
184		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	183	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ladybug_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
185	184	state->m_fg_tilemap->set_transparent_pen(0);
186	185	}
187	186

trunk/src/mame/video/namcos2.c

r17674	r17675
398	398
399	399	void namcos2_state::video_start()
400	400	{
401		namco_tilemap_init(machine(), 2, memregion("gfx4")->base(), TilemapCB);
	401	namco_tilemap_init(2, memregion("gfx4")->base(), TilemapCB);
402	402	m_tilemap_roz = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_state::roz_tile_info), this), TILEMAP_SCAN_ROWS, 8,8,256,256);
403	403	m_tilemap_roz->set_transparent_pen(0xff);
404	404	draw_sprite_init();
r17674	r17675
446	446
447	447	void namcos2_state::video_start_finallap()
448	448	{
449		namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
	449	namco_tilemap_init(2,memregion("gfx4")->base(),TilemapCB);
450	450	draw_sprite_init();
451	451	}
452	452
r17674	r17675
475	475
476	476	void namcos2_state::video_start_luckywld()
477	477	{
478		namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
	478	namco_tilemap_init(2,memregion("gfx4")->base(),TilemapCB);
479	479	c355_obj_init( 0, 0x0, namcos2_shared_state::c355_obj_code2tile_delegate() );
480	480	if( m_gametype==NAMCOS2_LUCKY_AND_WILD )
481	481	{
r17674	r17675
512	512
513	513	void namcos2_state::video_start_sgunner()
514	514	{
515		namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
	515	namco_tilemap_init(2,memregion("gfx4")->base(),TilemapCB);
516	516	c355_obj_init( 0, 0x0, namcos2_shared_state::c355_obj_code2tile_delegate() );
517	517	}
518	518
r17674	r17675
538	538
539	539	void namcos2_state::video_start_metlhawk()
540	540	{
541		namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
	541	namco_tilemap_init(2,memregion("gfx4")->base(),TilemapCB);
542	542	c169_roz_init(1, "gfx5");
543	543	}
544	544

trunk/src/mame/video/digdug.c

r17674	r17675
73	73	***************************************************************************/
74	74
75	75	/* convert from 32x32 to 36x28 */
76		static TILEMAP_MAPPER( tilemap_scan )
	76	TILEMAP_MAPPER_MEMBER(digdug_state::tilemap_scan)
77	77	{
78	78	int offs;
79	79
r17674	r17675
88	88	}
89	89
90	90
91		static TILE_GET_INFO( bg_get_tile_info )
	91	TILE_GET_INFO_MEMBER(digdug_state::bg_get_tile_info)
92	92	{
93		UINT8 *rom = machine.root_device().memregion("gfx4")->base();
94		digdug_state *state =  machine.driver_data<digdug_state>();
	93	UINT8 *rom = machine().root_device().memregion("gfx4")->base();
95	94
96		int code = rom[tile_index | (state->m_bg_select << 10)];
	95	int code = rom[tile_index | (m_bg_select << 10)];
97	96	/* when the background is "disabled", it is actually still drawn, but using
98	97	a color code that makes all pixels black. There are pullups setting the
99	98	code to 0xf, but also solder pads that optionally connect the lines with
100	99	tilemap RAM, therefore allowing to pick some bits of the color code from
101	100	the top 4 bits of alpha code. This feature is not used by Dig Dug. */
102		int color = state->m_bg_disable ? 0xf : (code >> 4);
103		SET_TILE_INFO(
	101	int color = m_bg_disable ? 0xf : (code >> 4);
	102	SET_TILE_INFO_MEMBER(
104	103	2,
105	104	code,
106		color | state->m_bg_color_bank,
	105	color | m_bg_color_bank,
107	106	0);
108	107	}
109	108
110		static TILE_GET_INFO( tx_get_tile_info )
	109	TILE_GET_INFO_MEMBER(digdug_state::tx_get_tile_info)
111	110	{
112		digdug_state *state =  machine.driver_data<digdug_state>();
113		UINT8 code = state->m_videoram[tile_index];
	111	UINT8 code = m_videoram[tile_index];
114	112	int color;
115	113
116	114	/* the hardware has two ways to pick the color, either straight from the
r17674	r17675
118	116	formula. The former method isnot used by Dig Dug and seems kind of
119	117	useless (I don't know what use they were thinking of when they added
120	118	it), anyway here it is reproduced faithfully. */
121		if (state->m_tx_color_mode)
	119	if (m_tx_color_mode)
122	120	color = code & 0x0f;
123	121	else
124	122	color = ((code >> 4) & 0x0e) | ((code >> 3) & 2);
r17674	r17675
128	126	timing signals, while x flip is done by selecting the 2nd character set.
129	127	We reproduce this here, but since the tilemap system automatically flips
130	128	characters when screen is flipped, we have to flip them back. */
131		SET_TILE_INFO(
	129	SET_TILE_INFO_MEMBER(
132	130	0,
133		(code & 0x7f) | (state->flip_screen() ? 0x80 : 0),
	131	(code & 0x7f) | (flip_screen() ? 0x80 : 0),
134	132	color,
135		state->flip_screen() ? TILE_FLIPX : 0);
	133	flip_screen() ? TILE_FLIPX : 0);
136	134	}
137	135
138	136
r17674	r17675
147	145	{
148	146	digdug_state *state =  machine.driver_data<digdug_state>();
149	147
150		state->m_bg_tilemap = tilemap_create(machine, bg_get_tile_info,tilemap_scan,     8,8,36,28);
151		state->m_fg_tilemap = tilemap_create(machine, tx_get_tile_info,tilemap_scan,8,8,36,28);
	148	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(digdug_state::bg_get_tile_info),state),tilemap_mapper_delegate(FUNC(digdug_state::tilemap_scan),state),8,8,36,28);
	149	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(digdug_state::tx_get_tile_info),state),tilemap_mapper_delegate(FUNC(digdug_state::tilemap_scan),state),8,8,36,28);
152	150
153	151	state->m_fg_tilemap->set_transparent_pen(0);
154	152

trunk/src/mame/video/decocass.c

r17674	r17675
68	68	tilemap callbacks
69	69	********************************************/
70	70
71		static TILEMAP_MAPPER( fgvideoram_scan_cols )
	71	TILEMAP_MAPPER_MEMBER(decocass_state::fgvideoram_scan_cols )
72	72	{
73	73	/* logical (col,row) -> memory offset */
74	74	return (num_cols - 1 - col) * num_rows + row;
75	75	}
76	76
77		static TILEMAP_MAPPER( bgvideoram_scan_cols )
	77	TILEMAP_MAPPER_MEMBER(decocass_state::bgvideoram_scan_cols )
78	78	{
79	79	/* logical (col,row) -> memory offset */
80	80	return tile_offset[col * num_rows + row];
81	81	}
82	82
83		static TILE_GET_INFO( get_bg_l_tile_info )
	83	TILE_GET_INFO_MEMBER(decocass_state::get_bg_l_tile_info)
84	84	{
85		decocass_state *state = machine.driver_data<decocass_state>();
86		int color = (state->m_color_center_bot >> 7) & 1;
87		SET_TILE_INFO(
	85	int color = (m_color_center_bot >> 7) & 1;
	86	SET_TILE_INFO_MEMBER(
88	87	2,
89		(0x80 == (tile_index & 0x80)) ? 16 : state->m_bgvideoram[tile_index] >> 4,
	88	(0x80 == (tile_index & 0x80)) ? 16 : m_bgvideoram[tile_index] >> 4,
90	89	color,
91	90	0);
92	91	}
93	92
94		static TILE_GET_INFO( get_bg_r_tile_info )
	93	TILE_GET_INFO_MEMBER(decocass_state::get_bg_r_tile_info )
95	94	{
96		decocass_state *state = machine.driver_data<decocass_state>();
97		int color = (state->m_color_center_bot >> 7) & 1;
98		SET_TILE_INFO(
	95	int color = (m_color_center_bot >> 7) & 1;
	96	SET_TILE_INFO_MEMBER(
99	97	2,
100		(0x00 == (tile_index & 0x80)) ? 16 : state->m_bgvideoram[tile_index] >> 4,
	98	(0x00 == (tile_index & 0x80)) ? 16 : m_bgvideoram[tile_index] >> 4,
101	99	color,
102	100	TILE_FLIPY);
103	101	}
104	102
105		static TILE_GET_INFO( get_fg_tile_info )
	103	TILE_GET_INFO_MEMBER(decocass_state::get_fg_tile_info )
106	104	{
107		decocass_state *state = machine.driver_data<decocass_state>();
108		UINT8 code = state->m_fgvideoram[tile_index];
109		UINT8 attr = state->m_colorram[tile_index];
110		SET_TILE_INFO(
	105	UINT8 code = m_fgvideoram[tile_index];
	106	UINT8 attr = m_colorram[tile_index];
	107	SET_TILE_INFO_MEMBER(
111	108	0,
112	109	256 * (attr & 3) + code,
113		state->m_color_center_bot & 1,
	110	m_color_center_bot & 1,
114	111	0);
115	112	}
116	113
r17674	r17675
492	489	VIDEO_START( decocass )
493	490	{
494	491	decocass_state *state = machine.driver_data<decocass_state>();
495		state->m_bg_tilemap_l = tilemap_create(machine, get_bg_l_tile_info, bgvideoram_scan_cols, 16, 16, 32, 32);
496		state->m_bg_tilemap_r = tilemap_create(machine, get_bg_r_tile_info, bgvideoram_scan_cols, 16, 16, 32, 32);
497		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, fgvideoram_scan_cols, 8, 8, 32, 32);
	492	state->m_bg_tilemap_l = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(decocass_state::get_bg_l_tile_info),state), tilemap_mapper_delegate(FUNC(decocass_state::bgvideoram_scan_cols),state), 16, 16, 32, 32);
	493	state->m_bg_tilemap_r = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(decocass_state::get_bg_r_tile_info),state), tilemap_mapper_delegate(FUNC(decocass_state::bgvideoram_scan_cols),state), 16, 16, 32, 32);
	494	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(decocass_state::get_fg_tile_info),state), tilemap_mapper_delegate(FUNC(decocass_state::fgvideoram_scan_cols),state), 8, 8, 32, 32);
498	495
499	496	state->m_bg_tilemap_l->set_transparent_pen(0);
500	497	state->m_bg_tilemap_r->set_transparent_pen(0);

trunk/src/mame/video/m10.c

r17674	r17675
42	42	8*8   /* every char takes 8 consecutive bytes */
43	43	};
44	44
45		static TILEMAP_MAPPER( tilemap_scan )
	45	TILEMAP_MAPPER_MEMBER(m10_state::tilemap_scan)
46	46	{
47	47	return (31 - col) * 32 + row;
48	48	}
49	49
50	50
51		static void get_tile_info( running_machine &machine, tile_data &tileinfo, tilemap_memory_index tile_index, void *param )
	51	TILE_GET_INFO_MEMBER(m10_state::get_tile_info)
52	52	{
53		m10_state *state = machine.driver_data<m10_state>();
54
55		SET_TILE_INFO(0, state->m_videoram[tile_index], state->m_colorram[tile_index] & 0x07, 0);
	53	SET_TILE_INFO_MEMBER(0, m_videoram[tile_index], m_colorram[tile_index] & 0x07, 0);
56	54	}
57	55
58	56
r17674	r17675
104	102	{
105	103	m10_state *state = machine.driver_data<m10_state>();
106	104
107		state->m_tx_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan, 8, 8, 32, 32);
	105	state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(m10_state::get_tile_info),state), tilemap_mapper_delegate(FUNC(m10_state::tilemap_scan),state), 8, 8, 32, 32);
108	106	state->m_tx_tilemap->set_transparent_pen(0);
109	107	state->m_tx_tilemap->set_scrolldx(0, 62);
110	108	state->m_tx_tilemap->set_scrolldy(0, 0);
r17674	r17675
121	119
122	120	machine.gfx[0] = auto_alloc(machine, gfx_element(machine, charlayout, state->m_chargen, 8, 0));
123	121
124		state->m_tx_tilemap = tilemap_create(machine, get_tile_info,tilemap_scan, 8, 8, 32, 32);
	122	state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(m10_state::get_tile_info),state),tilemap_mapper_delegate(FUNC(m10_state::tilemap_scan),state), 8, 8, 32, 32);
125	123	state->m_tx_tilemap->set_scrolldx(0, 116);
126	124	state->m_tx_tilemap->set_scrolldy(0, 0);
127	125

trunk/src/mame/drivers/namcoic.c

r17674	r17675
51	51	SET_TILE_INFO(mTilemapInfo.gfxbank,tile,0,0);
52	52	} /* get_tile_info */
53	53
54		static TILE_GET_INFO( get_tile_info0 ) { get_tile_info(machine,tileinfo,tile_index,&mTilemapInfo.videoram[0x0000]); }
55		static TILE_GET_INFO( get_tile_info1 ) { get_tile_info(machine,tileinfo,tile_index,&mTilemapInfo.videoram[0x1000]); }
56		static TILE_GET_INFO( get_tile_info2 ) { get_tile_info(machine,tileinfo,tile_index,&mTilemapInfo.videoram[0x2000]); }
57		static TILE_GET_INFO( get_tile_info3 ) { get_tile_info(machine,tileinfo,tile_index,&mTilemapInfo.videoram[0x3000]); }
58		static TILE_GET_INFO( get_tile_info4 ) { get_tile_info(machine,tileinfo,tile_index,&mTilemapInfo.videoram[0x4008]); }
59		static TILE_GET_INFO( get_tile_info5 ) { get_tile_info(machine,tileinfo,tile_index,&mTilemapInfo.videoram[0x4408]); }
	54	TILE_GET_INFO_MEMBER( namcos2_shared_state::get_tile_info0 ) { get_tile_info(machine(),tileinfo,tile_index,&mTilemapInfo.videoram[0x0000]); }
	55	TILE_GET_INFO_MEMBER( namcos2_shared_state::get_tile_info1 ) { get_tile_info(machine(),tileinfo,tile_index,&mTilemapInfo.videoram[0x1000]); }
	56	TILE_GET_INFO_MEMBER( namcos2_shared_state::get_tile_info2 ) { get_tile_info(machine(),tileinfo,tile_index,&mTilemapInfo.videoram[0x2000]); }
	57	TILE_GET_INFO_MEMBER( namcos2_shared_state::get_tile_info3 ) { get_tile_info(machine(),tileinfo,tile_index,&mTilemapInfo.videoram[0x3000]); }
	58	TILE_GET_INFO_MEMBER( namcos2_shared_state::get_tile_info4 ) { get_tile_info(machine(),tileinfo,tile_index,&mTilemapInfo.videoram[0x4008]); }
	59	TILE_GET_INFO_MEMBER( namcos2_shared_state::get_tile_info5 ) { get_tile_info(machine(),tileinfo,tile_index,&mTilemapInfo.videoram[0x4408]); }
60	60
61		void
62		namco_tilemap_init( running_machine &machine, int gfxbank, void *maskBaseAddr,
	61	void namcos2_shared_state::namco_tilemap_init( int gfxbank, void *maskBaseAddr,
63	62	void (*cb)( running_machine &machine, UINT16 code, int *gfx, int *mask) )
64	63	{
65	64	int i;
66	65	mTilemapInfo.gfxbank = gfxbank;
67	66	mTilemapInfo.maskBaseAddr = (UINT8 *)maskBaseAddr;
68	67	mTilemapInfo.cb = cb;
69		mTilemapInfo.videoram = auto_alloc_array(machine, UINT16,  0x10000 );
	68	mTilemapInfo.videoram = auto_alloc_array(machine(), UINT16,  0x10000 );
70	69
71	70	/* four scrolling tilemaps */
72		mTilemapInfo.tmap[0] = tilemap_create(machine, get_tile_info0,TILEMAP_SCAN_ROWS,8,8,64,64);
73		mTilemapInfo.tmap[1] = tilemap_create(machine, get_tile_info1,TILEMAP_SCAN_ROWS,8,8,64,64);
74		mTilemapInfo.tmap[2] = tilemap_create(machine, get_tile_info2,TILEMAP_SCAN_ROWS,8,8,64,64);
75		mTilemapInfo.tmap[3] = tilemap_create(machine, get_tile_info3,TILEMAP_SCAN_ROWS,8,8,64,64);
	71	mTilemapInfo.tmap[0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_shared_state::get_tile_info0),this),TILEMAP_SCAN_ROWS,8,8,64,64);
	72	mTilemapInfo.tmap[1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_shared_state::get_tile_info1),this),TILEMAP_SCAN_ROWS,8,8,64,64);
	73	mTilemapInfo.tmap[2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_shared_state::get_tile_info2),this),TILEMAP_SCAN_ROWS,8,8,64,64);
	74	mTilemapInfo.tmap[3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_shared_state::get_tile_info3),this),TILEMAP_SCAN_ROWS,8,8,64,64);
76	75
77	76	/* two non-scrolling tilemaps */
78		mTilemapInfo.tmap[4] = tilemap_create(machine, get_tile_info4,TILEMAP_SCAN_ROWS,8,8,36,28);
79		mTilemapInfo.tmap[5] = tilemap_create(machine, get_tile_info5,TILEMAP_SCAN_ROWS,8,8,36,28);
	77	mTilemapInfo.tmap[4] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_shared_state::get_tile_info4),this),TILEMAP_SCAN_ROWS,8,8,36,28);
	78	mTilemapInfo.tmap[5] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_shared_state::get_tile_info5),this),TILEMAP_SCAN_ROWS,8,8,36,28);
80	79
81	80	/* define offsets for scrolling */
82	81	for( i=0; i<4; i++ )

trunk/src/mame/drivers/powerbal.c

r17674	r17675
376	376	PORT_DIPSETTING(    0xe0, "Easy 9" )
377	377	INPUT_PORTS_END
378	378
379		static TILE_GET_INFO( powerbal_get_bg_tile_info )
	379	TILE_GET_INFO_MEMBER(playmark_state::powerbal_get_bg_tile_info)
380	380	{
381		playmark_state *state = machine.driver_data<playmark_state>();
382		int code = (state->m_videoram1[tile_index] & 0x07ff) + state->m_tilebank * 0x800;
383		int colr = state->m_videoram1[tile_index] & 0xf000;
	381	int code = (m_videoram1[tile_index] & 0x07ff) + m_tilebank * 0x800;
	382	int colr = m_videoram1[tile_index] & 0xf000;
384	383
385		if (state->m_videoram1[tile_index] & 0x800)
	384	if (m_videoram1[tile_index] & 0x800)
386	385	code |= 0x8000;
387	386
388		SET_TILE_INFO(1, code, colr >> 12, 0);
	387	SET_TILE_INFO_MEMBER(1, code, colr >> 12, 0);
389	388	}
390	389
391	390	static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
r17674	r17675
421	420	{
422	421	playmark_state *state = machine.driver_data<playmark_state>();
423	422
424		state->m_bg_tilemap = tilemap_create(machine, powerbal_get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	423	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(playmark_state::powerbal_get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
425	424
426	425	state->m_xoffset = -20;
427	426

trunk/src/mess/includes/aquarius.h

r17674	r17675
33	33	DECLARE_READ8_MEMBER(floppy_r);
34	34	DECLARE_WRITE8_MEMBER(floppy_w);
35	35	DECLARE_DRIVER_INIT(aquarius);
	36	TILE_GET_INFO_MEMBER(aquarius_gettileinfo);
36	37	};
37	38
38	39

trunk/src/mess/includes/x68k.h

r17674	r17675
257	257	DECLARE_DRIVER_INIT(x68kxvi);
258	258	DECLARE_DRIVER_INIT(x68030);
259	259	DECLARE_DRIVER_INIT(x68000);
	260	TILE_GET_INFO_MEMBER(x68k_get_bg0_tile);
	261	TILE_GET_INFO_MEMBER(x68k_get_bg1_tile);
	262	TILE_GET_INFO_MEMBER(x68k_get_bg0_tile_16);
	263	TILE_GET_INFO_MEMBER(x68k_get_bg1_tile_16);
260	264	};
261	265
262	266

trunk/src/mess/includes/apple1.h

r17674	r17675
44	44	DECLARE_READ8_MEMBER(apple1_cassette_r);
45	45	DECLARE_WRITE8_MEMBER(apple1_cassette_w);
46	46	DECLARE_DRIVER_INIT(apple1);
	47	TILE_GET_INFO_MEMBER(terminal_gettileinfo);
47	48	};
48	49
49	50

trunk/src/mess/includes/microtan.h

r17674	r17675
48	48	DECLARE_WRITE8_MEMBER(microtan_bffx_w);
49	49	DECLARE_WRITE8_MEMBER(microtan_videoram_w);
50	50	DECLARE_DRIVER_INIT(microtan);
	51	TILE_GET_INFO_MEMBER(get_bg_tile_info);
51	52	};
52	53
53	54

trunk/src/mess/video/aquarius.c

r17674	r17675
77	77	m_tilemap->mark_tile_dirty(offset);
78	78	}
79	79
80		static TILE_GET_INFO(aquarius_gettileinfo)
	80	TILE_GET_INFO_MEMBER(aquarius_state::aquarius_gettileinfo)
81	81	{
82		aquarius_state *state = machine.driver_data<aquarius_state>();
83		UINT8 *videoram = state->m_videoram;
	82	UINT8 *videoram = m_videoram;
84	83	int bank = 0;
85	84	int code = videoram[tile_index];
86		int color = state->m_colorram[tile_index];
	85	int color = m_colorram[tile_index];
87	86	int flags = 0;
88	87
89		SET_TILE_INFO(bank, code, color, flags);
	88	SET_TILE_INFO_MEMBER(bank, code, color, flags);
90	89	}
91	90
92	91	VIDEO_START( aquarius )
93	92	{
94	93	aquarius_state *state = machine.driver_data<aquarius_state>();
95		state->m_tilemap = tilemap_create(machine, aquarius_gettileinfo, TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
	94	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(aquarius_state::aquarius_gettileinfo),state), TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
96	95	}
97	96
98	97	SCREEN_UPDATE_IND16( aquarius )

trunk/src/mess/video/x68k.c

r17674	r17675
1098	1098	GFXDECODEINFO_END
1099	1099	#endif
1100	1100
1101		static TILE_GET_INFO(x68k_get_bg0_tile)
	1101	TILE_GET_INFO_MEMBER(x68k_state::x68k_get_bg0_tile)
1102	1102	{
1103		x68k_state *state = machine.driver_data<x68k_state>();
1104		int code = state->m_spriteram[0x3000+tile_index] & 0x00ff;
1105		int colour = (state->m_spriteram[0x3000+tile_index] & 0x0f00) >> 8;
1106		int flags = (state->m_spriteram[0x3000+tile_index] & 0xc000) >> 14;
1107		SET_TILE_INFO(0,code,colour+16,flags);
	1103	int code = m_spriteram[0x3000+tile_index] & 0x00ff;
	1104	int colour = (m_spriteram[0x3000+tile_index] & 0x0f00) >> 8;
	1105	int flags = (m_spriteram[0x3000+tile_index] & 0xc000) >> 14;
	1106	SET_TILE_INFO_MEMBER(0,code,colour+16,flags);
1108	1107	}
1109	1108
1110		static TILE_GET_INFO(x68k_get_bg1_tile)
	1109	TILE_GET_INFO_MEMBER(x68k_state::x68k_get_bg1_tile)
1111	1110	{
1112		x68k_state *state = machine.driver_data<x68k_state>();
1113		int code = state->m_spriteram[0x2000+tile_index] & 0x00ff;
1114		int colour = (state->m_spriteram[0x2000+tile_index] & 0x0f00) >> 8;
1115		int flags = (state->m_spriteram[0x2000+tile_index] & 0xc000) >> 14;
1116		SET_TILE_INFO(0,code,colour+16,flags);
	1111	int code = m_spriteram[0x2000+tile_index] & 0x00ff;
	1112	int colour = (m_spriteram[0x2000+tile_index] & 0x0f00) >> 8;
	1113	int flags = (m_spriteram[0x2000+tile_index] & 0xc000) >> 14;
	1114	SET_TILE_INFO_MEMBER(0,code,colour+16,flags);
1117	1115	}
1118	1116
1119		static TILE_GET_INFO(x68k_get_bg0_tile_16)
	1117	TILE_GET_INFO_MEMBER(x68k_state::x68k_get_bg0_tile_16)
1120	1118	{
1121		x68k_state *state = machine.driver_data<x68k_state>();
1122		int code = state->m_spriteram[0x3000+tile_index] & 0x00ff;
1123		int colour = (state->m_spriteram[0x3000+tile_index] & 0x0f00) >> 8;
1124		int flags = (state->m_spriteram[0x3000+tile_index] & 0xc000) >> 14;
1125		SET_TILE_INFO(1,code,colour+16,flags);
	1119	int code = m_spriteram[0x3000+tile_index] & 0x00ff;
	1120	int colour = (m_spriteram[0x3000+tile_index] & 0x0f00) >> 8;
	1121	int flags = (m_spriteram[0x3000+tile_index] & 0xc000) >> 14;
	1122	SET_TILE_INFO_MEMBER(1,code,colour+16,flags);
1126	1123	}
1127	1124
1128		static TILE_GET_INFO(x68k_get_bg1_tile_16)
	1125	TILE_GET_INFO_MEMBER(x68k_state::x68k_get_bg1_tile_16)
1129	1126	{
1130		x68k_state *state = machine.driver_data<x68k_state>();
1131		int code = state->m_spriteram[0x2000+tile_index] & 0x00ff;
1132		int colour = (state->m_spriteram[0x2000+tile_index] & 0x0f00) >> 8;
1133		int flags = (state->m_spriteram[0x2000+tile_index] & 0xc000) >> 14;
1134		SET_TILE_INFO(1,code,colour+16,flags);
	1127	int code = m_spriteram[0x2000+tile_index] & 0x00ff;
	1128	int colour = (m_spriteram[0x2000+tile_index] & 0x0f00) >> 8;
	1129	int flags = (m_spriteram[0x2000+tile_index] & 0xc000) >> 14;
	1130	SET_TILE_INFO_MEMBER(1,code,colour+16,flags);
1135	1131	}
1136	1132
1137	1133	VIDEO_START( x68000 )
r17674	r17675
1152	1148	machine.gfx[gfx_index]->set_colors(32);
1153	1149
1154	1150	/* Tilemaps */
1155		state->m_bg0_8 = tilemap_create(machine, x68k_get_bg0_tile,TILEMAP_SCAN_ROWS,8,8,64,64);
1156		state->m_bg1_8 = tilemap_create(machine, x68k_get_bg1_tile,TILEMAP_SCAN_ROWS,8,8,64,64);
1157		state->m_bg0_16 = tilemap_create(machine, x68k_get_bg0_tile_16,TILEMAP_SCAN_ROWS,16,16,64,64);
1158		state->m_bg1_16 = tilemap_create(machine, x68k_get_bg1_tile_16,TILEMAP_SCAN_ROWS,16,16,64,64);
	1151	state->m_bg0_8 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(x68k_state::x68k_get_bg0_tile),state),TILEMAP_SCAN_ROWS,8,8,64,64);
	1152	state->m_bg1_8 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(x68k_state::x68k_get_bg1_tile),state),TILEMAP_SCAN_ROWS,8,8,64,64);
	1153	state->m_bg0_16 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(x68k_state::x68k_get_bg0_tile_16),state),TILEMAP_SCAN_ROWS,16,16,64,64);
	1154	state->m_bg1_16 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(x68k_state::x68k_get_bg1_tile_16),state),TILEMAP_SCAN_ROWS,16,16,64,64);
1159	1155
1160	1156	state->m_bg0_8->set_transparent_pen(0);
1161	1157	state->m_bg1_8->set_transparent_pen(0);

trunk/src/mess/video/apple1.c

r17674	r17675
70	70
71	71	***************************************************************************/
72	72
73		static TILE_GET_INFO(terminal_gettileinfo)
	73	TILE_GET_INFO_MEMBER(apple1_state::terminal_gettileinfo)
74	74	{
75		apple1_state *state = machine.driver_data<apple1_state>();
76	75	int ch, gfxfont, code, color;
77	76
78		ch = state->m_current_terminal->mem[tile_index];
79		code = ch & ((1 << state->m_current_terminal->char_bits) - 1);
80		color = ch >> state->m_current_terminal->char_bits;
81		gfxfont = state->m_current_terminal->gfx;
	77	ch = m_current_terminal->mem[tile_index];
	78	code = ch & ((1 << m_current_terminal->char_bits) - 1);
	79	color = ch >> m_current_terminal->char_bits;
	80	gfxfont = m_current_terminal->gfx;
82	81
83		if ((tile_index == state->m_current_terminal->cur_offset) && !state->m_current_terminal->cur_hidden && state->m_current_terminal->getcursorcode)
84		code = state->m_current_terminal->getcursorcode(code);
	82	if ((tile_index == m_current_terminal->cur_offset) && !m_current_terminal->cur_hidden && m_current_terminal->getcursorcode)
	83	code = m_current_terminal->getcursorcode(code);
85	84
86		SET_TILE_INFO(
	85	SET_TILE_INFO_MEMBER(
87	86	gfxfont,   /* gfx */
88	87	code,      /* character */
89	88	color,      /* color */
r17674	r17675
186	185	{
187	186	terminal_t *term;
188	187	int char_width, char_height;
189
	188	apple1_state *state = machine.driver_data<apple1_state>();
	189
190	190	char_width = machine.gfx[gfx]->width();
191	191	char_height = machine.gfx[gfx]->height();
192	192
193	193	term = (terminal_t *) auto_alloc_array(machine, char, sizeof(terminal_t) - sizeof(term->mem)
194	194	+ (num_cols * num_rows * sizeof(termchar_t)));
195	195
196		term->tm = tilemap_create(machine, terminal_gettileinfo, TILEMAP_SCAN_ROWS,
	196	term->tm = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(apple1_state::terminal_gettileinfo),state), TILEMAP_SCAN_ROWS,
197	197	char_width, char_height, num_cols, num_rows);
198	198
199	199	term->gfx = gfx;

trunk/src/mess/video/microtan.c

r17674	r17675
29	29	}
30	30	}
31	31
32		static TILE_GET_INFO(get_bg_tile_info)
	32	TILE_GET_INFO_MEMBER(microtan_state::get_bg_tile_info)
33	33	{
34		microtan_state *state = machine.driver_data<microtan_state>();
35		UINT8 *videoram = state->m_videoram;
36		int gfxn = state->m_chunky_buffer[tile_index];
	34	UINT8 *videoram = m_videoram;
	35	int gfxn = m_chunky_buffer[tile_index];
37	36	int code = videoram[tile_index];
38	37
39		SET_TILE_INFO(gfxn, code, 0, 0);
	38	SET_TILE_INFO_MEMBER(gfxn, code, 0, 0);
40	39	}
41	40
42	41	VIDEO_START( microtan )
43	42	{
44	43	microtan_state *state = machine.driver_data<microtan_state>();
45		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,
	44	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(microtan_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,
46	45	8, 16, 32, 16);
47	46
48	47	state->m_chunky_buffer = auto_alloc_array(machine, UINT8, 0x200);

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team