Previous

199869 Revisions

Next

r17673 Thursday 6th September, 2012 at 10:15:51 UTC by Miodrag Milanović
TILE/TILEMAP modernization part 1 (no whatsnew)

[src/mame/drivers]

1945kiii.c 5clown.c acommand.c albazg.c avt.c bestleag.c blackt96.c blitz.c bnstars.c cabaret.c calorie.c caswin.c cb2001.c cball.c chanbara.c chance32.c cntsteer.c coinmstr.c cshooter.c cultures.c cybertnk.c d9final.c dacholer.c ddayjlc.c ddealer.c dmndrby.c dreamwld.c drtomy.c drw80pkr.c dunhuang.c dynadice.c egghunt.c ettrivia.c firefox.c flyball.c galaxi.c goldnpkr.c good.c gstream.c hvyunit.c igs009.c igs017.c igs_m027.c igspoker.c jackie.c jalmah.c jclub2.c jokrwild.c jollyjgr.c jubilee.c kingdrby.c koftball.c koikoi.c limenko.c looping.c ltcasino.c luckgrln.c m14.c m63.c magic10.c magicfly.c majorpkr.c marinedt.c mayumi.c mgolf.c midas.c mil4000.c miniboy7.c mogura.c mole.c multfish.c mwarr.c namcos23.c nmg5.c nsmpoker.c olibochu.c onetwo.c panicr.c peplus.c pipeline.c pkscram.c ppmast93.c pturn.c pzletime.c quizpun2.c quizshow.c r2dx_v33.c rabbit.c rmhaihai.c safarir.c sbowling.c sbrkout.c sfbonus.c silvmil.c skyarmy.c skylncr.c spoker.c spool99.c sshot.c statriv2.c subsino.c subsino2.c superdq.c superwng.c suprgolf.c tattack.c tmspoker.c trvmadns.c umipoker.c videopkr.c vmetal.c vroulet.c wallc.c warpsped.c wink.c witch.c

[src/mess/drivers]

clcd.c supracan.c

trunk/src/mame/drivers/mgolf.c

r17672	r17673
33	33	DECLARE_READ8_MEMBER(mgolf_dial_r);
34	34	DECLARE_READ8_MEMBER(mgolf_misc_r);
35	35	DECLARE_WRITE8_MEMBER(mgolf_wram_w);
	36	TILE_GET_INFO_MEMBER(get_tile_info);
36	37	};
37	38
38	39
39		static TILE_GET_INFO( get_tile_info )
	40	TILE_GET_INFO_MEMBER(mgolf_state::get_tile_info)
40	41	{
41		mgolf_state *state = machine.driver_data<mgolf_state>();
42		UINT8 code = state->m_video_ram[tile_index];
	42	UINT8 code = m_video_ram[tile_index];
43	43
44		SET_TILE_INFO(0, code, code >> 7, 0);
	44	SET_TILE_INFO_MEMBER(0, code, code >> 7, 0);
45	45	}
46	46
47	47
r17672	r17673
55	55	static VIDEO_START( mgolf )
56	56	{
57	57	mgolf_state *state = machine.driver_data<mgolf_state>();
58		state->m_bg_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	58	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mgolf_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
59	59	}
60	60
61	61

trunk/src/mame/drivers/coinmstr.c

r17672	r17673
53	53	DECLARE_WRITE8_MEMBER(question_w);
54	54	DECLARE_READ8_MEMBER(ff_r);
55	55	DECLARE_DRIVER_INIT(coinmstr);
	56	TILE_GET_INFO_MEMBER(get_bg_tile_info);
56	57	};
57	58
58	59
r17672	r17673
899	900	GFXDECODE_END
900	901
901	902
902		static TILE_GET_INFO( get_bg_tile_info )
	903	TILE_GET_INFO_MEMBER(coinmstr_state::get_bg_tile_info)
903	904	{
904		coinmstr_state *state = machine.driver_data<coinmstr_state>();
905		UINT8 *videoram = state->m_videoram;
	905	UINT8 *videoram = m_videoram;
906	906	int tile = videoram[tile_index + 0x0240];
907	907	int color = tile_index;
908	908
909		tile |= (state->m_attr_ram1[tile_index + 0x0240] & 0x80) << 1;
910		tile |= (state->m_attr_ram2[tile_index + 0x0240] & 0x80) << 2;
	909	tile |= (m_attr_ram1[tile_index + 0x0240] & 0x80) << 1;
	910	tile |= (m_attr_ram2[tile_index + 0x0240] & 0x80) << 2;
911	911
912		tile |= (state->m_attr_ram3[tile_index + 0x0240] & 0x03) << (6+4);
	912	tile |= (m_attr_ram3[tile_index + 0x0240] & 0x03) << (6+4);
913	913
914		SET_TILE_INFO(0, tile, color, 0);
	914	SET_TILE_INFO_MEMBER(0, tile, color, 0);
915	915	}
916	916
917	917	static VIDEO_START( coinmstr )
918	918	{
919	919	coinmstr_state *state = machine.driver_data<coinmstr_state>();
920		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 46, 32);
	920	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(coinmstr_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 46, 32);
921	921	}
922	922
923	923	static SCREEN_UPDATE_IND16( coinmstr )

trunk/src/mame/drivers/cntsteer.c

r17672	r17673
81	81	DECLARE_WRITE8_MEMBER(nmimask_w);
82	82	DECLARE_INPUT_CHANGED_MEMBER(coin_inserted);
83	83	DECLARE_DRIVER_INIT(zerotrgt);
	84	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	85	TILE_GET_INFO_MEMBER(get_fg_tile_info);
84	86	};
85	87
86	88
r17672	r17673
112	114	}
113	115	}
114	116
115		static TILE_GET_INFO( get_bg_tile_info )
	117	TILE_GET_INFO_MEMBER(cntsteer_state::get_bg_tile_info)
116	118	{
117		cntsteer_state *state = machine.driver_data<cntsteer_state>();
118		int code = state->m_videoram2[tile_index];
	119	int code = m_videoram2[tile_index];
119	120
120		SET_TILE_INFO(2, code + state->m_bg_bank, state->m_bg_color_bank, 0);
	121	SET_TILE_INFO_MEMBER(2, code + m_bg_bank, m_bg_color_bank, 0);
121	122	}
122	123
123		static TILE_GET_INFO( get_fg_tile_info )
	124	TILE_GET_INFO_MEMBER(cntsteer_state::get_fg_tile_info)
124	125	{
125		cntsteer_state *state = machine.driver_data<cntsteer_state>();
126		int code = state->m_videoram[tile_index];
127		int attr = state->m_colorram[tile_index];
	126	int code = m_videoram[tile_index];
	127	int attr = m_colorram[tile_index];
128	128
129	129	code |= (attr & 0x01) << 8;
130	130
131		SET_TILE_INFO(0, code, 0x30 + ((attr & 0x78) >> 3), 0);
	131	SET_TILE_INFO_MEMBER(0, code, 0x30 + ((attr & 0x78) >> 3), 0);
132	132	}
133	133
134	134	static VIDEO_START( cntsteer )
135	135	{
136	136	cntsteer_state *state = machine.driver_data<cntsteer_state>();
137		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_COLS, 16, 16, 64, 64);
138		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS_FLIP_X, 8, 8, 32, 32);
	137	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cntsteer_state::get_bg_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 64, 64);
	138	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cntsteer_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS_FLIP_X, 8, 8, 32, 32);
139	139
140	140	state->m_fg_tilemap->set_transparent_pen(0);
141	141
r17672	r17673
145	145	static VIDEO_START( zerotrgt )
146	146	{
147	147	cntsteer_state *state = machine.driver_data<cntsteer_state>();
148		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 64, 64);
149		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS_FLIP_X, 8, 8, 32, 32);
	148	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cntsteer_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 64, 64);
	149	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cntsteer_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS_FLIP_X, 8, 8, 32, 32);
150	150
151	151	state->m_fg_tilemap->set_transparent_pen(0);
152	152

trunk/src/mame/drivers/mwarr.c

r17672	r17673
92	92	DECLARE_WRITE16_MEMBER(sprites_commands_w);
93	93	DECLARE_WRITE16_MEMBER(mwarr_brightness_w);
94	94	DECLARE_WRITE16_MEMBER(oki1_bank_w);
	95	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	96	TILE_GET_INFO_MEMBER(get_mlow_tile_info);
	97	TILE_GET_INFO_MEMBER(get_mhigh_tile_info);
	98	TILE_GET_INFO_MEMBER(get_tx_tile_info);
95	99	};
96	100
97	101
r17672	r17673
351	355	*
352	356	*************************************/
353	357
354		static TILE_GET_INFO( get_bg_tile_info )
	358	TILE_GET_INFO_MEMBER(mwarr_state::get_bg_tile_info)
355	359	{
356		mwarr_state *state = machine.driver_data<mwarr_state>();
357		int tileno = state->m_bg_videoram[tile_index] & 0x1fff;
358		int colour = (state->m_bg_videoram[tile_index] & 0xe000) >> 13;
	360	int tileno = m_bg_videoram[tile_index] & 0x1fff;
	361	int colour = (m_bg_videoram[tile_index] & 0xe000) >> 13;
359	362
360		SET_TILE_INFO(4, tileno, colour, 0);
	363	SET_TILE_INFO_MEMBER(4, tileno, colour, 0);
361	364	}
362	365
363		static TILE_GET_INFO( get_mlow_tile_info )
	366	TILE_GET_INFO_MEMBER(mwarr_state::get_mlow_tile_info)
364	367	{
365		mwarr_state *state = machine.driver_data<mwarr_state>();
366		int tileno = state->m_mlow_videoram[tile_index] & 0x1fff;
367		int colour = (state->m_mlow_videoram[tile_index] & 0xe000) >> 13;
	368	int tileno = m_mlow_videoram[tile_index] & 0x1fff;
	369	int colour = (m_mlow_videoram[tile_index] & 0xe000) >> 13;
368	370
369		SET_TILE_INFO(3, tileno, colour, 0);
	371	SET_TILE_INFO_MEMBER(3, tileno, colour, 0);
370	372	}
371	373
372		static TILE_GET_INFO( get_mhigh_tile_info )
	374	TILE_GET_INFO_MEMBER(mwarr_state::get_mhigh_tile_info)
373	375	{
374		mwarr_state *state = machine.driver_data<mwarr_state>();
375		int tileno = state->m_mhigh_videoram[tile_index] & 0x1fff;
376		int colour = (state->m_mhigh_videoram[tile_index] & 0xe000) >> 13;
	376	int tileno = m_mhigh_videoram[tile_index] & 0x1fff;
	377	int colour = (m_mhigh_videoram[tile_index] & 0xe000) >> 13;
377	378
378		SET_TILE_INFO(2, tileno, colour, 0);
	379	SET_TILE_INFO_MEMBER(2, tileno, colour, 0);
379	380	}
380	381
381		static TILE_GET_INFO( get_tx_tile_info )
	382	TILE_GET_INFO_MEMBER(mwarr_state::get_tx_tile_info)
382	383	{
383		mwarr_state *state = machine.driver_data<mwarr_state>();
384		int tileno = state->m_tx_videoram[tile_index] & 0x1fff;
385		int colour = (state->m_tx_videoram[tile_index] & 0xe000) >> 13;
	384	int tileno = m_tx_videoram[tile_index] & 0x1fff;
	385	int colour = (m_tx_videoram[tile_index] & 0xe000) >> 13;
386	386
387		SET_TILE_INFO(1, tileno, colour, 0);
	387	SET_TILE_INFO_MEMBER(1, tileno, colour, 0);
388	388	}
389	389
390	390	static VIDEO_START( mwarr )
391	391	{
392	392	mwarr_state *state = machine.driver_data<mwarr_state>();
393	393
394		state->m_bg_tilemap    = tilemap_create(machine, get_bg_tile_info,    TILEMAP_SCAN_COLS, 16, 16, 64, 16);
395		state->m_mlow_tilemap  = tilemap_create(machine, get_mlow_tile_info,  TILEMAP_SCAN_COLS, 16, 16, 64, 16);
396		state->m_mhigh_tilemap = tilemap_create(machine, get_mhigh_tile_info, TILEMAP_SCAN_COLS, 16, 16, 64, 16);
397		state->m_tx_tilemap    = tilemap_create(machine, get_tx_tile_info,    TILEMAP_SCAN_ROWS,  8,  8, 64, 32);
	394	state->m_bg_tilemap    = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mwarr_state::get_bg_tile_info),state),    TILEMAP_SCAN_COLS, 16, 16, 64, 16);
	395	state->m_mlow_tilemap  = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mwarr_state::get_mlow_tile_info),state),  TILEMAP_SCAN_COLS, 16, 16, 64, 16);
	396	state->m_mhigh_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mwarr_state::get_mhigh_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 64, 16);
	397	state->m_tx_tilemap    = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mwarr_state::get_tx_tile_info),state),    TILEMAP_SCAN_ROWS,  8,  8, 64, 32);
398	398
399	399	state->m_mlow_tilemap->set_transparent_pen(0);
400	400	state->m_mhigh_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/vroulet.c

r17672	r17673
60	60	DECLARE_WRITE8_MEMBER(ppi8255_a_w);
61	61	DECLARE_WRITE8_MEMBER(ppi8255_b_w);
62	62	DECLARE_WRITE8_MEMBER(ppi8255_c_w);
	63	TILE_GET_INFO_MEMBER(get_bg_tile_info);
63	64	};
64	65
65	66
r17672	r17673
98	99	m_bg_tilemap->mark_tile_dirty(offset);
99	100	}
100	101
101		static TILE_GET_INFO( get_bg_tile_info )
	102	TILE_GET_INFO_MEMBER(vroulet_state::get_bg_tile_info)
102	103	{
103		vroulet_state *state = machine.driver_data<vroulet_state>();
104		int attr = state->m_colorram[tile_index];
105		int code = state->m_videoram[tile_index] + ((attr & 0xc0) << 2);
	104	int attr = m_colorram[tile_index];
	105	int code = m_videoram[tile_index] + ((attr & 0xc0) << 2);
106	106	int color = attr & 0x1f;
107	107
108		SET_TILE_INFO(0, code, color, 0);
	108	SET_TILE_INFO_MEMBER(0, code, color, 0);
109	109	}
110	110
111	111	static VIDEO_START(vroulet)
112	112	{
113	113	vroulet_state *state = machine.driver_data<vroulet_state>();
114		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,
	114	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(vroulet_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,
115	115	8, 8, 32, 32);
116	116	}
117	117

trunk/src/mame/drivers/cultures.c

r17672	r17673
50	50	DECLARE_WRITE8_MEMBER(bg0_videoram_w);
51	51	DECLARE_WRITE8_MEMBER(misc_w);
52	52	DECLARE_WRITE8_MEMBER(bg_bank_w);
	53	TILE_GET_INFO_MEMBER(get_bg1_tile_info);
	54	TILE_GET_INFO_MEMBER(get_bg2_tile_info);
	55	TILE_GET_INFO_MEMBER(get_bg0_tile_info);
53	56	};
54	57
55	58
56	59
57		static TILE_GET_INFO( get_bg1_tile_info )
	60	TILE_GET_INFO_MEMBER(cultures_state::get_bg1_tile_info)
58	61	{
59		cultures_state *state = machine.driver_data<cultures_state>();
60		UINT8 *region = state->memregion("gfx3")->base() + 0x200000 + 0x80000 * state->m_bg1_bank;
	62	UINT8 *region = memregion("gfx3")->base() + 0x200000 + 0x80000 * m_bg1_bank;
61	63	int code = region[tile_index * 2] + (region[tile_index * 2 + 1] << 8);
62		SET_TILE_INFO(2, code, code >> 12, 0);
	64	SET_TILE_INFO_MEMBER(2, code, code >> 12, 0);
63	65	}
64	66
65		static TILE_GET_INFO( get_bg2_tile_info )
	67	TILE_GET_INFO_MEMBER(cultures_state::get_bg2_tile_info)
66	68	{
67		cultures_state *state = machine.driver_data<cultures_state>();
68		UINT8 *region = state->memregion("gfx2")->base() + 0x200000 + 0x80000 * state->m_bg2_bank;
	69	UINT8 *region = memregion("gfx2")->base() + 0x200000 + 0x80000 * m_bg2_bank;
69	70	int code = region[tile_index * 2] + (region[tile_index * 2 + 1] << 8);
70		SET_TILE_INFO(1, code, code >> 12, 0);
	71	SET_TILE_INFO_MEMBER(1, code, code >> 12, 0);
71	72	}
72	73
73		static TILE_GET_INFO( get_bg0_tile_info )
	74	TILE_GET_INFO_MEMBER(cultures_state::get_bg0_tile_info)
74	75	{
75		cultures_state *state = machine.driver_data<cultures_state>();
76		int code = state->m_bg0_videoram[tile_index * 2] + (state->m_bg0_videoram[tile_index * 2 + 1] << 8);
77		SET_TILE_INFO(0, code, code >> 12, 0);
	76	int code = m_bg0_videoram[tile_index * 2] + (m_bg0_videoram[tile_index * 2 + 1] << 8);
	77	SET_TILE_INFO_MEMBER(0, code, code >> 12, 0);
78	78	}
79	79
80	80	static VIDEO_START( cultures )
81	81	{
82	82	cultures_state *state = machine.driver_data<cultures_state>();
83		state->m_bg0_tilemap = tilemap_create(machine, get_bg0_tile_info,TILEMAP_SCAN_ROWS, 8, 8, 64, 128);
84		state->m_bg1_tilemap = tilemap_create(machine, get_bg1_tile_info,TILEMAP_SCAN_ROWS, 8, 8, 512, 512);
85		state->m_bg2_tilemap = tilemap_create(machine, get_bg2_tile_info,TILEMAP_SCAN_ROWS, 8, 8, 512, 512);
	83	state->m_bg0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cultures_state::get_bg0_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8, 64, 128);
	84	state->m_bg1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cultures_state::get_bg1_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8, 512, 512);
	85	state->m_bg2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cultures_state::get_bg2_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8, 512, 512);
86	86
87	87	state->m_bg1_tilemap->set_transparent_pen(0);
88	88	state->m_bg0_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/5clown.c

r17672	r17673
483	483	DECLARE_READ8_MEMBER(pia1_b_r);
484	484	DECLARE_WRITE8_MEMBER(fclown_ay8910_w);
485	485	DECLARE_DRIVER_INIT(fclown);
	486	TILE_GET_INFO_MEMBER(get_fclown_tile_info);
486	487	};
487	488
488	489
r17672	r17673
507	508	}
508	509
509	510
510		static TILE_GET_INFO( get_fclown_tile_info )
	511	TILE_GET_INFO_MEMBER(_5clown_state::get_fclown_tile_info)
511	512	{
512		_5clown_state *state = machine.driver_data<_5clown_state>();
513	513
514	514	/*  - bits -
515	515	7654 3210
r17672	r17673
520	520	x--- ----   Extra color for 7's.
521	521	*/
522	522
523		int attr = state->m_colorram[tile_index];
524		int code = ((attr & 0x01) << 8) | ((attr & 0x40) << 2) | state->m_videoram[tile_index];   /* bit 8 for extended char set */
	523	int attr = m_colorram[tile_index];
	524	int code = ((attr & 0x01) << 8) | ((attr & 0x40) << 2) | m_videoram[tile_index];   /* bit 8 for extended char set */
525	525	int bank = (attr & 0x02) >> 1;                                       /* bit 1 switch the gfx banks */
526	526	int color = (attr & 0x3c) >> 2 | ((attr & 0x80) >> 3);                     /* bits 2-3-4-5-7 for color */
527	527
528		SET_TILE_INFO(bank, code, color, 0);
	528	SET_TILE_INFO_MEMBER(bank, code, color, 0);
529	529	}
530	530
531	531
532	532	static VIDEO_START(fclown)
533	533	{
534	534	_5clown_state *state = machine.driver_data<_5clown_state>();
535		state->m_bg_tilemap = tilemap_create(machine, get_fclown_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	535	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(_5clown_state::get_fclown_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
536	536	}
537	537
538	538

trunk/src/mame/drivers/drw80pkr.c

r17672	r17673
66	66	DECLARE_READ8_MEMBER(bus_r);
67	67	DECLARE_READ8_MEMBER(drw80pkr_io_r);
68	68	DECLARE_DRIVER_INIT(drw80pkr);
	69	TILE_GET_INFO_MEMBER(get_bg_tile_info);
69	70	};
70	71
71	72
r17672	r17673
323	324	* Video/Character functions *
324	325	****************************/
325	326
326		static TILE_GET_INFO( get_bg_tile_info )
	327	TILE_GET_INFO_MEMBER(drw80pkr_state::get_bg_tile_info)
327	328	{
328		drw80pkr_state *state = machine.driver_data<drw80pkr_state>();
329		int color = state->m_color_ram[tile_index];
330		int code = state->m_video_ram[tile_index];
	329	int color = m_color_ram[tile_index];
	330	int code = m_video_ram[tile_index];
331	331
332		SET_TILE_INFO(0, code, color, 0);
	332	SET_TILE_INFO_MEMBER(0, code, color, 0);
333	333	}
334	334
335	335	static VIDEO_START( drw80pkr )
336	336	{
337	337	drw80pkr_state *state = machine.driver_data<drw80pkr_state>();
338		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 24, 27);
	338	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(drw80pkr_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 24, 27);
339	339	}
340	340
341	341	static SCREEN_UPDATE_IND16( drw80pkr )

trunk/src/mame/drivers/superdq.c

r17672	r17673
46	46	DECLARE_WRITE8_MEMBER(superdq_io_w);
47	47	DECLARE_READ8_MEMBER(superdq_ld_r);
48	48	DECLARE_WRITE8_MEMBER(superdq_ld_w);
	49	TILE_GET_INFO_MEMBER(get_tile_info);
49	50	};
50	51
51		static TILE_GET_INFO( get_tile_info )
	52	TILE_GET_INFO_MEMBER(superdq_state::get_tile_info)
52	53	{
53		superdq_state *state = machine.driver_data<superdq_state>();
54		int tile = state->m_videoram[tile_index];
	54	int tile = m_videoram[tile_index];
55	55
56		SET_TILE_INFO(0, tile, state->m_color_bank, 0);
	56	SET_TILE_INFO_MEMBER(0, tile, m_color_bank, 0);
57	57	}
58	58
59	59	static VIDEO_START( superdq )
60	60	{
61	61	superdq_state *state = machine.driver_data<superdq_state>();
62	62
63		state->m_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	63	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(superdq_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
64	64	}
65	65
66	66	static SCREEN_UPDATE_RGB32( superdq )

trunk/src/mame/drivers/bestleag.c

r17672	r17673
46	46	DECLARE_WRITE16_MEMBER(bestleag_bgram_w);
47	47	DECLARE_WRITE16_MEMBER(bestleag_fgram_w);
48	48	DECLARE_WRITE16_MEMBER(oki_bank_w);
	49	TILE_GET_INFO_MEMBER(get_tx_tile_info);
	50	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	51	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	52	TILEMAP_MAPPER_MEMBER(bsb_bg_scan);
49	53	};
50	54
51	55
52	56	/* Video Handling */
53	57
54	58
55		static TILE_GET_INFO( get_tx_tile_info )
	59	TILE_GET_INFO_MEMBER(bestleag_state::get_tx_tile_info)
56	60	{
57		bestleag_state *state = machine.driver_data<bestleag_state>();
58		int code = state->m_txram[tile_index];
	61	int code = m_txram[tile_index];
59	62
60		SET_TILE_INFO(
	63	SET_TILE_INFO_MEMBER(
61	64	0,
62	65	(code & 0x0fff)|0x8000,
63	66	(code & 0xf000) >> 12,
64	67	0);
65	68	}
66	69
67		static TILE_GET_INFO( get_bg_tile_info )
	70	TILE_GET_INFO_MEMBER(bestleag_state::get_bg_tile_info)
68	71	{
69		bestleag_state *state = machine.driver_data<bestleag_state>();
70		int code = state->m_bgram[tile_index];
	72	int code = m_bgram[tile_index];
71	73
72		SET_TILE_INFO(
	74	SET_TILE_INFO_MEMBER(
73	75	1,
74	76	(code & 0x0fff),
75	77	(code & 0xf000) >> 12,
76	78	0);
77	79	}
78	80
79		static TILE_GET_INFO( get_fg_tile_info )
	81	TILE_GET_INFO_MEMBER(bestleag_state::get_fg_tile_info)
80	82	{
81		bestleag_state *state = machine.driver_data<bestleag_state>();
82		int code = state->m_fgram[tile_index];
	83	int code = m_fgram[tile_index];
83	84
84		SET_TILE_INFO(
	85	SET_TILE_INFO_MEMBER(
85	86	1,
86	87	(code & 0x0fff)|0x1000,
87	88	((code & 0xf000) >> 12)|0x10,
88	89	0);
89	90	}
90	91
91		static TILEMAP_MAPPER( bsb_bg_scan )
	92	TILEMAP_MAPPER_MEMBER(bestleag_state::bsb_bg_scan)
92	93	{
93	94	int offset;
94	95
r17672	r17673
102	103	static VIDEO_START(bestleag)
103	104	{
104	105	bestleag_state *state = machine.driver_data<bestleag_state>();
105		state->m_tx_tilemap = tilemap_create(machine, get_tx_tile_info,TILEMAP_SCAN_COLS,8,8,256, 32);
106		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,bsb_bg_scan,16,16,128, 64);
107		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,bsb_bg_scan,16,16,128, 64);
	106	state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bestleag_state::get_tx_tile_info),state),TILEMAP_SCAN_COLS,8,8,256, 32);
	107	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bestleag_state::get_bg_tile_info),state),tilemap_mapper_delegate(FUNC(bestleag_state::bsb_bg_scan),state),16,16,128, 64);
	108	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bestleag_state::get_fg_tile_info),state),tilemap_mapper_delegate(FUNC(bestleag_state::bsb_bg_scan),state),16,16,128, 64);
108	109
109	110	state->m_tx_tilemap->set_transparent_pen(15);
110	111	state->m_fg_tilemap->set_transparent_pen(15);

trunk/src/mame/drivers/cybertnk.c

r17672	r17673
215	215	DECLARE_WRITE8_MEMBER(cybertnk_irq_ack_w);
216	216	DECLARE_WRITE8_MEMBER(cybertnk_cnt_w);
217	217	DECLARE_DRIVER_INIT(cybertnk);
	218	TILE_GET_INFO_MEMBER(get_tilemap0_tile_info);
	219	TILE_GET_INFO_MEMBER(get_tilemap1_tile_info);
	220	TILE_GET_INFO_MEMBER(get_tilemap2_tile_info);
218	221	};
219	222
220	223	/* tile format
r17672	r17673
228	231
229	232	*/
230	233
231		static TILE_GET_INFO( get_tilemap0_tile_info )
	234	TILE_GET_INFO_MEMBER(cybertnk_state::get_tilemap0_tile_info)
232	235	{
233		cybertnk_state *state = machine.driver_data<cybertnk_state>();
234		int code = state->m_tilemap0_vram[tile_index];
	236	int code = m_tilemap0_vram[tile_index];
235	237	int pal = (code & 0xe000) >> 13;
236	238	pal     |=(code & 0x1c00) >> 7;
237	239
238		SET_TILE_INFO(
	240	SET_TILE_INFO_MEMBER(
239	241	0,
240	242	code & 0x1fff,
241	243	pal,
242	244	0);
243	245	}
244	246
245		static TILE_GET_INFO( get_tilemap1_tile_info )
	247	TILE_GET_INFO_MEMBER(cybertnk_state::get_tilemap1_tile_info)
246	248	{
247		cybertnk_state *state = machine.driver_data<cybertnk_state>();
248		int code = state->m_tilemap1_vram[tile_index];
	249	int code = m_tilemap1_vram[tile_index];
249	250	int pal = (code & 0xe000) >> 13;
250	251	pal     |=(code & 0x1c00) >> 7;
251	252
252		SET_TILE_INFO(
	253	SET_TILE_INFO_MEMBER(
253	254	1,
254	255	code & 0x1fff,
255	256	pal,
256	257	0);
257	258	}
258	259
259		static TILE_GET_INFO( get_tilemap2_tile_info )
	260	TILE_GET_INFO_MEMBER(cybertnk_state::get_tilemap2_tile_info)
260	261	{
261		cybertnk_state *state = machine.driver_data<cybertnk_state>();
262		int code = state->m_tilemap2_vram[tile_index];
	262	int code = m_tilemap2_vram[tile_index];
263	263	int pal = (code & 0xe000) >> 13;
264	264	pal     |=(code & 0x1c00) >> 7;
265	265
266		SET_TILE_INFO(
	266	SET_TILE_INFO_MEMBER(
267	267	2,
268	268	code & 0x1fff,
269	269	pal,
r17672	r17673
273	273	static VIDEO_START( cybertnk )
274	274	{
275	275	cybertnk_state *state = machine.driver_data<cybertnk_state>();
276		state->m_tilemap0_tilemap = tilemap_create(machine, get_tilemap0_tile_info,TILEMAP_SCAN_ROWS,8,8,128,32);
	276	state->m_tilemap0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cybertnk_state::get_tilemap0_tile_info),state),TILEMAP_SCAN_ROWS,8,8,128,32);
277	277	state->m_tilemap0_tilemap->set_transparent_pen(0);
278	278
279		state->m_tilemap1_tilemap = tilemap_create(machine, get_tilemap1_tile_info,TILEMAP_SCAN_ROWS,8,8,128,32);
	279	state->m_tilemap1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cybertnk_state::get_tilemap1_tile_info),state),TILEMAP_SCAN_ROWS,8,8,128,32);
280	280	state->m_tilemap1_tilemap->set_transparent_pen(0);
281	281
282		state->m_tilemap2_tilemap = tilemap_create(machine, get_tilemap2_tile_info,TILEMAP_SCAN_ROWS,8,8,128,32);
	282	state->m_tilemap2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cybertnk_state::get_tilemap2_tile_info),state),TILEMAP_SCAN_ROWS,8,8,128,32);
283	283	state->m_tilemap2_tilemap->set_transparent_pen(0);
284	284	}
285	285

trunk/src/mame/drivers/pipeline.c

r17672	r17673
97	97	DECLARE_WRITE8_MEMBER(vidctrl_w);
98	98	DECLARE_READ8_MEMBER(protection_r);
99	99	DECLARE_WRITE8_MEMBER(protection_w);
	100	TILE_GET_INFO_MEMBER(get_tile_info);
	101	TILE_GET_INFO_MEMBER(get_tile_info2);
100	102	};
101	103
102	104
103		static TILE_GET_INFO( get_tile_info )
	105	TILE_GET_INFO_MEMBER(pipeline_state::get_tile_info)
104	106	{
105		pipeline_state *state = machine.driver_data<pipeline_state>();
106		int code = state->m_vram2[tile_index]+state->m_vram2[tile_index+0x800]*256;
107		SET_TILE_INFO(
	107	int code = m_vram2[tile_index]+m_vram2[tile_index+0x800]*256;
	108	SET_TILE_INFO_MEMBER(
108	109	0,
109	110	code,
110	111	0,
111	112	0);
112	113	}
113	114
114		static TILE_GET_INFO( get_tile_info2 )
	115	TILE_GET_INFO_MEMBER(pipeline_state::get_tile_info2)
115	116	{
116		pipeline_state *state = machine.driver_data<pipeline_state>();
117		int code =state->m_vram1[tile_index]+((state->m_vram1[tile_index+0x800]>>4))*256;
118		int color=((state->m_vram1[tile_index+0x800])&0xf);
119		SET_TILE_INFO
	117	int code =m_vram1[tile_index]+((m_vram1[tile_index+0x800]>>4))*256;
	118	int color=((m_vram1[tile_index+0x800])&0xf);
	119	SET_TILE_INFO_MEMBER
120	120	(
121	121	1,
122	122	code,
r17672	r17673
129	129	{
130	130	pipeline_state *state = machine.driver_data<pipeline_state>();
131	131	state->m_palram=auto_alloc_array(machine, UINT8, 0x1000);
132		state->m_tilemap1 = tilemap_create( machine, get_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32 );
133		state->m_tilemap2 = tilemap_create( machine, get_tile_info2,TILEMAP_SCAN_ROWS,8,8,64,32 );
	132	state->m_tilemap1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pipeline_state::get_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32 );
	133	state->m_tilemap2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pipeline_state::get_tile_info2),state),TILEMAP_SCAN_ROWS,8,8,64,32 );
134	134	state->m_tilemap2->set_transparent_pen(0);
135	135	}
136	136

trunk/src/mame/drivers/chanbara.c

r17672	r17673
86	86	DECLARE_WRITE8_MEMBER(chanbara_ay_out_0_w);
87	87	DECLARE_WRITE8_MEMBER(chanbara_ay_out_1_w);
88	88	DECLARE_DRIVER_INIT(chanbara);
	89	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	90	TILE_GET_INFO_MEMBER(get_bg2_tile_info);
89	91	};
90	92
91	93
r17672	r17673
133	135	}
134	136
135	137
136		static TILE_GET_INFO( get_bg_tile_info )
	138	TILE_GET_INFO_MEMBER(chanbara_state::get_bg_tile_info)
137	139	{
138		chanbara_state *state = machine.driver_data<chanbara_state>();
139		int code = state->m_videoram[tile_index] + ((state->m_colorram[tile_index] & 1) << 8);
140		int color = (state->m_colorram[tile_index] >> 1) & 0x1f;
	140	int code = m_videoram[tile_index] + ((m_colorram[tile_index] & 1) << 8);
	141	int color = (m_colorram[tile_index] >> 1) & 0x1f;
141	142
142		SET_TILE_INFO(0, code, color, 0);
	143	SET_TILE_INFO_MEMBER(0, code, color, 0);
143	144	}
144	145
145		static TILE_GET_INFO( get_bg2_tile_info )
	146	TILE_GET_INFO_MEMBER(chanbara_state::get_bg2_tile_info)
146	147	{
147		chanbara_state *state = machine.driver_data<chanbara_state>();
148		int code = state->m_videoram2[tile_index];
149		int color = (state->m_colorram2[tile_index] >> 1) & 0x1f;
	148	int code = m_videoram2[tile_index];
	149	int color = (m_colorram2[tile_index] >> 1) & 0x1f;
150	150
151		SET_TILE_INFO(2, code, color, 0);
	151	SET_TILE_INFO_MEMBER(2, code, color, 0);
152	152	}
153	153
154	154	static VIDEO_START(chanbara )
155	155	{
156	156	chanbara_state *state = machine.driver_data<chanbara_state>();
157		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,8, 8, 32, 32);
158		state->m_bg2_tilemap = tilemap_create(machine, get_bg2_tile_info, TILEMAP_SCAN_ROWS,16, 16, 16, 32);
	157	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(chanbara_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,8, 8, 32, 32);
	158	state->m_bg2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(chanbara_state::get_bg2_tile_info),state), TILEMAP_SCAN_ROWS,16, 16, 16, 32);
159	159	state->m_bg_tilemap->set_transparent_pen(0);
160	160	}
161	161

trunk/src/mame/drivers/m14.c

r17672	r17673
80	80	DECLARE_WRITE8_MEMBER(hopper_w);
81	81	DECLARE_INPUT_CHANGED_MEMBER(left_coin_inserted);
82	82	DECLARE_INPUT_CHANGED_MEMBER(right_coin_inserted);
	83	TILE_GET_INFO_MEMBER(m14_get_tile_info);
83	84	};
84	85
85	86
r17672	r17673
107	108	}
108	109	}
109	110
110		static TILE_GET_INFO( m14_get_tile_info )
	111	TILE_GET_INFO_MEMBER(m14_state::m14_get_tile_info)
111	112	{
112		m14_state *state = machine.driver_data<m14_state>();
113	113
114		int code = state->m_video_ram[tile_index];
115		int color = state->m_color_ram[tile_index] & 0x0f;
	114	int code = m_video_ram[tile_index];
	115	int color = m_color_ram[tile_index] & 0x0f;
116	116
117	117	/* colorram & 0xf0 used but unknown purpose*/
118	118
119		SET_TILE_INFO(
	119	SET_TILE_INFO_MEMBER(
120	120	0,
121	121	code,
122	122	color,
r17672	r17673
127	127	{
128	128	m14_state *state = machine.driver_data<m14_state>();
129	129
130		state->m_m14_tilemap = tilemap_create(machine, m14_get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	130	state->m_m14_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(m14_state::m14_get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
131	131	}
132	132
133	133	static SCREEN_UPDATE_IND16( m14 )

trunk/src/mame/drivers/nsmpoker.c

r17672	r17673
79	79	DECLARE_WRITE8_MEMBER(nsmpoker_colorram_w);
80	80	DECLARE_WRITE8_MEMBER(debug_w);
81	81	DECLARE_READ8_MEMBER(debug_r);
	82	TILE_GET_INFO_MEMBER(get_bg_tile_info);
82	83	};
83	84
84	85
r17672	r17673
101	102	}
102	103
103	104
104		static TILE_GET_INFO( get_bg_tile_info )
	105	TILE_GET_INFO_MEMBER(nsmpoker_state::get_bg_tile_info)
105	106	{
106		nsmpoker_state *state = machine.driver_data<nsmpoker_state>();
107	107	/*  - bits -
108	108	7654 3210
109	109	---- ----   bank select.
110	110	---- ----   color code.
111	111	---- ----   seems unused.
112	112	*/
113		//  int attr = state->m_colorram[tile_index];
114		int code = state->m_videoram[tile_index];
	113	//  int attr = m_colorram[tile_index];
	114	int code = m_videoram[tile_index];
115	115	//  int bank = (attr & 0x08) >> 3;
116	116	//  int color = (attr & 0x03);
117	117
118		SET_TILE_INFO( 0 /* bank */, code, 0 /* color */, 0);
	118	SET_TILE_INFO_MEMBER( 0 /* bank */, code, 0 /* color */, 0);
119	119	}
120	120
121	121
122	122	static VIDEO_START( nsmpoker )
123	123	{
124	124	nsmpoker_state *state = machine.driver_data<nsmpoker_state>();
125		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	125	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(nsmpoker_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
126	126	}
127	127
128	128

trunk/src/mame/drivers/majorpkr.c

r17672	r17673
488	488	DECLARE_WRITE8_MEMBER(lamps_b_w);
489	489	DECLARE_WRITE8_MEMBER(pulses_w);
490	490	DECLARE_DRIVER_INIT(majorpkr);
	491	TILE_GET_INFO_MEMBER(bg_get_tile_info);
	492	TILE_GET_INFO_MEMBER(fg_get_tile_info);
491	493	};
492	494
493	495
r17672	r17673
495	497	*     Video Hardware     *
496	498	*************************/
497	499
498		static TILE_GET_INFO( bg_get_tile_info )
	500	TILE_GET_INFO_MEMBER(majorpkr_state::bg_get_tile_info)
499	501	{
500		majorpkr_state *state = machine.driver_data<majorpkr_state>();
501	502
502		int code = state->m_videoram[0x800 + 2 * tile_index] + (state->m_videoram[0x800 + 2 * tile_index + 1] << 8);
	503	int code = m_videoram[0x800 + 2 * tile_index] + (m_videoram[0x800 + 2 * tile_index + 1] << 8);
503	504
504		SET_TILE_INFO(
	505	SET_TILE_INFO_MEMBER(
505	506	0,
506	507	(code & 0x1fff),
507	508	code >> 13,
508	509	0);
509	510	}
510	511
511		static TILE_GET_INFO( fg_get_tile_info )
	512	TILE_GET_INFO_MEMBER(majorpkr_state::fg_get_tile_info)
512	513	{
513		majorpkr_state *state = machine.driver_data<majorpkr_state>();
514	514
515		int code = state->m_videoram[2 * tile_index] + (state->m_videoram[2 * tile_index + 1] << 8);
	515	int code = m_videoram[2 * tile_index] + (m_videoram[2 * tile_index + 1] << 8);
516	516
517		SET_TILE_INFO(
	517	SET_TILE_INFO_MEMBER(
518	518	1,
519	519	(code & 0x07ff),
520	520	code >> 13,
r17672	r17673
526	526	{
527	527	majorpkr_state *state = machine.driver_data<majorpkr_state>();
528	528
529		state->m_bg_tilemap = tilemap_create(machine, bg_get_tile_info, TILEMAP_SCAN_ROWS, 16, 8, 36, 28);
530		state->m_fg_tilemap = tilemap_create(machine, fg_get_tile_info, TILEMAP_SCAN_ROWS, 16, 8, 36, 28);
	529	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(majorpkr_state::bg_get_tile_info),state), TILEMAP_SCAN_ROWS, 16, 8, 36, 28);
	530	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(majorpkr_state::fg_get_tile_info),state), TILEMAP_SCAN_ROWS, 16, 8, 36, 28);
531	531	state->m_fg_tilemap->set_transparent_pen(0);
532	532
533	533	state->m_generic_paletteram_8.allocate(4 * 0x800);

trunk/src/mame/drivers/sshot.c

r17672	r17673
171	171	DECLARE_WRITE8_MEMBER(supershot_vidram_w);
172	172	DECLARE_WRITE8_MEMBER(supershot_output0_w);
173	173	DECLARE_WRITE8_MEMBER(supershot_output1_w);
	174	TILE_GET_INFO_MEMBER(get_supershot_text_tile_info);
174	175	};
175	176
176	177	/*************************************
r17672	r17673
179	180	*
180	181	*************************************/
181	182
182		static TILE_GET_INFO( get_supershot_text_tile_info )
	183	TILE_GET_INFO_MEMBER(supershot_state::get_supershot_text_tile_info)
183	184	{
184		supershot_state *state = machine.driver_data<supershot_state>();
185	185
186		UINT8 code = state->m_videoram[tile_index];
187		SET_TILE_INFO(0, code, 0, 0);
	186	UINT8 code = m_videoram[tile_index];
	187	SET_TILE_INFO_MEMBER(0, code, 0, 0);
188	188	}
189	189
190	190	static VIDEO_START( supershot )
191	191	{
192	192	supershot_state *state = machine.driver_data<supershot_state>();
193		state->m_tilemap = tilemap_create(machine, get_supershot_text_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	193	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supershot_state::get_supershot_text_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
194	194	}
195	195
196	196	static SCREEN_UPDATE_IND16( supershot )

trunk/src/mame/drivers/gstream.c

r17672	r17673
177	177	DECLARE_CUSTOM_INPUT_MEMBER(gstream_mirror_service_r);
178	178	DECLARE_CUSTOM_INPUT_MEMBER(gstream_mirror_r);
179	179	DECLARE_DRIVER_INIT(gstream);
	180	TILE_GET_INFO_MEMBER(get_gs1_tile_info);
	181	TILE_GET_INFO_MEMBER(get_gs2_tile_info);
	182	TILE_GET_INFO_MEMBER(get_gs3_tile_info);
180	183	};
181	184
182	185
r17672	r17673
441	444
442	445
443	446
444		static TILE_GET_INFO( get_gs1_tile_info )
	447	TILE_GET_INFO_MEMBER(gstream_state::get_gs1_tile_info)
445	448	{
446		gstream_state *state = machine.driver_data<gstream_state>();
447		int tileno = (state->m_vram[tile_index + 0x000 / 4] & 0x0fff0000) >> 16;
448		int palette = (state->m_vram[tile_index + 0x000 / 4] & 0xc0000000) >> 30;
449		SET_TILE_INFO(0, tileno, palette + 0x10, 0);
	449	int tileno = (m_vram[tile_index + 0x000 / 4] & 0x0fff0000) >> 16;
	450	int palette = (m_vram[tile_index + 0x000 / 4] & 0xc0000000) >> 30;
	451	SET_TILE_INFO_MEMBER(0, tileno, palette + 0x10, 0);
450	452	}
451	453
452		static TILE_GET_INFO( get_gs2_tile_info )
	454	TILE_GET_INFO_MEMBER(gstream_state::get_gs2_tile_info)
453	455	{
454		gstream_state *state = machine.driver_data<gstream_state>();
455		int tileno = (state->m_vram[tile_index + 0x400 / 4] & 0x0fff0000) >> 16;
456		int palette = (state->m_vram[tile_index + 0x400 / 4] & 0xc0000000) >> 30;
457		SET_TILE_INFO(0, tileno + 0x1000, palette + 0x14, 0);
	456	int tileno = (m_vram[tile_index + 0x400 / 4] & 0x0fff0000) >> 16;
	457	int palette = (m_vram[tile_index + 0x400 / 4] & 0xc0000000) >> 30;
	458	SET_TILE_INFO_MEMBER(0, tileno + 0x1000, palette + 0x14, 0);
458	459	}
459	460
460	461
461		static TILE_GET_INFO( get_gs3_tile_info )
	462	TILE_GET_INFO_MEMBER(gstream_state::get_gs3_tile_info)
462	463	{
463		gstream_state *state = machine.driver_data<gstream_state>();
464		int tileno = (state->m_vram[tile_index + 0x800 / 4] & 0x0fff0000) >> 16;
465		int palette = (state->m_vram[tile_index + 0x800 / 4] & 0xc0000000) >> 30;
466		SET_TILE_INFO(0, tileno + 0x2000, palette + 0x18, 0);
	464	int tileno = (m_vram[tile_index + 0x800 / 4] & 0x0fff0000) >> 16;
	465	int palette = (m_vram[tile_index + 0x800 / 4] & 0xc0000000) >> 30;
	466	SET_TILE_INFO_MEMBER(0, tileno + 0x2000, palette + 0x18, 0);
467	467	}
468	468
469	469
470	470	static VIDEO_START(gstream)
471	471	{
472	472	gstream_state *state = machine.driver_data<gstream_state>();
473		state->m_tilemap1 = tilemap_create(machine, get_gs1_tile_info, TILEMAP_SCAN_ROWS, 32, 32, 16, 16);
474		state->m_tilemap2 = tilemap_create(machine, get_gs2_tile_info, TILEMAP_SCAN_ROWS, 32, 32, 16, 16);
475		state->m_tilemap3 = tilemap_create(machine, get_gs3_tile_info, TILEMAP_SCAN_ROWS, 32, 32, 16, 16);
	473	state->m_tilemap1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gstream_state::get_gs1_tile_info),state), TILEMAP_SCAN_ROWS, 32, 32, 16, 16);
	474	state->m_tilemap2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gstream_state::get_gs2_tile_info),state), TILEMAP_SCAN_ROWS, 32, 32, 16, 16);
	475	state->m_tilemap3 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gstream_state::get_gs3_tile_info),state), TILEMAP_SCAN_ROWS, 32, 32, 16, 16);
476	476
477	477	state->m_tilemap1->set_transparent_pen(0);
478	478	state->m_tilemap2->set_transparent_pen(0);

trunk/src/mame/drivers/igs017.c

r17672	r17673
148	148	DECLARE_DRIVER_INIT(tarzana);
149	149	DECLARE_DRIVER_INIT(lhzb2a);
150	150	DECLARE_DRIVER_INIT(mgdha);
	151	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	152	TILE_GET_INFO_MEMBER(get_bg_tile_info);
151	153	};
152	154
153	155
r17672	r17673
178	180
179	181	#define COLOR(_X)   (((_X)>>2)&7)
180	182
181		static TILE_GET_INFO( get_fg_tile_info )
	183	TILE_GET_INFO_MEMBER(igs017_state::get_fg_tile_info)
182	184	{
183		igs017_state *state = machine.driver_data<igs017_state>();
184		int code = state->m_fg_videoram[tile_index*4+0] + (state->m_fg_videoram[tile_index*4+1] << 8);
185		int attr = state->m_fg_videoram[tile_index*4+2] + (state->m_fg_videoram[tile_index*4+3] << 8);
186		SET_TILE_INFO(0, code, COLOR(attr), TILE_FLIPXY( attr >> 5 ));
	185	int code = m_fg_videoram[tile_index*4+0] + (m_fg_videoram[tile_index*4+1] << 8);
	186	int attr = m_fg_videoram[tile_index*4+2] + (m_fg_videoram[tile_index*4+3] << 8);
	187	SET_TILE_INFO_MEMBER(0, code, COLOR(attr), TILE_FLIPXY( attr >> 5 ));
187	188	}
188		static TILE_GET_INFO( get_bg_tile_info )
	189	TILE_GET_INFO_MEMBER(igs017_state::get_bg_tile_info)
189	190	{
190		igs017_state *state = machine.driver_data<igs017_state>();
191		int code = state->m_bg_videoram[tile_index*4+0] + (state->m_bg_videoram[tile_index*4+1] << 8);
192		int attr = state->m_bg_videoram[tile_index*4+2] + (state->m_bg_videoram[tile_index*4+3] << 8);
193		SET_TILE_INFO(0, code, COLOR(attr)+8, TILE_FLIPXY( attr >> 5 ));
	191	int code = m_bg_videoram[tile_index*4+0] + (m_bg_videoram[tile_index*4+1] << 8);
	192	int attr = m_bg_videoram[tile_index*4+2] + (m_bg_videoram[tile_index*4+3] << 8);
	193	SET_TILE_INFO_MEMBER(0, code, COLOR(attr)+8, TILE_FLIPXY( attr >> 5 ));
194	194	}
195	195
196	196	WRITE8_MEMBER(igs017_state::fg_w)
r17672	r17673
264	264	static VIDEO_START( igs017 )
265	265	{
266	266	igs017_state *state = machine.driver_data<igs017_state>();
267		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32);
268		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32);
	267	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs017_state::get_fg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	268	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs017_state::get_bg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
269	269
270	270	state->m_fg_tilemap->set_transparent_pen(0xf);
271	271	state->m_bg_tilemap->set_transparent_pen(0xf);

trunk/src/mame/drivers/avt.c

r17672	r17673
441	441	UINT8 m_crtc_vreg[0x100],m_crtc_index;
442	442
443	443	DECLARE_WRITE8_MEMBER(debug_w);
	444	TILE_GET_INFO_MEMBER(get_bg_tile_info);
444	445	};
445	446
446	447	#define mc6845_h_char_total    (state->m_crtc_vreg[0])
r17672	r17673
480	481	}
481	482
482	483
483		static TILE_GET_INFO( get_bg_tile_info )
	484	TILE_GET_INFO_MEMBER(avt_state::get_bg_tile_info)
484	485	{
485		avt_state *state = machine.driver_data<avt_state>();
486	486	/*  - bits -
487	487	7654 3210
488	488	xxxx ----   color code.
489	489	---- xxxx   seems unused.
490	490	*/
491		int attr = state->m_colorram[tile_index];
492		int code = state->m_videoram[tile_index] | ((attr & 1) << 8);
	491	int attr = m_colorram[tile_index];
	492	int code = m_videoram[tile_index] | ((attr & 1) << 8);
493	493	int color = (attr & 0xf0)>>4;
494	494
495		SET_TILE_INFO( 0, code, color, 0);
	495	SET_TILE_INFO_MEMBER( 0, code, color, 0);
496	496	}
497	497
498	498
499	499	static VIDEO_START( avt )
500	500	{
501	501	avt_state *state = machine.driver_data<avt_state>();
502		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 28, 32);
	502	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(avt_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 28, 32);
503	503	}
504	504
505	505

trunk/src/mame/drivers/mole.c

r17672	r17673
69	69	DECLARE_WRITE8_MEMBER(mole_tilebank_w);
70	70	DECLARE_WRITE8_MEMBER(mole_flipscreen_w);
71	71	DECLARE_READ8_MEMBER(mole_protection_r);
	72	TILE_GET_INFO_MEMBER(get_bg_tile_info);
72	73	};
73	74
74	75
r17672	r17673
86	87	palette_set_color_rgb(machine, i, pal1bit(i >> 0), pal1bit(i >> 2), pal1bit(i >> 1));
87	88	}
88	89
89		static TILE_GET_INFO( get_bg_tile_info )
	90	TILE_GET_INFO_MEMBER(mole_state::get_bg_tile_info)
90	91	{
91		mole_state *state = machine.driver_data<mole_state>();
92		UINT16 code = state->m_tileram[tile_index];
	92	UINT16 code = m_tileram[tile_index];
93	93
94		SET_TILE_INFO((code & 0x200) ? 1 : 0, code & 0x1ff, 0, 0);
	94	SET_TILE_INFO_MEMBER((code & 0x200) ? 1 : 0, code & 0x1ff, 0, 0);
95	95	}
96	96
97	97	static VIDEO_START( mole )
98	98	{
99	99	mole_state *state = machine.driver_data<mole_state>();
100	100	memset(state->m_tileram, 0, sizeof(state->m_tileram));
101		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
	101	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mole_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
102	102
103	103	state->save_item(NAME(state->m_tileram));
104	104	}

trunk/src/mame/drivers/dynadice.c

r17672	r17673
60	60	DECLARE_WRITE8_MEMBER(sound_data_w);
61	61	DECLARE_WRITE8_MEMBER(sound_control_w);
62	62	DECLARE_DRIVER_INIT(dynadice);
	63	TILE_GET_INFO_MEMBER(get_tile_info);
63	64	};
64	65
65	66
r17672	r17673
192	193	GFXDECODE_ENTRY( "gfx2", 0, charlayout2,  0, 1 ) /* 3bpp */
193	194	GFXDECODE_END
194	195
195		static TILE_GET_INFO( get_tile_info )
	196	TILE_GET_INFO_MEMBER(dynadice_state::get_tile_info)
196	197	{
197		dynadice_state *state = machine.driver_data<dynadice_state>();
198		int code = state->m_videoram[tile_index];
199		SET_TILE_INFO(1, code, 0, 0);
	198	int code = m_videoram[tile_index];
	199	SET_TILE_INFO_MEMBER(1, code, 0, 0);
200	200	}
201	201
202	202	static VIDEO_START( dynadice )
r17672	r17673
204	204	dynadice_state *state = machine.driver_data<dynadice_state>();
205	205
206	206	/* pacman - style videoram layout */
207		state->m_bg_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
208		state->m_top_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_COLS, 8, 8, 2, 32);
	207	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dynadice_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	208	state->m_top_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dynadice_state::get_tile_info),state), TILEMAP_SCAN_COLS, 8, 8, 2, 32);
209	209	state->m_bg_tilemap->set_scrollx(0, -16);
210	210	}
211	211

trunk/src/mame/drivers/skyarmy.c

r17672	r17673
50	50	DECLARE_WRITE8_MEMBER(skyarmy_videoram_w);
51	51	DECLARE_WRITE8_MEMBER(skyarmy_colorram_w);
52	52	DECLARE_WRITE8_MEMBER(nmi_enable_w);
	53	TILE_GET_INFO_MEMBER(get_skyarmy_tile_info);
53	54	};
54	55
55	56	WRITE8_MEMBER(skyarmy_state::skyarmy_flip_screen_x_w)
r17672	r17673
62	63	flip_screen_y_set(data & 0x01);
63	64	}
64	65
65		static TILE_GET_INFO( get_skyarmy_tile_info )
	66	TILE_GET_INFO_MEMBER(skyarmy_state::get_skyarmy_tile_info)
66	67	{
67		skyarmy_state *state = machine.driver_data<skyarmy_state>();
68		int code = state->m_videoram[tile_index];
69		int attr = BITSWAP8(state->m_colorram[tile_index], 7, 6, 5, 4, 3, 0, 1, 2) & 7;
	68	int code = m_videoram[tile_index];
	69	int attr = BITSWAP8(m_colorram[tile_index], 7, 6, 5, 4, 3, 0, 1, 2) & 7;
70	70
71		SET_TILE_INFO( 0, code, attr, 0);
	71	SET_TILE_INFO_MEMBER( 0, code, attr, 0);
72	72	}
73	73
74	74	WRITE8_MEMBER(skyarmy_state::skyarmy_videoram_w)
r17672	r17673
118	118	{
119	119	skyarmy_state *state = machine.driver_data<skyarmy_state>();
120	120
121		state->m_tilemap = tilemap_create(machine, get_skyarmy_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	121	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(skyarmy_state::get_skyarmy_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
122	122	state->m_tilemap->set_scroll_cols(32);
123	123	}
124	124

trunk/src/mame/drivers/suprgolf.c

r17672	r17673
65	65	DECLARE_WRITE8_MEMBER(suprgolf_writeA);
66	66	DECLARE_WRITE8_MEMBER(suprgolf_writeB);
67	67	DECLARE_DRIVER_INIT(suprgolf);
	68	TILE_GET_INFO_MEMBER(get_tile_info);
68	69	};
69	70
70		static TILE_GET_INFO( get_tile_info )
	71	TILE_GET_INFO_MEMBER(suprgolf_state::get_tile_info)
71	72	{
72		suprgolf_state *state = machine.driver_data<suprgolf_state>();
73		int code = state->m_videoram[tile_index*2]+256*(state->m_videoram[tile_index*2+1]);
74		int color = state->m_videoram[tile_index*2+0x800] & 0x7f;
	73	int code = m_videoram[tile_index*2]+256*(m_videoram[tile_index*2+1]);
	74	int color = m_videoram[tile_index*2+0x800] & 0x7f;
75	75
76		SET_TILE_INFO(
	76	SET_TILE_INFO_MEMBER(
77	77	0,
78	78	code,
79	79	color,
r17672	r17673
84	84	{
85	85	suprgolf_state *state = machine.driver_data<suprgolf_state>();
86	86
87		state->m_tilemap = tilemap_create( machine, get_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32 );
	87	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(suprgolf_state::get_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32 );
88	88	state->m_paletteram = auto_alloc_array(machine, UINT8, 0x1000);
89	89	state->m_bg_vram = auto_alloc_array(machine, UINT8, 0x2000*0x20);
90	90	state->m_bg_fb = auto_alloc_array(machine, UINT16, 0x2000*0x20);

trunk/src/mame/drivers/dmndrby.c

r17672	r17673
77	77	DECLARE_WRITE8_MEMBER(dderby_sound_w);
78	78	DECLARE_READ8_MEMBER(input_r);
79	79	DECLARE_WRITE8_MEMBER(output_w);
	80	TILE_GET_INFO_MEMBER(get_dmndrby_tile_info);
80	81	};
81	82
82	83
r17672	r17673
317	318	GFXDECODE_ENTRY( "gfx3", 0, tiles16x16_layout, 16*16, 32 )
318	319	GFXDECODE_END
319	320
320		static TILE_GET_INFO( get_dmndrby_tile_info )
	321	TILE_GET_INFO_MEMBER(dmndrby_state::get_dmndrby_tile_info)
321	322	{
322		dmndrby_state *state = machine.driver_data<dmndrby_state>();
323		int code = state->m_racetrack_tilemap_rom[tile_index];
324		int attr = state->m_racetrack_tilemap_rom[tile_index+0x2000];
	323	int code = m_racetrack_tilemap_rom[tile_index];
	324	int attr = m_racetrack_tilemap_rom[tile_index+0x2000];
325	325
326	326	int col = attr&0x1f;
327	327	int flipx = (attr&0x40)>>6;
328	328
329	329
330		SET_TILE_INFO(
	330	SET_TILE_INFO_MEMBER(
331	331	2,
332	332	code,
333	333	col,
r17672	r17673
339	339	{
340	340	dmndrby_state *state = machine.driver_data<dmndrby_state>();
341	341	state->m_racetrack_tilemap_rom = state->memregion("user1")->base();
342		state->m_racetrack_tilemap = tilemap_create(machine,get_dmndrby_tile_info,TILEMAP_SCAN_ROWS,16,16, 16, 512);
	342	state->m_racetrack_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dmndrby_state::get_dmndrby_tile_info),state),TILEMAP_SCAN_ROWS,16,16, 16, 512);
343	343	state->m_racetrack_tilemap->mark_all_dirty();
344	344
345	345	}

trunk/src/mame/drivers/magicfly.c

r17672	r17673
433	433	DECLARE_WRITE8_MEMBER(magicfly_colorram_w);
434	434	DECLARE_READ8_MEMBER(mux_port_r);
435	435	DECLARE_WRITE8_MEMBER(mux_port_w);
	436	TILE_GET_INFO_MEMBER(get_magicfly_tile_info);
	437	TILE_GET_INFO_MEMBER(get_7mezzo_tile_info);
436	438	};
437	439
438	440
r17672	r17673
453	455	m_bg_tilemap->mark_tile_dirty(offset);
454	456	}
455	457
456		static TILE_GET_INFO( get_magicfly_tile_info )
	458	TILE_GET_INFO_MEMBER(magicfly_state::get_magicfly_tile_info)
457	459	{
458		magicfly_state *state = machine.driver_data<magicfly_state>();
459	460	/*  - bits -
460	461	7654 3210
461	462	---- -xxx   Tiles color.
r17672	r17673
465	466	x--- ----   Mirrored from bit 3. The code check this one to boot the game.
466	467
467	468	*/
468		int attr = state->m_colorram[tile_index];
469		int code = state->m_videoram[tile_index];
	469	int attr = m_colorram[tile_index];
	470	int code = m_videoram[tile_index];
470	471	int bank = (attr & 0x10) >> 4;   /* bit 4 switch the gfx banks */
471	472	int color = attr & 0x07;         /* bits 0-2 for color */
472	473
473	474	/* Seems that bit 7 is mirrored from bit 3 to have a normal boot */
474	475	/* Boot only check the first color RAM offset */
475	476
476		state->m_colorram[0] = state->m_colorram[0] | ((state->m_colorram[0] & 0x08) << 4);   /* only for 1st offset */
477		//state->m_colorram[tile_index] = attr | ((attr & 0x08) << 4);         /* for the whole color RAM */
	477	m_colorram[0] = m_colorram[0] | ((m_colorram[0] & 0x08) << 4);   /* only for 1st offset */
	478	//m_colorram[tile_index] = attr | ((attr & 0x08) << 4);         /* for the whole color RAM */
478	479
479		SET_TILE_INFO(bank, code, color, 0);
	480	SET_TILE_INFO_MEMBER(bank, code, color, 0);
480	481	}
481	482
482	483	static VIDEO_START(magicfly)
483	484	{
484	485	magicfly_state *state = machine.driver_data<magicfly_state>();
485		state->m_bg_tilemap = tilemap_create(machine, get_magicfly_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 29);
	486	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(magicfly_state::get_magicfly_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 29);
486	487	}
487	488
488		static TILE_GET_INFO( get_7mezzo_tile_info )
	489	TILE_GET_INFO_MEMBER(magicfly_state::get_7mezzo_tile_info)
489	490	{
490		magicfly_state *state = machine.driver_data<magicfly_state>();
491	491	/*  - bits -
492	492	7654 3210
493	493	---- -xxx   Tiles color.
r17672	r17673
497	497	x--- ----   Mirrored from bit 2. The code check this one to boot the game.
498	498
499	499	*/
500		int attr = state->m_colorram[tile_index];
501		int code = state->m_videoram[tile_index];
	500	int attr = m_colorram[tile_index];
	501	int code = m_videoram[tile_index];
502	502	int bank = (attr & 0x10) >> 4;    /* bit 4 switch the gfx banks */
503	503	int color = attr & 0x07;          /* bits 0-2 for color */
504	504
505	505	/* Seems that bit 7 is mirrored from bit 2 to have a normal boot */
506	506	/* Boot only check the first color RAM offset */
507	507
508		state->m_colorram[0] = state->m_colorram[0] | ((state->m_colorram[0] & 0x04) << 5);   /* only for 1st offset */
509		//state->m_colorram[tile_index] = attr | ((attr & 0x04) << 5);         /* for the whole color RAM */
	508	m_colorram[0] = m_colorram[0] | ((m_colorram[0] & 0x04) << 5);   /* only for 1st offset */
	509	//m_colorram[tile_index] = attr | ((attr & 0x04) << 5);         /* for the whole color RAM */
510	510
511		SET_TILE_INFO(bank, code, color, 0);
	511	SET_TILE_INFO_MEMBER(bank, code, color, 0);
512	512	}
513	513
514	514	static VIDEO_START( 7mezzo )
515	515	{
516	516	magicfly_state *state = machine.driver_data<magicfly_state>();
517		state->m_bg_tilemap = tilemap_create(machine, get_7mezzo_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 29);
	517	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(magicfly_state::get_7mezzo_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 29);
518	518	}
519	519
520	520	static SCREEN_UPDATE_IND16( magicfly )

trunk/src/mame/drivers/namcos23.c

r17672	r17673
1430	1430	DECLARE_READ8_MEMBER(s23_gun_r);
1431	1431	DECLARE_READ8_MEMBER(iob_r);
1432	1432	DECLARE_DRIVER_INIT(ss23);
	1433	TILE_GET_INFO_MEMBER(TextTilemapGetInfo);
1433	1434	};
1434	1435
1435	1436
r17672	r17673
1440	1441	return (pSource[0]<<((offs&1)*16))>>16;
1441	1442	}
1442	1443
1443		static TILE_GET_INFO( TextTilemapGetInfo )
	1444	TILE_GET_INFO_MEMBER(namcos23_state::TextTilemapGetInfo)
1444	1445	{
1445		namcos23_state *state = machine.driver_data<namcos23_state>();
1446		UINT16 data = nthword( state->m_textram,tile_index );
	1446	UINT16 data = nthword( m_textram,tile_index );
1447	1447	/**
1448	1448	* x---.----.----.---- blend
1449	1449	* xxxx.----.----.---- palette select
1450	1450	* ----.xx--.----.---- flip
1451	1451	* ----.--xx.xxxx.xxxx code
1452	1452	*/
1453		SET_TILE_INFO( 0, data&0x03ff, data>>12, TILE_FLIPYX((data&0x0c00)>>10) );
	1453	SET_TILE_INFO_MEMBER( 0, data&0x03ff, data>>12, TILE_FLIPYX((data&0x0c00)>>10) );
1454	1454	} /* TextTilemapGetInfo */
1455	1455
1456	1456	WRITE32_MEMBER(namcos23_state::namcos23_textram_w)
r17672	r17673
2399	2399	{
2400	2400	namcos23_state *state = machine.driver_data<namcos23_state>();
2401	2401	machine.gfx[0]->set_source(reinterpret_cast<UINT8 *>(state->m_charram.target()));
2402		state->m_bgtilemap = tilemap_create(machine, TextTilemapGetInfo, TILEMAP_SCAN_ROWS, 16, 16, 64, 64);
	2402	state->m_bgtilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(namcos23_state::TextTilemapGetInfo),state), TILEMAP_SCAN_ROWS, 16, 16, 64, 64);
2403	2403	state->m_bgtilemap->set_transparent_pen(0xf);
2404	2404
2405	2405	// Gorgon's tilemap offset is 0, S23/SS23's is 860

trunk/src/mame/drivers/onetwo.c

r17672	r17673
72	72	DECLARE_WRITE8_MEMBER(onetwo_soundlatch_w);
73	73	DECLARE_WRITE8_MEMBER(palette1_w);
74	74	DECLARE_WRITE8_MEMBER(palette2_w);
	75	TILE_GET_INFO_MEMBER(get_fg_tile_info);
75	76	};
76	77
77	78
r17672	r17673
82	83	*
83	84	*************************************/
84	85
85		static TILE_GET_INFO( get_fg_tile_info )
	86	TILE_GET_INFO_MEMBER(onetwo_state::get_fg_tile_info)
86	87	{
87		onetwo_state *state = machine.driver_data<onetwo_state>();
88		int code = (state->m_fgram[tile_index * 2 + 1] << 8) | state->m_fgram[tile_index * 2];
89		int color = (state->m_fgram[tile_index * 2 + 1] & 0x80) >> 7;
	88	int code = (m_fgram[tile_index * 2 + 1] << 8) | m_fgram[tile_index * 2];
	89	int color = (m_fgram[tile_index * 2 + 1] & 0x80) >> 7;
90	90
91	91	code &= 0x7fff;
92	92
93		SET_TILE_INFO(0, code, color, 0);
	93	SET_TILE_INFO_MEMBER(0, code, color, 0);
94	94	}
95	95
96	96	static VIDEO_START( onetwo )
97	97	{
98	98	onetwo_state *state = machine.driver_data<onetwo_state>();
99		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	99	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(onetwo_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
100	100	}
101	101
102	102	static SCREEN_UPDATE_IND16( onetwo )

trunk/src/mame/drivers/mayumi.c

r17672	r17673
41	41	DECLARE_WRITE8_MEMBER(input_sel_w);
42	42	DECLARE_READ8_MEMBER(key_matrix_1p_r);
43	43	DECLARE_READ8_MEMBER(key_matrix_2p_r);
	44	TILE_GET_INFO_MEMBER(get_tile_info);
44	45	};
45	46
46	47
r17672	r17673
50	51	*
51	52	*************************************/
52	53
53		static TILE_GET_INFO( get_tile_info )
	54	TILE_GET_INFO_MEMBER(mayumi_state::get_tile_info)
54	55	{
55		mayumi_state *state = machine.driver_data<mayumi_state>();
56		int code = state->m_videoram[tile_index] + (state->m_videoram[tile_index + 0x800] & 0x1f) * 0x100;
57		int col = (state->m_videoram[tile_index + 0x1000] >> 3) & 0x1f;
	56	int code = m_videoram[tile_index] + (m_videoram[tile_index + 0x800] & 0x1f) * 0x100;
	57	int col = (m_videoram[tile_index + 0x1000] >> 3) & 0x1f;
58	58
59		SET_TILE_INFO(0, code, col, 0);
	59	SET_TILE_INFO_MEMBER(0, code, col, 0);
60	60	}
61	61
62	62	static VIDEO_START( mayumi )
63	63	{
64	64	mayumi_state *state = machine.driver_data<mayumi_state>();
65		state->m_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	65	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mayumi_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
66	66	}
67	67
68	68	WRITE8_MEMBER(mayumi_state::mayumi_videoram_w)

trunk/src/mame/drivers/bnstars.c

r17672	r17673
147	147	DECLARE_READ32_MEMBER(bnstars3_r);
148	148	DECLARE_WRITE32_MEMBER(bnstars1_mahjong_select_w);
149	149	DECLARE_DRIVER_INIT(bnstars);
	150	TILE_GET_INFO_MEMBER(get_ms32_tx0_tile_info);
	151	TILE_GET_INFO_MEMBER(get_ms32_tx1_tile_info);
	152	TILE_GET_INFO_MEMBER(get_ms32_bg0_tile_info);
	153	TILE_GET_INFO_MEMBER(get_ms32_bg1_tile_info);
	154	TILE_GET_INFO_MEMBER(get_ms32_roz0_tile_info);
	155	TILE_GET_INFO_MEMBER(get_ms32_roz1_tile_info);
150	156	};
151	157
152	158
153	159
154		static TILE_GET_INFO( get_ms32_tx0_tile_info )
	160	TILE_GET_INFO_MEMBER(bnstars_state::get_ms32_tx0_tile_info)
155	161	{
156		bnstars_state *state = machine.driver_data<bnstars_state>();
157	162	int tileno, colour;
158	163
159		tileno = state->m_ms32_tx0_ram[tile_index *2+0] & 0x0000ffff;
160		colour = state->m_ms32_tx0_ram[tile_index *2+1] & 0x0000000f;
	164	tileno = m_ms32_tx0_ram[tile_index *2+0] & 0x0000ffff;
	165	colour = m_ms32_tx0_ram[tile_index *2+1] & 0x0000000f;
161	166
162		SET_TILE_INFO(3,tileno,colour,0);
	167	SET_TILE_INFO_MEMBER(3,tileno,colour,0);
163	168	}
164	169
165		static TILE_GET_INFO( get_ms32_tx1_tile_info )
	170	TILE_GET_INFO_MEMBER(bnstars_state::get_ms32_tx1_tile_info)
166	171	{
167		bnstars_state *state = machine.driver_data<bnstars_state>();
168	172	int tileno, colour;
169	173
170		tileno = state->m_ms32_tx1_ram[tile_index *2+0] & 0x0000ffff;
171		colour = state->m_ms32_tx1_ram[tile_index *2+1] & 0x0000000f;
	174	tileno = m_ms32_tx1_ram[tile_index *2+0] & 0x0000ffff;
	175	colour = m_ms32_tx1_ram[tile_index *2+1] & 0x0000000f;
172	176
173		SET_TILE_INFO(7,tileno,colour,0);
	177	SET_TILE_INFO_MEMBER(7,tileno,colour,0);
174	178	}
175	179
176	180	WRITE32_MEMBER(bnstars_state::ms32_tx0_ram_w)
r17672	r17673
187	191
188	192	/* BG Layers */
189	193
190		static TILE_GET_INFO( get_ms32_bg0_tile_info )
	194	TILE_GET_INFO_MEMBER(bnstars_state::get_ms32_bg0_tile_info)
191	195	{
192		bnstars_state *state = machine.driver_data<bnstars_state>();
193	196	int tileno,colour;
194	197
195		tileno = state->m_ms32_bg0_ram[tile_index *2+0] & 0x0000ffff;
196		colour = state->m_ms32_bg0_ram[tile_index *2+1] & 0x0000000f;
	198	tileno = m_ms32_bg0_ram[tile_index *2+0] & 0x0000ffff;
	199	colour = m_ms32_bg0_ram[tile_index *2+1] & 0x0000000f;
197	200
198		SET_TILE_INFO(2,tileno,colour,0);
	201	SET_TILE_INFO_MEMBER(2,tileno,colour,0);
199	202	}
200	203
201		static TILE_GET_INFO( get_ms32_bg1_tile_info )
	204	TILE_GET_INFO_MEMBER(bnstars_state::get_ms32_bg1_tile_info)
202	205	{
203		bnstars_state *state = machine.driver_data<bnstars_state>();
204	206	int tileno,colour;
205	207
206		tileno = state->m_ms32_bg1_ram[tile_index *2+0] & 0x0000ffff;
207		colour = state->m_ms32_bg1_ram[tile_index *2+1] & 0x0000000f;
	208	tileno = m_ms32_bg1_ram[tile_index *2+0] & 0x0000ffff;
	209	colour = m_ms32_bg1_ram[tile_index *2+1] & 0x0000000f;
208	210
209		SET_TILE_INFO(6,tileno,colour,0);
	211	SET_TILE_INFO_MEMBER(6,tileno,colour,0);
210	212	}
211	213
212	214	WRITE32_MEMBER(bnstars_state::ms32_bg0_ram_w)
r17672	r17673
309	311	}
310	312
311	313
312		static TILE_GET_INFO( get_ms32_roz0_tile_info )
	314	TILE_GET_INFO_MEMBER(bnstars_state::get_ms32_roz0_tile_info)
313	315	{
314		bnstars_state *state = machine.driver_data<bnstars_state>();
315	316	int tileno,colour;
316	317
317		tileno = state->m_ms32_roz0_ram[tile_index *2+0] & 0x0000ffff;
318		colour = state->m_ms32_roz0_ram[tile_index *2+1] & 0x0000000f;
	318	tileno = m_ms32_roz0_ram[tile_index *2+0] & 0x0000ffff;
	319	colour = m_ms32_roz0_ram[tile_index *2+1] & 0x0000000f;
319	320
320		SET_TILE_INFO(1,tileno,colour,0);
	321	SET_TILE_INFO_MEMBER(1,tileno,colour,0);
321	322	}
322	323
323		static TILE_GET_INFO( get_ms32_roz1_tile_info )
	324	TILE_GET_INFO_MEMBER(bnstars_state::get_ms32_roz1_tile_info)
324	325	{
325		bnstars_state *state = machine.driver_data<bnstars_state>();
326	326	int tileno,colour;
327	327
328		tileno = state->m_ms32_roz1_ram[tile_index *2+0] & 0x0000ffff;
329		colour = state->m_ms32_roz1_ram[tile_index *2+1] & 0x0000000f;
	328	tileno = m_ms32_roz1_ram[tile_index *2+0] & 0x0000ffff;
	329	colour = m_ms32_roz1_ram[tile_index *2+1] & 0x0000000f;
330	330
331		SET_TILE_INFO(5,tileno,colour,0);
	331	SET_TILE_INFO_MEMBER(5,tileno,colour,0);
332	332	}
333	333
334	334	WRITE32_MEMBER(bnstars_state::ms32_roz0_ram_w)
r17672	r17673
507	507	static VIDEO_START(bnstars)
508	508	{
509	509	bnstars_state *state = machine.driver_data<bnstars_state>();
510		state->m_ms32_tx_tilemap[0] = tilemap_create(machine, get_ms32_tx0_tile_info,TILEMAP_SCAN_ROWS, 8, 8,64,64);
511		state->m_ms32_tx_tilemap[1] = tilemap_create(machine, get_ms32_tx1_tile_info,TILEMAP_SCAN_ROWS, 8, 8,64,64);
	510	state->m_ms32_tx_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bnstars_state::get_ms32_tx0_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8,64,64);
	511	state->m_ms32_tx_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bnstars_state::get_ms32_tx1_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8,64,64);
512	512	state->m_ms32_tx_tilemap[0]->set_transparent_pen(0);
513	513	state->m_ms32_tx_tilemap[1]->set_transparent_pen(0);
514	514
515		state->m_ms32_bg_tilemap[0] = tilemap_create(machine, get_ms32_bg0_tile_info,TILEMAP_SCAN_ROWS,16,16,64,64);
516		state->m_ms32_bg_tilemap[1] = tilemap_create(machine, get_ms32_bg1_tile_info,TILEMAP_SCAN_ROWS,16,16,64,64);
	515	state->m_ms32_bg_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bnstars_state::get_ms32_bg0_tile_info),state),TILEMAP_SCAN_ROWS,16,16,64,64);
	516	state->m_ms32_bg_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bnstars_state::get_ms32_bg1_tile_info),state),TILEMAP_SCAN_ROWS,16,16,64,64);
517	517	state->m_ms32_bg_tilemap[0]->set_transparent_pen(0);
518	518	state->m_ms32_bg_tilemap[1]->set_transparent_pen(0);
519	519
520		state->m_ms32_roz_tilemap[0] = tilemap_create(machine, get_ms32_roz0_tile_info,TILEMAP_SCAN_ROWS,16,16,128,128);
521		state->m_ms32_roz_tilemap[1] = tilemap_create(machine, get_ms32_roz1_tile_info,TILEMAP_SCAN_ROWS,16,16,128,128);
	520	state->m_ms32_roz_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bnstars_state::get_ms32_roz0_tile_info),state),TILEMAP_SCAN_ROWS,16,16,128,128);
	521	state->m_ms32_roz_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(bnstars_state::get_ms32_roz1_tile_info),state),TILEMAP_SCAN_ROWS,16,16,128,128);
522	522	state->m_ms32_roz_tilemap[0]->set_transparent_pen(0);
523	523	state->m_ms32_roz_tilemap[1]->set_transparent_pen(0);
524	524

trunk/src/mame/drivers/vmetal.c

r17672	r17673
116	116	DECLARE_READ16_MEMBER(varia_dips_bit1_r);
117	117	DECLARE_WRITE8_MEMBER(vmetal_control_w);
118	118	DECLARE_WRITE8_MEMBER(vmetal_es8712_w);
	119	TILE_GET_INFO_MEMBER(get_vmetal_texttilemap_tile_info);
	120	TILE_GET_INFO_MEMBER(get_vmetal_mid1tilemap_tile_info);
	121	TILE_GET_INFO_MEMBER(get_vmetal_mid2tilemap_tile_info);
119	122	};
120	123
121	124
r17672	r17673
383	386	GFXDECODE_END
384	387
385	388
386		static TILE_GET_INFO( get_vmetal_texttilemap_tile_info )
	389	TILE_GET_INFO_MEMBER(vmetal_state::get_vmetal_texttilemap_tile_info)
387	390	{
388		vmetal_state *state = machine.driver_data<vmetal_state>();
389	391	UINT32 tile;
390		UINT16 color, data = state->m_texttileram[tile_index];
	392	UINT16 color, data = m_texttileram[tile_index];
391	393	int idx = ((data & 0x7fff) >> 4) * 2;
392		UINT32 lookup = (state->m_tlookup[idx] << 16) | state->m_tlookup[idx + 1];
	394	UINT32 lookup = (m_tlookup[idx] << 16) | m_tlookup[idx + 1];
393	395
394	396	tile = (data & 0xf) | (lookup & 0x7fff0);
395	397	color = ((lookup >> 20) & 0x1f) + 0xe0;
r17672	r17673
397	399	if (data & 0x8000)
398	400	tile = 0;
399	401
400		SET_TILE_INFO(1, tile, color, TILE_FLIPYX(0x0));
	402	SET_TILE_INFO_MEMBER(1, tile, color, TILE_FLIPYX(0x0));
401	403	}
402	404
403	405
404		static TILE_GET_INFO( get_vmetal_mid1tilemap_tile_info )
	406	TILE_GET_INFO_MEMBER(vmetal_state::get_vmetal_mid1tilemap_tile_info)
405	407	{
406		vmetal_state *state = machine.driver_data<vmetal_state>();
407		UINT16 tile, color, data = state->m_mid1tileram[tile_index];
	408	UINT16 tile, color, data = m_mid1tileram[tile_index];
408	409
409		get_vmetal_tlookup(machine, data, &tile, &color);
	410	get_vmetal_tlookup(machine(), data, &tile, &color);
410	411
411	412	if (data & 0x8000)
412	413	tile = 0;
413	414
414		SET_TILE_INFO(0, tile, color, TILE_FLIPYX(0x0));
	415	SET_TILE_INFO_MEMBER(0, tile, color, TILE_FLIPYX(0x0));
415	416	}
416	417
417		static TILE_GET_INFO( get_vmetal_mid2tilemap_tile_info )
	418	TILE_GET_INFO_MEMBER(vmetal_state::get_vmetal_mid2tilemap_tile_info)
418	419	{
419		vmetal_state *state = machine.driver_data<vmetal_state>();
420		UINT16 tile, color, data = state->m_mid2tileram[tile_index];
	420	UINT16 tile, color, data = m_mid2tileram[tile_index];
421	421
422		get_vmetal_tlookup(machine, data, &tile, &color);
	422	get_vmetal_tlookup(machine(), data, &tile, &color);
423	423
424	424	if (data & 0x8000)
425	425	tile = 0;
426	426
427		SET_TILE_INFO(0, tile, color, TILE_FLIPYX(0x0));
	427	SET_TILE_INFO_MEMBER(0, tile, color, TILE_FLIPYX(0x0));
428	428	}
429	429
430	430	static void expand_gfx1(running_machine &machine)
r17672	r17673
445	445	{
446	446	vmetal_state *state = machine.driver_data<vmetal_state>();
447	447
448		state->m_texttilemap = tilemap_create(machine, get_vmetal_texttilemap_tile_info, TILEMAP_SCAN_ROWS,  8,  8, 256, 256);
449		state->m_mid1tilemap = tilemap_create(machine, get_vmetal_mid1tilemap_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 256, 256);
450		state->m_mid2tilemap = tilemap_create(machine, get_vmetal_mid2tilemap_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 256, 256);
	448	state->m_texttilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(vmetal_state::get_vmetal_texttilemap_tile_info),state), TILEMAP_SCAN_ROWS,  8,  8, 256, 256);
	449	state->m_mid1tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(vmetal_state::get_vmetal_mid1tilemap_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 256, 256);
	450	state->m_mid2tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(vmetal_state::get_vmetal_mid2tilemap_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 256, 256);
451	451
452	452	state->m_texttilemap->set_transparent_pen(15);
453	453	state->m_mid1tilemap->set_transparent_pen(15);

trunk/src/mame/drivers/firefox.c

r17672	r17673
95	95	DECLARE_READ8_MEMBER(riot_porta_r);
96	96	DECLARE_WRITE8_MEMBER(riot_porta_w);
97	97	DECLARE_WRITE_LINE_MEMBER(riot_irq);
	98	TILE_GET_INFO_MEMBER(bgtile_get_info);
98	99	};
99	100
100	101
r17672	r17673
190	191	*
191	192	*************************************/
192	193
193		static TILE_GET_INFO( bgtile_get_info )
	194	TILE_GET_INFO_MEMBER(firefox_state::bgtile_get_info)
194	195	{
195		firefox_state *state = machine.driver_data<firefox_state>();
196		SET_TILE_INFO(0, state->m_tileram[tile_index], 0, 0);
	196	SET_TILE_INFO_MEMBER(0, m_tileram[tile_index], 0, 0);
197	197	}
198	198
199	199
r17672	r17673
207	207	static VIDEO_START( firefox )
208	208	{
209	209	firefox_state *state = machine.driver_data<firefox_state>();
210		state->m_bgtiles = tilemap_create(machine, bgtile_get_info, TILEMAP_SCAN_ROWS, 8,8, 64,64);
	210	state->m_bgtiles = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(firefox_state::bgtile_get_info),state), TILEMAP_SCAN_ROWS, 8,8, 64,64);
211	211	state->m_bgtiles->set_transparent_pen(0);
212	212	state->m_bgtiles->set_scrolldy(machine.primary_screen->visible_area().min_y, 0);
213	213	}

trunk/src/mame/drivers/caswin.c

r17672	r17673
65	65	DECLARE_READ8_MEMBER(vvillage_rng_r);
66	66	DECLARE_WRITE8_MEMBER(vvillage_output_w);
67	67	DECLARE_WRITE8_MEMBER(vvillage_lamps_w);
	68	TILE_GET_INFO_MEMBER(get_sc0_tile_info);
68	69	};
69	70
70	71
71	72
72		static TILE_GET_INFO( get_sc0_tile_info )
	73	TILE_GET_INFO_MEMBER(caswin_state::get_sc0_tile_info)
73	74	{
74		caswin_state *state = machine.driver_data<caswin_state>();
75		int tile = (state->m_sc0_vram[tile_index] | ((state->m_sc0_attr[tile_index] & 0x70)<<4)) & 0x7ff;
76		int colour = state->m_sc0_attr[tile_index] & 0xf;
	75	int tile = (m_sc0_vram[tile_index] | ((m_sc0_attr[tile_index] & 0x70)<<4)) & 0x7ff;
	76	int colour = m_sc0_attr[tile_index] & 0xf;
77	77
78		SET_TILE_INFO(
	78	SET_TILE_INFO_MEMBER(
79	79	0,
80	80	tile,
81	81	colour,
r17672	r17673
85	85	static VIDEO_START(vvillage)
86	86	{
87	87	caswin_state *state = machine.driver_data<caswin_state>();
88		state->m_sc0_tilemap = tilemap_create(machine, get_sc0_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32);
	88	state->m_sc0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(caswin_state::get_sc0_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32);
89	89	}
90	90
91	91	static SCREEN_UPDATE_IND16(vvillage)

trunk/src/mame/drivers/koftball.c

r17672	r17673
62	62	DECLARE_WRITE16_MEMBER(bmc_1_videoram_w);
63	63	DECLARE_WRITE16_MEMBER(bmc_2_videoram_w);
64	64	DECLARE_DRIVER_INIT(koftball);
	65	TILE_GET_INFO_MEMBER(get_t1_tile_info);
	66	TILE_GET_INFO_MEMBER(get_t2_tile_info);
65	67	};
66	68
67	69
68		static TILE_GET_INFO( get_t1_tile_info )
	70	TILE_GET_INFO_MEMBER(koftball_state::get_t1_tile_info)
69	71	{
70		koftball_state *state = machine.driver_data<koftball_state>();
71		int data = state->m_bmc_1_videoram[tile_index];
72		SET_TILE_INFO(
	72	int data = m_bmc_1_videoram[tile_index];
	73	SET_TILE_INFO_MEMBER(
73	74	0,
74	75	data,
75	76	0,
76	77	0);
77	78	}
78	79
79		static TILE_GET_INFO( get_t2_tile_info )
	80	TILE_GET_INFO_MEMBER(koftball_state::get_t2_tile_info)
80	81	{
81		koftball_state *state = machine.driver_data<koftball_state>();
82		int data = state->m_bmc_2_videoram[tile_index];
83		SET_TILE_INFO(
	82	int data = m_bmc_2_videoram[tile_index];
	83	SET_TILE_INFO_MEMBER(
84	84	0,
85	85	data,
86	86	0,
r17672	r17673
90	90	static VIDEO_START( koftball )
91	91	{
92	92	koftball_state *state = machine.driver_data<koftball_state>();
93		state->m_tilemap_1 = tilemap_create(machine, get_t1_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32);
94		state->m_tilemap_2 = tilemap_create(machine, get_t2_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32);
	93	state->m_tilemap_1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(koftball_state::get_t1_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	94	state->m_tilemap_2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(koftball_state::get_t2_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
95	95
96	96	state->m_tilemap_1->set_transparent_pen(0);
97	97	}

trunk/src/mame/drivers/igs_m027.c

r17672	r17673
55	55	DECLARE_DRIVER_INIT(hauntedh);
56	56	DECLARE_DRIVER_INIT(bigd2);
57	57	DECLARE_DRIVER_INIT(klxyj);
	58	TILE_GET_INFO_MEMBER(get_tx_tilemap_tile_info);
	59	TILE_GET_INFO_MEMBER(get_bg_tilemap_tile_info);
58	60	};
59	61
60	62
r17672	r17673
125	127	//logerror( "TX VIDEO RAM OFFSET %x ,data %x!\n",offset ,m_igs_tx_videoram[offset]);
126	128	}
127	129
128		static TILE_GET_INFO( get_tx_tilemap_tile_info )
	130	TILE_GET_INFO_MEMBER(igs_m027_state::get_tx_tilemap_tile_info)
129	131	{
130		igs_m027_state *state = machine.driver_data<igs_m027_state>();
131	132	//ppppppppNNNNNNNN
132	133	int tileno,colour;
133		tileno = state->m_igs_tx_videoram[tile_index] & 0xffff;
134		colour = (state->m_igs_tx_videoram[tile_index]>>0x10) & 0xffff;
	134	tileno = m_igs_tx_videoram[tile_index] & 0xffff;
	135	colour = (m_igs_tx_videoram[tile_index]>>0x10) & 0xffff;
135	136
136		SET_TILE_INFO(0,tileno,colour,0);
	137	SET_TILE_INFO_MEMBER(0,tileno,colour,0);
137	138	}
138	139
139	140	/* BG Layer */
r17672	r17673
145	146	logerror("BG VIDEO RAM OFFSET %x ,data %x!\n",offset ,m_igs_bg_videoram[offset]);
146	147	}
147	148
148		static TILE_GET_INFO( get_bg_tilemap_tile_info )
	149	TILE_GET_INFO_MEMBER(igs_m027_state::get_bg_tilemap_tile_info)
149	150	{
150		igs_m027_state *state = machine.driver_data<igs_m027_state>();
151	151	//ppppppppNNNNNNNN
152	152	int tileno,colour;
153		tileno = state->m_igs_bg_videoram[tile_index] & 0xffff;
154		colour = (state->m_igs_bg_videoram[tile_index]>>0x10) & 0xffff;
	153	tileno = m_igs_bg_videoram[tile_index] & 0xffff;
	154	colour = (m_igs_bg_videoram[tile_index]>>0x10) & 0xffff;
155	155
156		SET_TILE_INFO(0,tileno,colour,0);
	156	SET_TILE_INFO_MEMBER(0,tileno,colour,0);
157	157	}
158	158
159	159
r17672	r17673
173	173	static VIDEO_START(igs_majhong)
174	174	{
175	175	igs_m027_state *state = machine.driver_data<igs_m027_state>();
176		state->m_igs_tx_tilemap= tilemap_create(machine, get_tx_tilemap_tile_info,TILEMAP_SCAN_ROWS, 8, 8,64,32);
	176	state->m_igs_tx_tilemap= &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs_m027_state::get_tx_tilemap_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8,64,32);
177	177	state->m_igs_tx_tilemap->set_transparent_pen(15);
178		state->m_igs_bg_tilemap= tilemap_create(machine, get_bg_tilemap_tile_info,TILEMAP_SCAN_ROWS, 8, 8,64,32);
179		//state->m_igs_bg_tilemap= tilemap_create(machine, get_bg_tilemap_tile_info,TILEMAP_SCAN_ROWS, 8, 8,64,32);
	178	state->m_igs_bg_tilemap= &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs_m027_state::get_bg_tilemap_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8,64,32);
	179	//state->m_igs_bg_tilemap= &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs_m027_state::get_bg_tilemap_tile_info),state),TILEMAP_SCAN_ROWS, 8, 8,64,32);
180	180	//state->m_igs_bg_tilemap->set_transparent_pen(15);
181	181	logerror("Video START OK!\n");
182	182	}

trunk/src/mame/drivers/subsino2.c

r17672	r17673
159	159	DECLARE_DRIVER_INIT(mtrain);
160	160	DECLARE_DRIVER_INIT(saklove);
161	161	DECLARE_DRIVER_INIT(xplan);
	162	TILE_GET_INFO_MEMBER(ss9601_get_tile_info_0);
	163	TILE_GET_INFO_MEMBER(ss9601_get_tile_info_1);
162	164	};
163	165
164	166
r17672	r17673
182	184	}
183	185
184	186	// Layer 0
185		static TILE_GET_INFO( ss9601_get_tile_info_0 )
	187	TILE_GET_INFO_MEMBER(subsino2_state::ss9601_get_tile_info_0)
186	188	{
187		subsino2_state *state = machine.driver_data<subsino2_state>();
188		ss9601_get_tile_info(&state->m_layers[0], machine, tileinfo, tile_index, param);
	189	ss9601_get_tile_info(&m_layers[0], machine(), tileinfo, tile_index, param);
189	190	}
190	191
191	192	// Layer 1
192		static TILE_GET_INFO( ss9601_get_tile_info_1 )
	193	TILE_GET_INFO_MEMBER(subsino2_state::ss9601_get_tile_info_1)
193	194	{
194		subsino2_state *state = machine.driver_data<subsino2_state>();
195		ss9601_get_tile_info(&state->m_layers[1], machine, tileinfo, tile_index, param);
	195	ss9601_get_tile_info(&m_layers[1], machine(), tileinfo, tile_index, param);
196	196	}
197	197
198	198
r17672	r17673
577	577	{
578	578	layer_t *l = &state->m_layers[i];
579	579
580		l->tmap = tilemap_create(machine, i ? ss9601_get_tile_info_1 : ss9601_get_tile_info_0, TILEMAP_SCAN_ROWS, 8,8, 0x80,0x40);
	580	l->tmap = &machine.tilemap().create(i ? tilemap_get_info_delegate(FUNC(subsino2_state::ss9601_get_tile_info_1),state) : tilemap_get_info_delegate(FUNC(subsino2_state::ss9601_get_tile_info_0),state), TILEMAP_SCAN_ROWS, 8,8, 0x80,0x40);
581	581
582	582	l->tmap->set_transparent_pen(0);
583	583

trunk/src/mame/drivers/m63.c

r17672	r17673
177	177	DECLARE_WRITE8_MEMBER(nmi_mask_w);
178	178	DECLARE_DRIVER_INIT(wilytowr);
179	179	DECLARE_DRIVER_INIT(fghtbskt);
	180	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	181	TILE_GET_INFO_MEMBER(get_fg_tile_info);
180	182	};
181	183
182	184
r17672	r17673
284	286	}
285	287
286	288
287		static TILE_GET_INFO( get_bg_tile_info )
	289	TILE_GET_INFO_MEMBER(m63_state::get_bg_tile_info)
288	290	{
289		m63_state *state = machine.driver_data<m63_state>();
290	291
291		int attr = state->m_colorram[tile_index];
292		int code = state->m_videoram[tile_index] | ((attr & 0x30) << 4);
293		int color = (attr & 0x0f) + (state->m_pal_bank << 4);
	292	int attr = m_colorram[tile_index];
	293	int code = m_videoram[tile_index] | ((attr & 0x30) << 4);
	294	int color = (attr & 0x0f) + (m_pal_bank << 4);
294	295
295		SET_TILE_INFO(1, code, color, 0);
	296	SET_TILE_INFO_MEMBER(1, code, color, 0);
296	297	}
297	298
298		static TILE_GET_INFO( get_fg_tile_info )
	299	TILE_GET_INFO_MEMBER(m63_state::get_fg_tile_info)
299	300	{
300		m63_state *state = machine.driver_data<m63_state>();
301	301
302		int code = state->m_videoram2[tile_index];
	302	int code = m_videoram2[tile_index];
303	303
304		SET_TILE_INFO(0, code, 0, state->m_fg_flag);
	304	SET_TILE_INFO_MEMBER(0, code, 0, m_fg_flag);
305	305	}
306	306
307	307	static VIDEO_START( m63 )
308	308	{
309	309	m63_state *state = machine.driver_data<m63_state>();
310	310
311		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
312		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	311	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(m63_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	312	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(m63_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
313	313
314	314	state->m_bg_tilemap->set_scroll_cols(32);
315	315	state->m_fg_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/jclub2.c

r17672	r17673
138	138	DECLARE_WRITE32_MEMBER(darkhors_unk1_w);
139	139	DECLARE_WRITE32_MEMBER(darkhors_eeprom_w);
140	140	DECLARE_DRIVER_INIT(darkhors);
	141	TILE_GET_INFO_MEMBER(get_tile_info_0);
	142	TILE_GET_INFO_MEMBER(get_tile_info_1);
141	143	};
142	144
143	145
r17672	r17673
155	157	static SCREEN_UPDATE_IND16( darkhors );
156	158
157	159
158		static TILE_GET_INFO( get_tile_info_0 )
	160	TILE_GET_INFO_MEMBER(darkhors_state::get_tile_info_0)
159	161	{
160		darkhors_state *state = machine.driver_data<darkhors_state>();
161		UINT16 tile      =   state->m_tmapram[tile_index] >> 16;
162		UINT16 color   =   state->m_tmapram[tile_index] & 0xffff;
163		SET_TILE_INFO(0, tile/2, (color & 0x200) ? (color & 0x1ff) : ((color & 0x0ff) * 4) , 0);
	162	UINT16 tile      =   m_tmapram[tile_index] >> 16;
	163	UINT16 color   =   m_tmapram[tile_index] & 0xffff;
	164	SET_TILE_INFO_MEMBER(0, tile/2, (color & 0x200) ? (color & 0x1ff) : ((color & 0x0ff) * 4) , 0);
164	165	}
165	166
166		static TILE_GET_INFO( get_tile_info_1 )
	167	TILE_GET_INFO_MEMBER(darkhors_state::get_tile_info_1)
167	168	{
168		darkhors_state *state = machine.driver_data<darkhors_state>();
169		UINT16 tile      =   state->m_tmapram2[tile_index] >> 16;
170		UINT16 color   =   state->m_tmapram2[tile_index] & 0xffff;
171		SET_TILE_INFO(0, tile/2, (color & 0x200) ? (color & 0x1ff) : ((color & 0x0ff) * 4) , 0);
	169	UINT16 tile      =   m_tmapram2[tile_index] >> 16;
	170	UINT16 color   =   m_tmapram2[tile_index] & 0xffff;
	171	SET_TILE_INFO_MEMBER(0, tile/2, (color & 0x200) ? (color & 0x1ff) : ((color & 0x0ff) * 4) , 0);
172	172	}
173	173
174	174	WRITE32_MEMBER(darkhors_state::darkhors_tmapram_w)
r17672	r17673
220	220	static VIDEO_START( darkhors )
221	221	{
222	222	darkhors_state *state = machine.driver_data<darkhors_state>();
223		state->m_tmap         =   tilemap_create(   machine, get_tile_info_0, TILEMAP_SCAN_ROWS,
224		16,16, 0x40,0x40   );
225
226		state->m_tmap2         =   tilemap_create(   machine, get_tile_info_1, TILEMAP_SCAN_ROWS,
227		16,16, 0x40,0x40   );
228
	223	state->m_tmap =   &machine.tilemap().create(tilemap_get_info_delegate(FUNC(darkhors_state::get_tile_info_0),state), TILEMAP_SCAN_ROWS,16,16, 0x40,0x40);
	224	state->m_tmap2= &machine.tilemap().create(tilemap_get_info_delegate(FUNC(darkhors_state::get_tile_info_1),state), TILEMAP_SCAN_ROWS,16,16, 0x40,0x40);
229	225	state->m_tmap->set_transparent_pen(0);
230	226	state->m_tmap2->set_transparent_pen(0);
231	227

trunk/src/mame/drivers/rmhaihai.c

r17672	r17673
56	56	DECLARE_WRITE8_MEMBER(themj_rombank_w);
57	57	DECLARE_WRITE8_MEMBER(adpcm_w);
58	58	DECLARE_DRIVER_INIT(rmhaihai);
	59	TILE_GET_INFO_MEMBER(get_bg_tile_info);
59	60	};
60	61
61	62
r17672	r17673
72	73	m_bg_tilemap->mark_tile_dirty(offset);
73	74	}
74	75
75		static TILE_GET_INFO( get_bg_tile_info )
	76	TILE_GET_INFO_MEMBER(rmhaihai_state::get_bg_tile_info)
76	77	{
77		rmhaihai_state *state = machine.driver_data<rmhaihai_state>();
78		int attr = state->m_colorram[tile_index];
79		int code = state->m_videoram[tile_index] + (state->m_gfxbank << 12) + ((attr & 0x07) << 8) + ((attr & 0x80) << 4);
80		int color = (state->m_gfxbank << 5) + (attr >> 3);
	78	int attr = m_colorram[tile_index];
	79	int code = m_videoram[tile_index] + (m_gfxbank << 12) + ((attr & 0x07) << 8) + ((attr & 0x80) << 4);
	80	int color = (m_gfxbank << 5) + (attr >> 3);
81	81
82		SET_TILE_INFO(0, code, color, 0);
	82	SET_TILE_INFO_MEMBER(0, code, color, 0);
83	83	}
84	84
85	85	static VIDEO_START( rmhaihai )
86	86	{
87	87	rmhaihai_state *state = machine.driver_data<rmhaihai_state>();
88		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,
	88	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(rmhaihai_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,
89	89	8, 8, 64, 32);
90	90	}
91	91

trunk/src/mame/drivers/midas.c

r17672	r17673
76	76	DECLARE_WRITE16_MEMBER(hammer_led_w);
77	77	DECLARE_WRITE16_MEMBER(midas_eeprom_w);
78	78	DECLARE_DRIVER_INIT(livequiz);
	79	TILE_GET_INFO_MEMBER(get_tile_info);
79	80	};
80	81
81	82
r17672	r17673
83	84	static SCREEN_UPDATE_IND16( midas );
84	85
85	86
86		static TILE_GET_INFO( get_tile_info )
	87	TILE_GET_INFO_MEMBER(midas_state::get_tile_info)
87	88	{
88		midas_state *state = machine.driver_data<midas_state>();
89		UINT16 code = state->m_gfxram[ tile_index + 0x7000 ];
90		SET_TILE_INFO(1, code & 0xfff, (code >> 12) & 0xf, TILE_FLIPXY( 0 ));
	89	UINT16 code = m_gfxram[ tile_index + 0x7000 ];
	90	SET_TILE_INFO_MEMBER(1, code & 0xfff, (code >> 12) & 0xf, TILE_FLIPXY( 0 ));
91	91	}
92	92
93	93	static VIDEO_START( midas )
r17672	r17673
95	95	midas_state *state = machine.driver_data<midas_state>();
96	96	state->m_gfxram = auto_alloc_array(machine, UINT16, 0x20000/2);
97	97
98		state->m_tmap = tilemap_create(   machine, get_tile_info, TILEMAP_SCAN_COLS,
99		8,8, 0x80,0x20   );
	98	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(midas_state::get_tile_info),state), TILEMAP_SCAN_COLS,8,8,0x80,0x20);
100	99
101	100	state->m_tmap->set_transparent_pen(0);
102	101	}

trunk/src/mame/drivers/galaxi.c

r17672	r17673
86	86	DECLARE_WRITE16_MEMBER(galaxi_500004_w);
87	87	DECLARE_CUSTOM_INPUT_MEMBER(ticket_r);
88	88	DECLARE_CUSTOM_INPUT_MEMBER(hopper_r);
	89	TILE_GET_INFO_MEMBER(get_bg1_tile_info);
	90	TILE_GET_INFO_MEMBER(get_bg2_tile_info);
	91	TILE_GET_INFO_MEMBER(get_bg3_tile_info);
	92	TILE_GET_INFO_MEMBER(get_bg4_tile_info);
	93	TILE_GET_INFO_MEMBER(get_fg_tile_info);
89	94	};
90	95
91	96
r17672	r17673
93	98	Video Hardware
94	99	***************************************************************************/
95	100
96		static TILE_GET_INFO( get_bg1_tile_info )
	101	TILE_GET_INFO_MEMBER(galaxi_state::get_bg1_tile_info)
97	102	{
98		galaxi_state *state = machine.driver_data<galaxi_state>();
99		UINT16 code = state->m_bg1_ram[tile_index];
100		SET_TILE_INFO(0, code, 0x10 + (code >> 12), 0);
	103	UINT16 code = m_bg1_ram[tile_index];
	104	SET_TILE_INFO_MEMBER(0, code, 0x10 + (code >> 12), 0);
101	105	}
102	106
103		static TILE_GET_INFO( get_bg2_tile_info )
	107	TILE_GET_INFO_MEMBER(galaxi_state::get_bg2_tile_info)
104	108	{
105		galaxi_state *state = machine.driver_data<galaxi_state>();
106		UINT16 code = state->m_bg2_ram[tile_index];
107		SET_TILE_INFO(0, code, 0x10 + (code >> 12), 0);
	109	UINT16 code = m_bg2_ram[tile_index];
	110	SET_TILE_INFO_MEMBER(0, code, 0x10 + (code >> 12), 0);
108	111	}
109	112
110		static TILE_GET_INFO( get_bg3_tile_info )
	113	TILE_GET_INFO_MEMBER(galaxi_state::get_bg3_tile_info)
111	114	{
112		galaxi_state *state = machine.driver_data<galaxi_state>();
113		UINT16 code = state->m_bg3_ram[tile_index];
114		SET_TILE_INFO(0, code, (code >> 12), 0);
	115	UINT16 code = m_bg3_ram[tile_index];
	116	SET_TILE_INFO_MEMBER(0, code, (code >> 12), 0);
115	117	}
116	118
117		static TILE_GET_INFO( get_bg4_tile_info )
	119	TILE_GET_INFO_MEMBER(galaxi_state::get_bg4_tile_info)
118	120	{
119		galaxi_state *state = machine.driver_data<galaxi_state>();
120		UINT16 code = state->m_bg4_ram[tile_index];
121		SET_TILE_INFO(0, code, (code >> 12), 0);
	121	UINT16 code = m_bg4_ram[tile_index];
	122	SET_TILE_INFO_MEMBER(0, code, (code >> 12), 0);
122	123	}
123	124
124		static TILE_GET_INFO( get_fg_tile_info )
	125	TILE_GET_INFO_MEMBER(galaxi_state::get_fg_tile_info)
125	126	{
126		galaxi_state *state = machine.driver_data<galaxi_state>();
127		UINT16 code = state->m_fg_ram[tile_index];
128		SET_TILE_INFO(1, code, 0x20 + (code >> 12), 0);
	127	UINT16 code = m_fg_ram[tile_index];
	128	SET_TILE_INFO_MEMBER(1, code, 0x20 + (code >> 12), 0);
129	129	}
130	130
131	131	WRITE16_MEMBER(galaxi_state::galaxi_bg1_w)
r17672	r17673
162	162	{
163	163	galaxi_state *state = machine.driver_data<galaxi_state>();
164	164
165		state->m_bg1_tmap = tilemap_create(machine, get_bg1_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
166		state->m_bg2_tmap = tilemap_create(machine, get_bg2_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
167		state->m_bg3_tmap = tilemap_create(machine, get_bg3_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
168		state->m_bg4_tmap = tilemap_create(machine, get_bg4_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
	165	state->m_bg1_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(galaxi_state::get_bg1_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
	166	state->m_bg2_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(galaxi_state::get_bg2_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
	167	state->m_bg3_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(galaxi_state::get_bg3_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
	168	state->m_bg4_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(galaxi_state::get_bg4_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 0x20, 0x10);
169	169
170		state->m_fg_tmap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 0x40, 0x20);
	170	state->m_fg_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(galaxi_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 0x40, 0x20);
171	171
172	172	state->m_bg1_tmap->set_transparent_pen(0);
173	173	state->m_bg2_tmap->set_transparent_pen(0);

trunk/src/mame/drivers/cabaret.c

r17672	r17673
51	51	DECLARE_WRITE8_MEMBER(cabaret_nmi_and_coins_w);
52	52	void show_out();
53	53	DECLARE_DRIVER_INIT(cabaret);
	54	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	55	TILE_GET_INFO_MEMBER(get_fg_tile_info);
54	56	};
55	57
56	58
r17672	r17673
74	76	m_bg_tilemap->mark_tile_dirty(offset);
75	77	}
76	78
77		static TILE_GET_INFO( get_bg_tile_info )
	79	TILE_GET_INFO_MEMBER(cabaret_state::get_bg_tile_info)
78	80	{
79		cabaret_state *state = machine.driver_data<cabaret_state>();
80		int code = state->m_bg_tile_ram[tile_index];
81		SET_TILE_INFO(1, code & 0xff, 0, 0);
	81	int code = m_bg_tile_ram[tile_index];
	82	SET_TILE_INFO_MEMBER(1, code & 0xff, 0, 0);
82	83	}
83	84
84		static TILE_GET_INFO( get_fg_tile_info )
	85	TILE_GET_INFO_MEMBER(cabaret_state::get_fg_tile_info)
85	86	{
86		cabaret_state *state = machine.driver_data<cabaret_state>();
87		int code = state->m_fg_tile_ram[tile_index] | (state->m_fg_color_ram[tile_index] << 8);
	87	int code = m_fg_tile_ram[tile_index] | (m_fg_color_ram[tile_index] << 8);
88	88	int tile = code & 0x1fff;
89		SET_TILE_INFO(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
	89	SET_TILE_INFO_MEMBER(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
90	90	}
91	91
92	92	WRITE8_MEMBER(cabaret_state::fg_tile_w)
r17672	r17673
104	104	static VIDEO_START(cabaret)
105	105	{
106	106	cabaret_state *state = machine.driver_data<cabaret_state>();
107		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,   8,  32,   64, 8);
108		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
	107	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cabaret_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  32,   64, 8);
	108	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cabaret_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
109	109	state->m_fg_tilemap->set_transparent_pen(0);
110	110	state->m_bg_tilemap->set_scroll_cols(64);
111	111	}

trunk/src/mame/drivers/olibochu.c

r17672	r17673
81	81	DECLARE_WRITE8_MEMBER(olibochu_colorram_w);
82	82	DECLARE_WRITE8_MEMBER(olibochu_flipscreen_w);
83	83	DECLARE_WRITE8_MEMBER(sound_command_w);
	84	TILE_GET_INFO_MEMBER(get_bg_tile_info);
84	85	};
85	86
86	87
r17672	r17673
146	147	/* other bits are used, but unknown */
147	148	}
148	149
149		static TILE_GET_INFO( get_bg_tile_info )
	150	TILE_GET_INFO_MEMBER(olibochu_state::get_bg_tile_info)
150	151	{
151		olibochu_state *state = machine.driver_data<olibochu_state>();
152		int attr = state->m_colorram[tile_index];
153		int code = state->m_videoram[tile_index] + ((attr & 0x20) << 3);
	152	int attr = m_colorram[tile_index];
	153	int code = m_videoram[tile_index] + ((attr & 0x20) << 3);
154	154	int color = (attr & 0x1f) + 0x20;
155	155	int flags = ((attr & 0x40) ? TILE_FLIPX : 0) | ((attr & 0x80) ? TILE_FLIPY : 0);
156	156
157		SET_TILE_INFO(0, code, color, flags);
	157	SET_TILE_INFO_MEMBER(0, code, color, flags);
158	158	}
159	159
160	160	static VIDEO_START( olibochu )
161	161	{
162	162	olibochu_state *state = machine.driver_data<olibochu_state>();
163		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	163	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(olibochu_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
164	164	}
165	165
166	166	static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )

trunk/src/mame/drivers/kingdrby.c

r17672	r17673
105	105	DECLARE_READ8_MEMBER(key_matrix_r);
106	106	DECLARE_READ8_MEMBER(sound_cmd_r);
107	107	DECLARE_WRITE8_MEMBER(outportb_w);
	108	TILE_GET_INFO_MEMBER(get_sc0_tile_info);
	109	TILE_GET_INFO_MEMBER(get_sc1_tile_info);
108	110	};
109	111
110	112
r17672	r17673
129	131	---- ---x tile bank
130	132	*/
131	133
132		static TILE_GET_INFO( get_sc0_tile_info )
	134	TILE_GET_INFO_MEMBER(kingdrby_state::get_sc0_tile_info)
133	135	{
134		kingdrby_state *state = machine.driver_data<kingdrby_state>();
135		int tile = state->m_vram[tile_index] | state->m_attr[tile_index]<<8;
136		int color = (state->m_attr[tile_index] & 0x06)>>1;
	136	int tile = m_vram[tile_index] | m_attr[tile_index]<<8;
	137	int color = (m_attr[tile_index] & 0x06)>>1;
137	138
138	139	tile&=0x1ff;
139	140
140		SET_TILE_INFO(
	141	SET_TILE_INFO_MEMBER(
141	142	1,
142	143	tile,
143	144	color|0x40,
144	145	0);
145	146	}
146	147
147		static TILE_GET_INFO( get_sc1_tile_info )
	148	TILE_GET_INFO_MEMBER(kingdrby_state::get_sc1_tile_info)
148	149	{
149		kingdrby_state *state = machine.driver_data<kingdrby_state>();
150		int tile = state->m_vram[tile_index] | state->m_attr[tile_index]<<8;
151		int color = (state->m_attr[tile_index] & 0x06)>>1;
	150	int tile = m_vram[tile_index] | m_attr[tile_index]<<8;
	151	int color = (m_attr[tile_index] & 0x06)>>1;
152	152
153	153	tile&=0x1ff;
154	154	//original 0xc
155	155	//0x13
156	156	//
157	157
158		SET_TILE_INFO(
	158	SET_TILE_INFO_MEMBER(
159	159	1,
160	160	tile,
161	161	color|0x40,
162	162	0);
163	163
164		tileinfo.category = (state->m_attr[tile_index] & 0x08)>>3;
	164	tileinfo.category = (m_attr[tile_index] & 0x08)>>3;
165	165	}
166	166
167	167	static VIDEO_START(kingdrby)
168	168	{
169	169	kingdrby_state *state = machine.driver_data<kingdrby_state>();
170		state->m_sc0_tilemap = tilemap_create(machine, get_sc0_tile_info,TILEMAP_SCAN_ROWS,8,8,32,24);
171		state->m_sc1_tilemap = tilemap_create(machine, get_sc1_tile_info,TILEMAP_SCAN_ROWS,8,8,32,24);
172		state->m_sc0w_tilemap = tilemap_create(machine, get_sc0_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32);
	170	state->m_sc0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(kingdrby_state::get_sc0_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,24);
	171	state->m_sc1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(kingdrby_state::get_sc1_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,24);
	172	state->m_sc0w_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(kingdrby_state::get_sc0_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32);
173	173
174	174	state->m_sc1_tilemap->set_transparent_pen(0);
175	175	}

trunk/src/mame/drivers/r2dx_v33.c

r17672	r17673
51	51	DECLARE_DRIVER_INIT(rdx_v33);
52	52	DECLARE_DRIVER_INIT(nzerotea);
53	53	DECLARE_DRIVER_INIT(zerotm2k);
	54	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	55	TILE_GET_INFO_MEMBER(get_md_tile_info);
	56	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	57	TILE_GET_INFO_MEMBER(get_tx_tile_info);
54	58	};
55	59
56	60
r17672	r17673
58	62	static UINT16 *bg_vram,*md_vram,*fg_vram,*tx_vram;
59	63	static tilemap_t *bg_tilemap,*md_tilemap,*fg_tilemap,*tx_tilemap;
60	64
61		static TILE_GET_INFO( get_bg_tile_info )
	65	TILE_GET_INFO_MEMBER(r2dx_v33_state::get_bg_tile_info)
62	66	{
63	67	int tile = bg_vram[tile_index];
64	68	int color = (tile>>12)&0xf;
65	69
66	70	tile &= 0xfff;
67	71
68		SET_TILE_INFO(1,tile + 0x0000,color,0);
	72	SET_TILE_INFO_MEMBER(1,tile + 0x0000,color,0);
69	73	}
70	74
71		static TILE_GET_INFO( get_md_tile_info )
	75	TILE_GET_INFO_MEMBER(r2dx_v33_state::get_md_tile_info)
72	76	{
73	77	int tile = md_vram[tile_index];
74	78	int color = (tile>>12)&0xf;
75	79
76	80	tile &= 0xfff;
77	81
78		SET_TILE_INFO(2,tile + 0x2000,color,0);
	82	SET_TILE_INFO_MEMBER(2,tile + 0x2000,color,0);
79	83	}
80	84
81		static TILE_GET_INFO( get_fg_tile_info )
	85	TILE_GET_INFO_MEMBER(r2dx_v33_state::get_fg_tile_info)
82	86	{
83	87	int tile = fg_vram[tile_index];
84	88	int color = (tile>>12)&0xf;
85	89
86	90	tile &= 0xfff;
87	91
88		SET_TILE_INFO(3,tile + 0x1000,color,0);
	92	SET_TILE_INFO_MEMBER(3,tile + 0x1000,color,0);
89	93	}
90	94
91		static TILE_GET_INFO( get_tx_tile_info )
	95	TILE_GET_INFO_MEMBER(r2dx_v33_state::get_tx_tile_info)
92	96	{
93	97	int tile = tx_vram[tile_index];
94	98	int color = (tile>>12)&0xf;
95	99
96	100	tile &= 0xfff;
97	101
98		SET_TILE_INFO(4,tile,color,0);
	102	SET_TILE_INFO_MEMBER(4,tile,color,0);
99	103	}
100	104
101	105	/* copied from Legionnaire */
r17672	r17673
187	191
188	192	static VIDEO_START( rdx_v33 )
189	193	{
190		bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,16,16,32,32);
191		md_tilemap = tilemap_create(machine, get_md_tile_info, TILEMAP_SCAN_ROWS,16,16,32,32);
192		fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,16,16,32,32);
193		tx_tilemap = tilemap_create(machine, get_tx_tile_info, TILEMAP_SCAN_ROWS,8, 8, 64,32);
	194	r2dx_v33_state *state = machine.driver_data<r2dx_v33_state>();
	195	bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(r2dx_v33_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,16,16,32,32);
	196	md_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(r2dx_v33_state::get_md_tile_info),state), TILEMAP_SCAN_ROWS,16,16,32,32);
	197	fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(r2dx_v33_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,16,16,32,32);
	198	tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(r2dx_v33_state::get_tx_tile_info),state), TILEMAP_SCAN_ROWS,8, 8, 64,32);
194	199
195	200	bg_tilemap->set_transparent_pen(15);
196	201	md_tilemap->set_transparent_pen(15);

trunk/src/mame/drivers/warpsped.c

r17672	r17673
102	102	DECLARE_WRITE8_MEMBER(warpspeed_hardware_w);
103	103	DECLARE_WRITE8_MEMBER(warpspeed_vidram_w);
104	104	DECLARE_DRIVER_INIT(warpspeed);
	105	TILE_GET_INFO_MEMBER(get_warpspeed_text_tile_info);
	106	TILE_GET_INFO_MEMBER(get_warpspeed_starfield_tile_info);
105	107	};
106	108
107	109	WRITE8_MEMBER(warpspeed_state::warpspeed_hardware_w)
r17672	r17673
109	111	m_regs[offset] = data;
110	112	}
111	113
112		static TILE_GET_INFO( get_warpspeed_text_tile_info )
	114	TILE_GET_INFO_MEMBER(warpspeed_state::get_warpspeed_text_tile_info)
113	115	{
114		warpspeed_state *state = machine.driver_data<warpspeed_state>();
115	116
116		UINT8 code = state->m_videoram[tile_index] & 0x3f;
117		SET_TILE_INFO(0, code, 0, 0);
	117	UINT8 code = m_videoram[tile_index] & 0x3f;
	118	SET_TILE_INFO_MEMBER(0, code, 0, 0);
118	119	}
119	120
120		static TILE_GET_INFO( get_warpspeed_starfield_tile_info )
	121	TILE_GET_INFO_MEMBER(warpspeed_state::get_warpspeed_starfield_tile_info)
121	122	{
122	123	UINT8 code = 0x3f;
123	124	if ( tile_index & 1 )
124	125	{
125		code = machine.root_device().memregion("starfield")->base()[tile_index >> 1] & 0x3f;
	126	code = machine().root_device().memregion("starfield")->base()[tile_index >> 1] & 0x3f;
126	127	}
127		SET_TILE_INFO(1, code, 0, 0);
	128	SET_TILE_INFO_MEMBER(1, code, 0, 0);
128	129	}
129	130
130	131	WRITE8_MEMBER(warpspeed_state::warpspeed_vidram_w)
r17672	r17673
137	138	static VIDEO_START( warpspeed )
138	139	{
139	140	warpspeed_state *state = machine.driver_data<warpspeed_state>();
140		state->m_text_tilemap = tilemap_create(machine, get_warpspeed_text_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	141	state->m_text_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(warpspeed_state::get_warpspeed_text_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
141	142	state->m_text_tilemap->set_transparent_pen(0);
142		state->m_starfield_tilemap = tilemap_create(machine, get_warpspeed_starfield_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	143	state->m_starfield_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(warpspeed_state::get_warpspeed_starfield_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
143	144	state->m_starfield_tilemap->mark_all_dirty();
144	145	}
145	146

trunk/src/mame/drivers/looping.c

r17672	r17673
138	138	DECLARE_WRITE8_MEMBER(ay_enable_w);
139	139	DECLARE_WRITE8_MEMBER(speech_enable_w);
140	140	DECLARE_DRIVER_INIT(looping);
	141	TILE_GET_INFO_MEMBER(get_tile_info);
141	142	};
142	143
143	144
r17672	r17673
195	196	*
196	197	*************************************/
197	198
198		static TILE_GET_INFO( get_tile_info )
	199	TILE_GET_INFO_MEMBER(looping_state::get_tile_info)
199	200	{
200		looping_state *state = machine.driver_data<looping_state>();
201		int tile_number = state->m_videoram[tile_index];
202		int color = state->m_colorram[(tile_index & 0x1f) * 2 + 1] & 0x07;
203		SET_TILE_INFO(0, tile_number, color, 0);
	201	int tile_number = m_videoram[tile_index];
	202	int color = m_colorram[(tile_index & 0x1f) * 2 + 1] & 0x07;
	203	SET_TILE_INFO_MEMBER(0, tile_number, color, 0);
204	204	}
205	205
206	206
r17672	r17673
208	208	{
209	209	looping_state *state = machine.driver_data<looping_state>();
210	210
211		state->m_bg_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8,8, 32,32);
	211	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(looping_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8,8, 32,32);
212	212
213	213	state->m_bg_tilemap->set_scroll_cols(0x20);
214	214	}

trunk/src/mame/drivers/1945kiii.c

r17672	r17673
74	74	DECLARE_WRITE16_MEMBER(k3_scrollx_w);
75	75	DECLARE_WRITE16_MEMBER(k3_scrolly_w);
76	76	DECLARE_WRITE16_MEMBER(k3_soundbanks_w);
	77	TILE_GET_INFO_MEMBER(get_k3_bg_tile_info);
77	78	};
78	79
79	80
r17672	r17673
83	84	m_bg_tilemap->mark_tile_dirty(offset);
84	85	}
85	86
86		static TILE_GET_INFO( get_k3_bg_tile_info )
	87	TILE_GET_INFO_MEMBER(k3_state::get_k3_bg_tile_info)
87	88	{
88		k3_state *state = machine.driver_data<k3_state>();
89		int tileno = state->m_bgram[tile_index];
90		SET_TILE_INFO(1, tileno, 0, 0);
	89	int tileno = m_bgram[tile_index];
	90	SET_TILE_INFO_MEMBER(1, tileno, 0, 0);
91	91	}
92	92
93	93	static VIDEO_START(k3)
94	94	{
95	95	k3_state *state = machine.driver_data<k3_state>();
96		state->m_bg_tilemap = tilemap_create(machine, get_k3_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 32, 64);
	96	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(k3_state::get_k3_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 64);
97	97	}
98	98
99	99	static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )

trunk/src/mame/drivers/statriv2.c

r17672	r17673
104	104	DECLARE_DRIVER_INIT(addr_lmhe);
105	105	DECLARE_DRIVER_INIT(addr_xhl);
106	106	DECLARE_DRIVER_INIT(laserdisc);
	107	TILE_GET_INFO_MEMBER(horizontal_tile_info);
	108	TILE_GET_INFO_MEMBER(vertical_tile_info);
107	109	};
108	110
109	111
r17672	r17673
116	118	*
117	119	*************************************/
118	120
119		static TILE_GET_INFO( horizontal_tile_info )
	121	TILE_GET_INFO_MEMBER(statriv2_state::horizontal_tile_info)
120	122	{
121		statriv2_state *state = machine.driver_data<statriv2_state>();
122		UINT8 *videoram = state->m_videoram;
	123	UINT8 *videoram = m_videoram;
123	124	int code = videoram[0x400+tile_index];
124	125	int attr = videoram[tile_index] & 0x3f;
125	126
126		SET_TILE_INFO(0, code, attr, 0);
	127	SET_TILE_INFO_MEMBER(0, code, attr, 0);
127	128	}
128	129
129		static TILE_GET_INFO( vertical_tile_info )
	130	TILE_GET_INFO_MEMBER(statriv2_state::vertical_tile_info)
130	131	{
131		statriv2_state *state = machine.driver_data<statriv2_state>();
132		UINT8 *videoram = state->m_videoram;
	132	UINT8 *videoram = m_videoram;
133	133	int code = videoram[0x400+tile_index];
134	134	int attr = videoram[tile_index] & 0x3f;
135	135
136		SET_TILE_INFO(0, ((code & 0x7f) << 1) | ((code & 0x80) >> 7), attr, 0);
	136	SET_TILE_INFO_MEMBER(0, ((code & 0x7f) << 1) | ((code & 0x80) >> 7), attr, 0);
137	137	}
138	138
139	139
r17672	r17673
158	158	static VIDEO_START( horizontal )
159	159	{
160	160	statriv2_state *state = machine.driver_data<statriv2_state>();
161		state->m_tilemap = tilemap_create(machine, horizontal_tile_info ,TILEMAP_SCAN_ROWS, 8,15, 64,16);
	161	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(statriv2_state::horizontal_tile_info),state) ,TILEMAP_SCAN_ROWS, 8,15, 64,16);
162	162	}
163	163
164	164	static VIDEO_START( vertical )
165	165	{
166	166	statriv2_state *state = machine.driver_data<statriv2_state>();
167		state->m_tilemap = tilemap_create(machine, vertical_tile_info, TILEMAP_SCAN_ROWS, 8,8, 32,32);
	167	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(statriv2_state::vertical_tile_info),state), TILEMAP_SCAN_ROWS, 8,8, 32,32);
168	168	}
169	169
170	170

trunk/src/mame/drivers/d9final.c

r17672	r17673
42	42	DECLARE_WRITE8_MEMBER(sc0_cram);
43	43	DECLARE_WRITE8_MEMBER(d9final_bank_w);
44	44	DECLARE_READ8_MEMBER(prot_latch_r);
	45	TILE_GET_INFO_MEMBER(get_sc0_tile_info);
45	46	};
46	47
47	48
48	49
49		static TILE_GET_INFO( get_sc0_tile_info )
	50	TILE_GET_INFO_MEMBER(d9final_state::get_sc0_tile_info)
50	51	{
51		d9final_state *state = machine.driver_data<d9final_state>();
52		int tile = ((state->m_hi_vram[tile_index] & 0x3f)<<8) | state->m_lo_vram[tile_index];
53		int color = state->m_cram[tile_index] & 0x3f;
	52	int tile = ((m_hi_vram[tile_index] & 0x3f)<<8) | m_lo_vram[tile_index];
	53	int color = m_cram[tile_index] & 0x3f;
54	54
55		SET_TILE_INFO(
	55	SET_TILE_INFO_MEMBER(
56	56	0,
57	57	tile,
58	58	color,
r17672	r17673
62	62	static VIDEO_START(d9final)
63	63	{
64	64	d9final_state *state = machine.driver_data<d9final_state>();
65		state->m_sc0_tilemap = tilemap_create(machine, get_sc0_tile_info,TILEMAP_SCAN_ROWS,8,8,64,32);
	65	state->m_sc0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(d9final_state::get_sc0_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
66	66	}
67	67
68	68	static SCREEN_UPDATE_IND16(d9final)

trunk/src/mame/drivers/acommand.c

r17672	r17673
88	88	DECLARE_READ16_MEMBER(ac_devices_r);
89	89	DECLARE_WRITE16_MEMBER(ac_devices_w);
90	90	DECLARE_WRITE16_MEMBER(ac_unk2_w);
	91	TILEMAP_MAPPER_MEMBER(bg_scan);
	92	TILE_GET_INFO_MEMBER(ac_get_bg_tile_info);
	93	TILE_GET_INFO_MEMBER(ac_get_tx_tile_info);
91	94	};
92	95
93	96
94	97
95		static TILEMAP_MAPPER( bg_scan )
	98	TILEMAP_MAPPER_MEMBER(acommand_state::bg_scan)
96	99	{
97	100	/* logical (col,row) -> memory offset */
98	101	return (row & 0x0f) + ((col & 0xff) << 4) + ((row & 0x70) << 8);
99	102	}
100	103
101		static TILE_GET_INFO( ac_get_bg_tile_info )
	104	TILE_GET_INFO_MEMBER(acommand_state::ac_get_bg_tile_info)
102	105	{
103		acommand_state *state = machine.driver_data<acommand_state>();
104		int code = state->m_ac_bgvram[tile_index];
105		SET_TILE_INFO(
	106	int code = m_ac_bgvram[tile_index];
	107	SET_TILE_INFO_MEMBER(
106	108	1,
107	109	code & 0xfff,
108	110	(code & 0xf000) >> 12,
109	111	0);
110	112	}
111	113
112		static TILE_GET_INFO( ac_get_tx_tile_info )
	114	TILE_GET_INFO_MEMBER(acommand_state::ac_get_tx_tile_info)
113	115	{
114		acommand_state *state = machine.driver_data<acommand_state>();
115		int code = state->m_ac_txvram[tile_index];
116		SET_TILE_INFO(
	116	int code = m_ac_txvram[tile_index];
	117	SET_TILE_INFO_MEMBER(
117	118	0,
118	119	code & 0xfff,
119	120	(code & 0xf000) >> 12,
r17672	r17673
182	183	static VIDEO_START( acommand )
183	184	{
184	185	acommand_state *state = machine.driver_data<acommand_state>();
185		state->m_tx_tilemap = tilemap_create(machine, ac_get_tx_tile_info,TILEMAP_SCAN_COLS,8,8,512,32);
186		state->m_bg_tilemap = tilemap_create(machine, ac_get_bg_tile_info,bg_scan,16,16,256,16);
	186	state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(acommand_state::ac_get_tx_tile_info),state),TILEMAP_SCAN_COLS,8,8,512,32);
	187	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(acommand_state::ac_get_bg_tile_info),state),tilemap_mapper_delegate(FUNC(acommand_state::bg_scan),state),16,16,256,16);
187	188
188	189	state->m_ac_vregs = auto_alloc_array(machine, UINT16, 0x80/2);
189	190

trunk/src/mame/drivers/ppmast93.c

r17672	r17673
152	152	DECLARE_WRITE8_MEMBER(ppmast93_bgram_w);
153	153	DECLARE_WRITE8_MEMBER(ppmast93_port4_w);
154	154	DECLARE_WRITE8_MEMBER(ppmast_sound_w);
	155	TILE_GET_INFO_MEMBER(get_ppmast93_bg_tile_info);
	156	TILE_GET_INFO_MEMBER(get_ppmast93_fg_tile_info);
155	157	};
156	158
157	159
r17672	r17673
322	324	GFXDECODE_ENTRY( "gfx1", 0, tiles8x8_layout, 0, 16 )
323	325	GFXDECODE_END
324	326
325		static TILE_GET_INFO( get_ppmast93_bg_tile_info )
	327	TILE_GET_INFO_MEMBER(ppmast93_state::get_ppmast93_bg_tile_info)
326	328	{
327		ppmast93_state *state = machine.driver_data<ppmast93_state>();
328		int code = (state->m_bgram[tile_index*2+1] << 8) | state->m_bgram[tile_index*2];
329		SET_TILE_INFO(
	329	int code = (m_bgram[tile_index*2+1] << 8) | m_bgram[tile_index*2];
	330	SET_TILE_INFO_MEMBER(
330	331	0,
331	332	code & 0x0fff,
332	333	(code & 0xf000) >> 12,
333	334	0);
334	335	}
335	336
336		static TILE_GET_INFO( get_ppmast93_fg_tile_info )
	337	TILE_GET_INFO_MEMBER(ppmast93_state::get_ppmast93_fg_tile_info)
337	338	{
338		ppmast93_state *state = machine.driver_data<ppmast93_state>();
339		int code = (state->m_fgram[tile_index*2+1] << 8) | state->m_fgram[tile_index*2];
340		SET_TILE_INFO(
	339	int code = (m_fgram[tile_index*2+1] << 8) | m_fgram[tile_index*2];
	340	SET_TILE_INFO_MEMBER(
341	341	0,
342	342	(code & 0x0fff)+0x1000,
343	343	(code & 0xf000) >> 12,
r17672	r17673
347	347	static VIDEO_START( ppmast93 )
348	348	{
349	349	ppmast93_state *state = machine.driver_data<ppmast93_state>();
350		state->m_bg_tilemap = tilemap_create(machine, get_ppmast93_bg_tile_info,TILEMAP_SCAN_ROWS,8,8,32, 32);
351		state->m_fg_tilemap = tilemap_create(machine, get_ppmast93_fg_tile_info,TILEMAP_SCAN_ROWS,8,8,32, 32);
	350	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ppmast93_state::get_ppmast93_bg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32, 32);
	351	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ppmast93_state::get_ppmast93_fg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32, 32);
352	352
353	353	state->m_fg_tilemap->set_transparent_pen(0);
354	354	}

trunk/src/mame/drivers/goldnpkr.c

r17672	r17673
997	997	DECLARE_DRIVER_INIT(vkdlswwc);
998	998	DECLARE_DRIVER_INIT(vkdlswwr);
999	999	DECLARE_DRIVER_INIT(vkdlswwv);
	1000	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	1001	TILE_GET_INFO_MEMBER(wcrdxtnd_get_bg_tile_info);
1000	1002	};
1001	1003
1002	1004
r17672	r17673
1017	1019	m_bg_tilemap->mark_tile_dirty(offset);
1018	1020	}
1019	1021
1020		static TILE_GET_INFO( get_bg_tile_info )
	1022	TILE_GET_INFO_MEMBER(goldnpkr_state::get_bg_tile_info)
1021	1023	{
1022		goldnpkr_state *state = machine.driver_data<goldnpkr_state>();
1023	1024	/*  - bits -
1024	1025	7654 3210
1025	1026	--xx xx--   tiles color.
r17672	r17673
1028	1029	xx-- ----   unused.
1029	1030	*/
1030	1031
1031		int attr = state->m_colorram[tile_index];
1032		int code = ((attr & 1) << 8) | state->m_videoram[tile_index];
	1032	int attr = m_colorram[tile_index];
	1033	int code = ((attr & 1) << 8) | m_videoram[tile_index];
1033	1034	int bank = (attr & 0x02) >> 1;   /* bit 1 switch the gfx banks */
1034	1035	int color = (attr & 0x3c) >> 2;   /* bits 2-3-4-5 for color */
1035	1036
1036		SET_TILE_INFO(bank, code, color, 0);
	1037	SET_TILE_INFO_MEMBER(bank, code, color, 0);
1037	1038	}
1038	1039
1039		static TILE_GET_INFO( wcrdxtnd_get_bg_tile_info )
	1040	TILE_GET_INFO_MEMBER(goldnpkr_state::wcrdxtnd_get_bg_tile_info)
1040	1041	{
1041		goldnpkr_state *state = machine.driver_data<goldnpkr_state>();
1042	1042	/* 16 graphics banks system for VK extended (up & down) PCB's
1043	1043
1044	1044	- bits -
r17672	r17673
1047	1047	xx-- --xx   tiles bank.
1048	1048	*/
1049	1049
1050		int attr = state->m_colorram[tile_index];
1051		int code = ((attr & 1) << 8) | state->m_videoram[tile_index];
	1050	int attr = m_colorram[tile_index];
	1051	int code = ((attr & 1) << 8) | m_videoram[tile_index];
1052	1052	int bank = (attr & 0x03) + ((attr & 0xc0) >> 4);   /* bits 0, 1, 6 & 7 switch the gfx banks */
1053	1053	int color = (attr & 0x3c) >> 2;   /* bits 2-3-4-5 for color */
1054	1054
1055		SET_TILE_INFO(bank, code, color, 0);
	1055	SET_TILE_INFO_MEMBER(bank, code, color, 0);
1056	1056	}
1057	1057
1058	1058	static VIDEO_START( goldnpkr )
1059	1059	{
1060	1060	goldnpkr_state *state = machine.driver_data<goldnpkr_state>();
1061		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	1061	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(goldnpkr_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
1062	1062	}
1063	1063
1064	1064	static VIDEO_START( wcrdxtnd )
1065	1065	{
1066	1066	goldnpkr_state *state = machine.driver_data<goldnpkr_state>();
1067		state->m_bg_tilemap = tilemap_create(machine, wcrdxtnd_get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	1067	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(goldnpkr_state::wcrdxtnd_get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
1068	1068	}
1069	1069
1070	1070	static SCREEN_UPDATE_IND16( goldnpkr )

trunk/src/mame/drivers/pkscram.c

r17672	r17673
38	38	DECLARE_WRITE16_MEMBER(pkscramble_mdtilemap_w);
39	39	DECLARE_WRITE16_MEMBER(pkscramble_bgtilemap_w);
40	40	DECLARE_WRITE16_MEMBER(pkscramble_output_w);
	41	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	42	TILE_GET_INFO_MEMBER(get_md_tile_info);
	43	TILE_GET_INFO_MEMBER(get_fg_tile_info);
41	44	};
42	45
43	46
r17672	r17673
184	187	INPUT_PORTS_END
185	188
186	189
187		static TILE_GET_INFO( get_bg_tile_info )
	190	TILE_GET_INFO_MEMBER(pkscram_state::get_bg_tile_info)
188	191	{
189		pkscram_state *state = machine.driver_data<pkscram_state>();
190		int tile  = state->m_pkscramble_bgtilemap_ram[tile_index*2];
191		int color = state->m_pkscramble_bgtilemap_ram[tile_index*2 + 1] & 0x7f;
	192	int tile  = m_pkscramble_bgtilemap_ram[tile_index*2];
	193	int color = m_pkscramble_bgtilemap_ram[tile_index*2 + 1] & 0x7f;
192	194
193		SET_TILE_INFO(0,tile,color,0);
	195	SET_TILE_INFO_MEMBER(0,tile,color,0);
194	196	}
195	197
196		static TILE_GET_INFO( get_md_tile_info )
	198	TILE_GET_INFO_MEMBER(pkscram_state::get_md_tile_info)
197	199	{
198		pkscram_state *state = machine.driver_data<pkscram_state>();
199		int tile  = state->m_pkscramble_mdtilemap_ram[tile_index*2];
200		int color = state->m_pkscramble_mdtilemap_ram[tile_index*2 + 1] & 0x7f;
	200	int tile  = m_pkscramble_mdtilemap_ram[tile_index*2];
	201	int color = m_pkscramble_mdtilemap_ram[tile_index*2 + 1] & 0x7f;
201	202
202		SET_TILE_INFO(0,tile,color,0);
	203	SET_TILE_INFO_MEMBER(0,tile,color,0);
203	204	}
204	205
205		static TILE_GET_INFO( get_fg_tile_info )
	206	TILE_GET_INFO_MEMBER(pkscram_state::get_fg_tile_info)
206	207	{
207		pkscram_state *state = machine.driver_data<pkscram_state>();
208		int tile  = state->m_pkscramble_fgtilemap_ram[tile_index*2];
209		int color = state->m_pkscramble_fgtilemap_ram[tile_index*2 + 1] & 0x7f;
	208	int tile  = m_pkscramble_fgtilemap_ram[tile_index*2];
	209	int color = m_pkscramble_fgtilemap_ram[tile_index*2 + 1] & 0x7f;
210	210
211		SET_TILE_INFO(0,tile,color,0);
	211	SET_TILE_INFO_MEMBER(0,tile,color,0);
212	212	}
213	213
214	214	static TIMER_DEVICE_CALLBACK( scanline_callback )
r17672	r17673
233	233	static VIDEO_START( pkscramble )
234	234	{
235	235	pkscram_state *state = machine.driver_data<pkscram_state>();
236		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8,32,32);
237		state->m_md_tilemap = tilemap_create(machine, get_md_tile_info, TILEMAP_SCAN_ROWS, 8, 8,32,32);
238		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8,32,32);
	236	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pkscram_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8,32,32);
	237	state->m_md_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pkscram_state::get_md_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8,32,32);
	238	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pkscram_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8,32,32);
239	239
240	240	state->m_md_tilemap->set_transparent_pen(15);
241	241	state->m_fg_tilemap->set_transparent_pen(15);

trunk/src/mame/drivers/superwng.c

r17672	r17673
67	67	DECLARE_WRITE8_MEMBER(superwng_cointcnt2_w);
68	68	DECLARE_WRITE8_MEMBER(superwng_hopper_w);
69	69	DECLARE_READ8_MEMBER(superwng_sound_byte_r);
	70	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	71	TILE_GET_INFO_MEMBER(get_fg_tile_info);
70	72	};
71	73
72		static TILE_GET_INFO( get_bg_tile_info )
	74	TILE_GET_INFO_MEMBER(superwng_state::get_bg_tile_info)
73	75	{
74		superwng_state *state = machine.driver_data<superwng_state>();
75		int code = state->m_videoram_bg[tile_index];
76		int attr = state->m_colorram_bg[tile_index];
	76	int code = m_videoram_bg[tile_index];
	77	int attr = m_colorram_bg[tile_index];
77	78
78	79	code= (code&0x7f) | ((attr&0x40)<<1) | ((code&0x80)<<1);
79		code|=state->m_tile_bank?0x200:0;
	80	code|=m_tile_bank?0x200:0;
80	81
81	82	int flipx=(attr&0x80) ? TILE_FLIPX : 0;
82	83	int flipy=(attr&0x80) ? TILE_FLIPY : 0;
83	84
84		SET_TILE_INFO(0, code, attr & 0xf, flipx|flipy);
	85	SET_TILE_INFO_MEMBER(0, code, attr & 0xf, flipx|flipy);
85	86	}
86	87
87		static TILE_GET_INFO( get_fg_tile_info )
	88	TILE_GET_INFO_MEMBER(superwng_state::get_fg_tile_info)
88	89	{
89		superwng_state *state = machine.driver_data<superwng_state>();
90		int code = state->m_videoram_fg[tile_index];
91		int attr = state->m_colorram_fg[tile_index];
	90	int code = m_videoram_fg[tile_index];
	91	int attr = m_colorram_fg[tile_index];
92	92
93	93	code= (code&0x7f) | ((attr&0x40)<<1) | ((code&0x80)<<1);
94	94
95		code|=state->m_tile_bank?0x200:0;
	95	code|=m_tile_bank?0x200:0;
96	96
97	97	int flipx=(attr&0x80) ? TILE_FLIPX : 0;
98	98	int flipy=(attr&0x80) ? TILE_FLIPY : 0;
99	99
100		SET_TILE_INFO(0, code, attr & 0xf, flipx|flipy);
	100	SET_TILE_INFO_MEMBER(0, code, attr & 0xf, flipx|flipy);
101	101	}
102	102
103	103	static VIDEO_START( superwng )
104	104	{
105	105	superwng_state *state = machine.driver_data<superwng_state>();
106		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
107		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	106	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(superwng_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	107	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(superwng_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
108	108
109	109	state->m_bg_tilemap->set_scrollx(0, 64);
110	110	}

trunk/src/mame/drivers/silvmil.c

r17672	r17673
105	105
106	106
107	107	DECLARE_DRIVER_INIT(silvmil);
	108	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	109	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	110	TILEMAP_MAPPER_MEMBER(deco16_scan_rows);
108	111	};
109	112
110	113
111		static TILE_GET_INFO( get_bg_tile_info )
	114	TILE_GET_INFO_MEMBER(silvmil_state::get_bg_tile_info)
112	115	{
113		silvmil_state *state = machine.driver_data<silvmil_state>();
114		int data  = state->m_bg_videoram[tile_index];
	116	int data  = m_bg_videoram[tile_index];
115	117	int tile  = data & 0x3ff;
116	118	int color = (data >> 12) & 0x0f;
117		int bank = state->m_silvmil_tilebank[(data&0xc00)>>10]*0x400;
	119	int bank = m_silvmil_tilebank[(data&0xc00)>>10]*0x400;
118	120
119		SET_TILE_INFO(1, tile + bank, color + 0x20, 0);
	121	SET_TILE_INFO_MEMBER(1, tile + bank, color + 0x20, 0);
120	122	}
121	123
122		static TILE_GET_INFO( get_fg_tile_info )
	124	TILE_GET_INFO_MEMBER(silvmil_state::get_fg_tile_info)
123	125	{
124		silvmil_state *state = machine.driver_data<silvmil_state>();
125		int data  = state->m_fg_videoram[tile_index];
	126	int data  = m_fg_videoram[tile_index];
126	127	int tile  = data & 0x3ff;
127	128	int color = (data >> 12) & 0x0f;
128		int bank = state->m_silvmil_tilebank[(data&0xc00)>>10]*0x400;
	129	int bank = m_silvmil_tilebank[(data&0xc00)>>10]*0x400;
129	130
130		SET_TILE_INFO(1, tile + bank, color + 0x10, 0);
	131	SET_TILE_INFO_MEMBER(1, tile + bank, color + 0x10, 0);
131	132	}
132	133
133		static TILEMAP_MAPPER( deco16_scan_rows )
	134	TILEMAP_MAPPER_MEMBER(silvmil_state::deco16_scan_rows)
134	135	{
135	136	/* logical (col,row) -> memory offset */
136	137	return (col & 0x1f) + ((row & 0x1f) << 5) + ((col & 0x20) << 5) + ((row & 0x20) << 6);
r17672	r17673
139	140	VIDEO_START( silvmil )
140	141	{
141	142	silvmil_state *state = machine.driver_data<silvmil_state>();
142		state->m_bg_layer = tilemap_create(machine, get_bg_tile_info, deco16_scan_rows, 16, 16, 64, 32);
143		state->m_fg_layer = tilemap_create(machine, get_fg_tile_info, deco16_scan_rows, 16, 16, 64, 32);
	143	state->m_bg_layer = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(silvmil_state::get_bg_tile_info),state), tilemap_mapper_delegate(FUNC(silvmil_state::deco16_scan_rows),state), 16, 16, 64, 32);
	144	state->m_fg_layer = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(silvmil_state::get_fg_tile_info),state), tilemap_mapper_delegate(FUNC(silvmil_state::deco16_scan_rows),state), 16, 16, 64, 32);
144	145
145	146	state->m_fg_layer->set_transparent_pen(0);
146	147	}

trunk/src/mame/drivers/trvmadns.c

r17672	r17673
83	83	DECLARE_WRITE8_MEMBER(w2);
84	84	DECLARE_WRITE8_MEMBER(w3);
85	85	DECLARE_WRITE8_MEMBER(trvmadns_tileram_w);
	86	TILE_GET_INFO_MEMBER(get_bg_tile_info);
86	87	};
87	88
88	89
r17672	r17673
259	260	GFXDECODE_ENTRY( NULL, 0x6000, charlayout, 0, 4 ) // doesn't matter where we point this, all the tiles are decoded while the game runs
260	261	GFXDECODE_END
261	262
262		static TILE_GET_INFO( get_bg_tile_info )
	263	TILE_GET_INFO_MEMBER(trvmadns_state::get_bg_tile_info)
263	264	{
264		trvmadns_state *state = machine.driver_data<trvmadns_state>();
265	265	int tile,attr,color,flag;
266	266
267		attr = state->m_tileram[tile_index*2 + 0];
268		tile = state->m_tileram[tile_index*2 + 1] + ((attr & 0x01) << 8);
	267	attr = m_tileram[tile_index*2 + 0];
	268	tile = m_tileram[tile_index*2 + 1] + ((attr & 0x01) << 8);
269	269	color = (attr & 0x18) >> 3;
270	270	flag = TILE_FLIPXY((attr & 0x06) >> 1);
271	271
r17672	r17673
275	275	//0x20? tile transparent pen 1?
276	276	//0x40? tile transparent pen 1?
277	277
278		SET_TILE_INFO(0,tile,color,flag);
	278	SET_TILE_INFO_MEMBER(0,tile,color,flag);
279	279
280	280	tileinfo.category = (attr & 0x20)>>5;
281	281	}
r17672	r17673
283	283	static VIDEO_START( trvmadns )
284	284	{
285	285	trvmadns_state *state = machine.driver_data<trvmadns_state>();
286		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	286	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(trvmadns_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
287	287
288	288	//  fg_tilemap->set_transparent_pen(1);
289	289

trunk/src/mame/drivers/albazg.c

r17672	r17673
72	72	DECLARE_READ8_MEMBER(mux_r);
73	73	DECLARE_WRITE8_MEMBER(mux_w);
74	74	DECLARE_WRITE8_MEMBER(yumefuda_output_w);
	75	TILE_GET_INFO_MEMBER(y_get_bg_tile_info);
75	76	};
76	77
77		static TILE_GET_INFO( y_get_bg_tile_info )
	78	TILE_GET_INFO_MEMBER(albazg_state::y_get_bg_tile_info)
78	79	{
79		albazg_state *state = machine.driver_data<albazg_state>();
80		int code = state->m_videoram[tile_index];
81		int color = state->m_colorram[tile_index];
	80	int code = m_videoram[tile_index];
	81	int color = m_colorram[tile_index];
82	82
83		SET_TILE_INFO(
	83	SET_TILE_INFO_MEMBER(
84	84	0,
85	85	code + ((color & 0xf8) << 3),
86	86	color & 0x7,
r17672	r17673
91	91	static VIDEO_START( yumefuda )
92	92	{
93	93	albazg_state *state = machine.driver_data<albazg_state>();
94		state->m_bg_tilemap = tilemap_create(machine, y_get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	94	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(albazg_state::y_get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
95	95	}
96	96
97	97	static SCREEN_UPDATE_IND16( yumefuda )

trunk/src/mame/drivers/ltcasino.c

r17672	r17673
32	32	DECLARE_WRITE8_MEMBER(ltcasino_tile_num_w);
33	33	DECLARE_WRITE8_MEMBER(ltcasino_tile_atr_w);
34	34	DECLARE_DRIVER_INIT(mv4in1);
	35	TILE_GET_INFO_MEMBER(get_ltcasino_tile_info);
35	36	};
36	37
37	38
38	39	/* Video */
39	40
40		static TILE_GET_INFO( get_ltcasino_tile_info )
	41	TILE_GET_INFO_MEMBER(ltcasino_state::get_ltcasino_tile_info)
41	42	{
42		ltcasino_state *state = machine.driver_data<ltcasino_state>();
43	43	int tileno, colour;
44	44
45		tileno = state->m_tile_num_ram[tile_index];
46		colour = state->m_tile_atr_ram[tile_index];
	45	tileno = m_tile_num_ram[tile_index];
	46	colour = m_tile_atr_ram[tile_index];
47	47
48	48	tileno += (colour & 0x80) << 1;
49	49
50		SET_TILE_INFO(0,tileno,0,0);
	50	SET_TILE_INFO_MEMBER(0,tileno,0,0);
51	51	}
52	52
53	53	static VIDEO_START(ltcasino)
54	54	{
55	55	ltcasino_state *state = machine.driver_data<ltcasino_state>();
56		state->m_tilemap = tilemap_create(machine, get_ltcasino_tile_info,TILEMAP_SCAN_ROWS,8, 8,64,32);
	56	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ltcasino_state::get_ltcasino_tile_info),state),TILEMAP_SCAN_ROWS,8, 8,64,32);
57	57	}
58	58
59	59

trunk/src/mame/drivers/blitz.c

r17672	r17673
310	310	DECLARE_WRITE8_MEMBER(mux_w);
311	311	DECLARE_WRITE8_MEMBER(lamps_a_w);
312	312	DECLARE_WRITE8_MEMBER(sound_w);
	313	TILE_GET_INFO_MEMBER(get_bg_tile_info);
313	314	};
314	315
315	316
r17672	r17673
332	333	}
333	334
334	335
335		static TILE_GET_INFO( get_bg_tile_info )
	336	TILE_GET_INFO_MEMBER(blitz_state::get_bg_tile_info)
336	337	{
337		blitz_state *state = machine.driver_data<blitz_state>();
338	338	/*  - bits -
339	339	7654 3210
340	340	--xx xx--   tiles color.
r17672	r17673
343	343	xx-- ----   unused.
344	344	*/
345	345
346		int attr = state->m_colorram[tile_index];
347		int code = ((attr & 1) << 8) | state->m_videoram[tile_index];
	346	int attr = m_colorram[tile_index];
	347	int code = ((attr & 1) << 8) | m_videoram[tile_index];
348	348	int bank = (attr & 0x02) >> 1;   /* bit 1 switch the gfx banks */
349	349	int color = (attr & 0x3c) >> 2;   /* bits 2-3-4-5 for color */
350	350
351		SET_TILE_INFO(bank, code, color, 0);
	351	SET_TILE_INFO_MEMBER(bank, code, color, 0);
352	352	}
353	353
354	354
355	355	static VIDEO_START( megadpkr )
356	356	{
357	357	blitz_state *state = machine.driver_data<blitz_state>();
358		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	358	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blitz_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
359	359	}
360	360
361	361	static SCREEN_UPDATE_IND16( megadpkr )

trunk/src/mame/drivers/sfbonus.c

r17672	r17673
446	446	UINT8 xor5, UINT8 b50, UINT8 b51, UINT8 b52, UINT8 b53, UINT8 b54, UINT8 b55, UINT8 b56,UINT8 b57,
447	447	UINT8 xor6, UINT8 b60, UINT8 b61, UINT8 b62, UINT8 b63, UINT8 b64, UINT8 b65, UINT8 b66,UINT8 b67,
448	448	UINT8 xor7, UINT8 b70, UINT8 b71, UINT8 b72, UINT8 b73, UINT8 b74, UINT8 b75, UINT8 b76,UINT8 b77 );
	449	TILE_GET_INFO_MEMBER(get_sfbonus_tile_info);
	450	TILE_GET_INFO_MEMBER(get_sfbonus_reel_tile_info);
	451	TILE_GET_INFO_MEMBER(get_sfbonus_reel2_tile_info);
	452	TILE_GET_INFO_MEMBER(get_sfbonus_reel3_tile_info);
	453	TILE_GET_INFO_MEMBER(get_sfbonus_reel4_tile_info);
449	454	};
450	455
451	456
r17672	r17673
765	770
766	771
767	772
768		static TILE_GET_INFO( get_sfbonus_tile_info )
	773	TILE_GET_INFO_MEMBER(sfbonus_state::get_sfbonus_tile_info)
769	774	{
770		sfbonus_state *state = machine.driver_data<sfbonus_state>();
771		int code = state->m_tilemap_ram[(tile_index*2)+0] | (state->m_tilemap_ram[(tile_index*2)+1]<<8);
772		int flipx = (state->m_tilemap_ram[(tile_index*2)+1] & 0x80)>>7;
773		int flipy = (state->m_tilemap_ram[(tile_index*2)+1] & 0x40)>>5;
	775	int code = m_tilemap_ram[(tile_index*2)+0] | (m_tilemap_ram[(tile_index*2)+1]<<8);
	776	int flipx = (m_tilemap_ram[(tile_index*2)+1] & 0x80)>>7;
	777	int flipy = (m_tilemap_ram[(tile_index*2)+1] & 0x40)>>5;
774	778
775		SET_TILE_INFO(
	779	SET_TILE_INFO_MEMBER(
776	780	0,
777	781	code,
778	782	0,
779	783	TILE_FLIPYX(flipx | flipy));
780	784	}
781	785
782		static TILE_GET_INFO( get_sfbonus_reel_tile_info )
	786	TILE_GET_INFO_MEMBER(sfbonus_state::get_sfbonus_reel_tile_info)
783	787	{
784		sfbonus_state *state = machine.driver_data<sfbonus_state>();
785		int code = state->m_reel_ram[(tile_index*2)+0] | (state->m_reel_ram[(tile_index*2)+1]<<8);
786		int flipx = (state->m_reel_ram[(tile_index*2)+1] & 0x80)>>7;
787		int flipy = 0;//(state->m_reel_ram[(tile_index*2)+1] & 0x40)>>5;
	788	int code = m_reel_ram[(tile_index*2)+0] | (m_reel_ram[(tile_index*2)+1]<<8);
	789	int flipx = (m_reel_ram[(tile_index*2)+1] & 0x80)>>7;
	790	int flipy = 0;//(m_reel_ram[(tile_index*2)+1] & 0x40)>>5;
788	791
789		int priority = (state->m_reel_ram[(tile_index*2)+1] & 0x40)>>6;
	792	int priority = (m_reel_ram[(tile_index*2)+1] & 0x40)>>6;
790	793
791		SET_TILE_INFO(
	794	SET_TILE_INFO_MEMBER(
792	795	1,
793	796	code,
794	797	priority,  // colour aboused as priority
795	798	TILE_FLIPYX(flipx | flipy));
796	799	}
797	800
798		static TILE_GET_INFO( get_sfbonus_reel2_tile_info )
	801	TILE_GET_INFO_MEMBER(sfbonus_state::get_sfbonus_reel2_tile_info)
799	802	{
800		sfbonus_state *state = machine.driver_data<sfbonus_state>();
801		int code = state->m_reel2_ram[(tile_index*2)+0] | (state->m_reel2_ram[(tile_index*2)+1]<<8);
802		int flipx = (state->m_reel2_ram[(tile_index*2)+1] & 0x80)>>7;
803		int flipy = 0;//(state->m_reel2_ram[(tile_index*2)+1] & 0x40)>>5;
	803	int code = m_reel2_ram[(tile_index*2)+0] | (m_reel2_ram[(tile_index*2)+1]<<8);
	804	int flipx = (m_reel2_ram[(tile_index*2)+1] & 0x80)>>7;
	805	int flipy = 0;//(m_reel2_ram[(tile_index*2)+1] & 0x40)>>5;
804	806
805		int priority = (state->m_reel2_ram[(tile_index*2)+1] & 0x40)>>6;
	807	int priority = (m_reel2_ram[(tile_index*2)+1] & 0x40)>>6;
806	808
807		SET_TILE_INFO(
	809	SET_TILE_INFO_MEMBER(
808	810	1,
809	811	code,
810	812	priority,  // colour abused as priority
811	813	TILE_FLIPYX(flipx | flipy));
812	814	}
813	815
814		static TILE_GET_INFO( get_sfbonus_reel3_tile_info )
	816	TILE_GET_INFO_MEMBER(sfbonus_state::get_sfbonus_reel3_tile_info)
815	817	{
816		sfbonus_state *state = machine.driver_data<sfbonus_state>();
817		int code = state->m_reel3_ram[(tile_index*2)+0] | (state->m_reel3_ram[(tile_index*2)+1]<<8);
818		int flipx = (state->m_reel3_ram[(tile_index*2)+1] & 0x80)>>7;
819		int flipy = 0;//(state->m_reel3_ram[(tile_index*2)+1] & 0x40)>>5;
	818	int code = m_reel3_ram[(tile_index*2)+0] | (m_reel3_ram[(tile_index*2)+1]<<8);
	819	int flipx = (m_reel3_ram[(tile_index*2)+1] & 0x80)>>7;
	820	int flipy = 0;//(m_reel3_ram[(tile_index*2)+1] & 0x40)>>5;
820	821
821		int priority = (state->m_reel3_ram[(tile_index*2)+1] & 0x40)>>6;
	822	int priority = (m_reel3_ram[(tile_index*2)+1] & 0x40)>>6;
822	823
823		SET_TILE_INFO(
	824	SET_TILE_INFO_MEMBER(
824	825	1,
825	826	code,
826	827	priority,  // colour abused as priority
827	828	TILE_FLIPYX(flipx | flipy));
828	829	}
829	830
830		static TILE_GET_INFO( get_sfbonus_reel4_tile_info )
	831	TILE_GET_INFO_MEMBER(sfbonus_state::get_sfbonus_reel4_tile_info)
831	832	{
832		sfbonus_state *state = machine.driver_data<sfbonus_state>();
833		int code = state->m_reel4_ram[(tile_index*2)+0] | (state->m_reel4_ram[(tile_index*2)+1]<<8);
834		int flipx = (state->m_reel4_ram[(tile_index*2)+1] & 0x80)>>7;
835		int flipy = 0;//(state->m_reel4_ram[(tile_index*2)+1] & 0x40)>>5;
	833	int code = m_reel4_ram[(tile_index*2)+0] | (m_reel4_ram[(tile_index*2)+1]<<8);
	834	int flipx = (m_reel4_ram[(tile_index*2)+1] & 0x80)>>7;
	835	int flipy = 0;//(m_reel4_ram[(tile_index*2)+1] & 0x40)>>5;
836	836
837		int priority = (state->m_reel4_ram[(tile_index*2)+1] & 0x40)>>6;
	837	int priority = (m_reel4_ram[(tile_index*2)+1] & 0x40)>>6;
838	838
839		SET_TILE_INFO(
	839	SET_TILE_INFO_MEMBER(
840	840	1,
841	841	code,
842	842	priority, // colour abused as priority
r17672	r17673
900	900	sfbonus_state *state = machine.driver_data<sfbonus_state>();
901	901	state->m_temp_reel_bitmap = auto_bitmap_ind16_alloc(machine,1024,512);
902	902
903		state->m_tilemap = tilemap_create(machine,get_sfbonus_tile_info,TILEMAP_SCAN_ROWS,8,8, 128, 64);
904		state->m_reel_tilemap = tilemap_create(machine,get_sfbonus_reel_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 16);
905		state->m_reel2_tilemap = tilemap_create(machine,get_sfbonus_reel2_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 16);
906		state->m_reel3_tilemap = tilemap_create(machine,get_sfbonus_reel3_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 16);
907		state->m_reel4_tilemap = tilemap_create(machine,get_sfbonus_reel4_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 16);
	903	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sfbonus_state::get_sfbonus_tile_info),state),TILEMAP_SCAN_ROWS,8,8, 128, 64);
	904	state->m_reel_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sfbonus_state::get_sfbonus_reel_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 16);
	905	state->m_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sfbonus_state::get_sfbonus_reel2_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 16);
	906	state->m_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sfbonus_state::get_sfbonus_reel3_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 16);
	907	state->m_reel4_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sfbonus_state::get_sfbonus_reel4_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 16);
908	908
909	909	state->m_tilemap->set_transparent_pen(0);
910	910	state->m_reel_tilemap->set_transparent_pen(255);

trunk/src/mame/drivers/cshooter.c

r17672	r17673
115	115	DECLARE_WRITE8_MEMBER(seibu_sound_comms_w);
116	116	DECLARE_DRIVER_INIT(cshootere);
117	117	DECLARE_DRIVER_INIT(cshooter);
	118	TILE_GET_INFO_MEMBER(get_cstx_tile_info);
118	119	};
119	120
120	121
121		static TILE_GET_INFO( get_cstx_tile_info )
	122	TILE_GET_INFO_MEMBER(cshooter_state::get_cstx_tile_info)
122	123	{
123		cshooter_state *state = machine.driver_data<cshooter_state>();
124		int code = (state->m_txram[tile_index*2]);
125		int attr = (state->m_txram[tile_index*2+1]);
	124	int code = (m_txram[tile_index*2]);
	125	int attr = (m_txram[tile_index*2+1]);
126	126	int rg;
127	127	rg=0;
128	128	if (attr & 0x20) rg = 1;
129	129
130		SET_TILE_INFO(
	130	SET_TILE_INFO_MEMBER(
131	131
132	132	rg,
133	133	(code & 0x1ff),
r17672	r17673
144	144	static VIDEO_START(cshooter)
145	145	{
146	146	cshooter_state *state = machine.driver_data<cshooter_state>();
147		state->m_txtilemap = tilemap_create(machine, get_cstx_tile_info,TILEMAP_SCAN_ROWS, 8,8,32, 32);
	147	state->m_txtilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cshooter_state::get_cstx_tile_info),state),TILEMAP_SCAN_ROWS, 8,8,32, 32);
148	148	state->m_txtilemap->set_transparent_pen(3);
149	149	}
150	150

trunk/src/mame/drivers/spool99.c

r17672	r17673
115	115	DECLARE_WRITE8_MEMBER(eeprom_clockline_w);
116	116	DECLARE_WRITE8_MEMBER(eeprom_dataline_w);
117	117	DECLARE_DRIVER_INIT(spool99);
	118	TILE_GET_INFO_MEMBER(get_spool99_tile_info);
118	119	};
119	120
120		static TILE_GET_INFO( get_spool99_tile_info )
	121	TILE_GET_INFO_MEMBER(spool99_state::get_spool99_tile_info)
121	122	{
122		spool99_state *state = machine.driver_data<spool99_state>();
123		int code = ((state->m_vram[tile_index*2+1]<<8) | (state->m_vram[tile_index*2+0]));
124		int color = state->m_cram[tile_index*2+0];
	123	int code = ((m_vram[tile_index*2+1]<<8) | (m_vram[tile_index*2+0]));
	124	int color = m_cram[tile_index*2+0];
125	125
126		SET_TILE_INFO(
	126	SET_TILE_INFO_MEMBER(
127	127	0,
128	128	code & 0x3fff,
129	129	color & 0x1f,
r17672	r17673
134	134	{
135	135	spool99_state *state = machine.driver_data<spool99_state>();
136	136
137		state->m_sc0_tilemap = tilemap_create(machine, get_spool99_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	137	state->m_sc0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(spool99_state::get_spool99_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
138	138	}
139	139
140	140	static SCREEN_UPDATE_IND16(spool99)

trunk/src/mame/drivers/multfish.c

r17672	r17673
233	233	DECLARE_DRIVER_INIT(gnomeent);
234	234	DECLARE_DRIVER_INIT(lhauntent);
235	235	DECLARE_DRIVER_INIT(fcockt2ent);
	236	TILE_GET_INFO_MEMBER(get_multfish_tile_info);
	237	TILE_GET_INFO_MEMBER(get_multfish_reel_tile_info);
236	238	};
237	239
238		static TILE_GET_INFO( get_multfish_tile_info )
	240	TILE_GET_INFO_MEMBER(multfish_state::get_multfish_tile_info)
239	241	{
240		multfish_state *state = machine.driver_data<multfish_state>();
241		int code = state->m_vid[tile_index*2+0x0000] | (state->m_vid[tile_index*2+0x0001] << 8);
242		int attr = state->m_vid[tile_index*2+0x1000] | (state->m_vid[tile_index*2+0x1001] << 8);
	242	int code = m_vid[tile_index*2+0x0000] | (m_vid[tile_index*2+0x0001] << 8);
	243	int attr = m_vid[tile_index*2+0x1000] | (m_vid[tile_index*2+0x1001] << 8);
243	244
244	245	tileinfo.category = (attr&0x100)>>8;
245	246
246		SET_TILE_INFO(
	247	SET_TILE_INFO_MEMBER(
247	248	0,
248	249	code&0x1fff,
249	250	attr&0x7,
250	251	0);
251	252	}
252	253
253		static TILE_GET_INFO( get_multfish_reel_tile_info )
	254	TILE_GET_INFO_MEMBER(multfish_state::get_multfish_reel_tile_info)
254	255	{
255		multfish_state *state = machine.driver_data<multfish_state>();
256		int code = state->m_vid[tile_index*2+0x2000] | (state->m_vid[tile_index*2+0x2001] << 8);
	256	int code = m_vid[tile_index*2+0x2000] | (m_vid[tile_index*2+0x2001] << 8);
257	257
258		SET_TILE_INFO(
	258	SET_TILE_INFO_MEMBER(
259	259	0,
260	260	(code&0x1fff)+0x2000,
261	261	(code>>14)+0x8,
r17672	r17673
269	269	memset(state->m_vid,0x00,sizeof(state->m_vid));
270	270	state->save_item(NAME(state->m_vid));
271	271
272		state->m_tilemap = tilemap_create(machine,get_multfish_tile_info,TILEMAP_SCAN_ROWS,16,16, 64, 32);
	272	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(multfish_state::get_multfish_tile_info),state),TILEMAP_SCAN_ROWS,16,16, 64, 32);
273	273	state->m_tilemap->set_transparent_pen(255);
274	274
275		state->m_reel_tilemap = tilemap_create(machine,get_multfish_reel_tile_info,TILEMAP_SCAN_ROWS,16,16, 64, 64);
	275	state->m_reel_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(multfish_state::get_multfish_reel_tile_info),state),TILEMAP_SCAN_ROWS,16,16, 64, 64);
276	276	state->m_reel_tilemap->set_transparent_pen(255);
277	277	state->m_reel_tilemap->set_scroll_cols(64);
278	278	}

trunk/src/mame/drivers/witch.c

r17672	r17673
234	234	DECLARE_WRITE8_MEMBER(xscroll_w);
235	235	DECLARE_WRITE8_MEMBER(yscroll_w);
236	236	DECLARE_DRIVER_INIT(witch);
	237	TILE_GET_INFO_MEMBER(get_gfx0b_tile_info);
	238	TILE_GET_INFO_MEMBER(get_gfx0a_tile_info);
	239	TILE_GET_INFO_MEMBER(get_gfx1_tile_info);
237	240	};
238	241
239	242
240	243	#define UNBANKED_SIZE 0x800
241	244
242	245
243		static TILE_GET_INFO( get_gfx0b_tile_info )
	246	TILE_GET_INFO_MEMBER(witch_state::get_gfx0b_tile_info)
244	247	{
245		witch_state *state = machine.driver_data<witch_state>();
246		int code  = state->m_gfx0_vram[tile_index];
247		int color = state->m_gfx0_cram[tile_index];
	248	int code  = m_gfx0_vram[tile_index];
	249	int color = m_gfx0_cram[tile_index];
248	250
249	251	code=code | ((color & 0xe0) << 3);
250	252
r17672	r17673
253	255	code=0;
254	256	}
255	257
256		SET_TILE_INFO(
	258	SET_TILE_INFO_MEMBER(
257	259	1,
258	260	code,//tiles beyond 0x7ff only for sprites?
259	261	color & 0x0f,
260	262	0);
261	263	}
262	264
263		static TILE_GET_INFO( get_gfx0a_tile_info )
	265	TILE_GET_INFO_MEMBER(witch_state::get_gfx0a_tile_info)
264	266	{
265		witch_state *state = machine.driver_data<witch_state>();
266		int code  = state->m_gfx0_vram[tile_index];
267		int color = state->m_gfx0_cram[tile_index];
	267	int code  = m_gfx0_vram[tile_index];
	268	int color = m_gfx0_cram[tile_index];
268	269
269	270	code=code | ((color & 0xe0) << 3);
270	271
r17672	r17673
273	274	code=0;
274	275	}
275	276
276		SET_TILE_INFO(
	277	SET_TILE_INFO_MEMBER(
277	278	1,
278	279	code,//tiles beyond 0x7ff only for sprites?
279	280	color & 0x0f,
280	281	0);
281	282	}
282	283
283		static TILE_GET_INFO( get_gfx1_tile_info )
	284	TILE_GET_INFO_MEMBER(witch_state::get_gfx1_tile_info)
284	285	{
285		witch_state *state = machine.driver_data<witch_state>();
286		int code  = state->m_gfx1_vram[tile_index];
287		int color = state->m_gfx1_cram[tile_index];
	286	int code  = m_gfx1_vram[tile_index];
	287	int color = m_gfx1_cram[tile_index];
288	288
289		SET_TILE_INFO(
	289	SET_TILE_INFO_MEMBER(
290	290	0,
291	291	code | ((color & 0xf0) << 4),
292	292	(color>>0) & 0x0f,
r17672	r17673
705	705	static VIDEO_START(witch)
706	706	{
707	707	witch_state *state = machine.driver_data<witch_state>();
708		state->m_gfx0a_tilemap = tilemap_create(machine, get_gfx0a_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32);
709		state->m_gfx0b_tilemap = tilemap_create(machine, get_gfx0b_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32);
710		state->m_gfx1_tilemap = tilemap_create(machine, get_gfx1_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32);
	708	state->m_gfx0a_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(witch_state::get_gfx0a_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32);
	709	state->m_gfx0b_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(witch_state::get_gfx0b_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32);
	710	state->m_gfx1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(witch_state::get_gfx1_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32);
711	711
712	712	state->m_gfx0a_tilemap->set_transparent_pen(0);
713	713	state->m_gfx0b_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/luckgrln.c

r17672	r17673
145	145	DECLARE_WRITE8_MEMBER(counters_w);
146	146	DECLARE_READ8_MEMBER(test_r);
147	147	DECLARE_DRIVER_INIT(luckgrln);
	148	TILE_GET_INFO_MEMBER(get_luckgrln_reel1_tile_info);
	149	TILE_GET_INFO_MEMBER(get_luckgrln_reel2_tile_info);
	150	TILE_GET_INFO_MEMBER(get_luckgrln_reel3_tile_info);
	151	TILE_GET_INFO_MEMBER(get_luckgrln_reel4_tile_info);
148	152	};
149	153
150	154
r17672	r17673
162	166
163	167
164	168
165		static TILE_GET_INFO( get_luckgrln_reel1_tile_info )
	169	TILE_GET_INFO_MEMBER(luckgrln_state::get_luckgrln_reel1_tile_info)
166	170	{
167		luckgrln_state *state = machine.driver_data<luckgrln_state>();
168		int code = state->m_reel1_ram[tile_index];
169		int attr = state->m_reel1_attr[tile_index];
	171	int code = m_reel1_ram[tile_index];
	172	int attr = m_reel1_attr[tile_index];
170	173	int col = (attr & 0x1f);
171	174
172	175	code |= (attr & 0xe0)<<3;
173	176
174	177
175		SET_TILE_INFO(
	178	SET_TILE_INFO_MEMBER(
176	179	1,
177	180	code,
178	181	col,
r17672	r17673
193	196	}
194	197
195	198
196		static TILE_GET_INFO( get_luckgrln_reel2_tile_info )
	199	TILE_GET_INFO_MEMBER(luckgrln_state::get_luckgrln_reel2_tile_info)
197	200	{
198		luckgrln_state *state = machine.driver_data<luckgrln_state>();
199		int code = state->m_reel2_ram[tile_index];
200		int attr = state->m_reel2_attr[tile_index];
	201	int code = m_reel2_ram[tile_index];
	202	int attr = m_reel2_attr[tile_index];
201	203	int col = (attr & 0x1f);
202	204
203	205	code |= (attr & 0xe0)<<3;
204	206
205	207
206		SET_TILE_INFO(
	208	SET_TILE_INFO_MEMBER(
207	209	1,
208	210	code,
209	211	col,
r17672	r17673
223	225	}
224	226
225	227
226		static TILE_GET_INFO( get_luckgrln_reel3_tile_info )
	228	TILE_GET_INFO_MEMBER(luckgrln_state::get_luckgrln_reel3_tile_info)
227	229	{
228		luckgrln_state *state = machine.driver_data<luckgrln_state>();
229		int code = state->m_reel3_ram[tile_index];
230		int attr = state->m_reel3_attr[tile_index];
	230	int code = m_reel3_ram[tile_index];
	231	int attr = m_reel3_attr[tile_index];
231	232	int col = (attr & 0x1f);
232	233
233	234	code |= (attr & 0xe0)<<3;
234	235
235		SET_TILE_INFO(
	236	SET_TILE_INFO_MEMBER(
236	237	1,
237	238	code,
238	239	col,
r17672	r17673
252	253	}
253	254
254	255
255		static TILE_GET_INFO( get_luckgrln_reel4_tile_info )
	256	TILE_GET_INFO_MEMBER(luckgrln_state::get_luckgrln_reel4_tile_info)
256	257	{
257		luckgrln_state *state = machine.driver_data<luckgrln_state>();
258		int code = state->m_reel4_ram[tile_index];
259		int attr = state->m_reel4_attr[tile_index];
	258	int code = m_reel4_ram[tile_index];
	259	int attr = m_reel4_attr[tile_index];
260	260	int col = (attr & 0x1f);
261	261
262	262	code |= (attr & 0xe0)<<3;
263	263
264		SET_TILE_INFO(
	264	SET_TILE_INFO_MEMBER(
265	265	1,
266	266	code,
267	267	col,
r17672	r17673
271	271	static VIDEO_START(luckgrln)
272	272	{
273	273	luckgrln_state *state = machine.driver_data<luckgrln_state>();
274		state->m_reel1_tilemap = tilemap_create(machine,get_luckgrln_reel1_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
275		state->m_reel2_tilemap = tilemap_create(machine,get_luckgrln_reel2_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
276		state->m_reel3_tilemap = tilemap_create(machine,get_luckgrln_reel3_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
277		state->m_reel4_tilemap = tilemap_create(machine,get_luckgrln_reel4_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	274	state->m_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(luckgrln_state::get_luckgrln_reel1_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	275	state->m_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(luckgrln_state::get_luckgrln_reel2_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	276	state->m_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(luckgrln_state::get_luckgrln_reel3_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	277	state->m_reel4_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(luckgrln_state::get_luckgrln_reel4_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
278	278
279	279	state->m_reel1_tilemap->set_scroll_cols(64);
280	280	state->m_reel2_tilemap->set_scroll_cols(64);

trunk/src/mame/drivers/quizshow.c

r17672	r17673
59	59	DECLARE_CUSTOM_INPUT_MEMBER(quizshow_tape_headpos_r);
60	60	DECLARE_INPUT_CHANGED_MEMBER(quizshow_category_select);
61	61	DECLARE_DRIVER_INIT(quizshow);
	62	TILE_GET_INFO_MEMBER(get_tile_info);
62	63	};
63	64
64	65
r17672	r17673
87	88	colortable_entry_set_value(machine.colortable, i, lut_pal[i]);
88	89	}
89	90
90		static TILE_GET_INFO( get_tile_info )
	91	TILE_GET_INFO_MEMBER(quizshow_state::get_tile_info)
91	92	{
92		quizshow_state *state = machine.driver_data<quizshow_state>();
93		UINT8 code = state->m_main_ram[tile_index];
	93	UINT8 code = m_main_ram[tile_index];
94	94
95	95	// d6: blink, d7: invert
96		UINT8 color = (code & (state->m_blink_state | 0x80)) >> 6;
	96	UINT8 color = (code & (m_blink_state | 0x80)) >> 6;
97	97
98		SET_TILE_INFO(0, code & 0x3f, color, 0);
	98	SET_TILE_INFO_MEMBER(0, code & 0x3f, color, 0);
99	99	}
100	100
101	101	VIDEO_START( quizshow )
102	102	{
103	103	quizshow_state *state = machine.driver_data<quizshow_state>();
104		state->m_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 16, 32, 16);
	104	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(quizshow_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 16, 32, 16);
105	105	}
106	106
107	107	SCREEN_UPDATE_IND16( quizshow )

trunk/src/mame/drivers/videopkr.c

r17672	r17673
356	356	DECLARE_WRITE8_MEMBER(baby_sound_p2_w);
357	357	DECLARE_READ8_MEMBER(baby_sound_p3_r);
358	358	DECLARE_WRITE8_MEMBER(baby_sound_p3_w);
	359	TILE_GET_INFO_MEMBER(get_bg_tile_info);
359	360	};
360	361
361	362
r17672	r17673
492	493	}
493	494	}
494	495
495		static TILE_GET_INFO( get_bg_tile_info )
	496	TILE_GET_INFO_MEMBER(videopkr_state::get_bg_tile_info)
496	497	{
497		videopkr_state *state = machine.driver_data<videopkr_state>();
498	498	int offs = tile_index;
499		int attr = state->m_color_ram[offs] + state->ioport("IN2")->read(); /* Color Switch Action */
500		int code = state->m_video_ram[offs];
	499	int attr = m_color_ram[offs] + ioport("IN2")->read(); /* Color Switch Action */
	500	int code = m_video_ram[offs];
501	501	int color = attr;
502		SET_TILE_INFO(0, code, color, 0);
	502	SET_TILE_INFO_MEMBER(0, code, color, 0);
503	503	}
504	504
505	505
506	506	static VIDEO_START( videopkr )
507	507	{
508	508	videopkr_state *state = machine.driver_data<videopkr_state>();
509		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	509	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(videopkr_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
510	510	}
511	511
512	512	static VIDEO_START( vidadcba )
513	513	{
514	514	videopkr_state *state = machine.driver_data<videopkr_state>();
515		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 8, 32, 32);
	515	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(videopkr_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 8, 32, 32);
516	516	}
517	517
518	518

trunk/src/mame/drivers/igspoker.c

r17672	r17673
114	114	DECLARE_DRIVER_INIT(cpoker);
115	115	DECLARE_DRIVER_INIT(igs_ncs2);
116	116	DECLARE_DRIVER_INIT(cpokerpk);
	117	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	118	TILE_GET_INFO_MEMBER(get_fg_tile_info);
117	119	};
118	120
119	121
r17672	r17673
154	156	}
155	157
156	158
157		static TILE_GET_INFO( get_bg_tile_info )
	159	TILE_GET_INFO_MEMBER(igspoker_state::get_bg_tile_info)
158	160	{
159		igspoker_state *state = machine.driver_data<igspoker_state>();
160		int code = state->m_bg_tile_ram[tile_index];
161		SET_TILE_INFO(1 + (tile_index & 3), code, 0, 0);
	161	int code = m_bg_tile_ram[tile_index];
	162	SET_TILE_INFO_MEMBER(1 + (tile_index & 3), code, 0, 0);
162	163	}
163	164
164		static TILE_GET_INFO( get_fg_tile_info )
	165	TILE_GET_INFO_MEMBER(igspoker_state::get_fg_tile_info)
165	166	{
166		igspoker_state *state = machine.driver_data<igspoker_state>();
167		int code = state->m_fg_tile_ram[tile_index] | (state->m_fg_color_ram[tile_index] << 8);
	167	int code = m_fg_tile_ram[tile_index] | (m_fg_color_ram[tile_index] << 8);
168	168	int tile = code & 0x1fff;
169		SET_TILE_INFO(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
	169	SET_TILE_INFO_MEMBER(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
170	170	}
171	171
172	172	WRITE8_MEMBER(igspoker_state::bg_tile_w)
r17672	r17673
190	190	static VIDEO_START(igs_video)
191	191	{
192	192	igspoker_state *state = machine.driver_data<igspoker_state>();
193		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
194		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,   8,  32,   64, 8);
	193	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igspoker_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
	194	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igspoker_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  32,   64, 8);
195	195
196	196	state->m_fg_tilemap->set_transparent_pen(0);
197	197	}
r17672	r17673
212	212	static VIDEO_START(cpokerpk)
213	213	{
214	214	igspoker_state *state = machine.driver_data<igspoker_state>();
215		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
	215	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igspoker_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
216	216	}
217	217
218	218	static SCREEN_UPDATE_IND16(cpokerpk)

trunk/src/mame/drivers/mil4000.c

r17672	r17673
117	117	DECLARE_WRITE16_MEMBER(sc2_vram_w);
118	118	DECLARE_WRITE16_MEMBER(sc3_vram_w);
119	119	DECLARE_WRITE16_MEMBER(output_w);
	120	TILE_GET_INFO_MEMBER(get_sc0_tile_info);
	121	TILE_GET_INFO_MEMBER(get_sc1_tile_info);
	122	TILE_GET_INFO_MEMBER(get_sc2_tile_info);
	123	TILE_GET_INFO_MEMBER(get_sc3_tile_info);
120	124	};
121	125
122	126
123		static TILE_GET_INFO( get_sc0_tile_info )
	127	TILE_GET_INFO_MEMBER(mil4000_state::get_sc0_tile_info)
124	128	{
125		mil4000_state *state = machine.driver_data<mil4000_state>();
126		UINT32 data = (state->m_sc0_vram[tile_index*2]<<16) | state->m_sc0_vram[tile_index*2+1];
	129	UINT32 data = (m_sc0_vram[tile_index*2]<<16) | m_sc0_vram[tile_index*2+1];
127	130	int tile = data >> 14;
128		int color = (state->m_sc0_vram[tile_index*2+1] & 0x1f)+0;
	131	int color = (m_sc0_vram[tile_index*2+1] & 0x1f)+0;
129	132
130		SET_TILE_INFO(
	133	SET_TILE_INFO_MEMBER(
131	134	0,
132	135	tile,
133	136	color,
134	137	0);
135	138	}
136	139
137		static TILE_GET_INFO( get_sc1_tile_info )
	140	TILE_GET_INFO_MEMBER(mil4000_state::get_sc1_tile_info)
138	141	{
139		mil4000_state *state = machine.driver_data<mil4000_state>();
140		UINT32 data = (state->m_sc1_vram[tile_index*2]<<16) | state->m_sc1_vram[tile_index*2+1];
	142	UINT32 data = (m_sc1_vram[tile_index*2]<<16) | m_sc1_vram[tile_index*2+1];
141	143	int tile = data >> 14;
142		int color = (state->m_sc1_vram[tile_index*2+1] & 0x1f)+0x10;
	144	int color = (m_sc1_vram[tile_index*2+1] & 0x1f)+0x10;
143	145
144		SET_TILE_INFO(
	146	SET_TILE_INFO_MEMBER(
145	147	0,
146	148	tile,
147	149	color,
148	150	0);
149	151	}
150	152
151		static TILE_GET_INFO( get_sc2_tile_info )
	153	TILE_GET_INFO_MEMBER(mil4000_state::get_sc2_tile_info)
152	154	{
153		mil4000_state *state = machine.driver_data<mil4000_state>();
154		UINT32 data = (state->m_sc2_vram[tile_index*2]<<16) | state->m_sc2_vram[tile_index*2+1];
	155	UINT32 data = (m_sc2_vram[tile_index*2]<<16) | m_sc2_vram[tile_index*2+1];
155	156	int tile = data >> 14;
156		int color = (state->m_sc2_vram[tile_index*2+1] & 0x1f)+0x20;
	157	int color = (m_sc2_vram[tile_index*2+1] & 0x1f)+0x20;
157	158
158		SET_TILE_INFO(
	159	SET_TILE_INFO_MEMBER(
159	160	0,
160	161	tile,
161	162	color,
162	163	0);
163	164	}
164	165
165		static TILE_GET_INFO( get_sc3_tile_info )
	166	TILE_GET_INFO_MEMBER(mil4000_state::get_sc3_tile_info)
166	167	{
167		mil4000_state *state = machine.driver_data<mil4000_state>();
168		UINT32 data = (state->m_sc3_vram[tile_index*2]<<16) | state->m_sc3_vram[tile_index*2+1];
	168	UINT32 data = (m_sc3_vram[tile_index*2]<<16) | m_sc3_vram[tile_index*2+1];
169	169	int tile = data >> 14;
170		int color = (state->m_sc3_vram[tile_index*2+1] & 0x1f)+0x30;
	170	int color = (m_sc3_vram[tile_index*2+1] & 0x1f)+0x30;
171	171
172		SET_TILE_INFO(
	172	SET_TILE_INFO_MEMBER(
173	173	0,
174	174	tile,
175	175	color,
r17672	r17673
179	179	static VIDEO_START(mil4000)
180	180	{
181	181	mil4000_state *state = machine.driver_data<mil4000_state>();
182		state->m_sc0_tilemap = tilemap_create(machine, get_sc0_tile_info,TILEMAP_SCAN_ROWS,8,8,64,64);
183		state->m_sc1_tilemap = tilemap_create(machine, get_sc1_tile_info,TILEMAP_SCAN_ROWS,8,8,64,64);
184		state->m_sc2_tilemap = tilemap_create(machine, get_sc2_tile_info,TILEMAP_SCAN_ROWS,8,8,64,64);
185		state->m_sc3_tilemap = tilemap_create(machine, get_sc3_tile_info,TILEMAP_SCAN_ROWS,8,8,64,64);
	182	state->m_sc0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mil4000_state::get_sc0_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,64);
	183	state->m_sc1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mil4000_state::get_sc1_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,64);
	184	state->m_sc2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mil4000_state::get_sc2_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,64);
	185	state->m_sc3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mil4000_state::get_sc3_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,64);
186	186
187	187	state->m_sc1_tilemap->set_transparent_pen(0);
188	188	state->m_sc2_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/koikoi.c

r17672	r17673
68	68	DECLARE_WRITE8_MEMBER(io_w);
69	69	DECLARE_READ8_MEMBER(input_r);
70	70	DECLARE_WRITE8_MEMBER(unknown_w);
	71	TILE_GET_INFO_MEMBER(get_tile_info);
71	72	};
72	73
73	74
r17672	r17673
77	78	*
78	79	*************************************/
79	80
80		static TILE_GET_INFO( get_tile_info )
	81	TILE_GET_INFO_MEMBER(koikoi_state::get_tile_info)
81	82	{
82		koikoi_state *state = machine.driver_data<koikoi_state>();
83		int code  = state->m_videoram[tile_index] | ((state->m_videoram[tile_index + 0x400] & 0x40) << 2);
84		int color = (state->m_videoram[tile_index + 0x400] & 0x1f);
85		int flip  = (state->m_videoram[tile_index + 0x400] & 0x80) ? (TILEMAP_FLIPX | TILEMAP_FLIPY) : 0;
	83	int code  = m_videoram[tile_index] | ((m_videoram[tile_index + 0x400] & 0x40) << 2);
	84	int color = (m_videoram[tile_index + 0x400] & 0x1f);
	85	int flip  = (m_videoram[tile_index + 0x400] & 0x80) ? (TILEMAP_FLIPX | TILEMAP_FLIPY) : 0;
86	86
87		SET_TILE_INFO( 0, code, color, flip);
	87	SET_TILE_INFO_MEMBER( 0, code, color, flip);
88	88	}
89	89
90	90	static PALETTE_INIT( koikoi )
r17672	r17673
136	136	static VIDEO_START(koikoi)
137	137	{
138	138	koikoi_state *state = machine.driver_data<koikoi_state>();
139		state->m_tmap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	139	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(koikoi_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
140	140	}
141	141
142	142	static SCREEN_UPDATE_IND16(koikoi)

trunk/src/mame/drivers/skylncr.c

r17672	r17673
102	102	DECLARE_READ8_MEMBER(ret_00);
103	103	DECLARE_WRITE8_MEMBER(skylncr_nmi_enable_w);
104	104	DECLARE_DRIVER_INIT(skylncr);
	105	TILE_GET_INFO_MEMBER(get_tile_info);
	106	TILE_GET_INFO_MEMBER(get_reel_1_tile_info);
	107	TILE_GET_INFO_MEMBER(get_reel_2_tile_info);
	108	TILE_GET_INFO_MEMBER(get_reel_3_tile_info);
	109	TILE_GET_INFO_MEMBER(get_reel_4_tile_info);
105	110	};
106	111
107	112
r17672	r17673
122	127	}
123	128
124	129
125		static TILE_GET_INFO( get_tile_info )
	130	TILE_GET_INFO_MEMBER(skylncr_state::get_tile_info)
126	131	{
127		skylncr_state *state = machine.driver_data<skylncr_state>();
128		UINT16 code = state->m_videoram[ tile_index ] + (state->m_colorram[ tile_index ] << 8);
129		SET_TILE_INFO(0, code, 0, TILE_FLIPYX( 0 ));
	132	UINT16 code = m_videoram[ tile_index ] + (m_colorram[ tile_index ] << 8);
	133	SET_TILE_INFO_MEMBER(0, code, 0, TILE_FLIPYX( 0 ));
130	134	}
131	135
132		static TILE_GET_INFO( get_reel_1_tile_info )
	136	TILE_GET_INFO_MEMBER(skylncr_state::get_reel_1_tile_info)
133	137	{
134		skylncr_state *state = machine.driver_data<skylncr_state>();
135		UINT16 code = state->m_reeltiles_1_ram[ tile_index ] + (state->m_reeltileshigh_1_ram[ tile_index ] << 8);
136		SET_TILE_INFO(1, code, 0, TILE_FLIPYX( 0 ));
	138	UINT16 code = m_reeltiles_1_ram[ tile_index ] + (m_reeltileshigh_1_ram[ tile_index ] << 8);
	139	SET_TILE_INFO_MEMBER(1, code, 0, TILE_FLIPYX( 0 ));
137	140	}
138	141
139		static TILE_GET_INFO( get_reel_2_tile_info )
	142	TILE_GET_INFO_MEMBER(skylncr_state::get_reel_2_tile_info)
140	143	{
141		skylncr_state *state = machine.driver_data<skylncr_state>();
142		UINT16 code = state->m_reeltiles_2_ram[ tile_index ] + (state->m_reeltileshigh_2_ram[ tile_index ] << 8);
143		SET_TILE_INFO(1, code, 0, TILE_FLIPYX( 0 ));
	144	UINT16 code = m_reeltiles_2_ram[ tile_index ] + (m_reeltileshigh_2_ram[ tile_index ] << 8);
	145	SET_TILE_INFO_MEMBER(1, code, 0, TILE_FLIPYX( 0 ));
144	146	}
145	147
146		static TILE_GET_INFO( get_reel_3_tile_info )
	148	TILE_GET_INFO_MEMBER(skylncr_state::get_reel_3_tile_info)
147	149	{
148		skylncr_state *state = machine.driver_data<skylncr_state>();
149		UINT16 code = state->m_reeltiles_3_ram[ tile_index ] + (state->m_reeltileshigh_3_ram[ tile_index ] << 8);
150		SET_TILE_INFO(1, code, 0, TILE_FLIPYX( 0 ));
	150	UINT16 code = m_reeltiles_3_ram[ tile_index ] + (m_reeltileshigh_3_ram[ tile_index ] << 8);
	151	SET_TILE_INFO_MEMBER(1, code, 0, TILE_FLIPYX( 0 ));
151	152	}
152	153
153		static TILE_GET_INFO( get_reel_4_tile_info )
	154	TILE_GET_INFO_MEMBER(skylncr_state::get_reel_4_tile_info)
154	155	{
155		skylncr_state *state = machine.driver_data<skylncr_state>();
156		UINT16 code = state->m_reeltiles_4_ram[ tile_index ] + (state->m_reeltileshigh_4_ram[ tile_index ] << 8);
157		SET_TILE_INFO(1, code, 0, TILE_FLIPYX( 0 ));
	156	UINT16 code = m_reeltiles_4_ram[ tile_index ] + (m_reeltileshigh_4_ram[ tile_index ] << 8);
	157	SET_TILE_INFO_MEMBER(1, code, 0, TILE_FLIPYX( 0 ));
158	158	}
159	159
160	160
r17672	r17673
162	162	{
163	163	skylncr_state *state = machine.driver_data<skylncr_state>();
164	164
165		state->m_tmap = tilemap_create(   machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 0x40, 0x20   );
	165	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(skylncr_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 0x40, 0x20   );
166	166
167		state->m_reel_1_tilemap = tilemap_create(machine, get_reel_1_tile_info, TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
168		state->m_reel_2_tilemap = tilemap_create(machine, get_reel_2_tile_info, TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
169		state->m_reel_3_tilemap = tilemap_create(machine, get_reel_3_tile_info, TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
170		state->m_reel_4_tilemap = tilemap_create(machine, get_reel_4_tile_info, TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
	167	state->m_reel_1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(skylncr_state::get_reel_1_tile_info),state), TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
	168	state->m_reel_2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(skylncr_state::get_reel_2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
	169	state->m_reel_3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(skylncr_state::get_reel_3_tile_info),state), TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
	170	state->m_reel_4_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(skylncr_state::get_reel_4_tile_info),state), TILEMAP_SCAN_ROWS, 8, 32, 64, 8 );
171	171
172	172	state->m_reel_2_tilemap->set_scroll_cols(0x40);
173	173	state->m_reel_3_tilemap->set_scroll_cols(0x40);

trunk/src/mame/drivers/limenko.c

r17672	r17673
83	83	DECLARE_DRIVER_INIT(dynabomb);
84	84	DECLARE_DRIVER_INIT(legendoh);
85	85	DECLARE_DRIVER_INIT(spotty);
	86	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	87	TILE_GET_INFO_MEMBER(get_md_tile_info);
	88	TILE_GET_INFO_MEMBER(get_fg_tile_info);
86	89	};
87	90
88	91
r17672	r17673
295	298	VIDEO HARDWARE EMULATION
296	299	*****************************************************************************************************/
297	300
298		static TILE_GET_INFO( get_bg_tile_info )
	301	TILE_GET_INFO_MEMBER(limenko_state::get_bg_tile_info)
299	302	{
300		limenko_state *state = machine.driver_data<limenko_state>();
301		int tile  = state->m_bg_videoram[tile_index] & 0x7ffff;
302		int color = (state->m_bg_videoram[tile_index]>>28) & 0xf;
303		SET_TILE_INFO(0,tile,color,0);
	303	int tile  = m_bg_videoram[tile_index] & 0x7ffff;
	304	int color = (m_bg_videoram[tile_index]>>28) & 0xf;
	305	SET_TILE_INFO_MEMBER(0,tile,color,0);
304	306	}
305	307
306		static TILE_GET_INFO( get_md_tile_info )
	308	TILE_GET_INFO_MEMBER(limenko_state::get_md_tile_info)
307	309	{
308		limenko_state *state = machine.driver_data<limenko_state>();
309		int tile  = state->m_md_videoram[tile_index] & 0x7ffff;
310		int color = (state->m_md_videoram[tile_index]>>28) & 0xf;
311		SET_TILE_INFO(0,tile,color,0);
	310	int tile  = m_md_videoram[tile_index] & 0x7ffff;
	311	int color = (m_md_videoram[tile_index]>>28) & 0xf;
	312	SET_TILE_INFO_MEMBER(0,tile,color,0);
312	313	}
313	314
314		static TILE_GET_INFO( get_fg_tile_info )
	315	TILE_GET_INFO_MEMBER(limenko_state::get_fg_tile_info)
315	316	{
316		limenko_state *state = machine.driver_data<limenko_state>();
317		int tile  = state->m_fg_videoram[tile_index] & 0x7ffff;
318		int color = (state->m_fg_videoram[tile_index]>>28) & 0xf;
319		SET_TILE_INFO(0,tile,color,0);
	317	int tile  = m_fg_videoram[tile_index] & 0x7ffff;
	318	int color = (m_fg_videoram[tile_index]>>28) & 0xf;
	319	SET_TILE_INFO_MEMBER(0,tile,color,0);
320	320	}
321	321
322	322	static void draw_single_sprite(bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_element *gfx,
r17672	r17673
503	503	static VIDEO_START( limenko )
504	504	{
505	505	limenko_state *state = machine.driver_data<limenko_state>();
506		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info,TILEMAP_SCAN_ROWS,8,8,128,64);
507		state->m_md_tilemap = tilemap_create(machine, get_md_tile_info,TILEMAP_SCAN_ROWS,8,8,128,64);
508		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info,TILEMAP_SCAN_ROWS,8,8,128,64);
	506	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(limenko_state::get_bg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,128,64);
	507	state->m_md_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(limenko_state::get_md_tile_info),state),TILEMAP_SCAN_ROWS,8,8,128,64);
	508	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(limenko_state::get_fg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,128,64);
509	509
510	510	state->m_md_tilemap->set_transparent_pen(0);
511	511	state->m_fg_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/drtomy.c

r17672	r17673
35	35	DECLARE_WRITE16_MEMBER(drtomy_vram_fg_w);
36	36	DECLARE_WRITE16_MEMBER(drtomy_vram_bg_w);
37	37	DECLARE_WRITE16_MEMBER(drtomy_okibank_w);
	38	TILE_GET_INFO_MEMBER(get_tile_info_fg);
	39	TILE_GET_INFO_MEMBER(get_tile_info_bg);
38	40	};
39	41
40	42
41	43
42		static TILE_GET_INFO( get_tile_info_fg )
	44	TILE_GET_INFO_MEMBER(drtomy_state::get_tile_info_fg)
43	45	{
44		drtomy_state *state = machine.driver_data<drtomy_state>();
45		int code  = state->m_videoram_fg[tile_index] & 0xfff;
46		int color = (state->m_videoram_fg[tile_index] & 0xf000) >> 12;
47		SET_TILE_INFO(2, code, color, 0);
	46	int code  = m_videoram_fg[tile_index] & 0xfff;
	47	int color = (m_videoram_fg[tile_index] & 0xf000) >> 12;
	48	SET_TILE_INFO_MEMBER(2, code, color, 0);
48	49	}
49	50
50	51
51		static TILE_GET_INFO( get_tile_info_bg )
	52	TILE_GET_INFO_MEMBER(drtomy_state::get_tile_info_bg)
52	53	{
53		drtomy_state *state = machine.driver_data<drtomy_state>();
54		int code  = state->m_videoram_bg[tile_index] & 0xfff;
55		int color = (state->m_videoram_bg[tile_index] & 0xf000) >> 12;
56		SET_TILE_INFO(1, code, color, 0);
	54	int code  = m_videoram_bg[tile_index] & 0xfff;
	55	int color = (m_videoram_bg[tile_index] & 0xf000) >> 12;
	56	SET_TILE_INFO_MEMBER(1, code, color, 0);
57	57	}
58	58
59	59
r17672	r17673
123	123	{
124	124	drtomy_state *state = machine.driver_data<drtomy_state>();
125	125
126		state->m_tilemap_bg = tilemap_create(machine, get_tile_info_bg, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
127		state->m_tilemap_fg = tilemap_create(machine, get_tile_info_fg, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	126	state->m_tilemap_bg = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(drtomy_state::get_tile_info_bg),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	127	state->m_tilemap_fg = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(drtomy_state::get_tile_info_fg),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
128	128
129	129	state->m_tilemap_fg->set_transparent_pen(0);
130	130	}

trunk/src/mame/drivers/calorie.c

r17672	r17673
107	107	DECLARE_WRITE8_MEMBER(bogus_w);
108	108	DECLARE_DRIVER_INIT(calorie);
109	109	DECLARE_DRIVER_INIT(calorieb);
	110	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	111	TILE_GET_INFO_MEMBER(get_fg_tile_info);
110	112	};
111	113
112	114
r17672	r17673
116	118	*
117	119	*************************************/
118	120
119		static TILE_GET_INFO( get_bg_tile_info )
	121	TILE_GET_INFO_MEMBER(calorie_state::get_bg_tile_info)
120	122	{
121		calorie_state *state = machine.driver_data<calorie_state>();
122		UINT8 *src = state->memregion("user1")->base();
123		int bg_base = (state->m_bg_bank & 0x0f) * 0x200;
	123	UINT8 *src = memregion("user1")->base();
	124	int bg_base = (m_bg_bank & 0x0f) * 0x200;
124	125	int code  = src[bg_base + tile_index] | (((src[bg_base + tile_index + 0x100]) & 0x10) << 4);
125	126	int color = src[bg_base + tile_index + 0x100] & 0x0f;
126	127	int flag  = src[bg_base + tile_index + 0x100] & 0x40 ? TILE_FLIPX : 0;
127	128
128		SET_TILE_INFO(1, code, color, flag);
	129	SET_TILE_INFO_MEMBER(1, code, color, flag);
129	130	}
130	131
131		static TILE_GET_INFO( get_fg_tile_info )
	132	TILE_GET_INFO_MEMBER(calorie_state::get_fg_tile_info)
132	133	{
133		calorie_state *state = machine.driver_data<calorie_state>();
134		int code  = ((state->m_fg_ram[tile_index + 0x400] & 0x30) << 4) | state->m_fg_ram[tile_index];
135		int color = state->m_fg_ram[tile_index + 0x400] & 0x0f;
	134	int code  = ((m_fg_ram[tile_index + 0x400] & 0x30) << 4) | m_fg_ram[tile_index];
	135	int color = m_fg_ram[tile_index + 0x400] & 0x0f;
136	136
137		SET_TILE_INFO(0, code, color, TILE_FLIPYX((state->m_fg_ram[tile_index + 0x400] & 0xc0) >> 6));
	137	SET_TILE_INFO_MEMBER(0, code, color, TILE_FLIPYX((m_fg_ram[tile_index + 0x400] & 0xc0) >> 6));
138	138	}
139	139
140	140
r17672	r17673
142	142	{
143	143	calorie_state *state = machine.driver_data<calorie_state>();
144	144
145		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 16, 16);
146		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	145	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(calorie_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 16, 16);
	146	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(calorie_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
147	147
148	148	state->m_fg_tilemap->set_transparent_pen(0);
149	149	}

trunk/src/mame/drivers/magic10.c

r17672	r17673
117	117	DECLARE_DRIVER_INIT(magic102);
118	118	DECLARE_DRIVER_INIT(magic10);
119	119	DECLARE_DRIVER_INIT(hotslot);
	120	TILE_GET_INFO_MEMBER(get_layer0_tile_info);
	121	TILE_GET_INFO_MEMBER(get_layer1_tile_info);
	122	TILE_GET_INFO_MEMBER(get_layer2_tile_info);
120	123	};
121	124
122	125
r17672	r17673
149	152	}
150	153
151	154
152		static TILE_GET_INFO( get_layer0_tile_info )
	155	TILE_GET_INFO_MEMBER(magic10_state::get_layer0_tile_info)
153	156	{
154		magic10_state *state = machine.driver_data<magic10_state>();
155		SET_TILE_INFO
	157	SET_TILE_INFO_MEMBER
156	158	(
157	159	1,
158		state->m_layer0_videoram[tile_index * 2],
159		state->m_layer0_videoram[tile_index * 2 + 1] & 0x0f,
160		TILE_FLIPYX((state->m_layer0_videoram[tile_index * 2 + 1] & 0xc0) >> 6)
	160	m_layer0_videoram[tile_index * 2],
	161	m_layer0_videoram[tile_index * 2 + 1] & 0x0f,
	162	TILE_FLIPYX((m_layer0_videoram[tile_index * 2 + 1] & 0xc0) >> 6)
161	163	);
162	164	}
163	165
164		static TILE_GET_INFO( get_layer1_tile_info )
	166	TILE_GET_INFO_MEMBER(magic10_state::get_layer1_tile_info)
165	167	{
166		magic10_state *state = machine.driver_data<magic10_state>();
167		SET_TILE_INFO
	168	SET_TILE_INFO_MEMBER
168	169	(
169	170	1,
170		state->m_layer1_videoram[tile_index * 2],
171		state->m_layer1_videoram[tile_index * 2 + 1] & 0x0f,
172		TILE_FLIPYX((state->m_layer1_videoram[tile_index * 2 + 1] & 0xc0) >> 6)
	171	m_layer1_videoram[tile_index * 2],
	172	m_layer1_videoram[tile_index * 2 + 1] & 0x0f,
	173	TILE_FLIPYX((m_layer1_videoram[tile_index * 2 + 1] & 0xc0) >> 6)
173	174	);
174	175	}
175	176
176		static TILE_GET_INFO( get_layer2_tile_info )
	177	TILE_GET_INFO_MEMBER(magic10_state::get_layer2_tile_info)
177	178	{
178		magic10_state *state = machine.driver_data<magic10_state>();
179		SET_TILE_INFO
	179	SET_TILE_INFO_MEMBER
180	180	(
181	181	0,
182		state->m_layer2_videoram[tile_index * 2],
183		state->m_layer2_videoram[tile_index * 2 + 1] & 0x0f,
	182	m_layer2_videoram[tile_index * 2],
	183	m_layer2_videoram[tile_index * 2 + 1] & 0x0f,
184	184	0
185	185	);
186	186	}
r17672	r17673
189	189	static VIDEO_START( magic10 )
190	190	{
191	191	magic10_state *state = machine.driver_data<magic10_state>();
192		state->m_layer0_tilemap = tilemap_create(machine, get_layer0_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
193		state->m_layer1_tilemap = tilemap_create(machine, get_layer1_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
194		state->m_layer2_tilemap = tilemap_create(machine, get_layer2_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	192	state->m_layer0_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(magic10_state::get_layer0_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	193	state->m_layer1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(magic10_state::get_layer1_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	194	state->m_layer2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(magic10_state::get_layer2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
195	195
196	196	state->m_layer1_tilemap->set_transparent_pen(0);
197	197	state->m_layer2_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/mogura.c

r17672	r17673
27	27	DECLARE_WRITE8_MEMBER(mogura_tileram_w);
28	28	DECLARE_WRITE8_MEMBER(mogura_dac_w);
29	29	DECLARE_WRITE8_MEMBER(mogura_gfxram_w);
	30	TILE_GET_INFO_MEMBER(get_mogura_tile_info);
30	31	};
31	32
32	33
r17672	r17673
63	64	}
64	65
65	66
66		static TILE_GET_INFO( get_mogura_tile_info )
	67	TILE_GET_INFO_MEMBER(mogura_state::get_mogura_tile_info)
67	68	{
68		mogura_state *state = machine.driver_data<mogura_state>();
69		int code = state->m_tileram[tile_index];
70		int attr = state->m_tileram[tile_index + 0x800];
	69	int code = m_tileram[tile_index];
	70	int attr = m_tileram[tile_index + 0x800];
71	71
72		SET_TILE_INFO(
	72	SET_TILE_INFO_MEMBER(
73	73	0,
74	74	code,
75	75	(attr >> 1) & 7,
r17672	r17673
81	81	{
82	82	mogura_state *state = machine.driver_data<mogura_state>();
83	83	machine.gfx[0]->set_source(state->m_gfxram);
84		state->m_tilemap = tilemap_create(machine, get_mogura_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	84	state->m_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(mogura_state::get_mogura_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
85	85	}
86	86
87	87	static SCREEN_UPDATE_IND16( mogura )

trunk/src/mame/drivers/ddealer.c

r17672	r17673
152	152	DECLARE_WRITE16_MEMBER(ddealer_mcu_shared_w);
153	153	DECLARE_READ16_MEMBER(ddealer_mcu_r);
154	154	DECLARE_DRIVER_INIT(ddealer);
	155	TILE_GET_INFO_MEMBER(get_back_tile_info);
155	156	};
156	157
157	158
r17672	r17673
161	162	m_flipscreen = data & 0x01;
162	163	}
163	164
164		static TILE_GET_INFO( get_back_tile_info )
	165	TILE_GET_INFO_MEMBER(ddealer_state::get_back_tile_info)
165	166	{
166		ddealer_state *state = machine.driver_data<ddealer_state>();
167		int code = state->m_back_vram[tile_index];
168		SET_TILE_INFO(
	167	int code = m_back_vram[tile_index];
	168	SET_TILE_INFO_MEMBER(
169	169	0,
170	170	code & 0xfff,
171	171	code >> 12,
r17672	r17673
176	176	{
177	177	ddealer_state *state = machine.driver_data<ddealer_state>();
178	178	state->m_flipscreen = 0;
179		state->m_back_tilemap = tilemap_create(machine, get_back_tile_info, TILEMAP_SCAN_COLS, 8, 8, 64, 32);
	179	state->m_back_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ddealer_state::get_back_tile_info),state), TILEMAP_SCAN_COLS, 8, 8, 64, 32);
180	180	}
181	181
182	182	static void ddealer_draw_video_layer( running_machine &machine, UINT16* vreg_base, UINT16* top, UINT16* bottom, bitmap_ind16 &bitmap, const rectangle &cliprect, int flipy)

trunk/src/mame/drivers/igs009.c

r17672	r17673
77	77	void show_out();
78	78	DECLARE_CUSTOM_INPUT_MEMBER(hopper_r);
79	79	DECLARE_DRIVER_INIT(jingbell);
	80	TILE_GET_INFO_MEMBER(get_jingbell_reel1_tile_info);
	81	TILE_GET_INFO_MEMBER(get_gp98_reel1_tile_info);
	82	TILE_GET_INFO_MEMBER(get_jingbell_reel2_tile_info);
	83	TILE_GET_INFO_MEMBER(get_gp98_reel2_tile_info);
	84	TILE_GET_INFO_MEMBER(get_jingbell_reel3_tile_info);
	85	TILE_GET_INFO_MEMBER(get_gp98_reel3_tile_info);
	86	TILE_GET_INFO_MEMBER(get_jingbell_reel4_tile_info);
	87	TILE_GET_INFO_MEMBER(get_gp98_reel4_tile_info);
	88	TILE_GET_INFO_MEMBER(get_fg_tile_info);
80	89	};
81	90
82	91
r17672	r17673
92	101	m_gp98_reel1_tilemap->mark_tile_dirty(offset);
93	102	}
94	103
95		static TILE_GET_INFO( get_jingbell_reel1_tile_info )
	104	TILE_GET_INFO_MEMBER(igs009_state::get_jingbell_reel1_tile_info)
96	105	{
97		igs009_state *state = machine.driver_data<igs009_state>();
98		int code = state->m_gp98_reel1_ram[tile_index];
	106	int code = m_gp98_reel1_ram[tile_index];
99	107
100		SET_TILE_INFO(
	108	SET_TILE_INFO_MEMBER(
101	109	0,
102	110	(code)+(((tile_index+1)&0x3)*0x100),
103	111	(code & 0x80) ? 0xc : 0,
r17672	r17673
105	113	}
106	114
107	115
108		static TILE_GET_INFO( get_gp98_reel1_tile_info )
	116	TILE_GET_INFO_MEMBER(igs009_state::get_gp98_reel1_tile_info)
109	117	{
110		igs009_state *state = machine.driver_data<igs009_state>();
111		int code = state->m_gp98_reel1_ram[tile_index];
	118	int code = m_gp98_reel1_ram[tile_index];
112	119
113		SET_TILE_INFO(
	120	SET_TILE_INFO_MEMBER(
114	121	0,
115	122	(code*4)+(tile_index&0x3),
116	123	0,
r17672	r17673
124	131	m_gp98_reel2_tilemap->mark_tile_dirty(offset);
125	132	}
126	133
127		static TILE_GET_INFO( get_jingbell_reel2_tile_info )
	134	TILE_GET_INFO_MEMBER(igs009_state::get_jingbell_reel2_tile_info)
128	135	{
129		igs009_state *state = machine.driver_data<igs009_state>();
130		int code = state->m_gp98_reel2_ram[tile_index];
	136	int code = m_gp98_reel2_ram[tile_index];
131	137
132		SET_TILE_INFO(
	138	SET_TILE_INFO_MEMBER(
133	139	0,
134	140	(code)+(((tile_index+1)&0x3)*0x100),
135	141	(code & 0x80) ? 0xc : 0,
136	142	0);
137	143	}
138	144
139		static TILE_GET_INFO( get_gp98_reel2_tile_info )
	145	TILE_GET_INFO_MEMBER(igs009_state::get_gp98_reel2_tile_info)
140	146	{
141		igs009_state *state = machine.driver_data<igs009_state>();
142		int code = state->m_gp98_reel2_ram[tile_index];
	147	int code = m_gp98_reel2_ram[tile_index];
143	148
144		SET_TILE_INFO(
	149	SET_TILE_INFO_MEMBER(
145	150	0,
146	151	(code*4)+(tile_index&0x3),
147	152	0,
r17672	r17673
156	161	m_gp98_reel3_tilemap->mark_tile_dirty(offset);
157	162	}
158	163
159		static TILE_GET_INFO( get_jingbell_reel3_tile_info )
	164	TILE_GET_INFO_MEMBER(igs009_state::get_jingbell_reel3_tile_info)
160	165	{
161		igs009_state *state = machine.driver_data<igs009_state>();
162		int code = state->m_gp98_reel3_ram[tile_index];
	166	int code = m_gp98_reel3_ram[tile_index];
163	167
164		SET_TILE_INFO(
	168	SET_TILE_INFO_MEMBER(
165	169	0,
166	170	(code)+(((tile_index+1)&0x3)*0x100),
167	171	(code & 0x80) ? 0xc : 0,
168	172	0);
169	173	}
170	174
171		static TILE_GET_INFO( get_gp98_reel3_tile_info )
	175	TILE_GET_INFO_MEMBER(igs009_state::get_gp98_reel3_tile_info)
172	176	{
173		igs009_state *state = machine.driver_data<igs009_state>();
174		int code = state->m_gp98_reel3_ram[tile_index];
	177	int code = m_gp98_reel3_ram[tile_index];
175	178
176		SET_TILE_INFO(
	179	SET_TILE_INFO_MEMBER(
177	180	0,
178	181	(code*4)+(tile_index&0x3),
179	182	0,
r17672	r17673
188	191	m_gp98_reel4_tilemap->mark_tile_dirty(offset);
189	192	}
190	193
191		static TILE_GET_INFO( get_jingbell_reel4_tile_info )
	194	TILE_GET_INFO_MEMBER(igs009_state::get_jingbell_reel4_tile_info)
192	195	{
193		igs009_state *state = machine.driver_data<igs009_state>();
194		int code = state->m_gp98_reel4_ram[tile_index];
	196	int code = m_gp98_reel4_ram[tile_index];
195	197
196		SET_TILE_INFO(
	198	SET_TILE_INFO_MEMBER(
197	199	0,
198	200	(code)+(((tile_index+1)&0x3)*0x100),
199	201	(code & 0x80) ? 0xc : 0,
200	202	0);
201	203	}
202	204
203		static TILE_GET_INFO( get_gp98_reel4_tile_info )
	205	TILE_GET_INFO_MEMBER(igs009_state::get_gp98_reel4_tile_info)
204	206	{
205		igs009_state *state = machine.driver_data<igs009_state>();
206		int code = state->m_gp98_reel4_ram[tile_index];
	207	int code = m_gp98_reel4_ram[tile_index];
207	208
208		SET_TILE_INFO(
	209	SET_TILE_INFO_MEMBER(
209	210	0,
210	211	(code*4)+(tile_index&0x3),
211	212	0,
r17672	r17673
225	226	}
226	227
227	228
228		static TILE_GET_INFO( get_fg_tile_info )
	229	TILE_GET_INFO_MEMBER(igs009_state::get_fg_tile_info)
229	230	{
230		igs009_state *state = machine.driver_data<igs009_state>();
231		int code = state->m_fg_tile_ram[tile_index] | (state->m_fg_color_ram[tile_index] << 8);
232		SET_TILE_INFO(1, code, (4*(code >> 14)+3), 0);
	231	int code = m_fg_tile_ram[tile_index] | (m_fg_color_ram[tile_index] << 8);
	232	SET_TILE_INFO_MEMBER(1, code, (4*(code >> 14)+3), 0);
233	233	}
234	234
235	235	WRITE8_MEMBER(igs009_state::fg_tile_w)
r17672	r17673
247	247	static VIDEO_START(jingbell)
248	248	{
249	249	igs009_state *state = machine.driver_data<igs009_state>();
250		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   0x80,0x20);
	250	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   0x80,0x20);
251	251	state->m_fg_tilemap->set_transparent_pen(0);
252	252
253		state->m_gp98_reel1_tilemap = tilemap_create(machine,get_jingbell_reel1_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
254		state->m_gp98_reel2_tilemap = tilemap_create(machine,get_jingbell_reel2_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
255		state->m_gp98_reel3_tilemap = tilemap_create(machine,get_jingbell_reel3_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
256		state->m_gp98_reel4_tilemap = tilemap_create(machine,get_jingbell_reel4_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
	253	state->m_gp98_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_jingbell_reel1_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
	254	state->m_gp98_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_jingbell_reel2_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
	255	state->m_gp98_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_jingbell_reel3_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
	256	state->m_gp98_reel4_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_jingbell_reel4_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
257	257
258	258	state->m_gp98_reel1_tilemap->set_scroll_cols(128);
259	259	state->m_gp98_reel2_tilemap->set_scroll_cols(128);
r17672	r17673
265	265	static VIDEO_START(gp98)
266	266	{
267	267	igs009_state *state = machine.driver_data<igs009_state>();
268		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   0x80,0x20);
	268	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   0x80,0x20);
269	269	state->m_fg_tilemap->set_transparent_pen(0);
270	270
271		state->m_gp98_reel1_tilemap = tilemap_create(machine,get_gp98_reel1_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
272		state->m_gp98_reel2_tilemap = tilemap_create(machine,get_gp98_reel2_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
273		state->m_gp98_reel3_tilemap = tilemap_create(machine,get_gp98_reel3_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
274		state->m_gp98_reel4_tilemap = tilemap_create(machine,get_gp98_reel4_tile_info,TILEMAP_SCAN_ROWS,8,32, 128, 8);
	271	state->m_gp98_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_gp98_reel1_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
	272	state->m_gp98_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_gp98_reel2_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
	273	state->m_gp98_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_gp98_reel3_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
	274	state->m_gp98_reel4_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(igs009_state::get_gp98_reel4_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 128, 8);
275	275
276	276	state->m_gp98_reel1_tilemap->set_scroll_cols(128);
277	277	state->m_gp98_reel2_tilemap->set_scroll_cols(128);

trunk/src/mame/drivers/dacholer.c

r17672	r17673
83	83	DECLARE_WRITE8_MEMBER(snd_irq_w);
84	84	DECLARE_WRITE8_MEMBER(music_irq_w);
85	85	DECLARE_CUSTOM_INPUT_MEMBER(snd_ack_r);
	86	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	87	TILE_GET_INFO_MEMBER(get_fg_tile_info);
86	88	};
87	89
88		static TILE_GET_INFO( get_bg_tile_info )
	90	TILE_GET_INFO_MEMBER(dacholer_state::get_bg_tile_info)
89	91	{
90		dacholer_state *state = machine.driver_data<dacholer_state>();
91		SET_TILE_INFO(1, state->m_bgvideoram[tile_index] + state->m_bg_bank * 0x100, 0, 0);
	92	SET_TILE_INFO_MEMBER(1, m_bgvideoram[tile_index] + m_bg_bank * 0x100, 0, 0);
92	93	}
93	94
94		static TILE_GET_INFO( get_fg_tile_info )
	95	TILE_GET_INFO_MEMBER(dacholer_state::get_fg_tile_info)
95	96	{
96		dacholer_state *state = machine.driver_data<dacholer_state>();
97		SET_TILE_INFO(0, state->m_fgvideoram[tile_index], 0, 0);
	97	SET_TILE_INFO_MEMBER(0, m_fgvideoram[tile_index], 0, 0);
98	98	}
99	99
100	100	static VIDEO_START( dacholer )
101	101	{
102	102	dacholer_state *state = machine.driver_data<dacholer_state>();
103		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
104		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	103	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dacholer_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	104	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dacholer_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
105	105
106	106	state->m_fg_tilemap->set_transparent_pen(0);
107	107	}

trunk/src/mame/drivers/cb2001.c

r17672	r17673
66	66	DECLARE_WRITE16_MEMBER(cb2001_vidctrl_w);
67	67	DECLARE_WRITE16_MEMBER(cb2001_vidctrl2_w);
68	68	DECLARE_WRITE16_MEMBER(cb2001_bg_w);
	69	TILE_GET_INFO_MEMBER(get_cb2001_reel1_tile_info);
	70	TILE_GET_INFO_MEMBER(get_cb2001_reel2_tile_info);
	71	TILE_GET_INFO_MEMBER(get_cb2001_reel3_tile_info);
69	72	};
70	73
71	74
r17672	r17673
456	459	}
457	460
458	461
459		static TILE_GET_INFO( get_cb2001_reel1_tile_info )
	462	TILE_GET_INFO_MEMBER(cb2001_state::get_cb2001_reel1_tile_info)
460	463	{
461		cb2001_state *state = machine.driver_data<cb2001_state>();
462		int code = state->m_vram_bg[(0x0000/2) + tile_index/2];
	464	int code = m_vram_bg[(0x0000/2) + tile_index/2];
463	465
464	466	if (tile_index&1)
465	467	code >>=8;
r17672	r17673
468	470
469	471	int colour = 0;//= (cb2001_out_c&0x7) + 8;
470	472
471		SET_TILE_INFO(
	473	SET_TILE_INFO_MEMBER(
472	474	1,
473	475	code+0x800,
474	476	colour,
475	477	0);
476	478	}
477	479
478		static TILE_GET_INFO( get_cb2001_reel2_tile_info )
	480	TILE_GET_INFO_MEMBER(cb2001_state::get_cb2001_reel2_tile_info)
479	481	{
480		cb2001_state *state = machine.driver_data<cb2001_state>();
481		int code = state->m_vram_bg[(0x0200/2) + tile_index/2];
	482	int code = m_vram_bg[(0x0200/2) + tile_index/2];
482	483
483	484	if (tile_index&1)
484	485	code >>=8;
r17672	r17673
487	488
488	489	int colour = 0;//(cb2001_out_c&0x7) + 8;
489	490
490		SET_TILE_INFO(
	491	SET_TILE_INFO_MEMBER(
491	492	1,
492	493	code+0x800,
493	494	colour,
r17672	r17673
495	496	}
496	497
497	498
498		static TILE_GET_INFO( get_cb2001_reel3_tile_info )
	499	TILE_GET_INFO_MEMBER(cb2001_state::get_cb2001_reel3_tile_info)
499	500	{
500		cb2001_state *state = machine.driver_data<cb2001_state>();
501		int code = state->m_vram_bg[(0x0400/2) + tile_index/2];
	501	int code = m_vram_bg[(0x0400/2) + tile_index/2];
502	502	int colour = 0;//(cb2001_out_c&0x7) + 8;
503	503
504	504	if (tile_index&1)
r17672	r17673
506	506
507	507	code &=0xff;
508	508
509		SET_TILE_INFO(
	509	SET_TILE_INFO_MEMBER(
510	510	1,
511	511	code+0x800,
512	512	colour,
r17672	r17673
517	517	static VIDEO_START(cb2001)
518	518	{
519	519	cb2001_state *state = machine.driver_data<cb2001_state>();
520		state->m_reel1_tilemap = tilemap_create(machine,get_cb2001_reel1_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
521		state->m_reel2_tilemap = tilemap_create(machine,get_cb2001_reel2_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
522		state->m_reel3_tilemap = tilemap_create(machine,get_cb2001_reel3_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	520	state->m_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cb2001_state::get_cb2001_reel1_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	521	state->m_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cb2001_state::get_cb2001_reel2_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	522	state->m_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cb2001_state::get_cb2001_reel3_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
523	523
524	524	state->m_reel1_tilemap->set_scroll_cols(64);
525	525	state->m_reel2_tilemap->set_scroll_cols(64);

trunk/src/mame/drivers/wallc.c

r17672	r17673
66	66	DECLARE_WRITE8_MEMBER(wallc_coin_counter_w);
67	67	DECLARE_DRIVER_INIT(wallc);
68	68	DECLARE_DRIVER_INIT(wallca);
	69	TILE_GET_INFO_MEMBER(get_bg_tile_info);
69	70	};
70	71
71	72
r17672	r17673
139	140	m_bg_tilemap->mark_tile_dirty(offset);
140	141	}
141	142
142		static TILE_GET_INFO( get_bg_tile_info )
	143	TILE_GET_INFO_MEMBER(wallc_state::get_bg_tile_info)
143	144	{
144		wallc_state *state = machine.driver_data<wallc_state>();
145		UINT8 *videoram = state->m_videoram;
146		SET_TILE_INFO(0, videoram[tile_index] + 0x100, 1, 0);
	145	UINT8 *videoram = m_videoram;
	146	SET_TILE_INFO_MEMBER(0, videoram[tile_index] + 0x100, 1, 0);
147	147	}
148	148
149	149	static VIDEO_START( wallc )
150	150	{
151	151	wallc_state *state = machine.driver_data<wallc_state>();
152		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_COLS_FLIP_Y,   8, 8, 32, 32);
	152	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(wallc_state::get_bg_tile_info),state), TILEMAP_SCAN_COLS_FLIP_Y,   8, 8, 32, 32);
153	153	}
154	154
155	155	static SCREEN_UPDATE_IND16( wallc )

trunk/src/mame/drivers/marinedt.c

r17672	r17673
147	147	DECLARE_WRITE8_MEMBER(marinedt_sound_w);
148	148	DECLARE_WRITE8_MEMBER(marinedt_pd_w);
149	149	DECLARE_WRITE8_MEMBER(marinedt_pf_w);
	150	TILE_GET_INFO_MEMBER(get_tile_info);
150	151	};
151	152
152	153
r17672	r17673
477	478	}
478	479
479	480
480		static TILE_GET_INFO( get_tile_info )
	481	TILE_GET_INFO_MEMBER(marinedt_state::get_tile_info)
481	482	{
482		marinedt_state *state = machine.driver_data<marinedt_state>();
483		int code = state->m_tx_tileram[tile_index];
	483	int code = m_tx_tileram[tile_index];
484	484	int color = 0;
485	485	int flags = TILE_FLIPX;
486	486
487		SET_TILE_INFO(0, code, color, flags);
	487	SET_TILE_INFO_MEMBER(0, code, color, flags);
488	488	}
489	489
490	490	static VIDEO_START( marinedt )
491	491	{
492	492	marinedt_state *state = machine.driver_data<marinedt_state>();
493		state->m_tx_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	493	state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(marinedt_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
494	494
495	495	state->m_tx_tilemap->set_transparent_pen(0);
496	496	state->m_tx_tilemap->set_scrolldx(0, 4*8);

trunk/src/mame/drivers/subsino.c

r17672	r17673
293	293	DECLARE_DRIVER_INIT(sharkpye);
294	294	DECLARE_DRIVER_INIT(tisub);
295	295	DECLARE_DRIVER_INIT(mtrainnv);
	296	TILE_GET_INFO_MEMBER(get_tile_info);
	297	TILE_GET_INFO_MEMBER(get_stisub_tile_info);
	298	TILE_GET_INFO_MEMBER(get_subsino_reel1_tile_info);
	299	TILE_GET_INFO_MEMBER(get_stisub_reel1_tile_info);
	300	TILE_GET_INFO_MEMBER(get_subsino_reel2_tile_info);
	301	TILE_GET_INFO_MEMBER(get_stisub_reel2_tile_info);
	302	TILE_GET_INFO_MEMBER(get_subsino_reel3_tile_info);
	303	TILE_GET_INFO_MEMBER(get_stisub_reel3_tile_info);
296	304	};
297	305
298	306
r17672	r17673
321	329	m_tmap->mark_tile_dirty(offset);
322	330	}
323	331
324		static TILE_GET_INFO( get_tile_info )
	332	TILE_GET_INFO_MEMBER(subsino_state::get_tile_info)
325	333	{
326		subsino_state *state = machine.driver_data<subsino_state>();
327		UINT16 code = state->m_videoram[ tile_index ] + (state->m_colorram[ tile_index ] << 8);
	334	UINT16 code = m_videoram[ tile_index ] + (m_colorram[ tile_index ] << 8);
328	335	UINT16 color = (code >> 8) & 0x0f;
329	336	code = ((code & 0xf000) >> 4) + ((code & 0xff) >> 0);
330		code += state->m_tiles_offset;
331		SET_TILE_INFO(0, code, color, 0);
	337	code += m_tiles_offset;
	338	SET_TILE_INFO_MEMBER(0, code, color, 0);
332	339	}
333	340
334		static TILE_GET_INFO( get_stisub_tile_info )
	341	TILE_GET_INFO_MEMBER(subsino_state::get_stisub_tile_info)
335	342	{
336		subsino_state *state = machine.driver_data<subsino_state>();
337		UINT16 code = state->m_videoram[ tile_index ] + (state->m_colorram[ tile_index ] << 8);
	343	UINT16 code = m_videoram[ tile_index ] + (m_colorram[ tile_index ] << 8);
338	344	code&= 0x3fff;
339		SET_TILE_INFO(0, code, 0, 0);
	345	SET_TILE_INFO_MEMBER(0, code, 0, 0);
340	346	}
341	347
342	348
343	349	static VIDEO_START( subsino )
344	350	{
345	351	subsino_state *state = machine.driver_data<subsino_state>();
346		state->m_tmap = tilemap_create(   machine, get_tile_info, TILEMAP_SCAN_ROWS, 8,8, 0x40,0x20 );
	352	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8,8, 0x40,0x20 );
347	353	state->m_tmap->set_transparent_pen(0 );
348	354	state->m_tiles_offset = 0;
349	355	}
r17672	r17673
356	362	m_reel1_tilemap->mark_tile_dirty(offset);
357	363	}
358	364
359		static TILE_GET_INFO( get_subsino_reel1_tile_info )
	365	TILE_GET_INFO_MEMBER(subsino_state::get_subsino_reel1_tile_info)
360	366	{
361		subsino_state *state = machine.driver_data<subsino_state>();
362		int code = state->m_reel1_ram[tile_index];
363		int colour = (state->m_out_c&0x7) + 8;
	367	int code = m_reel1_ram[tile_index];
	368	int colour = (m_out_c&0x7) + 8;
364	369
365		SET_TILE_INFO(
	370	SET_TILE_INFO_MEMBER(
366	371	1,
367	372	code,
368	373	colour,
369	374	0);
370	375	}
371	376
372		static TILE_GET_INFO( get_stisub_reel1_tile_info )
	377	TILE_GET_INFO_MEMBER(subsino_state::get_stisub_reel1_tile_info)
373	378	{
374		subsino_state *state = machine.driver_data<subsino_state>();
375		int code = state->m_reel1_ram[tile_index];
376		int attr = state->m_reel1_attr[tile_index];
	379	int code = m_reel1_ram[tile_index];
	380	int attr = m_reel1_attr[tile_index];
377	381
378		SET_TILE_INFO(
	382	SET_TILE_INFO_MEMBER(
379	383	1,
380	384	code | (attr << 8),
381	385	0,
r17672	r17673
389	393	m_reel2_tilemap->mark_tile_dirty(offset);
390	394	}
391	395
392		static TILE_GET_INFO( get_subsino_reel2_tile_info )
	396	TILE_GET_INFO_MEMBER(subsino_state::get_subsino_reel2_tile_info)
393	397	{
394		subsino_state *state = machine.driver_data<subsino_state>();
395		int code = state->m_reel2_ram[tile_index];
396		int colour = (state->m_out_c&0x7) + 8;
	398	int code = m_reel2_ram[tile_index];
	399	int colour = (m_out_c&0x7) + 8;
397	400
398		SET_TILE_INFO(
	401	SET_TILE_INFO_MEMBER(
399	402	1,
400	403	code,
401	404	colour,
402	405	0);
403	406	}
404	407
405		static TILE_GET_INFO( get_stisub_reel2_tile_info )
	408	TILE_GET_INFO_MEMBER(subsino_state::get_stisub_reel2_tile_info)
406	409	{
407		subsino_state *state = machine.driver_data<subsino_state>();
408		int code = state->m_reel2_ram[tile_index];
409		int attr = state->m_reel2_attr[tile_index];
	410	int code = m_reel2_ram[tile_index];
	411	int attr = m_reel2_attr[tile_index];
410	412
411		SET_TILE_INFO(
	413	SET_TILE_INFO_MEMBER(
412	414	1,
413	415	code | (attr << 8),
414	416	0,
r17672	r17673
421	423	m_reel3_tilemap->mark_tile_dirty(offset);
422	424	}
423	425
424		static TILE_GET_INFO( get_subsino_reel3_tile_info )
	426	TILE_GET_INFO_MEMBER(subsino_state::get_subsino_reel3_tile_info)
425	427	{
426		subsino_state *state = machine.driver_data<subsino_state>();
427		int code = state->m_reel3_ram[tile_index];
428		int colour = (state->m_out_c&0x7) + 8;
	428	int code = m_reel3_ram[tile_index];
	429	int colour = (m_out_c&0x7) + 8;
429	430
430		SET_TILE_INFO(
	431	SET_TILE_INFO_MEMBER(
431	432	1,
432	433	code,
433	434	colour,
434	435	0);
435	436	}
436	437
437		static TILE_GET_INFO( get_stisub_reel3_tile_info )
	438	TILE_GET_INFO_MEMBER(subsino_state::get_stisub_reel3_tile_info)
438	439	{
439		subsino_state *state = machine.driver_data<subsino_state>();
440		int code = state->m_reel3_ram[tile_index];
441		int attr = state->m_reel3_attr[tile_index];
	440	int code = m_reel3_ram[tile_index];
	441	int attr = m_reel3_attr[tile_index];
442	442
443		SET_TILE_INFO(
	443	SET_TILE_INFO_MEMBER(
444	444	1,
445	445	code | (attr << 8),
446	446	0,
r17672	r17673
453	453	subsino_state *state = machine.driver_data<subsino_state>();
454	454	VIDEO_START_CALL( subsino );
455	455
456		state->m_reel1_tilemap = tilemap_create(machine,get_subsino_reel1_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
457		state->m_reel2_tilemap = tilemap_create(machine,get_subsino_reel2_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
458		state->m_reel3_tilemap = tilemap_create(machine,get_subsino_reel3_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	456	state->m_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_subsino_reel1_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	457	state->m_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_subsino_reel2_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	458	state->m_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_subsino_reel3_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
459	459
460	460	state->m_reel1_tilemap->set_scroll_cols(64);
461	461	state->m_reel2_tilemap->set_scroll_cols(64);
r17672	r17673
466	466	static VIDEO_START( stisub )
467	467	{
468	468	subsino_state *state = machine.driver_data<subsino_state>();
469		state->m_tmap = tilemap_create(   machine, get_stisub_tile_info, TILEMAP_SCAN_ROWS, 8,8, 0x40,0x20 );
	469	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_stisub_tile_info),state), TILEMAP_SCAN_ROWS, 8,8, 0x40,0x20 );
470	470	state->m_tmap->set_transparent_pen(0 );
471	471
472		state->m_reel1_tilemap = tilemap_create(machine,get_stisub_reel1_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
473		state->m_reel2_tilemap = tilemap_create(machine,get_stisub_reel2_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
474		state->m_reel3_tilemap = tilemap_create(machine,get_stisub_reel3_tile_info,TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	472	state->m_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_stisub_reel1_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	473	state->m_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_stisub_reel2_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
	474	state->m_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(subsino_state::get_stisub_reel3_tile_info),state),TILEMAP_SCAN_ROWS, 8, 32, 64, 8);
475	475
476	476	state->m_reel1_tilemap->set_scroll_cols(64);
477	477	state->m_reel2_tilemap->set_scroll_cols(64);

trunk/src/mame/drivers/flyball.c

r17672	r17673
54	54	DECLARE_WRITE8_MEMBER(flyball_pitcher_vert_w);
55	55	DECLARE_WRITE8_MEMBER(flyball_pitcher_horz_w);
56	56	DECLARE_WRITE8_MEMBER(flyball_misc_w);
	57	TILEMAP_MAPPER_MEMBER(flyball_get_memory_offset);
	58	TILE_GET_INFO_MEMBER(flyball_get_tile_info);
57	59	};
58	60
59	61
r17672	r17673
63	65	*
64	66	*************************************/
65	67
66		static TILEMAP_MAPPER( flyball_get_memory_offset )
	68	TILEMAP_MAPPER_MEMBER(flyball_state::flyball_get_memory_offset)
67	69	{
68	70	if (col == 0)
69	71	col = num_cols;
r17672	r17673
72	74	}
73	75
74	76
75		static TILE_GET_INFO( flyball_get_tile_info )
	77	TILE_GET_INFO_MEMBER(flyball_state::flyball_get_tile_info)
76	78	{
77		flyball_state *state = machine.driver_data<flyball_state>();
78		UINT8 data = state->m_playfield_ram[tile_index];
	79	UINT8 data = m_playfield_ram[tile_index];
79	80	int flags = ((data & 0x40) ? TILE_FLIPX : 0) | ((data & 0x80) ? TILE_FLIPY : 0);
80	81	int code = data & 63;
81	82
r17672	r17673
84	85	code += 64;
85	86	}
86	87
87		SET_TILE_INFO(0, code, 0, flags);
	88	SET_TILE_INFO_MEMBER(0, code, 0, flags);
88	89	}
89	90
90	91
91	92	static VIDEO_START( flyball )
92	93	{
93	94	flyball_state *state = machine.driver_data<flyball_state>();
94		state->m_tmap = tilemap_create(machine, flyball_get_tile_info, flyball_get_memory_offset, 8, 16, 32, 16);
	95	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(flyball_state::flyball_get_tile_info),state), tilemap_mapper_delegate(FUNC(flyball_state::flyball_get_memory_offset),state), 8, 16, 32, 16);
95	96	}
96	97
97	98

trunk/src/mame/drivers/pturn.c

r17672	r17673
113	113	DECLARE_READ8_MEMBER(pturn_protection_r);
114	114	DECLARE_READ8_MEMBER(pturn_protection2_r);
115	115	DECLARE_DRIVER_INIT(pturn);
	116	TILE_GET_INFO_MEMBER(get_pturn_tile_info);
	117	TILE_GET_INFO_MEMBER(get_pturn_bg_tile_info);
116	118	};
117	119
118	120
r17672	r17673
126	128	0xa0, 0xb0, 0xe0, 0xf0
127	129	};
128	130
129		static TILE_GET_INFO( get_pturn_tile_info )
	131	TILE_GET_INFO_MEMBER(pturn_state::get_pturn_tile_info)
130	132	{
131		pturn_state *state = machine.driver_data<pturn_state>();
132		UINT8 *videoram = state->m_videoram;
	133	UINT8 *videoram = m_videoram;
133	134	int tileno;
134	135	tileno = videoram[tile_index];
135	136
136		tileno=tile_lookup[tileno>>4]|(tileno&0xf)|(state->m_fgbank<<8);
	137	tileno=tile_lookup[tileno>>4]|(tileno&0xf)|(m_fgbank<<8);
137	138
138		SET_TILE_INFO(0,tileno,state->m_fgpalette,0);
	139	SET_TILE_INFO_MEMBER(0,tileno,m_fgpalette,0);
139	140	}
140	141
141	142
142	143
143		static TILE_GET_INFO( get_pturn_bg_tile_info )
	144	TILE_GET_INFO_MEMBER(pturn_state::get_pturn_bg_tile_info)
144	145	{
145		pturn_state *state = machine.driver_data<pturn_state>();
146	146	int tileno,palno;
147		tileno = state->memregion("user1")->base()[tile_index];
148		palno=state->m_bgpalette;
	147	tileno = memregion("user1")->base()[tile_index];
	148	palno=m_bgpalette;
149	149	if(palno==1)
150	150	{
151	151	palno=25;
152	152	}
153		SET_TILE_INFO(1,tileno+state->m_bgbank*256,palno,0);
	153	SET_TILE_INFO_MEMBER(1,tileno+m_bgbank*256,palno,0);
154	154	}
155	155
156	156	static VIDEO_START(pturn)
157	157	{
158	158	pturn_state *state = machine.driver_data<pturn_state>();
159		state->m_fgmap = tilemap_create(machine, get_pturn_tile_info,TILEMAP_SCAN_ROWS,8, 8,32,32);
	159	state->m_fgmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pturn_state::get_pturn_tile_info),state),TILEMAP_SCAN_ROWS,8, 8,32,32);
160	160	state->m_fgmap->set_transparent_pen(0);
161		state->m_bgmap = tilemap_create(machine, get_pturn_bg_tile_info,TILEMAP_SCAN_ROWS,8, 8,32,32*8);
	161	state->m_bgmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pturn_state::get_pturn_bg_tile_info),state),TILEMAP_SCAN_ROWS,8, 8,32,32*8);
162	162	state->m_bgmap->set_transparent_pen(0);
163	163	}
164	164

trunk/src/mame/drivers/jubilee.c

r17672	r17673
101	101	tilemap_t *m_bg_tilemap;
102	102	DECLARE_WRITE8_MEMBER(jubileep_videoram_w);
103	103	DECLARE_READ8_MEMBER(unk_r);
	104	TILE_GET_INFO_MEMBER(get_bg_tile_info);
104	105	};
105	106
106	107
r17672	r17673
116	117	}
117	118
118	119
119		static TILE_GET_INFO( get_bg_tile_info )
	120	TILE_GET_INFO_MEMBER(jubilee_state::get_bg_tile_info)
120	121	{
121		jubilee_state *state = machine.driver_data<jubilee_state>();
122		int code = state->m_videoram[tile_index];
	122	int code = m_videoram[tile_index];
123	123
124		SET_TILE_INFO( 0, code, 0, 0);
	124	SET_TILE_INFO_MEMBER( 0, code, 0, 0);
125	125	}
126	126
127	127
r17672	r17673
129	129	static VIDEO_START( jubileep )
130	130	{
131	131	jubilee_state *state = machine.driver_data<jubilee_state>();
132		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	132	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jubilee_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
133	133	}
134	134
135	135

trunk/src/mame/drivers/tattack.c

r17672	r17673
34	34	required_shared_ptr<UINT8> m_colorram;
35	35	tilemap_t *m_tmap;
36	36	DECLARE_DRIVER_INIT(tattack);
	37	TILE_GET_INFO_MEMBER(get_tile_info);
37	38	};
38	39
39	40
40	41
41		static TILE_GET_INFO( get_tile_info )
	42	TILE_GET_INFO_MEMBER(tattack_state::get_tile_info)
42	43	{
43		tattack_state *state = machine.driver_data<tattack_state>();
44		int code = state->m_videoram[tile_index];
45		int color = state->m_colorram[tile_index];
	44	int code = m_videoram[tile_index];
	45	int color = m_colorram[tile_index];
46	46
47	47	if((color&1 ) || (color>15) )
48	48	logerror("COLOR %i\n",color);
49	49
50	50	color>>=1;
51	51
52		SET_TILE_INFO(
	52	SET_TILE_INFO_MEMBER(
53	53	0,
54	54	code,
55	55	color,
r17672	r17673
67	67	static VIDEO_START( tattack )
68	68	{
69	69	tattack_state *state = machine.driver_data<tattack_state>();
70		state->m_tmap = tilemap_create( machine, get_tile_info,TILEMAP_SCAN_ROWS,8,8,32,32 );
	70	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(tattack_state::get_tile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32 );
71	71	}
72	72
73	73	static ADDRESS_MAP_START( mem, AS_PROGRAM, 8, tattack_state )

trunk/src/mame/drivers/dunhuang.c

r17672	r17673
117	117	DECLARE_WRITE8_MEMBER(dunhuang_rombank_w);
118	118	DECLARE_WRITE8_MEMBER(dunhuang_82_w);
119	119	DECLARE_READ8_MEMBER(dunhuang_dsw_r);
	120	TILE_GET_INFO_MEMBER(get_tile_info);
	121	TILE_GET_INFO_MEMBER(get_tile_info2);
120	122	};
121	123
122	124
r17672	r17673
125	127	***************************************************************************/
126	128
127	129
128		static TILE_GET_INFO( get_tile_info )
	130	TILE_GET_INFO_MEMBER(dunhuang_state::get_tile_info)
129	131	{
130		dunhuang_state *state = machine.driver_data<dunhuang_state>();
131		UINT16 code = state->m_videoram[tile_index];
132		UINT8 color = state->m_colorram[tile_index] & 0x0f;
133		SET_TILE_INFO(0, code, color, 0);
	132	UINT16 code = m_videoram[tile_index];
	133	UINT8 color = m_colorram[tile_index] & 0x0f;
	134	SET_TILE_INFO_MEMBER(0, code, color, 0);
134	135	}
135		static TILE_GET_INFO( get_tile_info2 )
	136	TILE_GET_INFO_MEMBER(dunhuang_state::get_tile_info2)
136	137	{
137		dunhuang_state *state = machine.driver_data<dunhuang_state>();
138		UINT16 code = state->m_videoram2[tile_index];
139		UINT8 color = state->m_colorram2[tile_index] & 0x0f;
140		SET_TILE_INFO(1, code, color, 0);
	138	UINT16 code = m_videoram2[tile_index];
	139	UINT8 color = m_colorram2[tile_index] & 0x0f;
	140	SET_TILE_INFO_MEMBER(1, code, color, 0);
141	141	}
142	142
143	143	static VIDEO_START(dunhuang)
144	144	{
145	145	dunhuang_state *state = machine.driver_data<dunhuang_state>();
146		state->m_tmap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8,8, 0x40,0x20);
147		state->m_tmap2 = tilemap_create(machine, get_tile_info2, TILEMAP_SCAN_ROWS, 8,32, 0x40,0x8);
	146	state->m_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dunhuang_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8,8, 0x40,0x20);
	147	state->m_tmap2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dunhuang_state::get_tile_info2),state), TILEMAP_SCAN_ROWS, 8,32, 0x40,0x8);
148	148
149	149	state->m_tmap->set_transparent_pen(0);
150	150	state->m_tmap2->set_transparent_pen(0);

trunk/src/mame/drivers/jackie.c

r17672	r17673
104	104	void show_out();
105	105	DECLARE_CUSTOM_INPUT_MEMBER(hopper_r);
106	106	DECLARE_DRIVER_INIT(jackie);
	107	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	108	TILE_GET_INFO_MEMBER(get_jackie_reel1_tile_info);
	109	TILE_GET_INFO_MEMBER(get_jackie_reel2_tile_info);
	110	TILE_GET_INFO_MEMBER(get_jackie_reel3_tile_info);
107	111	};
108	112
109	113
110	114
111	115
112		static TILE_GET_INFO( get_fg_tile_info )
	116	TILE_GET_INFO_MEMBER(jackie_state::get_fg_tile_info)
113	117	{
114		jackie_state *state = machine.driver_data<jackie_state>();
115		int code = state->m_fg_tile_ram[tile_index] | (state->m_fg_color_ram[tile_index] << 8);
	118	int code = m_fg_tile_ram[tile_index] | (m_fg_color_ram[tile_index] << 8);
116	119	int tile = code & 0x1fff;
117		SET_TILE_INFO(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
	120	SET_TILE_INFO_MEMBER(0, code, tile != 0x1fff ? ((code >> 12) & 0xe) + 1 : 0, 0);
118	121	}
119	122
120	123	WRITE8_MEMBER(jackie_state::fg_tile_w)
r17672	r17673
144	147	m_reel1_tilemap->mark_tile_dirty(offset);
145	148	}
146	149
147		static TILE_GET_INFO( get_jackie_reel1_tile_info )
	150	TILE_GET_INFO_MEMBER(jackie_state::get_jackie_reel1_tile_info)
148	151	{
149		jackie_state *state = machine.driver_data<jackie_state>();
150		int code = state->m_reel1_ram[tile_index];
151		SET_TILE_INFO(1, code, 0, 0);
	152	int code = m_reel1_ram[tile_index];
	153	SET_TILE_INFO_MEMBER(1, code, 0, 0);
152	154	}
153	155
154	156
r17672	r17673
159	161	m_reel2_tilemap->mark_tile_dirty(offset);
160	162	}
161	163
162		static TILE_GET_INFO( get_jackie_reel2_tile_info )
	164	TILE_GET_INFO_MEMBER(jackie_state::get_jackie_reel2_tile_info)
163	165	{
164		jackie_state *state = machine.driver_data<jackie_state>();
165		int code = state->m_reel2_ram[tile_index];
166		SET_TILE_INFO(1, code, 0, 0);
	166	int code = m_reel2_ram[tile_index];
	167	SET_TILE_INFO_MEMBER(1, code, 0, 0);
167	168	}
168	169
169	170
r17672	r17673
173	174	m_reel3_tilemap->mark_tile_dirty(offset);
174	175	}
175	176
176		static TILE_GET_INFO( get_jackie_reel3_tile_info )
	177	TILE_GET_INFO_MEMBER(jackie_state::get_jackie_reel3_tile_info)
177	178	{
178		jackie_state *state = machine.driver_data<jackie_state>();
179		int code = state->m_reel3_ram[tile_index];
180		SET_TILE_INFO(1, code, 0, 0);
	179	int code = m_reel3_ram[tile_index];
	180	SET_TILE_INFO_MEMBER(1, code, 0, 0);
181	181	}
182	182
183	183	static VIDEO_START(jackie)
184	184	{
185	185	jackie_state *state = machine.driver_data<jackie_state>();
186		state->m_reel1_tilemap = tilemap_create(machine,get_jackie_reel1_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 8);
187		state->m_reel2_tilemap = tilemap_create(machine,get_jackie_reel2_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 8);
188		state->m_reel3_tilemap = tilemap_create(machine,get_jackie_reel3_tile_info,TILEMAP_SCAN_ROWS,8,32, 64, 8);
	186	state->m_reel1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jackie_state::get_jackie_reel1_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 8);
	187	state->m_reel2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jackie_state::get_jackie_reel2_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 8);
	188	state->m_reel3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jackie_state::get_jackie_reel3_tile_info),state),TILEMAP_SCAN_ROWS,8,32, 64, 8);
189	189
190	190	state->m_reel1_tilemap->set_scroll_cols(64);
191	191	state->m_reel2_tilemap->set_scroll_cols(64);
192	192	state->m_reel3_tilemap->set_scroll_cols(64);
193	193
194		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
	194	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jackie_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   64, 32);
195	195	state->m_fg_tilemap->set_transparent_pen(0);
196	196	}
197	197

trunk/src/mame/drivers/blackt96.c

r17672	r17673
122	122	UINT16*       m_spriteram[8];
123	123	tilemap_t    *m_bg_tilemap[8];
124	124
	125	TILE_GET_INFO_MEMBER(get_bg0_tile_info);
	126	TILE_GET_INFO_MEMBER(get_bg1_tile_info);
	127	TILE_GET_INFO_MEMBER(get_bg2_tile_info);
	128	TILE_GET_INFO_MEMBER(get_bg3_tile_info);
	129	TILE_GET_INFO_MEMBER(get_bg4_tile_info);
	130	TILE_GET_INFO_MEMBER(get_bg5_tile_info);
	131	TILE_GET_INFO_MEMBER(get_bg6_tile_info);
	132	TILE_GET_INFO_MEMBER(get_bg7_tile_info);
125	133	};
126	134
127	135	#define GET_INFO( ram ) \
128		blackt96_state *state = machine.driver_data<blackt96_state>(); \
129	136	int tileno = (ram[tile_index*2+1] & 0x1fff); \
130	137	int rgn = (ram[tile_index*2+1] & 0x2000) >> 13; \
131	138	int flipyx = (ram[tile_index*2+1] & 0xc000)>>14; \
132	139	int col = (ram[tile_index*2] & 0x00ff); \
133	140	if (rgn==1) col >>=4; \
134		SET_TILE_INFO(1-rgn, tileno, col, TILE_FLIPYX(flipyx)); \
	141	SET_TILE_INFO_MEMBER(1-rgn, tileno, col, TILE_FLIPYX(flipyx)); \
135	142
136	143
137		static TILE_GET_INFO( get_bg0_tile_info ) { GET_INFO(state->m_spriteram0); }
138		static TILE_GET_INFO( get_bg1_tile_info ) { GET_INFO(state->m_spriteram1); }
139		static TILE_GET_INFO( get_bg2_tile_info ) { GET_INFO(state->m_spriteram2); }
140		static TILE_GET_INFO( get_bg3_tile_info ) { GET_INFO(state->m_spriteram3); }
141		static TILE_GET_INFO( get_bg4_tile_info ) { GET_INFO(state->m_spriteram4); }
142		static TILE_GET_INFO( get_bg5_tile_info ) { GET_INFO(state->m_spriteram5); }
143		static TILE_GET_INFO( get_bg6_tile_info ) { GET_INFO(state->m_spriteram6); }
144		static TILE_GET_INFO( get_bg7_tile_info ) { GET_INFO(state->m_spriteram7); }
	144	TILE_GET_INFO_MEMBER(blackt96_state::get_bg0_tile_info){ GET_INFO(m_spriteram0); }
	145	TILE_GET_INFO_MEMBER(blackt96_state::get_bg1_tile_info){ GET_INFO(m_spriteram1); }
	146	TILE_GET_INFO_MEMBER(blackt96_state::get_bg2_tile_info){ GET_INFO(m_spriteram2); }
	147	TILE_GET_INFO_MEMBER(blackt96_state::get_bg3_tile_info){ GET_INFO(m_spriteram3); }
	148	TILE_GET_INFO_MEMBER(blackt96_state::get_bg4_tile_info){ GET_INFO(m_spriteram4); }
	149	TILE_GET_INFO_MEMBER(blackt96_state::get_bg5_tile_info){ GET_INFO(m_spriteram5); }
	150	TILE_GET_INFO_MEMBER(blackt96_state::get_bg6_tile_info){ GET_INFO(m_spriteram6); }
	151	TILE_GET_INFO_MEMBER(blackt96_state::get_bg7_tile_info){ GET_INFO(m_spriteram7); }
145	152
146	153	WRITE16_MEMBER(blackt96_state::bg_videoram0_w) { COMBINE_DATA(&m_spriteram0[offset]); m_bg_tilemap[0]->mark_tile_dirty(offset/2); }
147	154	WRITE16_MEMBER(blackt96_state::bg_videoram1_w) { COMBINE_DATA(&m_spriteram1[offset]); m_bg_tilemap[1]->mark_tile_dirty(offset/2); }
r17672	r17673
156	163	{
157	164	blackt96_state *state = machine.driver_data<blackt96_state>();
158	165
159		state->m_bg_tilemap[0] = tilemap_create(machine, get_bg0_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
160		state->m_bg_tilemap[1] = tilemap_create(machine, get_bg1_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
161		state->m_bg_tilemap[2] = tilemap_create(machine, get_bg2_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
162		state->m_bg_tilemap[3] = tilemap_create(machine, get_bg3_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
163		state->m_bg_tilemap[4] = tilemap_create(machine, get_bg4_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
164		state->m_bg_tilemap[5] = tilemap_create(machine, get_bg5_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
165		state->m_bg_tilemap[6] = tilemap_create(machine, get_bg6_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
166		state->m_bg_tilemap[7] = tilemap_create(machine, get_bg7_tile_info, TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	166	state->m_bg_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg0_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	167	state->m_bg_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg1_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	168	state->m_bg_tilemap[2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg2_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	169	state->m_bg_tilemap[3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg3_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	170	state->m_bg_tilemap[4] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg4_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	171	state->m_bg_tilemap[5] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg5_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	172	state->m_bg_tilemap[6] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg6_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
	173	state->m_bg_tilemap[7] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(blackt96_state::get_bg7_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 32, 32);
167	174
168	175	state->m_spriteram[0] = state->m_spriteram0;
169	176	state->m_spriteram[1] = state->m_spriteram1;

trunk/src/mame/drivers/dreamwld.c

r17672	r17673
158	158	DECLARE_WRITE32_MEMBER(dreamwld_6295_0_bank_w);
159	159	DECLARE_WRITE32_MEMBER(dreamwld_6295_1_bank_w);
160	160	DECLARE_WRITE32_MEMBER(dreamwld_palette_w);
	161	TILE_GET_INFO_MEMBER(get_dreamwld_bg_tile_info);
	162	TILE_GET_INFO_MEMBER(get_dreamwld_bg2_tile_info);
161	163	};
162	164
163	165
r17672	r17673
234	236	m_bg_tilemap->mark_tile_dirty(offset * 2 + 1);
235	237	}
236	238
237		static TILE_GET_INFO( get_dreamwld_bg_tile_info )
	239	TILE_GET_INFO_MEMBER(dreamwld_state::get_dreamwld_bg_tile_info)
238	240	{
239		dreamwld_state *state = machine.driver_data<dreamwld_state>();
240	241	int tileno, colour;
241		tileno = (tile_index & 1) ? (state->m_bg_videoram[tile_index >> 1] & 0xffff) : ((state->m_bg_videoram[tile_index >> 1] >> 16) & 0xffff);
	242	tileno = (tile_index & 1) ? (m_bg_videoram[tile_index >> 1] & 0xffff) : ((m_bg_videoram[tile_index >> 1] >> 16) & 0xffff);
242	243	colour = tileno >> 13;
243	244	tileno &= 0x1fff;
244		SET_TILE_INFO(1, tileno + state->m_tilebank[0] * 0x2000, 0x80 + colour, 0);
	245	SET_TILE_INFO_MEMBER(1, tileno + m_tilebank[0] * 0x2000, 0x80 + colour, 0);
245	246	}
246	247
247	248
r17672	r17673
252	253	m_bg2_tilemap->mark_tile_dirty(offset * 2 + 1);
253	254	}
254	255
255		static TILE_GET_INFO( get_dreamwld_bg2_tile_info )
	256	TILE_GET_INFO_MEMBER(dreamwld_state::get_dreamwld_bg2_tile_info)
256	257	{
257		dreamwld_state *state = machine.driver_data<dreamwld_state>();
258	258	UINT16 tileno, colour;
259		tileno = (tile_index & 1) ? (state->m_bg2_videoram[tile_index >> 1] & 0xffff) : ((state->m_bg2_videoram[tile_index >> 1] >> 16) & 0xffff);
	259	tileno = (tile_index & 1) ? (m_bg2_videoram[tile_index >> 1] & 0xffff) : ((m_bg2_videoram[tile_index >> 1] >> 16) & 0xffff);
260	260	colour = tileno >> 13;
261	261	tileno &= 0x1fff;
262		SET_TILE_INFO(1, tileno + state->m_tilebank[1] * 0x2000, 0xc0 + colour, 0);
	262	SET_TILE_INFO_MEMBER(1, tileno + m_tilebank[1] * 0x2000, 0xc0 + colour, 0);
263	263	}
264	264
265	265	static VIDEO_START( dreamwld )
266	266	{
267	267	dreamwld_state *state = machine.driver_data<dreamwld_state>();
268	268
269		state->m_bg_tilemap = tilemap_create(machine, get_dreamwld_bg_tile_info,TILEMAP_SCAN_ROWS, 16, 16, 64,32);
270		state->m_bg2_tilemap = tilemap_create(machine, get_dreamwld_bg2_tile_info,TILEMAP_SCAN_ROWS, 16, 16, 64,32);
	269	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dreamwld_state::get_dreamwld_bg_tile_info),state),TILEMAP_SCAN_ROWS, 16, 16, 64,32);
	270	state->m_bg2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(dreamwld_state::get_dreamwld_bg2_tile_info),state),TILEMAP_SCAN_ROWS, 16, 16, 64,32);
271	271	state->m_bg2_tilemap->set_transparent_pen(0);
272	272
273	273	state->m_bg_tilemap->set_scroll_rows(256);   // line scrolling

trunk/src/mame/drivers/panicr.c

r17672	r17673
93	93	DECLARE_WRITE8_MEMBER(t5182shared_w);
94	94
95	95	DECLARE_DRIVER_INIT(panicr);
	96	TILE_GET_INFO_MEMBER(get_bgtile_info);
	97	TILE_GET_INFO_MEMBER(get_infotile_info);
	98	TILE_GET_INFO_MEMBER(get_txttile_info);
96	99	};
97	100
98	101
r17672	r17673
164	167	}
165	168
166	169
167		static TILE_GET_INFO( get_bgtile_info )
	170	TILE_GET_INFO_MEMBER(panicr_state::get_bgtile_info)
168	171	{
169	172	int code,attr;
170	173
171		code=machine.root_device().memregion("user1")->base()[tile_index];
172		attr=machine.root_device().memregion("user2")->base()[tile_index];
	174	code=machine().root_device().memregion("user1")->base()[tile_index];
	175	attr=machine().root_device().memregion("user2")->base()[tile_index];
173	176	code+=((attr&7)<<8);
174		SET_TILE_INFO(
	177	SET_TILE_INFO_MEMBER(
175	178	1,
176	179	code,
177	180	(attr & 0xf0) >> 4,
178	181	0);
179	182	}
180	183
181		static TILE_GET_INFO( get_infotile_info )
	184	TILE_GET_INFO_MEMBER(panicr_state::get_infotile_info)
182	185	{
183	186	int code,attr;
184	187
185		code=machine.root_device().memregion("user1")->base()[tile_index];
186		attr=machine.root_device().memregion("user2")->base()[tile_index];
	188	code=machine().root_device().memregion("user1")->base()[tile_index];
	189	attr=machine().root_device().memregion("user2")->base()[tile_index];
187	190	code+=((attr&7)<<8);
188		SET_TILE_INFO(
	191	SET_TILE_INFO_MEMBER(
189	192	2,
190	193	code,
191	194	(attr & 0xf0) >> 4,
192	195	0);
193	196	}
194	197
195		static TILE_GET_INFO( get_txttile_info )
	198	TILE_GET_INFO_MEMBER(panicr_state::get_txttile_info)
196	199	{
197		panicr_state *state = machine.driver_data<panicr_state>();
198		int code=state->m_textram[tile_index*4];
199		int attr=state->m_textram[tile_index*4+2];
	200	int code=m_textram[tile_index*4];
	201	int attr=m_textram[tile_index*4+2];
200	202	int color = attr & 0x07;
201	203
202	204	tileinfo.group = color;
203	205
204		SET_TILE_INFO(
	206	SET_TILE_INFO_MEMBER(
205	207	0,
206	208	code + ((attr & 8) << 5),
207	209	color,
r17672	r17673
213	215	{
214	216	panicr_state *state = machine.driver_data<panicr_state>();
215	217
216		state->m_bgtilemap = tilemap_create( machine, get_bgtile_info,TILEMAP_SCAN_ROWS,16,16,1024,16 );
217		state->m_infotilemap = tilemap_create( machine, get_infotile_info,TILEMAP_SCAN_ROWS,16,16,1024,16 ); // 3 more bitplanes, contains collision and priority data
	218	state->m_bgtilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(panicr_state::get_bgtile_info),state),TILEMAP_SCAN_ROWS,16,16,1024,16 );
	219	state->m_infotilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(panicr_state::get_infotile_info),state),TILEMAP_SCAN_ROWS,16,16,1024,16 ); // 3 more bitplanes, contains collision and priority data
218	220
219		state->m_txttilemap = tilemap_create( machine, get_txttile_info,TILEMAP_SCAN_ROWS,8,8,32,32 );
	221	state->m_txttilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(panicr_state::get_txttile_info),state),TILEMAP_SCAN_ROWS,8,8,32,32 );
220	222	colortable_configure_tilemap_groups(machine.colortable, state->m_txttilemap, machine.gfx[0], 0);
221	223	}
222	224

trunk/src/mame/drivers/sbowling.c

r17672	r17673
70	70	DECLARE_WRITE8_MEMBER(system_w);
71	71	DECLARE_WRITE8_MEMBER(graph_control_w);
72	72	DECLARE_READ8_MEMBER(controls_r);
	73	TILE_GET_INFO_MEMBER(get_sb_tile_info);
73	74	};
74	75
75		static TILE_GET_INFO( get_sb_tile_info )
	76	TILE_GET_INFO_MEMBER(sbowling_state::get_sb_tile_info)
76	77	{
77		sbowling_state *state = machine.driver_data<sbowling_state>();
78		UINT8 *rom = state->memregion("user1")->base();
79		int tileno = rom[tile_index + state->m_bgmap * 1024];
	78	UINT8 *rom = memregion("user1")->base();
	79	int tileno = rom[tile_index + m_bgmap * 1024];
80	80
81		SET_TILE_INFO(0, tileno, 0, 0);
	81	SET_TILE_INFO_MEMBER(0, tileno, 0, 0);
82	82	}
83	83
84	84	static void plot_pixel_sbw(bitmap_ind16 *tmpbitmap, int x, int y, int col, int flip)
r17672	r17673
129	129	sbowling_state *state = machine.driver_data<sbowling_state>();
130	130
131	131	state->m_tmpbitmap = auto_bitmap_ind16_alloc(machine,32*8,32*8);
132		state->m_sb_tilemap = tilemap_create(machine, get_sb_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	132	state->m_sb_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sbowling_state::get_sb_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
133	133	}
134	134
135	135	WRITE8_MEMBER(sbowling_state::pix_shift_w)

trunk/src/mame/drivers/good.c

r17672	r17673
54	54	tilemap_t  *m_fg_tilemap;
55	55	DECLARE_WRITE16_MEMBER(fg_tilemapram_w);
56	56	DECLARE_WRITE16_MEMBER(bg_tilemapram_w);
	57	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	58	TILE_GET_INFO_MEMBER(get_bg_tile_info);
57	59	};
58	60
59	61
r17672	r17673
63	65	m_fg_tilemap->mark_tile_dirty(offset / 2);
64	66	}
65	67
66		static TILE_GET_INFO( get_fg_tile_info )
	68	TILE_GET_INFO_MEMBER(good_state::get_fg_tile_info)
67	69	{
68		good_state *state = machine.driver_data<good_state>();
69		int tileno = state->m_fg_tilemapram[tile_index * 2];
70		int attr = state->m_fg_tilemapram[tile_index * 2 + 1] & 0xf;
71		SET_TILE_INFO(0, tileno, attr, 0);
	70	int tileno = m_fg_tilemapram[tile_index * 2];
	71	int attr = m_fg_tilemapram[tile_index * 2 + 1] & 0xf;
	72	SET_TILE_INFO_MEMBER(0, tileno, attr, 0);
72	73	}
73	74
74	75	WRITE16_MEMBER(good_state::bg_tilemapram_w)
r17672	r17673
77	78	m_bg_tilemap->mark_tile_dirty(offset / 2);
78	79	}
79	80
80		static TILE_GET_INFO( get_bg_tile_info )
	81	TILE_GET_INFO_MEMBER(good_state::get_bg_tile_info)
81	82	{
82		good_state *state = machine.driver_data<good_state>();
83		int tileno = state->m_bg_tilemapram[tile_index * 2];
84		int attr = state->m_bg_tilemapram[tile_index * 2 + 1] & 0xf;
85		SET_TILE_INFO(1, tileno, attr, 0);
	83	int tileno = m_bg_tilemapram[tile_index * 2];
	84	int attr = m_bg_tilemapram[tile_index * 2 + 1] & 0xf;
	85	SET_TILE_INFO_MEMBER(1, tileno, attr, 0);
86	86	}
87	87
88	88
r17672	r17673
90	90	static VIDEO_START( good )
91	91	{
92	92	good_state *state = machine.driver_data<good_state>();
93		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
94		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	93	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(good_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	94	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(good_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
95	95	state->m_fg_tilemap->set_transparent_pen(0xf);
96	96	}
97	97

trunk/src/mame/drivers/ettrivia.c

r17672	r17673
56	56	DECLARE_WRITE8_MEMBER(b000_w);
57	57	DECLARE_READ8_MEMBER(b000_r);
58	58	DECLARE_WRITE8_MEMBER(b800_w);
	59	TILE_GET_INFO_MEMBER(get_tile_info_bg);
	60	TILE_GET_INFO_MEMBER(get_tile_info_fg);
59	61	};
60	62
61	63
r17672	r17673
201	203	SET_TILE_INFO(gfx_code,code,color,0);
202	204	}
203	205
204		static TILE_GET_INFO( get_tile_info_bg )
	206	TILE_GET_INFO_MEMBER(ettrivia_state::get_tile_info_bg)
205	207	{
206		ettrivia_state *state = machine.driver_data<ettrivia_state>();
207		get_tile_info(machine, tileinfo, tile_index, state->m_bg_videoram, 0);
	208	get_tile_info(machine(), tileinfo, tile_index, m_bg_videoram, 0);
208	209	}
209	210
210		static TILE_GET_INFO( get_tile_info_fg )
	211	TILE_GET_INFO_MEMBER(ettrivia_state::get_tile_info_fg)
211	212	{
212		ettrivia_state *state = machine.driver_data<ettrivia_state>();
213		get_tile_info(machine, tileinfo, tile_index, state->m_fg_videoram, 1);
	213	get_tile_info(machine(), tileinfo, tile_index, m_fg_videoram, 1);
214	214	}
215	215
216	216	static PALETTE_INIT( ettrivia )
r17672	r17673
253	253	static VIDEO_START( ettrivia )
254	254	{
255	255	ettrivia_state *state = machine.driver_data<ettrivia_state>();
256		state->m_bg_tilemap = tilemap_create( machine, get_tile_info_bg,TILEMAP_SCAN_ROWS,8,8,64,32 );
257		state->m_fg_tilemap = tilemap_create( machine, get_tile_info_fg,TILEMAP_SCAN_ROWS,8,8,64,32 );
	256	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ettrivia_state::get_tile_info_bg),state),TILEMAP_SCAN_ROWS,8,8,64,32 );
	257	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ettrivia_state::get_tile_info_fg),state),TILEMAP_SCAN_ROWS,8,8,64,32 );
258	258
259	259	state->m_fg_tilemap->set_transparent_pen(0);
260	260	}

trunk/src/mame/drivers/jalmah.c

r17672	r17673
191	191	DECLARE_DRIVER_INIT(kakumei2);
192	192	DECLARE_DRIVER_INIT(daireika);
193	193	DECLARE_DRIVER_INIT(mjzoomin);
	194	TILEMAP_MAPPER_MEMBER(range0_16x16);
	195	TILEMAP_MAPPER_MEMBER(range1_16x16);
	196	TILEMAP_MAPPER_MEMBER(range2_16x16);
	197	TILEMAP_MAPPER_MEMBER(range3_16x16);
	198	TILEMAP_MAPPER_MEMBER(range2_8x8);
	199	TILEMAP_MAPPER_MEMBER(range3_8x8);
	200	TILE_GET_INFO_MEMBER(get_sc0_tile_info);
	201	TILE_GET_INFO_MEMBER(get_sc1_tile_info);
	202	TILE_GET_INFO_MEMBER(get_sc2_tile_info);
	203	TILE_GET_INFO_MEMBER(get_sc3_tile_info);
194	204	};
195	205
196	206
r17672	r17673
201	211	******************************************************************************************/
202	212
203	213	/*4096x512 tilemap*/
204		static TILEMAP_MAPPER( range0_16x16 )
	214	TILEMAP_MAPPER_MEMBER(jalmah_state::range0_16x16)
205	215	{
206	216	/* logical (col,row) -> memory offset */
207	217	return (row & 0x0f) + ((col & 0xff) << 4) + ((row & 0x70) << 8);
208	218	}
209	219
210	220	/*2048x1024 tilemap*/
211		static TILEMAP_MAPPER( range1_16x16 )
	221	TILEMAP_MAPPER_MEMBER(jalmah_state::range1_16x16)
212	222	{
213	223	/* logical (col,row) -> memory offset */
214	224	return (row & 0x0f) + ((col & 0x7f) << 4) + ((row & 0xf0) << 7);
215	225	}
216	226
217	227	/*1024x2048 tilemap*/
218		static TILEMAP_MAPPER( range2_16x16 )
	228	TILEMAP_MAPPER_MEMBER(jalmah_state::range2_16x16)
219	229	{
220	230	/* logical (col,row) -> memory offset */
221	231	return (row & 0x0f) + ((col & 0x3f) << 4) + ((row & 0x1f0) << 6);
222	232	}
223	233
224	234	/*512x4096 tilemap*/
225		static TILEMAP_MAPPER( range3_16x16 )
	235	TILEMAP_MAPPER_MEMBER(jalmah_state::range3_16x16)
226	236	{
227	237	/* logical (col,row) -> memory offset */
228	238	return (row & 0x0f) + ((col & 0x1f) << 4) + ((row & 0x3f0) << 5);
r17672	r17673
230	240
231	241
232	242	/*1024x512 tilemap*/
233		static TILEMAP_MAPPER( range2_8x8 )
	243	TILEMAP_MAPPER_MEMBER(jalmah_state::range2_8x8)
234	244	{
235	245	/* logical (col,row) -> memory offset */
236	246	return (row & 0x1f) + ((col & 0x7f) * 0x20) + ((row & 0x20) * 0x80);
237	247	}
238	248
239	249	/*512x1024 tilemap*/
240		static TILEMAP_MAPPER( range3_8x8 )
	250	TILEMAP_MAPPER_MEMBER(jalmah_state::range3_8x8)
241	251	{
242	252	return (row & 0x1f) + ((col & 0x3f) * 0x20) + ((row & 0x60) * 0x40);
243	253	}
244	254
245		static TILE_GET_INFO( get_sc0_tile_info )
	255	TILE_GET_INFO_MEMBER(jalmah_state::get_sc0_tile_info)
246	256	{
247		jalmah_state *state = machine.driver_data<jalmah_state>();
248		int code = state->m_sc0_vram[tile_index];
249		SET_TILE_INFO(
	257	int code = m_sc0_vram[tile_index];
	258	SET_TILE_INFO_MEMBER(
250	259	3,
251		(code & 0xfff) + ((state->m_sc0bank & 3) << 12),
	260	(code & 0xfff) + ((m_sc0bank & 3) << 12),
252	261	code >> 12,
253	262	0);
254	263	}
255	264
256		static TILE_GET_INFO( get_sc1_tile_info )
	265	TILE_GET_INFO_MEMBER(jalmah_state::get_sc1_tile_info)
257	266	{
258		jalmah_state *state = machine.driver_data<jalmah_state>();
259		int code = state->m_sc1_vram[tile_index];
260		SET_TILE_INFO(
	267	int code = m_sc1_vram[tile_index];
	268	SET_TILE_INFO_MEMBER(
261	269	2,
262	270	code & 0xfff,
263	271	code >> 12,
264	272	0);
265	273	}
266	274
267		static TILE_GET_INFO( get_sc2_tile_info )
	275	TILE_GET_INFO_MEMBER(jalmah_state::get_sc2_tile_info)
268	276	{
269		jalmah_state *state = machine.driver_data<jalmah_state>();
270		int code = state->m_sc2_vram[tile_index];
271		SET_TILE_INFO(
	277	int code = m_sc2_vram[tile_index];
	278	SET_TILE_INFO_MEMBER(
272	279	1,
273	280	code & 0xfff,
274	281	code >> 12,
275	282	0);
276	283	}
277	284
278		static TILE_GET_INFO( get_sc3_tile_info )
	285	TILE_GET_INFO_MEMBER(jalmah_state::get_sc3_tile_info)
279	286	{
280		jalmah_state *state = machine.driver_data<jalmah_state>();
281		int code = state->m_sc3_vram[tile_index];
282		SET_TILE_INFO(
	287	int code = m_sc3_vram[tile_index];
	288	SET_TILE_INFO_MEMBER(
283	289	0,
284	290	code & 0xfff,
285	291	code >> 12,
r17672	r17673
289	295	static VIDEO_START( jalmah )
290	296	{
291	297	jalmah_state *state = machine.driver_data<jalmah_state>();
292		state->m_sc0_tilemap_0 = tilemap_create(machine, get_sc0_tile_info,range0_16x16,16,16,256,32);
293		state->m_sc0_tilemap_1 = tilemap_create(machine, get_sc0_tile_info,range1_16x16,16,16,128,64);
294		state->m_sc0_tilemap_2 = tilemap_create(machine, get_sc0_tile_info,range2_16x16,16,16,64,128);
295		state->m_sc0_tilemap_3 = tilemap_create(machine, get_sc0_tile_info,range3_16x16,16,16,32,256);
	298	state->m_sc0_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc0_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range0_16x16),state),16,16,256,32);
	299	state->m_sc0_tilemap_1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc0_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range1_16x16),state),16,16,128,64);
	300	state->m_sc0_tilemap_2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc0_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range2_16x16),state),16,16,64,128);
	301	state->m_sc0_tilemap_3 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc0_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range3_16x16),state),16,16,32,256);
296	302
297		state->m_sc1_tilemap_0 = tilemap_create(machine, get_sc1_tile_info,range0_16x16,16,16,256,32);
298		state->m_sc1_tilemap_1 = tilemap_create(machine, get_sc1_tile_info,range1_16x16,16,16,128,64);
299		state->m_sc1_tilemap_2 = tilemap_create(machine, get_sc1_tile_info,range2_16x16,16,16,64,128);
300		state->m_sc1_tilemap_3 = tilemap_create(machine, get_sc1_tile_info,range3_16x16,16,16,32,256);
	303	state->m_sc1_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc1_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range0_16x16),state),16,16,256,32);
	304	state->m_sc1_tilemap_1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc1_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range1_16x16),state),16,16,128,64);
	305	state->m_sc1_tilemap_2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc1_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range2_16x16),state),16,16,64,128);
	306	state->m_sc1_tilemap_3 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc1_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range3_16x16),state),16,16,32,256);
301	307
302		state->m_sc2_tilemap_0 = tilemap_create(machine, get_sc2_tile_info,range0_16x16,16,16,256,32);
303		state->m_sc2_tilemap_1 = tilemap_create(machine, get_sc2_tile_info,range1_16x16,16,16,128,64);
304		state->m_sc2_tilemap_2 = tilemap_create(machine, get_sc2_tile_info,range2_16x16,16,16,64,128);
305		state->m_sc2_tilemap_3 = tilemap_create(machine, get_sc2_tile_info,range3_16x16,16,16,32,256);
	308	state->m_sc2_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc2_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range0_16x16),state),16,16,256,32);
	309	state->m_sc2_tilemap_1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc2_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range1_16x16),state),16,16,128,64);
	310	state->m_sc2_tilemap_2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc2_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range2_16x16),state),16,16,64,128);
	311	state->m_sc2_tilemap_3 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc2_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range3_16x16),state),16,16,32,256);
306	312
307		state->m_sc3_tilemap_0 = tilemap_create(machine, get_sc3_tile_info,TILEMAP_SCAN_COLS,8,8,256,32);
308		//state->m_sc3_tilemap_1 = tilemap_create(machine, get_sc3_tile_info,TILEMAP_SCAN_COLS,8,8,256,32);
309		state->m_sc3_tilemap_2 = tilemap_create(machine, get_sc3_tile_info,range2_8x8,8,8,128,64);
310		state->m_sc3_tilemap_3 = tilemap_create(machine, get_sc3_tile_info,range3_8x8,8,8,64,128);
	313	state->m_sc3_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc3_tile_info),state),TILEMAP_SCAN_COLS,8,8,256,32);
	314	//state->m_sc3_tilemap_1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc3_tile_info),state),TILEMAP_SCAN_COLS,8,8,256,32);
	315	state->m_sc3_tilemap_2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc3_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range2_8x8),state),8,8,128,64);
	316	state->m_sc3_tilemap_3 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc3_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range3_8x8),state),8,8,64,128);
311	317
312	318	state->m_jm_scrollram = auto_alloc_array(machine, UINT16, 0x80/2);
313	319	state->m_jm_vregs = auto_alloc_array(machine, UINT16, 0x40/2);
r17672	r17673
336	342	static VIDEO_START( urashima )
337	343	{
338	344	jalmah_state *state = machine.driver_data<jalmah_state>();
339		state->m_sc0_tilemap_0 = tilemap_create(machine, get_sc0_tile_info,range0_16x16,16,16,256,32);
340		state->m_sc3_tilemap_0 = tilemap_create(machine, get_sc3_tile_info,range2_8x8,8,8,128,64);
	345	state->m_sc0_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc0_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range0_16x16),state),16,16,256,32);
	346	state->m_sc3_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jalmah_state::get_sc3_tile_info),state),tilemap_mapper_delegate(FUNC(jalmah_state::range2_8x8),state),8,8,128,64);
341	347
342	348	state->m_jm_scrollram = auto_alloc_array(machine, UINT16, 0x80/2);
343	349	state->m_jm_vregs = auto_alloc_array(machine, UINT16, 0x40/2);

trunk/src/mame/drivers/spoker.c

r17672	r17673
54	54	DECLARE_CUSTOM_INPUT_MEMBER(hopper_r);
55	55	DECLARE_DRIVER_INIT(spk116it);
56	56	DECLARE_DRIVER_INIT(3super8);
	57	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	58	TILE_GET_INFO_MEMBER(get_fg_tile_info);
57	59	};
58	60
59	61	WRITE8_MEMBER(spoker_state::bg_tile_w)
r17672	r17673
63	65	m_bg_tilemap->mark_tile_dirty(offset);
64	66	}
65	67
66		static TILE_GET_INFO( get_bg_tile_info )
	68	TILE_GET_INFO_MEMBER(spoker_state::get_bg_tile_info)
67	69	{
68		spoker_state *state = machine.driver_data<spoker_state>();
69		int code = state->m_bg_tile_ram[tile_index];
70		SET_TILE_INFO(1 + (tile_index & 3), code & 0xff, 0, 0);
	70	int code = m_bg_tile_ram[tile_index];
	71	SET_TILE_INFO_MEMBER(1 + (tile_index & 3), code & 0xff, 0, 0);
71	72	}
72	73
73		static TILE_GET_INFO( get_fg_tile_info )
	74	TILE_GET_INFO_MEMBER(spoker_state::get_fg_tile_info)
74	75	{
75		spoker_state *state = machine.driver_data<spoker_state>();
76		int code = state->m_fg_tile_ram[tile_index] | (state->m_fg_color_ram[tile_index] << 8);
77		SET_TILE_INFO(0, code, (4*(code >> 14)+3), 0);
	76	int code = m_fg_tile_ram[tile_index] | (m_fg_color_ram[tile_index] << 8);
	77	SET_TILE_INFO_MEMBER(0, code, (4*(code >> 14)+3), 0);
78	78	}
79	79
80	80	WRITE8_MEMBER(spoker_state::fg_tile_w)
r17672	r17673
95	95	{
96	96	spoker_state *state = machine.driver_data<spoker_state>();
97	97
98		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,   8,  32,   128, 8);
99		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,  8,   128, 32);
	98	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(spoker_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  32,   128, 8);
	99	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(spoker_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,   8,  8,   128, 32);
100	100	state->m_fg_tilemap->set_transparent_pen(0);
101	101	}
102	102

trunk/src/mame/drivers/sbrkout.c

r17672	r17673
62	62	DECLARE_READ8_MEMBER(sync_r);
63	63	DECLARE_READ8_MEMBER(sync2_r);
64	64	DECLARE_WRITE8_MEMBER(sbrkout_videoram_w);
	65	TILE_GET_INFO_MEMBER(get_bg_tile_info);
65	66	};
66	67
67	68
r17672	r17673
296	297	*
297	298	*************************************/
298	299
299		static TILE_GET_INFO( get_bg_tile_info )
	300	TILE_GET_INFO_MEMBER(sbrkout_state::get_bg_tile_info)
300	301	{
301		sbrkout_state *state = machine.driver_data<sbrkout_state>();
302		UINT8 *videoram = state->m_videoram;
	302	UINT8 *videoram = m_videoram;
303	303	int code = (videoram[tile_index] & 0x80) ? videoram[tile_index] : 0;
304		SET_TILE_INFO(0, code, 0, 0);
	304	SET_TILE_INFO_MEMBER(0, code, 0, 0);
305	305	}
306	306
307	307
308	308	static VIDEO_START( sbrkout )
309	309	{
310	310	sbrkout_state *state = machine.driver_data<sbrkout_state>();
311		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	311	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(sbrkout_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
312	312	}
313	313
314	314

trunk/src/mame/drivers/nmg5.c

r17672	r17673
270	270	DECLARE_DRIVER_INIT(prot_val_10);
271	271	DECLARE_DRIVER_INIT(prot_val_20);
272	272	DECLARE_DRIVER_INIT(prot_val_40);
	273	TILE_GET_INFO_MEMBER(fg_get_tile_info);
	274	TILE_GET_INFO_MEMBER(bg_get_tile_info);
273	275	};
274	276
275	277
r17672	r17673
836	838	PORT_BIT( 0x8000, IP_ACTIVE_LOW, IPT_START2 )
837	839	INPUT_PORTS_END
838	840
	841	TILE_GET_INFO_MEMBER(nmg5_state::fg_get_tile_info){ SET_TILE_INFO_MEMBER(0, m_fg_videoram[tile_index] | (m_gfx_bank << 16), 0, 0);}
	842	TILE_GET_INFO_MEMBER(nmg5_state::bg_get_tile_info){ SET_TILE_INFO_MEMBER(0, m_bg_videoram[tile_index] | (m_gfx_bank << 16), 1, 0);}
839	843
840		INLINE void get_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, UINT16 *vram, int color )
841		{
842		nmg5_state *state = machine.driver_data<nmg5_state>();
843		SET_TILE_INFO(0, vram[tile_index] | (state->m_gfx_bank << 16), color, 0);
844		}
845
846		static TILE_GET_INFO( fg_get_tile_info ) { nmg5_state *state = machine.driver_data<nmg5_state>();   get_tile_info(machine, tileinfo, tile_index, state->m_fg_videoram, 0); }
847		static TILE_GET_INFO( bg_get_tile_info ) { nmg5_state *state = machine.driver_data<nmg5_state>();   get_tile_info(machine, tileinfo, tile_index, state->m_bg_videoram, 1); }
848
849	844	static VIDEO_START( nmg5 )
850	845	{
851	846	nmg5_state *state = machine.driver_data<nmg5_state>();
852	847
853		state->m_bg_tilemap = tilemap_create(machine, bg_get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
854		state->m_fg_tilemap = tilemap_create(machine, fg_get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	848	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(nmg5_state::bg_get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	849	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(nmg5_state::fg_get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
855	850	state->m_fg_tilemap->set_transparent_pen(0);
856	851	}
857	852

trunk/src/mame/drivers/wink.c

r17672	r17673
39	39	DECLARE_WRITE8_MEMBER(prot_w);
40	40	DECLARE_READ8_MEMBER(sound_r);
41	41	DECLARE_DRIVER_INIT(wink);
	42	TILE_GET_INFO_MEMBER(get_bg_tile_info);
42	43	};
43	44
44	45
45		static TILE_GET_INFO( get_bg_tile_info )
	46	TILE_GET_INFO_MEMBER(wink_state::get_bg_tile_info)
46	47	{
47		wink_state *state = machine.driver_data<wink_state>();
48		UINT8 *videoram = state->m_videoram;
	48	UINT8 *videoram = m_videoram;
49	49	int code = videoram[tile_index];
50		code |= 0x200 * state->m_tile_bank;
	50	code |= 0x200 * m_tile_bank;
51	51
52	52	// the 2 parts of the screen use different tile banking
53	53	if(tile_index < 0x360)
r17672	r17673
55	55	code |= 0x100;
56	56	}
57	57
58		SET_TILE_INFO(0, code, 0, 0);
	58	SET_TILE_INFO_MEMBER(0, code, 0, 0);
59	59	}
60	60
61	61	static VIDEO_START( wink )
62	62	{
63	63	wink_state *state = machine.driver_data<wink_state>();
64		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	64	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(wink_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
65	65	}
66	66
67	67	static SCREEN_UPDATE_IND16( wink )

trunk/src/mame/drivers/safarir.c

r17672	r17673
73	73	DECLARE_READ8_MEMBER(ram_r);
74	74	DECLARE_WRITE8_MEMBER(ram_bank_w);
75	75	DECLARE_WRITE8_MEMBER(safarir_audio_w);
	76	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	77	TILE_GET_INFO_MEMBER(get_fg_tile_info);
76	78	};
77	79
78	80
r17672	r17673
146	148	}
147	149	}
148	150
149		static TILE_GET_INFO( get_bg_tile_info )
	151	TILE_GET_INFO_MEMBER(safarir_state::get_bg_tile_info)
150	152	{
151	153	int color;
152		address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
153		safarir_state *state = machine.driver_data<safarir_state>();
154		UINT8 code = state->ram_r(*space,tile_index | 0x400);
	154	address_space *space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	155	UINT8 code = ram_r(*space,tile_index | 0x400);
155	156
156	157	if (code & 0x80)
157	158	color = 6;   /* yellow */
r17672	r17673
165	166	color |= (tile_index & 0xc0) ? 1 : 0;
166	167	}
167	168
168		SET_TILE_INFO(0, code & 0x7f, color, 0);
	169	SET_TILE_INFO_MEMBER(0, code & 0x7f, color, 0);
169	170	}
170	171
171	172
172		static TILE_GET_INFO( get_fg_tile_info )
	173	TILE_GET_INFO_MEMBER(safarir_state::get_fg_tile_info)
173	174	{
174	175	int color, flags;
175		address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
176		safarir_state *state = machine.driver_data<safarir_state>();
177		UINT8 code = state->ram_r(*space,tile_index);
	176	address_space *space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	177	UINT8 code = ram_r(*space,tile_index);
178	178
179	179	if (code & 0x80)
180	180	color = 7;   /* white */
r17672	r17673
183	183
184	184	flags = ((tile_index & 0x1f) >= 0x03) ? 0 : TILE_FORCE_LAYER0;
185	185
186		SET_TILE_INFO(1, code & 0x7f, color, flags);
	186	SET_TILE_INFO_MEMBER(1, code & 0x7f, color, flags);
187	187	}
188	188
189	189
r17672	r17673
191	191	{
192	192	safarir_state *state = machine.driver_data<safarir_state>();
193	193
194		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
195		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	194	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(safarir_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	195	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(safarir_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
196	196
197	197	state->m_fg_tilemap->set_transparent_pen(0);
198	198	}

trunk/src/mame/drivers/pzletime.c

r17672	r17673
53	53	DECLARE_CUSTOM_INPUT_MEMBER(ticket_status_r);
54	54	DECLARE_WRITE16_MEMBER(eeprom_w);
55	55	DECLARE_WRITE16_MEMBER(oki_bank_w);
	56	TILE_GET_INFO_MEMBER(get_mid_tile_info);
	57	TILE_GET_INFO_MEMBER(get_txt_tile_info);
56	58	};
57	59
58	60
59		static TILE_GET_INFO( get_mid_tile_info )
	61	TILE_GET_INFO_MEMBER(pzletime_state::get_mid_tile_info)
60	62	{
61		pzletime_state *state = machine.driver_data<pzletime_state>();
62		int tileno = state->m_mid_videoram[tile_index] & 0x0fff;
63		int colour = state->m_mid_videoram[tile_index] & 0xf000;
	63	int tileno = m_mid_videoram[tile_index] & 0x0fff;
	64	int colour = m_mid_videoram[tile_index] & 0xf000;
64	65	colour = colour >> 12;
65		SET_TILE_INFO(2, tileno, colour, 0);
	66	SET_TILE_INFO_MEMBER(2, tileno, colour, 0);
66	67	}
67	68
68		static TILE_GET_INFO( get_txt_tile_info )
	69	TILE_GET_INFO_MEMBER(pzletime_state::get_txt_tile_info)
69	70	{
70		pzletime_state *state = machine.driver_data<pzletime_state>();
71		int tileno = state->m_txt_videoram[tile_index] & 0x0fff;
72		int colour = state->m_txt_videoram[tile_index] & 0xf000;
	71	int tileno = m_txt_videoram[tile_index] & 0x0fff;
	72	int colour = m_txt_videoram[tile_index] & 0xf000;
73	73	colour = colour >> 12;
74	74
75		SET_TILE_INFO(0, tileno, colour, 0);
	75	SET_TILE_INFO_MEMBER(0, tileno, colour, 0);
76	76
77	77	tileinfo.category = BIT(colour, 3);
78	78	}
r17672	r17673
81	81	{
82	82	pzletime_state *state = machine.driver_data<pzletime_state>();
83	83
84		state->m_mid_tilemap = tilemap_create(machine, get_mid_tile_info, TILEMAP_SCAN_COLS, 16, 16, 64, 16);
85		state->m_txt_tilemap = tilemap_create(machine, get_txt_tile_info, TILEMAP_SCAN_ROWS,  8, 8, 64, 32);
	84	state->m_mid_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pzletime_state::get_mid_tile_info),state), TILEMAP_SCAN_COLS, 16, 16, 64, 16);
	85	state->m_txt_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(pzletime_state::get_txt_tile_info),state), TILEMAP_SCAN_ROWS,  8, 8, 64, 32);
86	86
87	87	state->m_mid_tilemap->set_transparent_pen(0);
88	88	state->m_txt_tilemap->set_transparent_pen(0);

trunk/src/mame/drivers/tmspoker.c

r17672	r17673
227	227	//DECLARE_WRITE8_MEMBER(debug_w);
228	228	DECLARE_READ8_MEMBER(unk_r);
229	229	DECLARE_DRIVER_INIT(bus);
	230	TILE_GET_INFO_MEMBER(get_bg_tile_info);
230	231	};
231	232
232	233
r17672	r17673
241	242	}
242	243
243	244
244		static TILE_GET_INFO( get_bg_tile_info )
	245	TILE_GET_INFO_MEMBER(tmspoker_state::get_bg_tile_info)
245	246	{
246	247	/*  - bits -
247	248	7654 3210
r17672	r17673
249	250	---- ----   color code.
250	251	---- ----   seems unused.
251	252	*/
252		tmspoker_state *state = machine.driver_data<tmspoker_state>();
253		int code = state->m_videoram[tile_index];
	253	int code = m_videoram[tile_index];
254	254
255		SET_TILE_INFO( 0 /* bank */, code, 0 /* color */, 0);
	255	SET_TILE_INFO_MEMBER( 0 /* bank */, code, 0 /* color */, 0);
256	256	}
257	257
258	258	static VIDEO_START( tmspoker )
259	259	{
260	260	tmspoker_state *state = machine.driver_data<tmspoker_state>();
261		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	261	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(tmspoker_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
262	262	}
263	263
264	264	static SCREEN_UPDATE_IND16( tmspoker )

trunk/src/mame/drivers/jollyjgr.c

r17672	r17673
134	134	DECLARE_WRITE8_MEMBER(jollyjgr_attrram_w);
135	135	DECLARE_WRITE8_MEMBER(jollyjgr_misc_w);
136	136	DECLARE_WRITE8_MEMBER(jollyjgr_coin_lookout_w);
	137	TILE_GET_INFO_MEMBER(get_bg_tile_info);
137	138	};
138	139
139	140
r17672	r17673
435	436	}
436	437
437	438	/* Tilemap is the same as in Galaxian */
438		static TILE_GET_INFO( get_bg_tile_info )
	439	TILE_GET_INFO_MEMBER(jollyjgr_state::get_bg_tile_info)
439	440	{
440		jollyjgr_state *state = machine.driver_data<jollyjgr_state>();
441		int color = state->m_colorram[((tile_index & 0x1f) << 1) | 1] & 7;
442		int region = (state->m_tilemap_bank & 0x20) ? 2 : 0;
443		SET_TILE_INFO(region, state->m_videoram[tile_index], color, 0);
	441	int color = m_colorram[((tile_index & 0x1f) << 1) | 1] & 7;
	442	int region = (m_tilemap_bank & 0x20) ? 2 : 0;
	443	SET_TILE_INFO_MEMBER(region, m_videoram[tile_index], color, 0);
444	444	}
445	445
446	446	static VIDEO_START( jollyjgr )
447	447	{
448	448	jollyjgr_state *state = machine.driver_data<jollyjgr_state>();
449		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	449	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jollyjgr_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
450	450
451	451	state->m_bg_tilemap->set_transparent_pen(0);
452	452	state->m_bg_tilemap->set_scroll_cols(32);

trunk/src/mame/drivers/peplus.c

r17672	r17673
262	262	DECLARE_DRIVER_INIT(peplus);
263	263	DECLARE_DRIVER_INIT(peplussb);
264	264	DECLARE_DRIVER_INIT(peplussbw);
	265	TILE_GET_INFO_MEMBER(get_bg_tile_info);
265	266	};
266	267
267	268	static const UINT8  id_022[8] = { 0x00, 0x01, 0x04, 0x09, 0x13, 0x16, 0x18, 0x00 };
r17672	r17673
935	936	* Video/Character functions *
936	937	****************************/
937	938
938		static TILE_GET_INFO( get_bg_tile_info )
	939	TILE_GET_INFO_MEMBER(peplus_state::get_bg_tile_info)
939	940	{
940		peplus_state *state = machine.driver_data<peplus_state>();
941		UINT8 *videoram = state->m_videoram;
942		int pr = state->m_palette_ram[tile_index];
943		int pr2 = state->m_palette_ram2[tile_index];
	941	UINT8 *videoram = m_videoram;
	942	int pr = m_palette_ram[tile_index];
	943	int pr2 = m_palette_ram2[tile_index];
944	944	int vr = videoram[tile_index];
945	945
946	946	int code = ((pr & 0x0f)*256) | vr;
947	947	int color = (pr>>4) & 0x0f;
948	948
949	949	// Access 2nd Half of CGs and CAP
950		if (state->m_jumper_e16_e17 && (pr2 & 0x10) == 0x10)
	950	if (m_jumper_e16_e17 && (pr2 & 0x10) == 0x10)
951	951	{
952	952	code += 0x1000;
953	953	color += 0x10;
954	954	}
955	955
956		SET_TILE_INFO(0, code, color, 0);
	956	SET_TILE_INFO_MEMBER(0, code, color, 0);
957	957	}
958	958
959	959	static VIDEO_START( peplus )
960	960	{
961	961	peplus_state *state = machine.driver_data<peplus_state>();
962		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
	962	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(peplus_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
963	963	state->m_palette_ram = auto_alloc_array(machine, UINT8, 0x3000);
964	964	memset(state->m_palette_ram, 0, 0x3000);
965	965	state->m_palette_ram2 = auto_alloc_array(machine, UINT8, 0x3000);

trunk/src/mame/drivers/ddayjlc.c

r17672	r17673
100	100	DECLARE_WRITE8_MEMBER(i8257_LMSR_w);
101	101	DECLARE_CUSTOM_INPUT_MEMBER(prot_r);
102	102	DECLARE_DRIVER_INIT(ddayjlc);
	103	TILE_GET_INFO_MEMBER(get_tile_info_bg);
103	104	};
104	105
105	106
r17672	r17673
369	370	GFXDECODE_ENTRY( "gfx3", 0, charlayout,     0x100, 16 )
370	371	GFXDECODE_END
371	372
372		static TILE_GET_INFO( get_tile_info_bg )
	373	TILE_GET_INFO_MEMBER(ddayjlc_state::get_tile_info_bg)
373	374	{
374		ddayjlc_state *state = machine.driver_data<ddayjlc_state>();
375		int code = state->m_bgram[tile_index] + ((state->m_bgram[tile_index + 0x400] & 0x08) << 5);
376		int color = (state->m_bgram[tile_index + 0x400] & 0x7);
377		color |= (state->m_bgram[tile_index + 0x400] & 0x40) >> 3;
	375	int code = m_bgram[tile_index] + ((m_bgram[tile_index + 0x400] & 0x08) << 5);
	376	int color = (m_bgram[tile_index + 0x400] & 0x7);
	377	color |= (m_bgram[tile_index + 0x400] & 0x40) >> 3;
378	378
379		SET_TILE_INFO(2, code, color, 0);
	379	SET_TILE_INFO_MEMBER(2, code, color, 0);
380	380	}
381	381
382	382	static VIDEO_START( ddayjlc )
383	383	{
384	384	ddayjlc_state *state = machine.driver_data<ddayjlc_state>();
385		state->m_bg_tilemap = tilemap_create(machine, get_tile_info_bg, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	385	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(ddayjlc_state::get_tile_info_bg),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
386	386	}
387	387
388	388	static SCREEN_UPDATE_IND16( ddayjlc )

trunk/src/mame/drivers/quizpun2.c

r17672	r17673
108	108	DECLARE_WRITE8_MEMBER(quizpun2_rombank_w);
109	109	DECLARE_WRITE8_MEMBER(quizpun2_irq_ack);
110	110	DECLARE_WRITE8_MEMBER(quizpun2_soundlatch_w);
	111	TILE_GET_INFO_MEMBER(get_bg_tile_info);
	112	TILE_GET_INFO_MEMBER(get_fg_tile_info);
111	113	};
112	114
113	115
r17672	r17673
117	119	Video Hardware
118	120	***************************************************************************/
119	121
120		static TILE_GET_INFO( get_bg_tile_info )
	122	TILE_GET_INFO_MEMBER(quizpun2_state::get_bg_tile_info)
121	123	{
122		quizpun2_state *state = machine.driver_data<quizpun2_state>();
123		UINT16 code = state->m_bg_ram[ tile_index * 2 ] + state->m_bg_ram[ tile_index * 2 + 1 ] * 256;
124		SET_TILE_INFO(0, code, 0, 0);
	124	UINT16 code = m_bg_ram[ tile_index * 2 ] + m_bg_ram[ tile_index * 2 + 1 ] * 256;
	125	SET_TILE_INFO_MEMBER(0, code, 0, 0);
125	126	}
126	127
127		static TILE_GET_INFO( get_fg_tile_info )
	128	TILE_GET_INFO_MEMBER(quizpun2_state::get_fg_tile_info)
128	129	{
129		quizpun2_state *state = machine.driver_data<quizpun2_state>();
130		UINT16 code  = state->m_fg_ram[ tile_index * 4 ] + state->m_fg_ram[ tile_index * 4 + 1 ] * 256;
131		UINT8  color = state->m_fg_ram[ tile_index * 4 + 2 ];
132		SET_TILE_INFO(1, code, color & 0x0f, 0);
	130	UINT16 code  = m_fg_ram[ tile_index * 4 ] + m_fg_ram[ tile_index * 4 + 1 ] * 256;
	131	UINT8  color = m_fg_ram[ tile_index * 4 + 2 ];
	132	SET_TILE_INFO_MEMBER(1, code, color & 0x0f, 0);
133	133	}
134	134
135	135	WRITE8_MEMBER(quizpun2_state::bg_ram_w)
r17672	r17673
147	147	static VIDEO_START(quizpun2)
148	148	{
149	149	quizpun2_state *state = machine.driver_data<quizpun2_state>();
150		state->m_bg_tmap = tilemap_create(   machine, get_bg_tile_info, TILEMAP_SCAN_ROWS,   8,16, 0x20,0x20   );
151		state->m_fg_tmap = tilemap_create(   machine, get_fg_tile_info, TILEMAP_SCAN_ROWS,   8,16, 0x20,0x20   );
	150	state->m_bg_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(quizpun2_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS,8,16,0x20,0x20);
	151	state->m_fg_tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(quizpun2_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,8,16,0x20,0x20);
152	152
153	153	state->m_bg_tmap->set_transparent_pen(0);
154	154	state->m_fg_tmap->set_transparent_pen(0);

trunk/src/mame/drivers/egghunt.c

r17672	r17673
75	75	DECLARE_WRITE8_MEMBER(egghunt_soundlatch_w);
76	76	DECLARE_READ8_MEMBER(egghunt_okibanking_r);
77	77	DECLARE_WRITE8_MEMBER(egghunt_okibanking_w);
	78	TILE_GET_INFO_MEMBER(get_bg_tile_info);
78	79	};
79	80
80	81
r17672	r17673
117	118	}
118	119	}
119	120
120		static TILE_GET_INFO( get_bg_tile_info )
	121	TILE_GET_INFO_MEMBER(egghunt_state::get_bg_tile_info)
121	122	{
122		egghunt_state *state = machine.driver_data<egghunt_state>();
123		int code = ((state->m_bgram[tile_index * 2 + 1] << 8) | state->m_bgram[tile_index * 2]) & 0x3fff;
124		int colour = state->m_atram[tile_index] & 0x3f;
	123	int code = ((m_bgram[tile_index * 2 + 1] << 8) | m_bgram[tile_index * 2]) & 0x3fff;
	124	int colour = m_atram[tile_index] & 0x3f;
125	125
126	126	if(code & 0x2000)
127	127	{
128		if((state->m_gfx_banking & 3) == 2)
	128	if((m_gfx_banking & 3) == 2)
129	129	code += 0x2000;
130		else if((state->m_gfx_banking & 3) == 3)
	130	else if((m_gfx_banking & 3) == 3)
131	131	code += 0x4000;
132		//      else if((state->m_gfx_banking & 3) == 1)
	132	//      else if((m_gfx_banking & 3) == 1)
133	133	//          code += 0;
134	134	}
135	135
136		SET_TILE_INFO(0, code, colour, 0);
	136	SET_TILE_INFO_MEMBER(0, code, colour, 0);
137	137	}
138	138
139	139	READ8_MEMBER(egghunt_state::egghunt_bgram_r)
r17672	r17673
172	172	{
173	173	egghunt_state *state = machine.driver_data<egghunt_state>();
174	174
175		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	175	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(egghunt_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
176	176
177	177	state->save_item(NAME(state->m_bgram));
178	178	state->save_item(NAME(state->m_spram));

trunk/src/mame/drivers/jokrwild.c

r17672	r17673
114	114	DECLARE_WRITE8_MEMBER(testa_w);
115	115	DECLARE_WRITE8_MEMBER(testb_w);
116	116	DECLARE_DRIVER_INIT(jokrwild);
	117	TILE_GET_INFO_MEMBER(get_bg_tile_info);
117	118	};
118	119
119	120
r17672	r17673
136	137	}
137	138
138	139
139		static TILE_GET_INFO( get_bg_tile_info )
	140	TILE_GET_INFO_MEMBER(jokrwild_state::get_bg_tile_info)
140	141	{
141		jokrwild_state *state = machine.driver_data<jokrwild_state>();
142	142	/*  - bits -
143	143	7654 3210
144	144	xx-- ----   bank select.
145	145	---- xxxx   color code.
146	146	*/
147		int attr = state->m_colorram[tile_index];
148		int code = state->m_videoram[tile_index] | ((attr & 0xc0) << 2);
	147	int attr = m_colorram[tile_index];
	148	int code = m_videoram[tile_index] | ((attr & 0xc0) << 2);
149	149	int color = (attr & 0x0f);
150	150
151		SET_TILE_INFO( 0, code , color , 0);
	151	SET_TILE_INFO_MEMBER( 0, code , color , 0);
152	152	}
153	153
154	154
155	155	static VIDEO_START( jokrwild )
156	156	{
157	157	jokrwild_state *state = machine.driver_data<jokrwild_state>();
158		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 24, 26);
	158	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(jokrwild_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 24, 26);
159	159	}
160	160
161	161

trunk/src/mame/drivers/umipoker.c

r17672	r17673
60	60	DECLARE_WRITE16_MEMBER(saiyu_counters_w);
61	61	DECLARE_DRIVER_INIT(umipoker);
62	62	DECLARE_DRIVER_INIT(saiyukip);
	63	TILE_GET_INFO_MEMBER(get_tile_info_0);
	64	TILE_GET_INFO_MEMBER(get_tile_info_1);
	65	TILE_GET_INFO_MEMBER(get_tile_info_2);
	66	TILE_GET_INFO_MEMBER(get_tile_info_3);
63	67	};
64	68
65		static TILE_GET_INFO( get_tile_info_0 )
	69	TILE_GET_INFO_MEMBER(umipoker_state::get_tile_info_0)
66	70	{
67		umipoker_state *state = machine.driver_data<umipoker_state>();
68		int tile = state->m_vram_0[tile_index*2+0];
69		int color = state->m_vram_0[tile_index*2+1] & 0x3f;
	71	int tile = m_vram_0[tile_index*2+0];
	72	int color = m_vram_0[tile_index*2+1] & 0x3f;
70	73
71		SET_TILE_INFO(
	74	SET_TILE_INFO_MEMBER(
72	75	0,
73	76	tile,
74	77	color,
75	78	0);
76	79	}
77	80
78		static TILE_GET_INFO( get_tile_info_1 )
	81	TILE_GET_INFO_MEMBER(umipoker_state::get_tile_info_1)
79	82	{
80		umipoker_state *state = machine.driver_data<umipoker_state>();
81		int tile = state->m_vram_1[tile_index*2+0];
82		int color = state->m_vram_1[tile_index*2+1] & 0x3f;
	83	int tile = m_vram_1[tile_index*2+0];
	84	int color = m_vram_1[tile_index*2+1] & 0x3f;
83	85
84		SET_TILE_INFO(
	86	SET_TILE_INFO_MEMBER(
85	87	0,
86	88	tile,
87	89	color,
88	90	0);
89	91	}
90	92
91		static TILE_GET_INFO( get_tile_info_2 )
	93	TILE_GET_INFO_MEMBER(umipoker_state::get_tile_info_2)
92	94	{
93		umipoker_state *state = machine.driver_data<umipoker_state>();
94		int tile = state->m_vram_2[tile_index*2+0];
95		int color = state->m_vram_2[tile_index*2+1] & 0x3f;
	95	int tile = m_vram_2[tile_index*2+0];
	96	int color = m_vram_2[tile_index*2+1] & 0x3f;
96	97
97		SET_TILE_INFO(
	98	SET_TILE_INFO_MEMBER(
98	99	0,
99	100	tile,
100	101	color,
101	102	0);
102	103	}
103	104
104		static TILE_GET_INFO( get_tile_info_3 )
	105	TILE_GET_INFO_MEMBER(umipoker_state::get_tile_info_3)
105	106	{
106		umipoker_state *state = machine.driver_data<umipoker_state>();
107		int tile = state->m_vram_3[tile_index*2+0];
108		int color = state->m_vram_3[tile_index*2+1] & 0x3f;
	107	int tile = m_vram_3[tile_index*2+0];
	108	int color = m_vram_3[tile_index*2+1] & 0x3f;
109	109
110		SET_TILE_INFO(
	110	SET_TILE_INFO_MEMBER(
111	111	0,
112	112	tile,
113	113	color,
r17672	r17673
118	118	{
119	119	umipoker_state *state = machine.driver_data<umipoker_state>();
120	120
121		state->m_tilemap_0 = tilemap_create(machine, get_tile_info_0,TILEMAP_SCAN_ROWS,8,8,64,32);
122		state->m_tilemap_1 = tilemap_create(machine, get_tile_info_1,TILEMAP_SCAN_ROWS,8,8,64,32);
123		state->m_tilemap_2 = tilemap_create(machine, get_tile_info_2,TILEMAP_SCAN_ROWS,8,8,64,32);
124		state->m_tilemap_3 = tilemap_create(machine, get_tile_info_3,TILEMAP_SCAN_ROWS,8,8,64,32);
	121	state->m_tilemap_0 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(umipoker_state::get_tile_info_0),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	122	state->m_tilemap_1 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(umipoker_state::get_tile_info_1),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	123	state->m_tilemap_2 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(umipoker_state::get_tile_info_2),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	124	state->m_tilemap_3 = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(umipoker_state::get_tile_info_3),state),TILEMAP_SCAN_ROWS,8,8,64,32);
125	125
126	126	state->m_tilemap_0->set_transparent_pen(0);
127	127	state->m_tilemap_1->set_transparent_pen(0);

trunk/src/mame/drivers/cball.c

r17672	r17673
27	27	DECLARE_WRITE8_MEMBER(cball_vram_w);
28	28	DECLARE_READ8_MEMBER(cball_wram_r);
29	29	DECLARE_WRITE8_MEMBER(cball_wram_w);
	30	TILE_GET_INFO_MEMBER(get_tile_info);
30	31	};
31	32
32	33
33		static TILE_GET_INFO( get_tile_info )
	34	TILE_GET_INFO_MEMBER(cball_state::get_tile_info)
34	35	{
35		cball_state *state = machine.driver_data<cball_state>();
36		UINT8 code = state->m_video_ram[tile_index];
	36	UINT8 code = m_video_ram[tile_index];
37	37
38		SET_TILE_INFO(0, code, code >> 7, 0);
	38	SET_TILE_INFO_MEMBER(0, code, code >> 7, 0);
39	39	}
40	40
41	41
r17672	r17673
49	49	static VIDEO_START( cball )
50	50	{
51	51	cball_state *state = machine.driver_data<cball_state>();
52		state->m_bg_tilemap = tilemap_create(machine, get_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	52	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cball_state::get_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
53	53	}
54	54
55	55

trunk/src/mame/drivers/chance32.c

r17672	r17673
57	57	required_shared_ptr<UINT8> m_bgram;
58	58
59	59	UINT8 mux_data;
	60	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	61	TILE_GET_INFO_MEMBER(get_bg_tile_info);
60	62	};
61	63
62	64
63		static TILE_GET_INFO( get_fg_tile_info )
	65	TILE_GET_INFO_MEMBER(chance32_state::get_fg_tile_info)
64	66	{
65		chance32_state *state = machine.driver_data<chance32_state>();
66		int code = (state->m_fgram[tile_index * 2 + 1] << 8) | state->m_fgram[tile_index * 2];
	67	int code = (m_fgram[tile_index * 2 + 1] << 8) | m_fgram[tile_index * 2];
67	68	int flip = (~code >> 12)&1;
68		SET_TILE_INFO(
	69	SET_TILE_INFO_MEMBER(
69	70	1,
70	71	code & 0x0fff,
71	72	code >> 13,
72	73	TILE_FLIPYX(flip<<1)|flip);
73	74	}
74	75
75		static TILE_GET_INFO( get_bg_tile_info )
	76	TILE_GET_INFO_MEMBER(chance32_state::get_bg_tile_info)
76	77	{
77		chance32_state *state = machine.driver_data<chance32_state>();
78		int code = (state->m_bgram[tile_index * 2 +1] << 8) | state->m_bgram[tile_index * 2];
	78	int code = (m_bgram[tile_index * 2 +1] << 8) | m_bgram[tile_index * 2];
79	79	int flip = (~code >> 12)&1;
80		SET_TILE_INFO(
	80	SET_TILE_INFO_MEMBER(
81	81	0,
82	82	code & 0x0fff,
83	83	code >> 13,
r17672	r17673
89	89	{
90	90	chance32_state *state = machine.driver_data<chance32_state>();
91	91
92		state->m_fg_tilemap = tilemap_create(machine, get_fg_tile_info, TILEMAP_SCAN_ROWS, 16, 8, 35, 29);
	92	state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(chance32_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 8, 35, 29);
93	93	state->m_fg_tilemap->set_transparent_pen(0);
94	94
95		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 8, 35, 29);
	95	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(chance32_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 8, 35, 29);
96	96
97	97	state->m_fg_tilemap->set_flip(TILE_FLIPX|TILE_FLIPY);
98	98	state->m_bg_tilemap->set_flip(TILE_FLIPX|TILE_FLIPY);

trunk/src/mame/drivers/rabbit.c

r17672	r17673
132	132	DECLARE_WRITE32_MEMBER(rabbit_blitter_w);
133	133	DECLARE_WRITE32_MEMBER(rabbit_eeprom_write);
134	134	DECLARE_DRIVER_INIT(rabbit);
	135	TILE_GET_INFO_MEMBER(get_rabbit_tilemap0_tile_info);
	136	TILE_GET_INFO_MEMBER(get_rabbit_tilemap1_tile_info);
	137	TILE_GET_INFO_MEMBER(get_rabbit_tilemap2_tile_info);
	138	TILE_GET_INFO_MEMBER(get_rabbit_tilemap3_tile_info);
135	139	};
136	140
137	141
r17672	r17673
197	201	}
198	202	}
199	203
200		static TILE_GET_INFO( get_rabbit_tilemap0_tile_info )
	204	TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap0_tile_info)
201	205	{
202		get_rabbit_tilemap_info(machine,tileinfo,tile_index,0,1);
	206	get_rabbit_tilemap_info(machine(),tileinfo,tile_index,0,1);
203	207	}
204	208
205		static TILE_GET_INFO( get_rabbit_tilemap1_tile_info )
	209	TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap1_tile_info)
206	210	{
207		get_rabbit_tilemap_info(machine,tileinfo,tile_index,1,1);
	211	get_rabbit_tilemap_info(machine(),tileinfo,tile_index,1,1);
208	212	}
209	213
210		static TILE_GET_INFO( get_rabbit_tilemap2_tile_info )
	214	TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap2_tile_info)
211	215	{
212		get_rabbit_tilemap_info(machine,tileinfo,tile_index,2,1);
	216	get_rabbit_tilemap_info(machine(),tileinfo,tile_index,2,1);
213	217	}
214	218
215		static TILE_GET_INFO( get_rabbit_tilemap3_tile_info )
	219	TILE_GET_INFO_MEMBER(rabbit_state::get_rabbit_tilemap3_tile_info)
216	220	{
217		get_rabbit_tilemap_info(machine,tileinfo,tile_index,3,0);
	221	get_rabbit_tilemap_info(machine(),tileinfo,tile_index,3,0);
218	222	}
219	223
220	224	WRITE32_MEMBER(rabbit_state::rabbit_tilemap0_w)
r17672	r17673
392	396	state->m_tilemap_ram[2] = auto_alloc_array_clear(machine, UINT32, 0x20000/4);
393	397	state->m_tilemap_ram[3] = auto_alloc_array_clear(machine, UINT32, 0x20000/4);
394	398
395		state->m_tilemap[0] = tilemap_create(machine, get_rabbit_tilemap0_tile_info,TILEMAP_SCAN_ROWS,16, 16, 128,32);
396		state->m_tilemap[1] = tilemap_create(machine, get_rabbit_tilemap1_tile_info,TILEMAP_SCAN_ROWS,16, 16, 128,32);
397		state->m_tilemap[2] = tilemap_create(machine, get_rabbit_tilemap2_tile_info,TILEMAP_SCAN_ROWS,16, 16, 128,32);
398		state->m_tilemap[3] = tilemap_create(machine, get_rabbit_tilemap3_tile_info,TILEMAP_SCAN_ROWS, 8,  8, 128,32);
	399	state->m_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap0_tile_info),state),TILEMAP_SCAN_ROWS,16, 16, 128,32);
	400	state->m_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap1_tile_info),state),TILEMAP_SCAN_ROWS,16, 16, 128,32);
	401	state->m_tilemap[2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap2_tile_info),state),TILEMAP_SCAN_ROWS,16, 16, 128,32);
	402	state->m_tilemap[3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(rabbit_state::get_rabbit_tilemap3_tile_info),state),TILEMAP_SCAN_ROWS, 8,  8, 128,32);
399	403
400	404	/* the tilemaps mix 4bpp and 8bbp tiles, we split these into 2 groups, and set a different transpen for each group */
401	405	state->m_tilemap[0]->map_pen_to_layer(0, 15,  TILEMAP_PIXEL_TRANSPARENT);

trunk/src/mame/drivers/hvyunit.c

r17672	r17673
122	122	DECLARE_WRITE8_MEMBER(mermaid_p2_w);
123	123	DECLARE_READ8_MEMBER(mermaid_p3_r);
124	124	DECLARE_WRITE8_MEMBER(mermaid_p3_w);
	125	TILE_GET_INFO_MEMBER(get_bg_tile_info);
125	126	};
126	127
127	128
r17672	r17673
160	161	*
161	162	*************************************/
162	163
163		static TILE_GET_INFO( get_bg_tile_info )
	164	TILE_GET_INFO_MEMBER(hvyunit_state::get_bg_tile_info)
164	165	{
165		hvyunit_state *state = machine.driver_data<hvyunit_state>();
166	166
167		int attr = state->m_colorram[tile_index];
168		int code = state->m_videoram[tile_index] + ((attr & 0x0f) << 8);
	167	int attr = m_colorram[tile_index];
	168	int code = m_videoram[tile_index] + ((attr & 0x0f) << 8);
169	169	int color = (attr >> 4);
170	170
171		SET_TILE_INFO(1, code, color, 0);
	171	SET_TILE_INFO_MEMBER(1, code, color, 0);
172	172	}
173	173
174	174	static VIDEO_START( hvyunit )
175	175	{
176	176	hvyunit_state *state = machine.driver_data<hvyunit_state>();
177		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
	177	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(hvyunit_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
178	178	}
179	179
180	180	static SCREEN_UPDATE_IND16( hvyunit )

trunk/src/mame/drivers/miniboy7.c

r17672	r17673
165	165	tilemap_t *m_bg_tilemap;
166	166	DECLARE_WRITE8_MEMBER(miniboy7_videoram_w);
167	167	DECLARE_WRITE8_MEMBER(miniboy7_colorram_w);
	168	TILE_GET_INFO_MEMBER(get_bg_tile_info);
168	169	};
169	170
170	171
r17672	r17673
184	185	m_bg_tilemap->mark_tile_dirty(offset);
185	186	}
186	187
187		static TILE_GET_INFO( get_bg_tile_info )
	188	TILE_GET_INFO_MEMBER(miniboy7_state::get_bg_tile_info)
188	189	{
189		miniboy7_state *state = machine.driver_data<miniboy7_state>();
190	190	/*  - bits -
191	191	7654 3210
192	192	--xx xx--   tiles color?.
193	193	---- --x-   tiles bank.
194	194	xx-- ---x   seems unused. */
195	195
196		int attr = state->m_colorram[tile_index];
197		int code = state->m_videoram[tile_index];
	196	int attr = m_colorram[tile_index];
	197	int code = m_videoram[tile_index];
198	198	int bank = (attr & 0x02) >> 1;   /* bit 1 switch the gfx banks */
199	199	int color = (attr & 0x3c);   /* bits 2-3-4-5 for color? */
200	200
201	201	if (bank == 1)   /* temporary hack to point to the 3rd gfx bank */
202	202	bank = 2;
203	203
204		SET_TILE_INFO(bank, code, color, 0);
	204	SET_TILE_INFO_MEMBER(bank, code, color, 0);
205	205	}
206	206
207	207	static VIDEO_START( miniboy7 )
208	208	{
209	209	miniboy7_state *state = machine.driver_data<miniboy7_state>();
210		state->m_bg_tilemap = tilemap_create(machine, get_bg_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 37, 37);
	210	state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(miniboy7_state::get_bg_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 37, 37);
211	211	}
212	212
213	213	static SCREEN_UPDATE_IND16( miniboy7 )

trunk/src/mess/drivers/supracan.c

r17672	r17673
194	194	tilemap_t *m_tilemap_sizes[4][4];
195	195	bitmap_ind16 m_sprite_final_bitmap;
196	196	void write_swapped_byte(int offset, UINT8 byte);
	197	TILE_GET_INFO_MEMBER(get_supracan_tilemap0_tile_info);
	198	TILE_GET_INFO_MEMBER(get_supracan_tilemap1_tile_info);
	199	TILE_GET_INFO_MEMBER(get_supracan_tilemap2_tile_info);
	200	TILE_GET_INFO_MEMBER(get_supracan_roz_tile_info);
197	201	};
198	202
199	203
r17672	r17673
371	375
372	376
373	377
374		static TILE_GET_INFO( get_supracan_tilemap0_tile_info )
	378	TILE_GET_INFO_MEMBER(supracan_state::get_supracan_tilemap0_tile_info)
375	379	{
376	380
377		supracan_tilemap_get_info_common(machine, 0, tileinfo, tile_index);
	381	supracan_tilemap_get_info_common(machine(), 0, tileinfo, tile_index);
378	382	}
379	383
380		static TILE_GET_INFO( get_supracan_tilemap1_tile_info )
	384	TILE_GET_INFO_MEMBER(supracan_state::get_supracan_tilemap1_tile_info)
381	385	{
382		supracan_tilemap_get_info_common(machine, 1, tileinfo, tile_index);
	386	supracan_tilemap_get_info_common(machine(), 1, tileinfo, tile_index);
383	387	}
384	388
385		static TILE_GET_INFO( get_supracan_tilemap2_tile_info )
	389	TILE_GET_INFO_MEMBER(supracan_state::get_supracan_tilemap2_tile_info)
386	390	{
387	391
388		supracan_tilemap_get_info_common(machine, 2, tileinfo, tile_index);
	392	supracan_tilemap_get_info_common(machine(), 2, tileinfo, tile_index);
389	393	}
390	394
391		static TILE_GET_INFO( get_supracan_roz_tile_info )
	395	TILE_GET_INFO_MEMBER(supracan_state::get_supracan_roz_tile_info)
392	396	{
393	397
394		supracan_tilemap_get_info_roz(machine, 3, tileinfo, tile_index);
	398	supracan_tilemap_get_info_roz(machine(), 3, tileinfo, tile_index);
395	399	}
396	400
397	401
r17672	r17673
404	408	state->m_vram_swapped = (UINT16*)(*machine.root_device().memregion("ram_gfx2"));
405	409	state->m_vram_addr_swapped = (UINT8*)(*state->memregion("ram_gfx3")); // hack for 1bpp layer at startup
406	410
407		state->m_tilemap_sizes[0][0] = tilemap_create(machine, get_supracan_tilemap0_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
408		state->m_tilemap_sizes[0][1] = tilemap_create(machine, get_supracan_tilemap0_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
409		state->m_tilemap_sizes[0][2] = tilemap_create(machine, get_supracan_tilemap0_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
410		state->m_tilemap_sizes[0][3] = tilemap_create(machine, get_supracan_tilemap0_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	411	state->m_tilemap_sizes[0][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap0_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	412	state->m_tilemap_sizes[0][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap0_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	413	state->m_tilemap_sizes[0][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap0_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
	414	state->m_tilemap_sizes[0][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap0_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
411	415
412		state->m_tilemap_sizes[1][0] = tilemap_create(machine, get_supracan_tilemap1_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
413		state->m_tilemap_sizes[1][1] = tilemap_create(machine, get_supracan_tilemap1_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
414		state->m_tilemap_sizes[1][2] = tilemap_create(machine, get_supracan_tilemap1_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
415		state->m_tilemap_sizes[1][3] = tilemap_create(machine, get_supracan_tilemap1_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	416	state->m_tilemap_sizes[1][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap1_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	417	state->m_tilemap_sizes[1][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap1_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	418	state->m_tilemap_sizes[1][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap1_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
	419	state->m_tilemap_sizes[1][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap1_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
416	420
417		state->m_tilemap_sizes[2][0] = tilemap_create(machine, get_supracan_tilemap2_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
418		state->m_tilemap_sizes[2][1] = tilemap_create(machine, get_supracan_tilemap2_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
419		state->m_tilemap_sizes[2][2] = tilemap_create(machine, get_supracan_tilemap2_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
420		state->m_tilemap_sizes[2][3] = tilemap_create(machine, get_supracan_tilemap2_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	421	state->m_tilemap_sizes[2][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	422	state->m_tilemap_sizes[2][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	423	state->m_tilemap_sizes[2][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
	424	state->m_tilemap_sizes[2][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_tilemap2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
421	425
422		state->m_tilemap_sizes[3][0] = tilemap_create(machine, get_supracan_roz_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
423		state->m_tilemap_sizes[3][1] = tilemap_create(machine, get_supracan_roz_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
424		state->m_tilemap_sizes[3][2] = tilemap_create(machine, get_supracan_roz_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
425		state->m_tilemap_sizes[3][3] = tilemap_create(machine, get_supracan_roz_tile_info, TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	426	state->m_tilemap_sizes[3][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_roz_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
	427	state->m_tilemap_sizes[3][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_roz_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	428	state->m_tilemap_sizes[3][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_roz_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 128, 32);
	429	state->m_tilemap_sizes[3][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(supracan_state::get_supracan_roz_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
426	430	}
427	431
428	432	static int get_tilemap_dimensions(running_machine &machine, int &xsize, int &ysize, int layer)

trunk/src/mess/drivers/clcd.c

r17672	r17673
28	28	{
29	29	}
30	30
31		static TILE_GET_INFO( get_clcd_tilemap_tile_info )
	31	TILE_GET_INFO_MEMBER(get_clcd_tilemap_tile_info)
32	32	{
33		clcd_state *state = machine.driver_data<clcd_state>();
34		int code  = state->m_ram.target()[((tile_index / 80) * 128) + (tile_index % 80) + 0x800];
	33	int code  = m_ram.target()[((tile_index / 80) * 128) + (tile_index % 80) + 0x800];
35	34
36		SET_TILE_INFO(0, code, 0, 0);
	35	SET_TILE_INFO_MEMBER(0, code, 0, 0);
37	36	}
38	37
39	38	virtual void machine_start()
r17672	r17673
43	42
44	43	virtual void video_start()
45	44	{
46		m_tilemap = tilemap_create(machine(), get_clcd_tilemap_tile_info, TILEMAP_SCAN_ROWS, 6, 8, 80, 16);
	45	m_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(clcd_state::get_clcd_tilemap_tile_info),this), TILEMAP_SCAN_ROWS, 6, 8, 80, 16);
47	46	}
48	47
49	48	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team