Previous

199869 Revisions

Next

r24768 Tuesday 6th August, 2013 at 04:31:30 UTC by Aaron Giles
Cave cleanup

[src/mame/includes]	cave.h
[src/mame/video]	cave.c

trunk/src/mame/includes/cave.h

r24767	r24768
62	62	} m_blit;
63	63
64	64
65		void (*m_get_sprite_info)(running_machine &machine);
66		void (*m_sprite_draw)(running_machine &machine, int priority);
	65	void (cave_state::*m_get_sprite_info)();
	66	void (cave_state::*m_sprite_draw)(int priority);
67	67
68	68	tilemap_t    *m_tilemap[4];
69	69	int          m_tiledim[4];
r24767	r24768
213	213	private:
214	214	inline void get_tile_info( tile_data &tileinfo, int tile_index, int GFX );
215	215	inline void tilemap_draw( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 flags, UINT32 priority, UINT32 priority2, int GFX );
	216	inline void vram_w( address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask, int GFX );
	217	inline void vram_8x8_w( address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask, int GFX );
	218	void set_pens();
	219	void cave_vh_start( int num );
	220	void get_sprite_info_cave();
	221	void get_sprite_info_donpachi();
	222	void sprite_init_cave();
	223	void cave_sprite_check(screen_device &screen, const rectangle &clip);
	224	void do_blit_zoom16_cave(const struct sprite_cave *sprite);
	225	void do_blit_zoom16_cave_zb( const struct sprite_cave *sprite );
	226	void do_blit_16_cave( const struct sprite_cave *sprite );
	227	void do_blit_16_cave_zb( const struct sprite_cave *sprite );
	228	void sprite_draw_cave( int priority );
	229	void sprite_draw_cave_zbuf( int priority );
	230	void sprite_draw_donpachi( int priority );
	231	void sprite_draw_donpachi_zbuf( int priority );
216	232	};

trunk/src/mame/video/cave.c

r24767	r24768
57	57
58	58	#define SWAP(X,Y) { int temp = X; X = Y; Y = temp; }
59	59
60		static void sprite_init_cave(running_machine &machine);
61		static void sprite_draw_cave(running_machine &machine, int priority);
62		static void sprite_draw_cave_zbuf(running_machine &machine, int priority);
63		static void sprite_draw_donpachi(running_machine &machine, int priority);
64		static void sprite_draw_donpachi_zbuf(running_machine &machine, int priority);
65	60
66	61	/***************************************************************************
67	62
r24767	r24768
178	173	}
179	174
180	175
181		static void set_pens( running_machine &machine )
	176	void cave_state::set_pens()
182	177	{
183		cave_state *state = machine.driver_data<cave_state>();
184	178	int pen;
185	179
186		for (pen = 0; pen < machine.total_colors(); pen++)
	180	for (pen = 0; pen < machine().total_colors(); pen++)
187	181	{
188		UINT16 data = state->m_paletteram[state->m_palette_map[pen]];
	182	UINT16 data = m_paletteram[m_palette_map[pen]];
189	183
190	184	rgb_t color = MAKE_RGB(pal5bit(data >> 5), pal5bit(data >> 10), pal5bit(data >> 0));
191	185
192		palette_set_color(machine, pen, color);
	186	palette_set_color(machine(), pen, color);
193	187	}
194	188	}
195	189
r24767	r24768
293	287	}
294	288
295	289
296		INLINE void vram_w( address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask, int GFX )
	290	inline void cave_state::vram_w( address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask, int GFX )
297	291	{
298		cave_state *state = space.machine().driver_data<cave_state>();
299		UINT16 *VRAM = state->m_vram[GFX];
300		tilemap_t *TILEMAP = state->m_tilemap[GFX];
	292	UINT16 *VRAM = m_vram[GFX];
	293	tilemap_t *TILEMAP = m_tilemap[GFX];
301	294
302	295	if ((VRAM[offset] & mem_mask) == (data & mem_mask))
303	296	return;
r24767	r24768
321	314	and 408000-407fff both go to the 8x8 tilemap ram. Use this function
322	315	in this cases. Note that the get_tile_info function looks in the
323	316	4000-7fff range for tiles, so we have to write the data there. */
324		INLINE void vram_8x8_w( address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask, int GFX )
	317	inline void cave_state::vram_8x8_w( address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask, int GFX )
325	318	{
326		cave_state *state = space.machine().driver_data<cave_state>();
327		UINT16 *VRAM = state->m_vram[GFX];
328		tilemap_t *TILEMAP = state->m_tilemap[GFX];
	319	UINT16 *VRAM = m_vram[GFX];
	320	tilemap_t *TILEMAP = m_tilemap[GFX];
329	321
330	322	offset %= 0x4000 / 2;
331	323	if ((VRAM[offset] & mem_mask) == (data & mem_mask))
r24767	r24768
362	354
363	355	***************************************************************************/
364	356
365		static void cave_vh_start( running_machine &machine, int num )
	357	void cave_state::cave_vh_start( int num )
366	358	{
367		cave_state *state = machine.driver_data<cave_state>();
	359	assert(m_palette_map != NULL);
368	360
369		assert(state->m_palette_map != NULL);
	361	m_tilemap[0] = 0;
	362	m_tilemap[1] = 0;
	363	m_tilemap[2] = 0;
	364	m_tilemap[3] = 0;
370	365
371		state->m_tilemap[0] = 0;
372		state->m_tilemap[1] = 0;
373		state->m_tilemap[2] = 0;
374		state->m_tilemap[3] = 0;
	366	m_tiledim[0] = 0;
	367	m_tiledim[1] = 0;
	368	m_tiledim[2] = 0;
	369	m_tiledim[3] = 0;
375	370
376		state->m_tiledim[0] = 0;
377		state->m_tiledim[1] = 0;
378		state->m_tiledim[2] = 0;
379		state->m_tiledim[3] = 0;
	371	m_old_tiledim[0] = 0;
	372	m_old_tiledim[1] = 0;
	373	m_old_tiledim[2] = 0;
	374	m_old_tiledim[3] = 0;
380	375
381		state->m_old_tiledim[0] = 0;
382		state->m_old_tiledim[1] = 0;
383		state->m_old_tiledim[2] = 0;
384		state->m_old_tiledim[3] = 0;
385
386	376	assert((num >= 1) && (num <= 4));
387	377
388	378	switch (num)
389	379	{
390	380	case 4:
391		state->m_tilemap[3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_3),state), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
392		state->m_tilemap[3]->set_transparent_pen(0);
393		state->m_tilemap[3]->set_scroll_rows(1);
394		state->m_tilemap[3]->set_scroll_cols(1);
395		state->save_item(NAME(state->m_tiledim[3]));
396		state->save_item(NAME(state->m_old_tiledim[3]));
	381	m_tilemap[3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_3),this), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
	382	m_tilemap[3]->set_transparent_pen(0);
	383	m_tilemap[3]->set_scroll_rows(1);
	384	m_tilemap[3]->set_scroll_cols(1);
	385	save_item(NAME(m_tiledim[3]));
	386	save_item(NAME(m_old_tiledim[3]));
397	387
398	388	case 3:
399		state->m_tilemap[2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_2),state), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
400		state->m_tilemap[2]->set_transparent_pen(0);
401		state->m_tilemap[2]->set_scroll_rows(1);
402		state->m_tilemap[2]->set_scroll_cols(1);
403		state->save_item(NAME(state->m_tiledim[2]));
404		state->save_item(NAME(state->m_old_tiledim[2]));
	389	m_tilemap[2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_2),this), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
	390	m_tilemap[2]->set_transparent_pen(0);
	391	m_tilemap[2]->set_scroll_rows(1);
	392	m_tilemap[2]->set_scroll_cols(1);
	393	save_item(NAME(m_tiledim[2]));
	394	save_item(NAME(m_old_tiledim[2]));
405	395
406	396	case 2:
407		state->m_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_1),state), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
408		state->m_tilemap[1]->set_transparent_pen(0);
409		state->m_tilemap[1]->set_scroll_rows(1);
410		state->m_tilemap[1]->set_scroll_cols(1);
411		state->save_item(NAME(state->m_tiledim[1]));
412		state->save_item(NAME(state->m_old_tiledim[1]));
	397	m_tilemap[1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_1),this), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
	398	m_tilemap[1]->set_transparent_pen(0);
	399	m_tilemap[1]->set_scroll_rows(1);
	400	m_tilemap[1]->set_scroll_cols(1);
	401	save_item(NAME(m_tiledim[1]));
	402	save_item(NAME(m_old_tiledim[1]));
413	403
414	404	case 1:
415		state->m_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_0),state), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
416		state->m_tilemap[0]->set_transparent_pen(0);
417		state->m_tilemap[0]->set_scroll_rows(1);
418		state->m_tilemap[0]->set_scroll_cols(1);
419		state->save_item(NAME(state->m_tiledim[0]));
420		state->save_item(NAME(state->m_old_tiledim[0]));
	405	m_tilemap[0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::get_tile_info_0),this), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8);
	406	m_tilemap[0]->set_transparent_pen(0);
	407	m_tilemap[0]->set_scroll_rows(1);
	408	m_tilemap[0]->set_scroll_cols(1);
	409	save_item(NAME(m_tiledim[0]));
	410	save_item(NAME(m_old_tiledim[0]));
421	411
422	412	break;
423	413	}
424	414
425		sprite_init_cave(machine);
	415	sprite_init_cave();
426	416
427		state->m_layers_offs_x = 0x13;
428		state->m_layers_offs_y = -0x12;
	417	m_layers_offs_x = 0x13;
	418	m_layers_offs_y = -0x12;
429	419
430		state->m_row_effect_offs_n = -1;
431		state->m_row_effect_offs_f = 1;
	420	m_row_effect_offs_n = -1;
	421	m_row_effect_offs_f = 1;
432	422
433		state->m_background_color = machine.config().m_gfxdecodeinfo[0].color_codes_start +
434		(machine.config().m_gfxdecodeinfo[0].total_color_codes - 1) *
435		machine.gfx[0]->granularity();
	423	m_background_color = machine().config().m_gfxdecodeinfo[0].color_codes_start +
	424	(machine().config().m_gfxdecodeinfo[0].total_color_codes - 1) *
	425	machine().gfx[0]->granularity();
436	426
437		switch (state->m_kludge)
	427	switch (m_kludge)
438	428	{
439	429	case 1: /* sailormn */
440		state->m_row_effect_offs_n = -1;
441		state->m_row_effect_offs_f = -1;
	430	m_row_effect_offs_n = -1;
	431	m_row_effect_offs_f = -1;
442	432	break;
443	433	case 2: /* uopoko dfeveron */
444		state->m_background_color = 0x3f00;
	434	m_background_color = 0x3f00;
445	435	break;
446	436	case 4: /* pwrinst2 */
447		state->m_background_color = 0x7f00;
448		state->m_layers_offs_y++;
	437	m_background_color = 0x7f00;
	438	m_layers_offs_y++;
449	439	break;
450	440	}
451	441	}
452	442
453		VIDEO_START_MEMBER(cave_state,cave_1_layer){    cave_vh_start(machine(), 1);    }
454		VIDEO_START_MEMBER(cave_state,cave_2_layers){   cave_vh_start(machine(), 2);    }
455		VIDEO_START_MEMBER(cave_state,cave_3_layers){   cave_vh_start(machine(), 3);    }
456		VIDEO_START_MEMBER(cave_state,cave_4_layers){   cave_vh_start(machine(), 4);    }
	443	VIDEO_START_MEMBER(cave_state,cave_1_layer){    cave_vh_start(1);    }
	444	VIDEO_START_MEMBER(cave_state,cave_2_layers){   cave_vh_start(2);    }
	445	VIDEO_START_MEMBER(cave_state,cave_3_layers){   cave_vh_start(3);    }
	446	VIDEO_START_MEMBER(cave_state,cave_4_layers){   cave_vh_start(4);    }
457	447
458	448
459	449	VIDEO_START_MEMBER(cave_state,sailormn_3_layers)
460	450	{
461		cave_vh_start(machine(), 2);
	451	cave_vh_start(2);
462	452
463	453	/* Layer 2 (8x8) needs to be handled differently */
464	454	m_tilemap[2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(cave_state::sailormn_get_tile_info_2),this), TILEMAP_SCAN_ROWS, 8, 8, 512 / 8, 512 / 8 );
r24767	r24768
500	490
501	491	***************************************************************************/
502	492
503		static void get_sprite_info_cave( running_machine &machine )
	493	void cave_state::get_sprite_info_cave()
504	494	{
505		cave_state *state = machine.driver_data<cave_state>();
506	495	pen_t base_pal = 0;
507		const UINT8 *base_gfx = state->memregion("sprites")->base();
508		int code_max = state->memregion("sprites")->bytes() / (16*16);
	496	const UINT8 *base_gfx = memregion("sprites")->base();
	497	int code_max = memregion("sprites")->bytes() / (16*16);
509	498
510	499	UINT16 *source;
511	500	UINT16 *finish;
512		struct sprite_cave *sprite = state->m_sprite;
	501	struct sprite_cave *sprite = m_sprite;
513	502
514		int glob_flipx = state->m_videoregs[0] & 0x8000;
515		int glob_flipy = state->m_videoregs[1] & 0x8000;
	503	int glob_flipx = m_videoregs[0] & 0x8000;
	504	int glob_flipy = m_videoregs[1] & 0x8000;
516	505
517		int max_x = machine.primary_screen->width();
518		int max_y = machine.primary_screen->height();
	506	int max_x = m_screen->width();
	507	int max_y = m_screen->height();
519	508
520		source = state->m_spriteram + ((state->m_spriteram.bytes() / 2) / 2) * state->m_spriteram_bank;
	509	source = m_spriteram + ((m_spriteram.bytes() / 2) / 2) * m_spriteram_bank;
521	510
522		if (state->m_videoregs[4] & 0x02)
523		if (state->m_spriteram_2)
524		source = state->m_spriteram_2 + ((state->m_spriteram.bytes() / 2) / 2) * state->m_spriteram_bank;
	511	if (m_videoregs[4] & 0x02)
	512	if (m_spriteram_2)
	513	source = m_spriteram_2 + ((m_spriteram.bytes() / 2) / 2) * m_spriteram_bank;
525	514
526		finish = source + ((state->m_spriteram.bytes() / 2) / 2);
	515	finish = source + ((m_spriteram.bytes() / 2) / 2);
527	516
528	517
529	518	for (; source < finish; source += 8)
r24767	r24768
531	520	int x, y, attr, code, zoomx, zoomy, size, flipx, flipy;
532	521	int total_width_f, total_height_f;
533	522
534		if (state->m_spritetype[0] == 2)    /* Hot Dog Storm */
	523	if (m_spritetype[0] == 2)    /* Hot Dog Storm */
535	524	{
536	525	x = (source[0] & 0x3ff) << 8;
537	526	y = (source[1] & 0x3ff) << 8;
r24767	r24768
589	578	sprite->ycount0 = sprite->zoomy_re - 1;
590	579	}
591	580
592		if (state->m_spritetype[0] == 2)
	581	if (m_spritetype[0] == 2)
593	582	{
594	583	x >>= 8;
595	584	y >>= 8;
r24767	r24768
626	615
627	616	sprite++;
628	617	}
629		state->m_num_sprites = sprite - state->m_sprite;
	618	m_num_sprites = sprite - m_sprite;
630	619	}
631	620
632		static void get_sprite_info_donpachi( running_machine &machine )
	621	void cave_state::get_sprite_info_donpachi()
633	622	{
634		cave_state *state = machine.driver_data<cave_state>();
635	623	pen_t base_pal = 0;
636		const UINT8 *base_gfx = state->memregion("sprites")->base();
637		int code_max = state->memregion("sprites")->bytes() / (16*16);
	624	const UINT8 *base_gfx = memregion("sprites")->base();
	625	int code_max = memregion("sprites")->bytes() / (16*16);
638	626
639	627	UINT16 *source;
640	628	UINT16 *finish;
641	629
642		struct sprite_cave *sprite = state->m_sprite;
	630	struct sprite_cave *sprite = m_sprite;
643	631
644		int glob_flipx = state->m_videoregs[0] & 0x8000;
645		int glob_flipy = state->m_videoregs[1] & 0x8000;
	632	int glob_flipx = m_videoregs[0] & 0x8000;
	633	int glob_flipy = m_videoregs[1] & 0x8000;
646	634
647		int max_x = machine.primary_screen->width();
648		int max_y = machine.primary_screen->height();
	635	int max_x = m_screen->width();
	636	int max_y = m_screen->height();
649	637
650		source = state->m_spriteram + ((state->m_spriteram.bytes() / 2) / 2) * state->m_spriteram_bank;
	638	source = m_spriteram + ((m_spriteram.bytes() / 2) / 2) * m_spriteram_bank;
651	639
652		if (state->m_videoregs[4] & 0x02)
653		if (state->m_spriteram_2)
654		source = state->m_spriteram_2 + ((state->m_spriteram.bytes() / 2) / 2) * state->m_spriteram_bank;
	640	if (m_videoregs[4] & 0x02)
	641	if (m_spriteram_2)
	642	source = m_spriteram_2 + ((m_spriteram.bytes() / 2) / 2) * m_spriteram_bank;
655	643
656		finish = source + ((state->m_spriteram.bytes() / 2) / 2);
	644	finish = source + ((m_spriteram.bytes() / 2) / 2);
657	645
658	646	for (; source < finish; source += 8)
659	647	{
r24767	r24768
663	651	code = source[1] + ((attr & 3) << 16);
664	652	x    = source[2] & 0x3ff;
665	653
666		if (state->m_spritetype[0] == 3)    /* pwrinst2 */
	654	if (m_spritetype[0] == 3)    /* pwrinst2 */
667	655	y = (source[3] + 1) & 0x3ff;
668	656	else
669	657	y = source[3] & 0x3ff;
r24767	r24768
687	675	flipx    = attr & 0x0008;
688	676	flipy    = attr & 0x0004;
689	677
690		if (state->m_spritetype[0] == 3)    /* pwrinst2 */
	678	if (m_spritetype[0] == 3)    /* pwrinst2 */
691	679	{
692	680	sprite->priority = ((attr & 0x0010) >> 4) + 2;
693	681	sprite->base_pen = base_pal + (attr & 0x3f00) + 0x4000 * ((attr & 0x0020) >> 5);
r24767	r24768
712	700
713	701	sprite++;
714	702	}
715		state->m_num_sprites = sprite - state->m_sprite;
	703	m_num_sprites = sprite - m_sprite;
716	704	}
717	705
718	706
719		static void sprite_init_cave( running_machine &machine )
	707	void cave_state::sprite_init_cave()
720	708	{
721		cave_state *state = machine.driver_data<cave_state>();
722
723		if (state->m_spritetype[0] == 0 || state->m_spritetype[0] == 2) // most of the games
	709	if (m_spritetype[0] == 0 || m_spritetype[0] == 2) // most of the games
724	710	{
725		state->m_get_sprite_info = get_sprite_info_cave;
726		state->m_spritetype[1] = CAVE_SPRITETYPE_ZOOM;
	711	m_get_sprite_info = &cave_state::get_sprite_info_cave;
	712	m_spritetype[1] = CAVE_SPRITETYPE_ZOOM;
727	713	}
728	714	else                        // donpachi ddonpach
729	715	{
730		state->m_get_sprite_info = get_sprite_info_donpachi;
731		state->m_spritetype[1] = 0;
	716	m_get_sprite_info = &cave_state::get_sprite_info_donpachi;
	717	m_spritetype[1] = 0;
732	718	}
733	719
734		state->m_sprite_zbuf_baseval = 0x10000 - MAX_SPRITE_NUM;
735		machine.primary_screen->register_screen_bitmap(state->m_sprite_zbuf);
	720	m_sprite_zbuf_baseval = 0x10000 - MAX_SPRITE_NUM;
	721	m_screen->register_screen_bitmap(m_sprite_zbuf);
736	722
737		state->m_num_sprites = state->m_spriteram.bytes() / 0x10 / 2;
738		state->m_sprite = auto_alloc_array_clear(machine, struct sprite_cave, state->m_num_sprites);
	723	m_num_sprites = m_spriteram.bytes() / 0x10 / 2;
	724	m_sprite = auto_alloc_array_clear(machine(), struct sprite_cave, m_num_sprites);
739	725
740		memset(state->m_sprite_table, 0, sizeof(state->m_sprite_table));
741		state->m_sprite_draw = sprite_draw_donpachi;
	726	memset(m_sprite_table, 0, sizeof(m_sprite_table));
	727	m_sprite_draw = &cave_state::sprite_draw_donpachi;
742	728
743		state->save_item(NAME(state->m_sprite_zbuf));
744		state->save_item(NAME(state->m_sprite_zbuf_baseval));
745		state->save_item(NAME(state->m_num_sprites));
746		state->save_item(NAME(state->m_spriteram_bank));
747		state->save_item(NAME(state->m_spriteram_bank_delay));
	729	save_item(NAME(m_sprite_zbuf));
	730	save_item(NAME(m_sprite_zbuf_baseval));
	731	save_item(NAME(m_num_sprites));
	732	save_item(NAME(m_spriteram_bank));
	733	save_item(NAME(m_spriteram_bank_delay));
748	734
749		state->save_item(NAME(state->m_blit.clip_left));
750		state->save_item(NAME(state->m_blit.clip_right));
751		state->save_item(NAME(state->m_blit.clip_top));
752		state->save_item(NAME(state->m_blit.clip_bottom));
	735	save_item(NAME(m_blit.clip_left));
	736	save_item(NAME(m_blit.clip_right));
	737	save_item(NAME(m_blit.clip_top));
	738	save_item(NAME(m_blit.clip_bottom));
753	739
754		machine.save().register_postload(save_prepost_delegate(FUNC(cave_state::cave_get_sprite_info), state));
	740	machine().save().register_postload(save_prepost_delegate(FUNC(cave_state::cave_get_sprite_info), this));
755	741	}
756	742
757		static void cave_sprite_check( screen_device &screen, const rectangle &clip )
	743	void cave_state::cave_sprite_check(screen_device &screen, const rectangle &clip)
758	744	{
759		cave_state *state = screen.machine().driver_data<cave_state>();
760
761	745	{   /* set clip */
762	746	int left = clip.min_x;
763	747	int top = clip.min_y;
764	748	int right = clip.max_x + 1;
765	749	int bottom = clip.max_y + 1;
766	750
767		state->m_blit.clip_left = left;
768		state->m_blit.clip_top = top;
769		state->m_blit.clip_right = right;
770		state->m_blit.clip_bottom = bottom;
	751	m_blit.clip_left = left;
	752	m_blit.clip_top = top;
	753	m_blit.clip_right = right;
	754	m_blit.clip_bottom = bottom;
771	755	}
772	756
773	757	{   /* check priority & sprite type */
774		struct sprite_cave *sprite = state->m_sprite;
775		const struct sprite_cave *finish = &sprite[state->m_num_sprites];
	758	struct sprite_cave *sprite = m_sprite;
	759	const struct sprite_cave *finish = &sprite[m_num_sprites];
776	760	int i[4] = {0,0,0,0};
777	761	int priority_check = 0;
778		int spritetype = state->m_spritetype[1];
	762	int spritetype = m_spritetype[1];
779	763	const rectangle &visarea = screen.visible_area();
780	764
781	765	while (sprite < finish)
782	766	{
783		if (sprite->x + sprite->total_width  > state->m_blit.clip_left && sprite->x < state->m_blit.clip_right  &&
784		sprite->y + sprite->total_height > state->m_blit.clip_top  && sprite->y < state->m_blit.clip_bottom    )
	767	if (sprite->x + sprite->total_width  > m_blit.clip_left && sprite->x < m_blit.clip_right  &&
	768	sprite->y + sprite->total_height > m_blit.clip_top  && sprite->y < m_blit.clip_bottom    )
785	769	{
786		state->m_sprite_table[sprite->priority][i[sprite->priority]++] = sprite;
	770	m_sprite_table[sprite->priority][i[sprite->priority]++] = sprite;
787	771
788	772	if(!(spritetype & CAVE_SPRITETYPE_ZBUF))
789	773	{
r24767	r24768
796	780	sprite++;
797	781	}
798	782
799		state->m_sprite_table[0][i[0]] = 0;
800		state->m_sprite_table[1][i[1]] = 0;
801		state->m_sprite_table[2][i[2]] = 0;
802		state->m_sprite_table[3][i[3]] = 0;
	783	m_sprite_table[0][i[0]] = 0;
	784	m_sprite_table[1][i[1]] = 0;
	785	m_sprite_table[2][i[2]] = 0;
	786	m_sprite_table[3][i[3]] = 0;
803	787
804	788	switch (spritetype)
805	789	{
806	790	case CAVE_SPRITETYPE_ZOOM:
807		state->m_sprite_draw = sprite_draw_cave;
	791	m_sprite_draw = &cave_state::sprite_draw_cave;
808	792	break;
809	793
810	794	case CAVE_SPRITETYPE_ZOOM | CAVE_SPRITETYPE_ZBUF:
811		state->m_sprite_draw = sprite_draw_cave_zbuf;
	795	m_sprite_draw = &cave_state::sprite_draw_cave_zbuf;
812	796	if (clip.min_y == visarea.min_y)
813	797	{
814		if(!(state->m_sprite_zbuf_baseval += MAX_SPRITE_NUM))
815		state->m_sprite_zbuf.fill(0, visarea);
	798	if(!(m_sprite_zbuf_baseval += MAX_SPRITE_NUM))
	799	m_sprite_zbuf.fill(0, visarea);
816	800	}
817	801	break;
818	802
819	803	case CAVE_SPRITETYPE_ZBUF:
820		state->m_sprite_draw = sprite_draw_donpachi_zbuf;
	804	m_sprite_draw = &cave_state::sprite_draw_donpachi_zbuf;
821	805	if (clip.min_y == visarea.min_y)
822	806	{
823		if(!(state->m_sprite_zbuf_baseval += MAX_SPRITE_NUM))
824		state->m_sprite_zbuf.fill(0, visarea);
	807	if(!(m_sprite_zbuf_baseval += MAX_SPRITE_NUM))
	808	m_sprite_zbuf.fill(0, visarea);
825	809	}
826	810	break;
827	811
828	812	default:
829	813	case 0:
830		state->m_sprite_draw = sprite_draw_donpachi;
	814	m_sprite_draw = &cave_state::sprite_draw_donpachi;
831	815	}
832	816	}
833	817	}
834	818
835		static void do_blit_zoom16_cave( running_machine &machine, const struct sprite_cave *sprite )
	819	void cave_state::do_blit_zoom16_cave(const struct sprite_cave *sprite)
836	820	{
837	821	/*  assumes SPRITE_LIST_RAW_DATA flag is set */
838		cave_state *state = machine.driver_data<cave_state>();
839	822	int x1, x2, y1, y2, dx, dy;
840	823	int xcount0 = 0x10000 + sprite->xcount0, ycount0 = 0x10000 + sprite->ycount0;
841	824
r24767	r24768
844	827	x2 = sprite->x;
845	828	x1 = x2 + sprite->total_width;
846	829	dx = -1;
847		if (x2 < state->m_blit.clip_left)
848		x2 = state->m_blit.clip_left;
	830	if (x2 < m_blit.clip_left)
	831	x2 = m_blit.clip_left;
849	832
850		if (x1 > state->m_blit.clip_right)
	833	if (x1 > m_blit.clip_right)
851	834	{
852		xcount0 += (x1 - state->m_blit.clip_right) * sprite->zoomx_re;
853		x1 = state->m_blit.clip_right;
	835	xcount0 += (x1 - m_blit.clip_right) * sprite->zoomx_re;
	836	x1 = m_blit.clip_right;
854	837	while ((xcount0 & 0xffff) >= sprite->zoomx_re)
855	838	{
856	839	xcount0 += sprite->zoomx_re;
r24767	r24768
867	850	x1 = sprite->x;
868	851	x2 = x1 + sprite->total_width;
869	852	dx = 1;
870		if (x1 < state->m_blit.clip_left)
	853	if (x1 < m_blit.clip_left)
871	854	{
872		xcount0 += (state->m_blit.clip_left - x1) * sprite->zoomx_re;
873		x1 = state->m_blit.clip_left;
	855	xcount0 += (m_blit.clip_left - x1) * sprite->zoomx_re;
	856	x1 = m_blit.clip_left;
874	857	while ((xcount0 & 0xffff) >= sprite->zoomx_re)
875	858	{
876	859	xcount0 += sprite->zoomx_re;
877	860	x1++;
878	861	}
879	862	}
880		if (x2 > state->m_blit.clip_right)
881		x2 = state->m_blit.clip_right;
	863	if (x2 > m_blit.clip_right)
	864	x2 = m_blit.clip_right;
882	865	if (x1 >= x2)
883	866	return;
884	867	}
r24767	r24768
888	871	y2 = sprite->y;
889	872	y1 = y2 + sprite->total_height;
890	873	dy = -1;
891		if (y2 < state->m_blit.clip_top)
892		y2 = state->m_blit.clip_top;
893		if (y1 > state->m_blit.clip_bottom)
	874	if (y2 < m_blit.clip_top)
	875	y2 = m_blit.clip_top;
	876	if (y1 > m_blit.clip_bottom)
894	877	{
895		ycount0 += (y1 - state->m_blit.clip_bottom) * sprite->zoomy_re;
896		y1 = state->m_blit.clip_bottom;
	878	ycount0 += (y1 - m_blit.clip_bottom) * sprite->zoomy_re;
	879	y1 = m_blit.clip_bottom;
897	880	while ((ycount0 & 0xffff) >= sprite->zoomy_re)
898	881	{
899	882	ycount0 += sprite->zoomy_re;
r24767	r24768
909	892	y1 = sprite->y;
910	893	y2 = y1 + sprite->total_height;
911	894	dy = 1;
912		if (y1 < state->m_blit.clip_top)
	895	if (y1 < m_blit.clip_top)
913	896	{
914		ycount0 += (state->m_blit.clip_top - y1) * sprite->zoomy_re;
915		y1 = state->m_blit.clip_top;
	897	ycount0 += (m_blit.clip_top - y1) * sprite->zoomy_re;
	898	y1 = m_blit.clip_top;
916	899	while ((ycount0 & 0xffff) >= sprite->zoomy_re)
917	900	{
918	901	ycount0 += sprite->zoomy_re;
919	902	y1++;
920	903	}
921	904	}
922		if (y2 > state->m_blit.clip_bottom )
923		y2 = state->m_blit.clip_bottom;
	905	if (y2 > m_blit.clip_bottom )
	906	y2 = m_blit.clip_bottom;
924	907	if (y1 >= y2)
925	908	return;
926	909	}
r24767	r24768
930	913	pen_t base_pen = sprite->base_pen;
931	914	int x, y;
932	915	UINT8 pen;
933		int pitch = state->m_blit.line_offset * dy / 2;
934		UINT16 *dest = (UINT16 *)(state->m_blit.baseaddr + state->m_blit.line_offset * y1);
	916	int pitch = m_blit.line_offset * dy / 2;
	917	UINT16 *dest = (UINT16 *)(m_blit.baseaddr + m_blit.line_offset * y1);
935	918	int ycount = ycount0;
936	919
937	920	for (y = y1; y != y2; y += dy)
r24767	r24768
965	948	}
966	949
967	950
968		static void do_blit_zoom16_cave_zb( running_machine &machine, const struct sprite_cave *sprite )
	951	void cave_state::do_blit_zoom16_cave_zb( const struct sprite_cave *sprite )
969	952	{
970	953	/*  assumes SPRITE_LIST_RAW_DATA flag is set */
971		cave_state *state = machine.driver_data<cave_state>();
972	954	int x1, x2, y1, y2, dx, dy;
973	955	int xcount0 = 0x10000 + sprite->xcount0, ycount0 = 0x10000 + sprite->ycount0;
974	956
r24767	r24768
977	959	x2 = sprite->x;
978	960	x1 = x2 + sprite->total_width;
979	961	dx = -1;
980		if (x2 < state->m_blit.clip_left)
981		x2 = state->m_blit.clip_left;
982		if (x1 > state->m_blit.clip_right)
	962	if (x2 < m_blit.clip_left)
	963	x2 = m_blit.clip_left;
	964	if (x1 > m_blit.clip_right)
983	965	{
984		xcount0 += (x1 - state->m_blit.clip_right) * sprite->zoomx_re;
985		x1 = state->m_blit.clip_right;
	966	xcount0 += (x1 - m_blit.clip_right) * sprite->zoomx_re;
	967	x1 = m_blit.clip_right;
986	968	while ((xcount0 & 0xffff) >= sprite->zoomx_re)
987	969	{
988	970	xcount0 += sprite->zoomx_re;
r24767	r24768
998	980	x1 = sprite->x;
999	981	x2 = x1 + sprite->total_width;
1000	982	dx = 1;
1001		if (x1 < state->m_blit.clip_left)
	983	if (x1 < m_blit.clip_left)
1002	984	{
1003		xcount0 += (state->m_blit.clip_left - x1) * sprite->zoomx_re;
1004		x1 = state->m_blit.clip_left;
	985	xcount0 += (m_blit.clip_left - x1) * sprite->zoomx_re;
	986	x1 = m_blit.clip_left;
1005	987	while ((xcount0 & 0xffff) >= sprite->zoomx_re)
1006	988	{
1007	989	xcount0 += sprite->zoomx_re;
1008	990	x1++;
1009	991	}
1010	992	}
1011		if (x2 > state->m_blit.clip_right)
1012		x2 = state->m_blit.clip_right;
	993	if (x2 > m_blit.clip_right)
	994	x2 = m_blit.clip_right;
1013	995	if (x1 >= x2)
1014	996	return;
1015	997	}
r24767	r24768
1018	1000	y2 = sprite->y;
1019	1001	y1 = y2 + sprite->total_height;
1020	1002	dy = -1;
1021		if (y2 < state->m_blit.clip_top)
1022		y2 = state->m_blit.clip_top;
1023		if (y1 > state->m_blit.clip_bottom)
	1003	if (y2 < m_blit.clip_top)
	1004	y2 = m_blit.clip_top;
	1005	if (y1 > m_blit.clip_bottom)
1024	1006	{
1025		ycount0 += (y1 - state->m_blit.clip_bottom) * sprite->zoomy_re;
1026		y1 = state->m_blit.clip_bottom;
	1007	ycount0 += (y1 - m_blit.clip_bottom) * sprite->zoomy_re;
	1008	y1 = m_blit.clip_bottom;
1027	1009	while ((ycount0 & 0xffff) >= sprite->zoomy_re)
1028	1010	{
1029	1011	ycount0 += sprite->zoomy_re;
r24767	r24768
1039	1021	y1 = sprite->y;
1040	1022	y2 = y1 + sprite->total_height;
1041	1023	dy = 1;
1042		if (y1 < state->m_blit.clip_top)
	1024	if (y1 < m_blit.clip_top)
1043	1025	{
1044		ycount0 += (state->m_blit.clip_top - y1) * sprite->zoomy_re;
1045		y1 = state->m_blit.clip_top;
	1026	ycount0 += (m_blit.clip_top - y1) * sprite->zoomy_re;
	1027	y1 = m_blit.clip_top;
1046	1028	while ((ycount0 & 0xffff) >= sprite->zoomy_re)
1047	1029	{
1048	1030	ycount0 += sprite->zoomy_re;
1049	1031	y1++;
1050	1032	}
1051	1033	}
1052		if (y2 > state->m_blit.clip_bottom)
1053		y2 = state->m_blit.clip_bottom;
	1034	if (y2 > m_blit.clip_bottom)
	1035	y2 = m_blit.clip_bottom;
1054	1036	if (y1 >= y2)
1055	1037	return;
1056	1038	}
r24767	r24768
1060	1042	pen_t base_pen = sprite->base_pen;
1061	1043	int x, y;
1062	1044	UINT8 pen;
1063		int pitch = state->m_blit.line_offset * dy / 2;
1064		UINT16 *dest = (UINT16 *)(state->m_blit.baseaddr + state->m_blit.line_offset * y1);
1065		int pitchz = state->m_blit.line_offset_zbuf * dy / 2;
1066		UINT16 *zbf = (UINT16 *)(state->m_blit.baseaddr_zbuf + state->m_blit.line_offset_zbuf * y1);
1067		UINT16 pri_sp = (UINT16)(sprite - state->m_sprite) + state->m_sprite_zbuf_baseval;
	1045	int pitch = m_blit.line_offset * dy / 2;
	1046	UINT16 *dest = (UINT16 *)(m_blit.baseaddr + m_blit.line_offset * y1);
	1047	int pitchz = m_blit.line_offset_zbuf * dy / 2;
	1048	UINT16 *zbf = (UINT16 *)(m_blit.baseaddr_zbuf + m_blit.line_offset_zbuf * y1);
	1049	UINT16 pri_sp = (UINT16)(sprite - m_sprite) + m_sprite_zbuf_baseval;
1068	1050	int ycount = ycount0;
1069	1051
1070	1052	for (y = y1; y != y2; y += dy)
r24767	r24768
1101	1083	}
1102	1084	}
1103	1085
1104		static void do_blit_16_cave( running_machine &machine, const struct sprite_cave *sprite )
	1086	void cave_state::do_blit_16_cave( const struct sprite_cave *sprite )
1105	1087	{
1106	1088	/*  assumes SPRITE_LIST_RAW_DATA flag is set */
1107		cave_state *state = machine.driver_data<cave_state>();
1108	1089	int x1, x2, y1, y2, dx, dy;
1109	1090	int xcount0 = 0, ycount0 = 0;
1110	1091
r24767	r24768
1113	1094	x2 = sprite->x;
1114	1095	x1 = x2 + sprite->total_width;
1115	1096	dx = -1;
1116		if (x2 < state->m_blit.clip_left)
1117		x2 = state->m_blit.clip_left;
1118		if (x1 > state->m_blit.clip_right)
	1097	if (x2 < m_blit.clip_left)
	1098	x2 = m_blit.clip_left;
	1099	if (x1 > m_blit.clip_right)
1119	1100	{
1120		xcount0 = x1 - state->m_blit.clip_right;
1121		x1 = state->m_blit.clip_right;
	1101	xcount0 = x1 - m_blit.clip_right;
	1102	x1 = m_blit.clip_right;
1122	1103	}
1123	1104	if (x2 >= x1)
1124	1105	return;
r24767	r24768
1129	1110	x1 = sprite->x;
1130	1111	x2 = x1 + sprite->total_width;
1131	1112	dx = 1;
1132		if (x1 < state->m_blit.clip_left)
	1113	if (x1 < m_blit.clip_left)
1133	1114	{
1134		xcount0 = state->m_blit.clip_left - x1;
1135		x1 = state->m_blit.clip_left;
	1115	xcount0 = m_blit.clip_left - x1;
	1116	x1 = m_blit.clip_left;
1136	1117	}
1137		if (x2 > state->m_blit.clip_right)
1138		x2 = state->m_blit.clip_right;
	1118	if (x2 > m_blit.clip_right)
	1119	x2 = m_blit.clip_right;
1139	1120	if (x1 >= x2)
1140	1121	return;
1141	1122	}
r24767	r24768
1144	1125	y2 = sprite->y;
1145	1126	y1 = y2 + sprite->total_height;
1146	1127	dy = -1;
1147		if (y2 < state->m_blit.clip_top)
1148		y2 = state->m_blit.clip_top;
1149		if (y1 > state->m_blit.clip_bottom)
	1128	if (y2 < m_blit.clip_top)
	1129	y2 = m_blit.clip_top;
	1130	if (y1 > m_blit.clip_bottom)
1150	1131	{
1151		ycount0 = y1 - state->m_blit.clip_bottom;
1152		y1 = state->m_blit.clip_bottom;
	1132	ycount0 = y1 - m_blit.clip_bottom;
	1133	y1 = m_blit.clip_bottom;
1153	1134	}
1154	1135	if (y2 >= y1)
1155	1136	return;
r24767	r24768
1159	1140	y1 = sprite->y;
1160	1141	y2 = y1 + sprite->total_height;
1161	1142	dy = 1;
1162		if (y1 < state->m_blit.clip_top )
	1143	if (y1 < m_blit.clip_top )
1163	1144	{
1164		ycount0 = state->m_blit.clip_top - y1;
1165		y1 = state->m_blit.clip_top;
	1145	ycount0 = m_blit.clip_top - y1;
	1146	y1 = m_blit.clip_top;
1166	1147	}
1167		if (y2 > state->m_blit.clip_bottom)
1168		y2 = state->m_blit.clip_bottom;
	1148	if (y2 > m_blit.clip_bottom)
	1149	y2 = m_blit.clip_bottom;
1169	1150	if (y1 >= y2)
1170	1151	return;
1171	1152	}
r24767	r24768
1175	1156	pen_t base_pen = sprite->base_pen;
1176	1157	int x, y;
1177	1158	UINT8 pen;
1178		int pitch = state->m_blit.line_offset * dy / 2;
1179		UINT16 *dest = (UINT16 *)(state->m_blit.baseaddr + state->m_blit.line_offset * y1);
	1159	int pitch = m_blit.line_offset * dy / 2;
	1160	UINT16 *dest = (UINT16 *)(m_blit.baseaddr + m_blit.line_offset * y1);
1180	1161
1181	1162	pen_data += sprite->line_offset * ycount0 + xcount0;
1182	1163	for (y = y1; y != y2; y += dy)
r24767	r24768
1197	1178	}
1198	1179
1199	1180
1200		static void do_blit_16_cave_zb( running_machine &machine, const struct sprite_cave *sprite )
	1181	void cave_state::do_blit_16_cave_zb( const struct sprite_cave *sprite )
1201	1182	{
1202	1183	/*  assumes SPRITE_LIST_RAW_DATA flag is set */
1203		cave_state *state = machine.driver_data<cave_state>();
1204	1184	int x1, x2, y1, y2, dx, dy;
1205	1185	int xcount0 = 0, ycount0 = 0;
1206	1186
r24767	r24768
1209	1189	x2 = sprite->x;
1210	1190	x1 = x2 + sprite->total_width;
1211	1191	dx = -1;
1212		if (x2 < state->m_blit.clip_left)
1213		x2 = state->m_blit.clip_left;
1214		if (x1 > state->m_blit.clip_right)
	1192	if (x2 < m_blit.clip_left)
	1193	x2 = m_blit.clip_left;
	1194	if (x1 > m_blit.clip_right)
1215	1195	{
1216		xcount0 = x1 - state->m_blit.clip_right;
1217		x1 = state->m_blit.clip_right;
	1196	xcount0 = x1 - m_blit.clip_right;
	1197	x1 = m_blit.clip_right;
1218	1198	}
1219	1199	if (x2 >= x1)
1220	1200	return;
r24767	r24768
1225	1205	x1 = sprite->x;
1226	1206	x2 = x1 + sprite->total_width;
1227	1207	dx = 1;
1228		if (x1 < state->m_blit.clip_left)
	1208	if (x1 < m_blit.clip_left)
1229	1209	{
1230		xcount0 = state->m_blit.clip_left - x1;
1231		x1 = state->m_blit.clip_left;
	1210	xcount0 = m_blit.clip_left - x1;
	1211	x1 = m_blit.clip_left;
1232	1212	}
1233		if (x2 > state->m_blit.clip_right)
1234		x2 = state->m_blit.clip_right;
	1213	if (x2 > m_blit.clip_right)
	1214	x2 = m_blit.clip_right;
1235	1215	if (x1 >= x2)
1236	1216	return;
1237	1217	}
r24767	r24768
1240	1220	y2 = sprite->y;
1241	1221	y1 = y2 + sprite->total_height;
1242	1222	dy = -1;
1243		if (y2 < state->m_blit.clip_top)
1244		y2 = state->m_blit.clip_top;
1245		if (y1 > state->m_blit.clip_bottom)
	1223	if (y2 < m_blit.clip_top)
	1224	y2 = m_blit.clip_top;
	1225	if (y1 > m_blit.clip_bottom)
1246	1226	{
1247		ycount0 = y1 - state->m_blit.clip_bottom;
1248		y1 = state->m_blit.clip_bottom;
	1227	ycount0 = y1 - m_blit.clip_bottom;
	1228	y1 = m_blit.clip_bottom;
1249	1229	}
1250	1230	if (y2 >= y1)
1251	1231	return;
r24767	r24768
1256	1236	y1 = sprite->y;
1257	1237	y2 = y1 + sprite->total_height;
1258	1238	dy = 1;
1259		if (y1 < state->m_blit.clip_top)
	1239	if (y1 < m_blit.clip_top)
1260	1240	{
1261		ycount0 = state->m_blit.clip_top - y1;
1262		y1 = state->m_blit.clip_top;
	1241	ycount0 = m_blit.clip_top - y1;
	1242	y1 = m_blit.clip_top;
1263	1243	}
1264		if (y2 > state->m_blit.clip_bottom)
1265		y2 = state->m_blit.clip_bottom;
	1244	if (y2 > m_blit.clip_bottom)
	1245	y2 = m_blit.clip_bottom;
1266	1246	if (y1 >= y2)
1267	1247	return;
1268	1248	}
r24767	r24768
1272	1252	pen_t base_pen = sprite->base_pen;
1273	1253	int x, y;
1274	1254	UINT8 pen;
1275		int pitch = state->m_blit.line_offset * dy / 2;
1276		UINT16 *dest = (UINT16 *)(state->m_blit.baseaddr + state->m_blit.line_offset * y1);
1277		int pitchz = state->m_blit.line_offset_zbuf * dy / 2;
1278		UINT16 *zbf = (UINT16 *)(state->m_blit.baseaddr_zbuf + state->m_blit.line_offset_zbuf * y1);
1279		UINT16 pri_sp = (UINT16)(sprite - state->m_sprite) + state->m_sprite_zbuf_baseval;
	1255	int pitch = m_blit.line_offset * dy / 2;
	1256	UINT16 *dest = (UINT16 *)(m_blit.baseaddr + m_blit.line_offset * y1);
	1257	int pitchz = m_blit.line_offset_zbuf * dy / 2;
	1258	UINT16 *zbf = (UINT16 *)(m_blit.baseaddr_zbuf + m_blit.line_offset_zbuf * y1);
	1259	UINT16 pri_sp = (UINT16)(sprite - m_sprite) + m_sprite_zbuf_baseval;
1280	1260
1281	1261	pen_data += sprite->line_offset * ycount0 + xcount0;
1282	1262	for (y = y1; y != y2; y += dy)
r24767	r24768
1301	1281	}
1302	1282
1303	1283
1304		static void sprite_draw_cave( running_machine &machine, int priority )
	1284	void cave_state::sprite_draw_cave( int priority )
1305	1285	{
1306		cave_state *state = machine.driver_data<cave_state>();
1307	1286	int i = 0;
1308		while (state->m_sprite_table[priority][i])
	1287	while (m_sprite_table[priority][i])
1309	1288	{
1310		const struct sprite_cave *sprite = state->m_sprite_table[priority][i++];
	1289	const struct sprite_cave *sprite = m_sprite_table[priority][i++];
1311	1290	if ((sprite->tile_width == sprite->total_width) && (sprite->tile_height == sprite->total_height))
1312		do_blit_16_cave(machine, sprite);
	1291	do_blit_16_cave(sprite);
1313	1292	else
1314		do_blit_zoom16_cave(machine, sprite);
	1293	do_blit_zoom16_cave(sprite);
1315	1294	}
1316	1295	}
1317	1296
1318		static void sprite_draw_cave_zbuf( running_machine &machine, int priority )
	1297	void cave_state::sprite_draw_cave_zbuf( int priority )
1319	1298	{
1320		cave_state *state = machine.driver_data<cave_state>();
1321	1299	int i = 0;
1322		while (state->m_sprite_table[priority][i])
	1300	while (m_sprite_table[priority][i])
1323	1301	{
1324		const struct sprite_cave *sprite = state->m_sprite_table[priority][i++];
	1302	const struct sprite_cave *sprite = m_sprite_table[priority][i++];
1325	1303	if ((sprite->tile_width == sprite->total_width) && (sprite->tile_height == sprite->total_height))
1326		do_blit_16_cave_zb(machine, sprite);
	1304	do_blit_16_cave_zb(sprite);
1327	1305	else
1328		do_blit_zoom16_cave_zb(machine, sprite);
	1306	do_blit_zoom16_cave_zb(sprite);
1329	1307	}
1330	1308	}
1331	1309
1332		static void sprite_draw_donpachi( running_machine &machine, int priority )
	1310	void cave_state::sprite_draw_donpachi( int priority )
1333	1311	{
1334		cave_state *state = machine.driver_data<cave_state>();
1335	1312	int i = 0;
1336		while (state->m_sprite_table[priority][i])
1337		do_blit_16_cave(machine, state->m_sprite_table[priority][i++]);
	1313	while (m_sprite_table[priority][i])
	1314	do_blit_16_cave(m_sprite_table[priority][i++]);
1338	1315	}
1339	1316
1340		static void sprite_draw_donpachi_zbuf( running_machine &machine, int priority )
	1317	void cave_state::sprite_draw_donpachi_zbuf( int priority )
1341	1318	{
1342		cave_state *state = machine.driver_data<cave_state>();
1343	1319	int i = 0;
1344		while (state->m_sprite_table[priority][i])
1345		do_blit_16_cave_zb(machine, state->m_sprite_table[priority][i++]);
	1320	while (m_sprite_table[priority][i])
	1321	do_blit_16_cave_zb(m_sprite_table[priority][i++]);
1346	1322	}
1347	1323
1348	1324
r24767	r24768
1529	1505	int pri, pri2, GFX;
1530	1506	int layers_ctrl = -1;
1531	1507
1532		set_pens(machine());
	1508	set_pens();
1533	1509
1534	1510	m_blit.baseaddr = reinterpret_cast<UINT8 *>(bitmap.raw_pixptr(0));
1535	1511	m_blit.line_offset = bitmap.rowbytes();
r24767	r24768
1622	1598	*/
1623	1599	for (pri = 0; pri <= 3; pri++)  // tile / sprite priority
1624	1600	{
1625		if (layers_ctrl & (1 << (pri + 16)))    (*m_sprite_draw)(screen.machine(), pri);
	1601	if (layers_ctrl & (1 << (pri + 16)))    (this->*m_sprite_draw)(pri);
1626	1602
1627	1603	for (pri2 = 0; pri2 <= 3; pri2++)   // priority of the whole layer
1628	1604	{
r24767	r24768
1646	1622	if (machine().video().skip_this_frame() == 0)
1647	1623	{
1648	1624	m_spriteram_bank = m_spriteram_bank_delay;
1649		(*m_get_sprite_info)(machine());
	1625	(this->*m_get_sprite_info)();
1650	1626	}
1651	1627	m_spriteram_bank_delay = m_videoregs[4] & 1;
1652	1628	}
r24767	r24768
1655	1631	if (machine().video().skip_this_frame() == 0)
1656	1632	{
1657	1633	m_spriteram_bank = m_videoregs[4] & 1;
1658		(*m_get_sprite_info)(machine());
	1634	(this->*m_get_sprite_info)();
1659	1635	}
1660	1636	}
1661	1637	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team