Previous

199869 Revisions

Next

r21023 Wednesday 13th February, 2013 at 10:24:35 UTC by Miodrag Milanović
Modernization of drivers part 19 (no whatsnew)

[src/mame/drivers]	taito_b.c taito_l.c taito_z.c taitojc.c tank8.c tceptor.c tecmosys.c tetrisp2.c thedeep.c thief.c thunderx.c tigeroad.c tmnt.c toaplan1.c toaplan2.c topspeed.c triplhnt.c tubep.c tumbleb.c tumblep.c turbo.c twin16.c twincobr.c wardner.c
[src/mame/includes]	tagteam.h tail2nos.h taito_b.h taito_f2.h taito_h.h taito_l.h taito_o.h taito_z.h taitoair.h taitojc.h taitosj.h tank8.h tankbatt.h tankbust.h targeth.h tbowl.h tceptor.h tecmo.h tecmosys.h tehkanwc.h terracre.h tetrisp2.h thedeep.h thief.h thoop2.h thunderx.h tiamc1.h tigeroad.h timelimt.h timeplt.h tmnt.h tnzs.h toaplan1.h toaplan2.h toki.h topspeed.h toypop.h tp84.h trackfld.h travrusa.h triplhnt.h tryout.h tsamurai.h tubep.h tumbleb.h tumblep.h tunhunt.h turbo.h tutankhm.h twin16.h twincobr.h
[src/mame/machine]	tnzs.c toaplan1.c twincobr.c
[src/mame/video]	tagteam.c tail2nos.c taito_b.c taito_f2.c taito_h.c taito_l.c taito_o.c taito_z.c taitoair.c taitojc.c taitosj.c tank8.c tankbatt.c tankbust.c targeth.c tbowl.c tceptor.c tecmo.c tecmosys.c tehkanwc.c terracre.c tetrisp2.c thedeep.c thief.c thoop2.c tiamc1.c tigeroad.c timelimt.c timeplt.c toaplan1.c toaplan2.c toki.c topspeed.c toypop.c tp84.c trackfld.c travrusa.c triplhnt.c tryout.c tsamurai.c tubep.c tumbleb.c tunhunt.c turbo.c tutankhm.c twin16.c twincobr.c

trunk/src/mame/video/tiamc1.c

r21022	r21023
152	152	machine().gfx[0]->set_source(m_charram);
153	153	}
154	154
155		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	155	void tiamc1_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
156	156	{
157		tiamc1_state *state = machine.driver_data<tiamc1_state>();
158	157	int offs;
159	158
160	159	for (offs = 0; offs < 16; offs++)
161	160	{
162	161	int flipx, flipy, sx, sy, spritecode;
163	162
164		sx = state->m_spriteram_x[offs] ^ 0xff;
165		sy = state->m_spriteram_y[offs] ^ 0xff;
166		flipx = !(state->m_spriteram_a[offs] & 0x08);
167		flipy = !(state->m_spriteram_a[offs] & 0x02);
168		spritecode = state->m_spriteram_n[offs] ^ 0xff;
	163	sx = m_spriteram_x[offs] ^ 0xff;
	164	sy = m_spriteram_y[offs] ^ 0xff;
	165	flipx = !(m_spriteram_a[offs] & 0x08);
	166	flipy = !(m_spriteram_a[offs] & 0x02);
	167	spritecode = m_spriteram_n[offs] ^ 0xff;
169	168
170		if (!(state->m_spriteram_a[offs] & 0x01))
171		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	169	if (!(m_spriteram_a[offs] & 0x01))
	170	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
172	171	spritecode,
173	172	0,
174	173	flipx, flipy,
r21022	r21023
200	199	m_bg_tilemap1->draw(bitmap, cliprect, 0, 0);
201	200
202	201
203		draw_sprites(machine(), bitmap, cliprect);
	202	draw_sprites(bitmap, cliprect);
204	203
205	204	return 0;
206	205	}

trunk/src/mame/video/toaplan2.c

r21022	r21023
55	55	***************************************************************************/
56	56
57	57
58		static void truxton2_create_tx_tilemap(running_machine &machine)
	58	void toaplan2_state::truxton2_create_tx_tilemap()
59	59	{
60		toaplan2_state *state = machine.driver_data<toaplan2_state>();
61	60
62		state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(toaplan2_state::get_text_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
63		state->m_tx_tilemap->set_scroll_rows(8*32); /* line scrolling */
64		state->m_tx_tilemap->set_scroll_cols(1);
65		state->m_tx_tilemap->set_transparent_pen(0);
	61	m_tx_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(toaplan2_state::get_text_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
	62	m_tx_tilemap->set_scroll_rows(8*32); /* line scrolling */
	63	m_tx_tilemap->set_scroll_cols(1);
	64	m_tx_tilemap->set_transparent_pen(0);
66	65	}
67	66
68		static void register_state_save(running_machine &machine)
	67	void toaplan2_state::register_state_save()
69	68	{
70		toaplan2_state *state = machine.driver_data<toaplan2_state>();
71	69
72		state->save_item(NAME(state->m_tx_flip));
	70	save_item(NAME(m_tx_flip));
73	71	}
74	72
75	73	void toaplan2_state::truxton2_postload()
r21022	r21023
99	97	m_vdp1->custom_priority_bitmap = &m_custom_priority_bitmap;
100	98	}
101	99
102		register_state_save(machine());
	100	register_state_save();
103	101	}
104	102
105	103	VIDEO_START_MEMBER(toaplan2_state,truxton2)
r21022	r21023
110	108	machine().gfx[2]->set_source(reinterpret_cast<UINT8 *>(m_tx_gfxram16.target()));
111	109	machine().save().register_postload(save_prepost_delegate(FUNC(toaplan2_state::truxton2_postload), this));
112	110
113		truxton2_create_tx_tilemap(machine());
	111	truxton2_create_tx_tilemap();
114	112	m_tx_tilemap->set_scrolldx(0x1d4 +1, 0x2a);
115	113	}
116	114
r21022	r21023
119	117	VIDEO_START_CALL_MEMBER( toaplan2 );
120	118
121	119	/* Create the Text tilemap for this game */
122		truxton2_create_tx_tilemap(machine());
	120	truxton2_create_tx_tilemap();
123	121
124	122	/* This bootleg has additional layer offsets on the VDP */
125	123	m_vdp0->bg.extra_xoffset.normal  = -0x1d6  -26;
r21022	r21023
144	142	VIDEO_START_CALL_MEMBER( toaplan2 );
145	143
146	144	/* Create the Text tilemap for this game */
147		truxton2_create_tx_tilemap(machine());
	145	truxton2_create_tx_tilemap();
148	146	m_tx_tilemap->set_scrolldx(0x1d4, 0x2a);
149	147	}
150	148
r21022	r21023
153	151	VIDEO_START_CALL_MEMBER( toaplan2 );
154	152
155	153	/* Create the Text tilemap for this game */
156		truxton2_create_tx_tilemap(machine());
	154	truxton2_create_tx_tilemap();
157	155	m_tx_tilemap->set_scrolldx(0x04, 0x2a);
158	156	}
159	157
r21022	r21023
168	166	machine().gfx[2]->set_source(reinterpret_cast<UINT8 *>(m_tx_gfxram16.target()));
169	167	machine().save().register_postload(save_prepost_delegate(FUNC(toaplan2_state::truxton2_postload), this));
170	168
171		truxton2_create_tx_tilemap(machine());
	169	truxton2_create_tx_tilemap();
172	170	m_tx_tilemap->set_scrolldx(0x1d4, 0x2a);
173	171
174	172	/* Has special banking */

trunk/src/mame/video/tankbust.c

r21022	r21023
176	176	offset  3   xxxxxxxx    x position (8 LSB bits)
177	177	*/
178	178
179		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	179	void tankbust_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
180	180	{
181		tankbust_state *state = machine.driver_data<tankbust_state>();
182		UINT8 *spriteram = state->m_spriteram;
	181	UINT8 *spriteram = m_spriteram;
183	182	int offs;
184	183
185		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	184	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
186	185	{
187	186	int code,color,sx,sy,flipx,flipy;
188	187
r21022	r21023
211	210
212	211	if ((spriteram[offs+1]!=4)) //otherwise - ghost sprites
213	212	{
214		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	213	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
215	214	code, color,
216	215	flipx,flipy,
217	216	sx,sy,0);
r21022	r21023
237	236	#endif
238	237
239	238	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
240		draw_sprites(machine(), bitmap, cliprect);
	239	draw_sprites(bitmap, cliprect);
241	240	m_bg_tilemap->draw(bitmap, cliprect, 1, 0);
242	241
243	242	m_txt_tilemap->draw(bitmap, cliprect, 0,0);

trunk/src/mame/video/tetrisp2.c

r21022	r21023
790	790	}
791	791
792	792	// scrambled palettes?
793		static inline int mypal(int x)
	793	inline int stepstag_state::mypal(int x)
794	794	{
795	795	//  return pal5bit(x >> 3);
796	796	return pal5bit((x^0xff) >> 3);

trunk/src/mame/video/taitoair.c

r21022	r21023
69	69	Screen refresh
70	70	***************************************************************************/
71	71
72		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	72	void taitoair_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
73	73	{
74	74	/* Y chain size is 16/32?/64/64? pixels. X chain size
75	75	is always 64 pixels. */
76	76
77		taitoair_state *state = machine.driver_data<taitoair_state>();
78		address_space &space = machine.driver_data()->generic_space();
	77	address_space &space = machine().driver_data()->generic_space();
79	78	static const int size[] = { 1, 2, 4, 4 };
80	79	int x0, y0, x, y, dx, dy, ex, ey, zx, zy;
81	80	int ysize;
r21022	r21023
90	89	if (offs <  0x01b0 && priority == 0)    continue;
91	90	if (offs >= 0x01b0 && priority == 1)    continue;
92	91
93		x0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
94		y0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
95		zoomx     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
96		zoomy     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x007f);
97		tile_offs = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
98		ysize     = size[(tc0080vco_sprram_r(state->m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
	92	x0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
	93	y0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
	94	zoomx     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
	95	zoomy     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x007f);
	96	tile_offs = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
	97	ysize     = size[(tc0080vco_sprram_r(m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
99	98
100	99	if (tile_offs)
101	100	{
r21022	r21023
131	130	if (x0 >= 0x200) x0 -= 0x400;
132	131	if (y0 >= 0x200) y0 -= 0x400;
133	132
134		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	133	if (tc0080vco_flipscreen_r(m_tc0080vco))
135	134	{
136	135	x0 = 497 - x0;
137	136	y0 = 498 - y0;
r21022	r21023
154	153	{
155	154	int tile, color, flipx, flipy;
156	155
157		tile  = tc0080vco_cram_0_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
158		color = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
159		flipx = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
160		flipy = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
	156	tile  = tc0080vco_cram_0_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
	157	color = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
	158	flipx = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
	159	flipy = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
161	160
162		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	161	if (tc0080vco_flipscreen_r(m_tc0080vco))
163	162	{
164	163	flipx ^= 0x0040;
165	164	flipy ^= 0x0080;
166	165	}
167	166
168	167	drawgfxzoom_transpen( bitmap, cliprect,
169		machine.gfx[0],
	168	machine().gfx[0],
170	169	tile,
171	170	color,
172	171	flipx, flipy,
r21022	r21023
183	182	}
184	183	}
185	184
186		static void fill_slope( bitmap_ind16 &bitmap, const rectangle &cliprect, int color, INT32 x1, INT32 x2, INT32 sl1, INT32 sl2, INT32 y1, INT32 y2, INT32 *nx1, INT32 *nx2 )
	185	void taitoair_state::fill_slope( bitmap_ind16 &bitmap, const rectangle &cliprect, int color, INT32 x1, INT32 x2, INT32 sl1, INT32 sl2, INT32 y1, INT32 y2, INT32 *nx1, INT32 *nx2 )
187	186	{
188	187	if (y1 > cliprect.max_y)
189	188	return;
r21022	r21023
258	257	*nx2 = x2;
259	258	}
260	259
261		static void fill_poly( bitmap_ind16 &bitmap, const rectangle &cliprect, const struct taitoair_poly *q )
	260	void taitoair_state::fill_poly( bitmap_ind16 &bitmap, const rectangle &cliprect, const struct taitoair_poly *q )
262	261	{
263	262	INT32 sl1, sl2, cury, limy, x1, x2;
264	263	int pmin, pmax, i, ps1, ps2;
r21022	r21023
441	440	}
442	441
443	442
444		void multVecMtx(const INT16* vec4, const float* m, float* result)
	443	void taitoair_state::multVecMtx(const INT16* vec4, const float* m, float* result)
445	444	{
446	445	#define M(row,col)  m[col*4+row]
447	446	result[0] = vec4[0]*M(0,0) + vec4[1]*M(1,0) + vec4[2]*M(2,0) + vec4[3]*M(3,0);
r21022	r21023
455	454	#undef M
456	455	}
457	456
458		int projectEyeCoordToScreen(float* projectionMatrix,
459		const int Res,
460		INT16* eyePoint3d,
461		int type)
	457	int taitoair_state::projectEyeCoordToScreen(float* projectionMatrix,const int Res,INT16* eyePoint3d,int type)
462	458	{
463	459	/* Return (-1, -1) if the eye point is behind camera */
464	460	int res = -10000;
r21022	r21023
483	479	return res;
484	480	}
485	481
486		void airInfernoFrustum(const INT16 leftExtent, const INT16 bottomExtent, float* m)
	482	void taitoair_state::airInfernoFrustum(const INT16 leftExtent, const INT16 bottomExtent, float* m)
487	483	{
488	484	/* Hard-coded near and far clipping planes :( */
489	485	float nearZ = 1.0f;
r21022	r21023
598	594
599	595	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 0, 0, 0);
600	596
601		draw_sprites(machine(), bitmap, cliprect, 0);
	597	draw_sprites(bitmap, cliprect, 0);
602	598
603	599	copybitmap_trans(bitmap, *m_framebuffer[1], 0, 0, 0, 0, cliprect, 0);
604	600
605	601	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 1, 0, 0);
606	602
607		draw_sprites(machine(), bitmap, cliprect, 1);
	603	draw_sprites(bitmap, cliprect, 1);
608	604
609	605	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 2, 0, 0);
610	606

trunk/src/mame/video/tceptor.c

r21022	r21023
87	87
88	88	/*******************************************************************/
89	89
90		INLINE int get_tile_addr(int tile_index)
	90	inline int tceptor_state::get_tile_addr(int tile_index)
91	91	{
92	92	int x = tile_index / 28;
93	93	int y = tile_index % 28;
r21022	r21023
224	224
225	225	/*******************************************************************/
226	226
227		static void decode_bg(running_machine &machine, const char * region)
	227	void tceptor_state::decode_bg(const char * region)
228	228	{
229		tceptor_state *state = machine.driver_data<tceptor_state>();
230	229	static const gfx_layout bg_layout =
231	230	{
232	231	8, 8,
r21022	r21023
238	237	128
239	238	};
240	239
241		int gfx_index = state->m_bg;
242		UINT8 *src = machine.root_device().memregion(region)->base() + 0x8000;
	240	int gfx_index = m_bg;
	241	UINT8 *src = machine().root_device().memregion(region)->base() + 0x8000;
243	242	UINT8 *buffer;
244	243	int len = 0x8000;
245	244	int i;
246	245
247		buffer = auto_alloc_array(machine, UINT8, len);
	246	buffer = auto_alloc_array(machine(), UINT8, len);
248	247
249	248	/* expand rom tc2-19.10d */
250	249	for (i = 0; i < len / 2; i++)
r21022	r21023
254	253	}
255	254
256	255	memcpy(src, buffer, len);
257		auto_free(machine, buffer);
	256	auto_free(machine(), buffer);
258	257
259	258	/* decode the graphics */
260		machine.gfx[gfx_index] = auto_alloc(machine, gfx_element(machine, bg_layout, machine.root_device().memregion(region)->base(), 64, 2048));
	259	machine().gfx[gfx_index] = auto_alloc(machine(), gfx_element(machine(), bg_layout, machine().root_device().memregion(region)->base(), 64, 2048));
261	260	}
262	261
263		static void decode_sprite(running_machine &machine, int gfx_index, const gfx_layout *layout, const void *data)
	262	void tceptor_state::decode_sprite(int gfx_index, const gfx_layout *layout, const void *data)
264	263	{
265	264	/* decode the graphics */
266		machine.gfx[gfx_index] = auto_alloc(machine, gfx_element(machine, *layout, (const UINT8 *)data, 64, 1024));
	265	machine().gfx[gfx_index] = auto_alloc(machine(), gfx_element(machine(), *layout, (const UINT8 *)data, 64, 1024));
267	266	}
268	267
269	268	// fix sprite order
270		static void decode_sprite16(running_machine &machine, const char * region)
	269	void tceptor_state::decode_sprite16(const char * region)
271	270	{
272		tceptor_state *state = machine.driver_data<tceptor_state>();
273	271	static const gfx_layout spr16_layout =
274	272	{
275	273	16, 16,
r21022	r21023
287	285	2*16*16
288	286	};
289	287
290		UINT8 *src = machine.root_device().memregion(region)->base();
291		int len = machine.root_device().memregion(region)->bytes();
	288	UINT8 *src = machine().root_device().memregion(region)->base();
	289	int len = machine().root_device().memregion(region)->bytes();
292	290	UINT8 *dst;
293	291	int i, y;
294	292
295		dst = auto_alloc_array(machine, UINT8, len);
	293	dst = auto_alloc_array(machine(), UINT8, len);
296	294
297	295	for (i = 0; i < len / (4*4*16); i++)
298	296	for (y = 0; y < 16; y++)
r21022	r21023
311	309	4);
312	310	}
313	311
314		decode_sprite(machine, state->m_sprite16, &spr16_layout, dst);
	312	decode_sprite(m_sprite16, &spr16_layout, dst);
315	313	}
316	314
317	315	// fix sprite order
318		static void decode_sprite32(running_machine &machine, const char * region)
	316	void tceptor_state::decode_sprite32(const char * region)
319	317	{
320		tceptor_state *state = machine.driver_data<tceptor_state>();
321	318	static const gfx_layout spr32_layout =
322	319	{
323	320	32, 32,
r21022	r21023
339	336	2*32*32
340	337	};
341	338
342		UINT8 *src = machine.root_device().memregion(region)->base();
343		int len = machine.root_device().memregion(region)->bytes();
	339	UINT8 *src = machine().root_device().memregion(region)->base();
	340	int len = machine().root_device().memregion(region)->bytes();
344	341	int total = spr32_layout.total;
345	342	int size = spr32_layout.charincrement / 8;
346	343	UINT8 *dst;
347	344	int i;
348	345
349		dst = auto_alloc_array(machine, UINT8, len);
	346	dst = auto_alloc_array(machine(), UINT8, len);
350	347
351	348	memset(dst, 0, len);
352	349
r21022	r21023
361	358	memcpy(&dst[size * (i + total)], &src[size * (code + total)], size);
362	359	}
363	360
364		decode_sprite(machine, state->m_sprite32, &spr32_layout, dst);
	361	decode_sprite(m_sprite32, &spr32_layout, dst);
365	362	}
366	363
367	364	void tceptor_state::video_start()
r21022	r21023
377	374	assert(gfx_index + 4 <= MAX_GFX_ELEMENTS);
378	375
379	376	m_bg = gfx_index++;
380		decode_bg(machine(), "gfx2");
	377	decode_bg("gfx2");
381	378
382	379	m_sprite16 = gfx_index++;
383		decode_sprite16(machine(), "gfx3");
	380	decode_sprite16("gfx3");
384	381
385	382	m_sprite32 = gfx_index++;
386		decode_sprite32(machine(), "gfx4");
	383	decode_sprite32("gfx4");
387	384
388	385	/* allocate temp bitmaps */
389	386	machine().primary_screen->register_screen_bitmap(m_temp_bitmap);
r21022	r21023
430	427	z: zoom y
431	428	*/
432	429
433		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int sprite_priority)
	430	void tceptor_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int sprite_priority)
434	431	{
435		tceptor_state *state = machine.driver_data<tceptor_state>();
436		UINT16 *mem1 = &state->m_sprite_ram_buffered[0x000/2];
437		UINT16 *mem2 = &state->m_sprite_ram_buffered[0x100/2];
	432	UINT16 *mem1 = &m_sprite_ram_buffered[0x000/2];
	433	UINT16 *mem2 = &m_sprite_ram_buffered[0x100/2];
438	434	int need_mask = 0;
439	435	int i;
440	436
r21022	r21023
456	452
457	453	if (mem2[0 + i] & 0x2000)
458	454	{
459		gfx = state->m_sprite32;
	455	gfx = m_sprite32;
460	456	code = mem1[0 + i] & 0x3ff;
461	457
462	458	}
463	459	else
464	460	{
465		gfx = state->m_sprite16;
	461	gfx = m_sprite16;
466	462	code = mem1[0 + i] & 0x1ff;
467	463	scaley *= 2;
468	464	}
469	465
470		if (state->m_is_mask_spr[color])
	466	if (m_is_mask_spr[color])
471	467	{
472	468	if (!need_mask)
473	469	// backup previous bitmap
474		copybitmap(state->m_temp_bitmap, bitmap, 0, 0, 0, 0, cliprect);
	470	copybitmap(m_temp_bitmap, bitmap, 0, 0, 0, 0, cliprect);
475	471
476	472	need_mask = 1;
477	473	}
r21022	r21023
485	481
486	482	drawgfxzoom_transmask(bitmap,
487	483	cliprect,
488		machine.gfx[gfx],
	484	machine().gfx[gfx],
489	485	code,
490	486	color,
491	487	flipx, flipy,
492	488	x, y,
493	489	scalex,
494	490	scaley,
495		colortable_get_transpen_mask(machine.colortable, machine.gfx[gfx], color, SPR_TRANS_COLOR));
	491	colortable_get_transpen_mask(machine().colortable, machine().gfx[gfx], color, SPR_TRANS_COLOR));
496	492	}
497	493	}
498	494
r21022	r21023
503	499
504	500	for (x = cliprect.min_x; x <= cliprect.max_x; x++)
505	501	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
506		if (colortable_entry_get_value(machine.colortable, bitmap.pix16(y, x)) == SPR_MASK_COLOR)
	502	if (colortable_entry_get_value(machine().colortable, bitmap.pix16(y, x)) == SPR_MASK_COLOR)
507	503	// restore pixel
508		bitmap.pix16(y, x) = state->m_temp_bitmap.pix16(y, x);
	504	bitmap.pix16(y, x) = m_temp_bitmap.pix16(y, x);
509	505	}
510	506	}
511	507
r21022	r21023
534	530	{
535	531	m_c45_road->draw(bitmap, cliprect, pri * 2);
536	532	m_c45_road->draw(bitmap, cliprect, pri * 2 + 1);
537		draw_sprites(machine(), bitmap, cliprect, pri);
	533	draw_sprites(bitmap, cliprect, pri);
538	534	}
539	535
540	536	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);

trunk/src/mame/video/tagteam.c

r21022	r21023
140	140	8, 8, 32, 32);
141	141	}
142	142
143		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	143	void tagteam_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
144	144	{
145		tagteam_state *state = machine.driver_data<tagteam_state>();
146	145	int offs;
147	146
148	147	for (offs = 0; offs < 0x20; offs += 4)
149	148	{
150		int spritebank = (state->m_videoram[offs] & 0x30) << 4;
151		int code = state->m_videoram[offs + 1] + 256 * spritebank;
152		int color = state->m_palettebank << 1 | 1;
153		int flipx = state->m_videoram[offs] & 0x04;
154		int flipy = state->m_videoram[offs] & 0x02;
155		int sx = 240 - state->m_videoram[offs + 3];
156		int sy = 240 - state->m_videoram[offs + 2];
	149	int spritebank = (m_videoram[offs] & 0x30) << 4;
	150	int code = m_videoram[offs + 1] + 256 * spritebank;
	151	int color = m_palettebank << 1 | 1;
	152	int flipx = m_videoram[offs] & 0x04;
	153	int flipy = m_videoram[offs] & 0x02;
	154	int sx = 240 - m_videoram[offs + 3];
	155	int sy = 240 - m_videoram[offs + 2];
157	156
158		if (!(state->m_videoram[offs] & 0x01)) continue;
	157	if (!(m_videoram[offs] & 0x01)) continue;
159	158
160		if (state->flip_screen())
	159	if (flip_screen())
161	160	{
162	161	sx = 240 - sx;
163	162	sy = 240 - sy;
r21022	r21023
166	165	}
167	166
168	167	drawgfx_transpen(bitmap, cliprect,
169		machine.gfx[1],
	168	machine().gfx[1],
170	169	code, color,
171	170	flipx, flipy,
172	171	sx, sy, 0);
173	172
174	173	/* Wrap around */
175	174
176		code = state->m_videoram[offs + 0x20] + 256 * spritebank;
177		color = state->m_palettebank;
178		sy += (state->flip_screen() ? -256 : 256);
	175	code = m_videoram[offs + 0x20] + 256 * spritebank;
	176	color = m_palettebank;
	177	sy += (flip_screen() ? -256 : 256);
179	178
180	179	drawgfx_transpen(bitmap, cliprect,
181		machine.gfx[1],
	180	machine().gfx[1],
182	181	code, color,
183	182	flipx, flipy,
184	183	sx, sy, 0);
r21022	r21023
188	187	UINT32 tagteam_state::screen_update_tagteam(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
189	188	{
190	189	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
191		draw_sprites(machine(), bitmap, cliprect);
	190	draw_sprites(bitmap, cliprect);
192	191	return 0;
193	192	}

trunk/src/mame/video/timelimt.c

r21022	r21023
109	109	}
110	110
111	111
112		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	112	void timelimt_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
113	113	{
114		timelimt_state *state = machine.driver_data<timelimt_state>();
115		UINT8 *spriteram = state->m_spriteram;
	114	UINT8 *spriteram = m_spriteram;
116	115	int offs;
117	116
118		for( offs = state->m_spriteram.bytes(); offs >= 0; offs -= 4 )
	117	for( offs = m_spriteram.bytes(); offs >= 0; offs -= 4 )
119	118	{
120	119	int sy = 240 - spriteram[offs];
121	120	int sx = spriteram[offs+3];
r21022	r21023
127	126	code += ( attr & 0x80 ) ? 0x40 : 0x00;
128	127	code += ( attr & 0x40 ) ? 0x80 : 0x00;
129	128
130		drawgfx_transpen( bitmap, cliprect,machine.gfx[2],
	129	drawgfx_transpen( bitmap, cliprect,machine().gfx[2],
131	130	code,
132	131	attr & 7,
133	132	flipx,flipy,
r21022	r21023
142	141	m_bg_tilemap->set_scrolly(0, m_scrolly);
143	142	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
144	143
145		draw_sprites(machine(), bitmap, cliprect);
	144	draw_sprites(bitmap, cliprect);
146	145
147	146	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
148	147	return 0;

trunk/src/mame/video/tail2nos.c

r21022	r21023
136	136
137	137	***************************************************************************/
138	138
139		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	139	void tail2nos_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
140	140	{
141		tail2nos_state *state = machine.driver_data<tail2nos_state>();
142		UINT16 *spriteram = state->m_spriteram;
	141	UINT16 *spriteram = m_spriteram;
143	142	int offs;
144	143
145	144
146		for (offs = 0; offs < state->m_spriteram.bytes() / 2; offs += 4)
	145	for (offs = 0; offs < m_spriteram.bytes() / 2; offs += 4)
147	146	{
148	147	int sx, sy, flipx, flipy, code, color;
149	148
r21022	r21023
159	158	flipy = spriteram[offs + 2] & 0x0800;
160	159
161	160	drawgfx_transpen(bitmap,/* placement relative to zoom layer verified on the real thing */
162		cliprect,machine.gfx[1],
	161	cliprect,machine().gfx[1],
163	162	code,
164	163	40 + color,
165	164	flipx,flipy,
r21022	r21023
172	171	if (m_video_enable)
173	172	{
174	173	k051316_zoom_draw(m_k051316, bitmap, cliprect, 0, 0);
175		draw_sprites(machine(), bitmap, cliprect);
	174	draw_sprites(bitmap, cliprect);
176	175	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
177	176	}
178	177	else

trunk/src/mame/video/turbo.c

r21022	r21023
8	8	#include "includes/turbo.h"
9	9	#include "video/resnet.h"
10	10
11
12
13		struct sprite_info
14		{
15		UINT16  ve;                 /* VE0-15 signals for this row */
16		UINT8   lst;                /* LST0-7 signals for this row */
17		UINT32  latched[8];         /* latched pixel data */
18		UINT8   plb[8];             /* latched PLB state */
19		UINT32  offset[8];          /* current offset for this row */
20		UINT32  frac[8];            /* leftover fraction */
21		UINT32  step[8];            /* stepping value */
22		};
23
24	11	static const UINT32 sprite_expand[16] =
25	12	{
26	13	0x00000000, 0x00000001, 0x00000100, 0x00000101,
r21022	r21023
220	207	*
221	208	*************************************/
222	209
223		INLINE UINT32 sprite_xscale(UINT8 dacinput, double vr1, double vr2, double cext)
	210	inline UINT32 turbo_state::sprite_xscale(UINT8 dacinput, double vr1, double vr2, double cext)
224	211	{
225	212	/* compute the effective pixel clock for this sprite */
226	213	/* thanks to Frank Palazzolo for figuring out this logic */
r21022	r21023
275	262	*
276	263	*************************************/
277	264
278		static void turbo_prepare_sprites(running_machine &machine, turbo_state *state, UINT8 y, sprite_info *info)
	265	void turbo_state::turbo_prepare_sprites(UINT8 y, sprite_info *info)
279	266	{
280		const UINT8 *pr1119 = machine.root_device().memregion("proms")->base() + 0x200;
	267	const UINT8 *pr1119 = machine().root_device().memregion("proms")->base() + 0x200;
281	268	int sprnum;
282	269
283	270	/* initialize the line enable signals to 0 */
r21022	r21023
287	274	/* compute the sprite information, which was done on the previous scanline during HBLANK */
288	275	for (sprnum = 0; sprnum < 16; sprnum++)
289	276	{
290		UINT8 *rambase = &state->m_spriteram[sprnum * 0x10];
	277	UINT8 *rambase = &m_spriteram[sprnum * 0x10];
291	278	int level = sprnum & 7;
292	279	UINT8 clo, chi;
293	280	UINT32 sum;
r21022	r21023
335	322	VR1 = 310 Ohm
336	323	VR2 = 910 Ohm
337	324	*/
338		info->step[level] = sprite_xscale(xscale, 1.0e3 * machine.root_device().ioport("VR1")->read() / 100.0, 1.0e3 * machine.root_device().ioport("VR2")->read() / 100.0, 100e-12);
	325	info->step[level] = sprite_xscale(xscale, 1.0e3 * machine().root_device().ioport("VR1")->read() / 100.0, 1.0e3 * machine().root_device().ioport("VR2")->read() / 100.0, 100e-12);
339	326	}
340	327	}
341	328	}
342	329
343	330
344		static UINT32 turbo_get_sprite_bits(const UINT8 *sprite_gfxdata, UINT8 road, sprite_info *sprinfo)
	331	UINT32 turbo_state::turbo_get_sprite_bits(const UINT8 *sprite_gfxdata, UINT8 road, sprite_info *sprinfo)
345	332	{
346	333	UINT8 sprlive = sprinfo->lst;
347	334	UINT32 sprdata = 0;
r21022	r21023
427	414
428	415	/* compute the sprite information; we use y-1 since this info was computed during HBLANK */
429	416	/* on the previous scanline */
430		turbo_prepare_sprites(machine(), this, y, &sprinfo);
	417	turbo_prepare_sprites(y, &sprinfo);
431	418
432	419	/* loop over columns */
433	420	for (x = 0; x <= cliprect.max_x; x += TURBO_X_SCALE)
r21022	r21023
632	619
633	620	*/
634	621
635		static void subroc3d_prepare_sprites(running_machine &machine, turbo_state *state, UINT8 y, sprite_info *info)
	622	void turbo_state::subroc3d_prepare_sprites(UINT8 y, sprite_info *info)
636	623	{
637		const UINT8 *pr1449 = machine.root_device().memregion("proms")->base() + 0x300;
	624	const UINT8 *pr1449 = machine().root_device().memregion("proms")->base() + 0x300;
638	625	int sprnum;
639	626
640	627	/* initialize the line enable signals to 0 */
r21022	r21023
644	631	/* compute the sprite information, which was done on the previous scanline during HBLANK */
645	632	for (sprnum = 0; sprnum < 16; sprnum++)
646	633	{
647		UINT8 *rambase = &state->m_spriteram[sprnum * 8];
	634	UINT8 *rambase = &m_spriteram[sprnum * 8];
648	635	int level = sprnum & 7;
649	636	UINT8 clo, chi;
650	637	UINT32 sum;
r21022	r21023
692	679	}
693	680
694	681
695		static UINT32 subroc3d_get_sprite_bits(const UINT8 *sprite_gfxdata, sprite_info *sprinfo, UINT8 *plb)
	682	UINT32 turbo_state::subroc3d_get_sprite_bits(const UINT8 *sprite_gfxdata, sprite_info *sprinfo, UINT8 *plb)
696	683	{
697	684	/* see logic on each sprite:
698	685	END = (CDA == 1 && (CDA ^ CDB) == 0 && (CDC ^ CDD) == 0)
r21022	r21023
767	754
768	755	/* compute the sprite information; we use y-1 since this info was computed during HBLANK */
769	756	/* on the previous scanline */
770		subroc3d_prepare_sprites(machine(), this, y, &sprinfo);
	757	subroc3d_prepare_sprites(y, &sprinfo);
771	758
772	759	/* loop over columns */
773	760	for (x = 0; x <= cliprect.max_x; x += TURBO_X_SCALE)
r21022	r21023
849	836	*
850	837	*************************************/
851	838
852		static void buckrog_prepare_sprites(running_machine &machine, turbo_state *state, UINT8 y, sprite_info *info)
	839	void turbo_state::buckrog_prepare_sprites(UINT8 y, sprite_info *info)
853	840	{
854		const UINT8 *pr5196 = machine.root_device().memregion("proms")->base() + 0x100;
	841	const UINT8 *pr5196 = machine().root_device().memregion("proms")->base() + 0x100;
855	842	int sprnum;
856	843
857	844	/* initialize the line enable signals to 0 */
r21022	r21023
861	848	/* compute the sprite information, which was done on the previous scanline during HBLANK */
862	849	for (sprnum = 0; sprnum < 16; sprnum++)
863	850	{
864		UINT8 *rambase = &state->m_spriteram[sprnum * 8];
	851	UINT8 *rambase = &m_spriteram[sprnum * 8];
865	852	int level = sprnum & 7;
866	853	UINT8 clo, chi;
867	854	UINT32 sum;
r21022	r21023
910	897	}
911	898
912	899
913		static UINT32 buckrog_get_sprite_bits(const UINT8 *sprite_gfxdata, sprite_info *sprinfo, UINT8 *plb)
	900	UINT32 turbo_state::buckrog_get_sprite_bits(const UINT8 *sprite_gfxdata, sprite_info *sprinfo, UINT8 *plb)
914	901	{
915	902	/* see logic on each sprite:
916	903	END = (CDA == 1 && (CDA ^ CDB) == 0 && (CDC ^ CDD) == 0)
r21022	r21023
985	972
986	973	/* compute the sprite information; we use y-1 since this info was computed during HBLANK */
987	974	/* on the previous scanline */
988		buckrog_prepare_sprites(machine(), this, y, &sprinfo);
	975	buckrog_prepare_sprites(y, &sprinfo);
989	976
990	977	/* loop over columns */
991	978	for (x = 0; x <= cliprect.max_x; x += TURBO_X_SCALE)

trunk/src/mame/video/tsamurai.c

r21022	r21023
126	126
127	127	***************************************************************************/
128	128
129		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	129	void tsamurai_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
130	130	{
131		tsamurai_state *state = machine.driver_data<tsamurai_state>();
132		UINT8 *spriteram = state->m_spriteram;
133		gfx_element *gfx = machine.gfx[2];
	131	UINT8 *spriteram = m_spriteram;
	132	gfx_element *gfx = machine().gfx[2];
134	133	const UINT8 *source = spriteram+32*4-4;
135	134	const UINT8 *finish = spriteram; /* ? */
136		state->m_flicker = 1-state->m_flicker;
	135	m_flicker = 1-m_flicker;
137	136
138	137	while( source>=finish )
139	138	{
r21022	r21023
165	164	/* So I'm using this specific check. -kal 11 jul 2002 */
166	165	//      if(sprite_type == 1) sy=sy+2;
167	166
168		if( state->flip_screen() )
	167	if( flip_screen() )
169	168	{
170	169	drawgfx_transpen( bitmap,cliprect,gfx,
171	170	sprite_number&0x7f,
r21022	r21023
208	207	*/
209	208	bitmap.fill(m_bgcolor, cliprect);
210	209	m_background->draw(bitmap, cliprect, 0,0);
211		draw_sprites(machine(), bitmap,cliprect);
	210	draw_sprites(bitmap,cliprect);
212	211	m_foreground->draw(bitmap, cliprect, 0,0);
213	212	return 0;
214	213	}
r21022	r21023
260	259	#endif
261	260
262	261	m_foreground->draw(bitmap, cliprect, 0,0);
263		draw_sprites(machine(),bitmap,cliprect);
	262	draw_sprites(bitmap,cliprect);
264	263	return 0;
265	264	}

trunk/src/mame/video/taito_h.c

r21022	r21023
70	70	Screen refresh
71	71	***************************************************************************/
72	72
73		static void syvalion_draw_sprites( running_machine &machine,bitmap_ind16 &bitmap, const rectangle &cliprect )
	73	void taitoh_state::syvalion_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
74	74	{
75	75	/* Y chain size is 16/32?/64/64? pixels. X chain size
76	76	is always 64 pixels. */
77	77
78		taitoh_state *state = machine.driver_data<taitoh_state>();
79		address_space &space = machine.driver_data()->generic_space();
	78	address_space &space = machine().driver_data()->generic_space();
80	79	static const int size[] = { 1, 2, 4, 4 };
81	80	int x0, y0, x, y, dx, ex, zx;
82	81	int ysize;
r21022	r21023
87	86
88	87	for (offs = 0x03f8 / 2; offs >= 0; offs -= 0x008 / 2)
89	88	{
90		x0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
91		y0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
92		zoomx     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
93		tile_offs = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
94		ysize     = size[(tc0080vco_sprram_r(state->m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
	89	x0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
	90	y0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
	91	zoomx     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
	92	tile_offs = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
	93	ysize     = size[(tc0080vco_sprram_r(m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
95	94
96	95	if (tile_offs)
97	96	{
r21022	r21023
113	112	if (x0 >= 0x200) x0 -= 0x400;
114	113	if (y0 >= 0x200) y0 -= 0x400;
115	114
116		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	115	if (tc0080vco_flipscreen_r(m_tc0080vco))
117	116	{
118	117	x0 = 497 - x0;
119	118	y0 = 498 - y0;
r21022	r21023
135	134	{
136	135	int tile, color, flipx, flipy;
137	136
138		tile  = tc0080vco_cram_0_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
139		color = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
140		flipx = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
141		flipy = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
	137	tile  = tc0080vco_cram_0_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
	138	color = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
	139	flipx = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
	140	flipy = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
142	141
143		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	142	if (tc0080vco_flipscreen_r(m_tc0080vco))
144	143	{
145	144	flipx ^= 0x0040;
146	145	flipy ^= 0x0080;
147	146	}
148	147
149	148	drawgfxzoom_transpen( bitmap, cliprect,
150		machine.gfx[0],
	149	machine().gfx[0],
151	150	tile,
152	151	color,
153	152	flipx, flipy,
r21022	r21023
164	163	}
165	164	}
166	165
167		static void recordbr_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	166	void taitoh_state::recordbr_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
168	167	{
169	168	/* Y chain size is 16/32?/64/64? pixels. X chain size
170	169	is always 64 pixels. */
171	170
172		taitoh_state *state = machine.driver_data<taitoh_state>();
173		address_space &space = machine.driver_data()->generic_space();
	171	address_space &space = machine().driver_data()->generic_space();
174	172	static const int size[] = { 1, 2, 4, 4 };
175	173	int x0, y0, x, y, dx, dy, ex, ey, zx, zy;
176	174	int ysize;
r21022	r21023
184	182	if (offs <  0x01b0 && priority == 0)    continue;
185	183	if (offs >= 0x01b0 && priority == 1)    continue;
186	184
187		x0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
188		y0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
189		zoomx     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
190		zoomy     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x007f);
191		tile_offs = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
192		ysize     = size[(tc0080vco_sprram_r(state->m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
	185	x0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
	186	y0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
	187	zoomx     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
	188	zoomy     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x007f);
	189	tile_offs = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
	190	ysize     = size[(tc0080vco_sprram_r(m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
193	191
194	192	if (tile_offs)
195	193	{
r21022	r21023
225	223	if (x0 >= 0x200) x0 -= 0x400;
226	224	if (y0 >= 0x200) y0 -= 0x400;
227	225
228		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	226	if (tc0080vco_flipscreen_r(m_tc0080vco))
229	227	{
230	228	x0 = 497 - x0;
231	229	y0 = 498 - y0;
r21022	r21023
248	246	{
249	247	int tile, color, flipx, flipy;
250	248
251		tile  = tc0080vco_cram_0_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
252		color = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
253		flipx = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
254		flipy = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
	249	tile  = tc0080vco_cram_0_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
	250	color = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
	251	flipx = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
	252	flipy = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
255	253
256		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	254	if (tc0080vco_flipscreen_r(m_tc0080vco))
257	255	{
258	256	flipx ^= 0x0040;
259	257	flipy ^= 0x0080;
260	258	}
261	259
262	260	drawgfxzoom_transpen( bitmap, cliprect,
263		machine.gfx[0],
	261	machine().gfx[0],
264	262	tile,
265	263	color,
266	264	flipx, flipy,
r21022	r21023
277	275	}
278	276	}
279	277
280		static void dleague_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	278	void taitoh_state::dleague_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
281	279	{
282	280	/* Y chain size is 16/32?/64/64? pixels. X chain size
283	281	is always 64 pixels. */
284	282
285		taitoh_state *state = machine.driver_data<taitoh_state>();
286		address_space &space = machine.driver_data()->generic_space();
	283	address_space &space = machine().driver_data()->generic_space();
287	284	static const int size[] = { 1, 2, 4, 4 };
288	285	int x0, y0, x, y, dx, ex, zx;
289	286	int ysize;
r21022	r21023
295	292
296	293	for (offs = 0x03f8 / 2; offs >= 0; offs -= 0x008 / 2)
297	294	{
298		x0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
299		y0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
300		zoomx     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
301		tile_offs = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
302		pribit    = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 0, 0xffff) & 0x1000) >> 12;
303		ysize     = size[(tc0080vco_sprram_r(state->m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
	295	x0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
	296	y0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
	297	zoomx     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
	298	tile_offs = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
	299	pribit    = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 0, 0xffff) & 0x1000) >> 12;
	300	ysize     = size[(tc0080vco_sprram_r(m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
304	301
305	302	if (tile_offs)
306	303	{
r21022	r21023
320	317	zx = (dx + ex) << 12;
321	318	}
322	319
323		if (tc0080vco_scrram_r(state->m_tc0080vco, space, 0x0002, 0xffff) & 0x8000)
	320	if (tc0080vco_scrram_r(m_tc0080vco, space, 0x0002, 0xffff) & 0x8000)
324	321	pribit = 1;
325	322
326	323	if (x0 >= 0x200) x0 -= 0x400;
327	324	if (y0 >= 0x200) y0 -= 0x400;
328	325
329		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	326	if (tc0080vco_flipscreen_r(m_tc0080vco))
330	327	{
331	328	x0 = 497 - x0;
332	329	y0 = 498 - y0;
r21022	r21023
350	347	{
351	348	int tile, color, flipx, flipy;
352	349
353		tile  = tc0080vco_cram_0_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
354		color = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
355		flipx = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
356		flipy = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
	350	tile  = tc0080vco_cram_0_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
	351	color = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
	352	flipx = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
	353	flipy = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
357	354
358	355
359		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	356	if (tc0080vco_flipscreen_r(m_tc0080vco))
360	357	{
361	358	flipx ^= 0x0040;
362	359	flipy ^= 0x0080;
363	360	}
364	361
365	362	drawgfxzoom_transpen( bitmap, cliprect,
366		machine.gfx[0],
	363	machine().gfx[0],
367	364	tile,
368	365	color,
369	366	flipx, flipy,
r21022	r21023
383	380
384	381
385	382
386		static void taitoh_log_vram(running_machine &machine)
	383	void taitoh_state::taitoh_log_vram()
387	384	{
388	385	#ifdef MAME_DEBUG
389	386	// null function: the necessary pointers are now internal to taitoic.c
r21022	r21023
398	395	{
399	396	tc0080vco_tilemap_update(m_tc0080vco);
400	397
401		taitoh_log_vram(machine());
	398	taitoh_log_vram();
402	399
403	400	bitmap.fill(0, cliprect);
404	401
405	402	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 0, TILEMAP_DRAW_OPAQUE, 0);
406	403	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 1, 0, 0);
407		syvalion_draw_sprites(machine(), bitmap,cliprect);
	404	syvalion_draw_sprites(bitmap,cliprect);
408	405	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 2, 0, 0);
409	406
410	407	return 0;
r21022	r21023
415	412	{
416	413	tc0080vco_tilemap_update(m_tc0080vco);
417	414
418		taitoh_log_vram(machine());
	415	taitoh_log_vram();
419	416
420	417	bitmap.fill(0, cliprect);
421	418
r21022	r21023
423	420	if (!machine().input().code_pressed(KEYCODE_A))
424	421	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 0, TILEMAP_DRAW_OPAQUE, 0);
425	422	if (!machine().input().code_pressed(KEYCODE_S))
426		recordbr_draw_sprites(machine(), bitmap, cliprect, 0);
	423	recordbr_draw_sprites(bitmap, cliprect, 0);
427	424	if (!machine().input().code_pressed(KEYCODE_D))
428	425	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 1, 0, 0);
429	426	if (!machine().input().code_pressed(KEYCODE_F))
430		recordbr_draw_sprites(machine(), bitmap, cliprect, 1);
	427	recordbr_draw_sprites(bitmap, cliprect, 1);
431	428	#else
432	429	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 0, TILEMAP_DRAW_OPAQUE, 0);
433		recordbr_draw_sprites(machine(), bitmap, cliprect, 0);
	430	recordbr_draw_sprites(bitmap, cliprect, 0);
434	431	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 1, 0, 0);
435		recordbr_draw_sprites(machine(), bitmap, cliprect, 1);
	432	recordbr_draw_sprites(bitmap, cliprect, 1);
436	433	#endif
437	434
438	435	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 2, 0, 0);
r21022	r21023
444	441	{
445	442	tc0080vco_tilemap_update(m_tc0080vco);
446	443
447		taitoh_log_vram(machine());
	444	taitoh_log_vram();
448	445
449	446	bitmap.fill(0, cliprect);
450	447
r21022	r21023
459	456	dleague_draw_sprites(machine(), bitmap, cliprect, 1);
460	457	#else
461	458	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 0, TILEMAP_DRAW_OPAQUE, 0);
462		dleague_draw_sprites (machine(), bitmap, cliprect, 0);
	459	dleague_draw_sprites (bitmap, cliprect, 0);
463	460	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 1, 0, 0);
464		dleague_draw_sprites (machine(), bitmap, cliprect, 1);
	461	dleague_draw_sprites (bitmap, cliprect, 1);
465	462	#endif
466	463
467	464	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 2, 0, 0);

trunk/src/mame/video/tp84.c

r21022	r21023
149	149	}
150	150
151	151
152		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	152	void tp84_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
153	153	{
154		tp84_state *state = machine.driver_data<tp84_state>();
155	154	int offs;
156		int palette_base = ((*state->m_palette_bank & 0x07) << 4);
	155	int palette_base = ((*m_palette_bank & 0x07) << 4);
157	156
158	157	for (offs = 0x5c; offs >= 0; offs -= 4)
159	158	{
160		int x = state->m_spriteram[offs];
161		int y = 240 - state->m_spriteram[offs + 3];
	159	int x = m_spriteram[offs];
	160	int y = 240 - m_spriteram[offs + 3];
162	161
163		int code = state->m_spriteram[offs + 1];
164		int color = palette_base | (state->m_spriteram[offs + 2] & 0x0f);
165		int flip_x = ~state->m_spriteram[offs + 2] & 0x40;
166		int flip_y =  state->m_spriteram[offs + 2] & 0x80;
	162	int code = m_spriteram[offs + 1];
	163	int color = palette_base | (m_spriteram[offs + 2] & 0x0f);
	164	int flip_x = ~m_spriteram[offs + 2] & 0x40;
	165	int flip_y =  m_spriteram[offs + 2] & 0x80;
167	166
168		drawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flip_x, flip_y, x, y,
169		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, palette_base));
	167	drawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flip_x, flip_y, x, y,
	168	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, palette_base));
170	169
171	170	}
172	171	}
r21022	r21023
189	188	}
190	189
191	190	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
192		draw_sprites(machine(), bitmap, cliprect);
	191	draw_sprites(bitmap, cliprect);
193	192
194	193	/* draw top status region */
195	194	clip.min_x = visarea.min_x;

trunk/src/mame/video/tecmosys.c

r21022	r21023
70	70	}
71	71
72	72
73		INLINE void set_color_555_tecmo(running_machine &machine, pen_t color, int rshift, int gshift, int bshift, UINT16 data)
	73	inline void tecmosys_state::set_color_555_tecmo(pen_t color, int rshift, int gshift, int bshift, UINT16 data)
74	74	{
75		palette_set_color_rgb(machine, color, pal5bit(data >> rshift), pal5bit(data >> gshift), pal5bit(data >> bshift));
	75	palette_set_color_rgb(machine(), color, pal5bit(data >> rshift), pal5bit(data >> gshift), pal5bit(data >> bshift));
76	76	}
77	77
78	78	WRITE16_MEMBER(tecmosys_state::tilemap_paletteram16_xGGGGGRRRRRBBBBB_word_w)
79	79	{
80	80	COMBINE_DATA(&m_tilemap_paletteram16[offset]);
81		set_color_555_tecmo(machine(), offset+0x4000, 5, 10, 0, m_tilemap_paletteram16[offset]);
	81	set_color_555_tecmo(offset+0x4000, 5, 10, 0, m_tilemap_paletteram16[offset]);
82	82	}
83	83
84	84	WRITE16_MEMBER(tecmosys_state::bg0_tilemap_lineram_w)
r21022	r21023
101	101
102	102
103	103
104		static void tecmosys_render_sprites_to_bitmap(running_machine &machine, bitmap_rgb32 &bitmap, UINT16 extrax, UINT16 extray )
	104	void tecmosys_state::tecmosys_render_sprites_to_bitmap(bitmap_rgb32 &bitmap, UINT16 extrax, UINT16 extray )
105	105	{
106		tecmosys_state *state = machine.driver_data<tecmosys_state>();
107		UINT8 *gfxsrc    = state->memregion       ( "gfx1" )->base();
	106	UINT8 *gfxsrc    = memregion       ( "gfx1" )->base();
108	107	int i;
109	108
110	109	/* render sprites (with priority information) to temp bitmap */
111		state->m_sprite_bitmap.fill(0x0000);
	110	m_sprite_bitmap.fill(0x0000);
112	111	/* there are multiple spritelists in here, to allow for buffering */
113		for (i=(state->m_spritelist*0x4000)/2;i<((state->m_spritelist+1)*0x4000)/2;i+=8)
	112	for (i=(m_spritelist*0x4000)/2;i<((m_spritelist+1)*0x4000)/2;i+=8)
114	113	{
115	114	int xcnt,ycnt;
116	115	int drawx, drawy;
r21022	r21023
125	124	int priority;
126	125	int zoomx, zoomy;
127	126
128		x = state->m_spriteram[i+0]+386;
129		y = (state->m_spriteram[i+1]+1);
	127	x = m_spriteram[i+0]+386;
	128	y = (m_spriteram[i+1]+1);
130	129
131	130	x-= extrax;
132	131	y-= extray;
r21022	r21023
137	136	if (x&0x200) x-=0x400;
138	137	if (y&0x100) y-=0x200;
139	138
140		address =  state->m_spriteram[i+5]| ((state->m_spriteram[i+4]&0x000f)<<16);
	139	address =  m_spriteram[i+5]| ((m_spriteram[i+4]&0x000f)<<16);
141	140
142	141	address<<=8;
143	142
144		flipx = (state->m_spriteram[i+4]&0x0040)>>6;
145		flipy = (state->m_spriteram[i+4]&0x0080)>>7; // used by some move effects in tkdensho
	143	flipx = (m_spriteram[i+4]&0x0040)>>6;
	144	flipy = (m_spriteram[i+4]&0x0080)>>7; // used by some move effects in tkdensho
146	145
147		zoomx = (state->m_spriteram[i+2] & 0x0fff)>>0; // zoom?
148		zoomy = (state->m_spriteram[i+3] & 0x0fff)>>0; // zoom?
	146	zoomx = (m_spriteram[i+2] & 0x0fff)>>0; // zoom?
	147	zoomy = (m_spriteram[i+3] & 0x0fff)>>0; // zoom?
149	148
150	149	if ((!zoomx) || (!zoomy)) continue;
151	150
152		ysize =  ((state->m_spriteram[i+6] & 0x00ff))*16;
153		xsize =  (((state->m_spriteram[i+6] & 0xff00)>>8))*16;
	151	ysize =  ((m_spriteram[i+6] & 0x00ff))*16;
	152	xsize =  (((m_spriteram[i+6] & 0xff00)>>8))*16;
154	153
155		colour =  ((state->m_spriteram[i+4] & 0x3f00))>>8;
	154	colour =  ((m_spriteram[i+4] & 0x3f00))>>8;
156	155
157		priority = ((state->m_spriteram[i+4] & 0x0030))>>4;
	156	priority = ((m_spriteram[i+4] & 0x0030))>>4;
158	157
159		if (state->m_spriteram[i+4] & 0x8000) continue;
	158	if (m_spriteram[i+4] & 0x8000) continue;
160	159
161	160	for (ycnt = 0; ycnt < ysize; ycnt++)
162	161	{
r21022	r21023
178	177	{
179	178	UINT8 data;
180	179
181		dstptr = &state->m_sprite_bitmap.pix16(drawy, drawx);
	180	dstptr = &m_sprite_bitmap.pix16(drawy, drawx);
182	181
183	182
184	183	data =  (gfxsrc[address]);
r21022	r21023
193	192	}
194	193	}
195	194
196		static void tecmosys_tilemap_copy_to_compose(tecmosys_state *state, UINT16 pri)
	195	void tecmosys_state::tecmosys_tilemap_copy_to_compose(UINT16 pri)
197	196	{
198	197	int y,x;
199	198	UINT16 *srcptr;
200	199	UINT16 *dstptr;
201	200	for (y=0;y<240;y++)
202	201	{
203		srcptr = &state->m_tmp_tilemap_renderbitmap.pix16(y);
204		dstptr = &state->m_tmp_tilemap_composebitmap.pix16(y);
	202	srcptr = &m_tmp_tilemap_renderbitmap.pix16(y);
	203	dstptr = &m_tmp_tilemap_composebitmap.pix16(y);
205	204	for (x=0;x<320;x++)
206	205	{
207	206	if ((srcptr[x]&0xf)!=0x0)
r21022	r21023
210	209	}
211	210	}
212	211
213		static void tecmosys_do_final_mix(running_machine &machine, bitmap_rgb32 &bitmap)
	212	void tecmosys_state::tecmosys_do_final_mix(bitmap_rgb32 &bitmap)
214	213	{
215		tecmosys_state *state = machine.driver_data<tecmosys_state>();
216		const pen_t *paldata = machine.pens;
	214	const pen_t *paldata = machine().pens;
217	215	int y,x;
218	216	UINT16 *srcptr;
219	217	UINT16 *srcptr2;
r21022	r21023
221	219
222	220	for (y=0;y<240;y++)
223	221	{
224		srcptr = &state->m_tmp_tilemap_composebitmap.pix16(y);
225		srcptr2 = &state->m_sprite_bitmap.pix16(y);
	222	srcptr = &m_tmp_tilemap_composebitmap.pix16(y);
	223	srcptr2 = &m_sprite_bitmap.pix16(y);
226	224
227	225	dstptr = &bitmap.pix32(y);
228	226	for (x=0;x<320;x++)
r21022	r21023
236	234	pri = srcptr[x] & 0xc000;
237	235	pri2 = srcptr2[x] & 0xc000;
238	236
239		penvalue = state->m_tilemap_paletteram16[srcptr[x]&0x7ff];
	237	penvalue = m_tilemap_paletteram16[srcptr[x]&0x7ff];
240	238	colour =   paldata[(srcptr[x]&0x7ff) | 0x4000];
241	239
242	240	if (srcptr2[x]&0x3fff)
243	241	{
244		penvalue2 = state->m_generic_paletteram_16[srcptr2[x]&0x3fff];
	242	penvalue2 = m_generic_paletteram_16[srcptr2[x]&0x3fff];
245	243	colour2 = paldata[srcptr2[x]&0x3fff];
246	244	}
247	245	else
248	246	{
249		penvalue2 = state->m_tilemap_paletteram16[srcptr[x]&0x7ff];
	247	penvalue2 = m_tilemap_paletteram16[srcptr[x]&0x7ff];
250	248	colour2 =   paldata[(srcptr[x]&0x7ff) | 0x4000];
251	249	}
252	250
r21022	r21023
299	297
300	298	m_tmp_tilemap_renderbitmap.fill(0, cliprect);
301	299	m_bg0tilemap->draw(m_tmp_tilemap_renderbitmap, cliprect, 0,0);
302		tecmosys_tilemap_copy_to_compose(this, 0x0000);
	300	tecmosys_tilemap_copy_to_compose(0x0000);
303	301
304	302	m_tmp_tilemap_renderbitmap.fill(0, cliprect);
305	303	m_bg1tilemap->draw(m_tmp_tilemap_renderbitmap, cliprect, 0,0);
306		tecmosys_tilemap_copy_to_compose(this, 0x4000);
	304	tecmosys_tilemap_copy_to_compose(0x4000);
307	305
308	306	m_tmp_tilemap_renderbitmap.fill(0, cliprect);
309	307	m_bg2tilemap->draw(m_tmp_tilemap_renderbitmap, cliprect, 0,0);
310		tecmosys_tilemap_copy_to_compose(this, 0x8000);
	308	tecmosys_tilemap_copy_to_compose(0x8000);
311	309
312	310	m_tmp_tilemap_renderbitmap.fill(0, cliprect);
313	311	m_txt_tilemap->draw(m_tmp_tilemap_renderbitmap, cliprect, 0,0);
314		tecmosys_tilemap_copy_to_compose(this, 0xc000);
	312	tecmosys_tilemap_copy_to_compose(0xc000);
315	313
316	314
317		tecmosys_do_final_mix(machine(), bitmap);
	315	tecmosys_do_final_mix(bitmap);
318	316
319	317	// prepare sprites for NEXT frame - causes 1 frame palette errors, but prevents sprite lag in tkdensho, which is correct?
320		tecmosys_render_sprites_to_bitmap(machine(), bitmap, m_880000regs[0x0], m_880000regs[0x1]);
	318	tecmosys_render_sprites_to_bitmap(bitmap, m_880000regs[0x0], m_880000regs[0x1]);
321	319
322	320	return 0;
323	321	}

trunk/src/mame/video/taitosj.c

r21022	r21023
11	11	#include "includes/taitosj.h"
12	12
13	13
14		#define GLOBAL_FLIP_X           (*state->m_video_mode & 0x01)
15		#define GLOBAL_FLIP_Y           (*state->m_video_mode & 0x02)
16		#define SPRITE_RAM_PAGE_OFFSET  ((*state->m_video_mode & 0x04) ? 0x80 : 0x00)
17		#define SPRITES_ON              (*state->m_video_mode & 0x80)
	14	#define GLOBAL_FLIP_X           (*m_video_mode & 0x01)
	15	#define GLOBAL_FLIP_Y           (*m_video_mode & 0x02)
	16	#define SPRITE_RAM_PAGE_OFFSET  ((*m_video_mode & 0x04) ? 0x80 : 0x00)
	17	#define SPRITES_ON              (*m_video_mode & 0x80)
18	18	#define TRANSPARENT_PEN         (0x40)
19	19
20	20
21	21
22	22	static const int layer_enable_mask[3] = { 0x10, 0x20, 0x40 };
23	23
24		typedef void (*copy_layer_func_t)(running_machine &, bitmap_ind16 &,
25		const rectangle &, int, int *, rectangle *);
26	24
27
28	25	/***************************************************************************
29	26
30	27	I call the three layers with the conventional names "front", "middle" and
r21022	r21023
90	87
91	88	***************************************************************************/
92	89
93		static void set_pens(running_machine &machine)
	90	void taitosj_state::set_pens()
94	91	{
95		taitosj_state *state = machine.driver_data<taitosj_state>();
96	92	static const int resistances[3] = { 1000, 470, 270 };
97	93	double rweights[3], gweights[3], bweights[3];
98	94	int i;
r21022	r21023
109	105	int r, g, b, val;
110	106
111	107	/* red component */
112		val = state->m_paletteram[(i << 1) | 0x01];
	108	val = m_paletteram[(i << 1) | 0x01];
113	109	bit0 = (~val >> 6) & 0x01;
114	110	bit1 = (~val >> 7) & 0x01;
115		val = state->m_paletteram[(i << 1) | 0x00];
	111	val = m_paletteram[(i << 1) | 0x00];
116	112	bit2 = (~val >> 0) & 0x01;
117	113	r = combine_3_weights(rweights, bit0, bit1, bit2);
118	114
119	115	/* green component */
120		val = state->m_paletteram[(i << 1) | 0x01];
	116	val = m_paletteram[(i << 1) | 0x01];
121	117	bit0 = (~val >> 3) & 0x01;
122	118	bit1 = (~val >> 4) & 0x01;
123	119	bit2 = (~val >> 5) & 0x01;
124	120	g = combine_3_weights(gweights, bit0, bit1, bit2);
125	121
126	122	/* blue component */
127		val = state->m_paletteram[(i << 1) | 0x01];
	123	val = m_paletteram[(i << 1) | 0x01];
128	124	bit0 = (~val >> 0) & 0x01;
129	125	bit1 = (~val >> 1) & 0x01;
130	126	bit2 = (~val >> 2) & 0x01;
131	127	b = combine_3_weights(bweights, bit0, bit1, bit2);
132	128
133		palette_set_color(machine, i, MAKE_RGB(r, g, b));
	129	palette_set_color(machine(), i, MAKE_RGB(r, g, b));
134	130	}
135	131	}
136	132
r21022	r21023
140	136
141	137	***************************************************************************/
142	138
143		static void compute_draw_order(running_machine &machine)
	139	void taitosj_state::compute_draw_order()
144	140	{
145		taitosj_state *state = machine.driver_data<taitosj_state>();
146	141	int i;
147		UINT8 *color_prom = state->memregion("proms")->base();
	142	UINT8 *color_prom = memregion("proms")->base();
148	143
149	144	/* do a simple conversion of the PROM into layer priority order. Note that */
150	145	/* this is a simplification, which assumes the PROM encodes a sensible priority */
r21022	r21023
165	160
166	161	mask |= (1 << data);    /* in next loop, we'll see which of the remaining */
167	162	/* layers has top priority when this one is transparent */
168		state->m_draw_order[i][j] = data;
	163	m_draw_order[i][j] = data;
169	164	}
170	165	}
171	166	}
r21022	r21023
191	186	machine().gfx[2]->set_source(m_characterram + 0x1800);
192	187	machine().gfx[3]->set_source(m_characterram + 0x1800);
193	188
194		compute_draw_order(machine());
	189	compute_draw_order();
195	190	}
196	191
197	192
r21022	r21023
251	246	}
252	247
253	248
254		INLINE int get_sprite_xy(taitosj_state *state, UINT8 which, UINT8* sx, UINT8* sy)
	249	inline int taitosj_state::get_sprite_xy(UINT8 which, UINT8* sx, UINT8* sy)
255	250	{
256	251	offs_t offs = which * 4;
257	252
258		*sx =       state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 0] - 1;
259		*sy = 240 - state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 1];
	253	*sx =       m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 0] - 1;
	254	*sy = 240 - m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 1];
260	255
261	256	return (*sy < 240);
262	257	}
263	258
264	259
265		INLINE gfx_element *get_sprite_gfx_element(running_machine &machine, UINT8 which)
	260	inline gfx_element * taitosj_state::get_sprite_gfx_element(UINT8 which)
266	261	{
267		taitosj_state *state = machine.driver_data<taitosj_state>();
268	262	offs_t offs = which * 4;
269	263
270		return machine.gfx[(state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 3] & 0x40) ? 3 : 1];
	264	return machine().gfx[(m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 3] & 0x40) ? 3 : 1];
271	265	}
272	266
273	267
274		static int check_sprite_sprite_bitpattern(running_machine &machine,
275		int sx1, int sy1, int which1,
276		int sx2, int sy2, int which2)
	268	int taitosj_state::check_sprite_sprite_bitpattern(int sx1, int sy1, int which1,int sx2, int sy2, int which2)
277	269	{
278		taitosj_state *state = machine.driver_data<taitosj_state>();
279	270	int x, y, minx, miny, maxx = 16, maxy = 16;
280	271
281	272	offs_t offs1 = which1 * 4;
r21022	r21023
309	300	}
310	301
311	302	/* draw the sprites into separate bitmaps and check overlapping region */
312		state->m_sprite_layer_collbitmap1.fill(TRANSPARENT_PEN);
313		drawgfx_transpen(state->m_sprite_sprite_collbitmap1, state->m_sprite_sprite_collbitmap1.cliprect(), get_sprite_gfx_element(machine, which1),
314		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs1 + 3] & 0x3f,
	303	m_sprite_layer_collbitmap1.fill(TRANSPARENT_PEN);
	304	drawgfx_transpen(m_sprite_sprite_collbitmap1, m_sprite_sprite_collbitmap1.cliprect(), get_sprite_gfx_element(which1),
	305	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs1 + 3] & 0x3f,
315	306	0,
316		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs1 + 2] & 0x01,
317		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs1 + 2] & 0x02,
	307	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs1 + 2] & 0x01,
	308	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs1 + 2] & 0x02,
318	309	sx1, sy1, 0);
319	310
320		state->m_sprite_sprite_collbitmap2.fill(TRANSPARENT_PEN);
321		drawgfx_transpen(state->m_sprite_sprite_collbitmap2, state->m_sprite_sprite_collbitmap2.cliprect(), get_sprite_gfx_element(machine, which2),
322		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs2 + 3] & 0x3f,
	311	m_sprite_sprite_collbitmap2.fill(TRANSPARENT_PEN);
	312	drawgfx_transpen(m_sprite_sprite_collbitmap2, m_sprite_sprite_collbitmap2.cliprect(), get_sprite_gfx_element(which2),
	313	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs2 + 3] & 0x3f,
323	314	0,
324		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs2 + 2] & 0x01,
325		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs2 + 2] & 0x02,
	315	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs2 + 2] & 0x01,
	316	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs2 + 2] & 0x02,
326	317	sx2, sy2, 0);
327	318
328	319	for (y = miny; y < maxy; y++)
329	320	for (x = minx; x < maxx; x++)
330		if ((state->m_sprite_sprite_collbitmap1.pix16(y, x) != TRANSPARENT_PEN) &&
331		(state->m_sprite_sprite_collbitmap2.pix16(y, x) != TRANSPARENT_PEN))
	321	if ((m_sprite_sprite_collbitmap1.pix16(y, x) != TRANSPARENT_PEN) &&
	322	(m_sprite_sprite_collbitmap2.pix16(y, x) != TRANSPARENT_PEN))
332	323	return 1;  /* collided */
333	324
334	325	return 0;
335	326	}
336	327
337	328
338		static void check_sprite_sprite_collision(running_machine &machine)
	329	void taitosj_state::check_sprite_sprite_collision()
339	330	{
340		taitosj_state *state = machine.driver_data<taitosj_state>();
341	331	if (SPRITES_ON)
342	332	{
343	333	int which1;
r21022	r21023
350	340
351	341	if ((which1 >= 0x10) && (which1 <= 0x17)) continue; /* no sprites here */
352	342
353		if (!get_sprite_xy(state, which1, &sx1, &sy1)) continue;
	343	if (!get_sprite_xy(which1, &sx1, &sy1)) continue;
354	344
355	345	for (which2 = which1 + 1; which2 < 0x20; which2++)
356	346	{
r21022	r21023
358	348
359	349	if ((which2 >= 0x10) && (which2 <= 0x17)) continue;   /* no sprites here */
360	350
361		if (!get_sprite_xy(state, which2, &sx2, &sy2)) continue;
	351	if (!get_sprite_xy(which2, &sx2, &sy2)) continue;
362	352
363	353	/* quickly rule out any pairs that cannot be touching */
364	354	if ((abs((INT8)sx1 - (INT8)sx2) < 16) &&
r21022	r21023
366	356	{
367	357	int reg;
368	358
369		if (!check_sprite_sprite_bitpattern(machine, sx1, sy1, which1, sx2, sy2, which2))  continue;
	359	if (!check_sprite_sprite_bitpattern(sx1, sy1, which1, sx2, sy2, which2))  continue;
370	360
371	361	/* mark sprite as collided */
372	362	/* note that only the sprite with the higher number is marked */
r21022	r21023
379	369	reg = which1 >> 3;
380	370	if (reg == 3)  reg = 2;
381	371
382		state->m_collision_reg[reg] |= (1 << (which1 & 0x07));
	372	m_collision_reg[reg] |= (1 << (which1 & 0x07));
383	373	}
384	374	else
385	375	{
386	376	reg = which2 >> 3;
387	377	if (reg == 3)  reg = 2;
388	378
389		state->m_collision_reg[reg] |= (1 << (which2 & 0x07));
	379	m_collision_reg[reg] |= (1 << (which2 & 0x07));
390	380	}
391	381	}
392	382	}
r21022	r21023
395	385	}
396	386
397	387
398		static void calculate_sprite_areas(running_machine &machine, int *sprites_on, rectangle *sprite_areas)
	388	void taitosj_state::calculate_sprite_areas(int *sprites_on, rectangle *sprite_areas)
399	389	{
400		taitosj_state *state = machine.driver_data<taitosj_state>();
401	390	int which;
402		int width = machine.primary_screen->width();
403		int height = machine.primary_screen->height();
	391	int width = machine().primary_screen->width();
	392	int height = machine().primary_screen->height();
404	393
405	394	for (which = 0; which < 0x20; which++)
406	395	{
r21022	r21023
408	397
409	398	if ((which >= 0x10) && (which <= 0x17)) continue;   /* no sprites here */
410	399
411		if (get_sprite_xy(state, which, &sx, &sy))
	400	if (get_sprite_xy(which, &sx, &sy))
412	401	{
413	402	int minx, miny, maxx, maxy;
414	403
r21022	r21023
446	435	}
447	436
448	437
449		static int check_sprite_layer_bitpattern(running_machine &machine, int which, rectangle *sprite_areas)
	438	int taitosj_state::check_sprite_layer_bitpattern(int which, rectangle *sprite_areas)
450	439	{
451		taitosj_state *state = machine.driver_data<taitosj_state>();
452	440	int y, x;
453	441	offs_t offs = which * 4;
454	442	int result = 0;  /* no collisions */
455	443
456		int check_layer_1 = *state->m_video_mode & layer_enable_mask[0];
457		int check_layer_2 = *state->m_video_mode & layer_enable_mask[1];
458		int check_layer_3 = *state->m_video_mode & layer_enable_mask[2];
	444	int check_layer_1 = *m_video_mode & layer_enable_mask[0];
	445	int check_layer_2 = *m_video_mode & layer_enable_mask[1];
	446	int check_layer_3 = *m_video_mode & layer_enable_mask[2];
459	447
460	448	int minx = sprite_areas[which].min_x;
461	449	int miny = sprite_areas[which].min_y;
462	450	int maxx = sprite_areas[which].max_x + 1;
463	451	int maxy = sprite_areas[which].max_y + 1;
464	452
465		int flip_x = (state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x01) ^ GLOBAL_FLIP_X;
466		int flip_y = (state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x02) ^ GLOBAL_FLIP_Y;
	453	int flip_x = (m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x01) ^ GLOBAL_FLIP_X;
	454	int flip_y = (m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x02) ^ GLOBAL_FLIP_Y;
467	455
468	456	/* draw sprite into a bitmap and check if layers collide */
469		state->m_sprite_layer_collbitmap1.fill(TRANSPARENT_PEN);
470		drawgfx_transpen(state->m_sprite_layer_collbitmap1, state->m_sprite_layer_collbitmap1.cliprect(),get_sprite_gfx_element(machine, which),
471		state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 3] & 0x3f,
	457	m_sprite_layer_collbitmap1.fill(TRANSPARENT_PEN);
	458	drawgfx_transpen(m_sprite_layer_collbitmap1, m_sprite_layer_collbitmap1.cliprect(),get_sprite_gfx_element(which),
	459	m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 3] & 0x3f,
472	460	0,
473	461	flip_x, flip_y,
474	462	0,0,0);
475	463
476	464	for (y = miny; y < maxy; y++)
477	465	for (x = minx; x < maxx; x++)
478		if (state->m_sprite_layer_collbitmap1.pix16(y - miny, x - minx) != TRANSPARENT_PEN) /* is there anything to check for ? */
	466	if (m_sprite_layer_collbitmap1.pix16(y - miny, x - minx) != TRANSPARENT_PEN) /* is there anything to check for ? */
479	467	{
480		if (check_layer_1 && (state->m_sprite_layer_collbitmap2[0].pix16(y, x) != TRANSPARENT_PEN))
	468	if (check_layer_1 && (m_sprite_layer_collbitmap2[0].pix16(y, x) != TRANSPARENT_PEN))
481	469	result |= 0x01;  /* collided with layer 1 */
482	470
483		if (check_layer_2 && (state->m_sprite_layer_collbitmap2[1].pix16(y, x) != TRANSPARENT_PEN))
	471	if (check_layer_2 && (m_sprite_layer_collbitmap2[1].pix16(y, x) != TRANSPARENT_PEN))
484	472	result |= 0x02;  /* collided with layer 2 */
485	473
486		if (check_layer_3 && (state->m_sprite_layer_collbitmap2[2].pix16(y, x) != TRANSPARENT_PEN))
	474	if (check_layer_3 && (m_sprite_layer_collbitmap2[2].pix16(y, x) != TRANSPARENT_PEN))
487	475	result |= 0x04;  /* collided with layer 3 */
488	476	}
489	477
r21022	r21023
491	479	}
492	480
493	481
494		static void check_sprite_layer_collision(running_machine &machine, int *sprites_on, rectangle *sprite_areas)
	482	void taitosj_state::check_sprite_layer_collision(int *sprites_on, rectangle *sprite_areas)
495	483	{
496		taitosj_state *state = machine.driver_data<taitosj_state>();
497	484	if (SPRITES_ON)
498	485	{
499	486	int which;
r21022	r21023
504	491	if ((which >= 0x10) && (which <= 0x17)) continue;   /* no sprites here */
505	492
506	493	if (sprites_on[which])
507		state->m_collision_reg[3] |= check_sprite_layer_bitpattern(machine, which, sprite_areas);
	494	m_collision_reg[3] |= check_sprite_layer_bitpattern(which, sprite_areas);
508	495	}
509	496	}
510	497	}
511	498
512	499
513		static void draw_layers(running_machine &machine)
	500	void taitosj_state::draw_layers()
514	501	{
515		taitosj_state *state = machine.driver_data<taitosj_state>();
516	502	offs_t offs;
517	503
518		state->m_layer_bitmap[0].fill(TRANSPARENT_PEN);
519		state->m_layer_bitmap[1].fill(TRANSPARENT_PEN);
520		state->m_layer_bitmap[2].fill(TRANSPARENT_PEN);
	504	m_layer_bitmap[0].fill(TRANSPARENT_PEN);
	505	m_layer_bitmap[1].fill(TRANSPARENT_PEN);
	506	m_layer_bitmap[2].fill(TRANSPARENT_PEN);
521	507
522	508	for (offs = 0; offs < 0x0400; offs++)
523	509	{
r21022	r21023
527	513	if (GLOBAL_FLIP_X) sx = 31 - sx;
528	514	if (GLOBAL_FLIP_Y) sy = 31 - sy;
529	515
530		drawgfx_transpen(state->m_layer_bitmap[0],state->m_layer_bitmap[0].cliprect(),machine.gfx[state->m_colorbank[0] & 0x08 ? 2 : 0],
531		state->m_videoram_1[offs],
532		state->m_colorbank[0] & 0x07,
	516	drawgfx_transpen(m_layer_bitmap[0],m_layer_bitmap[0].cliprect(),machine().gfx[m_colorbank[0] & 0x08 ? 2 : 0],
	517	m_videoram_1[offs],
	518	m_colorbank[0] & 0x07,
533	519	GLOBAL_FLIP_X,GLOBAL_FLIP_Y,
534	520	8*sx,8*sy,0);
535	521
536		drawgfx_transpen(state->m_layer_bitmap[1],state->m_layer_bitmap[1].cliprect(),machine.gfx[state->m_colorbank[0] & 0x80 ? 2 : 0],
537		state->m_videoram_2[offs],
538		(state->m_colorbank[0] >> 4) & 0x07,
	522	drawgfx_transpen(m_layer_bitmap[1],m_layer_bitmap[1].cliprect(),machine().gfx[m_colorbank[0] & 0x80 ? 2 : 0],
	523	m_videoram_2[offs],
	524	(m_colorbank[0] >> 4) & 0x07,
539	525	GLOBAL_FLIP_X,GLOBAL_FLIP_Y,
540	526	8*sx,8*sy,0);
541	527
542		drawgfx_transpen(state->m_layer_bitmap[2],state->m_layer_bitmap[2].cliprect(),machine.gfx[state->m_colorbank[1] & 0x08 ? 2 : 0],
543		state->m_videoram_3[offs],
544		state->m_colorbank[1] & 0x07,
	528	drawgfx_transpen(m_layer_bitmap[2],m_layer_bitmap[2].cliprect(),machine().gfx[m_colorbank[1] & 0x08 ? 2 : 0],
	529	m_videoram_3[offs],
	530	m_colorbank[1] & 0x07,
545	531	GLOBAL_FLIP_X,GLOBAL_FLIP_Y,
546	532	8*sx,8*sy,0);
547	533	}
548	534	}
549	535
550	536
551		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap)
	537	void taitosj_state::draw_sprites(bitmap_ind16 &bitmap)
552	538	{
553		taitosj_state *state = machine.driver_data<taitosj_state>();
554	539	/*
555	540	sprite visibility area is missing 4 pixels from the sides, surely to reduce
556	541	wraparound side effects. This was verified on a real Elevator Action.
r21022	r21023
574	559
575	560	if ((which >= 0x10) && (which <= 0x17)) continue;   /* no sprites here */
576	561
577		if (get_sprite_xy(state, which, &sx, &sy))
	562	if (get_sprite_xy(which, &sx, &sy))
578	563	{
579		int code = state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 3] & 0x3f;
580		int color = 2 * ((state->m_colorbank[1] >> 4) & 0x03) + ((state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] >> 2) & 0x01);
581		int flip_x = state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x01;
582		int flip_y = state->m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x02;
	564	int code = m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 3] & 0x3f;
	565	int color = 2 * ((m_colorbank[1] >> 4) & 0x03) + ((m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] >> 2) & 0x01);
	566	int flip_x = m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x01;
	567	int flip_y = m_spriteram[SPRITE_RAM_PAGE_OFFSET + offs + 2] & 0x02;
583	568
584	569	if (GLOBAL_FLIP_X)
585	570	{
r21022	r21023
593	578	flip_y = !flip_y;
594	579	}
595	580
596		drawgfx_transpen(bitmap, GLOBAL_FLIP_X ? spritevisibleareaflip : spritevisiblearea,get_sprite_gfx_element(machine, which), code, color,
	581	drawgfx_transpen(bitmap, GLOBAL_FLIP_X ? spritevisibleareaflip : spritevisiblearea,get_sprite_gfx_element(which), code, color,
597	582	flip_x, flip_y, sx, sy,0);
598	583
599	584	/* draw with wrap around. The horizontal games (eg. sfposeid) need this */
600		drawgfx_transpen(bitmap, GLOBAL_FLIP_X ? spritevisibleareaflip : spritevisiblearea,get_sprite_gfx_element(machine, which), code, color,
	585	drawgfx_transpen(bitmap, GLOBAL_FLIP_X ? spritevisibleareaflip : spritevisiblearea,get_sprite_gfx_element(which), code, color,
601	586	flip_x, flip_y, sx - 0x100, sy,0);
602	587	}
603	588	}
r21022	r21023
605	590	}
606	591
607	592
608		static void taitosj_copy_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,
609		int which, int *sprites_on, rectangle *sprite_areas)
	593	void taitosj_state::taitosj_copy_layer(bitmap_ind16 &bitmap, const rectangle &cliprect,int which, int *sprites_on, rectangle *sprite_areas)
610	594	{
611		taitosj_state *state = machine.driver_data<taitosj_state>();
612	595	static const int fudge1[3] = { 3,  1, -1 };
613	596	static const int fudge2[3] = { 8, 10, 12 };
614	597
615		if (*state->m_video_mode & layer_enable_mask[which])
	598	if (*m_video_mode & layer_enable_mask[which])
616	599	{
617	600	int i, scrollx, scrolly[32];
618	601
619		scrollx = state->m_scroll[2 * which];
	602	scrollx = m_scroll[2 * which];
620	603
621	604	if (GLOBAL_FLIP_X)
622	605	scrollx =  (scrollx & 0xf8) + ((scrollx + fudge1[which]) & 7) + fudge2[which];
r21022	r21023
625	608
626	609	if (GLOBAL_FLIP_Y)
627	610	for (i = 0;i < 32;i++)
628		scrolly[31 - i] =  state->m_colscrolly[32 * which + i] + state->m_scroll[2 * which + 1];
	611	scrolly[31 - i] =  m_colscrolly[32 * which + i] + m_scroll[2 * which + 1];
629	612	else
630	613	for (i = 0;i < 32;i++)
631		scrolly[i]      = -state->m_colscrolly[32 * which + i] - state->m_scroll[2 * which + 1];
	614	scrolly[i]      = -m_colscrolly[32 * which + i] - m_scroll[2 * which + 1];
632	615
633		copyscrollbitmap_trans(bitmap, state->m_layer_bitmap[which], 1, &scrollx, 32, scrolly, cliprect, TRANSPARENT_PEN);
	616	copyscrollbitmap_trans(bitmap, m_layer_bitmap[which], 1, &scrollx, 32, scrolly, cliprect, TRANSPARENT_PEN);
634	617
635	618	/* store parts covered with sprites for sprites/layers collision detection */
636	619	for (i = 0; i < 0x20; i++)
r21022	r21023
638	621	if ((i >= 0x10) && (i <= 0x17)) continue; /* no sprites here */
639	622
640	623	if (sprites_on[i])
641		copyscrollbitmap(state->m_sprite_layer_collbitmap2[which], state->m_layer_bitmap[which], 1, &scrollx, 32, scrolly, sprite_areas[i]);
	624	copyscrollbitmap(m_sprite_layer_collbitmap2[which], m_layer_bitmap[which], 1, &scrollx, 32, scrolly, sprite_areas[i]);
642	625	}
643	626	}
644	627	}
645	628
646	629
647		static void kikstart_copy_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,
648		int which, int *sprites_on, rectangle *sprite_areas)
	630	void taitosj_state::kikstart_copy_layer(bitmap_ind16 &bitmap, const rectangle &cliprect,int which, int *sprites_on, rectangle *sprite_areas)
649	631	{
650		taitosj_state *state = machine.driver_data<taitosj_state>();
651		if (*state->m_video_mode & layer_enable_mask[which])
	632	if (*m_video_mode & layer_enable_mask[which])
652	633	{
653	634	int i, scrolly, scrollx[32 * 8];
654	635
r21022	r21023
657	638	switch (which)
658	639	{
659	640	case 0: scrollx[32 * 8 - i] = 0 ;break;
660		case 1: scrollx[32 * 8 - i] = state->m_kikstart_scrollram[i] + ((state->m_scroll[2 * which] + 0x0a) & 0xff);break;
661		case 2: scrollx[32 * 8 - i] = state->m_kikstart_scrollram[0x100 + i] + ((state->m_scroll[2 * which] + 0xc) & 0xff);break;
	641	case 1: scrollx[32 * 8 - i] = m_kikstart_scrollram[i] + ((m_scroll[2 * which] + 0x0a) & 0xff);break;
	642	case 2: scrollx[32 * 8 - i] = m_kikstart_scrollram[0x100 + i] + ((m_scroll[2 * which] + 0xc) & 0xff);break;
662	643	}
663	644	else
664	645	switch (which)
665	646	{
666	647	case 0: scrollx[i] = 0 ;break;
667		case 1: scrollx[i] = 0xff - state->m_kikstart_scrollram[i - 1] - ((state->m_scroll[2 * which] - 0x10) & 0xff);break;
668		case 2: scrollx[i] = 0xff - state->m_kikstart_scrollram[0x100 + i - 1] - ((state->m_scroll[2 * which] - 0x12) & 0xff);break;
	648	case 1: scrollx[i] = 0xff - m_kikstart_scrollram[i - 1] - ((m_scroll[2 * which] - 0x10) & 0xff);break;
	649	case 2: scrollx[i] = 0xff - m_kikstart_scrollram[0x100 + i - 1] - ((m_scroll[2 * which] - 0x12) & 0xff);break;
669	650	}
670	651
671		scrolly = state->m_scroll[2 * which + 1];   /* always 0 */
672		copyscrollbitmap_trans(bitmap, state->m_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, cliprect, TRANSPARENT_PEN);
	652	scrolly = m_scroll[2 * which + 1];   /* always 0 */
	653	copyscrollbitmap_trans(bitmap, m_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, cliprect, TRANSPARENT_PEN);
673	654
674	655	/* store parts covered with sprites for sprites/layers collision detection */
675	656	for (i = 0; i < 0x20; i++)
r21022	r21023
677	658	if ((i >= 0x10) && (i <= 0x17)) continue; /* no sprites here */
678	659
679	660	if (sprites_on[i])
680		copyscrollbitmap(state->m_sprite_layer_collbitmap2[which], state->m_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, sprite_areas[i]);
	661	copyscrollbitmap(m_sprite_layer_collbitmap2[which], m_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, sprite_areas[i]);
681	662	}
682	663	}
683	664	}
684	665
685	666
686		static void copy_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,
687		copy_layer_func_t copy_layer_func, int which, int *sprites_on, rectangle *sprite_areas)
	667	void taitosj_state::copy_layer(bitmap_ind16 &bitmap, const rectangle &cliprect,copy_layer_func_t copy_layer_func, int which, int *sprites_on, rectangle *sprite_areas)
688	668	{
689	669	if (which == 0)
690		draw_sprites(machine, bitmap);
	670	draw_sprites(bitmap);
691	671	else
692		copy_layer_func(machine, bitmap, cliprect, which - 1, sprites_on, sprite_areas);
	672	(this->*copy_layer_func)(bitmap, cliprect, which - 1, sprites_on, sprite_areas);
693	673	}
694	674
695	675
696		static void copy_layers(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,
697		copy_layer_func_t copy_layer_func, int *sprites_on, rectangle *sprite_areas)
	676	void taitosj_state::copy_layers(bitmap_ind16 &bitmap, const rectangle &cliprect,copy_layer_func_t copy_layer_func, int *sprites_on, rectangle *sprite_areas)
698	677	{
699		taitosj_state *state = machine.driver_data<taitosj_state>();
700	678	int i = 0;
701	679
702	680	/* fill the screen with the background color */
703		bitmap.fill(8 * (state->m_colorbank[1] & 0x07), cliprect);
	681	bitmap.fill(8 * (m_colorbank[1] & 0x07), cliprect);
704	682
705	683	for (i = 0; i < 4; i++)
706	684	{
707		int which = state->m_draw_order[*state->m_video_priority & 0x1f][i];
	685	int which = m_draw_order[*m_video_priority & 0x1f][i];
708	686
709		copy_layer(machine, bitmap, cliprect, copy_layer_func, which, sprites_on, sprite_areas);
	687	copy_layer(bitmap, cliprect, copy_layer_func, which, sprites_on, sprite_areas);
710	688	}
711	689	}
712	690
713	691
714		static void check_collision(running_machine &machine, int *sprites_on, rectangle *sprite_areas)
	692	void taitosj_state::check_collision(int *sprites_on, rectangle *sprite_areas)
715	693	{
716		check_sprite_sprite_collision(machine);
	694	check_sprite_sprite_collision();
717	695
718		check_sprite_layer_collision(machine, sprites_on, sprite_areas);
	696	check_sprite_layer_collision(sprites_on, sprite_areas);
719	697
720	698	/*check_layer_layer_collision();*/  /* not implemented !!! */
721	699	}
722	700
723	701
724		static int video_update_common(running_machine &machine, bitmap_ind16 &bitmap,
725		const rectangle &cliprect, copy_layer_func_t copy_layer_func)
	702	int taitosj_state::video_update_common(bitmap_ind16 &bitmap, const rectangle &cliprect, copy_layer_func_t copy_layer_func)
726	703	{
727	704	int sprites_on[0x20];           /* 1 if sprite is active */
728	705	rectangle sprite_areas[0x20];   /* areas on bitmap (sprite locations) */
729	706
730		set_pens(machine);
	707	set_pens();
731	708
732		draw_layers(machine);
	709	draw_layers();
733	710
734		calculate_sprite_areas(machine, sprites_on, sprite_areas);
	711	calculate_sprite_areas(sprites_on, sprite_areas);
735	712
736		copy_layers(machine, bitmap, cliprect, copy_layer_func, sprites_on, sprite_areas);
	713	copy_layers(bitmap, cliprect, copy_layer_func, sprites_on, sprite_areas);
737	714
738	715	/*check_sprite_layer_collision() uses drawn bitmaps, so it must me called _AFTER_ draw_layers() */
739		check_collision(machine, sprites_on, sprite_areas);
	716	check_collision(sprites_on, sprite_areas);
740	717
741	718	return 0;
742	719	}
r21022	r21023
744	721
745	722	UINT32 taitosj_state::screen_update_taitosj(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
746	723	{
747		return video_update_common(machine(), bitmap, cliprect, taitosj_copy_layer);
	724	return video_update_common(bitmap, cliprect, &taitosj_state::taitosj_copy_layer);
748	725	}
749	726
750	727
751	728	UINT32 taitosj_state::screen_update_kikstart(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
752	729	{
753		return video_update_common(machine(), bitmap, cliprect, kikstart_copy_layer);
	730	return video_update_common(bitmap, cliprect, &taitosj_state::kikstart_copy_layer);
754	731	}

trunk/src/mame/video/topspeed.c

r21022	r21023
26	26
27	27	********************************************************************************/
28	28
29		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	29	void topspeed_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
30	30	{
31		topspeed_state *state = machine.driver_data<topspeed_state>();
32		UINT16 *spriteram = state->m_spriteram;
	31	UINT16 *spriteram = m_spriteram;
33	32	int offs, map_offset, x, y, curx, cury, sprite_chunk;
34		UINT16 *spritemap = state->m_spritemap;
	33	UINT16 *spritemap = m_spritemap;
35	34	UINT16 data, tilenum, code, color;
36	35	UINT8 flipx, flipy, priority, bad_chunks;
37	36	UINT8 j, k, px, py, zx, zy, zoomx, zoomy;
r21022	r21023
92	91	zx = x + (((k + 1) * zoomx) / 8) - curx;
93	92	zy = y + (((j + 1) * zoomy) / 16) - cury;
94	93
95		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	94	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
96	95	code,
97	96	color,
98	97	flipx,flipy,
99	98	curx,cury,
100	99	zx<<12,zy<<13,
101		machine.priority_bitmap,primasks[priority],0);
	100	machine().priority_bitmap,primasks[priority],0);
102	101	}
103	102
104	103	if (bad_chunks)
r21022	r21023
181	180	if (m_dislayer[4] == 0)
182	181	#endif
183	182
184		draw_sprites(machine(), bitmap,cliprect);
	183	draw_sprites(bitmap,cliprect);
185	184	return 0;
186	185	}

trunk/src/mame/video/toki.c

r21022	r21023
163	163	***************************************************************************/
164	164
165	165
166		static void toki_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	166	void toki_state::toki_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
167	167	{
168		toki_state *state = machine.driver_data<toki_state>();
169	168	int x,y,xoffs,yoffs,tile,flipx,flipy,color,offs;
170	169	UINT16 *sprite_word;
171	170
172		for (offs = (state->m_spriteram->bytes()/2)-4;offs >= 0;offs -= 4)
	171	for (offs = (m_spriteram->bytes()/2)-4;offs >= 0;offs -= 4)
173	172	{
174		sprite_word = &state->m_spriteram->buffer()[offs];
	173	sprite_word = &m_spriteram->buffer()[offs];
175	174
176	175	if ((sprite_word[2] != 0xf000) && (sprite_word[0] != 0xffff))
177	176	{
r21022	r21023
190	189	flipy   = 0;
191	190	tile    = (sprite_word[1] & 0xfff) + ((sprite_word[2] & 0x8000) >> 3);
192	191
193		if (state->flip_screen()) {
	192	if (flip_screen()) {
194	193	x=240-x;
195	194	y=240-y;
196	195	if (flipx) flipx=0; else flipx=1;
197	196	flipy=1;
198	197	}
199	198
200		drawgfx_transpen (bitmap,cliprect,machine.gfx[1],
	199	drawgfx_transpen (bitmap,cliprect,machine().gfx[1],
201	200	tile,
202	201	color,
203	202	flipx,flipy,
r21022	r21023
207	206	}
208	207
209	208
210		static void tokib_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	209	void toki_state::tokib_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
211	210	{
212		toki_state *state = machine.driver_data<toki_state>();
213	211	int x,y,tile,flipx,color,offs;
214	212	UINT16 *sprite_word;
215	213
216		for (offs = 0;offs < state->m_spriteram->bytes() / 2;offs += 4)
	214	for (offs = 0;offs < m_spriteram->bytes() / 2;offs += 4)
217	215	{
218		sprite_word = &state->m_spriteram->buffer()[offs];
	216	sprite_word = &m_spriteram->buffer()[offs];
219	217
220	218	if (sprite_word[0] == 0xf100)
221	219	break;
r21022	r21023
235	233	tile    = sprite_word[1] & 0x1fff;
236	234	color   = sprite_word[2] >> 12;
237	235
238		drawgfx_transpen (bitmap,cliprect,machine.gfx[1],
	236	drawgfx_transpen (bitmap,cliprect,machine().gfx[1],
239	237	tile,
240	238	color,
241	239	flipx,0,
r21022	r21023
279	277	m_foreground_layer->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
280	278	m_background_layer->draw(bitmap, cliprect, 0,0);
281	279	}
282		toki_draw_sprites(machine(), bitmap,cliprect);
	280	toki_draw_sprites(bitmap,cliprect);
283	281	m_text_layer->draw(bitmap, cliprect, 0,0);
284	282	return 0;
285	283	}
r21022	r21023
301	299	m_background_layer->draw(bitmap, cliprect, 0,0);
302	300	}
303	301
304		tokib_draw_sprites(machine(), bitmap,cliprect);
	302	tokib_draw_sprites(bitmap,cliprect);
305	303	m_text_layer->draw(bitmap, cliprect, 0,0);
306	304	return 0;
307	305	}

trunk/src/mame/video/thedeep.c

r21022	r21023
143	143
144	144	***************************************************************************/
145	145
146		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	146	void thedeep_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
147	147	{
148		thedeep_state *state = machine.driver_data<thedeep_state>();
149		UINT8 *s = state->m_spriteram, *end = s + state->m_spriteram.bytes();
	148	UINT8 *s = m_spriteram, *end = s + m_spriteram.bytes();
150	149
151	150	while (s < end)
152	151	{
r21022	r21023
169	168	if (color & 1)  sx -= 256;
170	169	if (attr  & 1)  sy -= 256;
171	170
172		if (state->flip_screen())
	171	if (flip_screen())
173	172	{
174	173	flipx = !flipx;
175	174	flipy = !flipy;
r21022	r21023
188	187
189	188	for (y = 0; y < ny; y++)
190	189	{
191		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	190	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
192	191	code + (flipy ? (ny - y - 1) :  y),
193	192	color,
194	193	flipx,flipy,
r21022	r21023
222	221	bitmap.fill(get_black_pen(machine()), cliprect);
223	222
224	223	m_tilemap_0->draw(bitmap, cliprect, 0,0);
225		draw_sprites(machine(), bitmap,cliprect);
	224	draw_sprites(bitmap,cliprect);
226	225	m_tilemap_1->draw(bitmap, cliprect, 0,0);
227	226	return 0;
228	227	}

trunk/src/mame/video/tumbleb.c

r21022	r21023
116	116	return (col & 0x1f) + ((row & 0x1f) << 5) + ((col & 0x60) << 5);
117	117	}
118	118
119		INLINE void get_bg_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base)
	119	inline void tumbleb_state::get_bg_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base)
120	120	{
121		tumbleb_state *state = machine.driver_data<tumbleb_state>();
122	121	int data = gfx_base[tile_index];
123	122
124		SET_TILE_INFO(
	123	SET_TILE_INFO_MEMBER(
125	124	gfx_bank,
126		(data & 0x0fff) | (state->m_tilebank >> 2),
	125	(data & 0x0fff) | (m_tilebank >> 2),
127	126	data >> 12,
128	127	0);
129	128	}
130	129
131		TILE_GET_INFO_MEMBER(tumbleb_state::get_bg1_tile_info){ get_bg_tile_info(machine(), tileinfo, tile_index, 2, m_pf1_data); }
132		TILE_GET_INFO_MEMBER(tumbleb_state::get_bg2_tile_info){ get_bg_tile_info(machine(), tileinfo, tile_index, 1, m_pf2_data); }
	130	TILE_GET_INFO_MEMBER(tumbleb_state::get_bg1_tile_info){ get_bg_tile_info(tileinfo, tile_index, 2, m_pf1_data); }
	131	TILE_GET_INFO_MEMBER(tumbleb_state::get_bg2_tile_info){ get_bg_tile_info(tileinfo, tile_index, 1, m_pf2_data); }
133	132
134	133	TILE_GET_INFO_MEMBER(tumbleb_state::get_fg_tile_info)
135	134	{
r21022	r21023
142	141	0);
143	142	}
144	143
145		INLINE void get_fncywld_bg_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base)
	144	inline void tumbleb_state::get_fncywld_bg_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base)
146	145	{
147	146	int data = gfx_base[tile_index * 2];
148	147	int attr = gfx_base[tile_index * 2 + 1];
149	148
150		SET_TILE_INFO(
	149	SET_TILE_INFO_MEMBER(
151	150	gfx_bank,
152	151	data & 0x1fff,
153	152	attr & 0x1f,
154	153	0);
155	154	}
156	155
157		TILE_GET_INFO_MEMBER(tumbleb_state::get_fncywld_bg1_tile_info){ get_fncywld_bg_tile_info(machine(), tileinfo, tile_index, 2, m_pf1_data); }
158		TILE_GET_INFO_MEMBER(tumbleb_state::get_fncywld_bg2_tile_info){ get_fncywld_bg_tile_info(machine(), tileinfo, tile_index, 1, m_pf2_data); }
	156	TILE_GET_INFO_MEMBER(tumbleb_state::get_fncywld_bg1_tile_info){ get_fncywld_bg_tile_info(tileinfo, tile_index, 2, m_pf1_data); }
	157	TILE_GET_INFO_MEMBER(tumbleb_state::get_fncywld_bg2_tile_info){ get_fncywld_bg_tile_info(tileinfo, tile_index, 1, m_pf2_data); }
159	158
160	159	TILE_GET_INFO_MEMBER(tumbleb_state::get_fncywld_fg_tile_info)
161	160	{
r21022	r21023
170	169	}
171	170
172	171
173		INLINE void pangpang_get_bg_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base )
	172	inline void tumbleb_state::pangpang_get_bg_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base )
174	173	{
175	174	int data = gfx_base[tile_index * 2 + 1];
176	175	int attr = gfx_base[tile_index * 2];
177	176
178		SET_TILE_INFO(
	177	SET_TILE_INFO_MEMBER(
179	178	gfx_bank,
180	179	data & 0x1fff,
181	180	(attr >>12) & 0xf,
182	181	0);
183	182	}
184	183
185		INLINE void pangpang_get_bg2x_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base )
	184	inline void tumbleb_state::pangpang_get_bg2x_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base )
186	185	{
187	186	int data = gfx_base[tile_index * 2 + 1];
188	187	int attr = gfx_base[tile_index * 2];
189	188
190		SET_TILE_INFO(
	189	SET_TILE_INFO_MEMBER(
191	190	gfx_bank,
192	191	(data & 0xfff) + 0x1000,
193	192	(attr >>12) & 0xf,
r21022	r21023
195	194	}
196	195
197	196
198		TILE_GET_INFO_MEMBER(tumbleb_state::pangpang_get_bg1_tile_info){ pangpang_get_bg_tile_info(machine(), tileinfo, tile_index, 2, m_pf1_data); }
199		TILE_GET_INFO_MEMBER(tumbleb_state::pangpang_get_bg2_tile_info){ pangpang_get_bg2x_tile_info(machine(), tileinfo, tile_index, 1, m_pf2_data); }
	197	TILE_GET_INFO_MEMBER(tumbleb_state::pangpang_get_bg1_tile_info){ pangpang_get_bg_tile_info(tileinfo, tile_index, 2, m_pf1_data); }
	198	TILE_GET_INFO_MEMBER(tumbleb_state::pangpang_get_bg2_tile_info){ pangpang_get_bg2x_tile_info(tileinfo, tile_index, 1, m_pf2_data); }
200	199
201	200	TILE_GET_INFO_MEMBER(tumbleb_state::pangpang_get_fg_tile_info)
202	201	{
r21022	r21023
283	282
284	283	/******************************************************************************/
285	284
286		void tumbleb_draw_common(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pf1x_offs, int pf1y_offs, int pf2x_offs, int pf2y_offs)
	285	void tumbleb_state::tumbleb_draw_common(bitmap_ind16 &bitmap, const rectangle &cliprect, int pf1x_offs, int pf1y_offs, int pf2x_offs, int pf2y_offs)
287	286	{
288		tumbleb_state *state = machine.driver_data<tumbleb_state>();
289	287
290		state->m_pf1_tilemap->set_scrollx(0, state->m_control_0[1] + pf1x_offs);
291		state->m_pf1_tilemap->set_scrolly(0, state->m_control_0[2] + pf1y_offs);
292		state->m_pf1_alt_tilemap->set_scrollx(0, state->m_control_0[1] + pf1x_offs);
293		state->m_pf1_alt_tilemap->set_scrolly(0, state->m_control_0[2] + pf1y_offs);
294		state->m_pf2_tilemap->set_scrollx(0, state->m_control_0[3] + pf2x_offs);
295		state->m_pf2_tilemap->set_scrolly(0, state->m_control_0[4] + pf2y_offs);
	288	m_pf1_tilemap->set_scrollx(0, m_control_0[1] + pf1x_offs);
	289	m_pf1_tilemap->set_scrolly(0, m_control_0[2] + pf1y_offs);
	290	m_pf1_alt_tilemap->set_scrollx(0, m_control_0[1] + pf1x_offs);
	291	m_pf1_alt_tilemap->set_scrolly(0, m_control_0[2] + pf1y_offs);
	292	m_pf2_tilemap->set_scrollx(0, m_control_0[3] + pf2x_offs);
	293	m_pf2_tilemap->set_scrolly(0, m_control_0[4] + pf2y_offs);
296	294
297		state->m_pf2_tilemap->draw(bitmap, cliprect, 0, 0);
	295	m_pf2_tilemap->draw(bitmap, cliprect, 0, 0);
298	296
299		if (state->m_control_0[6] & 0x80)
300		state->m_pf1_tilemap->draw(bitmap, cliprect, 0, 0);
	297	if (m_control_0[6] & 0x80)
	298	m_pf1_tilemap->draw(bitmap, cliprect, 0, 0);
301	299	else
302		state->m_pf1_alt_tilemap->draw(bitmap, cliprect, 0, 0);
	300	m_pf1_alt_tilemap->draw(bitmap, cliprect, 0, 0);
303	301
304		machine.device<decospr_device>("spritegen")->draw_sprites(bitmap, cliprect, state->m_spriteram, state->m_spriteram.bytes()/2);
	302	machine().device<decospr_device>("spritegen")->draw_sprites(bitmap, cliprect, m_spriteram, m_spriteram.bytes()/2);
305	303	}
306	304
307	305	UINT32 tumbleb_state::screen_update_tumblepb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r21022	r21023
321	319	else
322	320	offs2 = -5;
323	321
324		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	322	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
325	323
326	324	return 0;
327	325	}
r21022	r21023
343	341	else
344	342	offs2 = -5;
345	343
346		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	344	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
347	345	return 0;
348	346	}
349	347
r21022	r21023
364	362	else
365	363	offs2 = -5;
366	364
367		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	365	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
368	366	return 0;
369	367	}
370	368
r21022	r21023
378	376	offsy = 2;
379	377	offsx2 = -5;
380	378
381		tumbleb_draw_common(machine(),bitmap,cliprect, offsx2, 0, offsx, offsy);
	379	tumbleb_draw_common(bitmap,cliprect, offsx2, 0, offsx, offsy);
382	380
383	381	return 0;
384	382	}
r21022	r21023
402	400	else
403	401	offs2 = 8;
404	402
405		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	403	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
406	404	return 0;
407	405	}
408	406
r21022	r21023
415	413	offs = -1;
416	414	offs2 = -2;
417	415
418		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	416	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
419	417
420	418	return 0;
421	419	}
r21022	r21023
429	427	offs = -1;
430	428	offs2 = -5; // foreground scroll..
431	429
432		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, -16, offs, 0);
	430	tumbleb_draw_common(bitmap,cliprect, offs2, -16, offs, 0);
433	431
434	432	m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, m_spriteram.bytes()/2);
435	433	return 0;
r21022	r21023
452	450	else
453	451	offs2 = -5;
454	452
455		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	453	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
456	454
457	455	return 0;
458	456	}
r21022	r21023
474	472	else
475	473	offs2 = -5;
476	474
477		tumbleb_draw_common(machine(),bitmap,cliprect, offs2, 0, offs, 0);
	475	tumbleb_draw_common(bitmap,cliprect, offs2, 0, offs, 0);
478	476	return 0;
479	477	}
480	478

trunk/src/mame/video/tigeroad.c

r21022	r21023
64	64	}
65	65	}
66	66
67		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	67	void tigeroad_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
68	68	{
69		tigeroad_state *state = machine.driver_data<tigeroad_state>();
70		UINT16 *source = &state->m_spriteram->buffer()[state->m_spriteram->bytes()/2] - 4;
71		UINT16 *finish = state->m_spriteram->buffer();
	69	UINT16 *source = &m_spriteram->buffer()[m_spriteram->bytes()/2] - 4;
	70	UINT16 *finish = m_spriteram->buffer();
72	71
73	72	// TODO: The Track Map should probably be drawn on top of the background tilemap...
74	73	//       Also convert the below into a for loop!
r21022	r21023
89	88	if (sx > 0x100) sx -= 0x200;
90	89	if (sy > 0x100) sy -= 0x200;
91	90
92		if (state->flip_screen())
	91	if (flip_screen())
93	92	{
94	93	sx = 240 - sx;
95	94	sy = 240 - sy;
r21022	r21023
98	97	}
99	98
100	99	drawgfx_transpen(bitmap, cliprect,
101		machine.gfx[2],
	100	machine().gfx[2],
102	101	tile_number,
103	102	color,
104	103	flipx, flipy,
r21022	r21023
158	157	UINT32 tigeroad_state::screen_update_tigeroad(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
159	158	{
160	159	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
161		draw_sprites(machine(), bitmap, cliprect, 0);
	160	draw_sprites(bitmap, cliprect, 0);
162	161	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
163		//draw_sprites(machine(), bitmap, cliprect, 1); draw priority sprites?
	162	//draw_sprites(bitmap, cliprect, 1); draw priority sprites?
164	163	m_fg_tilemap->draw(bitmap, cliprect, 0, 2);
165	164	return 0;
166	165	}

trunk/src/mame/video/taito_z.c

r21022	r21023
143	143	********************************************************/
144	144
145	145
146		static void contcirc_draw_sprites_16x8( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
	146	void taitoz_state::contcirc_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
147	147	{
148		taitoz_state *state = machine.driver_data<taitoz_state>();
149		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
150		UINT16 *spriteram = state->m_spriteram;
	148	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	149	UINT16 *spriteram = m_spriteram;
151	150	int offs, data, tilenum, color, flipx, flipy;
152	151	int x, y, priority, curx, cury;
153	152	int sprites_flipscreen = 0;
r21022	r21023
156	155	int bad_chunks;
157	156	static const int primasks[2] = { 0xf0, 0xfc };
158	157
159		for (offs = 0; offs < state->m_spriteram.bytes() / 2; offs += 4)
	158	for (offs = 0; offs < m_spriteram.bytes() / 2; offs += 4)
160	159	{
161	160	data = spriteram[offs + 0];
162	161	zoomy = (data & 0xfe00) >> 9;
r21022	r21023
223	222	flipy = !flipy;
224	223	}
225	224
226		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	225	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
227	226	code,
228	227	color,
229	228	flipx,flipy,
230	229	curx,cury,
231		zx<<12,zy<<13,machine.priority_bitmap,primasks[priority],0);
	230	zx<<12,zy<<13,machine().priority_bitmap,primasks[priority],0);
232	231	}
233	232
234	233	if (bad_chunks)
r21022	r21023
238	237
239	238
240	239
241		static void chasehq_draw_sprites_16x16( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
	240	void taitoz_state::chasehq_draw_sprites_16x16( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
242	241	{
243		taitoz_state *state = machine.driver_data<taitoz_state>();
244		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
245		UINT16 *spriteram = state->m_spriteram;
	242	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	243	UINT16 *spriteram = m_spriteram;
246	244	int offs, data, tilenum, color, flipx, flipy;
247	245	int x, y, priority, curx, cury;
248	246	int sprites_flipscreen = 0;
r21022	r21023
251	249	int bad_chunks;
252	250	static const int primasks[2] = { 0xf0, 0xfc };
253	251
254		for (offs = state->m_spriteram.bytes() / 2 - 4; offs >= 0; offs -= 4)
	252	for (offs = m_spriteram.bytes() / 2 - 4; offs >= 0; offs -= 4)
255	253	{
256	254	data = spriteram[offs + 0];
257	255	zoomy = (data & 0xfe00) >> 9;
r21022	r21023
321	319	flipy = !flipy;
322	320	}
323	321
324		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	322	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
325	323	code,
326	324	color,
327	325	flipx,flipy,
328	326	curx,cury,
329	327	zx<<12,zy<<12,
330		machine.priority_bitmap,primasks[priority],0);
	328	machine().priority_bitmap,primasks[priority],0);
331	329	}
332	330	}
333	331	else if ((zoomx - 1) & 0x20)    /* 64x128 sprites, $40000-$5ffff in spritemap rom, OBJB */
r21022	r21023
364	362	flipy = !flipy;
365	363	}
366	364
367		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2],
	365	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[2],
368	366	code,
369	367	color,
370	368	flipx,flipy,
371	369	curx,cury,
372	370	zx<<12,zy<<12,
373		machine.priority_bitmap,primasks[priority],0);
	371	machine().priority_bitmap,primasks[priority],0);
374	372	}
375	373	}
376	374	else if (!((zoomx - 1) & 0x60)) /* 32x128 sprites, $60000-$7ffff in spritemap rom, OBJB */
r21022	r21023
407	405	flipy = !flipy;
408	406	}
409	407
410		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2],
	408	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[2],
411	409	code,
412	410	color,
413	411	flipx,flipy,
414	412	curx,cury,
415	413	zx<<12,zy<<12,
416		machine.priority_bitmap,primasks[priority],0);
	414	machine().priority_bitmap,primasks[priority],0);
417	415	}
418	416	}
419	417
r21022	r21023
424	422
425	423
426	424
427		static void bshark_draw_sprites_16x8( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
	425	void taitoz_state::bshark_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
428	426	{
429		taitoz_state *state = machine.driver_data<taitoz_state>();
430		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
431		UINT16 *spriteram = state->m_spriteram;
	427	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	428	UINT16 *spriteram = m_spriteram;
432	429	int offs, data, tilenum, color, flipx, flipy;
433	430	int x, y, priority, curx, cury;
434	431	int sprites_flipscreen = 0;
r21022	r21023
437	434	int bad_chunks;
438	435	static const int primasks[2] = { 0xf0, 0xfc };
439	436
440		for (offs = state->m_spriteram.bytes() / 2 - 4; offs >= 0; offs -= 4)
	437	for (offs = m_spriteram.bytes() / 2 - 4; offs >= 0; offs -= 4)
441	438	{
442	439	data = spriteram[offs + 0];
443	440	zoomy = (data & 0x7e00) >> 9;
r21022	r21023
504	501	flipy = !flipy;
505	502	}
506	503
507		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	504	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
508	505	code,
509	506	color,
510	507	flipx,flipy,
511	508	curx,cury,
512	509	zx<<12,zy<<13,
513		machine.priority_bitmap,primasks[priority],0);
	510	machine().priority_bitmap,primasks[priority],0);
514	511	}
515	512
516	513	if (bad_chunks)
r21022	r21023
520	517
521	518
522	519
523		static void sci_draw_sprites_16x8( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
	520	void taitoz_state::sci_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
524	521	{
525		taitoz_state *state = machine.driver_data<taitoz_state>();
526		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
527		UINT16 *spriteram = state->m_spriteram;
	522	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	523	UINT16 *spriteram = m_spriteram;
528	524	int offs, start_offs, data, tilenum, color, flipx, flipy;
529	525	int x, y, priority, curx, cury;
530	526	int sprites_flipscreen = 0;
r21022	r21023
539	535	// reversing it now only gives us sprite updates on alternate
540	536	// frames. So we probably have to partly buffer spriteram?
541	537
542		start_offs = (state->m_sci_spriteframe & 1) * 0x800;
	538	start_offs = (m_sci_spriteframe & 1) * 0x800;
543	539	start_offs = 0x800 - start_offs;
544	540
545	541	for (offs = (start_offs + 0x800 - 4); offs >= start_offs; offs -= 4)
r21022	r21023
609	605	flipy = !flipy;
610	606	}
611	607
612		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	608	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
613	609	code,
614	610	color,
615	611	flipx,flipy,
616	612	curx,cury,
617	613	zx<<12,zy<<13,
618		machine.priority_bitmap,primasks[priority],0);
	614	machine().priority_bitmap,primasks[priority],0);
619	615	}
620	616
621	617	if (bad_chunks)
r21022	r21023
625	621
626	622
627	623
628		static void aquajack_draw_sprites_16x8(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,int y_offs)
	624	void taitoz_state::aquajack_draw_sprites_16x8(bitmap_ind16 &bitmap,const rectangle &cliprect,int y_offs)
629	625	{
630		taitoz_state *state = machine.driver_data<taitoz_state>();
631		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
632		UINT16 *spriteram = state->m_spriteram;
	626	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	627	UINT16 *spriteram = m_spriteram;
633	628	int offs, data, tilenum, color, flipx, flipy;
634	629	int x, y, priority, curx, cury;
635	630	int sprites_flipscreen = 0;
r21022	r21023
638	633	int bad_chunks;
639	634	static const int primasks[2] = { 0xf0, 0xfc };
640	635
641		for (offs = 0; offs < state->m_spriteram.bytes() / 2; offs += 4)
	636	for (offs = 0; offs < m_spriteram.bytes() / 2; offs += 4)
642	637	{
643	638	data = spriteram[offs + 0];
644	639	zoomy = (data & 0x7e00) >> 9;
r21022	r21023
704	699	flipy = !flipy;
705	700	}
706	701
707		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	702	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
708	703	code,
709	704	color,
710	705	flipx,flipy,
711	706	curx,cury,
712	707	zx<<12,zy<<13,
713		machine.priority_bitmap,primasks[priority],0);
	708	machine().priority_bitmap,primasks[priority],0);
714	709	}
715	710
716	711	if (bad_chunks)
r21022	r21023
720	715
721	716
722	717
723		static void spacegun_draw_sprites_16x8(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,int y_offs)
	718	void taitoz_state::spacegun_draw_sprites_16x8(bitmap_ind16 &bitmap,const rectangle &cliprect,int y_offs)
724	719	{
725		taitoz_state *state = machine.driver_data<taitoz_state>();
726		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
727		UINT16 *spriteram = state->m_spriteram;
	720	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	721	UINT16 *spriteram = m_spriteram;
728	722	int offs, data, tilenum, color, flipx, flipy;
729	723	int x, y, priority, curx, cury;
730	724	int sprites_flipscreen = 0;
r21022	r21023
733	727	int bad_chunks;
734	728	static const int primasks[2] = { 0xf0, 0xfc };
735	729
736		for (offs = 0; offs < state->m_spriteram.bytes() / 2 - 4; offs += 4)
	730	for (offs = 0; offs < m_spriteram.bytes() / 2 - 4; offs += 4)
737	731	{
738	732	data = spriteram[offs + 0];
739	733	zoomy = (data & 0xfe00) >> 9;
r21022	r21023
799	793	flipy = !flipy;
800	794	}
801	795
802		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	796	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
803	797	code,
804	798	color,
805	799	flipx,flipy,
806	800	curx,cury,
807	801	zx<<12,zy<<13,
808		machine.priority_bitmap,primasks[priority],0);
	802	machine().priority_bitmap,primasks[priority],0);
809	803	}
810	804
811	805	if (bad_chunks)
r21022	r21023
856	850	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -3, m_road_palbank << 6, 1, 0, 1, 2); // -6
857	851	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
858	852
859		contcirc_draw_sprites_16x8(machine(), bitmap, cliprect, 5); // 7
	853	contcirc_draw_sprites_16x8(bitmap, cliprect, 5); // 7
860	854	return 0;
861	855	}
862	856
r21022	r21023
883	877	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -1, 0xc0, 0, 0, 1, 2);
884	878	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
885	879
886		chasehq_draw_sprites_16x16(machine(), bitmap, cliprect, 7);
	880	chasehq_draw_sprites_16x16(bitmap, cliprect, 7);
887	881	return 0;
888	882	}
889	883
r21022	r21023
908	902	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -1, 0xc0, 0, 1, 1, 2);
909	903	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
910	904
911		bshark_draw_sprites_16x8(machine(), bitmap, cliprect, 8);
	905	bshark_draw_sprites_16x8(bitmap, cliprect, 8);
912	906	return 0;
913	907	}
914	908
r21022	r21023
933	927	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -1, 0xc0, 0, 0, 1, 2);
934	928	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
935	929
936		sci_draw_sprites_16x8(machine(), bitmap, cliprect, 6);
	930	sci_draw_sprites_16x8(bitmap, cliprect, 6);
937	931	return 0;
938	932	}
939	933
r21022	r21023
958	952	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -1, 0, 2, 1, 1, 2);
959	953	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
960	954
961		aquajack_draw_sprites_16x8(machine(), bitmap, cliprect, 3);
	955	aquajack_draw_sprites_16x8(bitmap, cliprect, 3);
962	956	return 0;
963	957	}
964	958
r21022	r21023
982	976	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[1], 0, 2);
983	977	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
984	978
985		spacegun_draw_sprites_16x8(machine(), bitmap, cliprect, 4);
	979	spacegun_draw_sprites_16x8(bitmap, cliprect, 4);
986	980
987	981	return 0;
988	982	}
r21022	r21023
1013	1007	tc0480scp_tilemap_draw(m_tc0480scp, bitmap, cliprect, layer[2], 0, 1);
1014	1008
1015	1009	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -1, 0xc0, 0, 0, 1, 2);
1016		bshark_draw_sprites_16x8(machine(), bitmap, cliprect, 7);
	1010	bshark_draw_sprites_16x8(bitmap, cliprect, 7);
1017	1011
1018	1012	/* This layer used for the big numeric displays */
1019	1013	tc0480scp_tilemap_draw(m_tc0480scp, bitmap, cliprect, layer[3], 0, 4);
r21022	r21023
1049	1043	tc0480scp_tilemap_draw(m_tc0480scp, bitmap, cliprect, layer[3], 0, 2);
1050	1044
1051	1045	tc0150rod_draw(m_tc0150rod, bitmap, cliprect, -1, 0xc0, 0, 0, 1, 2);
1052		sci_draw_sprites_16x8(machine(), bitmap, cliprect, 7);
	1046	sci_draw_sprites_16x8(bitmap, cliprect, 7);
1053	1047
1054	1048	tc0480scp_tilemap_draw(m_tc0480scp, bitmap, cliprect, layer[4], 0, 4);
1055	1049	return 0;

trunk/src/mame/video/toypop.c

r21022	r21023
165	165	m_bg_image[2*offset+1] = (data & 0xf) | ((data & 0xf0) << 4);
166	166	}
167	167
168		static void draw_background(running_machine &machine, bitmap_ind16 &bitmap)
	168	void toypop_state::draw_background(bitmap_ind16 &bitmap)
169	169	{
170		toypop_state *state = machine.driver_data<toypop_state>();
171		pen_t pen_base = 0x300 + 0x10*state->m_palettebank;
	170	pen_t pen_base = 0x300 + 0x10*m_palettebank;
172	171
173	172	// copy the background image from RAM (0x190200-0x19FDFF) to bitmap
174		if (state->m_bitmapflip)
	173	if (m_bitmapflip)
175	174	{
176	175	int offs = 0xFDFE/2;
177	176	for (int y = 0; y < 224; y++)
r21022	r21023
179	178	UINT16 *scanline = &bitmap.pix16(y);
180	179	for (int x = 0; x < 288; x+=2)
181	180	{
182		UINT16 data = state->m_bg_image[offs];
	181	UINT16 data = m_bg_image[offs];
183	182	scanline[x]   = pen_base | (data & 0x0f);
184	183	scanline[x+1] = pen_base | (data >> 8);
185	184	offs--;
r21022	r21023
194	193	UINT16 *scanline = &bitmap.pix16(y);
195	194	for (int x = 0; x < 288; x+=2)
196	195	{
197		UINT16 data = state->m_bg_image[offs];
	196	UINT16 data = m_bg_image[offs];
198	197	scanline[x]   = pen_base | (data >> 8);
199	198	scanline[x+1] = pen_base | (data & 0x0f);
200	199	offs++;
r21022	r21023
212	211	***************************************************************************/
213	212
214	213
215		void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base)
	214	void toypop_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base)
216	215	{
217		toypop_state *state = machine.driver_data<toypop_state>();
218	216	UINT8 *spriteram = spriteram_base + 0x780;
219	217	UINT8 *spriteram_2 = spriteram + 0x800;
220	218	UINT8 *spriteram_3 = spriteram_2 + 0x800;
r21022	r21023
245	243	sy -= 16 * sizey;
246	244	sy = (sy & 0xff) - 32;  // fix wraparound
247	245
248		if (state->flip_screen())
	246	if (flip_screen())
249	247	{
250	248	flipx ^= 1;
251	249	flipy ^= 1;
r21022	r21023
256	254	{
257	255	for (int x = 0;x <= sizex;x++)
258	256	{
259		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	257	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
260	258	sprite + gfx_offs[y ^ (sizey & flipy)][x ^ (sizex & flipx)],
261	259	color,
262	260	flipx,flipy,
263	261	sx + 16*x,sy + 16*y,
264		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0xff));
	262	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0xff));
265	263	}
266	264	}
267	265	}
r21022	r21023
271	269
272	270	UINT32 toypop_state::screen_update_toypop(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
273	271	{
274		draw_background(machine(), bitmap);
	272	draw_background(bitmap);
275	273	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
276		draw_sprites(machine(), bitmap, cliprect, m_spriteram);
	274	draw_sprites(bitmap, cliprect, m_spriteram);
277	275	return 0;
278	276	}

trunk/src/mame/video/taito_f2.c

r21022	r21023
26	26
27	27	/***********************************************************************************/
28	28
29		static void taitof2_core_vh_start (running_machine &machine, int sprite_type, int hide, int flip_hide )
	29	void taitof2_state::taitof2_core_vh_start (int sprite_type, int hide, int flip_hide )
30	30	{
31	31	int i;
32		taitof2_state *state = machine.driver_data<taitof2_state>();
33		state->m_sprite_type = sprite_type;
34		state->m_hide_pixels = hide;
35		state->m_flip_hide_pixels = flip_hide;
	32	m_sprite_type = sprite_type;
	33	m_hide_pixels = hide;
	34	m_flip_hide_pixels = flip_hide;
36	35
37		state->m_spriteram_delayed = auto_alloc_array(machine, UINT16, state->m_spriteram.bytes() / 2);
38		state->m_spriteram_buffered = auto_alloc_array(machine, UINT16, state->m_spriteram.bytes() / 2);
39		state->m_spritelist = auto_alloc_array(machine, struct f2_tempsprite, 0x400);
	36	m_spriteram_delayed = auto_alloc_array(machine(), UINT16, m_spriteram.bytes() / 2);
	37	m_spriteram_buffered = auto_alloc_array(machine(), UINT16, m_spriteram.bytes() / 2);
	38	m_spritelist = auto_alloc_array(machine(), struct f2_tempsprite, 0x400);
40	39
41	40	for (i = 0; i < 8; i ++)
42	41	{
43		state->m_spritebank_buffered[i] = 0x400 * i;
44		state->m_spritebank[i] = state->m_spritebank_buffered[i];
	42	m_spritebank_buffered[i] = 0x400 * i;
	43	m_spritebank[i] = m_spritebank_buffered[i];
45	44	}
46	45
47		state->m_sprites_disabled = 1;
48		state->m_sprites_active_area = 0;
49		state->m_sprites_flipscreen = 0;
	46	m_sprites_disabled = 1;
	47	m_sprites_active_area = 0;
	48	m_sprites_flipscreen = 0;
50	49
51		state->m_sprites_master_scrollx = 0;
52		state->m_sprites_master_scrolly = 0;
	50	m_sprites_master_scrollx = 0;
	51	m_sprites_master_scrolly = 0;
53	52
54		state->m_spriteblendmode = 0;
55		state->m_prepare_sprites = 0;
	53	m_spriteblendmode = 0;
	54	m_prepare_sprites = 0;
56	55
57		state->m_game = 0;  /* means NOT footchmp */
	56	m_game = 0;  /* means NOT footchmp */
58	57
59		state->save_item(NAME(state->m_spritebank));
60		state->save_item(NAME(state->m_spritebank_buffered));
61		state->save_item(NAME(state->m_sprites_disabled));
62		state->save_item(NAME(state->m_sprites_active_area));
63		state->save_item(NAME(state->m_sprites_flipscreen));
64		state->save_item(NAME(state->m_sprites_master_scrollx));
65		state->save_item(NAME(state->m_sprites_master_scrolly));
66		state->save_item(NAME(state->m_tilepri));
67		state->save_item(NAME(state->m_spritepri));
68		state->save_item(NAME(state->m_spriteblendmode));
69		state->save_item(NAME(state->m_prepare_sprites));
70		state->save_pointer(NAME(state->m_spriteram_delayed), state->m_spriteram.bytes() / 2);
71		state->save_pointer(NAME(state->m_spriteram_buffered), state->m_spriteram.bytes() / 2);
	58	save_item(NAME(m_spritebank));
	59	save_item(NAME(m_spritebank_buffered));
	60	save_item(NAME(m_sprites_disabled));
	61	save_item(NAME(m_sprites_active_area));
	62	save_item(NAME(m_sprites_flipscreen));
	63	save_item(NAME(m_sprites_master_scrollx));
	64	save_item(NAME(m_sprites_master_scrolly));
	65	save_item(NAME(m_tilepri));
	66	save_item(NAME(m_spritepri));
	67	save_item(NAME(m_spriteblendmode));
	68	save_item(NAME(m_prepare_sprites));
	69	save_pointer(NAME(m_spriteram_delayed), m_spriteram.bytes() / 2);
	70	save_pointer(NAME(m_spriteram_buffered), m_spriteram.bytes() / 2);
72	71	}
73	72
74	73	/**************************************************************************************/
r21022	r21023
77	76
78	77	VIDEO_START_MEMBER(taitof2_state,taitof2_default)
79	78	{
80		taitof2_core_vh_start(machine(), 0, 0, 0);
	79	taitof2_core_vh_start(0, 0, 0);
81	80	}
82	81
83	82	VIDEO_START_MEMBER(taitof2_state,taitof2_megab)/* Megab, Liquidk */
84	83	{
85		taitof2_core_vh_start(machine(), 0, 3, 3);
	84	taitof2_core_vh_start(0, 3, 3);
86	85	}
87	86
88	87	VIDEO_START_MEMBER(taitof2_state,taitof2_quiz)/* Quiz Crayons, Quiz Jinsei */
89	88	{
90		taitof2_core_vh_start(machine(), 3, 3, 3);
	89	taitof2_core_vh_start(3, 3, 3);
91	90	}
92	91
93	92	VIDEO_START_MEMBER(taitof2_state,taitof2_finalb)
94	93	{
95		taitof2_core_vh_start(machine(), 0, 1, 1);
	94	taitof2_core_vh_start(0, 1, 1);
96	95	}
97	96
98	97	VIDEO_START_MEMBER(taitof2_state,taitof2_ssi)
99	98	{
100		taitof2_core_vh_start(machine(), 0, 3, 3);
	99	taitof2_core_vh_start(0, 3, 3);
101	100	}
102	101
103	102	VIDEO_START_MEMBER(taitof2_state,taitof2_growl)
104	103	{
105		taitof2_core_vh_start(machine(), 0, 3, 3);
	104	taitof2_core_vh_start(0, 3, 3);
106	105	}
107	106
108	107	VIDEO_START_MEMBER(taitof2_state,taitof2_ninjak)
109	108	{
110		taitof2_core_vh_start(machine(), 0, 0, 0);
	109	taitof2_core_vh_start(0, 0, 0);
111	110	}
112	111
113	112	VIDEO_START_MEMBER(taitof2_state,taitof2_qzchikyu)
114	113	{
115		taitof2_core_vh_start(machine(), 0, 0, 4);
	114	taitof2_core_vh_start(0, 0, 4);
116	115	}
117	116
118	117	VIDEO_START_MEMBER(taitof2_state,taitof2_solfigtr)
119	118	{
120		taitof2_core_vh_start(machine(), 0, 3, -3);
	119	taitof2_core_vh_start(0, 3, -3);
121	120	}
122	121
123	122	VIDEO_START_MEMBER(taitof2_state,taitof2_koshien)
124	123	{
125		taitof2_core_vh_start(machine(), 0, 1,  - 1);
	124	taitof2_core_vh_start(0, 1,  - 1);
126	125	}
127	126
128	127	VIDEO_START_MEMBER(taitof2_state,taitof2_gunfront)
129	128	{
130		taitof2_core_vh_start(machine(), 0, 3, 3);
	129	taitof2_core_vh_start(0, 3, 3);
131	130	}
132	131
133	132	VIDEO_START_MEMBER(taitof2_state,taitof2_thundfox)
134	133	{
135		taitof2_core_vh_start(machine(), 0, 3, -3);
	134	taitof2_core_vh_start(0, 3, -3);
136	135	}
137	136
138	137	VIDEO_START_MEMBER(taitof2_state,taitof2_mjnquest)
139	138	{
140		taitof2_core_vh_start(machine(), 0, 0, 0);
	139	taitof2_core_vh_start(0, 0, 0);
141	140
142	141	tc0100scn_set_bg_tilemask(m_tc0100scn, 0x7fff);
143	142	}
144	143
145	144	VIDEO_START_MEMBER(taitof2_state,taitof2_footchmp)
146	145	{
147		taitof2_core_vh_start(machine(), 0, 3, 3);
	146	taitof2_core_vh_start(0, 3, 3);
148	147
149	148	m_game = FOOTCHMP;
150	149	}
151	150
152	151	VIDEO_START_MEMBER(taitof2_state,taitof2_hthero)
153	152	{
154		taitof2_core_vh_start(machine(), 0, 3, 3);
	153	taitof2_core_vh_start(0, 3, 3);
155	154
156	155	m_game = FOOTCHMP;
157	156	}
158	157
159	158	VIDEO_START_MEMBER(taitof2_state,taitof2_deadconx)
160	159	{
161		taitof2_core_vh_start(machine(), 0, 3, 3);
	160	taitof2_core_vh_start(0, 3, 3);
162	161	}
163	162
164	163	VIDEO_START_MEMBER(taitof2_state,taitof2_deadconxj)
165	164	{
166		taitof2_core_vh_start(machine(), 0, 3, 3);
	165	taitof2_core_vh_start(0, 3, 3);
167	166	}
168	167
169	168	VIDEO_START_MEMBER(taitof2_state,taitof2_metalb)
170	169	{
171		taitof2_core_vh_start(machine(), 0, 3, 3);
	170	taitof2_core_vh_start(0, 3, 3);
172	171	}
173	172
174	173	VIDEO_START_MEMBER(taitof2_state,taitof2_yuyugogo)
175	174	{
176		taitof2_core_vh_start(machine(), 1, 3, 3);
	175	taitof2_core_vh_start(1, 3, 3);
177	176	}
178	177
179	178	VIDEO_START_MEMBER(taitof2_state,taitof2_yesnoj)
180	179	{
181		taitof2_core_vh_start(machine(), 0, 3, 3);
	180	taitof2_core_vh_start(0, 3, 3);
182	181	}
183	182
184	183	VIDEO_START_MEMBER(taitof2_state,taitof2_dinorex)
185	184	{
186		taitof2_core_vh_start(machine(), 3, 3, 3);
	185	taitof2_core_vh_start(3, 3, 3);
187	186	}
188	187
189	188	VIDEO_START_MEMBER(taitof2_state,taitof2_dondokod)/* dondokod, cameltry */
190	189	{
191	190	m_pivot_xdisp = -16;
192	191	m_pivot_ydisp = 0;
193		taitof2_core_vh_start(machine(), 0, 3, 3);
	192	taitof2_core_vh_start(0, 3, 3);
194	193	}
195	194
196	195	VIDEO_START_MEMBER(taitof2_state,taitof2_pulirula)
197	196	{
198	197	m_pivot_xdisp = -10;    /* alignment seems correct (see level 2, falling */
199	198	m_pivot_ydisp = 16; /* block of ice after armour man) */
200		taitof2_core_vh_start(machine(), 2, 3, 3);
	199	taitof2_core_vh_start(2, 3, 3);
201	200	}
202	201
203	202	VIDEO_START_MEMBER(taitof2_state,taitof2_driftout)
204	203	{
205	204	m_pivot_xdisp = -16;
206	205	m_pivot_ydisp = 16;
207		taitof2_core_vh_start(machine(), 0, 3, 3);
	206	taitof2_core_vh_start(0, 3, 3);
208	207	}
209	208
210	209
r21022	r21023
271	270	m_spritebank_buffered[7] = m_spritebank_buffered[6] + 0x400;
272	271	}
273	272
274		static void taito_f2_tc360_spritemixdraw( running_machine &machine, bitmap_ind16 &dest_bmp, const rectangle &clip, gfx_element *gfx,
	273	void taitof2_state::taito_f2_tc360_spritemixdraw( bitmap_ind16 &dest_bmp, const rectangle &clip, gfx_element *gfx,
275	274	UINT32 code, UINT32 color, int flipx, int flipy, int sx, int sy, int scalex, int scaley )
276	275	{
277		taitof2_state *state = machine.driver_data<taitof2_state>();
278	276	int pal_base = gfx->colorbase() + gfx->granularity() * (color % gfx->colors());
279	277	const UINT8 *source_base = gfx->get_data(code % gfx->elements());
280	278	bitmap_ind8 &priority_bitmap = gfx->machine().priority_bitmap;
r21022	r21023
360	358	UINT8 tilemap_priority = 0, sprite_priority = 0;
361	359
362	360	// Get tilemap priority (0 - 0xf) for this destination pixel
363		if (pri[x] & 0x10) tilemap_priority = state->m_tilepri[4];
364		else if (pri[x] & 0x8) tilemap_priority = state->m_tilepri[3];
365		else if (pri[x] & 0x4) tilemap_priority = state->m_tilepri[2];
366		else if (pri[x] & 0x2) tilemap_priority = state->m_tilepri[1];
367		else if (pri[x] & 0x1) tilemap_priority = state->m_tilepri[0];
	361	if (pri[x] & 0x10) tilemap_priority = m_tilepri[4];
	362	else if (pri[x] & 0x8) tilemap_priority = m_tilepri[3];
	363	else if (pri[x] & 0x4) tilemap_priority = m_tilepri[2];
	364	else if (pri[x] & 0x2) tilemap_priority = m_tilepri[1];
	365	else if (pri[x] & 0x1) tilemap_priority = m_tilepri[0];
368	366
369	367	// Get sprite priority (0 - 0xf) for this source pixel
370	368	if ((color & 0xc0) == 0xc0)
371		sprite_priority = state->m_spritepri[3];
	369	sprite_priority = m_spritepri[3];
372	370	else if ((color & 0xc0) == 0x80)
373		sprite_priority = state->m_spritepri[2];
	371	sprite_priority = m_spritepri[2];
374	372	else if ((color & 0xc0) == 0x40)
375		sprite_priority = state->m_spritepri[1];
	373	sprite_priority = m_spritepri[1];
376	374	else if ((color & 0xc0) == 0x00)
377		sprite_priority = state->m_spritepri[0];
	375	sprite_priority = m_spritepri[0];
378	376
379	377	// Blend mode 1 - Sprite under tilemap, use sprite palette with tilemap data
380		if ((state->m_spriteblendmode & 0xc0) == 0xc0 && sprite_priority == (tilemap_priority - 1))
	378	if ((m_spriteblendmode & 0xc0) == 0xc0 && sprite_priority == (tilemap_priority - 1))
381	379	{
382	380	dest[x] = ((pal_base + c) & 0xfff0) | (dest[x] & 0xf);
383	381	}
384	382	// Blend mode 1 - Sprite over tilemap, use sprite data with tilemap palette
385		else if ((state->m_spriteblendmode & 0xc0) == 0xc0 && sprite_priority == (tilemap_priority + 1))
	383	else if ((m_spriteblendmode & 0xc0) == 0xc0 && sprite_priority == (tilemap_priority + 1))
386	384	{
387	385	if (dest[x] & 0xf)
388	386	dest[x] = (dest[x] & 0xfff0) | ((pal_base + c) & 0xf);
r21022	r21023
390	388	dest[x] = pal_base + c;
391	389	}
392	390	// Blend mode 2 - Sprite under tilemap, use sprite data with tilemap palette
393		else if ((state->m_spriteblendmode & 0xc0) == 0x80 && sprite_priority == (tilemap_priority - 1))
	391	else if ((m_spriteblendmode & 0xc0) == 0x80 && sprite_priority == (tilemap_priority - 1))
394	392	{
395	393	dest[x] = (dest[x] & 0xffef);
396	394	}
397	395	// Blend mode 2 - Sprite over tilemap, alternate sprite palette, confirmed in Pulirula level 2
398		else if ((state->m_spriteblendmode & 0xc0) == 0x80 && sprite_priority == (tilemap_priority + 1))
	396	else if ((m_spriteblendmode & 0xc0) == 0x80 && sprite_priority == (tilemap_priority + 1))
399	397	{
400	398	dest[x] = ((pal_base + c) & 0xffef); // Pulirula level 2, Liquid Kids attract mode
401	399	}
r21022	r21023
417	415	}
418	416	}
419	417
420		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int *primasks, int uses_tc360_mixer )
	418	void taitof2_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int *primasks, int uses_tc360_mixer )
421	419	{
422	420	/*
423	421	Sprite format:
r21022	r21023
476	474	non zoom parts.
477	475
478	476	*/
479		taitof2_state *state = machine.driver_data<taitof2_state>();
480	477	int i, x, y, off, extoffs;
481	478	int code, color, spritedata, spritecont, flipx, flipy;
482	479	int xcurrent, ycurrent, big_sprite = 0;
r21022	r21023
489	486
490	487	/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
491	488	while processing sprite ram and then draw them all at the end */
492		struct f2_tempsprite *sprite_ptr = state->m_spritelist;
	489	struct f2_tempsprite *sprite_ptr = m_spritelist;
493	490
494	491	/* must remember enable status from last frame because driftout fails to
495	492	reactivate them from a certain point onwards. */
496		int disabled = state->m_sprites_disabled;
	493	int disabled = m_sprites_disabled;
497	494
498	495	/* must remember master scroll from previous frame because driftout
499	496	sometimes doesn't set it. */
500		int master_scrollx = state->m_sprites_master_scrollx;
501		int master_scrolly = state->m_sprites_master_scrolly;
	497	int master_scrollx = m_sprites_master_scrollx;
	498	int master_scrolly = m_sprites_master_scrolly;
502	499
503	500	/* must also remember the sprite bank from previous frame. */
504		int area = state->m_sprites_active_area;
	501	int area = m_sprites_active_area;
505	502
506	503	scroll1x = 0;
507	504	scroll1y = 0;
r21022	r21023
509	506	xcurrent = ycurrent = 0;
510	507	color = 0;
511	508
512		f2_x_offset = state->m_hide_pixels;   /* Get rid of 0-3 unwanted pixels on edge of screen. */
513		if (state->m_sprites_flipscreen)
514		f2_x_offset = -state->m_flip_hide_pixels;       // was -f2_x_offset
	509	f2_x_offset = m_hide_pixels;   /* Get rid of 0-3 unwanted pixels on edge of screen. */
	510	if (m_sprites_flipscreen)
	511	f2_x_offset = -m_flip_hide_pixels;       // was -f2_x_offset
515	512
516	513	/* safety check to avoid getting stuck in bank 2 for games using only one bank */
517		if (area == 0x8000 && state->m_spriteram_buffered[(0x8000 + 6) / 2] == 0 && state->m_spriteram_buffered[(0x8000 + 10) / 2] == 0)
	514	if (area == 0x8000 && m_spriteram_buffered[(0x8000 + 6) / 2] == 0 && m_spriteram_buffered[(0x8000 + 10) / 2] == 0)
518	515	area = 0;
519	516
520	517	for (off = 0; off < 0x4000; off += 16)
r21022	r21023
522	519	/* sprites_active_area may change during processing */
523	520	int offs = off + area;
524	521
525		if (state->m_spriteram_buffered[(offs + 6) / 2] & 0x8000)
	522	if (m_spriteram_buffered[(offs + 6) / 2] & 0x8000)
526	523	{
527		disabled = state->m_spriteram_buffered[(offs + 10) / 2] & 0x1000;
528		state->m_sprites_flipscreen = state->m_spriteram_buffered[(offs + 10) / 2] & 0x2000;
	524	disabled = m_spriteram_buffered[(offs + 10) / 2] & 0x1000;
	525	m_sprites_flipscreen = m_spriteram_buffered[(offs + 10) / 2] & 0x2000;
529	526
530	527	/* Get rid of 0-3 unwanted pixels on edge of screen. */
531		f2_x_offset = state->m_hide_pixels;
532		if (state->m_sprites_flipscreen)
533		f2_x_offset = -state->m_flip_hide_pixels;       // was -f2_x_offset
	528	f2_x_offset = m_hide_pixels;
	529	if (m_sprites_flipscreen)
	530	f2_x_offset = -m_flip_hide_pixels;       // was -f2_x_offset
534	531
535		if (state->m_game == FOOTCHMP)
536		area = 0x8000 * (state->m_spriteram_buffered[(offs + 6) / 2] & 0x0001);
	532	if (m_game == FOOTCHMP)
	533	area = 0x8000 * (m_spriteram_buffered[(offs + 6) / 2] & 0x0001);
537	534	else
538		area = 0x8000 * (state->m_spriteram_buffered[(offs + 10) / 2] & 0x0001);
	535	area = 0x8000 * (m_spriteram_buffered[(offs + 10) / 2] & 0x0001);
539	536	continue;
540	537	}
541	538
542	539	//popmessage("%04x",area);
543	540
544	541	/* check for extra scroll offset */
545		if ((state->m_spriteram_buffered[(offs + 4) / 2] & 0xf000) == 0xa000)
	542	if ((m_spriteram_buffered[(offs + 4) / 2] & 0xf000) == 0xa000)
546	543	{
547		master_scrollx = state->m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
	544	master_scrollx = m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
548	545	if (master_scrollx >= 0x800)
549	546	master_scrollx -= 0x1000;   /* signed value */
550	547
551		master_scrolly = state->m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
	548	master_scrolly = m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
552	549	if (master_scrolly >= 0x800)
553	550	master_scrolly -= 0x1000;   /* signed value */
554	551	}
555	552
556		if ((state->m_spriteram_buffered[(offs + 4) / 2] & 0xf000) == 0x5000)
	553	if ((m_spriteram_buffered[(offs + 4) / 2] & 0xf000) == 0x5000)
557	554	{
558		scroll1x = state->m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
	555	scroll1x = m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
559	556	if (scroll1x >= 0x800)
560	557	scroll1x -= 0x1000;   /* signed value */
561	558
562		scroll1y = state->m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
	559	scroll1y = m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
563	560	if (scroll1y >= 0x800)
564	561	scroll1y -= 0x1000;   /* signed value */
565	562	}
r21022	r21023
567	564	if (disabled)
568	565	continue;
569	566
570		spritedata = state->m_spriteram_buffered[(offs + 8) / 2];
	567	spritedata = m_spriteram_buffered[(offs + 8) / 2];
571	568
572	569	spritecont = (spritedata & 0xff00) >> 8;
573	570
r21022	r21023
575	572	{
576	573	if (big_sprite == 0)   /* are we starting a big sprite ? */
577	574	{
578		xlatch = state->m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
579		ylatch = state->m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
	575	xlatch = m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
	576	ylatch = m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
580	577	x_no = 0;
581	578	y_no = 0;
582		zoomword = state->m_spriteram_buffered[(offs + 2) / 2];
	579	zoomword = m_spriteram_buffered[(offs + 2) / 2];
583	580	zoomylatch = (zoomword >> 8) & 0xff;
584	581	zoomxlatch = (zoomword >> 0) & 0xff;
585	582	big_sprite = 1;   /* we have started a new big sprite */
r21022	r21023
600	597	// of anything.
601	598	if (big_sprite == 0 || (spritecont & 0xf0) == 0)
602	599	{
603		x = state->m_spriteram_buffered[(offs + 4) / 2];
	600	x = m_spriteram_buffered[(offs + 4) / 2];
604	601
605	602	// Some absolute x values deduced here are 1 too high (scenes when you get
606	603	// home run in Koshien, and may also relate to BG layer woods and stuff as you
r21022	r21023
623	620	scrolly = scroll1y + master_scrolly;
624	621	}
625	622	x &= 0xfff;
626		y = state->m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
	623	y = m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
627	624
628	625	xcurrent = x;
629	626	ycurrent = y;
r21022	r21023
675	672	}
676	673	else
677	674	{
678		zoomword = state->m_spriteram_buffered[(offs + 2) / 2];
	675	zoomword = m_spriteram_buffered[(offs + 2) / 2];
679	676	zoomy = (zoomword >> 8) & 0xff;
680	677	zoomx = (zoomword >> 0) & 0xff;
681	678	zx = (0x100 - zoomx) / 16;
r21022	r21023
693	690	/* spriteram[0x4000-7fff] has no corresponding extension area */
694	691	if (extoffs >= 0x8000) extoffs -= 0x4000;
695	692
696		if (state->m_sprite_type == 0)
	693	if (m_sprite_type == 0)
697	694	{
698		code = state->m_spriteram_buffered[(offs) / 2] & 0x1fff;
	695	code = m_spriteram_buffered[(offs) / 2] & 0x1fff;
699	696	i = (code & 0x1c00) >> 10;
700		code = state->m_spritebank[i] + (code & 0x3ff);
	697	code = m_spritebank[i] + (code & 0x3ff);
701	698	}
702	699
703		if (state->m_sprite_type == 1)   /* Yuyugogo */
	700	if (m_sprite_type == 1)   /* Yuyugogo */
704	701	{
705		code = state->m_spriteram_buffered[(offs) / 2] & 0x3ff;
706		i = (state->m_sprite_extension[(extoffs >> 4)] & 0x3f ) << 10;
	702	code = m_spriteram_buffered[(offs) / 2] & 0x3ff;
	703	i = (m_sprite_extension[(extoffs >> 4)] & 0x3f ) << 10;
707	704	code = (i | code);
708	705	}
709	706
710		if (state->m_sprite_type == 2)   /* Pulirula */
	707	if (m_sprite_type == 2)   /* Pulirula */
711	708	{
712		code = state->m_spriteram_buffered[(offs) / 2] & 0xff;
713		i = (state->m_sprite_extension[(extoffs >> 4)] & 0xff00 );
	709	code = m_spriteram_buffered[(offs) / 2] & 0xff;
	710	i = (m_sprite_extension[(extoffs >> 4)] & 0xff00 );
714	711	code = (i | code);
715	712	}
716	713
717		if (state->m_sprite_type == 3)   /* Dinorex and a few quizzes */
	714	if (m_sprite_type == 3)   /* Dinorex and a few quizzes */
718	715	{
719		code = state->m_spriteram_buffered[(offs) / 2] & 0xff;
720		i = (state->m_sprite_extension[(extoffs >> 4)] & 0xff ) << 8;
	716	code = m_spriteram_buffered[(offs) / 2] & 0xff;
	717	i = (m_sprite_extension[(extoffs >> 4)] & 0xff ) << 8;
721	718	code = (i | code);
722	719	}
723	720
r21022	r21023
732	729	cury = (y + scrolly) & 0xfff;
733	730	if (cury >= 0x800)  cury -= 0x1000;   /* treat it as signed */
734	731
735		if (state->m_sprites_flipscreen)
	732	if (m_sprites_flipscreen)
736	733	{
737	734	/* -zx/y is there to fix zoomed sprite coords in screenflip.
738	735	drawgfxzoom does not know to draw from flip-side of sprites when
r21022	r21023
747	744	{
748	745	sprite_ptr->code = code;
749	746	sprite_ptr->color = color;
750		if (machine.gfx[0]->granularity() == 64)    /* Final Blow is 6-bit deep */
	747	if (machine().gfx[0]->granularity() == 64)    /* Final Blow is 6-bit deep */
751	748	sprite_ptr->color /= 4;
752	749	sprite_ptr->flipx = flipx;
753	750	sprite_ptr->flipy = flipy;
r21022	r21023
765	762	}
766	763	else
767	764	{
768		drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	765	drawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
769	766	sprite_ptr->code,
770	767	sprite_ptr->color,
771	768	sprite_ptr->flipx,sprite_ptr->flipy,
r21022	r21023
777	774
778	775
779	776	/* this happens only if primsks != NULL */
780		while (sprite_ptr != state->m_spritelist)
	777	while (sprite_ptr != m_spritelist)
781	778	{
782	779	sprite_ptr--;
783	780
784	781	if (!uses_tc360_mixer)
785		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[0],
	782	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[0],
786	783	sprite_ptr->code,
787	784	sprite_ptr->color,
788	785	sprite_ptr->flipx,sprite_ptr->flipy,
789	786	sprite_ptr->x,sprite_ptr->y,
790	787	sprite_ptr->zoomx,sprite_ptr->zoomy,
791		machine.priority_bitmap,sprite_ptr->primask,0);
	788	machine().priority_bitmap,sprite_ptr->primask,0);
792	789	else
793		taito_f2_tc360_spritemixdraw(machine, bitmap,cliprect,machine.gfx[0],
	790	taito_f2_tc360_spritemixdraw(bitmap,cliprect,machine().gfx[0],
794	791	sprite_ptr->code,
795	792	sprite_ptr->color,
796	793	sprite_ptr->flipx,sprite_ptr->flipy,
r21022	r21023
800	797	}
801	798
802	799
803		static void update_spritebanks( running_machine &machine )
	800	void taitof2_state::update_spritebanks(  )
804	801	{
805		taitof2_state *state = machine.driver_data<taitof2_state>();
806	802	int i;
807	803	#if 1
808	804	for (i = 0; i < 8; i ++)
809	805	{
810		state->m_spritebank[i] = state->m_spritebank_buffered[i];
	806	m_spritebank[i] = m_spritebank_buffered[i];
811	807	}
812	808	#else
813	809	/* this makes footchmp blobbing worse! */
814	810	for (i = 0; i < 8; i ++)
815	811	{
816		state->m_spritebank[i] = state->m_spritebank_eof[i];
817		state->m_spritebank_eof[i] = state->m_spritebank_buffered[i];
	812	m_spritebank[i] = m_spritebank_eof[i];
	813	m_spritebank_eof[i] = m_spritebank_buffered[i];
818	814	}
819	815	#endif
820	816	}
821	817
822		static void taitof2_handle_sprite_buffering( running_machine &machine )
	818	void taitof2_state::taitof2_handle_sprite_buffering(  )
823	819	{
824		taitof2_state *state = machine.driver_data<taitof2_state>();
825	820
826		if (state->m_prepare_sprites)   /* no buffering */
	821	if (m_prepare_sprites)   /* no buffering */
827	822	{
828		memcpy(state->m_spriteram_buffered, state->m_spriteram, state->m_spriteram.bytes());
829		state->m_prepare_sprites = 0;
	823	memcpy(m_spriteram_buffered, m_spriteram, m_spriteram.bytes());
	824	m_prepare_sprites = 0;
830	825	}
831	826	}
832	827
833		static void taitof2_update_sprites_active_area( running_machine &machine )
	828	void taitof2_state::taitof2_update_sprites_active_area(  )
834	829	{
835		taitof2_state *state = machine.driver_data<taitof2_state>();
836	830	int off;
837	831
838		update_spritebanks(machine);
	832	update_spritebanks();
839	833
840	834	/* if the frame was skipped, we'll have to do the buffering now */
841		taitof2_handle_sprite_buffering(machine);
	835	taitof2_handle_sprite_buffering();
842	836
843	837	/* safety check to avoid getting stuck in bank 2 for games using only one bank */
844		if (state->m_sprites_active_area == 0x8000 &&
845		state->m_spriteram_buffered[(0x8000 + 6) / 2] == 0 &&
846		state->m_spriteram_buffered[(0x8000 + 10) / 2] == 0)
847		state->m_sprites_active_area = 0;
	838	if (m_sprites_active_area == 0x8000 &&
	839	m_spriteram_buffered[(0x8000 + 6) / 2] == 0 &&
	840	m_spriteram_buffered[(0x8000 + 10) / 2] == 0)
	841	m_sprites_active_area = 0;
848	842
849	843	for (off = 0; off < 0x4000; off += 16)
850	844	{
851	845	/* sprites_active_area may change during processing */
852		int offs = off + state->m_sprites_active_area;
	846	int offs = off + m_sprites_active_area;
853	847
854		if (state->m_spriteram_buffered[(offs + 6) / 2] & 0x8000)
	848	if (m_spriteram_buffered[(offs + 6) / 2] & 0x8000)
855	849	{
856		state->m_sprites_disabled = state->m_spriteram_buffered[(offs + 10) / 2] & 0x1000;
857		if (state->m_game == FOOTCHMP)
858		state->m_sprites_active_area = 0x8000 * (state->m_spriteram_buffered[(offs + 6) / 2] & 0x0001);
	850	m_sprites_disabled = m_spriteram_buffered[(offs + 10) / 2] & 0x1000;
	851	if (m_game == FOOTCHMP)
	852	m_sprites_active_area = 0x8000 * (m_spriteram_buffered[(offs + 6) / 2] & 0x0001);
859	853	else
860		state->m_sprites_active_area = 0x8000 * (state->m_spriteram_buffered[(offs + 10) / 2] & 0x0001);
	854	m_sprites_active_area = 0x8000 * (m_spriteram_buffered[(offs + 10) / 2] & 0x0001);
861	855	continue;
862	856	}
863	857
864	858	/* check for extra scroll offset */
865		if ((state->m_spriteram_buffered[(offs + 4) / 2] & 0xf000) == 0xa000)
	859	if ((m_spriteram_buffered[(offs + 4) / 2] & 0xf000) == 0xa000)
866	860	{
867		state->m_sprites_master_scrollx = state->m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
868		if (state->m_sprites_master_scrollx >= 0x800)
869		state->m_sprites_master_scrollx -= 0x1000;   /* signed value */
	861	m_sprites_master_scrollx = m_spriteram_buffered[(offs + 4) / 2] & 0xfff;
	862	if (m_sprites_master_scrollx >= 0x800)
	863	m_sprites_master_scrollx -= 0x1000;   /* signed value */
870	864
871		state->m_sprites_master_scrolly = state->m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
872		if (state->m_sprites_master_scrolly >= 0x800)
873		state->m_sprites_master_scrolly -= 0x1000;   /* signed value */
	865	m_sprites_master_scrolly = m_spriteram_buffered[(offs + 6) / 2] & 0xfff;
	866	if (m_sprites_master_scrolly >= 0x800)
	867	m_sprites_master_scrolly -= 0x1000;   /* signed value */
874	868	}
875	869	}
876	870	}
r21022	r21023
881	875	// rising edge
882	876	if (state)
883	877	{
884		taitof2_update_sprites_active_area(machine());
	878	taitof2_update_sprites_active_area();
885	879
886	880	m_prepare_sprites = 1;
887	881	}
r21022	r21023
895	889	UINT16 *spriteram = m_spriteram;
896	890	int i;
897	891
898		taitof2_update_sprites_active_area(machine());
	892	taitof2_update_sprites_active_area();
899	893
900	894	m_prepare_sprites = 0;
901	895	memcpy(m_spriteram_buffered, m_spriteram_delayed, m_spriteram.bytes());
r21022	r21023
913	907	UINT16 *spriteram = m_spriteram;
914	908	int i;
915	909
916		taitof2_update_sprites_active_area(machine());
	910	taitof2_update_sprites_active_area();
917	911
918	912	m_prepare_sprites = 0;
919	913	memcpy(m_spriteram_buffered, m_spriteram_delayed, m_spriteram.bytes());
r21022	r21023
931	925	UINT16 *spriteram = m_spriteram;
932	926	int i;
933	927
934		taitof2_update_sprites_active_area(machine());
	928	taitof2_update_sprites_active_area();
935	929
936	930	m_prepare_sprites = 0;
937	931	memcpy(m_spriteram_buffered, m_spriteram_delayed, m_spriteram.bytes());
r21022	r21023
956	950	UINT16 *spriteram = m_spriteram;
957	951	int i;
958	952
959		taitof2_update_sprites_active_area(machine());
	953	taitof2_update_sprites_active_area();
960	954
961	955	m_prepare_sprites = 0;
962	956	memcpy(m_spriteram_buffered, m_spriteram_delayed, m_spriteram.bytes());
r21022	r21023
977	971	/* SSI */
978	972	UINT32 taitof2_state::screen_update_taitof2_ssi(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
979	973	{
980		taitof2_handle_sprite_buffering(machine());
	974	taitof2_handle_sprite_buffering();
981	975
982	976	/* SSI only uses sprites, the tilemap registers are not even initialized.
983	977	(they are in Majestic 12, but the tilemaps are not used anyway) */
984	978	machine().priority_bitmap.fill(0, cliprect);
985	979	bitmap.fill(0, cliprect);
986		draw_sprites(machine(), bitmap, cliprect, NULL, 0);
	980	draw_sprites(bitmap, cliprect, NULL, 0);
987	981	return 0;
988	982	}
989	983
990	984
991	985	UINT32 taitof2_state::screen_update_taitof2_yesnoj(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
992	986	{
993		taitof2_handle_sprite_buffering(machine());
	987	taitof2_handle_sprite_buffering();
994	988
995	989	tc0100scn_tilemap_update(m_tc0100scn);
996	990
997	991	machine().priority_bitmap.fill(0, cliprect);
998	992	bitmap.fill(0, cliprect);   /* wrong color? */
999		draw_sprites(machine(), bitmap, cliprect, NULL, 0);
	993	draw_sprites(bitmap, cliprect, NULL, 0);
1000	994	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, tc0100scn_bottomlayer(m_tc0100scn), 0, 0);
1001	995	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, tc0100scn_bottomlayer(m_tc0100scn) ^ 1, 0, 0);
1002	996	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, 2, 0, 0);
r21022	r21023
1006	1000
1007	1001	UINT32 taitof2_state::screen_update_taitof2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
1008	1002	{
1009		taitof2_handle_sprite_buffering(machine());
	1003	taitof2_handle_sprite_buffering();
1010	1004
1011	1005	tc0100scn_tilemap_update(m_tc0100scn);
1012	1006
r21022	r21023
1014	1008	bitmap.fill(0, cliprect);   /* wrong color? */
1015	1009	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, tc0100scn_bottomlayer(m_tc0100scn), 0, 0);
1016	1010	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, tc0100scn_bottomlayer(m_tc0100scn) ^ 1, 0, 0);
1017		draw_sprites(machine(), bitmap, cliprect, NULL, 0);
	1011	draw_sprites(bitmap, cliprect, NULL, 0);
1018	1012	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, 2, 0, 0);
1019	1013	return 0;
1020	1014	}
r21022	r21023
1025	1019	address_space &space = machine().driver_data()->generic_space();
1026	1020	int layer[3];
1027	1021
1028		taitof2_handle_sprite_buffering(machine());
	1022	taitof2_handle_sprite_buffering();
1029	1023
1030	1024	tc0100scn_tilemap_update(m_tc0100scn);
1031	1025
r21022	r21023
1050	1044	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[1], 0, 2);
1051	1045	tc0100scn_tilemap_draw(m_tc0100scn, bitmap, cliprect, layer[2], 0, 4);
1052	1046
1053		draw_sprites(machine(), bitmap, cliprect, NULL, 1);
	1047	draw_sprites(bitmap, cliprect, NULL, 1);
1054	1048	return 0;
1055	1049	}
1056	1050
1057	1051
1058	1052
1059		static void draw_roz_layer( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 priority)
	1053	void taitof2_state::draw_roz_layer( bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 priority)
1060	1054	{
1061		taitof2_state *state = machine.driver_data<taitof2_state>();
1062	1055
1063		if (state->m_tc0280grd != NULL)
1064		tc0280grd_zoom_draw(state->m_tc0280grd, bitmap, cliprect, state->m_pivot_xdisp, state->m_pivot_ydisp, priority);
	1056	if (m_tc0280grd != NULL)
	1057	tc0280grd_zoom_draw(m_tc0280grd, bitmap, cliprect, m_pivot_xdisp, m_pivot_ydisp, priority);
1065	1058
1066		if (state->m_tc0430grw != NULL)
1067		tc0430grw_zoom_draw(state->m_tc0430grw, bitmap, cliprect, state->m_pivot_xdisp, state->m_pivot_ydisp, priority);
	1059	if (m_tc0430grw != NULL)
	1060	tc0430grw_zoom_draw(m_tc0430grw, bitmap, cliprect, m_pivot_xdisp, m_pivot_ydisp, priority);
1068	1061	}
1069	1062
1070	1063	UINT32 taitof2_state::screen_update_taitof2_pri_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r21022	r21023
1077	1070	int i,j;
1078	1071	int roz_base_color = (tc0360pri_r(m_tc0360pri, space, 1) & 0x3f) << 2;
1079	1072
1080		taitof2_handle_sprite_buffering(machine());
	1073	taitof2_handle_sprite_buffering();
1081	1074
1082	1075	if (m_tc0280grd != NULL)
1083	1076	tc0280grd_tilemap_update(m_tc0280grd, roz_base_color);
r21022	r21023
1113	1106	{
1114	1107	if (rozpri == i)
1115	1108	{
1116		draw_roz_layer(machine(), bitmap, cliprect, 1 << drawn);
	1109	draw_roz_layer(bitmap, cliprect, 1 << drawn);
1117	1110	m_tilepri[drawn] = i;
1118	1111	drawn++;
1119	1112	}
r21022	r21023
1129	1122	}
1130	1123	}
1131	1124
1132		draw_sprites(machine(), bitmap, cliprect, NULL, 1);
	1125	draw_sprites(bitmap, cliprect, NULL, 1);
1133	1126	return 0;
1134	1127	}
1135	1128
r21022	r21023
1144	1137	int layer[2][3];
1145	1138	int drawn[2];
1146	1139
1147		taitof2_handle_sprite_buffering(machine());
	1140	taitof2_handle_sprite_buffering();
1148	1141
1149	1142	tc0100scn_tilemap_update(m_tc0100scn_1);
1150	1143	tc0100scn_tilemap_update(m_tc0100scn_2);
r21022	r21023
1220	1213	if (spritepri[i] < tilepri[1][1]) primasks[i] |= 0xff00;
1221	1214	}
1222	1215
1223		draw_sprites(machine(), bitmap,cliprect,primasks,0);
	1216	draw_sprites(bitmap,cliprect,primasks,0);
1224	1217	}
1225	1218
1226	1219
r21022	r21023
1279	1272	UINT8 layer[5], invlayer[4];
1280	1273	UINT16 priority;
1281	1274
1282		taitof2_handle_sprite_buffering(machine());
	1275	taitof2_handle_sprite_buffering();
1283	1276
1284	1277	tc0480scp_tilemap_update(m_tc0480scp);
1285	1278
r21022	r21023
1318	1311	tc0480scp_tilemap_draw(m_tc0480scp, bitmap, cliprect, layer[3], 0, 8);
1319	1312	tc0480scp_tilemap_draw(m_tc0480scp, bitmap, cliprect, layer[4], 0, 16);
1320	1313
1321		draw_sprites(machine(), bitmap, cliprect, NULL, 1);
	1314	draw_sprites(bitmap, cliprect, NULL, 1);
1322	1315	return 0;
1323	1316	}
1324	1317
r21022	r21023
1332	1325	UINT8 spritepri[4];
1333	1326	UINT16 priority;
1334	1327
1335		taitof2_handle_sprite_buffering(machine());
	1328	taitof2_handle_sprite_buffering();
1336	1329
1337	1330	tc0480scp_tilemap_update(m_tc0480scp);
1338	1331
r21022	r21023
1377	1370	if (spritepri[i] < tilepri[(layer[3])]) primasks[i] |= 0xff00;
1378	1371	}
1379	1372
1380		draw_sprites(machine(), bitmap, cliprect, primasks, 0);
	1373	draw_sprites(bitmap, cliprect, primasks, 0);
1381	1374	}
1382	1375
1383	1376	/*

trunk/src/mame/video/taito_l.c

r21022	r21023
139	139	return m_cur_ctrl;
140	140	}
141	141
142		void taitol_chardef14_m( running_machine &machine, int offset )
	142	void taitol_state::taitol_chardef14_m( int offset )
143	143	{
144		machine.gfx[2]->mark_dirty(offset / 32 + 0);
	144	machine().gfx[2]->mark_dirty(offset / 32 + 0);
145	145	}
146	146
147		void taitol_chardef15_m( running_machine &machine, int offset )
	147	void taitol_state::taitol_chardef15_m( int offset )
148	148	{
149		machine.gfx[2]->mark_dirty(offset / 32 + 128);
	149	machine().gfx[2]->mark_dirty(offset / 32 + 128);
150	150	}
151	151
152		void taitol_chardef16_m( running_machine &machine, int offset )
	152	void taitol_state::taitol_chardef16_m( int offset )
153	153	{
154		machine.gfx[2]->mark_dirty(offset / 32 + 256);
	154	machine().gfx[2]->mark_dirty(offset / 32 + 256);
155	155	}
156	156
157		void taitol_chardef17_m( running_machine &machine, int offset )
	157	void taitol_state::taitol_chardef17_m( int offset )
158	158	{
159		machine.gfx[2]->mark_dirty(offset / 32 + 384);
	159	machine().gfx[2]->mark_dirty(offset / 32 + 384);
160	160	}
161	161
162		void taitol_chardef1c_m( running_machine &machine, int offset )
	162	void taitol_state::taitol_chardef1c_m( int offset )
163	163	{
164		machine.gfx[2]->mark_dirty(offset / 32 + 512);
	164	machine().gfx[2]->mark_dirty(offset / 32 + 512);
165	165	}
166	166
167		void taitol_chardef1d_m( running_machine &machine, int offset )
	167	void taitol_state::taitol_chardef1d_m( int offset )
168	168	{
169		machine.gfx[2]->mark_dirty(offset / 32 + 640);
	169	machine().gfx[2]->mark_dirty(offset / 32 + 640);
170	170	}
171	171
172		void taitol_chardef1e_m( running_machine &machine, int offset )
	172	void taitol_state::taitol_chardef1e_m( int offset )
173	173	{
174		machine.gfx[2]->mark_dirty(offset / 32 + 768);
	174	machine().gfx[2]->mark_dirty(offset / 32 + 768);
175	175	}
176	176
177		void taitol_chardef1f_m( running_machine &machine, int offset )
	177	void taitol_state::taitol_chardef1f_m( int offset )
178	178	{
179		machine.gfx[2]->mark_dirty(offset / 32 + 896);
	179	machine().gfx[2]->mark_dirty(offset / 32 + 896);
180	180	}
181	181
182		void taitol_bg18_m( running_machine &machine, int offset )
	182	void taitol_state::taitol_bg18_m( int offset )
183	183	{
184		taitol_state *state = machine.driver_data<taitol_state>();
185		state->m_bg18_tilemap->mark_tile_dirty(offset / 2);
	184	m_bg18_tilemap->mark_tile_dirty(offset / 2);
186	185	}
187	186
188		void taitol_bg19_m( running_machine &machine, int offset )
	187	void taitol_state::taitol_bg19_m( int offset )
189	188	{
190		taitol_state *state = machine.driver_data<taitol_state>();
191		state->m_bg19_tilemap->mark_tile_dirty(offset / 2);
	189	m_bg19_tilemap->mark_tile_dirty(offset / 2);
192	190	}
193	191
194		void taitol_char1a_m( running_machine &machine, int offset )
	192	void taitol_state::taitol_char1a_m( int offset )
195	193	{
196		taitol_state *state = machine.driver_data<taitol_state>();
197		state->m_ch1a_tilemap->mark_tile_dirty(offset / 2);
	194	m_ch1a_tilemap->mark_tile_dirty(offset / 2);
198	195	}
199	196
200		void taitol_obj1b_m( running_machine &machine, int offset )
	197	void taitol_state::taitol_obj1b_m( int offset )
201	198	{
202	199	#if 0
203	200	if (offset >= 0x3f0 && offset <= 0x3ff)
r21022	r21023
230	227	plgirs2 bullets and raimais big bosses.
231	228	*/
232	229
233		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	230	void taitol_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
234	231	{
235		taitol_state *state = machine.driver_data<taitol_state>();
236	232	int offs;
237	233
238	234	/* at spriteram + 0x3f0 and 03f8 are the tilemap control registers; spriteram + 0x3e8 seems to be unused */
r21022	r21023
240	236	{
241	237	int code, color, sx, sy, flipx, flipy;
242	238
243		color = state->m_buff_spriteram[offs + 2] & 0x0f;
244		code = state->m_buff_spriteram[offs] | (state->m_buff_spriteram[offs + 1] << 8);
	239	color = m_buff_spriteram[offs + 2] & 0x0f;
	240	code = m_buff_spriteram[offs] | (m_buff_spriteram[offs + 1] << 8);
245	241
246		code |= (state->m_horshoes_gfxbank & 0x03) << 10;
	242	code |= (m_horshoes_gfxbank & 0x03) << 10;
247	243
248		sx = state->m_buff_spriteram[offs + 4] | ((state->m_buff_spriteram[offs + 5] & 1) << 8);
249		sy = state->m_buff_spriteram[offs + 6];
	244	sx = m_buff_spriteram[offs + 4] | ((m_buff_spriteram[offs + 5] & 1) << 8);
	245	sy = m_buff_spriteram[offs + 6];
250	246	if (sx >= 320)
251	247	sx -= 512;
252		flipx = state->m_buff_spriteram[offs + 3] & 0x01;
253		flipy = state->m_buff_spriteram[offs + 3] & 0x02;
	248	flipx = m_buff_spriteram[offs + 3] & 0x01;
	249	flipy = m_buff_spriteram[offs + 3] & 0x02;
254	250
255		if (state->m_flipscreen)
	251	if (m_flipscreen)
256	252	{
257	253	sx = 304 - sx;
258	254	sy = 240 - sy;
r21022	r21023
260	256	flipy = !flipy;
261	257	}
262	258
263		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	259	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
264	260	code,
265	261	color,
266	262	flipx,flipy,
267	263	sx,sy,
268		machine.priority_bitmap,
	264	machine().priority_bitmap,
269	265	(color & 0x08) ? 0xaa : 0x00,0);
270	266	}
271	267	}
r21022	r21023
302	298	else                    /* split priority */
303	299	m_bg18_tilemap->draw(bitmap, cliprect, 0,1);
304	300
305		draw_sprites(machine(), bitmap, cliprect);
	301	draw_sprites(bitmap, cliprect);
306	302
307	303	m_ch1a_tilemap->draw(bitmap, cliprect, 0, 0);
308	304	}

trunk/src/mame/video/timeplt.c

r21022	r21023
171	171	*
172	172	*************************************/
173	173
174		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	174	void timeplt_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
175	175	{
176		timeplt_state *state = machine.driver_data<timeplt_state>();
177		UINT8 *spriteram = state->m_spriteram;
178		UINT8 *spriteram_2 = state->m_spriteram2;
	176	UINT8 *spriteram = m_spriteram;
	177	UINT8 *spriteram_2 = m_spriteram2;
179	178	int offs;
180	179
181	180	for (offs = 0x3e;offs >= 0x10;offs -= 2)
r21022	r21023
188	187	int flipx = ~spriteram_2[offs] & 0x40;
189	188	int flipy = spriteram_2[offs] & 0x80;
190	189
191		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	190	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
192	191	code,
193	192	color,
194	193	flipx,flipy,
r21022	r21023
207	206	UINT32 timeplt_state::screen_update_timeplt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
208	207	{
209	208	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
210		draw_sprites(machine(), bitmap, cliprect);
	209	draw_sprites(bitmap, cliprect);
211	210	m_bg_tilemap->draw(bitmap, cliprect, 1, 0);
212	211	return 0;
213	212	}

trunk/src/mame/video/thoop2.c

r21022	r21023
98	98
99	99	***************************************************************************/
100	100
101		static void thoop2_sort_sprites(running_machine &machine)
	101	void thoop2_state::thoop2_sort_sprites()
102	102	{
103		thoop2_state *state = machine.driver_data<thoop2_state>();
104	103	int i;
105	104
106		state->m_sprite_count[0] = 0;
107		state->m_sprite_count[1] = 0;
108		state->m_sprite_count[2] = 0;
109		state->m_sprite_count[3] = 0;
110		state->m_sprite_count[4] = 0;
	105	m_sprite_count[0] = 0;
	106	m_sprite_count[1] = 0;
	107	m_sprite_count[2] = 0;
	108	m_sprite_count[3] = 0;
	109	m_sprite_count[4] = 0;
111	110
112	111	for (i = 3; i < (0x1000 - 6)/2; i += 4){
113		int color = (state->m_spriteram[i+2] & 0x7e00) >> 9;
114		int priority = (state->m_spriteram[i] & 0x3000) >> 12;
	112	int color = (m_spriteram[i+2] & 0x7e00) >> 9;
	113	int priority = (m_spriteram[i] & 0x3000) >> 12;
115	114
116	115	/* palettes 0x38-0x3f are used for high priority sprites in Big Karnak */
117	116	if (color >= 0x38){
118		state->m_sprite_table[4][state->m_sprite_count[4]] = i;
119		state->m_sprite_count[4]++;
	117	m_sprite_table[4][m_sprite_count[4]] = i;
	118	m_sprite_count[4]++;
120	119	}
121	120
122	121	/* save sprite number in the proper array for later */
123		state->m_sprite_table[priority][state->m_sprite_count[priority]] = i;
124		state->m_sprite_count[priority]++;
	122	m_sprite_table[priority][m_sprite_count[priority]] = i;
	123	m_sprite_count[priority]++;
125	124	}
126	125	}
127	126
r21022	r21023
144	143	3  | xxxxxxxx xxxxxx-- | sprite code (low bits)
145	144	*/
146	145
147		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri)
	146	void thoop2_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri)
148	147	{
149		thoop2_state *state = machine.driver_data<thoop2_state>();
150	148	int j, x, y, ex, ey;
151		gfx_element *gfx = machine.gfx[0];
	149	gfx_element *gfx = machine().gfx[0];
152	150
153	151	static const int x_offset[2] = {0x0,0x2};
154	152	static const int y_offset[2] = {0x0,0x1};
155	153
156		for (j = 0; j < state->m_sprite_count[pri]; j++){
157		int i = state->m_sprite_table[pri][j];
158		int sx = state->m_spriteram[i+2] & 0x01ff;
159		int sy = (240 - (state->m_spriteram[i] & 0x00ff)) & 0x00ff;
160		int number = state->m_spriteram[i+3];
161		int color = (state->m_spriteram[i+2] & 0x7e00) >> 9;
162		int attr = (state->m_spriteram[i] & 0xfe00) >> 9;
	154	for (j = 0; j < m_sprite_count[pri]; j++){
	155	int i = m_sprite_table[pri][j];
	156	int sx = m_spriteram[i+2] & 0x01ff;
	157	int sy = (240 - (m_spriteram[i] & 0x00ff)) & 0x00ff;
	158	int number = m_spriteram[i+3];
	159	int color = (m_spriteram[i+2] & 0x7e00) >> 9;
	160	int attr = (m_spriteram[i] & 0xfe00) >> 9;
163	161
164	162	int xflip = attr & 0x20;
165	163	int yflip = attr & 0x40;
r21022	r21023
202	200	m_pant[1]->set_scrolly(0, m_vregs[2]);
203	201	m_pant[1]->set_scrollx(0, m_vregs[3]);
204	202
205		thoop2_sort_sprites(machine());
	203	thoop2_sort_sprites();
206	204
207	205	bitmap.fill(0, cliprect );
208	206
209	207	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 3,0);
210	208	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 3,0);
211		draw_sprites(machine(), bitmap,cliprect,3);
	209	draw_sprites(bitmap,cliprect,3);
212	210	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 3,0);
213	211	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 3,0);
214	212
215	213	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 2,0);
216	214	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 2,0);
217		draw_sprites(machine(), bitmap,cliprect,2);
	215	draw_sprites(bitmap,cliprect,2);
218	216	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 2,0);
219	217	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 2,0);
220	218
221	219	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 1,0);
222	220	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 1,0);
223		draw_sprites(machine(), bitmap,cliprect,1);
	221	draw_sprites(bitmap,cliprect,1);
224	222	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 1,0);
225	223	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 1,0);
226	224
227	225	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 0,0);
228	226	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 0,0);
229		draw_sprites(machine(), bitmap,cliprect,0);
	227	draw_sprites(bitmap,cliprect,0);
230	228	m_pant[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0,0);
231	229	m_pant[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0,0);
232	230
233		draw_sprites(machine(), bitmap,cliprect,4);
	231	draw_sprites(bitmap,cliprect,4);
234	232	return 0;
235	233	}

trunk/src/mame/video/tubep.c

r21022	r21023
429	429	}
430	430
431	431
432		static void draw_sprite(running_machine &machine)
	432	void tubep_state::draw_sprite()
433	433	{
434		tubep_state *state = machine.driver_data<tubep_state>();
435	434	UINT32  XDOT;
436	435	UINT32  YDOT;
437		UINT8 * romCxx  = state->memregion("user2")->base()+0x00000;
	436	UINT8 * romCxx  = memregion("user2")->base()+0x00000;
438	437	UINT8 * romD10  = romCxx+0x10000;
439	438	UINT8 * romEF13 = romCxx+0x12000;
440	439	UINT8 * romHI2  = romCxx+0x14000;
441	440
442	441
443		for (YDOT=0; (YDOT^state->m_YSize) != 0x00; YDOT++)
	442	for (YDOT=0; (YDOT^m_YSize) != 0x00; YDOT++)
444	443	{
445	444	/* upper part of the schematic */
446		UINT32 ls273_e12 = romD10[ state->m_romD_addr | YDOT ] & 0x7f;
447		UINT32 romEF_addr_now = state->m_romEF_addr | ls273_e12;
	445	UINT32 ls273_e12 = romD10[ m_romD_addr | YDOT ] & 0x7f;
	446	UINT32 romEF_addr_now = m_romEF_addr | ls273_e12;
448	447	UINT32 E16_add_a = romEF13[ romEF_addr_now ] |
449	448	((romEF13[0x1000 + romEF_addr_now ]&0x0f)<<8);
450		UINT32 F16_add_b = E16_add_a + state->m_E16_add_b;
	449	UINT32 F16_add_b = E16_add_a + m_E16_add_b;
451	450
452	451	/* lower part of the schematic */
453		UINT32 romHI_addr = (YDOT) | (state->m_romHI_addr_mid) | (((state->m_romHI_addr_msb + 0x800) )&0x1800);
	452	UINT32 romHI_addr = (YDOT) | (m_romHI_addr_mid) | (((m_romHI_addr_msb + 0x800) )&0x1800);
454	453	UINT32 ls273_g4 = romHI2[ romHI_addr ];
455	454	UINT32 ls273_j4 = romHI2[0x2000+ romHI_addr ];
456		UINT32 ls86_gh5 = ls273_g4 ^ state->m_VINV;
457		UINT32 ls86_ij5 = ls273_j4 ^ state->m_VINV;
	455	UINT32 ls86_gh5 = ls273_g4 ^ m_VINV;
	456	UINT32 ls86_ij5 = ls273_j4 ^ m_VINV;
458	457
459		UINT32 ls157_gh7= state->m_ls273_g6 | (state->m_mark_2);
460		UINT32 ls157_ij7= state->m_ls273_j6 | (state->m_mark_1);
461		UINT32 ls283_gh8= (state->m_VINV & 1) + ls86_gh5 + ((ls86_gh5 & 0x80)<<1) + ls157_gh7;
462		UINT32 ls283_ij8= (state->m_VINV & 1) + ls86_ij5 + ((ls86_ij5 & 0x80)<<1) + ls157_ij7;
	458	UINT32 ls157_gh7= m_ls273_g6 | (m_mark_2);
	459	UINT32 ls157_ij7= m_ls273_j6 | (m_mark_1);
	460	UINT32 ls283_gh8= (m_VINV & 1) + ls86_gh5 + ((ls86_gh5 & 0x80)<<1) + ls157_gh7;
	461	UINT32 ls283_ij8= (m_VINV & 1) + ls86_ij5 + ((ls86_ij5 & 0x80)<<1) + ls157_ij7;
463	462
464	463	UINT32 ls273_g9 = ls283_gh8;
465	464	UINT32 ls273_j9 = ls283_ij8;
466	465
467		for (XDOT=0; (XDOT^state->m_XSize) != 0x00; XDOT++)
	466	for (XDOT=0; (XDOT^m_XSize) != 0x00; XDOT++)
468	467	{
469	468	/* upper part of the schematic */
470		UINT32 romD10_out = romD10[ state->m_romD_addr | XDOT ];
	469	UINT32 romD10_out = romD10[ m_romD_addr | XDOT ];
471	470	UINT32 F16_add_a = (romD10_out & 0x7e) >>1;
472	471	UINT32 romCxx_addr = (F16_add_a + F16_add_b ) & 0xffff;
473	472	UINT32 romCxx_out = romCxx[ romCxx_addr ];
474	473
475	474	UINT32 colorram_addr_lo = (romD10_out&1) ? (romCxx_out>>4)&0x0f: (romCxx_out>>0)&0x0f;
476	475
477		UINT8 sp_data = state->m_sprite_colorsharedram[ state->m_colorram_addr_hi | colorram_addr_lo ] & 0x0f; /* 2114 4-bit RAM */
	476	UINT8 sp_data = m_sprite_colorsharedram[ m_colorram_addr_hi | colorram_addr_lo ] & 0x0f; /* 2114 4-bit RAM */
478	477
479	478	/* lower part of the schematic */
480		romHI_addr = (XDOT) | (state->m_romHI_addr_mid) | (state->m_romHI_addr_msb);
	479	romHI_addr = (XDOT) | (m_romHI_addr_mid) | (m_romHI_addr_msb);
481	480	ls273_g4 = romHI2[ romHI_addr ];
482	481	ls273_j4 = romHI2[0x2000+ romHI_addr ];
483		ls86_gh5 = ls273_g4 ^ state->m_HINV;
484		ls86_ij5 = ls273_j4 ^ state->m_HINV;
	482	ls86_gh5 = ls273_g4 ^ m_HINV;
	483	ls86_ij5 = ls273_j4 ^ m_HINV;
485	484
486	485	ls157_gh7= ls273_g9;
487	486	ls157_ij7= ls273_j9;
488		ls283_gh8= (state->m_HINV & 1) + ls86_gh5 + ((ls86_gh5 & 0x80)<<1) + ls157_gh7;
489		ls283_ij8= (state->m_HINV & 1) + ls86_ij5 + ((ls86_ij5 & 0x80)<<1) + ls157_ij7;
	487	ls283_gh8= (m_HINV & 1) + ls86_gh5 + ((ls86_gh5 & 0x80)<<1) + ls157_gh7;
	488	ls283_ij8= (m_HINV & 1) + ls86_ij5 + ((ls86_ij5 & 0x80)<<1) + ls157_ij7;
490	489
491	490
492	491	if ( !((ls283_gh8&256) | (ls283_ij8&256)) ) /* skip wrapped sprite area - PAL12L6 (PLA019 in Roller Jammer schematics)*/
493	492	{
494		if ( state->m_spritemap[ (ls283_gh8&255) + (ls283_ij8&255)*256 + state->m_DISP*256*256 ] == 0x0f )
495		state->m_spritemap[ (ls283_gh8&255) + (ls283_ij8&255)*256 + state->m_DISP*256*256 ] = sp_data;
	493	if ( m_spritemap[ (ls283_gh8&255) + (ls283_ij8&255)*256 + m_DISP*256*256 ] == 0x0f )
	494	m_spritemap[ (ls283_gh8&255) + (ls283_ij8&255)*256 + m_DISP*256*256 ] = sp_data;
496	495	}
497	496	}
498	497	}
r21022	r21023
561	560	machine().scheduler().timer_set( attotime::from_hz(19968000/8) * ((m_XSize+1)*(m_YSize+1)), timer_expired_delegate(FUNC(tubep_state::sprite_timer_callback),this));
562	561
563	562	/* 3.clear of /SINT starts sprite drawing circuit */
564		draw_sprite(machine());
	563	draw_sprite();
565	564	break;
566	565	}
567	566	}
568	567	}
569	568
570		void tubep_vblank_end(running_machine &machine)
	569	void tubep_state::tubep_vblank_end()
571	570	{
572		tubep_state *state = machine.driver_data<tubep_state>();
573		state->m_DISP = state->m_DISP ^ 1;
574		/* logerror("EOF: DISP after this is=%i, and clearing it now.\n", state->m_DISP); */
	571	m_DISP = m_DISP ^ 1;
	572	/* logerror("EOF: DISP after this is=%i, and clearing it now.\n", m_DISP); */
575	573	/* clear the new frame (the one that was (just) displayed)*/
576		memset(state->m_spritemap+state->m_DISP*256*256, 0x0f, 256*256);
	574	memset(m_spritemap+m_DISP*256*256, 0x0f, 256*256);
577	575	}
578	576
579	577

trunk/src/mame/video/triplhnt.c

r21022	r21023
26	26
27	27	TIMER_CALLBACK_MEMBER(triplhnt_state::triplhnt_hit_callback)
28	28	{
29		triplhnt_set_collision(machine(), param);
	29	triplhnt_set_collision(param);
30	30	}
31	31
32	32
33		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	33	void triplhnt_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
34	34	{
35		triplhnt_state *state = machine.driver_data<triplhnt_state>();
36	35	int i;
37	36
38	37	int hit_line = 999;
r21022	r21023
42	41	{
43	42	rectangle rect;
44	43
45		int j = (state->m_orga_ram[i] & 15) ^ 15;
	44	int j = (m_orga_ram[i] & 15) ^ 15;
46	45
47	46	/* software sorts sprites by x and stores order in orga RAM */
48	47
49		int hpos = state->m_hpos_ram[j] ^ 255;
50		int vpos = state->m_vpos_ram[j] ^ 255;
51		int code = state->m_code_ram[j] ^ 255;
	48	int hpos = m_hpos_ram[j] ^ 255;
	49	int vpos = m_vpos_ram[j] ^ 255;
	50	int code = m_code_ram[j] ^ 255;
52	51
53	52	if (hpos == 255)
54	53	continue;
55	54
56	55	/* sprite placement might be wrong */
57	56
58		if (state->m_sprite_zoom)
	57	if (m_sprite_zoom)
59	58	{
60	59	rect.set(hpos - 16, hpos - 16 + 63, 196 - vpos, 196 - vpos + 63);
61	60	}
r21022	r21023
66	65
67	66	/* render sprite to auxiliary bitmap */
68	67
69		drawgfx_opaque(state->m_helper, cliprect, machine.gfx[state->m_sprite_zoom],
70		2 * code + state->m_sprite_bank, 0, code & 8, 0,
	68	drawgfx_opaque(m_helper, cliprect, machine().gfx[m_sprite_zoom],
	69	2 * code + m_sprite_bank, 0, code & 8, 0,
71	70	rect.min_x, rect.min_y);
72	71
73	72	rect &= cliprect;
r21022	r21023
82	81	{
83	82	for (y = rect.min_y; y <= rect.max_y; y++)
84	83	{
85		pen_t a = state->m_helper.pix16(y, x);
	84	pen_t a = m_helper.pix16(y, x);
86	85	pen_t b = bitmap.pix16(y, x);
87	86
88	87	if (a == 2 && b == 7)
r21022	r21023
99	98	}
100	99
101	100	if (hit_line != 999 && hit_code != 999)
102		machine.scheduler().timer_set(machine.primary_screen->time_until_pos(hit_line), timer_expired_delegate(FUNC(triplhnt_state::triplhnt_hit_callback),state), hit_code);
	101	machine().scheduler().timer_set(machine().primary_screen->time_until_pos(hit_line), timer_expired_delegate(FUNC(triplhnt_state::triplhnt_hit_callback),this), hit_code);
103	102	}
104	103
105	104
r21022	r21023
111	110
112	111	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
113	112
114		draw_sprites(machine(), bitmap, cliprect);
	113	draw_sprites(bitmap, cliprect);
115	114
116	115	address_space &space = machine().driver_data()->generic_space();
117	116	discrete_sound_w(discrete, space, TRIPLHNT_BEAR_ROAR_DATA, m_playfield_ram[0xfa] & 15);

trunk/src/mame/video/tankbatt.c

r21022	r21023
80	80	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(tankbatt_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
81	81	}
82	82
83		static void draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	83	void tankbatt_state::draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect)
84	84	{
85		tankbatt_state *state = machine.driver_data<tankbatt_state>();
86	85	int offs;
87	86
88		for (offs = 0;offs < state->m_bulletsram.bytes();offs += 2)
	87	for (offs = 0;offs < m_bulletsram.bytes();offs += 2)
89	88	{
90	89	int color = 0xff;   /* cyan, same color as the tanks */
91		int x = state->m_bulletsram[offs + 1];
92		int y = 255 - state->m_bulletsram[offs] - 2;
	90	int x = m_bulletsram[offs + 1];
	91	int y = 255 - m_bulletsram[offs] - 2;
93	92
94		drawgfx_opaque(bitmap,cliprect,machine.gfx[1],
	93	drawgfx_opaque(bitmap,cliprect,machine().gfx[1],
95	94	0,  /* this is just a square, generated by the hardware */
96	95	color,
97	96	0,0,
r21022	r21023
102	101	UINT32 tankbatt_state::screen_update_tankbatt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
103	102	{
104	103	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
105		draw_bullets(machine(), bitmap, cliprect);
	104	draw_bullets(bitmap, cliprect);
106	105	return 0;
107	106	}

trunk/src/mame/video/twin16.c

r21022	r21023
142	142	m_sprite_busy = 0;
143	143	}
144	144
145		static int twin16_set_sprite_timer( running_machine &machine )
	145	int twin16_state::twin16_set_sprite_timer(  )
146	146	{
147		twin16_state *state = machine.driver_data<twin16_state>();
148		if (state->m_sprite_busy) return 1;
	147	if (m_sprite_busy) return 1;
149	148
150	149	// sprite system busy, maybe a dma? time is guessed, assume 4 scanlines
151		state->m_sprite_busy = 1;
152		state->m_sprite_timer->adjust(machine.primary_screen->frame_period() / machine.primary_screen->height() * 4);
	150	m_sprite_busy = 1;
	151	m_sprite_timer->adjust(machine().primary_screen->frame_period() / machine().primary_screen->height() * 4);
153	152
154	153	return 0;
155	154	}
156	155
157		void twin16_spriteram_process( running_machine &machine )
	156	void twin16_state::twin16_spriteram_process(  )
158	157	{
159		twin16_state *state = machine.driver_data<twin16_state>();
160		UINT16 *spriteram16 = state->m_spriteram->live();
161		UINT16 dx = state->m_scrollx[0];
162		UINT16 dy = state->m_scrolly[0];
	158	UINT16 *spriteram16 = m_spriteram->live();
	159	UINT16 dx = m_scrollx[0];
	160	UINT16 dy = m_scrolly[0];
163	161
164	162	const UINT16 *source = &spriteram16[0x0000];
165	163	const UINT16 *finish = &spriteram16[0x1800];
166	164
167		twin16_set_sprite_timer(machine);
	165	twin16_set_sprite_timer();
168	166	memset(&spriteram16[0x1800],0xff,0x800*sizeof(UINT16));
169	167
170	168	while( source<finish )
r21022	r21023
213	211	}
214	212	source += 0x50/2;
215	213	}
216		state->m_need_process_spriteram = 0;
	214	m_need_process_spriteram = 0;
217	215	}
218	216
219		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap )
	217	void twin16_state::draw_sprites( bitmap_ind16 &bitmap )
220	218	{
221		twin16_state *state = machine.driver_data<twin16_state>();
222		const UINT16 *source = 0x1800+state->m_spriteram->buffer() + 0x800 - 4;
223		const UINT16 *finish = 0x1800+state->m_spriteram->buffer();
	219	const UINT16 *source = 0x1800+m_spriteram->buffer() + 0x800 - 4;
	220	const UINT16 *finish = 0x1800+m_spriteram->buffer();
224	221
225	222	for (; source >= finish; source -= 4)
226	223	{
r21022	r21023
241	238	int flipx = attributes&0x0100;
242	239	int priority = (attributes&0x4000)?TWIN16_SPRITE_PRI_L1:TWIN16_SPRITE_PRI_L2;
243	240
244		if( state->m_custom_video ) {
	241	if( m_custom_video ) {
245	242	/* fround board */
246		pen_data = state->m_gfx_rom + 0x80000;
	243	pen_data = m_gfx_rom + 0x80000;
247	244	}
248	245	else
249	246	{
r21022	r21023
251	248	{
252	249	/* bank select */
253	250	case 0:
254		pen_data = state->m_gfx_rom;
	251	pen_data = m_gfx_rom;
255	252	break;
256	253
257	254	case 1:
258		pen_data = state->m_gfx_rom + 0x40000;
	255	pen_data = m_gfx_rom + 0x40000;
259	256	break;
260	257
261	258	case 2:
262		pen_data = state->m_gfx_rom + 0x80000;
	259	pen_data = m_gfx_rom + 0x80000;
263	260	if( code&0x4000 ) pen_data += 0x40000;
264	261	break;
265	262
266	263	case 3:
267		pen_data = state->m_sprite_gfx_ram;
	264	pen_data = m_sprite_gfx_ram;
268	265	break;
269	266	}
270	267	code &= 0xfff;
r21022	r21023
277	274
278	275	pen_data += code*0x40;
279	276
280		if( state->m_video_register&TWIN16_SCREEN_FLIPY )
	277	if( m_video_register&TWIN16_SCREEN_FLIPY )
281	278	{
282	279	if (ypos>65000) ypos=ypos-65536; /* Bit hacky */
283	280	ypos = 256-ypos-height;
284	281	flipy = !flipy;
285	282	}
286		if( state->m_video_register&TWIN16_SCREEN_FLIPX )
	283	if( m_video_register&TWIN16_SCREEN_FLIPX )
287	284	{
288	285	if (xpos>65000) xpos=xpos-65536; /* Bit hacky */
289	286	xpos = 320-xpos-width;
r21022	r21023
299	296	if( sy>=16 && sy<256-16 )
300	297	{
301	298	UINT16 *dest = &bitmap.pix16(sy);
302		UINT8 *pdest = &machine.priority_bitmap.pix8(sy);
	299	UINT8 *pdest = &machine().priority_bitmap.pix8(sy);
303	300
304	301	for( x=0; x<width; x++ )
305	302	{
r21022	r21023
314	311
315	312	if (pdest[sx]<priority) {
316	313	if (shadow) {
317		dest[sx] = machine.shadow_table[dest[sx]];
	314	dest[sx] = machine().shadow_table[dest[sx]];
318	315	pdest[sx]|=TWIN16_SPRITE_CAST_SHADOW;
319	316	}
320	317	else {
r21022	r21023
323	320	}
324	321	else if (!shadow && pdest[sx]&TWIN16_SPRITE_CAST_SHADOW && (pdest[sx]&0xf)<priority) {
325	322	// shadow cast onto sprite below, evident in devilw lava level
326		dest[sx] = machine.shadow_table[pal_base + pen];
	323	dest[sx] = machine().shadow_table[pal_base + pen];
327	324	pdest[sx]^=TWIN16_SPRITE_CAST_SHADOW;
328	325	}
329	326
r21022	r21023
339	336
340	337
341	338
342		static void draw_layer( running_machine &machine, bitmap_ind16 &bitmap, int opaque )
	339	void twin16_state::draw_layer( bitmap_ind16 &bitmap, int opaque )
343	340	{
344		twin16_state *state = machine.driver_data<twin16_state>();
345		UINT16 *videoram = state->m_videoram;
	341	UINT16 *videoram = m_videoram;
346	342	const UINT16 *gfx_base;
347	343	const UINT16 *source = videoram;
348	344	int i, xxor, yxor;
349	345	int bank_table[4];
350	346	int dx, dy, palette;
351		int tile_flipx = state->m_video_register&TWIN16_TILE_FLIPX;
352		int tile_flipy = state->m_video_register&TWIN16_TILE_FLIPY;
	347	int tile_flipx = m_video_register&TWIN16_TILE_FLIPX;
	348	int tile_flipy = m_video_register&TWIN16_TILE_FLIPY;
353	349
354		if( ((state->m_video_register&TWIN16_PLANE_ORDER)?1:0) != opaque ) {
	350	if( ((m_video_register&TWIN16_PLANE_ORDER)?1:0) != opaque ) {
355	351	source += 0x1000;
356		dx = state->m_scrollx[2];
357		dy = state->m_scrolly[2];
	352	dx = m_scrollx[2];
	353	dy = m_scrolly[2];
358	354	palette = 1;
359	355	}
360	356	else {
361	357	source += 0x0000;
362		dx = state->m_scrollx[1];
363		dy = state->m_scrolly[1];
	358	dx = m_scrollx[1];
	359	dy = m_scrolly[1];
364	360	palette = 0;
365	361	}
366	362
367		if( state->m_custom_video ) {
	363	if( m_custom_video ) {
368	364	/* fround board */
369		gfx_base = state->m_gfx_rom;
370		bank_table[3] = (state->m_gfx_bank>>(4*3))&0xf;
371		bank_table[2] = (state->m_gfx_bank>>(4*2))&0xf;
372		bank_table[1] = (state->m_gfx_bank>>(4*1))&0xf;
373		bank_table[0] = (state->m_gfx_bank>>(4*0))&0xf;
	365	gfx_base = m_gfx_rom;
	366	bank_table[3] = (m_gfx_bank>>(4*3))&0xf;
	367	bank_table[2] = (m_gfx_bank>>(4*2))&0xf;
	368	bank_table[1] = (m_gfx_bank>>(4*1))&0xf;
	369	bank_table[0] = (m_gfx_bank>>(4*0))&0xf;
374	370	}
375	371	else {
376		gfx_base = state->m_tile_gfx_ram;
	372	gfx_base = m_tile_gfx_ram;
377	373	bank_table[0] = 0;
378	374	bank_table[1] = 1;
379	375	bank_table[2] = 2;
380	376	bank_table[3] = 3;
381	377	}
382	378
383		if( state->m_video_register&TWIN16_SCREEN_FLIPX )
	379	if( m_video_register&TWIN16_SCREEN_FLIPX )
384	380	{
385	381	dx = 256-dx-64;
386	382	tile_flipx = !tile_flipx;
387	383	}
388	384
389		if( state->m_video_register&TWIN16_SCREEN_FLIPY )
	385	if( m_video_register&TWIN16_SCREEN_FLIPY )
390	386	{
391	387	dy = 256-dy;
392	388	tile_flipy = !tile_flipy;
r21022	r21023
402	398	int sy = (i/64)*8;
403	399	int xpos,ypos;
404	400
405		if( state->m_video_register&TWIN16_SCREEN_FLIPX ) sx = 63*8 - sx;
406		if( state->m_video_register&TWIN16_SCREEN_FLIPY ) sy = 63*8 - sy;
	401	if( m_video_register&TWIN16_SCREEN_FLIPX ) sx = 63*8 - sx;
	402	if( m_video_register&TWIN16_SCREEN_FLIPY ) sy = 63*8 - sy;
407	403
408	404	xpos = (sx-dx)&0x1ff;
409	405	ypos = (sy-dy)&0x1ff;
r21022	r21023
434	430	{
435	431	const UINT16 *gfxptr = gfx_data + ((y - ypos) ^ yxor) * 2;
436	432	UINT16 *dest = &bitmap.pix16(y);
437		UINT8 *pdest = &machine.priority_bitmap.pix8(y);
	433	UINT8 *pdest = &machine().priority_bitmap.pix8(y);
438	434
439	435	for (x = x1; x <= x2; x++)
440	436	{
r21022	r21023
451	447	{
452	448	const UINT16 *gfxptr = gfx_data + ((y - ypos) ^ yxor) * 2;
453	449	UINT16 *dest = &bitmap.pix16(y);
454		UINT8 *pdest = &machine.priority_bitmap.pix8(y);
	450	UINT8 *pdest = &machine().priority_bitmap.pix8(y);
455	451
456	452	for (x = x1; x <= x2; x++)
457	453	{
r21022	r21023
520	516	if (m_video_register&TWIN16_SCREEN_FLIPY) text_flip|=TILEMAP_FLIPY;
521	517
522	518	machine().priority_bitmap.fill(0, cliprect);
523		draw_layer( machine(), bitmap, 1 );
524		draw_layer( machine(), bitmap, 0 );
525		draw_sprites( machine(), bitmap );
	519	draw_layer( bitmap, 1 );
	520	draw_layer( bitmap, 0 );
	521	draw_sprites( bitmap );
526	522
527	523	if (text_flip) m_text_tilemap->set_flip(text_flip);
528	524	m_text_tilemap->draw(bitmap, cliprect, 0, 0);
r21022	r21023
534	530	// rising edge
535	531	if (state)
536	532	{
537		twin16_set_sprite_timer(machine());
	533	twin16_set_sprite_timer();
538	534
539		if (twin16_spriteram_process_enable(machine())) {
540		if (m_need_process_spriteram) twin16_spriteram_process(machine());
	535	if (twin16_spriteram_process_enable()) {
	536	if (m_need_process_spriteram) twin16_spriteram_process();
541	537	m_need_process_spriteram = 1;
542	538
543	539	/* if the sprite preprocessor is used, sprite ram is copied to an external buffer first,

trunk/src/mame/video/tutankhm.c

r21022	r21023
37	37	*
38	38	*************************************/
39	39
40		static void get_pens( running_machine &machine, pen_t *pens )
	40	void tutankhm_state::get_pens( pen_t *pens )
41	41	{
42		tutankhm_state *state = machine.driver_data<tutankhm_state>();
43	42	offs_t i;
44	43
45	44	for (i = 0; i < NUM_PENS; i++)
46	45	{
47		UINT8 data = state->m_paletteram[i];
	46	UINT8 data = m_paletteram[i];
48	47
49	48	pens[i] = MAKE_RGB(pal3bit(data >> 0), pal3bit(data >> 3), pal2bit(data >> 6));
50	49	}
r21022	r21023
64	63	pen_t pens[NUM_PENS];
65	64	int x, y;
66	65
67		get_pens(machine(), pens);
	66	get_pens( pens);
68	67
69	68	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
70	69	{

trunk/src/mame/video/targeth.c

r21022	r21023
101	101	3  | xx------ -------- | not used?
102	102	*/
103	103
104		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	104	void targeth_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
105	105	{
106		targeth_state *state = machine.driver_data<targeth_state>();
107	106	int i;
108		gfx_element *gfx = machine.gfx[0];
	107	gfx_element *gfx = machine().gfx[0];
109	108
110	109	for (i = 3; i < (0x1000 - 6)/2; i += 4){
111		int sx = state->m_spriteram[i+2] & 0x03ff;
112		int sy = (240 - (state->m_spriteram[i] & 0x00ff)) & 0x00ff;
113		int number = state->m_spriteram[i+3] & 0x3fff;
114		int color = (state->m_spriteram[i+2] & 0x7c00) >> 10;
115		int attr = (state->m_spriteram[i] & 0xfe00) >> 9;
	110	int sx = m_spriteram[i+2] & 0x03ff;
	111	int sy = (240 - (m_spriteram[i] & 0x00ff)) & 0x00ff;
	112	int number = m_spriteram[i+3] & 0x3fff;
	113	int color = (m_spriteram[i+2] & 0x7c00) >> 10;
	114	int attr = (m_spriteram[i] & 0xfe00) >> 9;
116	115
117	116	int xflip = attr & 0x20;
118	117	int yflip = attr & 0x40;
r21022	r21023
139	138
140	139	m_pant[1]->draw(bitmap, cliprect, 0,0);
141	140	m_pant[0]->draw(bitmap, cliprect, 0,0);
142		draw_sprites(machine(), bitmap,cliprect);
	141	draw_sprites(bitmap,cliprect);
143	142
144	143	return 0;
145	144	}

trunk/src/mame/video/tunhunt.c

r21022	r21023
138	138	8-E             Lines (as normal) background
139	139	F               Hilight 3
140	140	*/
141		static void set_pens(running_machine &machine)
	141	void tunhunt_state::set_pens()
142	142	{
143	143	/*
144	144	The actual contents of the color proms (unused by this driver)
r21022	r21023
152	152	0020:   00 f0 f0 f0 b0 b0 00 f0
153	153	00 f0 f0 00 b0 00 f0 f0
154	154	*/
155		//const UINT8 *color_prom = machine.root_device().memregion( "proms" )->base();
156		tunhunt_state *state = machine.driver_data<tunhunt_state>();
	155	//const UINT8 *color_prom = machine().root_device().memregion( "proms" )->base();
157	156	int color;
158	157	int shade;
159	158	int i;
r21022	r21023
161	160
162	161	for( i=0; i<16; i++ )
163	162	{
164		color = state->m_generic_paletteram_8[i];
	163	color = m_generic_paletteram_8[i];
165	164	shade = 0xf^(color>>4);
166	165
167	166	color &= 0xf; /* hue select */
r21022	r21023
193	192	green   = APPLY_SHADE(green,shade);
194	193	blue    = APPLY_SHADE(blue,shade);
195	194
196		colortable_palette_set_color( machine.colortable,i,MAKE_RGB(red,green,blue) );
	195	colortable_palette_set_color( machine().colortable,i,MAKE_RGB(red,green,blue) );
197	196	}
198	197	}
199	198
200		static void draw_motion_object(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	199	void tunhunt_state::draw_motion_object(bitmap_ind16 &bitmap, const rectangle &cliprect)
201	200	{
202	201	/*
203	202	*      VSTRLO  0x1202
r21022	r21023
210	209	*          always 0x00?
211	210	*/
212	211
213		tunhunt_state *state = machine.driver_data<tunhunt_state>();
214		bitmap_ind16 &tmpbitmap = state->m_tmpbitmap;
215		UINT8 *spriteram = state->m_spriteram;
216		UINT8 *tunhunt_ram = state->m_workram;
	212	bitmap_ind16 &tmpbitmap = m_tmpbitmap;
	213	UINT8 *spriteram = m_spriteram;
	214	UINT8 *tunhunt_ram = m_workram;
217	215	//int skip = tunhunt_ram[MOBST];
218	216	int x0 = 255-tunhunt_ram[MOBJV];
219	217	int y0 = 255-tunhunt_ram[MOBJH];
r21022	r21023
269	267	);
270	268	}
271	269
272		static void draw_box(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	270	void tunhunt_state::draw_box(bitmap_ind16 &bitmap, const rectangle &cliprect)
273	271	{
274	272	/*
275	273	This is unnecessarily slow, but the box priorities aren't completely understood,
r21022	r21023
289	287	1280: 07 03 00      01  07 06 04 05 02 07 03 00     09 0a   0b 0c       palette select
290	288	->hue 06 02 ff      60  06 05 03 04 01 06 02 ff     d2 00   c2 ff
291	289	*/
292		tunhunt_state *state = machine.driver_data<tunhunt_state>();
293		UINT8 *tunhunt_ram = state->m_workram;
	290	UINT8 *tunhunt_ram = m_workram;
294	291	int span,x,y;
295	292	int color;
296	293	//  rectangle bbox;
r21022	r21023
323	320	}
324	321
325	322	/* "shell" graphics are 16x16 pixel tiles used for player shots and targeting cursor */
326		static void draw_shell(running_machine &machine,
327		bitmap_ind16 &bitmap,
	323	void tunhunt_state::draw_shell(bitmap_ind16 &bitmap,
328	324	const rectangle &cliprect,
329	325	int picture_code,
330	326	int hposition,
r21022	r21023
341	337	for( sy=0; sy<256; sy+=16 )
342	338	{
343	339	drawgfx_transpen( bitmap, cliprect,
344		machine.gfx[1],
	340	machine().gfx[1],
345	341	picture_code,
346	342	0, /* color */
347	343	0,0, /* flip */
r21022	r21023
366	362
367	363	*/
368	364	drawgfx_transpen( bitmap, cliprect,
369		machine.gfx[1],
	365	machine().gfx[1],
370	366	picture_code,
371	367	0, /* color */
372	368	0,0, /* flip */
r21022	r21023
375	371
376	372	UINT32 tunhunt_state::screen_update_tunhunt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
377	373	{
378		set_pens(machine());
	374	set_pens();
379	375
380		draw_box(machine(), bitmap, cliprect);
	376	draw_box(bitmap, cliprect);
381	377
382		draw_motion_object(machine(), bitmap, cliprect);
	378	draw_motion_object(bitmap, cliprect);
383	379
384		draw_shell(machine(), bitmap, cliprect,
	380	draw_shell(bitmap, cliprect,
385	381	m_workram[SHL0PC],  /* picture code */
386	382	m_workram[SHEL0H],  /* hposition */
387	383	m_workram[SHL0V],   /* vstart */
r21022	r21023
389	385	m_workram[SHL0ST],  /* vstretch */
390	386	m_control&0x08 ); /* hstretch */
391	387
392		draw_shell(machine(), bitmap, cliprect,
	388	draw_shell(bitmap, cliprect,
393	389	m_workram[SHL1PC],  /* picture code */
394	390	m_workram[SHEL1H],  /* hposition */
395	391	m_workram[SHL1V],   /* vstart */

trunk/src/mame/video/tbowl.c

r21022	r21023
119	119	}
120	120
121	121
122		void tbowl_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect, int xscroll, UINT8* spriteram)
	122	void tbowl_state::tbowl_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect, int xscroll, UINT8* spriteram)
123	123	{
124	124	int offs;
125	125	static const UINT8 layout[8][8] =
r21022	r21023
162	162
163	163	sx -= xscroll;
164	164
165		drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	165	drawgfx_transpen(bitmap,cliprect,machine().gfx[3],
166	166	code + layout[y][x],
167	167	color,
168	168	flipx,flipy,
169	169	sx,sy,0 );
170	170
171	171	/* wraparound */
172		drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	172	drawgfx_transpen(bitmap,cliprect,machine().gfx[3],
173	173	code + layout[y][x],
174	174	color,
175	175	flipx,flipy,
176	176	sx,sy-0x200,0 );
177	177
178	178	/* wraparound */
179		drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	179	drawgfx_transpen(bitmap,cliprect,machine().gfx[3],
180	180	code + layout[y][x],
181	181	color,
182	182	flipx,flipy,
183	183	sx-0x400,sy,0 );
184	184
185	185	/* wraparound */
186		drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	186	drawgfx_transpen(bitmap,cliprect,machine().gfx[3],
187	187	code + layout[y][x],
188	188	color,
189	189	flipx,flipy,
r21022	r21023
208	208
209	209	bitmap.fill(0x100, cliprect); /* is there a register controling the colour? looks odd when screen is blank */
210	210	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
211		tbowl_draw_sprites(machine(), bitmap,cliprect, 0, m_spriteram);
	211	tbowl_draw_sprites(bitmap,cliprect, 0, m_spriteram);
212	212	m_bg2_tilemap->draw(bitmap, cliprect, 0,0);
213	213	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
214	214
r21022	r21023
226	226
227	227	bitmap.fill(0x100, cliprect); /* is there a register controling the colour? looks odd when screen is blank */
228	228	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
229		tbowl_draw_sprites(machine(), bitmap,cliprect, 32*8, m_spriteram);
	229	tbowl_draw_sprites(bitmap,cliprect, 32*8, m_spriteram);
230	230	m_bg2_tilemap->draw(bitmap, cliprect, 0,0);
231	231	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
232	232

trunk/src/mame/video/twincobr.c

r21022	r21023
85	85	Start the video hardware emulation.
86	86	***************************************************************************/
87	87
88		static void twincobr_create_tilemaps(running_machine &machine)
	88	void twincobr_state::twincobr_create_tilemaps()
89	89	{
90		twincobr_state *state = machine.driver_data<twincobr_state>();
	90	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(twincobr_state::get_bg_tile_info),this),TILEMAP_SCAN_ROWS,8,8,64,64);
	91	m_fg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(twincobr_state::get_fg_tile_info),this),TILEMAP_SCAN_ROWS,8,8,64,64);
	92	m_tx_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(twincobr_state::get_tx_tile_info),this),TILEMAP_SCAN_ROWS,8,8,64,32);
91	93
92		state->m_bg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(twincobr_state::get_bg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,64);
93		state->m_fg_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(twincobr_state::get_fg_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,64);
94		state->m_tx_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(twincobr_state::get_tx_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
95
96		state->m_fg_tilemap->set_transparent_pen(0);
97		state->m_tx_tilemap->set_transparent_pen(0);
	94	m_fg_tilemap->set_transparent_pen(0);
	95	m_tx_tilemap->set_transparent_pen(0);
98	96	}
99	97
100	98	VIDEO_START_MEMBER(twincobr_state,toaplan0)
r21022	r21023
104	102	m_bgvideoram_size = 0x2000; /* banked two times 0x1000 */
105	103	m_fgvideoram_size = 0x1000;
106	104
107		twincobr_create_tilemaps(machine());
	105	twincobr_create_tilemaps();
108	106
109	107	m_txvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_txvideoram_size);
110	108	m_fgvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_fgvideoram_size);
111	109	m_bgvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_bgvideoram_size);
112	110
113	111	m_display_on = 0;
114		twincobr_display(machine(), m_display_on);
	112	twincobr_display(m_display_on);
115	113
116	114	state_save_register_global_pointer(machine(), m_txvideoram16, m_txvideoram_size);
117	115	state_save_register_global_pointer(machine(), m_fgvideoram16, m_fgvideoram_size);
r21022	r21023
137	135
138	136	void twincobr_state::twincobr_restore_screen()
139	137	{
140		twincobr_display(machine(), m_display_on);
141		twincobr_flipscreen(machine(), m_flip_screen);
	138	twincobr_display(m_display_on);
	139	twincobr_flipscreen(m_flip_screen);
142	140	}
143	141
144	142
r21022	r21023
146	144	Video I/O interface
147	145	***************************************************************************/
148	146
149		void twincobr_display(running_machine &machine, int enable)
	147	void twincobr_state::twincobr_display(int enable)
150	148	{
151		twincobr_state *state = machine.driver_data<twincobr_state>();
152	149
153		state->m_display_on = enable;
154		state->m_bg_tilemap->enable(enable);
155		state->m_fg_tilemap->enable(enable);
156		state->m_tx_tilemap->enable(enable);
	150	m_display_on = enable;
	151	m_bg_tilemap->enable(enable);
	152	m_fg_tilemap->enable(enable);
	153	m_tx_tilemap->enable(enable);
157	154	}
158	155
159		void twincobr_flipscreen(running_machine &machine, int flip)
	156	void twincobr_state::twincobr_flipscreen(int flip)
160	157	{
161		twincobr_state *state = machine.driver_data<twincobr_state>();
162	158
163		machine.tilemap().set_flip_all((flip ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0));
164		state->m_flip_screen = flip;
	159	machine().tilemap().set_flip_all((flip ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0));
	160	m_flip_screen = flip;
165	161	if (flip) {
166		state->m_scroll_x = 0x008;
167		state->m_scroll_y = 0x0c5;
	162	m_scroll_x = 0x008;
	163	m_scroll_y = 0x0c5;
168	164	}
169	165	else {
170		state->m_scroll_x = 0x037;
171		state->m_scroll_y = 0x01e;
	166	m_scroll_x = 0x037;
	167	m_scroll_y = 0x01e;
172	168	}
173	169	}
174	170
r21022	r21023
352	348	Ugly sprite hack for Wardner when hero is in shop
353	349	***************************************************************************/
354	350
355		static void wardner_sprite_priority_hack(running_machine &machine)
	351	void twincobr_state::wardner_sprite_priority_hack()
356	352	{
357		twincobr_state *state = machine.driver_data<twincobr_state>();
358	353
359		if (state->m_fgscrollx != state->m_bgscrollx) {
360		UINT16 *buffered_spriteram16 = reinterpret_cast<UINT16 *>(state->m_spriteram8->buffer());
361		if ((state->m_fgscrollx==0x1c9) || (state->m_flip_screen && (state->m_fgscrollx==0x17a))) { /* in the shop ? */
	354	if (m_fgscrollx != m_bgscrollx) {
	355	UINT16 *buffered_spriteram16 = reinterpret_cast<UINT16 *>(m_spriteram8->buffer());
	356	if ((m_fgscrollx==0x1c9) || (m_flip_screen && (m_fgscrollx==0x17a))) { /* in the shop ? */
362	357	int wardner_hack = buffered_spriteram16[0x0b04/2];
363	358	/* sprite position 0x6300 to 0x8700 -- hero on shop keeper (normal) */
364	359	/* sprite position 0x3900 to 0x5e00 -- hero on shop keeper (flip) */
r21022	r21023
382	377
383	378
384	379
385		static void twincobr_log_vram(running_machine &machine)
	380	void twincobr_state::twincobr_log_vram()
386	381	{
387	382	#ifdef MAME_DEBUG
388		twincobr_state *state = machine.driver_data<twincobr_state>();
389	383
390		if ( machine.input().code_pressed(KEYCODE_M) )
	384	if ( machine().input().code_pressed(KEYCODE_M) )
391	385	{
392	386	offs_t tile_voffs;
393	387	int tcode[4];
394		while (machine.input().code_pressed(KEYCODE_M)) ;
	388	while (machine().input().code_pressed(KEYCODE_M)) ;
395	389	logerror("Scrolls             BG-X BG-Y  FG-X FG-Y  TX-X  TX-Y\n");
396		logerror("------>             %04x %04x  %04x %04x  %04x  %04x\n",state->m_bgscrollx,state->m_bgscrolly,state->m_fgscrollx,state->m_fgscrolly,state->m_txscrollx,state->m_txscrolly);
397		for ( tile_voffs = 0; tile_voffs < (state->m_txvideoram_size/2); tile_voffs++ )
	390	logerror("------>             %04x %04x  %04x %04x  %04x  %04x\n",m_bgscrollx,m_bgscrolly,m_fgscrollx,m_fgscrolly,m_txscrollx,m_txscrolly);
	391	for ( tile_voffs = 0; tile_voffs < (m_txvideoram_size/2); tile_voffs++ )
398	392	{
399		tcode[1] = state->m_bgvideoram16[tile_voffs];
400		tcode[2] = state->m_fgvideoram16[tile_voffs];
401		tcode[3] = state->m_txvideoram16[tile_voffs];
	393	tcode[1] = m_bgvideoram16[tile_voffs];
	394	tcode[2] = m_fgvideoram16[tile_voffs];
	395	tcode[3] = m_txvideoram16[tile_voffs];
402	396	logerror("$(%04x)  (Col-Tile) BG1:%01x-%03x  FG1:%01x-%03x  TX1:%02x-%03x\n", tile_voffs,
403	397	tcode[1] & 0xf000 >> 12, tcode[1] & 0x0fff,
404	398	tcode[2] & 0xf000 >> 12, tcode[2] & 0x0fff,
405	399	tcode[3] & 0xf800 >> 11, tcode[3] & 0x07ff);
406	400	}
407		for ( tile_voffs = (state->m_txvideoram_size/2); tile_voffs < (state->m_fgvideoram_size/2); tile_voffs++ )
	401	for ( tile_voffs = (m_txvideoram_size/2); tile_voffs < (m_fgvideoram_size/2); tile_voffs++ )
408	402	{
409		tcode[1] = state->m_bgvideoram16[tile_voffs];
410		tcode[2] = state->m_fgvideoram16[tile_voffs];
	403	tcode[1] = m_bgvideoram16[tile_voffs];
	404	tcode[2] = m_fgvideoram16[tile_voffs];
411	405	logerror("$(%04x)  (Col-Tile) BG1:%01x-%03x  FG1:%01x-%03x\n", tile_voffs,
412	406	tcode[1] & 0xf000 >> 12, tcode[1] & 0x0fff,
413	407	tcode[2] & 0xf000 >> 12, tcode[2] & 0x0fff);
414	408	}
415		for ( tile_voffs = (state->m_fgvideoram_size/2); tile_voffs < (state->m_bgvideoram_size/2); tile_voffs++ )
	409	for ( tile_voffs = (m_fgvideoram_size/2); tile_voffs < (m_bgvideoram_size/2); tile_voffs++ )
416	410	{
417		tcode[1] = state->m_bgvideoram16[tile_voffs];
	411	tcode[1] = m_bgvideoram16[tile_voffs];
418	412	logerror("$(%04x)  (Col-Tile) BG1:%01x-%03x\n", tile_voffs,
419	413	tcode[1] & 0xf000 >> 12, tcode[1] & 0x0fff);
420	414	}
r21022	r21023
427	421	Sprite Handlers
428	422	***************************************************************************/
429	423
430		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	424	void twincobr_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
431	425	{
432		twincobr_state *state = machine.driver_data<twincobr_state>();
433	426	int offs;
434	427
435		if (state->m_display_on)
	428	if (m_display_on)
436	429	{
437	430	UINT16 *buffered_spriteram16;
438	431	UINT32 bytes;
439		if (state->m_spriteram16 != NULL)
	432	if (m_spriteram16 != NULL)
440	433	{
441		buffered_spriteram16 = state->m_spriteram16->buffer();
442		bytes = state->m_spriteram16->bytes();
	434	buffered_spriteram16 = m_spriteram16->buffer();
	435	bytes = m_spriteram16->bytes();
443	436	}
444	437	else
445	438	{
446		buffered_spriteram16 = reinterpret_cast<UINT16 *>(state->m_spriteram8->buffer());
447		bytes = state->m_spriteram8->bytes();
	439	buffered_spriteram16 = reinterpret_cast<UINT16 *>(m_spriteram8->buffer());
	440	bytes = m_spriteram8->bytes();
448	441	}
449	442	for (offs = 0;offs < bytes/2;offs += 4)
450	443	{
r21022	r21023
461	454	flipx = attribute & 0x100;
462	455	if (flipx) sx -= 14;        /* should really be 15 */
463	456	flipy = attribute & 0x200;
464		drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	457	drawgfx_transpen(bitmap,cliprect,machine().gfx[3],
465	458	sprite,
466	459	color,
467	460	flipx,flipy,
r21022	r21023
479	472
480	473	UINT32 twincobr_state::screen_update_toaplan0(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
481	474	{
482		twincobr_log_vram(machine());
	475	twincobr_log_vram();
483	476
484		if (m_wardner_sprite_hack) wardner_sprite_priority_hack(machine());
	477	if (m_wardner_sprite_hack) wardner_sprite_priority_hack();
485	478
486	479	bitmap.fill(0, cliprect);
487	480
488	481	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
489		draw_sprites(machine(), bitmap,cliprect,0x0400);
	482	draw_sprites(bitmap,cliprect,0x0400);
490	483	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
491		draw_sprites(machine(), bitmap,cliprect,0x0800);
	484	draw_sprites(bitmap,cliprect,0x0800);
492	485	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
493		draw_sprites(machine(), bitmap,cliprect,0x0c00);
	486	draw_sprites(bitmap,cliprect,0x0c00);
494	487	return 0;
495	488	}
496	489

trunk/src/mame/video/tryout.c

r21022	r21023
176	176	m_fg_tilemap->set_transparent_pen(0);
177	177	}
178	178
179		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	179	void tryout_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
180	180	{
181		tryout_state *state = machine.driver_data<tryout_state>();
182		UINT8 *spriteram = state->m_spriteram;
183		UINT8 *spriteram_2 = state->m_spriteram2;
	181	UINT8 *spriteram = m_spriteram;
	182	UINT8 *spriteram_2 = m_spriteram2;
184	183	int offs,fx,fy,x,y,color,sprite,inc;
185	184
186	185	for (offs = 0;offs < 0x7f;offs += 4)
r21022	r21023
196	195	fy = 0;
197	196	inc = 16;
198	197
199		if (state->flip_screen())
	198	if (flip_screen())
200	199	{
201	200	x = 240 - x;
202	201	fx = !fx;
r21022	r21023
210	209	/* Double Height */
211	210	if(spriteram[offs] & 0x10)
212	211	{
213		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	212	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
214	213	sprite,
215	214	color,fx,fy,x,y + inc,0);
216	215
217		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	216	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
218	217	sprite+1,
219	218	color,fx,fy,x,y,0);
220	219	}
221	220	else
222	221	{
223		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	222	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
224	223	sprite,
225	224	color,fx,fy,x,y,0);
226	225	}
r21022	r21023
253	252	{
254	253	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
255	254	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
256		draw_sprites(machine(), bitmap,cliprect);
	255	draw_sprites(bitmap,cliprect);
257	256	}
258	257
259	258	//  popmessage("%02x %02x %02x %02x",m_gfx_control[0],m_gfx_control[1],m_gfx_control[2],scrollx);

trunk/src/mame/video/taito_o.c

r21022	r21023
25	25	};
26	26
27	27
28		static void parentj_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	28	void taitoo_state::parentj_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
29	29	{
30	30	/* Y chain size is 16/32?/64/64? pixels. X chain size
31	31	is always 64 pixels. */
32	32
33		taitoo_state *state = machine.driver_data<taitoo_state>();
34		address_space &space = machine.driver_data()->generic_space();
	33	address_space &space = machine().driver_data()->generic_space();
35	34	static const int size[] = { 1, 2, 4, 4 };
36	35	int x0, y0, x, y, dx, dy, ex, ey, zx, zy;
37	36	int ysize;
r21022	r21023
45	44	if (offs <  0x01b0 && priority == 0)    continue;
46	45	if (offs >= 0x01b0 && priority == 1)    continue;
47	46
48		x0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
49		y0        =  tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
50		zoomx     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
51		zoomy     = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 2, 0xffff) & 0x007f);
52		tile_offs = (tc0080vco_sprram_r(state->m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
53		ysize     = size[(tc0080vco_sprram_r(state->m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
	47	x0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 1, 0xffff) & 0x3ff;
	48	y0        =  tc0080vco_sprram_r(m_tc0080vco, space, offs + 0, 0xffff) & 0x3ff;
	49	zoomx     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x7f00) >> 8;
	50	zoomy     = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 2, 0xffff) & 0x007f);
	51	tile_offs = (tc0080vco_sprram_r(m_tc0080vco, space, offs + 3, 0xffff) & 0x1fff) << 2;
	52	ysize     = size[(tc0080vco_sprram_r(m_tc0080vco, space, offs, 0xffff) & 0x0c00) >> 10];
54	53
55	54	if (tile_offs)
56	55	{
r21022	r21023
86	85	if (x0 >= 0x200) x0 -= 0x400;
87	86	if (y0 >= 0x200) y0 -= 0x400;
88	87
89		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	88	if (tc0080vco_flipscreen_r(m_tc0080vco))
90	89	{
91	90	x0 = 497 - x0;
92	91	y0 = 498 - y0;
r21022	r21023
109	108	{
110	109	int tile, color, flipx, flipy;
111	110
112		tile  = tc0080vco_cram_0_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
113		color = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
114		flipx = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
115		flipy = tc0080vco_cram_1_r(state->m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
	111	tile  = tc0080vco_cram_0_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x7fff;
	112	color = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x001f;
	113	flipx = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0040;
	114	flipy = tc0080vco_cram_1_r(m_tc0080vco, space, tile_offs, 0xffff) & 0x0080;
116	115
117		if (tc0080vco_flipscreen_r(state->m_tc0080vco))
	116	if (tc0080vco_flipscreen_r(m_tc0080vco))
118	117	{
119	118	flipx ^= 0x0040;
120	119	flipy ^= 0x0080;
121	120	}
122	121
123	122	drawgfxzoom_transpen( bitmap, cliprect,
124		machine.gfx[0],
	123	machine().gfx[0],
125	124	tile,
126	125	color,
127	126	flipx, flipy,
r21022	r21023
147	146
148	147	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 0, TILEMAP_DRAW_OPAQUE, 0);
149	148
150		parentj_draw_sprites(machine(), bitmap, cliprect, 0);
151		parentj_draw_sprites(machine(), bitmap, cliprect, 1);
	149	parentj_draw_sprites(bitmap, cliprect, 0);
	150	parentj_draw_sprites(bitmap, cliprect, 1);
152	151
153	152	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 1, 0, 0);
154	153	tc0080vco_tilemap_draw(m_tc0080vco, bitmap, cliprect, 2, 0, 0);

trunk/src/mame/video/terracre.c

r21022	r21023
27	27	SET_TILE_INFO_MEMBER( 0,data&0xff,0,0 );
28	28	}
29	29
30		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	30	void terracre_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
31	31	{
32		terracre_state *state = machine.driver_data<terracre_state>();
33		const UINT8 *spritepalettebank = state->memregion("user1")->base();
34		gfx_element *pGfx = machine.gfx[2];
35		const UINT16 *pSource = state->m_spriteram;
	32	const UINT8 *spritepalettebank = memregion("user1")->base();
	33	gfx_element *pGfx = machine().gfx[2];
	34	const UINT16 *pSource = m_spriteram;
36	35	int i;
37	36	int transparent_pen;
38	37
r21022	r21023
74	73	color += 16 * (spritepalettebank[(tile>>1)&0xff] & 0x0f);
75	74	}
76	75
77		if (state->flip_screen())
	76	if (flip_screen())
78	77	{
79	78	sx=240-sx;
80	79	sy=240-sy;
r21022	r21023
201	200	else
202	201	m_background->draw(bitmap, cliprect, 0, 0 );
203	202
204		draw_sprites(machine(), bitmap,cliprect );
	203	draw_sprites(bitmap,cliprect );
205	204	m_foreground->draw(bitmap, cliprect, 0, 0 );
206	205	return 0;
207	206	}

trunk/src/mame/video/trackfld.c

r21022	r21023
187	187
188	188
189	189
190		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	190	void trackfld_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
191	191	{
192		trackfld_state *state = machine.driver_data<trackfld_state>();
193		UINT8 *spriteram = state->m_spriteram;
194		UINT8 *spriteram_2 = state->m_spriteram2;
	192	UINT8 *spriteram = m_spriteram;
	193	UINT8 *spriteram_2 = m_spriteram2;
195	194	int offs;
196	195
197		for (offs = state->m_spriteram.bytes() - 2; offs >= 0; offs -= 2)
	196	for (offs = m_spriteram.bytes() - 2; offs >= 0; offs -= 2)
198	197	{
199	198	int attr = spriteram_2[offs];
200	199	int code = spriteram[offs + 1];
201	200	int color = attr & 0x0f;
202		if (!state->m_sprites_gfx_banked)
	201	if (!m_sprites_gfx_banked)
203	202	if (attr&1) code|=0x100; // extra tile# bit for the yiear conversion, trackfld doesn't have this many sprites so it will just get masked
204	203	int flipx = ~attr & 0x40;
205	204	int flipy = attr & 0x80;
206	205	int sx = spriteram[offs] - 1;
207	206	int sy = 240 - spriteram_2[offs + 1];
208	207
209		if (state->flip_screen())
	208	if (flip_screen())
210	209	{
211	210	sy = 240 - sy;
212	211	flipy = !flipy;
r21022	r21023
225	224
226	225
227	226	drawgfx_transmask(bitmap, cliprect,
228		machine.gfx[0],
229		code + state->m_sprite_bank1 + state->m_sprite_bank2, color,
	227	machine().gfx[0],
	228	code + m_sprite_bank1 + m_sprite_bank2, color,
230	229	flipx, flipy,
231	230	sx, sy,
232		colortable_get_transpen_mask(machine.colortable, machine.gfx[0], color, 0));
	231	colortable_get_transpen_mask(machine().colortable, machine().gfx[0], color, 0));
233	232
234	233	/* redraw with wraparound */
235	234	drawgfx_transmask(bitmap,cliprect,
236		machine.gfx[0],
237		code + state->m_sprite_bank1 + state->m_sprite_bank2, color,
	235	machine().gfx[0],
	236	code + m_sprite_bank1 + m_sprite_bank2, color,
238	237	flipx, flipy,
239	238	sx - 256, sy,
240		colortable_get_transpen_mask(machine.colortable, machine.gfx[0], color, 0));
	239	colortable_get_transpen_mask(machine().colortable, machine().gfx[0], color, 0));
241	240	}
242	241	}
243	242
r21022	r21023
255	254	}
256	255
257	256	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
258		draw_sprites(machine(), bitmap, cliprect);
	257	draw_sprites(bitmap, cliprect);
259	258	return 0;
260	259	}

trunk/src/mame/video/thief.c

r21022	r21023
146	146
147	147	/***************************************************************************/
148	148
149		static UINT16 fetch_image_addr( coprocessor_t &thief_coprocessor ){
	149	UINT16 thief_state::fetch_image_addr( coprocessor_t &thief_coprocessor )
	150	{
150	151	int addr = thief_coprocessor.param[IMAGE_ADDR_LO]+256*thief_coprocessor.param[IMAGE_ADDR_HI];
151	152	/* auto-increment */
152	153	thief_coprocessor.param[IMAGE_ADDR_LO]++;

trunk/src/mame/video/travrusa.c

r21022	r21023
246	246	}
247	247
248	248
249		static void set_scroll( running_machine &machine )
	249	void travrusa_state::set_scroll(  )
250	250	{
251		travrusa_state *state = machine.driver_data<travrusa_state>();
252	251	int i;
253	252
254	253	for (i = 0; i <= 2; i++)
255		state->m_bg_tilemap->set_scrollx(i, state->m_scrollx[0] + 256 * state->m_scrollx[1]);
	254	m_bg_tilemap->set_scrollx(i, m_scrollx[0] + 256 * m_scrollx[1]);
256	255
257		state->m_bg_tilemap->set_scrollx(3, 0);
	256	m_bg_tilemap->set_scrollx(3, 0);
258	257	}
259	258
260	259	WRITE8_MEMBER(travrusa_state::travrusa_scroll_x_low_w)
261	260	{
262	261	m_scrollx[0] = data;
263		set_scroll(machine());
	262	set_scroll();
264	263	}
265	264
266	265	WRITE8_MEMBER(travrusa_state::travrusa_scroll_x_high_w)
267	266	{
268	267	m_scrollx[1] = data;
269		set_scroll(machine());
	268	set_scroll();
270	269	}
271	270
272	271
r21022	r21023
289	288
290	289	***************************************************************************/
291	290
292		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	291	void travrusa_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
293	292	{
294		travrusa_state *state = machine.driver_data<travrusa_state>();
295	293	int offs;
296	294	const rectangle spritevisiblearea(1*8, 31*8-1, 0*8, 24*8-1);
297	295	const rectangle spritevisibleareaflip(1*8, 31*8-1, 8*8, 32*8-1);
298	296	rectangle clip = cliprect;
299		if (state->flip_screen())
	297	if (flip_screen())
300	298	clip &= spritevisibleareaflip;
301	299	else
302	300	clip &= spritevisiblearea;
303	301
304	302
305		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	303	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
306	304	{
307		int sx = ((state->m_spriteram[offs + 3] + 8) & 0xff) - 8;
308		int sy = 240 - state->m_spriteram[offs];
309		int code = state->m_spriteram[offs + 2];
310		int attr = state->m_spriteram[offs + 1];
	305	int sx = ((m_spriteram[offs + 3] + 8) & 0xff) - 8;
	306	int sy = 240 - m_spriteram[offs];
	307	int code = m_spriteram[offs + 2];
	308	int attr = m_spriteram[offs + 1];
311	309	int flipx = attr & 0x40;
312	310	int flipy = attr & 0x80;
313	311
314		if (state->flip_screen())
	312	if (flip_screen())
315	313	{
316	314	sx = 240 - sx;
317	315	sy = 240 - sy;
r21022	r21023
319	317	flipy = !flipy;
320	318	}
321	319
322		drawgfx_transpen(bitmap, clip, machine.gfx[1],
	320	drawgfx_transpen(bitmap, clip, machine().gfx[1],
323	321	code,
324	322	attr & 0x0f,
325	323	flipx, flipy,
r21022	r21023
331	329	UINT32 travrusa_state::screen_update_travrusa(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
332	330	{
333	331	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
334		draw_sprites(machine(), bitmap,cliprect);
	332	draw_sprites(bitmap,cliprect);
335	333	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
336	334	return 0;
337	335	}

trunk/src/mame/video/tecmo.c

r21022	r21023
156	156
157	157	***************************************************************************/
158	158
159		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	159	void tecmo_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
160	160	{
161		tecmo_state *state = machine.driver_data<tecmo_state>();
162		UINT8 *spriteram = state->m_spriteram;
	161	UINT8 *spriteram = m_spriteram;
163	162	int offs;
164	163	static const UINT8 layout[8][8] =
165	164	{
r21022	r21023
173	172	{42,43,46,47,58,59,62,63}
174	173	};
175	174
176		for (offs = state->m_spriteram.bytes()-8;offs >= 0;offs -= 8)
	175	for (offs = m_spriteram.bytes()-8;offs >= 0;offs -= 8)
177	176	{
178	177	int flags = spriteram[offs+3];
179	178	int priority = flags>>6;
r21022	r21023
184	183	int code,xpos,ypos,flipx,flipy,priority_mask,x,y;
185	184	int size = spriteram[offs + 2] & 3;
186	185
187		if (state->m_video_type != 0)   /* gemini, silkworm */
	186	if (m_video_type != 0)   /* gemini, silkworm */
188	187	code = which + ((bank & 0xf8) << 5);
189	188	else                        /* rygar */
190	189	code = which + ((bank & 0xf0) << 4);
r21022	r21023
197	196	flipx = bank & 1;
198	197	flipy = bank & 2;
199	198
200		if (state->flip_screen())
	199	if (flip_screen())
201	200	{
202	201	xpos = 256 - (8 * size) - xpos;
203	202	ypos = 256 - (8 * size) - ypos;
r21022	r21023
221	220	{
222	221	int sx = xpos + 8*(flipx?(size-1-x):x);
223	222	int sy = ypos + 8*(flipy?(size-1-y):y);
224		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	223	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
225	224	code + layout[y][x],
226	225	flags & 0xf,
227	226	flipx,flipy,
228	227	sx,sy,
229		machine.priority_bitmap,
	228	machine().priority_bitmap,
230	229	priority_mask,0);
231	230	}
232	231	}
r21022	r21023
243	242	m_fg_tilemap->draw(bitmap, cliprect, 0,2);
244	243	m_tx_tilemap->draw(bitmap, cliprect, 0,4);
245	244
246		draw_sprites(machine(), bitmap,cliprect);
	245	draw_sprites(bitmap,cliprect);
247	246	return 0;
248	247	}

trunk/src/mame/video/taito_b.c

r21022	r21023
23	23	COMBINE_DATA(&m_pixel_scroll[offset]);
24	24	}
25	25
26		static void hitice_clear_pixel_bitmap( running_machine &machine )
	26	void taitob_state::hitice_clear_pixel_bitmap(  )
27	27	{
28	28	int i;
29		taitob_state *state = machine.driver_data<taitob_state>();
30		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	29	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
31	30
32	31	for (i = 0; i < 0x40000; i++)
33		state->hitice_pixelram_w(space, i, 0, 0xffff);
	32	hitice_pixelram_w(space, i, 0, 0xffff);
34	33	}
35	34
36	35	WRITE16_MEMBER(taitob_state::realpunc_video_ctrl_w)
r21022	r21023
95	94	VIDEO_RESET_MEMBER(taitob_state,hitice)
96	95	{
97	96	/* kludge: clear the bitmap on startup */
98		hitice_clear_pixel_bitmap(machine());
	97	hitice_clear_pixel_bitmap();
99	98	}
100	99
101	100
r21022	r21023
127	126	}
128	127
129	128
130		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	129	void taitob_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
131	130	{
132	131	/*  Sprite format: (16 bytes per sprite)
133	132	offs:             bits:
r21022	r21023
158	157	000c - 000f: unused
159	158	*/
160	159
161		taitob_state *state = machine.driver_data<taitob_state>();
162	160	int x, y, xlatch = 0, ylatch = 0, x_no = 0, y_no = 0, x_num = 0, y_num = 0, big_sprite = 0;
163	161	int offs, code, color, flipx, flipy;
164	162	UINT32 data, zoomx, zoomy, zx, zy, zoomxlatch = 0, zoomylatch = 0;
165	163
166	164	for (offs = (0x1980 - 16) / 2; offs >=0; offs -= 8)
167	165	{
168		code = state->m_spriteram[offs];
	166	code = m_spriteram[offs];
169	167
170		color = state->m_spriteram[offs + 1];
	168	color = m_spriteram[offs + 1];
171	169	flipx = color & 0x4000;
172	170	flipy = color & 0x8000;
173	171	#if 0
r21022	r21023
180	178	#endif
181	179	color = (color & 0x3f) * 16;
182	180
183		x = state->m_spriteram[offs + 2] & 0x3ff;
184		y = state->m_spriteram[offs + 3] & 0x3ff;
	181	x = m_spriteram[offs + 2] & 0x3ff;
	182	y = m_spriteram[offs + 3] & 0x3ff;
185	183	if (x >= 0x200)  x -= 0x400;
186	184	if (y >= 0x200)  y -= 0x400;
187	185
188		data = state->m_spriteram[offs + 5];
	186	data = m_spriteram[offs + 5];
189	187	if (data)
190	188	{
191	189	if (!big_sprite)
r21022	r21023
196	194	y_no  = 0;
197	195	xlatch = x;
198	196	ylatch = y;
199		data = state->m_spriteram[offs + 4];
	197	data = m_spriteram[offs + 4];
200	198	zoomxlatch = (data >> 8) & 0xff;
201	199	zoomylatch = (data >> 0) & 0xff;
202	200	big_sprite = 1;
203	201	}
204	202	}
205	203
206		data = state->m_spriteram[offs + 4];
	204	data = m_spriteram[offs + 4];
207	205	zoomx = (data >> 8) & 0xff;
208	206	zoomy = (data >> 0) & 0xff;
209	207	zx = (0x100 - zoomx) / 16;
r21022	r21023
236	234
237	235	if ( zoomx || zoomy )
238	236	{
239		drawgfxzoom_transpen_raw(bitmap, cliprect, machine.gfx[1],
	237	drawgfxzoom_transpen_raw(bitmap, cliprect, machine().gfx[1],
240	238	code,
241	239	color,
242	240	flipx,flipy,
r21022	r21023
245	243	}
246	244	else
247	245	{
248		drawgfx_transpen_raw (bitmap,cliprect,machine.gfx[1],
	246	drawgfx_transpen_raw (bitmap,cliprect,machine().gfx[1],
249	247	code,
250	248	color,
251	249	flipx,flipy,
r21022	r21023
256	254	}
257	255
258	256
259		static void draw_framebuffer( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	257	void taitob_state::draw_framebuffer( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
260	258	{
261		taitob_state *state = machine.driver_data<taitob_state>();
262	259	rectangle myclip = cliprect;
263	260	int x, y;
264		address_space &space = machine.driver_data()->generic_space();
265		UINT8 video_control = tc0180vcu_get_videoctrl(state->m_tc0180vcu, space, 0);
266		UINT8 framebuffer_page = tc0180vcu_get_fb_page(state->m_tc0180vcu, space, 0);
	261	address_space &space = machine().driver_data()->generic_space();
	262	UINT8 video_control = tc0180vcu_get_videoctrl(m_tc0180vcu, space, 0);
	263	UINT8 framebuffer_page = tc0180vcu_get_fb_page(m_tc0180vcu, space, 0);
267	264
268	265	g_profiler.start(PROFILER_USER1);
269	266
r21022	r21023
282	279	/*popmessage("1. X[%3i;%3i] Y[%3i;%3i]", myclip.min_x, myclip.max_x, myclip.min_y, myclip.max_y);*/
283	280	for (y = myclip.min_y; y <= myclip.max_y; y++)
284	281	{
285		UINT16 *src = &state->m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
	282	UINT16 *src = &m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
286	283	UINT16 *dst;
287	284
288	285	dst = &bitmap.pix16(bitmap.height()-1-y, myclip.max_x);
r21022	r21023
292	289	UINT16 c = *src++;
293	290
294	291	if (c != 0)
295		*dst = state->m_b_sp_color_base + c;
	292	*dst = m_b_sp_color_base + c;
296	293
297	294	dst--;
298	295	}
r21022	r21023
302	299	{
303	300	for (y = myclip.min_y; y <= myclip.max_y; y++)
304	301	{
305		UINT16 *src = &state->m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
	302	UINT16 *src = &m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
306	303	UINT16 *dst = &bitmap.pix16(y, myclip.min_x);
307	304
308	305	for (x = myclip.min_x; x <= myclip.max_x; x++)
r21022	r21023
310	307	UINT16 c = *src++;
311	308
312	309	if (c != 0)
313		*dst = state->m_b_sp_color_base + c;
	310	*dst = m_b_sp_color_base + c;
314	311
315	312	dst++;
316	313	}
r21022	r21023
324	321	/*popmessage("3. X[%3i;%3i] Y[%3i;%3i]", myclip.min_x, myclip.max_x, myclip.min_y, myclip.max_y);*/
325	322	for (y = myclip.min_y ;y <= myclip.max_y; y++)
326	323	{
327		UINT16 *src = &state->m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
	324	UINT16 *src = &m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
328	325	UINT16 *dst;
329	326
330	327	dst = &bitmap.pix16(bitmap.height()-1-y, myclip.max_x);
r21022	r21023
334	331	UINT16 c = *src++;
335	332
336	333	if (c != 0 && (c & 0x10) == priority)
337		*dst = state->m_b_sp_color_base + c;
	334	*dst = m_b_sp_color_base + c;
338	335
339	336	dst--;
340	337	}
r21022	r21023
344	341	{
345	342	for (y = myclip.min_y; y <= myclip.max_y; y++)
346	343	{
347		UINT16 *src = &state->m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
	344	UINT16 *src = &m_framebuffer[framebuffer_page]->pix16(y, myclip.min_x);
348	345	UINT16 *dst = &bitmap.pix16(y, myclip.min_x);
349	346
350	347	for (x = myclip.min_x; x <= myclip.max_x; x++)
r21022	r21023
352	349	UINT16 c = *src++;
353	350
354	351	if (c != 0 && (c & 0x10) == priority)
355		*dst = state->m_b_sp_color_base + c;
	352	*dst = m_b_sp_color_base + c;
356	353
357	354	dst++;
358	355	}
r21022	r21023
376	373	/* Draw playfields */
377	374	tc0180vcu_tilemap_draw(m_tc0180vcu, bitmap, cliprect, 0, 1);
378	375
379		draw_framebuffer(machine(), bitmap, cliprect, 1);
	376	draw_framebuffer(bitmap, cliprect, 1);
380	377
381	378	tc0180vcu_tilemap_draw(m_tc0180vcu, bitmap, cliprect, 1, 0);
382	379
r21022	r21023
389	386	copyscrollbitmap_trans(bitmap, *m_pixel_bitmap, 1, &scrollx, 1, &scrolly, cliprect, m_b_fg_color_base * 16);
390	387	}
391	388
392		draw_framebuffer(machine(), bitmap, cliprect, 0);
	389	draw_framebuffer(bitmap, cliprect, 0);
393	390
394	391	tc0180vcu_tilemap_draw(m_tc0180vcu, bitmap, cliprect, 2, 0);
395	392
r21022	r21023
415	412	/* Draw the palettized playfields to an indexed bitmap */
416	413	tc0180vcu_tilemap_draw(m_tc0180vcu, *m_realpunc_bitmap, cliprect, 0, 1);
417	414
418		draw_framebuffer(machine(), *m_realpunc_bitmap, cliprect, 1);
	415	draw_framebuffer(*m_realpunc_bitmap, cliprect, 1);
419	416
420	417	tc0180vcu_tilemap_draw(m_tc0180vcu, *m_realpunc_bitmap, cliprect, 1, 0);
421	418
422	419	if (m_realpunc_video_ctrl & 0x0001)
423		draw_framebuffer(machine(), *m_realpunc_bitmap, cliprect, 0);
	420	draw_framebuffer(*m_realpunc_bitmap, cliprect, 0);
424	421
425	422	/* Copy the intermediate bitmap to the output bitmap, applying the palette */
426	423	for (y = 0; y <= cliprect.max_y; y++)
r21022	r21023
471	468	m_realpunc_bitmap->fill(0, cliprect);
472	469
473	470	if (!(m_realpunc_video_ctrl & 0x0001))
474		draw_framebuffer(machine(), *m_realpunc_bitmap, cliprect, 0);
	471	draw_framebuffer(*m_realpunc_bitmap, cliprect, 0);
475	472
476	473	tc0180vcu_tilemap_draw(m_tc0180vcu, *m_realpunc_bitmap, cliprect, 2, 0);
477	474
r21022	r21023
508	505	tc0180vcu_set_fb_page(m_tc0180vcu, space, 0, framebuffer_page);
509	506	}
510	507
511		draw_sprites(machine(), *m_framebuffer[framebuffer_page], machine().primary_screen->visible_area());
	508	draw_sprites(*m_framebuffer[framebuffer_page], machine().primary_screen->visible_area());
512	509	}
513	510	}

trunk/src/mame/video/toaplan1.c

r21022	r21023
206	206
207	207	***************************************************************************/
208	208
209		static void toaplan1_create_tilemaps(running_machine &machine)
	209	void toaplan1_state::toaplan1_create_tilemaps()
210	210	{
211		toaplan1_state *state = machine.driver_data<toaplan1_state>();
212	211
213		state->m_pf1_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf1_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
214		state->m_pf2_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf2_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
215		state->m_pf3_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf3_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
216		state->m_pf4_tilemap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf4_tile_info),state), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	212	m_pf1_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf1_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	213	m_pf2_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf2_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	214	m_pf3_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf3_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
	215	m_pf4_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(toaplan1_state::get_pf4_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
217	216
218		state->m_pf1_tilemap->set_transparent_pen(0);
219		state->m_pf2_tilemap->set_transparent_pen(0);
220		state->m_pf3_tilemap->set_transparent_pen(0);
221		state->m_pf4_tilemap->set_transparent_pen(0);
	217	m_pf1_tilemap->set_transparent_pen(0);
	218	m_pf2_tilemap->set_transparent_pen(0);
	219	m_pf3_tilemap->set_transparent_pen(0);
	220	m_pf4_tilemap->set_transparent_pen(0);
222	221
223		memset(state->m_empty_tile, 0x00, sizeof(state->m_empty_tile));
	222	memset(m_empty_tile, 0x00, sizeof(m_empty_tile));
224	223	}
225	224
226	225
227		static void toaplan1_paletteram_alloc(running_machine &machine)
	226	void toaplan1_state::toaplan1_paletteram_alloc()
228	227	{
229		toaplan1_state *state = machine.driver_data<toaplan1_state>();
230	228
231		UINT32 bytes = (state->m_colorram1.bytes() + state->m_colorram2.bytes())/2;
232		state->m_generic_paletteram_16.allocate(bytes);
	229	UINT32 bytes = (m_colorram1.bytes() + m_colorram2.bytes())/2;
	230	m_generic_paletteram_16.allocate(bytes);
233	231	}
234	232
235		static void toaplan1_vram_alloc(running_machine &machine)
	233	void toaplan1_state::toaplan1_vram_alloc()
236	234	{
237		toaplan1_state *state = machine.driver_data<toaplan1_state>();
238	235
239		state->m_pf1_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
240		state->m_pf2_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
241		state->m_pf3_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
242		state->m_pf4_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
	236	m_pf1_tilevram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
	237	m_pf2_tilevram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
	238	m_pf3_tilevram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
	239	m_pf4_tilevram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
243	240
244		state->save_pointer(NAME(state->m_pf1_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
245		state->save_pointer(NAME(state->m_pf2_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
246		state->save_pointer(NAME(state->m_pf3_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
247		state->save_pointer(NAME(state->m_pf4_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
	241	save_pointer(NAME(m_pf1_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
	242	save_pointer(NAME(m_pf2_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
	243	save_pointer(NAME(m_pf3_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
	244	save_pointer(NAME(m_pf4_tilevram16), TOAPLAN1_TILEVRAM_SIZE/2);
248	245
249	246	#ifdef MAME_DEBUG
250		state->m_display_pf1 = 1;
251		state->m_display_pf2 = 1;
252		state->m_display_pf3 = 1;
253		state->m_display_pf4 = 1;
254		state->m_displog = 0;
	247	m_display_pf1 = 1;
	248	m_display_pf2 = 1;
	249	m_display_pf3 = 1;
	250	m_display_pf4 = 1;
	251	m_displog = 0;
255	252	#endif
256	253	}
257	254
258		static void toaplan1_spritevram_alloc(running_machine &machine)
	255	void toaplan1_state::toaplan1_spritevram_alloc()
259	256	{
260		toaplan1_state *state = machine.driver_data<toaplan1_state>();
261	257
262		state->m_spriteram.allocate(TOAPLAN1_SPRITERAM_SIZE/2);
263		state->m_buffered_spriteram = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITERAM_SIZE/2);
264		state->m_spritesizeram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
265		state->m_buffered_spritesizeram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
	258	m_spriteram.allocate(TOAPLAN1_SPRITERAM_SIZE/2);
	259	m_buffered_spriteram = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_SPRITERAM_SIZE/2);
	260	m_spritesizeram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
	261	m_buffered_spritesizeram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
266	262
267		state->save_pointer(NAME(state->m_buffered_spriteram), TOAPLAN1_SPRITERAM_SIZE/2);
268		state->save_pointer(NAME(state->m_spritesizeram16), TOAPLAN1_SPRITESIZERAM_SIZE/2);
269		state->save_pointer(NAME(state->m_buffered_spritesizeram16), TOAPLAN1_SPRITESIZERAM_SIZE/2);
	263	save_pointer(NAME(m_buffered_spriteram), TOAPLAN1_SPRITERAM_SIZE/2);
	264	save_pointer(NAME(m_spritesizeram16), TOAPLAN1_SPRITESIZERAM_SIZE/2);
	265	save_pointer(NAME(m_buffered_spritesizeram16), TOAPLAN1_SPRITESIZERAM_SIZE/2);
270	266	}
271	267
272		static void toaplan1_set_scrolls(running_machine &machine)
	268	void toaplan1_state::toaplan1_set_scrolls()
273	269	{
274		toaplan1_state *state = machine.driver_data<toaplan1_state>();
275	270
276		state->m_pf1_tilemap->set_scrollx(0, (state->m_pf1_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs1));
277		state->m_pf2_tilemap->set_scrollx(0, (state->m_pf2_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs2));
278		state->m_pf3_tilemap->set_scrollx(0, (state->m_pf3_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs3));
279		state->m_pf4_tilemap->set_scrollx(0, (state->m_pf4_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs4));
280		state->m_pf1_tilemap->set_scrolly(0, (state->m_pf1_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
281		state->m_pf2_tilemap->set_scrolly(0, (state->m_pf2_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
282		state->m_pf3_tilemap->set_scrolly(0, (state->m_pf3_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
283		state->m_pf4_tilemap->set_scrolly(0, (state->m_pf4_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
	271	m_pf1_tilemap->set_scrollx(0, (m_pf1_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs1));
	272	m_pf2_tilemap->set_scrollx(0, (m_pf2_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs2));
	273	m_pf3_tilemap->set_scrollx(0, (m_pf3_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs3));
	274	m_pf4_tilemap->set_scrollx(0, (m_pf4_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs4));
	275	m_pf1_tilemap->set_scrolly(0, (m_pf1_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	276	m_pf2_tilemap->set_scrolly(0, (m_pf2_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	277	m_pf3_tilemap->set_scrolly(0, (m_pf3_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	278	m_pf4_tilemap->set_scrolly(0, (m_pf4_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
284	279	}
285	280
286	281	void toaplan1_state::rallybik_flipscreen()
r21022	r21023
297	292	toaplan1_bcu_flipscreen_w(space, 0, m_bcu_flipscreen, 0xffff);
298	293	}
299	294
300		static void register_common(running_machine &machine)
	295	void toaplan1_state::register_common()
301	296	{
302		toaplan1_state *state = machine.driver_data<toaplan1_state>();
303	297
304		state->save_item(NAME(state->m_scrollx_offs1));
305		state->save_item(NAME(state->m_scrollx_offs2));
306		state->save_item(NAME(state->m_scrollx_offs3));
307		state->save_item(NAME(state->m_scrollx_offs4));
308		state->save_item(NAME(state->m_scrolly_offs));
	298	save_item(NAME(m_scrollx_offs1));
	299	save_item(NAME(m_scrollx_offs2));
	300	save_item(NAME(m_scrollx_offs3));
	301	save_item(NAME(m_scrollx_offs4));
	302	save_item(NAME(m_scrolly_offs));
309	303
310		state->save_item(NAME(state->m_bcu_flipscreen));
311		state->save_item(NAME(state->m_fcu_flipscreen));
312		state->save_item(NAME(state->m_reset));
	304	save_item(NAME(m_bcu_flipscreen));
	305	save_item(NAME(m_fcu_flipscreen));
	306	save_item(NAME(m_reset));
313	307
314		state->save_item(NAME(state->m_pf1_scrollx));
315		state->save_item(NAME(state->m_pf1_scrolly));
316		state->save_item(NAME(state->m_pf2_scrollx));
317		state->save_item(NAME(state->m_pf2_scrolly));
318		state->save_item(NAME(state->m_pf3_scrollx));
319		state->save_item(NAME(state->m_pf3_scrolly));
320		state->save_item(NAME(state->m_pf4_scrollx));
321		state->save_item(NAME(state->m_pf4_scrolly));
	308	save_item(NAME(m_pf1_scrollx));
	309	save_item(NAME(m_pf1_scrolly));
	310	save_item(NAME(m_pf2_scrollx));
	311	save_item(NAME(m_pf2_scrolly));
	312	save_item(NAME(m_pf3_scrollx));
	313	save_item(NAME(m_pf3_scrolly));
	314	save_item(NAME(m_pf4_scrollx));
	315	save_item(NAME(m_pf4_scrolly));
322	316
323		state->save_item(NAME(state->m_tiles_offsetx));
324		state->save_item(NAME(state->m_tiles_offsety));
325		state->save_item(NAME(state->m_pf_voffs));
326		state->save_item(NAME(state->m_spriteram_offs));
	317	save_item(NAME(m_tiles_offsetx));
	318	save_item(NAME(m_tiles_offsety));
	319	save_item(NAME(m_pf_voffs));
	320	save_item(NAME(m_spriteram_offs));
327	321	}
328	322
329	323
330	324	VIDEO_START_MEMBER(toaplan1_state,rallybik)
331	325	{
332		toaplan1_create_tilemaps(machine());
333		toaplan1_paletteram_alloc(machine());
334		toaplan1_vram_alloc(machine());
	326	toaplan1_create_tilemaps();
	327	toaplan1_paletteram_alloc();
	328	toaplan1_vram_alloc();
335	329
336	330	m_buffered_spriteram = auto_alloc_array_clear(machine(), UINT16, m_spriteram.bytes()/2);
337	331	save_pointer(NAME(m_buffered_spriteram), m_spriteram.bytes()/2);
r21022	r21023
346	340	m_fcu_flipscreen = 0;
347	341	m_reset = 0;
348	342
349		register_common(machine());
	343	register_common();
350	344
351	345	machine().save().register_postload(save_prepost_delegate(FUNC(toaplan1_state::rallybik_flipscreen), this));
352	346	}
353	347
354	348	VIDEO_START_MEMBER(toaplan1_state,toaplan1)
355	349	{
356		toaplan1_create_tilemaps(machine());
357		toaplan1_paletteram_alloc(machine());
358		toaplan1_vram_alloc(machine());
359		toaplan1_spritevram_alloc(machine());
	350	toaplan1_create_tilemaps();
	351	toaplan1_paletteram_alloc();
	352	toaplan1_vram_alloc();
	353	toaplan1_spritevram_alloc();
360	354
361	355	m_scrollx_offs1 = 0x1ef + 6;
362	356	m_scrollx_offs2 = 0x1ef + 4;
r21022	r21023
368	362	m_fcu_flipscreen = 0;
369	363	m_reset = 1;
370	364
371		register_common(machine());
	365	register_common();
372	366
373	367	machine().save().register_postload(save_prepost_delegate(FUNC(toaplan1_state::toaplan1_flipscreen), this));
374	368	}
r21022	r21023
398	392	logerror("Tiles_offsety now = %08x\n", m_tiles_offsety);
399	393	}
400	394	m_reset = 1;
401		toaplan1_set_scrolls(machine());
	395	toaplan1_set_scrolls();
402	396	}
403	397
404	398	WRITE16_MEMBER(toaplan1_state::rallybik_bcu_flipscreen_w)
r21022	r21023
424	418	m_scrollx_offs4 = 0x00d + 0;
425	419	m_scrolly_offs  = 0x111;
426	420	}
427		toaplan1_set_scrolls(machine());
	421	toaplan1_set_scrolls();
428	422	}
429	423	}
430	424
r21022	r21023
454	448	m_scrollx_offs4 = 0x1ef + 0;
455	449	m_scrolly_offs  = 0x101;
456	450	}
457		toaplan1_set_scrolls(machine());
	451	toaplan1_set_scrolls();
458	452	}
459	453	}
460	454
r21022	r21023
706	700
707	701
708	702
709		static void toaplan1_log_vram(running_machine &machine)
	703	void toaplan1_state::toaplan1_log_vram()
710	704	{
711	705	#ifdef MAME_DEBUG
712		toaplan1_state *state = machine.driver_data<toaplan1_state>();
713	706
714		if ( machine.input().code_pressed(KEYCODE_M) )
	707	if ( machine().input().code_pressed(KEYCODE_M) )
715	708	{
716		UINT16 *spriteram16 = state->m_spriteram;
717		UINT16 *buffered_spriteram16 = state->m_buffered_spriteram;
	709	UINT16 *spriteram16 = m_spriteram;
	710	UINT16 *buffered_spriteram16 = m_buffered_spriteram;
718	711	offs_t sprite_voffs;
719		while (machine.input().code_pressed(KEYCODE_M)) ;
720		if (state->m_spritesizeram16)           /* FCU controller */
	712	while (machine().input().code_pressed(KEYCODE_M)) ;
	713	if (m_spritesizeram16)           /* FCU controller */
721	714	{
722	715	int schar,sattr,sxpos,sypos,bschar,bsattr,bsxpos,bsypos;
723		UINT16 *size  = (UINT16 *)(state->m_spritesizeram16);
724		UINT16 *bsize = (UINT16 *)(state->m_buffered_spritesizeram16);
	716	UINT16 *size  = (UINT16 *)(m_spritesizeram16);
	717	UINT16 *bsize = (UINT16 *)(m_buffered_spritesizeram16);
725	718	logerror("Scrolls    PF1-X  PF1-Y     PF2-X  PF2-Y     PF3-X  PF3-Y     PF4-X  PF4-Y\n");
726	719	logerror("------>    #%04x  #%04x     #%04x  #%04x     #%04x  #%04x     #%04x  #%04x\n",
727		state->m_pf1_scrollx, state->m_pf1_scrolly, state->m_pf2_scrollx, state->m_pf2_scrolly, state->m_pf3_scrollx, state->m_pf3_scrolly, state->m_pf4_scrollx, state->m_pf4_scrolly);
728		for ( sprite_voffs = 0; sprite_voffs < state->m_spriteram.bytes()/2; sprite_voffs += 4 )
	720	m_pf1_scrollx, m_pf1_scrolly, m_pf2_scrollx, m_pf2_scrolly, m_pf3_scrollx, m_pf3_scrolly, m_pf4_scrollx, m_pf4_scrolly);
	721	for ( sprite_voffs = 0; sprite_voffs < m_spriteram.bytes()/2; sprite_voffs += 4 )
729	722	{
730	723	bschar = buffered_spriteram16[sprite_voffs];
731	724	bsattr = buffered_spriteram16[sprite_voffs + 1];
r21022	r21023
745	738	int schar,sattr,sxpos,sypos,bschar,bsattr,bsxpos,bsypos;
746	739	logerror("Scrolls    PF1-X  PF1-Y     PF2-X  PF2-Y     PF3-X  PF3-Y     PF4-X  PF4-Y\n");
747	740	logerror("------>    #%04x  #%04x     #%04x  #%04x     #%04x  #%04x     #%04x  #%04x\n",
748		state->m_pf1_scrollx, state->m_pf1_scrolly, state->m_pf2_scrollx, state->m_pf2_scrolly, state->m_pf3_scrollx, state->m_pf3_scrolly, state->m_pf4_scrollx, state->m_pf4_scrolly);
749		for ( sprite_voffs = 0; sprite_voffs < state->m_spriteram.bytes()/2; sprite_voffs += 4 )
	741	m_pf1_scrollx, m_pf1_scrolly, m_pf2_scrollx, m_pf2_scrolly, m_pf3_scrollx, m_pf3_scrolly, m_pf4_scrollx, m_pf4_scrolly);
	742	for ( sprite_voffs = 0; sprite_voffs < m_spriteram.bytes()/2; sprite_voffs += 4 )
750	743	{
751	744	bschar = buffered_spriteram16[sprite_voffs];
752	745	bsattr = buffered_spriteram16[sprite_voffs + 1];
r21022	r21023
763	756	}
764	757	}
765	758
766		if ( machine.input().code_pressed(KEYCODE_SLASH) )
	759	if ( machine().input().code_pressed(KEYCODE_SLASH) )
767	760	{
768		UINT16 *size  = (UINT16 *)(state->m_spritesizeram16);
769		UINT16 *bsize = (UINT16 *)(state->m_buffered_spritesizeram16);
	761	UINT16 *size  = (UINT16 *)(m_spritesizeram16);
	762	UINT16 *bsize = (UINT16 *)(m_buffered_spritesizeram16);
770	763	offs_t offs;
771		while (machine.input().code_pressed(KEYCODE_SLASH)) ;
772		if (state->m_spritesizeram16)           /* FCU controller */
	764	while (machine().input().code_pressed(KEYCODE_SLASH)) ;
	765	if (m_spritesizeram16)           /* FCU controller */
773	766	{
774	767	logerror("Scrolls    PF1-X  PF1-Y     PF2-X  PF2-Y     PF3-X  PF3-Y     PF4-X  PF4-Y\n");
775	768	logerror("------>    #%04x  #%04x     #%04x  #%04x     #%04x  #%04x     #%04x  #%04x\n",
776		state->m_pf1_scrollx, state->m_pf1_scrolly, state->m_pf2_scrollx, state->m_pf2_scrolly, state->m_pf3_scrollx, state->m_pf3_scrolly, state->m_pf4_scrollx, state->m_pf4_scrolly);
	769	m_pf1_scrollx, m_pf1_scrolly, m_pf2_scrollx, m_pf2_scrolly, m_pf3_scrollx, m_pf3_scrolly, m_pf4_scrollx, m_pf4_scrolly);
777	770	for ( offs = 0; offs < (TOAPLAN1_SPRITESIZERAM_SIZE/2); offs +=4 )
778	771	{
779	772	logerror("SizeOffs:%04x   now:%04x %04x %04x %04x    next: %04x %04x %04x %04x\n", offs,
r21022	r21023
785	778	}
786	779	}
787	780
788		if ( machine.input().code_pressed(KEYCODE_N) )
	781	if ( machine().input().code_pressed(KEYCODE_N) )
789	782	{
790	783	offs_t tile_voffs;
791	784	int tchar[5], tattr[5];
792		while (machine.input().code_pressed(KEYCODE_N)) ;   /* BCU controller */
	785	while (machine().input().code_pressed(KEYCODE_N)) ;   /* BCU controller */
793	786	logerror("Scrolls    PF1-X  PF1-Y     PF2-X  PF2-Y     PF3-X  PF3-Y     PF4-X  PF4-Y\n");
794	787	logerror("------>    #%04x  #%04x     #%04x  #%04x     #%04x  #%04x     #%04x  #%04x\n",
795		state->m_pf1_scrollx, state->m_pf1_scrolly, state->m_pf2_scrollx, state->m_pf2_scrolly, state->m_pf3_scrollx, state->m_pf3_scrolly, state->m_pf4_scrollx, state->m_pf4_scrolly);
	788	m_pf1_scrollx, m_pf1_scrolly, m_pf2_scrollx, m_pf2_scrolly, m_pf3_scrollx, m_pf3_scrolly, m_pf4_scrollx, m_pf4_scrolly);
796	789	for ( tile_voffs = 0; tile_voffs < (TOAPLAN1_TILEVRAM_SIZE/2); tile_voffs += 2 )
797	790	{
798		tchar[1] = state->m_pf1_tilevram16[tile_voffs + 1];
799		tattr[1] = state->m_pf1_tilevram16[tile_voffs];
800		tchar[2] = state->m_pf2_tilevram16[tile_voffs + 1];
801		tattr[2] = state->m_pf2_tilevram16[tile_voffs];
802		tchar[3] = state->m_pf3_tilevram16[tile_voffs + 1];
803		tattr[3] = state->m_pf3_tilevram16[tile_voffs];
804		tchar[4] = state->m_pf4_tilevram16[tile_voffs + 1];
805		tattr[4] = state->m_pf4_tilevram16[tile_voffs];
	791	tchar[1] = m_pf1_tilevram16[tile_voffs + 1];
	792	tattr[1] = m_pf1_tilevram16[tile_voffs];
	793	tchar[2] = m_pf2_tilevram16[tile_voffs + 1];
	794	tattr[2] = m_pf2_tilevram16[tile_voffs];
	795	tchar[3] = m_pf3_tilevram16[tile_voffs + 1];
	796	tattr[3] = m_pf3_tilevram16[tile_voffs];
	797	tchar[4] = m_pf4_tilevram16[tile_voffs + 1];
	798	tattr[4] = m_pf4_tilevram16[tile_voffs];
806	799	//          logerror("PF3 offs:%04x   Tile:%04x  Attr:%04x\n", tile_voffs, tchar, tattr);
807	800	logerror("$(%04x)  Attr-Tile PF1:%04x-%04x  PF2:%04x-%04x  PF3:%04x-%04x  PF4:%04x-%04x\n", tile_voffs,
808	801	tattr[1], tchar[1],  tattr[2], tchar[2],
r21022	r21023
810	803	}
811	804	}
812	805
813		if ( machine.input().code_pressed(KEYCODE_W) )
	806	if ( machine().input().code_pressed(KEYCODE_W) )
814	807	{
815		while (machine.input().code_pressed(KEYCODE_W)) ;
	808	while (machine().input().code_pressed(KEYCODE_W)) ;
816	809	logerror("Mark here\n");
817	810	}
818		if ( machine.input().code_pressed(KEYCODE_E) )
	811	if ( machine().input().code_pressed(KEYCODE_E) )
819	812	{
820		while (machine.input().code_pressed(KEYCODE_E)) ;
821		state->m_displog += 1;
822		state->m_displog &= 1;
	813	while (machine().input().code_pressed(KEYCODE_E)) ;
	814	m_displog += 1;
	815	m_displog &= 1;
823	816	}
824		if (state->m_displog)
	817	if (m_displog)
825	818	{
826	819	logerror("Scrolls    PF1-X  PF1-Y     PF2-X  PF2-Y     PF3-X  PF3-Y     PF4-X  PF4-Y\n");
827	820	logerror("------>    #%04x  #%04x     #%04x  #%04x     #%04x  #%04x     #%04x  #%04x\n",
828		state->m_pf1_scrollx, state->m_pf1_scrolly, state->m_pf2_scrollx, state->m_pf2_scrolly, state->m_pf3_scrollx, state->m_pf3_scrolly, state->m_pf4_scrollx, state->m_pf4_scrolly);
	821	m_pf1_scrollx, m_pf1_scrolly, m_pf2_scrollx, m_pf2_scrolly, m_pf3_scrollx, m_pf3_scrolly, m_pf4_scrollx, m_pf4_scrolly);
829	822	}
830		if ( machine.input().code_pressed(KEYCODE_B) )
	823	if ( machine().input().code_pressed(KEYCODE_B) )
831	824	{
832		//      while (machine.input().code_pressed(KEYCODE_B)) ;
833		state->m_scrollx_offs1 += 0x1; state->m_scrollx_offs2 += 0x1; state->m_scrollx_offs3 += 0x1; state->m_scrollx_offs4 += 0x1;
834		logerror("Scrollx_offs now = %08x\n", state->m_scrollx_offs4);
835		state->m_pf1_tilemap->set_scrollx(0, (state->m_pf1_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs1));
836		state->m_pf2_tilemap->set_scrollx(0, (state->m_pf2_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs2));
837		state->m_pf3_tilemap->set_scrollx(0, (state->m_pf3_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs3));
838		state->m_pf4_tilemap->set_scrollx(0, (state->m_pf4_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs4));
	825	//      while (machine().input().code_pressed(KEYCODE_B)) ;
	826	m_scrollx_offs1 += 0x1; m_scrollx_offs2 += 0x1; m_scrollx_offs3 += 0x1; m_scrollx_offs4 += 0x1;
	827	logerror("Scrollx_offs now = %08x\n", m_scrollx_offs4);
	828	m_pf1_tilemap->set_scrollx(0, (m_pf1_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs1));
	829	m_pf2_tilemap->set_scrollx(0, (m_pf2_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs2));
	830	m_pf3_tilemap->set_scrollx(0, (m_pf3_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs3));
	831	m_pf4_tilemap->set_scrollx(0, (m_pf4_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs4));
839	832	}
840		if ( machine.input().code_pressed(KEYCODE_V) )
	833	if ( machine().input().code_pressed(KEYCODE_V) )
841	834	{
842		//      while (machine.input().code_pressed(KEYCODE_V)) ;
843		state->m_scrollx_offs1 -= 0x1; state->m_scrollx_offs2 -= 0x1; state->m_scrollx_offs3 -= 0x1; state->m_scrollx_offs4 -= 0x1;
844		logerror("Scrollx_offs now = %08x\n", state->m_scrollx_offs4);
845		state->m_pf1_tilemap->set_scrollx(0, (state->m_pf1_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs1));
846		state->m_pf2_tilemap->set_scrollx(0, (state->m_pf2_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs2));
847		state->m_pf3_tilemap->set_scrollx(0, (state->m_pf3_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs3));
848		state->m_pf4_tilemap->set_scrollx(0, (state->m_pf4_scrollx >> 7) - (state->m_tiles_offsetx - state->m_scrollx_offs4));
	835	//      while (machine().input().code_pressed(KEYCODE_V)) ;
	836	m_scrollx_offs1 -= 0x1; m_scrollx_offs2 -= 0x1; m_scrollx_offs3 -= 0x1; m_scrollx_offs4 -= 0x1;
	837	logerror("Scrollx_offs now = %08x\n", m_scrollx_offs4);
	838	m_pf1_tilemap->set_scrollx(0, (m_pf1_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs1));
	839	m_pf2_tilemap->set_scrollx(0, (m_pf2_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs2));
	840	m_pf3_tilemap->set_scrollx(0, (m_pf3_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs3));
	841	m_pf4_tilemap->set_scrollx(0, (m_pf4_scrollx >> 7) - (m_tiles_offsetx - m_scrollx_offs4));
849	842	}
850		if ( machine.input().code_pressed(KEYCODE_C) )
	843	if ( machine().input().code_pressed(KEYCODE_C) )
851	844	{
852		//      while (machine.input().code_pressed(KEYCODE_C)) ;
853		state->m_scrolly_offs += 0x1;
854		logerror("Scrolly_offs now = %08x\n", state->m_scrolly_offs);
855		state->m_pf1_tilemap->set_scrolly(0, (state->m_pf1_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
856		state->m_pf2_tilemap->set_scrolly(0, (state->m_pf2_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
857		state->m_pf3_tilemap->set_scrolly(0, (state->m_pf3_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
858		state->m_pf4_tilemap->set_scrolly(0, (state->m_pf4_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
	845	//      while (machine().input().code_pressed(KEYCODE_C)) ;
	846	m_scrolly_offs += 0x1;
	847	logerror("Scrolly_offs now = %08x\n", m_scrolly_offs);
	848	m_pf1_tilemap->set_scrolly(0, (m_pf1_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	849	m_pf2_tilemap->set_scrolly(0, (m_pf2_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	850	m_pf3_tilemap->set_scrolly(0, (m_pf3_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	851	m_pf4_tilemap->set_scrolly(0, (m_pf4_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
859	852	}
860		if ( machine.input().code_pressed(KEYCODE_X) )
	853	if ( machine().input().code_pressed(KEYCODE_X) )
861	854	{
862		//      while (machine.input().code_pressed(KEYCODE_X)) ;
863		state->m_scrolly_offs -= 0x1;
864		logerror("Scrolly_offs now = %08x\n", state->m_scrolly_offs);
865		state->m_pf1_tilemap->set_scrolly(0, (state->m_pf1_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
866		state->m_pf2_tilemap->set_scrolly(0, (state->m_pf2_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
867		state->m_pf3_tilemap->set_scrolly(0, (state->m_pf3_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
868		state->m_pf4_tilemap->set_scrolly(0, (state->m_pf4_scrolly >> 7) - (state->m_tiles_offsety - state->m_scrolly_offs));
	855	//      while (machine().input().code_pressed(KEYCODE_X)) ;
	856	m_scrolly_offs -= 0x1;
	857	logerror("Scrolly_offs now = %08x\n", m_scrolly_offs);
	858	m_pf1_tilemap->set_scrolly(0, (m_pf1_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	859	m_pf2_tilemap->set_scrolly(0, (m_pf2_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	860	m_pf3_tilemap->set_scrolly(0, (m_pf3_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
	861	m_pf4_tilemap->set_scrolly(0, (m_pf4_scrolly >> 7) - (m_tiles_offsety - m_scrolly_offs));
869	862	}
870	863
871		if ( machine.input().code_pressed(KEYCODE_L) )      /* Turn Playfield 4 on/off */
	864	if ( machine().input().code_pressed(KEYCODE_L) )      /* Turn Playfield 4 on/off */
872	865	{
873		while (machine.input().code_pressed(KEYCODE_L)) ;
874		state->m_display_pf4 += 1;
875		state->m_display_pf4 &= 1;
876		state->m_pf4_tilemap->enable(state->m_display_pf4);
	866	while (machine().input().code_pressed(KEYCODE_L)) ;
	867	m_display_pf4 += 1;
	868	m_display_pf4 &= 1;
	869	m_pf4_tilemap->enable(m_display_pf4);
877	870	}
878		if ( machine.input().code_pressed(KEYCODE_K) )      /* Turn Playfield 3 on/off */
	871	if ( machine().input().code_pressed(KEYCODE_K) )      /* Turn Playfield 3 on/off */
879	872	{
880		while (machine.input().code_pressed(KEYCODE_K)) ;
881		state->m_display_pf3 += 1;
882		state->m_display_pf3 &= 1;
883		state->m_pf3_tilemap->enable(state->m_display_pf3);
	873	while (machine().input().code_pressed(KEYCODE_K)) ;
	874	m_display_pf3 += 1;
	875	m_display_pf3 &= 1;
	876	m_pf3_tilemap->enable(m_display_pf3);
884	877	}
885		if ( machine.input().code_pressed(KEYCODE_J) )      /* Turn Playfield 2 on/off */
	878	if ( machine().input().code_pressed(KEYCODE_J) )      /* Turn Playfield 2 on/off */
886	879	{
887		while (machine.input().code_pressed(KEYCODE_J)) ;
888		state->m_display_pf2 += 1;
889		state->m_display_pf2 &= 1;
890		state->m_pf2_tilemap->enable(state->m_display_pf2);
	880	while (machine().input().code_pressed(KEYCODE_J)) ;
	881	m_display_pf2 += 1;
	882	m_display_pf2 &= 1;
	883	m_pf2_tilemap->enable(m_display_pf2);
891	884	}
892		if ( machine.input().code_pressed(KEYCODE_H) )      /* Turn Playfield 1 on/off */
	885	if ( machine().input().code_pressed(KEYCODE_H) )      /* Turn Playfield 1 on/off */
893	886	{
894		while (machine.input().code_pressed(KEYCODE_H)) ;
895		state->m_display_pf1 += 1;
896		state->m_display_pf1 &= 1;
897		state->m_pf1_tilemap->enable(state->m_display_pf1);
	887	while (machine().input().code_pressed(KEYCODE_H)) ;
	888	m_display_pf1 += 1;
	889	m_display_pf1 &= 1;
	890	m_pf1_tilemap->enable(m_display_pf1);
898	891	}
899	892	#endif
900	893	}
r21022	r21023
1002	995	}
1003	996
1004	997
1005		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	998	void toaplan1_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
1006	999	{
1007		toaplan1_state *state = machine.driver_data<toaplan1_state>();
1008		UINT16 *source = (UINT16 *)state->m_buffered_spriteram;
1009		UINT16 *size   = (UINT16 *)state->m_buffered_spritesizeram16;
1010		int fcu_flipscreen = state->m_fcu_flipscreen;
	1000	UINT16 *source = (UINT16 *)m_buffered_spriteram;
	1001	UINT16 *size   = (UINT16 *)m_buffered_spritesizeram16;
	1002	int fcu_flipscreen = m_fcu_flipscreen;
1011	1003	int offs;
1012	1004
1013		for (offs = state->m_spriteram.bytes()/2 - 4; offs >= 0; offs -= 4)
	1005	for (offs = m_spriteram.bytes()/2 - 4; offs >= 0; offs -= 4)
1014	1006	{
1015	1007	if (!(source[offs] & 0x8000))
1016	1008	{
r21022	r21023
1039	1031	/****** flip the sprite layer ******/
1040	1032	if (fcu_flipscreen)
1041	1033	{
1042		const rectangle &visarea = machine.primary_screen->visible_area();
	1034	const rectangle &visarea = machine().primary_screen->visible_area();
1043	1035
1044	1036	sx_base = visarea.width() - (sx_base + 8);  /* visarea.x = 320 */
1045	1037	sy_base = visarea.height() - (sy_base + 8); /* visarea.y = 240 */
r21022	r21023
1056	1048	if (fcu_flipscreen) sx = sx_base - dim_x;
1057	1049	else                sx = sx_base + dim_x;
1058	1050
1059		toaplan1_draw_sprite_custom(bitmap,cliprect,machine.gfx[1],
	1051	toaplan1_draw_sprite_custom(bitmap,cliprect,machine().gfx[1],
1060	1052	sprite,color,
1061	1053	fcu_flipscreen,fcu_flipscreen,
1062	1054	sx,sy,
r21022	r21023
1070	1062	}
1071	1063
1072	1064
1073		static void rallybik_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
	1065	void toaplan1_state::rallybik_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority )
1074	1066	{
1075		toaplan1_state *state = machine.driver_data<toaplan1_state>();
1076		UINT16 *buffered_spriteram16 = state->m_buffered_spriteram;
	1067	UINT16 *buffered_spriteram16 = m_buffered_spriteram;
1077	1068	int offs;
1078	1069
1079		for (offs = 0; offs < state->m_spriteram.bytes()/2; offs += 4)
	1070	for (offs = 0; offs < m_spriteram.bytes()/2; offs += 4)
1080	1071	{
1081	1072	int attrib, sx, sy, flipx, flipy;
1082	1073	int sprite, color;
r21022	r21023
1093	1084	flipx = attrib & 0x100;
1094	1085	if (flipx) sx -= 15;
1095	1086	flipy = attrib & 0x200;
1096		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	1087	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
1097	1088	sprite,
1098	1089	color,
1099	1090	flipx,flipy,
r21022	r21023
1112	1103	{
1113	1104	int priority;
1114	1105
1115		toaplan1_log_vram(machine());
	1106	toaplan1_log_vram();
1116	1107
1117	1108	bitmap.fill(0x120, cliprect);
1118	1109
r21022	r21023
1125	1116	m_pf3_tilemap->draw(bitmap, cliprect, priority, 0);
1126	1117	m_pf2_tilemap->draw(bitmap, cliprect, priority, 0);
1127	1118	m_pf1_tilemap->draw(bitmap, cliprect, priority, 0);
1128		rallybik_draw_sprites(machine(), bitmap,cliprect,priority << 8);
	1119	rallybik_draw_sprites(bitmap,cliprect,priority << 8);
1129	1120	}
1130	1121
1131	1122	return 0;
r21022	r21023
1135	1126	{
1136	1127	int priority;
1137	1128
1138		toaplan1_log_vram(machine());
	1129	toaplan1_log_vram();
1139	1130
1140	1131	machine().priority_bitmap.fill(0, cliprect);
1141	1132	bitmap.fill(0x120, cliprect);
r21022	r21023
1152	1143	m_pf1_tilemap->draw(bitmap, cliprect, priority, priority, 0);
1153	1144	}
1154	1145
1155		draw_sprites(machine(), bitmap, cliprect);
	1146	draw_sprites(bitmap, cliprect);
1156	1147	return 0;
1157	1148	}
1158	1149

trunk/src/mame/video/tank8.c

r21022	r21023
34	34	}
35	35
36	36
37		static void set_pens(tank8_state *state, colortable_t *colortable)
	37	void tank8_state::set_pens(colortable_t *colortable)
38	38	{
39		if (*state->m_team & 0x01)
	39	if (*m_team & 0x01)
40	40	{
41	41	colortable_palette_set_color(colortable, 0, MAKE_RGB(0xff, 0x00, 0x00)); /* red     */
42	42	colortable_palette_set_color(colortable, 1, MAKE_RGB(0x00, 0x00, 0xff)); /* blue    */
r21022	r21023
113	113	}
114	114
115	115
116		static int get_x_pos(tank8_state *state, int n)
	116	int tank8_state::get_x_pos(int n)
117	117	{
118		return 498 - state->m_pos_h_ram[n] - 2 * (state->m_pos_d_ram[n] & 128); /* ? */
	118	return 498 - m_pos_h_ram[n] - 2 * (m_pos_d_ram[n] & 128); /* ? */
119	119	}
120	120
121	121
122		static int get_y_pos(tank8_state *state, int n)
	122	int tank8_state::get_y_pos(int n)
123	123	{
124		return 2 * state->m_pos_v_ram[n] - 62;
	124	return 2 * m_pos_v_ram[n] - 62;
125	125	}
126	126
127	127
128		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	128	void tank8_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
129	129	{
130		tank8_state *state = machine.driver_data<tank8_state>();
131	130	int i;
132	131
133	132	for (i = 0; i < 8; i++)
134	133	{
135		UINT8 code = ~state->m_pos_d_ram[i];
	134	UINT8 code = ~m_pos_d_ram[i];
136	135
137		int x = get_x_pos(state, i);
138		int y = get_y_pos(state, i);
	136	int x = get_x_pos(i);
	137	int y = get_y_pos(i);
139	138
140		drawgfx_transpen(bitmap, cliprect, machine.gfx[(code & 0x04) ? 2 : 3],
	139	drawgfx_transpen(bitmap, cliprect, machine().gfx[(code & 0x04) ? 2 : 3],
141	140	code & 0x03,
142	141	i,
143	142	code & 0x10,
r21022	r21023
148	147	}
149	148
150	149
151		static void draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	150	void tank8_state::draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect)
152	151	{
153		tank8_state *state = machine.driver_data<tank8_state>();
154	152	int i;
155	153
156	154	for (i = 0; i < 8; i++)
157	155	{
158		int x = get_x_pos(state, 8 + i);
159		int y = get_y_pos(state, 8 + i);
	156	int x = get_x_pos(8 + i);
	157	int y = get_y_pos(8 + i);
160	158
161	159	x -= 4; /* ? */
162	160
r21022	r21023
170	168
171	169	TIMER_CALLBACK_MEMBER(tank8_state::tank8_collision_callback)
172	170	{
173		tank8_set_collision(machine(), param);
	171	tank8_set_collision(param);
174	172	}
175	173
176	174
177	175	UINT32 tank8_state::screen_update_tank8(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
178	176	{
179		set_pens(this, machine().colortable);
	177	set_pens(machine().colortable);
180	178	m_tilemap->draw(bitmap, cliprect, 0, 0);
181	179
182		draw_sprites(machine(), bitmap, cliprect);
183		draw_bullets(machine(), bitmap, cliprect);
	180	draw_sprites(bitmap, cliprect);
	181	draw_bullets(bitmap, cliprect);
184	182	return 0;
185	183	}
186	184
r21022	r21023
199	197	m_helper2.fill(8, visarea);
200	198	m_helper3.fill(8, visarea);
201	199
202		draw_sprites(machine(), m_helper2, visarea);
203		draw_bullets(machine(), m_helper3, visarea);
	200	draw_sprites(m_helper2, visarea);
	201	draw_bullets(m_helper3, visarea);
204	202
205	203	for (y = visarea.min_y; y <= visarea.max_y; y++)
206	204	{
r21022	r21023
262	260	if (p1[x] == 0x11)
263	261	index |= 0x20;
264	262
265		if (y - get_y_pos(this, sprite_num) >= 8)
	263	if (y - get_y_pos(sprite_num) >= 8)
266	264	index |= 0x40; /* collision on bottom side */
267	265
268		if (x - get_x_pos(this, sprite_num) >= 8)
	266	if (x - get_x_pos(sprite_num) >= 8)
269	267	index |= 0x80; /* collision on right side */
270	268	}
271	269

trunk/src/mame/video/tehkanwc.c

r21022	r21023
113	113	bit 7 = enable (0 = display off)
114	114	*/
115	115
116		static void gridiron_draw_led(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 led,int player)
	116	void tehkanwc_state::gridiron_draw_led(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 led,int player)
117	117	{
118	118	if (led&0x80)
119	119	output_set_digit_value(player, led&0x7f);
r21022	r21023
121	121	output_set_digit_value(player, 0x00);
122	122	}
123	123
124		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	124	void tehkanwc_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
125	125	{
126		tehkanwc_state *state = machine.driver_data<tehkanwc_state>();
127		UINT8 *spriteram = state->m_spriteram;
	126	UINT8 *spriteram = m_spriteram;
128	127	int offs;
129	128
130		for (offs = 0;offs < state->m_spriteram.bytes();offs += 4)
	129	for (offs = 0;offs < m_spriteram.bytes();offs += 4)
131	130	{
132	131	int attr = spriteram[offs + 1];
133	132	int code = spriteram[offs] + ((attr & 0x08) << 5);
r21022	r21023
137	136	int sx = spriteram[offs + 2] + ((attr & 0x20) << 3) - 128;
138	137	int sy = spriteram[offs + 3];
139	138
140		if (state->flip_screen_x())
	139	if (flip_screen_x())
141	140	{
142	141	sx = 240 - sx;
143	142	flipx = !flipx;
144	143	}
145	144
146		if (state->flip_screen_y())
	145	if (flip_screen_y())
147	146	{
148	147	sy = 240 - sy;
149	148	flipy = !flipy;
150	149	}
151	150
152		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	151	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
153	152	code, color, flipx, flipy, sx, sy, 0);
154	153	}
155	154	}
r21022	r21023
159	158	m_bg_tilemap->set_scrollx(0, m_scroll_x[0] + 256 * m_scroll_x[1]);
160	159	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
161	160	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
162		draw_sprites(machine(), bitmap, cliprect);
	161	draw_sprites(bitmap, cliprect);
163	162	m_fg_tilemap->draw(bitmap, cliprect, 1, 0);
164		gridiron_draw_led(machine(), bitmap, cliprect, m_led0, 0);
165		gridiron_draw_led(machine(), bitmap, cliprect, m_led1, 1);
	163	gridiron_draw_led(bitmap, cliprect, m_led0, 0);
	164	gridiron_draw_led(bitmap, cliprect, m_led1, 1);
166	165	return 0;
167	166	}

trunk/src/mame/video/taitojc.c

r21022	r21023
110	110
111	111	*/
112	112
113		static void draw_object(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 w1, UINT32 w2, UINT8 bank_type)
	113	void taitojc_state::draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 w1, UINT32 w2, UINT8 bank_type)
114	114	{
115		taitojc_state *state = machine.driver_data<taitojc_state>();
116	115	int x, y, width, height, palette;
117	116	int i, j;
118	117	int x1, x2, y1, y2;
r21022	r21023
143	142
144	143	/* TODO: untangle this! */
145	144	if(address >= 0xff000)
146		v = (UINT8*)&state->m_objlist[(address-0xff000)/4];
	145	v = (UINT8*)&m_objlist[(address-0xff000)/4];
147	146	if(address >= 0xfc000)
148		v = (UINT8*)&state->m_char_ram[(address-0xfc000)/4];
	147	v = (UINT8*)&m_char_ram[(address-0xfc000)/4];
149	148	else if(address >= 0xf8000)
150		v = (UINT8*)&state->m_tile_ram[(address-0xf8000)/4];
	149	v = (UINT8*)&m_tile_ram[(address-0xf8000)/4];
151	150	else
152		v = (UINT8*)&state->m_vram[address/4];
	151	v = (UINT8*)&m_vram[address/4];
153	152
154	153	/* guess, but it's probably doable via a vreg ... */
155	154	if ((width == 0 || height == 0) && bank_type == 2)
r21022	r21023
265	264	}
266	265	}
267	266
268		static void draw_object_bank(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 bank_type, UINT8 pri)
	267	void taitojc_state::draw_object_bank(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 bank_type, UINT8 pri)
269	268	{
270		taitojc_state *state = machine.driver_data<taitojc_state>();
271	269	UINT16 start_offs;
272	270	//  UINT8 double_xy;
273	271	int i;
274	272
275	273	start_offs = ((bank_type+1)*0x400)/4;
276		//  double_xy = (state->m_objlist[(0xd1c+bank_type*0x10)/4] & 0x20000000) >> 29;
	274	//  double_xy = (m_objlist[(0xd1c+bank_type*0x10)/4] & 0x20000000) >> 29;
277	275
278	276	/* probably a core bug in there (otherwise objects sticks on screen in Densha de Go) */
279		if(bank_type == 1 && (!(state->m_objlist[0xfc4/4] & 0x2000)))
	277	if(bank_type == 1 && (!(m_objlist[0xfc4/4] & 0x2000)))
280	278	return;
281	279
282	280	for (i=start_offs-2; i >= (start_offs-0x400/4); i-=2)
283	281	{
284		UINT32 w1 = state->m_objlist[i + 0];
285		UINT32 w2 = state->m_objlist[i + 1];
	282	UINT32 w1 = m_objlist[i + 0];
	283	UINT32 w2 = m_objlist[i + 1];
286	284
287	285	if (((w2 & 0x200000) >> 21) == pri)
288	286	{
289		draw_object(machine, bitmap, cliprect, w1, w2, bank_type);
	287	draw_object(bitmap, cliprect, w1, w2, bank_type);
290	288	}
291	289	}
292	290	}
r21022	r21023
325	323	bitmap.fill(0, cliprect);
326	324
327	325	// low priority objects
328		draw_object_bank(machine(), bitmap, cliprect, 0, 0);
329		draw_object_bank(machine(), bitmap, cliprect, 1, 0);
330		draw_object_bank(machine(), bitmap, cliprect, 2, 0);
	326	draw_object_bank(bitmap, cliprect, 0, 0);
	327	draw_object_bank(bitmap, cliprect, 1, 0);
	328	draw_object_bank(bitmap, cliprect, 2, 0);
331	329
332	330	// 3D layer
333	331	copybitmap_trans(bitmap, m_framebuffer, 0, 0, 0, 0, cliprect, 0);
334	332
335	333	// high priority objects
336		draw_object_bank(machine(), bitmap, cliprect, 0, 1);
337		draw_object_bank(machine(), bitmap, cliprect, 1, 1);
338		draw_object_bank(machine(), bitmap, cliprect, 2, 1);
	334	draw_object_bank(bitmap, cliprect, 0, 1);
	335	draw_object_bank(bitmap, cliprect, 1, 1);
	336	draw_object_bank(bitmap, cliprect, 2, 1);
339	337
340	338	// text layer
341	339	if (m_objlist[0xfc4/4] & 0x10000)
r21022	r21023
753	751	wait("Finished render");
754	752	}
755	753
756		void taitojc_clear_frame(running_machine &machine)
	754	void taitojc_state::taitojc_clear_frame()
757	755	{
758		taitojc_state *state = machine.driver_data<taitojc_state>();
759	756
760		state->m_framebuffer.fill(0, machine.primary_screen->visible_area());
761		state->m_zbuffer.fill(0xffff, machine.primary_screen->visible_area());
	757	m_framebuffer.fill(0, machine().primary_screen->visible_area());
	758	m_zbuffer.fill(0xffff, machine().primary_screen->visible_area());
762	759	}

trunk/src/mame/includes/targeth.h

r21022	r21023
22	22	virtual void video_start();
23	23	UINT32 screen_update_targeth(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
24	24	TIMER_DEVICE_CALLBACK_MEMBER(targeth_interrupt);
	25	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
25	26	};

trunk/src/mame/includes/tunhunt.h

r21022	r21023
25	25	virtual void video_start();
26	26	virtual void palette_init();
27	27	UINT32 screen_update_tunhunt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	28	void set_pens();
	29	void draw_motion_object(bitmap_ind16 &bitmap, const rectangle &cliprect);
	30	void draw_box(bitmap_ind16 &bitmap, const rectangle &cliprect);
	31	void draw_shell(bitmap_ind16 &bitmap, const rectangle &cliprect, int picture_code,
	32	int hposition,int vstart,int vstop,int vstretch,int hstretch);
28	33	};

trunk/src/mame/includes/toaplan1.h

r21022	r21023
147	147	void rallybik_flipscreen();
148	148	void toaplan1_flipscreen();
149	149	void demonwld_restore_dsp();
	150	void toaplan1_create_tilemaps();
	151	void toaplan1_paletteram_alloc();
	152	void toaplan1_vram_alloc();
	153	void toaplan1_spritevram_alloc();
	154	void toaplan1_set_scrolls();
	155	void register_common();
	156	void toaplan1_log_vram();
	157	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
	158	void rallybik_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	159	void demonwld_dsp(int enable);
	160	void toaplan1_driver_savestate();
	161	void demonwld_driver_savestate();
	162	void vimana_driver_savestate();
150	163	};
151	164
152	165

trunk/src/mame/includes/tehkanwc.h

r21022	r21023
48	48	virtual void video_start();
49	49	UINT32 screen_update_tehkanwc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50	50	TIMER_CALLBACK_MEMBER(reset_callback);
	51	void gridiron_draw_led(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 led,int player);
	52	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
51	53	};

trunk/src/mame/includes/toypop.h

r21022	r21023
54	54	INTERRUPT_GEN_MEMBER(toypop_sound_timer_irq);
55	55	INTERRUPT_GEN_MEMBER(toypop_m68000_interrupt);
56	56	TIMER_CALLBACK_MEMBER(namcoio_run);
	57	void draw_background(bitmap_ind16 &bitmap);
	58	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base);
57	59	};

trunk/src/mame/includes/taito_o.h

r21022	r21023
21	21	virtual void machine_start();
22	22	UINT32 screen_update_parentj(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
23	23	TIMER_DEVICE_CALLBACK_MEMBER(parentj_interrupt);
	24	void parentj_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
24	25	};

trunk/src/mame/includes/toaplan2.h

r21022	r21023
133	133	INTERRUPT_GEN_MEMBER(bbakraid_snd_interrupt);
134	134	TIMER_CALLBACK_MEMBER(toaplan2_raise_irq);
135	135	void truxton2_postload();
	136	void truxton2_create_tx_tilemap();
	137	void register_state_save();
	138	void toaplan2_vblank_irq(int irq_line);
136	139	};

trunk/src/mame/includes/tankbust.h

r21022	r21023
46	46	INTERRUPT_GEN_MEMBER(vblank_irq);
47	47	TIMER_CALLBACK_MEMBER(soundlatch_callback);
48	48	TIMER_CALLBACK_MEMBER(soundirqline_callback);
	49	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
49	50	};

trunk/src/mame/includes/tetrisp2.h

r21022	r21023
114	114	TIMER_CALLBACK_MEMBER(rockn_timer_sub_level4_callback);
115	115	TIMER_CALLBACK_MEMBER(rockn_timer_level1_callback);
116	116	TIMER_CALLBACK_MEMBER(rockn_timer_sub_level1_callback);
	117	void init_rockn_timer();
117	118	};
118	119
119	120	class stepstag_state : public tetrisp2_state
r21022	r21023
136	137	UINT32 screen_update_stepstag_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
137	138	UINT32 screen_update_stepstag_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
138	139	UINT32 screen_update_stepstag_mid(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	140	inline int mypal(int x);
139	141	};

trunk/src/mame/includes/taitoair.h

r21022	r21023
84	84	virtual void video_start();
85	85	UINT32 screen_update_taitoair(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
86	86	void reset_sound_region();
	87	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	88	void fill_slope( bitmap_ind16 &bitmap, const rectangle &cliprect, int color, INT32 x1, INT32 x2, INT32 sl1, INT32 sl2, INT32 y1, INT32 y2, INT32 *nx1, INT32 *nx2 );
	89	void multVecMtx(const INT16* vec4, const float* m, float* result);
	90	void airInfernoFrustum(const INT16 leftExtent, const INT16 bottomExtent, float* m);
	91	void fill_poly( bitmap_ind16 &bitmap, const rectangle &cliprect, const struct taitoair_poly *q );
	92	int projectEyeCoordToScreen(float* projectionMatrix,const int Res,INT16* eyePoint3d,int type);
87	93	};

trunk/src/mame/includes/turbo.h

r21022	r21023
92	92	UINT8       m_buckrog_myship;
93	93	int m_last_sound_a;
94	94
	95	struct sprite_info
	96	{
	97	UINT16  ve;                 /* VE0-15 signals for this row */
	98	UINT8   lst;                /* LST0-7 signals for this row */
	99	UINT32  latched[8];         /* latched pixel data */
	100	UINT8   plb[8];             /* latched PLB state */
	101	UINT32  offset[8];          /* current offset for this row */
	102	UINT32  frac[8];            /* leftover fraction */
	103	UINT32  step[8];            /* stepping value */
	104	};
	105
95	106	DECLARE_WRITE8_MEMBER(scanlines_w);
96	107	DECLARE_WRITE8_MEMBER(digit_w);
97	108	DECLARE_READ8_MEMBER(turbo_collision_r);
r21022	r21023
140	151	DECLARE_WRITE8_MEMBER(subroc3d_sound_c_w);
141	152	DECLARE_WRITE8_MEMBER(buckrog_sound_a_w);
142	153	DECLARE_WRITE8_MEMBER(buckrog_sound_b_w);
	154	inline UINT32 sprite_xscale(UINT8 dacinput, double vr1, double vr2, double cext);
	155	void turbo_prepare_sprites(UINT8 y, sprite_info *info);
	156	UINT32 turbo_get_sprite_bits(const UINT8 *sprite_gfxdata, UINT8 road, sprite_info *sprinfo);
	157	void subroc3d_prepare_sprites(UINT8 y, sprite_info *info);
	158	UINT32 subroc3d_get_sprite_bits(const UINT8 *sprite_gfxdata, sprite_info *sprinfo, UINT8 *plb);
	159	void buckrog_prepare_sprites(UINT8 y, sprite_info *info);
	160	UINT32 buckrog_get_sprite_bits(const UINT8 *sprite_gfxdata, sprite_info *sprinfo, UINT8 *plb);
	161	void turbo_rom_decode();
143	162	};
144	163
145	164

trunk/src/mame/includes/thoop2.h

r21022	r21023
21	21	TILE_GET_INFO_MEMBER(get_tile_info_thoop2_screen1);
22	22	virtual void video_start();
23	23	UINT32 screen_update_thoop2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	24	void thoop2_sort_sprites();
	25	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri);
24	26	};

trunk/src/mame/includes/taito_b.h

r21022	r21023
95	95	TIMER_CALLBACK_MEMBER(selfeena_interrupt4);
96	96	TIMER_CALLBACK_MEMBER(sbm_interrupt5);
97	97	TIMER_CALLBACK_MEMBER(realpunc_interrupt3);
	98	void hitice_clear_pixel_bitmap(  );
	99	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	100	void draw_framebuffer( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	101	void ryujin_patch(void);
	102	void sbm_patch(void);
98	103	};

trunk/src/mame/includes/timelimt.h

r21022	r21023
30	30	virtual void palette_init();
31	31	UINT32 screen_update_timelimt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
32	32	INTERRUPT_GEN_MEMBER(timelimt_irq);
	33	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
33	34	};

trunk/src/mame/includes/twin16.h

r21022	r21023
66	66	INTERRUPT_GEN_MEMBER(CPUA_interrupt);
67	67	INTERRUPT_GEN_MEMBER(CPUB_interrupt);
68	68	TIMER_CALLBACK_MEMBER(twin16_sprite_tick);
	69	int twin16_set_sprite_timer(  );
	70	void twin16_spriteram_process(  );
	71	void draw_sprites( bitmap_ind16 &bitmap );
	72	void draw_layer( bitmap_ind16 &bitmap, int opaque );
	73	int twin16_spriteram_process_enable(  );
	74	void gfx_untangle(  );
69	75	};
70	76
71	77	/*----------- defined in drivers/twin16.c -----------*/

trunk/src/mame/includes/tmnt.h

r21022	r21023
145	145	INTERRUPT_GEN_MEMBER(lgtnfght_interrupt);
146	146	INTERRUPT_GEN_MEMBER(tmnt_vblank_irq);
147	147	TIMER_CALLBACK_MEMBER(nmi_callback);
	148	void sound_nmi_callback( int param );
	149	inline UINT32 tmnt2_get_word( UINT32 addr );
	150	void tmnt2_put_word( address_space &space, UINT32 addr, UINT16 data );
148	151	};
149	152
150	153

trunk/src/mame/includes/tail2nos.h

r21022	r21023
40	40	virtual void video_start();
41	41	UINT32 screen_update_tail2nos(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
42	42	void tail2nos_postload();
	43	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
43	44	};
44	45
45	46	/*----------- defined in video/tail2nos.c -----------*/

trunk/src/mame/includes/tryout.h

r21022	r21023
35	35	virtual void video_start();
36	36	virtual void palette_init();
37	37	UINT32 screen_update_tryout(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	38	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
38	39	};

trunk/src/mame/includes/tsamurai.h

r21022	r21023
61	61	UINT32 screen_update_vsgongf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
62	62	INTERRUPT_GEN_MEMBER(samurai_interrupt);
63	63	INTERRUPT_GEN_MEMBER(vsgongf_sound_interrupt);
	64	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
64	65	};

trunk/src/mame/includes/taitojc.h

r21022	r21023
162	162	UINT32 screen_update_taitojc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
163	163	UINT32 screen_update_dendego(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
164	164	INTERRUPT_GEN_MEMBER(taitojc_vblank);
	165	void draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 w1, UINT32 w2, UINT8 bank_type);
	166	void draw_object_bank(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 bank_type, UINT8 pri);
	167	void taitojc_clear_frame();
	168	void debug_dsp_command();
	169	UINT8 mcu_comm_reg_r(address_space &space, int reg);
	170	void mcu_comm_reg_w(address_space &space, int reg, UINT8 data);
165	171	};
166	172
167	173

trunk/src/mame/includes/tecmosys.h

r21022	r21023
82	82	UINT32 screen_update_tecmosys(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
83	83	void tecmosys_prot_init(int which);
84	84	void tecmosys_prot_reset();
	85	inline void set_color_555_tecmo(pen_t color, int rshift, int gshift, int bshift, UINT16 data);
	86	void tecmosys_render_sprites_to_bitmap(bitmap_rgb32 &bitmap, UINT16 extrax, UINT16 extray );
	87	void tecmosys_tilemap_copy_to_compose(UINT16 pri);
	88	void tecmosys_do_final_mix(bitmap_rgb32 &bitmap);
	89	void tecmosys_descramble();
85	90	};

trunk/src/mame/includes/topspeed.h

r21022	r21023
61	61	TIMER_CALLBACK_MEMBER(topspeed_cpub_interrupt6);
62	62	DECLARE_WRITE8_MEMBER(topspeed_tc0140syt_comm_w);
63	63	void topspeed_postload();
	64	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	65	void parse_control(  )   /* assumes Z80 sandwiched between 68Ks */;
	66	void reset_sound_region(  );
64	67	};

trunk/src/mame/includes/thunderx.h

r21022	r21023
53	53	UINT32 screen_update_scontra(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
54	54	INTERRUPT_GEN_MEMBER(scontra_interrupt);
55	55	TIMER_CALLBACK_MEMBER(thunderx_firq_callback);
	56	void run_collisions( int s0, int e0, int s1, int e1, int cm, int hm );
	57	void calculate_collisions(  );
56	58	};
57	59
58	60

trunk/src/mame/includes/tceptor.h

r21022	r21023
67	67	INTERRUPT_GEN_MEMBER(m6809_vb_interrupt);
68	68	INTERRUPT_GEN_MEMBER(m68k_vb_interrupt);
69	69	INTERRUPT_GEN_MEMBER(mcu_vb_interrupt);
	70	inline int get_tile_addr(int tile_index);
	71	void decode_bg(const char * region);
	72	void decode_sprite(int gfx_index, const gfx_layout *layout, const void *data);
	73	void decode_sprite16(const char * region);
	74	void decode_sprite32(const char * region);
	75	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int sprite_priority);
	76	inline UINT8 fix_input0(UINT8 in1, UINT8 in2);
	77	inline UINT8 fix_input1(UINT8 in1, UINT8 in2);
70	78	};

trunk/src/mame/includes/tigeroad.h

r21022	r21023
28	28	TILEMAP_MAPPER_MEMBER(tigeroad_tilemap_scan);
29	29	virtual void video_start();
30	30	UINT32 screen_update_tigeroad(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	31	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	32	void f1dream_protection_w(address_space &space);
31	33	};

trunk/src/mame/includes/tnzs.h

r21022	r21023
101	101	INTERRUPT_GEN_MEMBER(arknoid2_interrupt);
102	102	TIMER_CALLBACK_MEMBER(kludge_callback);
103	103	void tnzs_postload();
	104	void mcu_reset(  );
	105	void mcu_handle_coins( int coin );
104	106	};

trunk/src/mame/includes/tp84.h

r21022	r21023
42	42	virtual void palette_init();
43	43	UINT32 screen_update_tp84(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
44	44	INTERRUPT_GEN_MEMBER(sub_vblank_irq);
	45	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
45	46	};

trunk/src/mame/includes/tubep.h

r21022	r21023
81	81	TIMER_CALLBACK_MEMBER(tubep_scanline_callback);
82	82	TIMER_CALLBACK_MEMBER(rjammer_scanline_callback);
83	83	TIMER_CALLBACK_MEMBER(sprite_timer_callback);
	84	void draw_sprite();
	85	void tubep_vblank_end();
	86	void tubep_setup_save_state();
84	87	};
85	88
86	89

trunk/src/mame/includes/tagteam.h

r21022	r21023
29	29	virtual void palette_init();
30	30	UINT32 screen_update_tagteam(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
31	31	INTERRUPT_GEN_MEMBER(sound_timer_irq);
	32	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
32	33	};

trunk/src/mame/includes/toki.h

r21022	r21023
40	40	virtual void video_start();
41	41	UINT32 screen_update_toki(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
42	42	UINT32 screen_update_tokib(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	43	void toki_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	44	void tokib_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
43	45	};

trunk/src/mame/includes/taito_f2.h

r21022	r21023
145	145	INTERRUPT_GEN_MEMBER(taitof2_interrupt);
146	146	TIMER_CALLBACK_MEMBER(taitof2_interrupt6);
147	147	void reset_driveout_sound_region();
	148	void taitof2_core_vh_start (int sprite_type, int hide, int flip_hide );
	149	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int *primasks, int uses_tc360_mixer );
	150	void update_spritebanks(  );
	151	void taitof2_handle_sprite_buffering(  );
	152	void taitof2_update_sprites_active_area(  );
	153	void draw_roz_layer( bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 priority);
	154	void taito_f2_tc360_spritemixdraw(bitmap_ind16 &dest_bmp, const rectangle &clip, gfx_element *gfx,
	155	UINT32 code, UINT32 color, int flipx, int flipy, int sx, int sy, int scalex, int scaley );
148	156	};

trunk/src/mame/includes/tbowl.h

r21022	r21023
53	53	virtual void video_start();
54	54	UINT32 screen_update_tbowl_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
55	55	UINT32 screen_update_tbowl_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	56	void tbowl_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect, int xscroll, UINT8* spriteram);
56	57	};

trunk/src/mame/includes/taito_h.h

r21022	r21023
31	31	UINT32 screen_update_recordbr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
32	32	UINT32 screen_update_dleague(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
33	33	void reset_sound_region();
	34	void syvalion_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	35	void recordbr_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	36	void dleague_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	37	void taitoh_log_vram();
34	38	};

trunk/src/mame/includes/tumblep.h

r21022	r21023
36	36	DECLARE_DRIVER_INIT(tumblep);
37	37	virtual void machine_start();
38	38	UINT32 screen_update_tumblep(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	39	void tumblep_patch_code(UINT16 offset);
39	40	};

trunk/src/mame/includes/taitosj.h

r21022	r21023
18	18	m_collision_reg(*this, "collision_reg"),
19	19	m_kikstart_scrollram(*this, "kikstart_scroll"){ }
20	20
	21	typedef void (taitosj_state::*copy_layer_func_t)(bitmap_ind16 &,
	22	const rectangle &, int, int *, rectangle *);
21	23	UINT8 m_sndnmi_disable;
22	24	UINT8 m_input_port_4_f0;
23	25	UINT8 m_kikstart_gears[2];
r21022	r21023
95	97	TIMER_CALLBACK_MEMBER(taitosj_mcu_status_real_w);
96	98	void init_common();
97	99	void reset_common();
	100	void set_pens();
	101	void compute_draw_order();
	102	inline int get_sprite_xy(UINT8 which, UINT8* sx, UINT8* sy);
	103	inline gfx_element *get_sprite_gfx_element(UINT8 which);
	104	void check_sprite_sprite_collision();
	105	void calculate_sprite_areas(int *sprites_on, rectangle *sprite_areas);
	106	int check_sprite_layer_bitpattern(int which, rectangle *sprite_areas);
	107	void check_sprite_layer_collision(int *sprites_on, rectangle *sprite_areas);
	108	void draw_layers();
	109	void draw_sprites(bitmap_ind16 &bitmap);
	110	void check_collision(int *sprites_on, rectangle *sprite_areas);
	111	int check_sprite_sprite_bitpattern(int sx1, int sy1, int which1,int sx2, int sy2, int which2);
	112	void taitosj_copy_layer(bitmap_ind16 &bitmap, const rectangle &cliprect,int which, int *sprites_on, rectangle *sprite_areas);
	113	void kikstart_copy_layer(bitmap_ind16 &bitmap, const rectangle &cliprect,int which, int *sprites_on, rectangle *sprite_areas);
	114	void copy_layer(bitmap_ind16 &bitmap, const rectangle &cliprect,copy_layer_func_t copy_layer_func, int which, int *sprites_on, rectangle *sprite_areas);
	115	void copy_layers(bitmap_ind16 &bitmap, const rectangle &cliprect,copy_layer_func_t copy_layer_func, int *sprites_on, rectangle *sprite_areas);
	116	int video_update_common(bitmap_ind16 &bitmap, const rectangle &cliprect, copy_layer_func_t copy_layer_func);
98	117	};

trunk/src/mame/includes/tiamc1.h

r21022	r21023
34	34	virtual void video_start();
35	35	virtual void palette_init();
36	36	UINT32 screen_update_tiamc1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	37	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
37	38	};
38	39
39	40

trunk/src/mame/includes/triplhnt.h

r21022	r21023
52	52	virtual void palette_init();
53	53	UINT32 screen_update_triplhnt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
54	54	TIMER_CALLBACK_MEMBER(triplhnt_hit_callback);
	55	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	56	void triplhnt_set_collision(int code);
	57	void triplhnt_update_misc(address_space &space, int offset);
55	58	};
56	59
57	60

trunk/src/mame/includes/tankbatt.h

r21022	r21023
31	31	virtual void palette_init();
32	32	UINT32 screen_update_tankbatt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
33	33	INTERRUPT_GEN_MEMBER(tankbatt_interrupt);
	34	void draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect);
34	35	};

trunk/src/mame/includes/tutankhm.h

r21022	r21023
33	33	DECLARE_MACHINE_RESET(tutankhm);
34	34	UINT32 screen_update_tutankhm(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
35	35	INTERRUPT_GEN_MEMBER(tutankhm_interrupt);
	36	void get_pens( pen_t *pens );
36	37	};

trunk/src/mame/includes/thief.h

r21022	r21023
	1	#include "sound/samples.h"
	2
1	3	struct coprocessor_t {
2	4	UINT8 *context_ram;
3	5	UINT8 bank;
r21022	r21023
35	37	virtual void video_start();
36	38	UINT32 screen_update_thief(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
37	39	INTERRUPT_GEN_MEMBER(thief_interrupt);
	40	UINT16 fetch_image_addr( coprocessor_t &thief_coprocessor );
	41	void tape_set_audio( samples_device *samples, int track, int bOn );
	42	void tape_set_motor( samples_device *samples, int bOn );
38	43	};

trunk/src/mame/includes/thedeep.h

r21022	r21023
52	52	UINT32 screen_update_thedeep(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
53	53	INTERRUPT_GEN_MEMBER(thedeep_mcu_irq);
54	54	TIMER_DEVICE_CALLBACK_MEMBER(thedeep_interrupt);
	55	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	56	void thedeep_maincpu_bankswitch(UINT8 bank_trig);
55	57	};

trunk/src/mame/includes/twincobr.h

r21022	r21023
109	109	INTERRUPT_GEN_MEMBER(wardner_interrupt);
110	110	void twincobr_restore_screen();
111	111	void twincobr_restore_dsp();
	112	void twincobr_create_tilemaps();
	113	void twincobr_display(int enable);
	114	void twincobr_flipscreen(int flip);
	115	void wardner_sprite_priority_hack();
	116	void twincobr_log_vram();
	117	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );
	118	void twincobr_dsp(int enable);
	119	void toaplan0_control_w(int offset, int data);
	120	void toaplan0_coin_dsp_w(address_space &space, int offset, int data);
	121	void twincobr_driver_savestate();
112	122	};
113	123
114	124

trunk/src/mame/includes/tumbleb.h

r21022	r21023
1	1
2	2	#include "video/decospr.h"
	3	#include "sound/okim6295.h"
3	4
4
5	5	class tumbleb_state : public driver_device
6	6	{
7	7	public:
r21022	r21023
109	109	UINT32 screen_update_sdfight(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
110	110	INTERRUPT_GEN_MEMBER(tumbleb2_interrupt);
111	111	void tumbleb_tilemap_redraw();
	112	inline void get_bg_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base);
	113	inline void get_fncywld_bg_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base);
	114	inline void pangpang_get_bg_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base );
	115	inline void pangpang_get_bg2x_tile_info( tile_data &tileinfo, int tile_index, int gfx_bank, UINT16 *gfx_base );
	116	void tumbleb_draw_common(bitmap_ind16 &bitmap, const rectangle &cliprect, int pf1x_offs, int pf1y_offs, int pf2x_offs, int pf2y_offs);
	117	void tumbleb2_set_music_bank( int bank );
	118	void tumbleb2_play_sound( okim6295_device *oki, int data );
	119	void process_tumbleb2_music_command( okim6295_device *oki, int data );
	120	void tumblepb_patch_code(UINT16 offset);
	121	void tumblepb_gfx_rearrange(int rgn);
	122	void suprtrio_decrypt_code();
	123	void suprtrio_decrypt_gfx();
112	124	};

trunk/src/mame/includes/taito_z.h

r21022	r21023
89	89	TIMER_CALLBACK_MEMBER(taitoz_interrupt6);
90	90	TIMER_CALLBACK_MEMBER(taitoz_cpub_interrupt5);
91	91	void taitoz_postload();
	92	void contcirc_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
	93	void chasehq_draw_sprites_16x16( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
	94	void bshark_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
	95	void sci_draw_sprites_16x8( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
	96	void aquajack_draw_sprites_16x8(bitmap_ind16 &bitmap,const rectangle &cliprect,int y_offs);
	97	void spacegun_draw_sprites_16x8(bitmap_ind16 &bitmap,const rectangle &cliprect,int y_offs);
	98	void parse_cpu_control(  );
	99	void reset_sound_region(  );
92	100	};

trunk/src/mame/includes/tecmo.h

r21022	r21023
49	49	DECLARE_MACHINE_RESET(rygar);
50	50	DECLARE_VIDEO_START(tecmo);
51	51	UINT32 screen_update_tecmo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	52	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
52	53	};

trunk/src/mame/includes/terracre.h

r21022	r21023
37	37	virtual void palette_init();
38	38	DECLARE_MACHINE_START(amazon);
39	39	UINT32 screen_update_amazon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	40	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
40	41	};

trunk/src/mame/includes/trackfld.h

r21022	r21023
69	69	INTERRUPT_GEN_MEMBER(vblank_irq);
70	70	INTERRUPT_GEN_MEMBER(vblank_nmi);
71	71	INTERRUPT_GEN_MEMBER(yieartf_timer_irq);
	72	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
72	73	};

trunk/src/mame/includes/tank8.h

r21022	r21023
62	62	UINT32 screen_update_tank8(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
63	63	void screen_eof_tank8(screen_device &screen, bool state);
64	64	TIMER_CALLBACK_MEMBER(tank8_collision_callback);
	65	void set_pens(colortable_t *colortable);
	66	inline int get_x_pos(int n);
	67	inline int get_y_pos(int n);
	68	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	69	void draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect);
	70	void tank8_set_collision(int index);
65	71	};
66	72
67	73	/*----------- defined in audio/tank8.c -----------*/
68	74
69	75	DISCRETE_SOUND_EXTERN( tank8 );
70
71		/*----------- defined in drivers/tank8.c -----------*/
72		void tank8_set_collision(running_machine &machine, int index);

trunk/src/mame/includes/taito_l.h

r21022	r21023
21	21	int m_flipscreen;
22	22
23	23	/* misc */
24		void (*m_current_notifier[4])(running_machine &, int);
	24	void (taitol_state::*m_current_notifier[4])(int);
25	25	UINT8 *m_current_base[4];
26	26
27	27	int m_cur_rombank;
r21022	r21023
123	123	void screen_eof_taitol(screen_device &screen, bool state);
124	124	TIMER_DEVICE_CALLBACK_MEMBER(vbl_interrupt);
125	125	IRQ_CALLBACK_MEMBER(irq_callback);
	126	void taitol_chardef14_m( int offset );
	127	void taitol_chardef15_m( int offset );
	128	void taitol_chardef16_m( int offset );
	129	void taitol_chardef17_m( int offset );
	130	void taitol_chardef1c_m( int offset );
	131	void taitol_chardef1d_m( int offset );
	132	void taitol_chardef1e_m( int offset );
	133	void taitol_chardef1f_m( int offset );
	134	void taitol_bg18_m( int offset );
	135	void taitol_bg19_m( int offset );
	136	void taitol_char1a_m( int offset );
	137	void taitol_obj1b_m( int offset );
	138	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	139	void palette_notifier(int addr);
	140	void state_register(  );
	141	void taito_machine_reset();
	142	void bank_w(address_space &space, offs_t offset, UINT8 data, int banknum );
126	143	};
127
128		/*----------- defined in video/taito_l.c -----------*/
129
130		void taitol_chardef14_m(running_machine &machine, int offset);
131		void taitol_chardef15_m(running_machine &machine, int offset);
132		void taitol_chardef16_m(running_machine &machine, int offset);
133		void taitol_chardef17_m(running_machine &machine, int offset);
134		void taitol_chardef1c_m(running_machine &machine, int offset);
135		void taitol_chardef1d_m(running_machine &machine, int offset);
136		void taitol_chardef1e_m(running_machine &machine, int offset);
137		void taitol_chardef1f_m(running_machine &machine, int offset);
138		void taitol_bg18_m(running_machine &machine, int offset);
139		void taitol_bg19_m(running_machine &machine, int offset);
140		void taitol_char1a_m(running_machine &machine, int offset);
141		void taitol_obj1b_m(running_machine &machine, int offset);

trunk/src/mame/includes/travrusa.h

r21022	r21023
25	25	virtual void palette_init();
26	26	DECLARE_PALETTE_INIT(shtrider);
27	27	UINT32 screen_update_travrusa(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	28	void set_scroll(  );
	29	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
28	30	};

trunk/src/mame/includes/timeplt.h

r21022	r21023
52	52	DECLARE_VIDEO_START(chkun);
53	53	UINT32 screen_update_timeplt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
54	54	INTERRUPT_GEN_MEMBER(timeplt_interrupt);
	55	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
55	56	};

trunk/src/mame/drivers/taito_l.c

r21022	r21023
65	65
66	66	static const struct
67	67	{
68		void (*notifier)(running_machine &, int);
	68	void (taitol_state::*notifier)(int);
69	69	UINT32 offset;
70	70	} rambank_modify_notifiers[12] =
71	71	{
72		{ taitol_chardef14_m, 0x0000 }, // 14
73		{ taitol_chardef15_m, 0x1000 }, // 15
74		{ taitol_chardef16_m, 0x2000 }, // 16
75		{ taitol_chardef17_m, 0x3000 }, // 17
	72	{ &taitol_state::taitol_chardef14_m, 0x0000 }, // 14
	73	{ &taitol_state::taitol_chardef15_m, 0x1000 }, // 15
	74	{ &taitol_state::taitol_chardef16_m, 0x2000 }, // 16
	75	{ &taitol_state::taitol_chardef17_m, 0x3000 }, // 17
76	76
77		{ taitol_bg18_m, 0x8000 },      // 18
78		{ taitol_bg19_m, 0x9000 },      // 19
79		{ taitol_char1a_m, 0xa000 },    // 1a
80		{ taitol_obj1b_m, 0xb000 },     // 1b
	77	{ &taitol_state::taitol_bg18_m, 0x8000 },      // 18
	78	{ &taitol_state::taitol_bg19_m, 0x9000 },      // 19
	79	{ &taitol_state::taitol_char1a_m, 0xa000 },    // 1a
	80	{ &taitol_state::taitol_obj1b_m, 0xb000 },     // 1b
81	81
82		{ taitol_chardef1c_m, 0x4000 }, // 1c
83		{ taitol_chardef1d_m, 0x5000 }, // 1d
84		{ taitol_chardef1e_m, 0x6000 }, // 1e
85		{ taitol_chardef1f_m, 0x7000 }, // 1f
	82	{ &taitol_state::taitol_chardef1c_m, 0x4000 }, // 1c
	83	{ &taitol_state::taitol_chardef1d_m, 0x5000 }, // 1d
	84	{ &taitol_state::taitol_chardef1e_m, 0x6000 }, // 1e
	85	{ &taitol_state::taitol_chardef1f_m, 0x7000 }, // 1f
86	86	};
87	87
88	88
89		static void palette_notifier(running_machine &machine, int addr)
	89	void taitol_state::palette_notifier(int addr)
90	90	{
91		taitol_state *state = machine.driver_data<taitol_state>();
92		UINT8 *p = state->m_palette_ram + (addr & ~1);
	91	UINT8 *p = m_palette_ram + (addr & ~1);
93	92	UINT8 byte0 = *p++;
94	93	UINT8 byte1 = *p;
95	94
r21022	r21023
97	96
98	97	if (addr > 0x200)
99	98	{
100		logerror("%s:Large palette ? %03x\n", machine.describe_context(), addr);
	99	logerror("%s:Large palette ? %03x\n", machine().describe_context(), addr);
101	100	}
102	101	else
103	102	{
104	103	//      r = g = b = ((addr & 0x1e) != 0)*255;
105		palette_set_color_rgb(machine, addr / 2, pal4bit(byte0), pal4bit(byte0 >> 4), pal4bit(byte1));
	104	palette_set_color_rgb(machine(), addr / 2, pal4bit(byte0), pal4bit(byte0 >> 4), pal4bit(byte1));
106	105	}
107	106	}
108	107
109	108	static const UINT8 puzznic_mcu_reply[] = { 0x50, 0x1f, 0xb6, 0xba, 0x06, 0x03, 0x47, 0x05, 0x00 };
110	109
111		static void state_register( running_machine &machine )
	110	void taitol_state::state_register(  )
112	111	{
113		taitol_state *state = machine.driver_data<taitol_state>();
114	112
115		state->save_item(NAME(state->m_irq_adr_table));
116		state->save_item(NAME(state->m_irq_enable));
117		state->save_item(NAME(state->m_cur_rambank));
118		state->save_item(NAME(state->m_cur_rombank));
119		state->save_item(NAME(state->m_cur_rombank2));
	113	save_item(NAME(m_irq_adr_table));
	114	save_item(NAME(m_irq_enable));
	115	save_item(NAME(m_cur_rambank));
	116	save_item(NAME(m_cur_rombank));
	117	save_item(NAME(m_cur_rombank2));
120	118
121		state->save_item(NAME(state->m_adpcm_pos));
122		state->save_item(NAME(state->m_adpcm_data));
123		state->save_item(NAME(state->m_trackx));
124		state->save_item(NAME(state->m_tracky));
125		state->save_item(NAME(state->m_mux_ctrl));
126		state->save_item(NAME(state->m_extport));
127		state->save_item(NAME(state->m_last_irq_level));
128		state->save_item(NAME(state->m_high));
129		state->save_item(NAME(state->m_high2));
	119	save_item(NAME(m_adpcm_pos));
	120	save_item(NAME(m_adpcm_data));
	121	save_item(NAME(m_trackx));
	122	save_item(NAME(m_tracky));
	123	save_item(NAME(m_mux_ctrl));
	124	save_item(NAME(m_extport));
	125	save_item(NAME(m_last_irq_level));
	126	save_item(NAME(m_high));
	127	save_item(NAME(m_high2));
130	128
131		state->save_item(NAME(state->m_mcu_pos));
132		state->save_item(NAME(state->m_mcu_reply_len));
133		state->save_item(NAME(state->m_last_data_adr));
134		state->save_item(NAME(state->m_last_data));
135		state->save_item(NAME(state->m_cur_bank));
	129	save_item(NAME(m_mcu_pos));
	130	save_item(NAME(m_mcu_reply_len));
	131	save_item(NAME(m_last_data_adr));
	132	save_item(NAME(m_last_data));
	133	save_item(NAME(m_cur_bank));
136	134
137		state->save_item(NAME(state->m_bankc));
138		state->save_item(NAME(state->m_horshoes_gfxbank));
139		state->save_item(NAME(state->m_cur_ctrl));
140		state->save_item(NAME(state->m_flipscreen));
	135	save_item(NAME(m_bankc));
	136	save_item(NAME(m_horshoes_gfxbank));
	137	save_item(NAME(m_cur_ctrl));
	138	save_item(NAME(m_flipscreen));
141	139	}
142	140
143	141	MACHINE_START_MEMBER(taitol_state,taito_l)
r21022	r21023
149	147	save_item(NAME(m_palette_ram));
150	148	save_item(NAME(m_empty_ram));
151	149
152		state_register(machine());
	150	state_register();
153	151	}
154	152
155		static void taito_machine_reset(running_machine &machine)
	153	void taitol_state::taito_machine_reset()
156	154	{
157		taitol_state *state = machine.driver_data<taitol_state>();
158	155	int i;
159	156
160	157	for (i = 0; i < 3; i++)
161		state->m_irq_adr_table[i] = 0;
	158	m_irq_adr_table[i] = 0;
162	159
163		state->m_irq_enable = 0;
	160	m_irq_enable = 0;
164	161
165	162	for (i = 0; i < 4; i++)
166	163	{
167		state->m_cur_rambank[i] = 0x80;
168		state->m_current_notifier[i] = palette_notifier;
169		state->m_current_base[i] = state->m_palette_ram;
170		state->membank(bankname[i])->set_base(state->m_current_base[i]);
	164	m_cur_rambank[i] = 0x80;
	165	m_current_notifier[i] = &taitol_state::palette_notifier;
	166	m_current_base[i] = m_palette_ram;
	167	membank(bankname[i])->set_base(m_current_base[i]);
171	168	}
172	169
173		state->m_cur_rombank = state->m_cur_rombank2 = 0;
174		state->membank("bank1")->set_base(machine.root_device().memregion("maincpu")->base());
	170	m_cur_rombank = m_cur_rombank2 = 0;
	171	membank("bank1")->set_base(machine().root_device().memregion("maincpu")->base());
175	172
176		machine.gfx[2]->set_source(state->m_rambanks);
	173	machine().gfx[2]->set_source(m_rambanks);
177	174
178		state->m_adpcm_pos = 0;
179		state->m_adpcm_data = -1;
180		state->m_trackx = state->m_tracky = 0;
181		state->m_mux_ctrl = 0;
182		state->m_extport = 0;
183		state->m_last_irq_level = 0;
184		state->m_high = 0;
185		state->m_high2 = 0;
	175	m_adpcm_pos = 0;
	176	m_adpcm_data = -1;
	177	m_trackx = m_tracky = 0;
	178	m_mux_ctrl = 0;
	179	m_extport = 0;
	180	m_last_irq_level = 0;
	181	m_high = 0;
	182	m_high2 = 0;
186	183
187		state->m_mcu_reply = puzznic_mcu_reply;
	184	m_mcu_reply = puzznic_mcu_reply;
188	185
189		state->m_mcu_pos = state->m_mcu_reply_len = 0;
190		state->m_last_data_adr = state->m_last_data = 0;
191		state->m_cur_bank = 1;
	186	m_mcu_pos = m_mcu_reply_len = 0;
	187	m_last_data_adr = m_last_data = 0;
	188	m_cur_bank = 1;
192	189
193	190	/* video related */
194		state->m_bankc[0] = state->m_bankc[1] = state->m_bankc[2] = state->m_bankc[3] = 0;
195		state->m_horshoes_gfxbank = 0;
196		state->m_cur_ctrl = 0;
197		state->m_flipscreen = 0;
	191	m_bankc[0] = m_bankc[1] = m_bankc[2] = m_bankc[3] = 0;
	192	m_horshoes_gfxbank = 0;
	193	m_cur_ctrl = 0;
	194	m_flipscreen = 0;
198	195	}
199	196
200	197
201	198	MACHINE_RESET_MEMBER(taitol_state,fhawk)
202	199	{
203		taito_machine_reset(machine());
	200	taito_machine_reset();
204	201	m_porte0_tag = NULL;
205	202	m_porte1_tag = NULL;
206	203	m_portf0_tag = NULL;
r21022	r21023
209	206
210	207	MACHINE_RESET_MEMBER(taitol_state,raimais)
211	208	{
212		taito_machine_reset(machine());
	209	taito_machine_reset();
213	210	m_porte0_tag = NULL;
214	211	m_porte1_tag = NULL;
215	212	m_portf0_tag = NULL;
r21022	r21023
218	215
219	216	MACHINE_RESET_MEMBER(taitol_state,champwr)
220	217	{
221		taito_machine_reset(machine());
	218	taito_machine_reset();
222	219	m_porte0_tag = NULL;
223	220	m_porte1_tag = NULL;
224	221	m_portf0_tag = NULL;
r21022	r21023
228	225
229	226	MACHINE_RESET_MEMBER(taitol_state,kurikint)
230	227	{
231		taito_machine_reset(machine());
	228	taito_machine_reset();
232	229	m_porte0_tag = NULL;
233	230	m_porte1_tag = NULL;
234	231	m_portf0_tag = NULL;
r21022	r21023
237	234
238	235	MACHINE_RESET_MEMBER(taitol_state,evilston)
239	236	{
240		taito_machine_reset(machine());
	237	taito_machine_reset();
241	238	m_porte0_tag = NULL;
242	239	m_porte1_tag = NULL;
243	240	m_portf0_tag = NULL;
r21022	r21023
246	243
247	244	MACHINE_RESET_MEMBER(taitol_state,puzznic)
248	245	{
249		taito_machine_reset(machine());
	246	taito_machine_reset();
250	247	m_porte0_tag = "DSWA";
251	248	m_porte1_tag = "DSWB";
252	249	m_portf0_tag = "IN0";
r21022	r21023
255	252
256	253	MACHINE_RESET_MEMBER(taitol_state,plotting)
257	254	{
258		taito_machine_reset(machine());
	255	taito_machine_reset();
259	256	m_porte0_tag = "DSWA";
260	257	m_porte1_tag = "DSWB";
261	258	m_portf0_tag = "IN0";
r21022	r21023
264	261
265	262	MACHINE_RESET_MEMBER(taitol_state,palamed)
266	263	{
267		taito_machine_reset(machine());
	264	taito_machine_reset();
268	265	m_porte0_tag = "DSWA";
269	266	m_porte1_tag = NULL;
270	267	m_portf0_tag = "DSWB";
r21022	r21023
273	270
274	271	MACHINE_RESET_MEMBER(taitol_state,cachat)
275	272	{
276		taito_machine_reset(machine());
	273	taito_machine_reset();
277	274	m_porte0_tag = "DSWA";
278	275	m_porte1_tag = NULL;
279	276	m_portf0_tag = "DSWB";
r21022	r21023
282	279
283	280	MACHINE_RESET_MEMBER(taitol_state,horshoes)
284	281	{
285		taito_machine_reset(machine());
	282	taito_machine_reset();
286	283	m_porte0_tag = "DSWA";
287	284	m_porte1_tag = "DSWB";
288	285	m_portf0_tag = "IN0";
r21022	r21023
409	406	}
410	407	else if (data == 0x80)
411	408	{
412		m_current_notifier[offset] = palette_notifier;
	409	m_current_notifier[offset] = &taitol_state::palette_notifier;
413	410	m_current_base[offset] = m_palette_ram;
414	411	}
415	412	else
r21022	r21023
427	424	return m_cur_rambank[offset];
428	425	}
429	426
430		static void bank_w(address_space &space, offs_t offset, UINT8 data, int banknum )
	427	void taitol_state::bank_w(address_space &space, offs_t offset, UINT8 data, int banknum )
431	428	{
432		taitol_state *state = space.machine().driver_data<taitol_state>();
433
434		if (state->m_current_base[banknum][offset] != data)
	429	if (m_current_base[banknum][offset] != data)
435	430	{
436		state->m_current_base[banknum][offset] = data;
437		if (state->m_current_notifier[banknum])
438		state->m_current_notifier[banknum](space.machine(), offset);
	431	m_current_base[banknum][offset] = data;
	432	if (m_current_notifier[banknum])
	433	(this->*m_current_notifier[banknum])(offset);
439	434	}
440	435	}
441	436

trunk/src/mame/drivers/triplhnt.c

r21022	r21023
23	23	}
24	24
25	25
26		void triplhnt_set_collision(running_machine &machine, int code)
	26	void triplhnt_state::triplhnt_set_collision(int code)
27	27	{
28		triplhnt_state *state = machine.driver_data<triplhnt_state>();
29		state->m_hit_code = code;
	28	m_hit_code = code;
30	29
31		machine.device("maincpu")->execute().set_input_line(0, HOLD_LINE);
	30	machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
32	31	}
33	32
34	33
35		static void triplhnt_update_misc(address_space &space, int offset)
	34	void triplhnt_state::triplhnt_update_misc(address_space &space, int offset)
36	35	{
37		triplhnt_state *state = space.machine().driver_data<triplhnt_state>();
38	36	samples_device *samples = space.machine().device<samples_device>("samples");
39	37	device_t *discrete = space.machine().device("discrete");
40	38	UINT8 is_witch_hunt;
r21022	r21023
51	49
52	50	if (offset & 1)
53	51	{
54		state->m_misc_flags |= 1 << bit;
	52	m_misc_flags |= 1 << bit;
55	53
56	54	if (bit == 5)
57	55	{
58		state->m_cmos[state->m_cmos_latch] = state->m_da_latch;
	56	m_cmos[m_cmos_latch] = m_da_latch;
59	57	}
60	58	}
61	59	else
62	60	{
63		state->m_misc_flags &= ~(1 << bit);
	61	m_misc_flags &= ~(1 << bit);
64	62	}
65	63
66		state->m_sprite_zoom = (state->m_misc_flags >> 4) & 1;
67		state->m_sprite_bank = (state->m_misc_flags >> 7) & 1;
	64	m_sprite_zoom = (m_misc_flags >> 4) & 1;
	65	m_sprite_bank = (m_misc_flags >> 7) & 1;
68	66
69		set_led_status(space.machine(), 0, state->m_misc_flags & 0x02);
	67	set_led_status(space.machine(), 0, m_misc_flags & 0x02);
70	68
71		coin_lockout_w(space.machine(), 0, !(state->m_misc_flags & 0x08));
72		coin_lockout_w(space.machine(), 1, !(state->m_misc_flags & 0x08));
	69	coin_lockout_w(space.machine(), 0, !(m_misc_flags & 0x08));
	70	coin_lockout_w(space.machine(), 1, !(m_misc_flags & 0x08));
73	71
74		discrete_sound_w(discrete, space, TRIPLHNT_SCREECH_EN, state->m_misc_flags & 0x04); // screech
75		discrete_sound_w(discrete, space, TRIPLHNT_LAMP_EN, state->m_misc_flags & 0x02);    // Lamp is used to reset noise
76		discrete_sound_w(discrete, space, TRIPLHNT_BEAR_EN, state->m_misc_flags & 0x80);    // bear
	72	discrete_sound_w(discrete, space, TRIPLHNT_SCREECH_EN, m_misc_flags & 0x04); // screech
	73	discrete_sound_w(discrete, space, TRIPLHNT_LAMP_EN, m_misc_flags & 0x02);    // Lamp is used to reset noise
	74	discrete_sound_w(discrete, space, TRIPLHNT_BEAR_EN, m_misc_flags & 0x80);    // bear
77	75
78	76	is_witch_hunt = space.machine().root_device().ioport("0C09")->read() == 0x40;
79		bit = ~state->m_misc_flags & 0x40;
	77	bit = ~m_misc_flags & 0x40;
80	78
81	79	/* if we're not playing the sample yet, start it */
82	80	if (!samples->playing(0))

trunk/src/mame/drivers/taitojc.c

r21022	r21023
387	387
388	388	#if DEBUG_DSP
389	389
390		static void debug_dsp_command(running_machine &machine)
	390	void taitojc_state::debug_dsp_command()
391	391	{
392		taitojc_state *state = machine.driver_data<taitojc_state>();
393		UINT16 *cmd = &state->m_dsp_shared_ram[0x1fc0/2];
	392	UINT16 *cmd = &m_dsp_shared_ram[0x1fc0/2];
394	393
395	394	switch (cmd[0])
396	395	{
r21022	r21023
429	428	#endif
430	429	for (i=0; i < ll; i++)
431	430	{
432		UINT16 d = state->m_dsp_shared_ram[saddr++];
	431	UINT16 d = m_dsp_shared_ram[saddr++];
433	432	if (daddr >= 0x8000 && daddr < 0x10000)
434	433	{
435		state->m_debug_dsp_ram[daddr-0x8000] = d;
	434	m_debug_dsp_ram[daddr-0x8000] = d;
436	435	}
437	436	daddr++;
438	437
r21022	r21023
472	471	while (!end)
473	472	{
474	473	int i;
475		UINT16 cmd = state->m_debug_dsp_ram[addr++];
	474	UINT16 cmd = m_debug_dsp_ram[addr++];
476	475	int length = cmd & 0xff;
477	476
478	477	if ((cmd >> 11) == 6)
r21022	r21023
481	480	printf("   %04X (%02X): ", cmd, cmd >> 11);
482	481	for (i=0; i < length; i++)
483	482	{
484		printf("%04X ", state->m_debug_dsp_ram[addr+i]);
	483	printf("%04X ", m_debug_dsp_ram[addr+i]);
485	484	}
486	485	printf("\n");
487	486
r21022	r21023
569	568
570	569
571	570
572		static UINT8 mcu_comm_reg_r(address_space &space, int reg)
	571	UINT8 taitojc_state::mcu_comm_reg_r(address_space &space, int reg)
573	572	{
574		taitojc_state *state = space.machine().driver_data<taitojc_state>();
575	573	UINT8 r = 0;
576	574
577	575	switch (reg)
578	576	{
579	577	case 0x03:
580	578	{
581		r = state->m_mcu_data_main;
	579	r = m_mcu_data_main;
582	580	break;
583	581	}
584	582	case 0x04:
585	583	{
586		r = state->m_mcu_comm_main | 0x14;
	584	r = m_mcu_comm_main | 0x14;
587	585	break;
588	586	}
589	587	default:
r21022	r21023
596	594	return r;
597	595	}
598	596
599		static void mcu_comm_reg_w(address_space &space, int reg, UINT8 data)
	597	void taitojc_state::mcu_comm_reg_w(address_space &space, int reg, UINT8 data)
600	598	{
601		taitojc_state *state = space.machine().driver_data<taitojc_state>();
602
603	599	switch (reg)
604	600	{
605	601	case 0x00:
606	602	{
607		state->m_mcu_data_hc11 = data;
608		state->m_mcu_comm_hc11 &= ~0x04;
609		state->m_mcu_comm_main &= ~0x20;
	603	m_mcu_data_hc11 = data;
	604	m_mcu_comm_hc11 &= ~0x04;
	605	m_mcu_comm_main &= ~0x20;
610	606	break;
611	607	}
612	608	case 0x04:
r21022	r21023
996	992	{
997	993	if (offset == 0)
998	994	{
999		taitojc_clear_frame(machine());
	995	taitojc_clear_frame();
1000	996	m_renderer->render_polygons(machine(), m_polygon_fifo, m_polygon_fifo_ptr);
1001	997
1002	998	m_polygon_fifo_ptr = 0;

trunk/src/mame/drivers/toaplan2.c

r21022	r21023
482	482	m_main_cpu->execute().set_input_line(param, HOLD_LINE);
483	483	}
484	484
485		static void toaplan2_vblank_irq(running_machine &machine, int irq_line)
	485	void toaplan2_state::toaplan2_vblank_irq(int irq_line)
486	486	{
487		toaplan2_state *state = machine.driver_data<toaplan2_state>();
488	487	// the IRQ appears to fire at line 0xe6
489		machine.scheduler().timer_set(machine.primary_screen->time_until_pos(0xe6), timer_expired_delegate(FUNC(toaplan2_state::toaplan2_raise_irq),state), irq_line);
	488	machine().scheduler().timer_set(machine().primary_screen->time_until_pos(0xe6), timer_expired_delegate(FUNC(toaplan2_state::toaplan2_raise_irq),this), irq_line);
490	489	}
491	490
492		INTERRUPT_GEN_MEMBER(toaplan2_state::toaplan2_vblank_irq1){ toaplan2_vblank_irq(machine(), 1); }
493		INTERRUPT_GEN_MEMBER(toaplan2_state::toaplan2_vblank_irq2){ toaplan2_vblank_irq(machine(), 2); }
494		INTERRUPT_GEN_MEMBER(toaplan2_state::toaplan2_vblank_irq4){ toaplan2_vblank_irq(machine(), 4); }
	491	INTERRUPT_GEN_MEMBER(toaplan2_state::toaplan2_vblank_irq1){ toaplan2_vblank_irq(1); }
	492	INTERRUPT_GEN_MEMBER(toaplan2_state::toaplan2_vblank_irq2){ toaplan2_vblank_irq(2); }
	493	INTERRUPT_GEN_MEMBER(toaplan2_state::toaplan2_vblank_irq4){ toaplan2_vblank_irq(4); }
495	494
496	495
497	496	READ16_MEMBER(toaplan2_state::video_count_r)

trunk/src/mame/drivers/tumblep.c

r21022	r21023
372	372	/******************************************************************************/
373	373
374	374	#if TUMBLEP_HACK
375		void tumblep_patch_code(UINT16 offset)
	375	void ::tumblep_patch_code(UINT16 offset)
376	376	{
377	377	/* A hack which enables all Dip Switches effects */
378		UINT16 *RAM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	378	UINT16 *RAM = (UINT16 *)machine().root_device().memregion("maincpu")->base();
379	379	RAM[(offset + 0)/2] = 0x0240;
380	380	RAM[(offset + 2)/2] = 0xffff;   // andi.w  #$f3ff, D0
381	381	}

trunk/src/mame/drivers/thedeep.c

r21022	r21023
187	187
188	188	***************************************************************************/
189	189
190		static void thedeep_maincpu_bankswitch(running_machine &machine,UINT8 bank_trig)
	190	void thedeep_state::thedeep_maincpu_bankswitch(UINT8 bank_trig)
191	191	{
192		thedeep_state *state = machine.driver_data<thedeep_state>();
193	192	UINT8 *rom;
194	193	int new_rombank = bank_trig & 3;
195	194
196		if (state->m_rombank == new_rombank)
	195	if (m_rombank == new_rombank)
197	196	return;
198		state->m_rombank = new_rombank;
199		rom = state->memregion("maincpu")->base();
200		state->membank("bank1")->set_base(rom + 0x10000 + state->m_rombank * 0x4000);
	197	m_rombank = new_rombank;
	198	rom = memregion("maincpu")->base();
	199	membank("bank1")->set_base(rom + 0x10000 + m_rombank * 0x4000);
201	200	/* there's code which falls through from the fixed ROM to bank #1, I have to */
202	201	/* copy it there otherwise the CPU bank switching support will not catch it. */
203		memcpy(rom + 0x08000, rom + 0x10000 + state->m_rombank * 0x4000, 0x4000);
	202	memcpy(rom + 0x08000, rom + 0x10000 + m_rombank * 0x4000, 0x4000);
204	203
205	204	}
206	205
207	206	WRITE8_MEMBER(thedeep_state::thedeep_p1_w)
208	207	{
209	208	flip_screen_set((data & 1) ^ 1);
210		thedeep_maincpu_bankswitch(machine(),(data & 6) >> 1);
	209	thedeep_maincpu_bankswitch((data & 6) >> 1);
211	210	logerror("P1 %02x\n",data);
212	211	}
213	212

trunk/src/mame/drivers/taito_z.c

r21022	r21023
979	979	#include "contcirc.lh"
980	980	#include "dblaxle.lh"
981	981
982		static void parse_cpu_control( running_machine &machine )
	982	void taitoz_state::parse_cpu_control(  )
983	983	{
984	984	/* bit 0 enables cpu B */
985		taitoz_state *state = machine.driver_data<taitoz_state>();
986		state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
	985	m_subcpu->set_input_line(INPUT_LINE_RESET, (m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
987	986	}
988	987
989	988	WRITE16_MEMBER(taitoz_state::cpua_ctrl_w)
r21022	r21023
994	993	data &= 0xff;
995	994
996	995	m_cpua_ctrl = data;
997		parse_cpu_control(machine());
	996	parse_cpu_control();
998	997	}
999	998
1000	999	WRITE16_MEMBER(taitoz_state::chasehq_cpua_ctrl_w)
r21022	r21023
1404	1403	SOUND
1405	1404	*****************************************************/
1406	1405
1407		static void reset_sound_region( running_machine &machine )
	1406	void taitoz_state::reset_sound_region(  )
1408	1407	{
1409		taitoz_state *state = machine.driver_data<taitoz_state>();
1410		state->membank("bank10")->set_entry(state->m_banknum);
	1408	membank("bank10")->set_entry(m_banknum);
1411	1409	}
1412	1410
1413	1411	WRITE8_MEMBER(taitoz_state::sound_bankswitch_w)
1414	1412	{
1415	1413	m_banknum = data & 7;
1416		reset_sound_region(machine());
	1414	reset_sound_region();
1417	1415	}
1418	1416
1419	1417	WRITE16_MEMBER(taitoz_state::taitoz_sound_w)
r21022	r21023
3027	3025
3028	3026	void taitoz_state::taitoz_postload()
3029	3027	{
3030		parse_cpu_control(machine());
3031		reset_sound_region(machine());
	3028	parse_cpu_control();
	3029	reset_sound_region();
3032	3030	}
3033	3031
3034	3032	MACHINE_START_MEMBER(taitoz_state,bshark)
r21022	r21023
5186	5184
5187	5185	DRIVER_INIT_MEMBER(taitoz_state,taitoz)
5188	5186	{
5189		machine().save().register_postload(save_prepost_delegate(FUNC(parse_cpu_control), &machine()));
	5187	machine().save().register_postload(save_prepost_delegate(FUNC(taitoz_state::parse_cpu_control), this));
5190	5188	}
5191	5189
5192	5190	DRIVER_INIT_MEMBER(taitoz_state,bshark)

trunk/src/mame/drivers/twin16.c

r21022	r21023
61	61
62	62
63	63
64		int twin16_spriteram_process_enable( running_machine &machine )
	64	int twin16_state::twin16_spriteram_process_enable(  )
65	65	{
66		twin16_state *state = machine.driver_data<twin16_state>();
67		return (state->m_CPUA_register & 0x40) == 0;
	66	return (m_CPUA_register & 0x40) == 0;
68	67	}
69	68
70	69	/******************************************************************************************/
r21022	r21023
125	124	machine().device("audiocpu")->execute().set_input_line_and_vector(0, HOLD_LINE, 0xff);
126	125
127	126	if ((old & 0x40) && (m_CPUA_register & 0x40) == 0)
128		twin16_spriteram_process(machine());
	127	twin16_spriteram_process();
129	128
130	129	if ((old & 0x10) == 0 && (m_CPUA_register & 0x10))
131	130	machine().device("sub")->execute().set_input_line(M68K_IRQ_6, HOLD_LINE);
r21022	r21023
1298	1297
1299	1298	/* Driver Initialization */
1300	1299
1301		static void gfx_untangle( running_machine &machine )
	1300	void twin16_state::gfx_untangle(  )
1302	1301	{
1303		twin16_state *state = machine.driver_data<twin16_state>();
1304	1302	// sprite, tile data
1305	1303	int i;
1306		UINT16 *temp = auto_alloc_array(machine, UINT16, 0x200000/2);
	1304	UINT16 *temp = auto_alloc_array(machine(), UINT16, 0x200000/2);
1307	1305
1308		state->m_gfx_rom = (UINT16 *)state->memregion("gfx2")->base();
1309		memcpy( temp, state->m_gfx_rom, 0x200000 );
	1306	m_gfx_rom = (UINT16 *)memregion("gfx2")->base();
	1307	memcpy( temp, m_gfx_rom, 0x200000 );
1310	1308
1311	1309	for( i=0; i<0x080000; i++ )
1312	1310	{
1313		state->m_gfx_rom[i*2+0] = temp[i+0x080000];
1314		state->m_gfx_rom[i*2+1] = temp[i];
	1311	m_gfx_rom[i*2+0] = temp[i+0x080000];
	1312	m_gfx_rom[i*2+1] = temp[i];
1315	1313	}
1316		auto_free( machine, temp );
	1314	auto_free( machine(), temp );
1317	1315	}
1318	1316
1319	1317	DRIVER_INIT_MEMBER(twin16_state,twin16)
1320	1318	{
1321		gfx_untangle(machine());
	1319	gfx_untangle();
1322	1320	m_custom_video = 0;
1323	1321	}
1324	1322
1325	1323	DRIVER_INIT_MEMBER(twin16_state,fround)
1326	1324	{
1327		gfx_untangle(machine());
	1325	gfx_untangle();
1328	1326	m_custom_video = 1;
1329	1327	}
1330	1328
1331	1329	DRIVER_INIT_MEMBER(twin16_state,cuebrickj)
1332	1330	{
1333		gfx_untangle(machine());
	1331	gfx_untangle();
1334	1332
1335	1333	machine().device<nvram_device>("nvram")->set_base(m_cuebrickj_nvram, 0x400*0x20);
1336	1334	}

trunk/src/mame/drivers/tecmosys.c

r21022	r21023
628	628	ROM_LOAD( "ae500w07.ad1", 0x080000, 0x080000, CRC(3734f92c) SHA1(048555b5aa89eaf983305c439ba08d32b4a1bb80) )
629	629	ROM_END
630	630
631		static void tecmosys_descramble(running_machine &machine)
	631	void tecmosys_state::tecmosys_descramble()
632	632	{
633		UINT8 *gfxsrc  = machine.root_device().memregion( "gfx1" )->base();
634		size_t srcsize = machine.root_device().memregion( "gfx1" )->bytes();
	633	UINT8 *gfxsrc  = machine().root_device().memregion( "gfx1" )->base();
	634	size_t srcsize = machine().root_device().memregion( "gfx1" )->bytes();
635	635	int i;
636	636
637	637	for (i=0; i < srcsize; i+=4)
r21022	r21023
652	652
653	653	DRIVER_INIT_MEMBER(tecmosys_state,deroon)
654	654	{
655		tecmosys_descramble(machine());
	655	tecmosys_descramble();
656	656	tecmosys_prot_init(0); // machine/tecmosys.c
657	657	}
658	658
659	659	DRIVER_INIT_MEMBER(tecmosys_state,tkdensho)
660	660	{
661		tecmosys_descramble(machine());
	661	tecmosys_descramble();
662	662	tecmosys_prot_init(1);
663	663	}
664	664
665	665	DRIVER_INIT_MEMBER(tecmosys_state,tkdensha)
666	666	{
667		tecmosys_descramble(machine());
	667	tecmosys_descramble();
668	668	tecmosys_prot_init(2);
669	669	}
670	670

trunk/src/mame/drivers/tmnt.c

r21022	r21023
296	296	#if 0
297	297	static int sound_nmi_enabled;
298	298
299		static void sound_nmi_callback( int param )
	299	void tmnt_state::sound_nmi_callback( int param )
300	300	{
301		machine.device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, ( sound_nmi_enabled ) ? CLEAR_LINE : ASSERT_LINE );
	301	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, ( sound_nmi_enabled ) ? CLEAR_LINE : ASSERT_LINE );
302	302
303	303	sound_nmi_enabled = 0;
304	304	}
r21022	r21023
742	742
743	743
744	744	#if 1
745		INLINE UINT32 tmnt2_get_word( running_machine &machine, UINT32 addr )
	745	inline UINT32 tmnt_state::tmnt2_get_word( UINT32 addr )
746	746	{
747		tmnt_state *state = machine.driver_data<tmnt_state>();
748	747
749	748	if (addr <= 0x07ffff / 2)
750		return(state->m_tmnt2_rom[addr]);
	749	return(m_tmnt2_rom[addr]);
751	750	else if (addr >= 0x104000 / 2 && addr <= 0x107fff / 2)
752		return(state->m_sunset_104000[addr - 0x104000 / 2]);
	751	return(m_sunset_104000[addr - 0x104000 / 2]);
753	752	else if (addr >= 0x180000 / 2 && addr <= 0x183fff / 2)
754		return(state->m_spriteram[addr - 0x180000 / 2]);
	753	return(m_spriteram[addr - 0x180000 / 2]);
755	754	return 0;
756	755	}
757	756
758		static void tmnt2_put_word( address_space &space, UINT32 addr, UINT16 data )
	757	void tmnt_state::tmnt2_put_word( address_space &space, UINT32 addr, UINT16 data )
759	758	{
760		tmnt_state *state = space.machine().driver_data<tmnt_state>();
761
762	759	UINT32 offs;
763	760	if (addr >= 0x180000 / 2 && addr <= 0x183fff / 2)
764	761	{
765		state->m_spriteram[addr - 0x180000 / 2] = data;
	762	m_spriteram[addr - 0x180000 / 2] = data;
766	763	offs = addr - 0x180000 / 2;
767	764	if (!(offs & 0x0031))
768	765	{
769	766	offs = ((offs & 0x000e) >> 1) | ((offs & 0x1fc0) >> 3);
770		k053245_word_w(state->m_k053245, space, offs, data, 0xffff);
	767	k053245_word_w(m_k053245, space, offs, data, 0xffff);
771	768	}
772	769	}
773	770	else if (addr >= 0x104000 / 2 && addr <= 0x107fff / 2)
774		state->m_sunset_104000[addr - 0x104000 / 2] = data;
	771	m_sunset_104000[addr - 0x104000 / 2] = data;
775	772	}
776	773
777	774	WRITE16_MEMBER(tmnt_state::tmnt2_1c0800_w)
r21022	r21023
797	794	zlock    = (mcu[8] & 0xff) == 0x0001;
798	795
799	796	for (i = 0; i < 4; i++)
800		src[i] = tmnt2_get_word(machine(), src_addr + i);
	797	src[i] = tmnt2_get_word(src_addr + i);
801	798	for (i = 0; i < 24; i++) mod[i] =
802		tmnt2_get_word(machine(), mod_addr + i);
	799	tmnt2_get_word(mod_addr + i);
803	800
804	801	code = src[0];          // code
805	802

trunk/src/mame/drivers/topspeed.c

r21022	r21023
294	294	COMBINE_DATA(&m_sharedram[offset]);
295	295	}
296	296
297		static void parse_control( running_machine &machine )   /* assumes Z80 sandwiched between 68Ks */
	297	void topspeed_state::parse_control(  )   /* assumes Z80 sandwiched between 68Ks */
298	298	{
299	299	/* bit 0 enables cpu B */
300	300	/* however this fails when recovering from a save state
301	301	if cpu B is disabled !! */
302		topspeed_state *state = machine.driver_data<topspeed_state>();
303		state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl &0x1) ? CLEAR_LINE : ASSERT_LINE);
	302	m_subcpu->set_input_line(INPUT_LINE_RESET, (m_cpua_ctrl &0x1) ? CLEAR_LINE : ASSERT_LINE);
304	303	}
305	304
306	305	WRITE16_MEMBER(topspeed_state::cpua_ctrl_w)
r21022	r21023
310	309
311	310	m_cpua_ctrl = data;
312	311
313		parse_control(machine());
	312	parse_control();
314	313
315	314	logerror("CPU #0 PC %06x: write %04x to cpu control\n", space.device().safe_pc(), data);
316	315	}
r21022	r21023
407	406	SOUND
408	407	*****************************************************/
409	408
410		static void reset_sound_region( running_machine &machine )
	409	void topspeed_state::reset_sound_region(  )
411	410	{
412		topspeed_state *state = machine.driver_data<topspeed_state>();
413		state->membank("bank10")->set_entry(state->m_banknum);
	411	membank("bank10")->set_entry(m_banknum);
414	412	}
415	413
416	414	WRITE8_MEMBER(topspeed_state::sound_bankswitch_w)/* assumes Z80 sandwiched between 68Ks */
417	415	{
418	416	m_banknum = data & 7;
419		reset_sound_region(machine());
	417	reset_sound_region();
420	418	}
421	419
422	420	WRITE8_MEMBER(topspeed_state::topspeed_tc0140syt_comm_w)
r21022	r21023
674	672
675	673	void topspeed_state::topspeed_postload()
676	674	{
677		parse_control(machine());
678		reset_sound_region(machine());
	675	parse_control();
	676	reset_sound_region();
679	677	}
680	678
681	679	void topspeed_state::machine_start()

trunk/src/mame/drivers/thunderx.c

r21022	r21023
178	178	// +3 : x (2 pixel units) of center of object
179	179	// +4 : y (2 pixel units) of center of object
180	180
181		static void run_collisions( running_machine &machine, int s0, int e0, int s1, int e1, int cm, int hm )
	181	void thunderx_state::run_collisions( int s0, int e0, int s1, int e1, int cm, int hm )
182	182	{
183		thunderx_state *state = machine.driver_data<thunderx_state>();
184	183	UINT8* p0;
185	184	UINT8* p1;
186	185	int ii, jj;
187	186
188		p0 = &state->m_pmcram[16 + 5 * s0];
	187	p0 = &m_pmcram[16 + 5 * s0];
189	188	for (ii = s0; ii < e0; ii++, p0 += 5)
190	189	{
191	190	int l0, r0, b0, t0;
r21022	r21023
199	198	t0 = p0[4] - p0[2];
200	199	b0 = p0[4] + p0[2];
201	200
202		p1 = &state->m_pmcram[16 + 5 * s1];
	201	p1 = &m_pmcram[16 + 5 * s1];
203	202	for (jj = s1; jj < e1; jj++,p1 += 5)
204	203	{
205	204	int l1,r1,b1,t1;
r21022	r21023
230	229	//
231	230	// emulates K052591 collision detection
232	231
233		static void calculate_collisions( running_machine &machine )
	232	void thunderx_state::calculate_collisions(  )
234	233	{
235		thunderx_state *state = machine.driver_data<thunderx_state>();
236	234	int X0,Y0;
237	235	int X1,Y1;
238	236	int CM,HM;
r21022	r21023
256	254	// hit mask is 40 to set bit on object 0 and object 1
257	255	// hit mask is 20 to set bit on object 1 only
258	256
259		Y0 = state->m_pmcram[0];
260		Y0 = (Y0 << 8) + state->m_pmcram[1];
	257	Y0 = m_pmcram[0];
	258	Y0 = (Y0 << 8) + m_pmcram[1];
261	259	Y0 = (Y0 - 15) / 5;
262		Y1 = (state->m_pmcram[2] - 15) / 5;
	260	Y1 = (m_pmcram[2] - 15) / 5;
263	261
264		if (state->m_pmcram[5] < 16)
	262	if (m_pmcram[5] < 16)
265	263	{
266	264	// US Thunder Cross uses this form
267		X0 = state->m_pmcram[5];
268		X0 = (X0 << 8) + state->m_pmcram[6];
	265	X0 = m_pmcram[5];
	266	X0 = (X0 << 8) + m_pmcram[6];
269	267	X0 = (X0 - 16) / 5;
270		X1 = (state->m_pmcram[7] - 16) / 5;
	268	X1 = (m_pmcram[7] - 16) / 5;
271	269	}
272	270	else
273	271	{
274	272	// Japan Thunder Cross uses this form
275		X0 = (state->m_pmcram[5] - 16) / 5;
276		X1 = (state->m_pmcram[6] - 16) / 5;
	273	X0 = (m_pmcram[5] - 16) / 5;
	274	X1 = (m_pmcram[6] - 16) / 5;
277	275	}
278	276
279		CM = state->m_pmcram[3];
280		HM = state->m_pmcram[4];
	277	CM = m_pmcram[3];
	278	HM = m_pmcram[4];
281	279
282		run_collisions(machine, X0, Y0, X1, Y1, CM, HM);
	280	run_collisions(X0, Y0, X1, Y1, CM, HM);
283	281	}
284	282
285	283	READ8_MEMBER(thunderx_state::thunderx_1f98_r)
r21022	r21023
300	298	/* bit 2 = do collision detection when 0->1 */
301	299	if ((data & 4) && !(m_1f98_data & 4))
302	300	{
303		calculate_collisions(machine());
	301	calculate_collisions();
304	302
305	303	/* 100 cycle delay is arbitrary */
306	304	machine().scheduler().timer_set(downcast<cpu_device *>(&space.device())->cycles_to_attotime(100), timer_expired_delegate(FUNC(thunderx_state::thunderx_firq_callback),this));

trunk/src/mame/drivers/tank8.c

r21022	r21023
11	11
12	12
13	13
14		void tank8_set_collision(running_machine &machine, int index)
	14	void tank8_state::tank8_set_collision(int index)
15	15	{
16		tank8_state *state = machine.driver_data<tank8_state>();
17		machine.device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
	16	machine().device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
18	17
19		state->m_collision_index = index;
	18	m_collision_index = index;
20	19	}
21	20
22	21

trunk/src/mame/drivers/tigeroad.c

r21022	r21023
79	79	0x0003, 0x0080, 0x0006, 0x0060, 0x0000, 0x00e0, 0x000a, 0x00c0, 0x0003, 0x0080, 0x0006, 0x0060, 0x0000, 0x00e0, 0x000a, 0x00c0,
80	80	0x0003, 0x0080, 0x0006, 0x0060, 0x0000, 0x00e0, 0x000a, 0x00c0, 0x0003, 0x0080, 0x0006, 0x0060, 0x0000, 0x00e0, 0x000a, 0x00c0 };
81	81
82		static void f1dream_protection_w(address_space &space)
	82	void tigeroad_state::f1dream_protection_w(address_space &space)
83	83	{
84		tigeroad_state *state = space.machine().driver_data<tigeroad_state>();
85	84	int indx;
86	85	int value = 255;
87	86	int prevpc = space.device().safe_pcbase();
r21022	r21023
89	88	if (prevpc == 0x244c)
90	89	{
91	90	/* Called once, when a race is started.*/
92		indx = state->m_ram16[0x3ff0/2];
93		state->m_ram16[0x3fe6/2] = f1dream_2450_lookup[indx];
94		state->m_ram16[0x3fe8/2] = f1dream_2450_lookup[++indx];
95		state->m_ram16[0x3fea/2] = f1dream_2450_lookup[++indx];
96		state->m_ram16[0x3fec/2] = f1dream_2450_lookup[++indx];
	91	indx = m_ram16[0x3ff0/2];
	92	m_ram16[0x3fe6/2] = f1dream_2450_lookup[indx];
	93	m_ram16[0x3fe8/2] = f1dream_2450_lookup[++indx];
	94	m_ram16[0x3fea/2] = f1dream_2450_lookup[++indx];
	95	m_ram16[0x3fec/2] = f1dream_2450_lookup[++indx];
97	96	}
98	97	else if (prevpc == 0x613a)
99	98	{
100	99	/* Called for every sprite on-screen.*/
101		if (state->m_ram16[0x3ff6/2] < 15)
	100	if (m_ram16[0x3ff6/2] < 15)
102	101	{
103		indx = f1dream_613ea_lookup[state->m_ram16[0x3ff6/2]] - state->m_ram16[0x3ff4/2];
	102	indx = f1dream_613ea_lookup[m_ram16[0x3ff6/2]] - m_ram16[0x3ff4/2];
104	103	if (indx > 255)
105	104	{
106	105	indx <<= 4;
107		indx += state->m_ram16[0x3ff6/2] & 0x00ff;
	106	indx += m_ram16[0x3ff6/2] & 0x00ff;
108	107	value = f1dream_613eb_lookup[indx];
109	108	}
110	109	}
111	110
112		state->m_ram16[0x3ff2/2] = value;
	111	m_ram16[0x3ff2/2] = value;
113	112	}
114	113	else if (prevpc == 0x17b70)
115	114	{
116	115	/* Called only before a real race, not a time trial.*/
117		if (state->m_ram16[0x3ff0/2] >= 0x04) indx = 128;
118		else if (state->m_ram16[0x3ff0/2] > 0x02) indx = 96;
119		else if (state->m_ram16[0x3ff0/2] == 0x02) indx = 64;
120		else if (state->m_ram16[0x3ff0/2] == 0x01) indx = 32;
	116	if (m_ram16[0x3ff0/2] >= 0x04) indx = 128;
	117	else if (m_ram16[0x3ff0/2] > 0x02) indx = 96;
	118	else if (m_ram16[0x3ff0/2] == 0x02) indx = 64;
	119	else if (m_ram16[0x3ff0/2] == 0x01) indx = 32;
121	120	else indx = 0;
122	121
123		indx += state->m_ram16[0x3fee/2];
	122	indx += m_ram16[0x3fee/2];
124	123	if (indx < 128)
125	124	{
126		state->m_ram16[0x3fe6/2] = f1dream_17b74_lookup[indx];
127		state->m_ram16[0x3fe8/2] = f1dream_17b74_lookup[++indx];
128		state->m_ram16[0x3fea/2] = f1dream_17b74_lookup[++indx];
129		state->m_ram16[0x3fec/2] = f1dream_17b74_lookup[++indx];
	125	m_ram16[0x3fe6/2] = f1dream_17b74_lookup[indx];
	126	m_ram16[0x3fe8/2] = f1dream_17b74_lookup[++indx];
	127	m_ram16[0x3fea/2] = f1dream_17b74_lookup[++indx];
	128	m_ram16[0x3fec/2] = f1dream_17b74_lookup[++indx];
130	129	}
131	130	else
132	131	{
133		state->m_ram16[0x3fe6/2] = 0x00ff;
134		state->m_ram16[0x3fe8/2] = 0x00ff;
135		state->m_ram16[0x3fea/2] = 0x00ff;
136		state->m_ram16[0x3fec/2] = 0x00ff;
	132	m_ram16[0x3fe6/2] = 0x00ff;
	133	m_ram16[0x3fe8/2] = 0x00ff;
	134	m_ram16[0x3fea/2] = 0x00ff;
	135	m_ram16[0x3fec/2] = 0x00ff;
137	136	}
138	137	}
139	138	else if ((prevpc == 0x27f8) || (prevpc == 0x511a) || (prevpc == 0x5142) || (prevpc == 0x516a))
140	139	{
141	140	/* The main CPU stuffs the byte for the soundlatch into 0xfffffd.*/
142		state->soundlatch_byte_w(space,2,state->m_ram16[0x3ffc/2]);
	141	soundlatch_byte_w(space,2,m_ram16[0x3ffc/2]);
143	142	}
144	143	}
145	144

trunk/src/mame/drivers/twincobr.c

r21022	r21023
1081	1081
1082	1082	DRIVER_INIT_MEMBER(twincobr_state,twincobr)
1083	1083	{
1084		twincobr_driver_savestate(machine());
	1084	twincobr_driver_savestate();
1085	1085	}
1086	1086
1087	1087

trunk/src/mame/drivers/turbo.c

r21022	r21023
1527	1527	*
1528	1528	*************************************/
1529	1529
1530		static void turbo_rom_decode(running_machine &machine)
	1530	void turbo_state::turbo_rom_decode()
1531	1531	{
1532	1532	/*
1533	1533	* The table is arranged this way (second half is mirror image of first)
r21022	r21023
1613	1613	2,1,2,1  /* 0x5000-0x5fff */
1614	1614	};
1615	1615
1616		UINT8 *RAM = machine.root_device().memregion("maincpu")->base();
	1616	UINT8 *RAM = machine().root_device().memregion("maincpu")->base();
1617	1617	int offs, i, j;
1618	1618	UINT8 src;
1619	1619
r21022	r21023
1637	1637
1638	1638	DRIVER_INIT_MEMBER(turbo_state,turbo_enc)
1639	1639	{
1640		turbo_rom_decode(machine());
	1640	turbo_rom_decode();
1641	1641	}
1642	1642
1643	1643

trunk/src/mame/drivers/taito_b.c

r21022	r21023
2743	2743	MACHINE_CONFIG_END
2744	2744
2745	2745	#if 0
2746		static void ryujin_patch(void)
	2746	void taitob_state::ryujin_patch(void)
2747	2747	{
2748		UINT16 *rom = (UINT16*)machine.root_device().memregion("maincpu")->base();
	2748	UINT16 *rom = (UINT16*)machine().root_device().memregion("maincpu")->base();
2749	2749	rom[ 0x62/2 ] = 1;
2750	2750	//0 (already in rom) - Taito Corporation 1993
2751	2751	//1 - Taito America corp with blue FBI logo
r21022	r21023
2796	2796	MACHINE_CONFIG_END
2797	2797
2798	2798	#if 0
2799		static void sbm_patch(void)
	2799	void taitob_state::sbm_patch(void)
2800	2800	{
2801		UINT16 *rom = (UINT16*)machine.root_device().memregion("maincpu")->base();
	2801	UINT16 *rom = (UINT16*)machine().root_device().memregion("maincpu")->base();
2802	2802	rom[ 0x7ffff/2 ] = 2; //US version
2803	2803	}
2804	2804	#endif

trunk/src/mame/drivers/tceptor.c

r21022	r21023
95	95
96	96
97	97	/* fix dsw/input data to memory mapped data */
98		static UINT8 fix_input0(UINT8 in1, UINT8 in2)
	98	UINT8 tceptor_state::fix_input0(UINT8 in1, UINT8 in2)
99	99	{
100	100	UINT8 r = 0;
101	101
r21022	r21023
111	111	return r;
112	112	}
113	113
114		static UINT8 fix_input1(UINT8 in1, UINT8 in2)
	114	UINT8 tceptor_state::fix_input1(UINT8 in1, UINT8 in2)
115	115	{
116	116	UINT8 r = 0;
117	117

trunk/src/mame/drivers/toaplan1.c

r21022	r21023
2515	2515
2516	2516	DRIVER_INIT_MEMBER(toaplan1_state,toaplan1)
2517	2517	{
2518		toaplan1_driver_savestate(machine());
	2518	toaplan1_driver_savestate();
2519	2519	}
2520	2520
2521	2521	DRIVER_INIT_MEMBER(toaplan1_state,demonwld)
2522	2522	{
2523		toaplan1_driver_savestate(machine());
2524		demonwld_driver_savestate(machine());
	2523	toaplan1_driver_savestate();
	2524	demonwld_driver_savestate();
2525	2525	}
2526	2526
2527	2527	DRIVER_INIT_MEMBER(toaplan1_state,vimana)
2528	2528	{
2529		toaplan1_driver_savestate(machine());
2530		vimana_driver_savestate(machine());
	2529	toaplan1_driver_savestate();
	2530	vimana_driver_savestate();
2531	2531	}
2532	2532
2533	2533

trunk/src/mame/drivers/tubep.c

r21022	r21023
283	283	if (scanline == 16)
284	284	{
285	285	logerror("/nmi CPU#3\n");
286		tubep_vblank_end(machine()); /* switch buffered sprite RAM page */
	286	tubep_vblank_end(); /* switch buffered sprite RAM page */
287	287	machine().device("mcu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
288	288	}
289	289	/* CPU #3 MS2010-A NMI */
r21022	r21023
323	323	*
324	324	*************************************/
325	325
326		static void tubep_setup_save_state(running_machine &machine)
	326	void tubep_state::tubep_setup_save_state()
327	327	{
328		tubep_state *state = machine.driver_data<tubep_state>();
329	328	/* Set up save state */
330		state_save_register_global(machine, state->m_sound_latch);
331		state_save_register_global(machine, state->m_ls74);
332		state_save_register_global(machine, state->m_ls377);
	329	state_save_register_global(machine(), m_sound_latch);
	330	state_save_register_global(machine(), m_ls74);
	331	state_save_register_global(machine(), m_ls377);
333	332	}
334	333
335	334
r21022	r21023
339	338	/* Create interrupt timer */
340	339	m_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tubep_state::tubep_scanline_callback),this));
341	340
342		tubep_setup_save_state(machine());
	341	tubep_setup_save_state();
343	342	}
344	343
345	344
r21022	r21023
465	464	if (scanline == 16)
466	465	{
467	466	logerror("/nmi CPU#3\n");
468		tubep_vblank_end(machine()); /* switch buffered sprite RAM page */
	467	tubep_vblank_end(); /* switch buffered sprite RAM page */
469	468	machine().device("mcu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
470	469	}
471	470	/* CPU #3 MS2010-A NMI */
r21022	r21023
502	501	/* Create interrupt timer */
503	502	m_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tubep_state::rjammer_scanline_callback),this));
504	503
505		tubep_setup_save_state(machine());
	504	tubep_setup_save_state();
506	505	}
507	506
508	507	MACHINE_RESET_MEMBER(tubep_state,rjammer)

trunk/src/mame/drivers/tetrisp2.c

r21022	r21023
1268	1268	machine().device("sub")->execute().set_input_line(1, HOLD_LINE);
1269	1269	}
1270	1270
1271		static void init_rockn_timer(running_machine &machine)
	1271	void tetrisp2_state::init_rockn_timer()
1272	1272	{
1273		tetrisp2_state *state = machine.driver_data<tetrisp2_state>();
1274		machine.scheduler().timer_pulse(attotime::from_msec(32), timer_expired_delegate(FUNC(tetrisp2_state::rockn_timer_level1_callback),state));
1275		state->m_rockn_timer_l4 = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(tetrisp2_state::rockn_timer_level4_callback),state));
	1273	machine().scheduler().timer_pulse(attotime::from_msec(32), timer_expired_delegate(FUNC(tetrisp2_state::rockn_timer_level1_callback),this));
	1274	m_rockn_timer_l4 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tetrisp2_state::rockn_timer_level4_callback),this));
1276	1275
1277		state_save_register_global_array(machine, state->m_systemregs);
1278		state_save_register_global_array(machine, state->m_rocknms_sub_systemregs);
1279		state_save_register_global(machine, state->m_rockn_protectdata);
1280		state_save_register_global(machine, state->m_rockn_adpcmbank);
1281		state_save_register_global(machine, state->m_rockn_soundvolume);
	1276	state_save_register_global_array(machine(), m_systemregs);
	1277	state_save_register_global_array(machine(), m_rocknms_sub_systemregs);
	1278	state_save_register_global(machine(), m_rockn_protectdata);
	1279	state_save_register_global(machine(), m_rockn_adpcmbank);
	1280	state_save_register_global(machine(), m_rockn_soundvolume);
1282	1281	}
1283	1282
1284	1283	DRIVER_INIT_MEMBER(tetrisp2_state,rockn)
1285	1284	{
1286		init_rockn_timer(machine());
	1285	init_rockn_timer();
1287	1286	m_rockn_protectdata = 1;
1288	1287	}
1289	1288
1290	1289	DRIVER_INIT_MEMBER(tetrisp2_state,rockn1)
1291	1290	{
1292		init_rockn_timer(machine());
	1291	init_rockn_timer();
1293	1292	m_rockn_protectdata = 1;
1294	1293	}
1295	1294
1296	1295	DRIVER_INIT_MEMBER(tetrisp2_state,rockn2)
1297	1296	{
1298		init_rockn_timer(machine());
	1297	init_rockn_timer();
1299	1298	m_rockn_protectdata = 2;
1300	1299	}
1301	1300
1302	1301	DRIVER_INIT_MEMBER(tetrisp2_state,rocknms)
1303	1302	{
1304		init_rockn_timer(machine());
	1303	init_rockn_timer();
1305	1304
1306	1305	machine().scheduler().timer_pulse(attotime::from_msec(32), timer_expired_delegate(FUNC(tetrisp2_state::rockn_timer_sub_level1_callback),this));
1307	1306	m_rockn_timer_sub_l4 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tetrisp2_state::rockn_timer_sub_level4_callback),this));
r21022	r21023
1312	1311
1313	1312	DRIVER_INIT_MEMBER(tetrisp2_state,rockn3)
1314	1313	{
1315		init_rockn_timer(machine());
	1314	init_rockn_timer();
1316	1315	m_rockn_protectdata = 4;
1317	1316	}
1318	1317
1319	1318	DRIVER_INIT_MEMBER(stepstag_state,stepstag)
1320	1319	{
1321		init_rockn_timer(machine());        // used
	1320	init_rockn_timer();        // used
1322	1321	m_rockn_protectdata = 1;    // unused?
1323	1322	}
1324	1323

trunk/src/mame/drivers/wardner.c

r21022	r21023
597	597	DRIVER_INIT_MEMBER(wardner_state,wardner)
598	598	{
599	599	m_ROM = machine().root_device().memregion("maincpu")->base();
600		twincobr_driver_savestate(machine());   /* Save-State stuff in src/machine/twincobr.c */
	600	twincobr_driver_savestate();   /* Save-State stuff in src/machine/twincobr.c */
601	601	}
602	602
603	603

trunk/src/mame/drivers/tumbleb.c

r21022	r21023
466	466	};
467	467
468	468	/* we use channels 1,2,3 for sound effects, and channel 4 for music */
469		static void tumbleb2_set_music_bank( running_machine &machine, int bank )
	469	void tumbleb_state::tumbleb2_set_music_bank( int bank )
470	470	{
471		UINT8 *oki = machine.root_device().memregion("oki")->base();
	471	UINT8 *oki = machine().root_device().memregion("oki")->base();
472	472	memcpy(&oki[0x38000], &oki[0x80000 + 0x38000 + 0x8000 * bank], 0x8000);
473	473	}
474	474
475		static void tumbleb2_play_sound( okim6295_device *oki, int data )
	475	void tumbleb_state::tumbleb2_play_sound( okim6295_device *oki, int data )
476	476	{
477	477	int status = oki->read_status();
478	478
r21022	r21023
505	505	// bank 7 = how to play?
506	506	// bank 8 = boss???
507	507
508		static void process_tumbleb2_music_command( okim6295_device *oki, int data )
	508	void tumbleb_state::process_tumbleb2_music_command( okim6295_device *oki, int data )
509	509	{
510		tumbleb_state *state = oki->machine().driver_data<tumbleb_state>();
511	510	int status = oki->read_status();
512	511
513	512	if (data == 1) // stop?
r21022	r21023
515	514	if (BIT(status, 3))
516	515	{
517	516	oki->write_command(0x40);       /* Stop playing music */
518		state->m_music_is_playing = 0;
	517	m_music_is_playing = 0;
519	518	}
520	519	}
521	520	else
522	521	{
523		if (state->m_music_is_playing != data)
	522	if (m_music_is_playing != data)
524	523	{
525		state->m_music_is_playing = data;
	524	m_music_is_playing = data;
526	525	oki->write_command(0x40); // stop the current music
527	526	switch (data)
528	527	{
529	528	case 0x04: // map screen
530		state->m_music_bank = 1;
531		state->m_music_command = 0x38;
	529	m_music_bank = 1;
	530	m_music_command = 0x38;
532	531	break;
533	532
534	533	case 0x05: // america
535		state->m_music_bank = 6;
536		state->m_music_command = 0x38;
	534	m_music_bank = 6;
	535	m_music_command = 0x38;
537	536	break;
538	537
539	538	case 0x06: // asia
540		state->m_music_bank = 2;
541		state->m_music_command = 0x38;
	539	m_music_bank = 2;
	540	m_music_command = 0x38;
542	541	break;
543	542
544	543	case 0x07: // africa/egypt -- don't seem to have a tune for this one
545		state->m_music_bank = 4;
546		state->m_music_command = 0x38;
	544	m_music_bank = 4;
	545	m_music_command = 0x38;
547	546	break;
548	547
549	548	case 0x08: // antartica
550		state->m_music_bank = 3;
551		state->m_music_command = 0x38;
	549	m_music_bank = 3;
	550	m_music_command = 0x38;
552	551	break;
553	552
554	553	case 0x09: // brazil / south america
555		state->m_music_bank = 4;
556		state->m_music_command = 0x38;
	554	m_music_bank = 4;
	555	m_music_command = 0x38;
557	556	break;
558	557
559	558	case 0x0a: // japan -- don't seem to have a tune
560		state->m_music_bank = 2;
561		state->m_music_command = 0x38;
	559	m_music_bank = 2;
	560	m_music_command = 0x38;
562	561	break;
563	562
564	563	case 0x0b: // australia
565		state->m_music_bank = 5;
566		state->m_music_command = 0x38;
	564	m_music_bank = 5;
	565	m_music_command = 0x38;
567	566	break;
568	567
569	568	case 0x0c: // france/europe
570		state->m_music_bank = 6;
571		state->m_music_command = 0x38;
	569	m_music_bank = 6;
	570	m_music_command = 0x38;
572	571	break;
573	572
574	573	case 0x0d: // how to play
575		state->m_music_bank = 7;
576		state->m_music_command = 0x38;
	574	m_music_bank = 7;
	575	m_music_command = 0x38;
577	576	break;
578	577
579	578	case 0x0f: // stage clear
580		state->m_music_bank = 0;
581		state->m_music_command = 0x33;
	579	m_music_bank = 0;
	580	m_music_command = 0x33;
582	581	break;
583	582
584	583	case 0x10: // boss stage
585		state->m_music_bank = 8;
586		state->m_music_command = 0x38;
	584	m_music_bank = 8;
	585	m_music_command = 0x38;
587	586	break;
588	587
589	588	case 0x12: // world clear
590		state->m_music_bank = 0;
591		state->m_music_command = 0x34;
	589	m_music_bank = 0;
	590	m_music_command = 0x34;
592	591	break;
593	592
594	593	default: // anything else..
595		state->m_music_bank = 8;
596		state->m_music_command = 0x38;
	594	m_music_bank = 8;
	595	m_music_command = 0x38;
597	596	break;
598	597	}
599	598
600		tumbleb2_set_music_bank(oki->machine(), state->m_music_bank);
	599	tumbleb2_set_music_bank(m_music_bank);
601	600	tumbleb2_playmusic(oki);
602	601	}
603	602	}
r21022	r21023
3192	3191	/******************************************************************************/
3193	3192
3194	3193	#if TUMBLEP_HACK
3195		void tumblepb_patch_code(running_machine &machine, UINT16 offset)
	3194	void tumbleb_state::tumblepb_patch_code(UINT16 offset)
3196	3195	{
3197	3196	/* A hack which enables all Dip Switches effects */
3198		UINT16 *RAM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	3197	UINT16 *RAM = (UINT16 *)machine().root_device().memregion("maincpu")->base();
3199	3198	RAM[(offset + 0)/2] = 0x0240;
3200	3199	RAM[(offset + 2)/2] = 0xffff;   // andi.w  #$f3ff, D0
3201	3200	}
3202	3201	#endif
3203	3202
3204	3203
3205		static void tumblepb_gfx_rearrange(running_machine &machine, int rgn)
	3204	void tumbleb_state::tumblepb_gfx_rearrange(int rgn)
3206	3205	{
3207	3206	UINT8* rom;
3208	3207	int len;
3209	3208
3210	3209	if (rgn == 1)
3211	3210	{
3212		rom = machine.root_device().memregion("tilegfx")->base();
3213		len = machine.root_device().memregion("tilegfx")->bytes();
	3211	rom = machine().root_device().memregion("tilegfx")->base();
	3212	len = machine().root_device().memregion("tilegfx")->bytes();
3214	3213	}
3215	3214	else
3216	3215	{
3217		rom = machine.root_device().memregion("sprgfx")->base();
3218		len = machine.root_device().memregion("sprgfx")->bytes();
	3216	rom = machine().root_device().memregion("sprgfx")->base();
	3217	len = machine().root_device().memregion("sprgfx")->bytes();
3219	3218	}
3220	3219
3221	3220	int i;
r21022	r21023
3237	3236
3238	3237	DRIVER_INIT_MEMBER(tumbleb_state,tumblepb)
3239	3238	{
3240		tumblepb_gfx_rearrange(machine(), 1);
	3239	tumblepb_gfx_rearrange(1);
3241	3240
3242	3241	#if TUMBLEP_HACK
3243		tumblepb_patch_code(machine(), 0x000132);
	3242	tumblepb_patch_code(0x000132);
3244	3243	#endif
3245	3244	}
3246	3245
3247	3246	DRIVER_INIT_MEMBER(tumbleb_state,tumblepba)
3248	3247	{
3249	3248	// rearrange the bg data instead of the sprite data on this one!
3250		tumblepb_gfx_rearrange(machine(), 2);
	3249	tumblepb_gfx_rearrange(2);
3251	3250	}
3252	3251
3253	3252	DRIVER_INIT_MEMBER(tumbleb_state,tumbleb2)
3254	3253	{
3255		tumblepb_gfx_rearrange(machine(), 1);
	3254	tumblepb_gfx_rearrange(1);
3256	3255
3257	3256	#if TUMBLEP_HACK
3258		tumblepb_patch_code(machine(), 0x000132);
	3257	tumblepb_patch_code(0x000132);
3259	3258	#endif
3260	3259	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x100000, 0x100001, write16_delegate(FUNC(tumbleb_state::tumbleb2_soundmcu_w),this));
3261	3260
r21022	r21023
3263	3262
3264	3263	DRIVER_INIT_MEMBER(tumbleb_state,jumpkids)
3265	3264	{
3266		tumblepb_gfx_rearrange(machine(), 1);
	3265	tumblepb_gfx_rearrange(1);
3267	3266
3268	3267	#if TUMBLEP_HACK
3269		tumblepb_patch_code(machine(), 0x00013a);
	3268	tumblepb_patch_code(0x00013a);
3270	3269	#endif
3271	3270	}
3272	3271
3273	3272	DRIVER_INIT_MEMBER(tumbleb_state,fncywld)
3274	3273	{
3275		tumblepb_gfx_rearrange(machine(), 1);
	3274	tumblepb_gfx_rearrange(1);
3276	3275
3277	3276	#if FNCYWLD_HACK
3278	3277	/* This is a hack to allow you to use the extra features
r21022	r21023
3294	3293
3295	3294	DRIVER_INIT_MEMBER(tumbleb_state,bcstory)
3296	3295	{
3297		tumblepb_gfx_rearrange(machine(), 1);
	3296	tumblepb_gfx_rearrange(1);
3298	3297	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x180008, 0x180009, read16_delegate(FUNC(tumbleb_state::bcstory_1a0_read),this)); // io should be here??
3299	3298	}
3300	3299
r21022	r21023
3308	3307	for (i = 0; i < len / 2; i++)
3309	3308	m_mainram[0x000/2 + i] = PROTDATA[i];
3310	3309
3311		tumblepb_gfx_rearrange(machine(), 1);
	3310	tumblepb_gfx_rearrange(1);
3312	3311
3313	3312	}
3314	3313
3315	3314
3316		static void suprtrio_decrypt_code(running_machine &machine)
	3315	void tumbleb_state::suprtrio_decrypt_code()
3317	3316	{
3318		UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
3319		UINT16 *buf = auto_alloc_array(machine, UINT16, 0x80000/2);
	3317	UINT16 *rom = (UINT16 *)machine().root_device().memregion("maincpu")->base();
	3318	UINT16 *buf = auto_alloc_array(machine(), UINT16, 0x80000/2);
3320	3319	int i;
3321	3320
3322	3321	/* decrypt main ROMs */
r21022	r21023
3328	3327	if ((i & 3) == 0) j ^= 0x08;
3329	3328	rom[i] = buf[j];
3330	3329	}
3331		auto_free(machine, buf);
	3330	auto_free(machine(), buf);
3332	3331	}
3333	3332
3334		static void suprtrio_decrypt_gfx(running_machine &machine)
	3333	void tumbleb_state::suprtrio_decrypt_gfx()
3335	3334	{
3336		UINT16 *rom = (UINT16 *)machine.root_device().memregion("tilegfx")->base();
3337		UINT16 *buf = auto_alloc_array(machine, UINT16, 0x100000/2);
	3335	UINT16 *rom = (UINT16 *)machine().root_device().memregion("tilegfx")->base();
	3336	UINT16 *buf = auto_alloc_array(machine(), UINT16, 0x100000/2);
3338	3337	int i;
3339	3338
3340	3339	/* decrypt tiles */
r21022	r21023
3345	3344	if (i & 1) j ^= 0x04;
3346	3345	rom[i] = buf[j];
3347	3346	}
3348		auto_free(machine, buf);
	3347	auto_free(machine(), buf);
3349	3348	}
3350	3349
3351	3350	DRIVER_INIT_MEMBER(tumbleb_state,suprtrio)
3352	3351	{
3353		suprtrio_decrypt_code(machine());
3354		suprtrio_decrypt_gfx(machine());
	3352	suprtrio_decrypt_code();
	3353	suprtrio_decrypt_gfx();
3355	3354	}
3356	3355
3357	3356	DRIVER_INIT_MEMBER(tumbleb_state,chokchok)
r21022	r21023
3367	3366
3368	3367	DRIVER_INIT_MEMBER(tumbleb_state,wlstar)
3369	3368	{
3370		tumblepb_gfx_rearrange(machine(), 1);
	3369	tumblepb_gfx_rearrange(1);
3371	3370
3372	3371	/* slightly different banking */
3373	3372	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x100002, 0x100003, write16_delegate(FUNC(tumbleb_state::wlstar_tilebank_w),this));
r21022	r21023
3383	3382
3384	3383	DRIVER_INIT_MEMBER(tumbleb_state,dquizgo)
3385	3384	{
3386		tumblepb_gfx_rearrange(machine(), 1);
	3385	tumblepb_gfx_rearrange(1);
3387	3386	}
3388	3387
3389	3388

trunk/src/mame/drivers/thief.c

r21022	r21023
59	59	kTalkTrack, kCrashTrack
60	60	};
61	61
62		static void tape_set_audio( samples_device *samples, int track, int bOn )
	62	void thief_state::tape_set_audio( samples_device *samples, int track, int bOn )
63	63	{
64	64	samples->set_volume(track, bOn ? 1.0 : 0.0 );
65	65	}
66	66
67		static void tape_set_motor( samples_device *samples, int bOn )
	67	void thief_state::tape_set_motor( samples_device *samples, int bOn )
68	68	{
69	69	if( bOn )
70	70	{

trunk/src/mame/machine/toaplan1.c

r21022	r21023
128	128	}
129	129
130	130
131		static void demonwld_dsp(running_machine &machine, int enable)
	131	void toaplan1_state::demonwld_dsp(int enable)
132	132	{
133		toaplan1_state *state = machine.driver_data<toaplan1_state>();
134	133
135		state->m_dsp_on = enable;
	134	m_dsp_on = enable;
136	135	if (enable)
137	136	{
138	137	logerror("Turning DSP on and 68000 off\n");
139		machine.device("dsp")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
140		machine.device("dsp")->execute().set_input_line(0, ASSERT_LINE); /* TMS32010 INT */
141		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	138	machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	139	machine().device("dsp")->execute().set_input_line(0, ASSERT_LINE); /* TMS32010 INT */
	140	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
142	141	}
143	142	else
144	143	{
145	144	logerror("Turning DSP off\n");
146		machine.device("dsp")->execute().set_input_line(0, CLEAR_LINE); /* TMS32010 INT */
147		machine.device("dsp")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	145	machine().device("dsp")->execute().set_input_line(0, CLEAR_LINE); /* TMS32010 INT */
	146	machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
148	147	}
149	148	}
150	149
151	150	void toaplan1_state::demonwld_restore_dsp()
152	151	{
153		demonwld_dsp(machine(), m_dsp_on);
	152	demonwld_dsp(m_dsp_on);
154	153	}
155	154
156	155	WRITE16_MEMBER(toaplan1_state::demonwld_dsp_ctrl_w)
r21022	r21023
163	162	{
164	163	switch (data)
165	164	{
166		case 0x00:  demonwld_dsp(machine(), 1); break;  /* Enable the INT line to the DSP */
167		case 0x01:  demonwld_dsp(machine(), 0); break;  /* Inhibit the INT line to the DSP */
	165	case 0x00:  demonwld_dsp(1); break;  /* Enable the INT line to the DSP */
	166	case 0x01:  demonwld_dsp(0); break;  /* Inhibit the INT line to the DSP */
168	167	default:    logerror("68000:%04x  Writing unknown command %08x to %08x\n",space.device().safe_pcbase() ,data ,0xe0000a + offset); break;
169	168	}
170	169	}
r21022	r21023
380	379	coin_lockout_global_w(machine(), 0);
381	380	}
382	381
383		void toaplan1_driver_savestate(running_machine &machine)
	382	void toaplan1_state::toaplan1_driver_savestate()
384	383	{
385		toaplan1_state *state = machine.driver_data<toaplan1_state>();
386	384
387		state->save_item(NAME(state->m_intenable));
388		state->save_item(NAME(state->m_coin_count));
389		state->save_item(NAME(state->m_unk_reset_port));
	385	save_item(NAME(m_intenable));
	386	save_item(NAME(m_coin_count));
	387	save_item(NAME(m_unk_reset_port));
390	388	}
391	389
392	390	MACHINE_RESET_MEMBER(toaplan1_state,zerowing)/* Hack for ZeroWing and OutZone. See the video driver */
r21022	r21023
403	401	m_dsp_execute = 0;
404	402	}
405	403
406		void demonwld_driver_savestate(running_machine &machine)
	404	void toaplan1_state::demonwld_driver_savestate()
407	405	{
408		toaplan1_state *state = machine.driver_data<toaplan1_state>();
409	406
410		state->save_item(NAME(state->m_dsp_on));
411		state->save_item(NAME(state->m_dsp_addr_w));
412		state->save_item(NAME(state->m_main_ram_seg));
413		state->save_item(NAME(state->m_dsp_BIO));
414		state->save_item(NAME(state->m_dsp_execute));
415		machine.save().register_postload(save_prepost_delegate(FUNC(toaplan1_state::demonwld_restore_dsp), state));
	407	save_item(NAME(m_dsp_on));
	408	save_item(NAME(m_dsp_addr_w));
	409	save_item(NAME(m_main_ram_seg));
	410	save_item(NAME(m_dsp_BIO));
	411	save_item(NAME(m_dsp_execute));
	412	machine().save().register_postload(save_prepost_delegate(FUNC(toaplan1_state::demonwld_restore_dsp), this));
416	413	}
417	414
418	415	MACHINE_RESET_MEMBER(toaplan1_state,vimana)
r21022	r21023
423	420	m_vimana_latch = 0;
424	421	}
425	422
426		void vimana_driver_savestate(running_machine &machine)
	423	void toaplan1_state::vimana_driver_savestate()
427	424	{
428		toaplan1_state *state = machine.driver_data<toaplan1_state>();
429	425
430		state->save_item(NAME(state->m_vimana_coins[0]));
431		state->save_item(NAME(state->m_vimana_coins[1]));
432		state->save_item(NAME(state->m_vimana_credits));
433		state->save_item(NAME(state->m_vimana_latch));
	426	save_item(NAME(m_vimana_coins[0]));
	427	save_item(NAME(m_vimana_coins[1]));
	428	save_item(NAME(m_vimana_credits));
	429	save_item(NAME(m_vimana_latch));
434	430	}

trunk/src/mame/machine/tnzs.c

r21022	r21023
117	117	}
118	118
119	119
120		static void mcu_reset( running_machine &machine )
	120	void tnzs_state::mcu_reset(  )
121	121	{
122		tnzs_state *state = machine.driver_data<tnzs_state>();
123	122
124		state->m_mcu_initializing = 3;
125		state->m_mcu_coinage_init = 0;
126		state->m_mcu_coinage[0] = 1;
127		state->m_mcu_coinage[1] = 1;
128		state->m_mcu_coinage[2] = 1;
129		state->m_mcu_coinage[3] = 1;
130		state->m_mcu_coins_a = 0;
131		state->m_mcu_coins_b = 0;
132		state->m_mcu_credits = 0;
133		state->m_mcu_reportcoin = 0;
134		state->m_mcu_command = 0;
	123	m_mcu_initializing = 3;
	124	m_mcu_coinage_init = 0;
	125	m_mcu_coinage[0] = 1;
	126	m_mcu_coinage[1] = 1;
	127	m_mcu_coinage[2] = 1;
	128	m_mcu_coinage[3] = 1;
	129	m_mcu_coins_a = 0;
	130	m_mcu_coins_b = 0;
	131	m_mcu_credits = 0;
	132	m_mcu_reportcoin = 0;
	133	m_mcu_command = 0;
135	134	}
136	135
137		static void mcu_handle_coins( running_machine &machine, int coin )
	136	void tnzs_state::mcu_handle_coins( int coin )
138	137	{
139		tnzs_state *state = machine.driver_data<tnzs_state>();
140	138
141	139	/* The coin inputs and coin counters are managed by the i8742 mcu. */
142	140	/* Here we simulate it. */
r21022	r21023
144	142	/* Coin/Play settings must also be taken into consideration */
145	143
146	144	if (coin & 0x08)    /* tilt */
147		state->m_mcu_reportcoin = coin;
148		else if (coin && coin != state->m_insertcoin)
	145	m_mcu_reportcoin = coin;
	146	else if (coin && coin != m_insertcoin)
149	147	{
150	148	if (coin & 0x01)    /* coin A */
151	149	{
152	150	//          logerror("Coin dropped into slot A\n");
153		coin_counter_w(machine,0,1); coin_counter_w(machine,0,0); /* Count slot A */
154		state->m_mcu_coins_a++;
155		if (state->m_mcu_coins_a >= state->m_mcu_coinage[0])
	151	coin_counter_w(machine(),0,1); coin_counter_w(machine(),0,0); /* Count slot A */
	152	m_mcu_coins_a++;
	153	if (m_mcu_coins_a >= m_mcu_coinage[0])
156	154	{
157		state->m_mcu_coins_a -= state->m_mcu_coinage[0];
158		state->m_mcu_credits += state->m_mcu_coinage[1];
159		if (state->m_mcu_credits >= 9)
	155	m_mcu_coins_a -= m_mcu_coinage[0];
	156	m_mcu_credits += m_mcu_coinage[1];
	157	if (m_mcu_credits >= 9)
160	158	{
161		state->m_mcu_credits = 9;
162		coin_lockout_global_w(machine, 1); /* Lock all coin slots */
	159	m_mcu_credits = 9;
	160	coin_lockout_global_w(machine(), 1); /* Lock all coin slots */
163	161	}
164	162	else
165	163	{
166		coin_lockout_global_w(machine, 0); /* Unlock all coin slots */
	164	coin_lockout_global_w(machine(), 0); /* Unlock all coin slots */
167	165	}
168	166	}
169	167	}
r21022	r21023
171	169	if (coin & 0x02)    /* coin B */
172	170	{
173	171	//          logerror("Coin dropped into slot B\n");
174		coin_counter_w(machine,1,1); coin_counter_w(machine,1,0); /* Count slot B */
175		state->m_mcu_coins_b++;
176		if (state->m_mcu_coins_b >= state->m_mcu_coinage[2])
	172	coin_counter_w(machine(),1,1); coin_counter_w(machine(),1,0); /* Count slot B */
	173	m_mcu_coins_b++;
	174	if (m_mcu_coins_b >= m_mcu_coinage[2])
177	175	{
178		state->m_mcu_coins_b -= state->m_mcu_coinage[2];
179		state->m_mcu_credits += state->m_mcu_coinage[3];
180		if (state->m_mcu_credits >= 9)
	176	m_mcu_coins_b -= m_mcu_coinage[2];
	177	m_mcu_credits += m_mcu_coinage[3];
	178	if (m_mcu_credits >= 9)
181	179	{
182		state->m_mcu_credits = 9;
183		coin_lockout_global_w(machine, 1); /* Lock all coin slots */
	180	m_mcu_credits = 9;
	181	coin_lockout_global_w(machine(), 1); /* Lock all coin slots */
184	182	}
185	183	else
186	184	{
187		coin_lockout_global_w(machine, 0); /* Unlock all coin slots */
	185	coin_lockout_global_w(machine(), 0); /* Unlock all coin slots */
188	186	}
189	187	}
190	188	}
r21022	r21023
192	190	if (coin & 0x04)    /* service */
193	191	{
194	192	//          logerror("Coin dropped into service slot C\n");
195		state->m_mcu_credits++;
	193	m_mcu_credits++;
196	194	}
197	195
198		state->m_mcu_reportcoin = coin;
	196	m_mcu_reportcoin = coin;
199	197	}
200	198	else
201	199	{
202		if (state->m_mcu_credits < 9)
203		coin_lockout_global_w(machine, 0); /* Unlock all coin slots */
	200	if (m_mcu_credits < 9)
	201	coin_lockout_global_w(machine(), 0); /* Unlock all coin slots */
204	202
205		state->m_mcu_reportcoin = 0;
	203	m_mcu_reportcoin = 0;
206	204	}
207		state->m_insertcoin = coin;
	205	m_insertcoin = coin;
208	206	}
209	207
210	208
r21022	r21023
629	627	coin |= ((ioport("COIN2")->read() & 1) << 1);
630	628	coin |= ((ioport("IN2")->read() & 3) << 2);
631	629	coin ^= 0x0c;
632		mcu_handle_coins(machine(), coin);
	630	mcu_handle_coins(coin);
633	631	break;
634	632	default:
635	633	break;
r21022	r21023
647	645	case MCU_EXTRMATN:
648	646	case MCU_DRTOPPEL:
649	647	case MCU_PLUMPOP:
650		mcu_reset(machine());
	648	mcu_reset();
651	649	break;
652	650	default:
653	651	break;
r21022	r21023
772	770	case MCU_PLUMPOP:
773	771	/* bit 2 resets the mcu */
774	772	if (data & 0x04)
775		mcu_reset(machine());
	773	mcu_reset();
776	774	break;
777	775	default:
778	776	break;

trunk/src/mame/machine/twincobr.c

r21022	r21023
174	174	}
175	175
176	176
177		static void twincobr_dsp(running_machine &machine, int enable)
	177	void twincobr_state::twincobr_dsp(int enable)
178	178	{
179		twincobr_state *state = machine.driver_data<twincobr_state>();
180		state->m_dsp_on = enable;
	179	m_dsp_on = enable;
181	180	if (enable) {
182	181	LOG(("Turning DSP on and main CPU off\n"));
183		machine.device("dsp")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
184		machine.device("dsp")->execute().set_input_line(0, ASSERT_LINE); /* TMS32010 INT */
185		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	182	machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	183	machine().device("dsp")->execute().set_input_line(0, ASSERT_LINE); /* TMS32010 INT */
	184	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
186	185	}
187	186	else {
188	187	LOG(("Turning DSP off\n"));
189		machine.device("dsp")->execute().set_input_line(0, CLEAR_LINE); /* TMS32010 INT */
190		machine.device("dsp")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	188	machine().device("dsp")->execute().set_input_line(0, CLEAR_LINE); /* TMS32010 INT */
	189	machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
191	190	}
192	191	}
193	192
194	193	void twincobr_state::twincobr_restore_dsp()
195	194	{
196		twincobr_dsp(machine(), m_dsp_on);
	195	twincobr_dsp(m_dsp_on);
197	196	}
198	197
199	198
200		static void toaplan0_control_w(running_machine &machine, int offset, int data)
	199	void twincobr_state::toaplan0_control_w(int offset, int data)
201	200	{
202		twincobr_state *state = machine.driver_data<twincobr_state>();
203		LOG(("%s:Writing %08x to %08x.\n",machine.describe_context(),data,toaplan_port_type[state->m_toaplan_main_cpu] - offset));
	201	LOG(("%s:Writing %08x to %08x.\n",machine().describe_context(),data,toaplan_port_type[m_toaplan_main_cpu] - offset));
204	202
205		if (state->m_toaplan_main_cpu == 1) {
206		if (data == 0x0c) { data = 0x1c; state->m_wardner_sprite_hack=0; }  /* Z80 ? */
207		if (data == 0x0d) { data = 0x1d; state->m_wardner_sprite_hack=1; }  /* Z80 ? */
	203	if (m_toaplan_main_cpu == 1) {
	204	if (data == 0x0c) { data = 0x1c; m_wardner_sprite_hack=0; }  /* Z80 ? */
	205	if (data == 0x0d) { data = 0x1d; m_wardner_sprite_hack=1; }  /* Z80 ? */
208	206	}
209	207
210	208	switch (data) {
211		case 0x0004: state->m_intenable = 0; break;
212		case 0x0005: state->m_intenable = 1; break;
213		case 0x0006: twincobr_flipscreen(machine, 0); break;
214		case 0x0007: twincobr_flipscreen(machine, 1); break;
215		case 0x0008: state->m_bg_ram_bank = 0x0000; break;
216		case 0x0009: state->m_bg_ram_bank = 0x1000; break;
217		case 0x000a: state->m_fg_rom_bank = 0x0000; break;
218		case 0x000b: state->m_fg_rom_bank = 0x1000; break;
219		case 0x000c: twincobr_dsp(machine, 1); break;    /* Enable the INT line to the DSP */
220		case 0x000d: twincobr_dsp(machine, 0); break;    /* Inhibit the INT line to the DSP */
221		case 0x000e: twincobr_display(machine, 0); break; /* Turn display off */
222		case 0x000f: twincobr_display(machine, 1); break; /* Turn display on */
	209	case 0x0004: m_intenable = 0; break;
	210	case 0x0005: m_intenable = 1; break;
	211	case 0x0006: twincobr_flipscreen(0); break;
	212	case 0x0007: twincobr_flipscreen(1); break;
	213	case 0x0008: m_bg_ram_bank = 0x0000; break;
	214	case 0x0009: m_bg_ram_bank = 0x1000; break;
	215	case 0x000a: m_fg_rom_bank = 0x0000; break;
	216	case 0x000b: m_fg_rom_bank = 0x1000; break;
	217	case 0x000c: twincobr_dsp(1); break;    /* Enable the INT line to the DSP */
	218	case 0x000d: twincobr_dsp(0); break;    /* Inhibit the INT line to the DSP */
	219	case 0x000e: twincobr_display(0); break; /* Turn display off */
	220	case 0x000f: twincobr_display(1); break; /* Turn display on */
223	221	}
224	222	}
225	223
r21022	r21023
227	225	{
228	226	if (ACCESSING_BITS_0_7)
229	227	{
230		toaplan0_control_w(machine(), offset, data & 0xff);
	228	toaplan0_control_w(offset, data & 0xff);
231	229	}
232	230	}
233	231
234	232	WRITE8_MEMBER(twincobr_state::wardner_control_w)
235	233	{
236		toaplan0_control_w(machine(), offset, data);
	234	toaplan0_control_w(offset, data);
237	235	}
238	236
239	237
r21022	r21023
251	249	}
252	250
253	251
254		static void toaplan0_coin_dsp_w(address_space &space, int offset, int data)
	252	void twincobr_state::toaplan0_coin_dsp_w(address_space &space, int offset, int data)
255	253	{
256		twincobr_state *state = space.machine().driver_data<twincobr_state>();
257	254	if (data > 1)
258		LOG(("%s:Writing %08x to %08x.\n",space.machine().describe_context(),data,toaplan_port_type[state->m_toaplan_main_cpu] - offset));
	255	LOG(("%s:Writing %08x to %08x.\n",machine().describe_context(),data,toaplan_port_type[m_toaplan_main_cpu] - offset));
259	256	switch (data) {
260		case 0x08: coin_counter_w(space.machine(), 0,0); break;
261		case 0x09: coin_counter_w(space.machine(), 0,1); break;
262		case 0x0a: coin_counter_w(space.machine(), 1,0); break;
263		case 0x0b: coin_counter_w(space.machine(), 1,1); break;
264		case 0x0c: coin_lockout_w(space.machine(), 0,1); break;
265		case 0x0d: coin_lockout_w(space.machine(), 0,0); break;
266		case 0x0e: coin_lockout_w(space.machine(), 1,1); break;
267		case 0x0f: coin_lockout_w(space.machine(), 1,0); break;
	257	case 0x08: coin_counter_w(machine(), 0,0); break;
	258	case 0x09: coin_counter_w(machine(), 0,1); break;
	259	case 0x0a: coin_counter_w(machine(), 1,0); break;
	260	case 0x0b: coin_counter_w(machine(), 1,1); break;
	261	case 0x0c: coin_lockout_w(machine(), 0,1); break;
	262	case 0x0d: coin_lockout_w(machine(), 0,0); break;
	263	case 0x0e: coin_lockout_w(machine(), 1,1); break;
	264	case 0x0f: coin_lockout_w(machine(), 1,0); break;
268	265	/****** The following apply to Flying Shark/Wardner only ******/
269	266	case 0x00:  /* This means assert the INT line to the DSP */
270	267	LOG(("Turning DSP on and main CPU off\n"));
271		space.machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
272		space.machine().device("dsp")->execute().set_input_line(0, ASSERT_LINE); /* TMS32010 INT */
273		space.machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	268	machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	269	machine().device("dsp")->execute().set_input_line(0, ASSERT_LINE); /* TMS32010 INT */
	270	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
274	271	break;
275	272	case 0x01:  /* This means inhibit the INT line to the DSP */
276	273	LOG(("Turning DSP off\n"));
277		space.machine().device("dsp")->execute().set_input_line(0, CLEAR_LINE); /* TMS32010 INT */
278		space.machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	274	machine().device("dsp")->execute().set_input_line(0, CLEAR_LINE); /* TMS32010 INT */
	275	machine().device("dsp")->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
279	276	break;
280	277	}
281	278	}
r21022	r21023
303	300	MACHINE_RESET_MEMBER(twincobr_state,twincobr)
304	301	{
305	302	m_toaplan_main_cpu = 0;     /* 68000 */
306		twincobr_display(machine(), 0);
	303	twincobr_display(0);
307	304	m_intenable = 0;
308	305	m_dsp_addr_w = 0;
309	306	m_main_ram_seg = 0;
r21022	r21023
318	315	MACHINE_RESET_CALL_MEMBER(twincobr);
319	316
320	317	m_toaplan_main_cpu = 1;     /* Z80 */
321		twincobr_display(machine(), 1);
	318	twincobr_display(1);
322	319	}
323	320
324		void twincobr_driver_savestate(running_machine &machine)
	321	void twincobr_state::twincobr_driver_savestate()
325	322	{
326		twincobr_state *state = machine.driver_data<twincobr_state>();
327	323
328		state_save_register_global(machine, state->m_toaplan_main_cpu);
329		state_save_register_global(machine, state->m_intenable);
330		state_save_register_global(machine, state->m_dsp_on);
331		state_save_register_global(machine, state->m_dsp_addr_w);
332		state_save_register_global(machine, state->m_main_ram_seg);
333		state_save_register_global(machine, state->m_dsp_BIO);
334		state_save_register_global(machine, state->m_dsp_execute);
335		state_save_register_global(machine, state->m_fsharkbt_8741);
336		state_save_register_global(machine, state->m_wardner_membank);
	324	state_save_register_global(machine(), m_toaplan_main_cpu);
	325	state_save_register_global(machine(), m_intenable);
	326	state_save_register_global(machine(), m_dsp_on);
	327	state_save_register_global(machine(), m_dsp_addr_w);
	328	state_save_register_global(machine(), m_main_ram_seg);
	329	state_save_register_global(machine(), m_dsp_BIO);
	330	state_save_register_global(machine(), m_dsp_execute);
	331	state_save_register_global(machine(), m_fsharkbt_8741);
	332	state_save_register_global(machine(), m_wardner_membank);
337	333
338		machine.save().register_postload(save_prepost_delegate(FUNC(twincobr_state::twincobr_restore_dsp), state));
	334	machine().save().register_postload(save_prepost_delegate(FUNC(twincobr_state::twincobr_restore_dsp), this));
339	335	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team