Previous

199869 Revisions

Next

r20932 Monday 11th February, 2013 at 11:18:02 UTC by Miodrag Milanović
Modernization of drivers part 12 (no whatsnew)

[src/mame/audio]	mw8080bw.c
[src/mame/drivers]	m72.c m92.c macrossp.c madalien.c maygay1b.c mcr.c mcr3.c mcr68.c megasys1.c metro.c mitchell.c ms32.c mw8080bw.c mystston.c
[src/mame/includes]	m10.h m107.h m52.h m57.h m58.h m62.h m72.h m90.h m92.h macrossp.h madalien.h mainsnk.h mappy.h marineb.h mario.h markham.h maygay1b.h mcatadv.h mcr.h mcr3.h mcr68.h meadows.h megasys1.h mermaid.h metlclsh.h metro.h mexico86.h midwunit.h midxunit.h mikie.h mitchell.h mjkjidai.h momoko.h mrdo.h mrflea.h mrjong.h ms32.h msisaac.h mugsmash.h munchmo.h mustache.h mw8080bw.h mystston.h
[src/mame/machine]	mcr68.c mexico86.c midwunit.c midxunit.c mw8080bw.c
[src/mame/video]	m10.c m107.c m52.c m57.c m58.c m62.c m72.c m90.c m92.c macrossp.c madalien.c mainsnk.c mappy.c marineb.c mario.c markham.c mcatadv.c mcr.c mcr3.c mcr68.c meadows.c megasys1.c mermaid.c metlclsh.c metro.c mikie.c mitchell.c mjkjidai.c momoko.c mrdo.c mrflea.c mrjong.c ms32.c msisaac.c mugsmash.c munchmo.c mustache.c mystston.c

trunk/src/mame/drivers/m92.c

r20931	r20932
204	204	#include "sound/okim6295.h"
205	205
206	206
207		#define M92_IRQ_0 ((state->m_irq_vectorbase+0)/4)  /* VBL interrupt */
208		#define M92_IRQ_1 ((state->m_irq_vectorbase+4)/4)  /* Sprite buffer complete interrupt */
209		#define M92_IRQ_2 ((state->m_irq_vectorbase+8)/4)  /* Raster interrupt */
	207	#define M92_IRQ_0 ((m_irq_vectorbase+0)/4)  /* VBL interrupt */
	208	#define M92_IRQ_1 ((m_irq_vectorbase+4)/4)  /* Sprite buffer complete interrupt */
	209	#define M92_IRQ_2 ((m_irq_vectorbase+8)/4)  /* Raster interrupt */
210	210	#define M92_IRQ_3 ((m_irq_vectorbase+12)/4) /* Sound cpu interrupt */
211	211
212	212
r20931	r20932
226	226
227	227	TIMER_DEVICE_CALLBACK_MEMBER(m92_state::m92_scanline_interrupt)
228	228	{
229		m92_state *state = machine().driver_data<m92_state>();
230	229	int scanline = param;
231	230
232	231	/* raster interrupt */
233	232	if (scanline == m_raster_irq_position)
234	233	{
235	234	machine().primary_screen->update_partial(scanline);
236		state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_2);
	235	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_2);
237	236	}
238	237
239	238	/* VBLANK interrupt */
240	239	else if (scanline == machine().primary_screen->visible_area().max_y + 1)
241	240	{
242	241	machine().primary_screen->update_partial(scanline);
243		state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_0);
	242	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_0);
244	243	}
245	244	}
246	245
r20931	r20932
908	907
909	908	/***************************************************************************/
910	909
911		void m92_sprite_interrupt(running_machine &machine)
	910	void m92_state::m92_sprite_interrupt()
912	911	{
913		m92_state *state = machine.driver_data<m92_state>();
914
915		state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_1);
	912	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_1);
916	913	}
917	914
918	915	static MACHINE_CONFIG_START( m92, m92_state )

trunk/src/mame/drivers/madalien.c

r20931	r20932
23	23	}
24	24
25	25
26		INLINE UINT8 shift_common(running_machine &machine, UINT8 hi, UINT8 lo)
	26	inline UINT8 madalien_state::shift_common(UINT8 hi, UINT8 lo)
27	27	{
28		const UINT8 *table = machine.root_device().memregion("user2")->base();
	28	const UINT8 *table = machine().root_device().memregion("user2")->base();
29	29
30	30	return table[((hi & 0x07) << 8) | lo];
31	31	}
32	32
33	33	READ8_MEMBER(madalien_state::shift_r)
34	34	{
35		return shift_common(machine(), *m_shift_hi, *m_shift_lo);
	35	return shift_common(*m_shift_hi, *m_shift_lo);
36	36	}
37	37
38	38	READ8_MEMBER(madalien_state::shift_rev_r)
r20931	r20932
40	40	UINT8 hi = *m_shift_hi ^ 0x07;
41	41	UINT8 lo = BITSWAP8(*m_shift_lo,0,1,2,3,4,5,6,7);
42	42
43		UINT8 ret = shift_common(machine(), hi, lo);
	43	UINT8 ret = shift_common(hi, lo);
44	44
45	45	return BITSWAP8(ret,7,0,1,2,3,4,5,6) & 0x7f;
46	46	}

trunk/src/mame/drivers/mcr.c

r20931	r20932
2751	2751	*
2752	2752	*************************************/
2753	2753
2754		static void mcr_init(running_machine &machine, int cpuboard, int vidboard, int ssioboard)
	2754	void mcr_state::mcr_init(int cpuboard, int vidboard, int ssioboard)
2755	2755	{
2756	2756	mcr_cpu_board = cpuboard;
2757	2757	mcr_sprite_board = vidboard;
r20931	r20932
2759	2759	mcr12_sprite_xoffs = 0;
2760	2760	mcr12_sprite_xoffs_flip = 0;
2761	2761
2762		state_save_register_global(machine, input_mux);
2763		state_save_register_global(machine, last_op4);
	2762	state_save_register_global(machine(), input_mux);
	2763	state_save_register_global(machine(), last_op4);
2764	2764
2765		midway_ssio_device *ssio = machine.device<midway_ssio_device>("ssio");
	2765	midway_ssio_device *ssio = machine().device<midway_ssio_device>("ssio");
2766	2766	if (ssio != NULL)
2767	2767	{
2768		mcr_state *state = machine.driver_data<mcr_state>();
2769		ssio->set_custom_output(0, 0xff, write8_delegate(FUNC(mcr_state::mcr_control_port_w), state));
	2768	ssio->set_custom_output(0, 0xff, write8_delegate(FUNC(mcr_state::mcr_control_port_w), this));
2770	2769	}
2771	2770	}
2772	2771
2773	2772
2774	2773	DRIVER_INIT_MEMBER(mcr_state,solarfox)
2775	2774	{
2776		mcr_init(machine(), 90009, 91399, 90908);
	2775	mcr_init(90009, 91399, 90908);
2777	2776	mcr12_sprite_xoffs = 16;
2778	2777
2779	2778	machine().device<midway_ssio_device>("ssio")->set_custom_input(0, 0x1c, read8_delegate(FUNC(mcr_state::solarfox_ip0_r),this));
r20931	r20932
2783	2782
2784	2783	DRIVER_INIT_MEMBER(mcr_state,kick)
2785	2784	{
2786		mcr_init(machine(), 90009, 91399, 90908);
	2785	mcr_init(90009, 91399, 90908);
2787	2786	mcr12_sprite_xoffs_flip = 16;
2788	2787
2789	2788	machine().device<midway_ssio_device>("ssio")->set_custom_input(1, 0xf0, read8_delegate(FUNC(mcr_state::kick_ip1_r),this));
r20931	r20932
2792	2791
2793	2792	DRIVER_INIT_MEMBER(mcr_state,dpoker)
2794	2793	{
2795		mcr_init(machine(), 90009, 91399, 90908);
	2794	mcr_init(90009, 91399, 90908);
2796	2795	mcr12_sprite_xoffs_flip = 16;
2797	2796
2798	2797	machine().device<midway_ssio_device>("ssio")->set_custom_input(0, 0x8e, read8_delegate(FUNC(mcr_state::dpoker_ip0_r),this));
r20931	r20932
2820	2819
2821	2820	DRIVER_INIT_MEMBER(mcr_state,mcr_90010)
2822	2821	{
2823		mcr_init(machine(), 90010, 91399, 90913);
	2822	mcr_init(90010, 91399, 90913);
2824	2823	}
2825	2824
2826	2825
2827	2826	DRIVER_INIT_MEMBER(mcr_state,wacko)
2828	2827	{
2829		mcr_init(machine(), 90010, 91399, 90913);
	2828	mcr_init(90010, 91399, 90913);
2830	2829
2831	2830	machine().device<midway_ssio_device>("ssio")->set_custom_input(1, 0xff, read8_delegate(FUNC(mcr_state::wacko_ip1_r),this));
2832	2831	machine().device<midway_ssio_device>("ssio")->set_custom_input(2, 0xff, read8_delegate(FUNC(mcr_state::wacko_ip2_r),this));
r20931	r20932
2836	2835
2837	2836	DRIVER_INIT_MEMBER(mcr_state,twotiger)
2838	2837	{
2839		mcr_init(machine(), 90010, 91399, 90913);
	2838	mcr_init(90010, 91399, 90913);
2840	2839
2841	2840	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0xff, write8_delegate(FUNC(mcr_state::twotiger_op4_w),this));
2842	2841	machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xe800, 0xefff, 0, 0x1000, read8_delegate(FUNC(mcr_state::twotiger_videoram_r),this), write8_delegate(FUNC(mcr_state::twotiger_videoram_w),this));
r20931	r20932
2845	2844
2846	2845	DRIVER_INIT_MEMBER(mcr_state,kroozr)
2847	2846	{
2848		mcr_init(machine(), 90010, 91399, 91483);
	2847	mcr_init(90010, 91399, 91483);
2849	2848
2850	2849	machine().device<midway_ssio_device>("ssio")->set_custom_input(1, 0x47, read8_delegate(FUNC(mcr_state::kroozr_ip1_r),this));
2851	2850	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0x34, write8_delegate(FUNC(mcr_state::kroozr_op4_w),this));
r20931	r20932
2854	2853
2855	2854	DRIVER_INIT_MEMBER(mcr_state,journey)
2856	2855	{
2857		mcr_init(machine(), 91475, 91464, 90913);
	2856	mcr_init(91475, 91464, 90913);
2858	2857
2859	2858	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0x01, write8_delegate(FUNC(mcr_state::journey_op4_w),this));
2860	2859	}
r20931	r20932
2862	2861
2863	2862	DRIVER_INIT_MEMBER(mcr_state,mcr_91490)
2864	2863	{
2865		mcr_init(machine(), 91490, 91464, 90913);
	2864	mcr_init(91490, 91464, 90913);
2866	2865	}
2867	2866
2868	2867
2869	2868	DRIVER_INIT_MEMBER(mcr_state,dotrone)
2870	2869	{
2871		mcr_init(machine(), 91490, 91464, 91657);
	2870	mcr_init(91490, 91464, 91657);
2872	2871
2873	2872	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0xff, write8_delegate(FUNC(mcr_state::dotron_op4_w),this));
2874	2873	}
r20931	r20932
2876	2875
2877	2876	DRIVER_INIT_MEMBER(mcr_state,nflfoot)
2878	2877	{
2879		mcr_init(machine(), 91490, 91464, 91657);
	2878	mcr_init(91490, 91464, 91657);
2880	2879
2881	2880	machine().device<midway_ssio_device>("ssio")->set_custom_input(2, 0x80, read8_delegate(FUNC(mcr_state::nflfoot_ip2_r),this));
2882	2881	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0xff, write8_delegate(FUNC(mcr_state::nflfoot_op4_w),this));
r20931	r20932
2895	2894
2896	2895	DRIVER_INIT_MEMBER(mcr_state,demoderb)
2897	2896	{
2898		mcr_init(machine(), 91490, 91464, 90913);
	2897	mcr_init(91490, 91464, 90913);
2899	2898
2900	2899	machine().device<midway_ssio_device>("ssio")->set_custom_input(1, 0xfc, read8_delegate(FUNC(mcr_state::demoderb_ip1_r),this));
2901	2900	machine().device<midway_ssio_device>("ssio")->set_custom_input(2, 0xfc, read8_delegate(FUNC(mcr_state::demoderb_ip2_r),this));

trunk/src/mame/drivers/macrossp.c

r20931	r20932
349	349	return soundlatch_word_r(space, offset, mem_mask);
350	350	}
351	351
352		static void update_colors( running_machine &machine )
	352	void macrossp_state::update_colors(  )
353	353	{
354		macrossp_state *state = machine.driver_data<macrossp_state>();
355	354	int i, r, g, b;
356	355
357	356	for (i = 0; i < 0x1000; i++)
358	357	{
359		b = ((state->m_paletteram[i] & 0x0000ff00) >>  8);
360		g = ((state->m_paletteram[i] & 0x00ff0000) >> 16);
361		r = ((state->m_paletteram[i] & 0xff000000) >> 24);
	358	b = ((m_paletteram[i] & 0x0000ff00) >>  8);
	359	g = ((m_paletteram[i] & 0x00ff0000) >> 16);
	360	r = ((m_paletteram[i] & 0xff000000) >> 24);
362	361
363		if (state->m_fade_effect > b)
	362	if (m_fade_effect > b)
364	363	b = 0;
365	364	else
366		b -= state->m_fade_effect;
	365	b -= m_fade_effect;
367	366
368		if (state->m_fade_effect > g)
	367	if (m_fade_effect > g)
369	368	g = 0;
370	369	else
371		g -= state->m_fade_effect;
	370	g -= m_fade_effect;
372	371
373		if (state->m_fade_effect > r)
	372	if (m_fade_effect > r)
374	373	r = 0;
375	374	else
376		r -= state->m_fade_effect;
	375	r -= m_fade_effect;
377	376
378		palette_set_color(machine, i, MAKE_RGB(r, g, b));
	377	palette_set_color(machine(), i, MAKE_RGB(r, g, b));
379	378	}
380	379	}
381	380
r20931	r20932
387	386	if (m_old_fade != m_fade_effect)
388	387	{
389	388	m_old_fade = m_fade_effect;
390		update_colors(machine());
	389	update_colors();
391	390	}
392	391	}
393	392

trunk/src/mame/drivers/metro.c

r20931	r20932
558	558	update_irq_state();
559	559	}
560	560
561		INLINE int blt_read( const UINT8 *ROM, const int offs )
	561	inline int metro_state::blt_read( const UINT8 *ROM, const int offs )
562	562	{
563	563	return ROM[offs];
564	564	}
r20931	r20932
6263	6263
6264	6264	***************************************************************************/
6265	6265
6266		static void metro_common( running_machine &machine )
	6266	void metro_state::metro_common(  )
6267	6267	{
6268		metro_state *state = machine.driver_data<metro_state>();
6269	6268
6270		memset(state->m_requested_int, 0, ARRAY_LENGTH(state->m_requested_int));
6271		state->m_vblank_bit = 0;
6272		state->m_blitter_bit = 2;
6273		state->m_irq_line = 2;
	6269	memset(m_requested_int, 0, ARRAY_LENGTH(m_requested_int));
	6270	m_vblank_bit = 0;
	6271	m_blitter_bit = 2;
	6272	m_irq_line = 2;
6274	6273
6275		*state->m_irq_enable = 0;
	6274	*m_irq_enable = 0;
6276	6275	}
6277	6276
6278	6277
r20931	r20932
6280	6279	{
6281	6280	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
6282	6281
6283		metro_common(machine());
	6282	metro_common();
6284	6283
6285	6284	m_porta = 0x00;
6286	6285	m_portb = 0x00;
r20931	r20932
6307	6306	{
6308	6307	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
6309	6308
6310		metro_common(machine());
	6309	metro_common();
6311	6310
6312	6311	m_porta = 0x00;
6313	6312	m_portb = 0x00;
r20931	r20932
6333	6332	src   +=  2;
6334	6333	}
6335	6334
6336		metro_common(machine());
	6335	metro_common();
6337	6336	m_irq_line = 1;
6338	6337	}
6339	6338
r20931	r20932
6360	6359
6361	6360	DRIVER_INIT_MEMBER(metro_state,blzntrnd)
6362	6361	{
6363		metro_common(machine());
	6362	metro_common();
6364	6363	m_irq_line = 1;
6365	6364	}
6366	6365
6367	6366	DRIVER_INIT_MEMBER(metro_state,mouja)
6368	6367	{
6369		metro_common(machine());
	6368	metro_common();
6370	6369	m_irq_line = -1;    /* split interrupt handlers */
6371	6370	m_vblank_bit = 1;
6372	6371	m_mouja_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(metro_state::mouja_irq_callback),this));
r20931	r20932
6374	6373
6375	6374	DRIVER_INIT_MEMBER(metro_state,gakusai)
6376	6375	{
6377		metro_common(machine());
	6376	metro_common();
6378	6377	m_irq_line = -1;
6379	6378	m_vblank_bit = 1;
6380	6379	m_blitter_bit = 3;
r20931	r20932
6382	6381
6383	6382	DRIVER_INIT_MEMBER(metro_state,puzzlet)
6384	6383	{
6385		metro_common(machine());
	6384	metro_common();
6386	6385	m_irq_line = 0;
6387	6386	m_vblank_bit = 1;
6388	6387	m_blitter_bit = 0;

trunk/src/mame/drivers/megasys1.c

r20931	r20932
3608	3608	ROM_END
3609	3609
3610	3610
3611		static void rodlandj_gfx_unmangle(running_machine &machine, const char *region)
	3611	void megasys1_state::rodlandj_gfx_unmangle(const char *region)
3612	3612	{
3613		UINT8 *rom = machine.root_device().memregion(region)->base();
3614		int size = machine.root_device().memregion(region)->bytes();
	3613	UINT8 *rom = machine().root_device().memregion(region)->base();
	3614	int size = machine().root_device().memregion(region)->bytes();
3615	3615	UINT8 *buffer;
3616	3616	int i;
3617	3617
r20931	r20932
3622	3622	| ((rom[i] & 0x48) << 1)
3623	3623	| ((rom[i] & 0x10) << 2);
3624	3624
3625		buffer = auto_alloc_array(machine, UINT8, size);
	3625	buffer = auto_alloc_array(machine(), UINT8, size);
3626	3626
3627	3627	memcpy(buffer,rom,size);
3628	3628
r20931	r20932
3637	3637	rom[i] = buffer[a];
3638	3638	}
3639	3639
3640		auto_free(machine, buffer);
	3640	auto_free(machine(), buffer);
3641	3641	}
3642	3642
3643		static void jitsupro_gfx_unmangle(running_machine &machine, const char *region)
	3643	void megasys1_state::jitsupro_gfx_unmangle(const char *region)
3644	3644	{
3645		UINT8 *rom = machine.root_device().memregion(region)->base();
3646		int size = machine.root_device().memregion(region)->bytes();
	3645	UINT8 *rom = machine().root_device().memregion(region)->base();
	3646	int size = machine().root_device().memregion(region)->bytes();
3647	3647	UINT8 *buffer;
3648	3648	int i;
3649	3649
r20931	r20932
3651	3651	for (i = 0;i < size;i++)
3652	3652	rom[i] =   BITSWAP8(rom[i],0x4,0x3,0x5,0x7,0x6,0x2,0x1,0x0);
3653	3653
3654		buffer = auto_alloc_array(machine, UINT8, size);
	3654	buffer = auto_alloc_array(machine(), UINT8, size);
3655	3655
3656	3656	memcpy(buffer,rom,size);
3657	3657
r20931	r20932
3664	3664	rom[i] = buffer[a];
3665	3665	}
3666	3666
3667		auto_free(machine, buffer);
	3667	auto_free(machine(), buffer);
3668	3668	}
3669	3669
3670		static void stdragona_gfx_unmangle(running_machine &machine, const char *region)
	3670	void megasys1_state::stdragona_gfx_unmangle(const char *region)
3671	3671	{
3672		UINT8 *rom = machine.root_device().memregion(region)->base();
3673		int size = machine.root_device().memregion(region)->bytes();
	3672	UINT8 *rom = machine().root_device().memregion(region)->base();
	3673	int size = machine().root_device().memregion(region)->bytes();
3674	3674	UINT8 *buffer;
3675	3675	int i;
3676	3676
r20931	r20932
3678	3678	for (i = 0;i < size;i++)
3679	3679	rom[i] =   BITSWAP8(rom[i],3,7,5,6,4,2,1,0);
3680	3680
3681		buffer = auto_alloc_array(machine, UINT8, size);
	3681	buffer = auto_alloc_array(machine(), UINT8, size);
3682	3682
3683	3683	memcpy(buffer,rom,size);
3684	3684
r20931	r20932
3691	3691	rom[i] = buffer[a];
3692	3692	}
3693	3693
3694		auto_free(machine, buffer);
	3694	auto_free(machine(), buffer);
3695	3695	}
3696	3696
3697	3697	/*************************************
r20931	r20932
3927	3927
3928	3928	astyanax_rom_decode(machine(), "maincpu");      // Code
3929	3929
3930		jitsupro_gfx_unmangle(machine(), "gfx1");   // Gfx
3931		jitsupro_gfx_unmangle(machine(), "gfx4");
	3930	jitsupro_gfx_unmangle("gfx1");   // Gfx
	3931	jitsupro_gfx_unmangle("gfx4");
3932	3932	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x00000, 0x3ffff, read16_delegate(FUNC(megasys1_state::megasys1A_mcu_hs_r),this));
3933	3933	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x20000, 0x20009, write16_delegate(FUNC(megasys1_state::megasys1A_mcu_hs_w),this));
3934	3934
r20931	r20932
3954	3954
3955	3955	DRIVER_INIT_MEMBER(megasys1_state,rodlandj)
3956	3956	{
3957		rodlandj_gfx_unmangle(machine(), "gfx1");
3958		rodlandj_gfx_unmangle(machine(), "gfx4");
	3957	rodlandj_gfx_unmangle("gfx1");
	3958	rodlandj_gfx_unmangle("gfx4");
3959	3959
3960	3960	astyanax_rom_decode(machine(), "maincpu");
3961	3961	}
r20931	r20932
4025	4025	{
4026	4026	phantasm_rom_decode(machine(), "maincpu");
4027	4027
4028		stdragona_gfx_unmangle(machine(), "gfx1");
4029		stdragona_gfx_unmangle(machine(), "gfx4");
	4028	stdragona_gfx_unmangle("gfx1");
	4029	stdragona_gfx_unmangle("gfx4");
4030	4030
4031	4031	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x00000, 0x3ffff, read16_delegate(FUNC(megasys1_state::stdragon_mcu_hs_r),this));
4032	4032	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x23ff0, 0x23ff9, write16_delegate(FUNC(megasys1_state::stdragon_mcu_hs_w),this));

trunk/src/mame/drivers/mitchell.c

r20931	r20932
2080	2080	*
2081	2081	*************************************/
2082	2082
2083		static void bootleg_decode( running_machine &machine )
	2083	void mitchell_state::bootleg_decode(  )
2084	2084	{
2085		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
2086		space.set_decrypted_region(0x0000, 0x7fff, machine.root_device().memregion("maincpu")->base() + 0x50000);
2087		machine.root_device().membank("bank1")->configure_decrypted_entries(0, 16, machine.root_device().memregion("maincpu")->base() + 0x60000, 0x4000);
	2085	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	2086	space.set_decrypted_region(0x0000, 0x7fff, machine().root_device().memregion("maincpu")->base() + 0x50000);
	2087	machine().root_device().membank("bank1")->configure_decrypted_entries(0, 16, machine().root_device().memregion("maincpu")->base() + 0x60000, 0x4000);
2088	2088	}
2089	2089
2090	2090
2091		static void configure_banks( running_machine &machine )
	2091	void mitchell_state::configure_banks(  )
2092	2092	{
2093		machine.root_device().membank("bank1")->configure_entries(0, 16, machine.root_device().memregion("maincpu")->base() + 0x10000, 0x4000);
	2093	machine().root_device().membank("bank1")->configure_entries(0, 16, machine().root_device().memregion("maincpu")->base() + 0x10000, 0x4000);
2094	2094	}
2095	2095
2096	2096
r20931	r20932
2098	2098	{
2099	2099	m_input_type = 0;
2100	2100	mgakuen2_decode(machine());
2101		configure_banks(machine());
	2101	configure_banks();
2102	2102	}
2103	2103	DRIVER_INIT_MEMBER(mitchell_state,pang)
2104	2104	{
2105	2105	m_input_type = 0;
2106	2106	pang_decode(machine());
2107		configure_banks(machine());
	2107	configure_banks();
2108	2108	}
2109	2109	DRIVER_INIT_MEMBER(mitchell_state,pangb)
2110	2110	{
2111	2111	m_input_type = 0;
2112		bootleg_decode(machine());
2113		configure_banks(machine());
	2112	bootleg_decode();
	2113	configure_banks();
2114	2114	if (m_nvram != NULL)
2115	2115	m_nvram->set_base(&m_dummy_nvram, sizeof(m_dummy_nvram));   /* for pangba */
2116	2116	}
r20931	r20932
2118	2118	{
2119	2119	m_input_type = 0;
2120	2120	cworld_decode(machine());
2121		configure_banks(machine());
	2121	configure_banks();
2122	2122	}
2123	2123	DRIVER_INIT_MEMBER(mitchell_state,hatena)
2124	2124	{
2125	2125	m_input_type = 0;
2126	2126	hatena_decode(machine());
2127		configure_banks(machine());
	2127	configure_banks();
2128	2128	}
2129	2129	DRIVER_INIT_MEMBER(mitchell_state,spang)
2130	2130	{
2131	2131	m_input_type = 3;
2132	2132	m_nvram->set_base(&memregion("maincpu")->base()[0xe000], 0x80); /* NVRAM */
2133	2133	spang_decode(machine());
2134		configure_banks(machine());
	2134	configure_banks();
2135	2135	}
2136	2136
2137	2137	DRIVER_INIT_MEMBER(mitchell_state,spangbl)
2138	2138	{
2139	2139	m_input_type = 3;
2140	2140	m_nvram->set_base(&memregion("maincpu")->base()[0xe000], 0x80); /* NVRAM */
2141		bootleg_decode(machine());
2142		configure_banks(machine());
	2141	bootleg_decode();
	2142	configure_banks();
2143	2143	}
2144	2144
2145	2145	DRIVER_INIT_MEMBER(mitchell_state,spangj)
r20931	r20932
2147	2147	m_input_type = 3;
2148	2148	m_nvram->set_base(&memregion("maincpu")->base()[0xe000], 0x80); /* NVRAM */
2149	2149	spangj_decode(machine());
2150		configure_banks(machine());
	2150	configure_banks();
2151	2151	}
2152	2152	DRIVER_INIT_MEMBER(mitchell_state,sbbros)
2153	2153	{
2154	2154	m_input_type = 3;
2155	2155	m_nvram->set_base(&memregion("maincpu")->base()[0xe000], 0x80); /* NVRAM */
2156	2156	sbbros_decode(machine());
2157		configure_banks(machine());
	2157	configure_banks();
2158	2158	}
2159	2159	DRIVER_INIT_MEMBER(mitchell_state,qtono1)
2160	2160	{
2161	2161	m_input_type = 0;
2162	2162	qtono1_decode(machine());
2163		configure_banks(machine());
	2163	configure_banks();
2164	2164	}
2165	2165	DRIVER_INIT_MEMBER(mitchell_state,qsangoku)
2166	2166	{
2167	2167	m_input_type = 0;
2168	2168	qsangoku_decode(machine());
2169		configure_banks(machine());
	2169	configure_banks();
2170	2170	}
2171	2171	DRIVER_INIT_MEMBER(mitchell_state,mgakuen)
2172	2172	{
2173	2173	m_input_type = 1;
2174		configure_banks(machine());
	2174	configure_banks();
2175	2175	machine().device("maincpu")->memory().space(AS_IO).install_read_port(0x03, 0x03, "DSW0");
2176	2176	machine().device("maincpu")->memory().space(AS_IO).install_read_port(0x04, 0x04, "DSW1");
2177	2177	}
r20931	r20932
2179	2179	{
2180	2180	m_input_type = 1;
2181	2181	mgakuen2_decode(machine());
2182		configure_banks(machine());
	2182	configure_banks();
2183	2183	}
2184	2184	DRIVER_INIT_MEMBER(mitchell_state,pkladies)
2185	2185	{
2186	2186	m_input_type = 1;
2187	2187	mgakuen2_decode(machine());
2188		configure_banks(machine());
	2188	configure_banks();
2189	2189	}
2190	2190	DRIVER_INIT_MEMBER(mitchell_state,pkladiesbl)
2191	2191	{
2192	2192	m_input_type = 1;
2193		bootleg_decode(machine());
2194		configure_banks(machine());
	2193	bootleg_decode();
	2194	configure_banks();
2195	2195	}
2196	2196	DRIVER_INIT_MEMBER(mitchell_state,marukin)
2197	2197	{
2198	2198	m_input_type = 1;
2199	2199	marukin_decode(machine());
2200		configure_banks(machine());
	2200	configure_banks();
2201	2201	}
2202	2202	DRIVER_INIT_MEMBER(mitchell_state,block)
2203	2203	{
2204	2204	m_input_type = 2;
2205	2205	m_nvram->set_base(&memregion("maincpu")->base()[0xff80], 0x80); /* NVRAM */
2206	2206	block_decode(machine());
2207		configure_banks(machine());
	2207	configure_banks();
2208	2208	}
2209	2209	DRIVER_INIT_MEMBER(mitchell_state,blockbl)
2210	2210	{
2211	2211	m_input_type = 2;
2212	2212	m_nvram->set_base(&memregion("maincpu")->base()[0xff80], 0x80); /* NVRAM */
2213		bootleg_decode(machine());
2214		configure_banks(machine());
	2213	bootleg_decode();
	2214	configure_banks();
2215	2215	}
2216	2216
2217	2217	DRIVER_INIT_MEMBER(mitchell_state,mstworld)
r20931	r20932
2257	2257	}
2258	2258	auto_free(machine(), source);
2259	2259
2260		bootleg_decode(machine());
2261		configure_banks(machine());
	2260	bootleg_decode();
	2261	configure_banks();
2262	2262	}
2263	2263
2264	2264

trunk/src/mame/drivers/mystston.c

r20931	r20932
37	37	*
38	38	*************************************/
39	39
40		void mystston_on_scanline_interrupt(running_machine &machine)
	40	void mystston_state::mystston_on_scanline_interrupt()
41	41	{
42		machine.device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
	42	machine().device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
43	43	}
44	44
45	45

trunk/src/mame/drivers/mw8080bw.c

r20931	r20932
552	552	#define TORNBASE_CAB_TYPE_PORT_TAG      ("CAB")
553	553
554	554
555		UINT8 tornbase_get_cabinet_type(running_machine &machine)
	555	UINT8 mw8080bw_state::tornbase_get_cabinet_type()
556	556	{
557		return machine.root_device().ioport(TORNBASE_CAB_TYPE_PORT_TAG)->read();
	557	return machine().root_device().ioport(TORNBASE_CAB_TYPE_PORT_TAG)->read();
558	558	}
559	559
560	560
r20931	r20932
568	568	{
569	569	UINT32 ret;
570	570
571		switch (tornbase_get_cabinet_type(machine()))
	571	switch (tornbase_get_cabinet_type())
572	572	{
573	573	case TORNBASE_CAB_TYPE_UPRIGHT_OLD:
574	574	ret = ioport(TORNBASE_L_HIT_PORT_TAG)->read();
r20931	r20932
589	589	{
590	590	UINT32 ret;
591	591
592		switch (tornbase_get_cabinet_type(machine()))
	592	switch (tornbase_get_cabinet_type())
593	593	{
594	594	case TORNBASE_CAB_TYPE_UPRIGHT_OLD:
595	595	case TORNBASE_CAB_TYPE_UPRIGHT_NEW:
r20931	r20932
2122	2122	}
2123	2123
2124	2124	#if 0
2125		UINT8 spcenctr_get_trench_width( *running_machine &machine )
	2125	UINT8 mw8080bw_state::spcenctr_get_trench_width()
2126	2126	{
2127		mw8080bw_state *state = machine.driver_data<mw8080bw_state>();
2128		return state->m_spcenctr_trench_width;
	2127	return m_spcenctr_trench_width;
2129	2128	}
2130	2129
2131	2130
2132		UINT8 spcenctr_get_trench_center( *running_machine &machine )
	2131	UINT8 mw8080bw_state::spcenctr_get_trench_center()
2133	2132	{
2134		mw8080bw_state *state = machine.driver_data<mw8080bw_state>();
2135		return state->m_spcenctr_trench_center;
	2133	return m_spcenctr_trench_center;
2136	2134	}
2137	2135
2138	2136
2139		UINT8 spcenctr_get_trench_slope( *running_machine &machine, UINT8 addr )
	2137	UINT8 mw8080bw_state::spcenctr_get_trench_slope(UINT8 addr )
2140	2138	{
2141		mw8080bw_state *state = machine.driver_data<mw8080bw_state>();
2142		return state->m_spcenctr_trench_slope[addr & 0x0f];
	2139	return m_spcenctr_trench_slope[addr & 0x0f];
2143	2140	}
2144	2141	#endif
2145	2142
r20931	r20932
2519	2516	/* upright PCB : switches visible
2520	2517	cocktail PCB: HI */
2521	2518
2522		if (invaders_is_cabinet_cocktail(machine()))
	2519	if (invaders_is_cabinet_cocktail())
2523	2520	ret = 0x03;
2524	2521	else
2525	2522	ret = ioport(INVADERS_SW6_SW7_PORT_TAG)->read();
r20931	r20932
2535	2532	/* upright PCB : switch visible
2536	2533	cocktail PCB: HI */
2537	2534
2538		if (invaders_is_cabinet_cocktail(machine()))
	2535	if (invaders_is_cabinet_cocktail())
2539	2536	ret = 0x01;
2540	2537	else
2541	2538	ret = ioport(INVADERS_SW5_PORT_TAG)->read();
r20931	r20932
2551	2548	/* upright PCB : P1 controls
2552	2549	cocktail PCB: HI */
2553	2550
2554		if (invaders_is_cabinet_cocktail(machine()))
	2551	if (invaders_is_cabinet_cocktail())
2555	2552	ret = 0x07;
2556	2553	else
2557	2554	ret = ioport(INVADERS_P1_CONTROL_PORT_TAG)->read();
r20931	r20932
2573	2570	/* upright PCB : P1 controls
2574	2571	cocktail PCB: P2 controls */
2575	2572
2576		if (invaders_is_cabinet_cocktail(machine()))
	2573	if (invaders_is_cabinet_cocktail())
2577	2574	ret = ioport(INVADERS_P2_CONTROL_PORT_TAG)->read();
2578	2575	else
2579	2576	ret = ioport(INVADERS_P1_CONTROL_PORT_TAG)->read();
r20931	r20932
2582	2579	}
2583	2580
2584	2581
2585		int invaders_is_cabinet_cocktail(running_machine &machine)
	2582	int mw8080bw_state::invaders_is_cabinet_cocktail()
2586	2583	{
2587		return machine.root_device().ioport(INVADERS_CAB_TYPE_PORT_TAG)->read();
	2584	return machine().root_device().ioport(INVADERS_CAB_TYPE_PORT_TAG)->read();
2588	2585	}
2589	2586
2590	2587
r20931	r20932
2788	2785
2789	2786
2790	2787	#ifdef UNUSED_FUNCTION
2791		static UINT32 invad2ct_coin_input_r(void *param)
	2788	UINT32 mw8080bw_state::invad2ct_coin_input_r(void *param)
2792	2789	{
2793		UINT32 ret = machine.root_device().ioport(INVAD2CT_COIN_INPUT_PORT_TAG)->read();
	2790	UINT32 ret = machine().root_device().ioport(INVAD2CT_COIN_INPUT_PORT_TAG)->read();
2794	2791
2795	2792	coin_counter_w(machine, 0, !ret);
2796	2793

trunk/src/mame/drivers/ms32.c

r20931	r20932
2191	2191	ROM_END
2192	2192
2193	2193
2194		static void configure_banks(running_machine &machine)
	2194	void ms32_state::configure_banks()
2195	2195	{
2196		ms32_state *state = machine.driver_data<ms32_state>();
2197		state_save_register_global(machine, state->m_to_main);
2198		state->membank("bank4")->configure_entries(0, 16, state->memregion("audiocpu")->base() + 0x14000, 0x4000);
2199		state->membank("bank5")->configure_entries(0, 16, state->memregion("audiocpu")->base() + 0x14000, 0x4000);
	2196	state_save_register_global(machine(), m_to_main);
	2197	membank("bank4")->configure_entries(0, 16, memregion("audiocpu")->base() + 0x14000, 0x4000);
	2198	membank("bank5")->configure_entries(0, 16, memregion("audiocpu")->base() + 0x14000, 0x4000);
2200	2199	}
2201	2200
2202	2201	DRIVER_INIT_MEMBER(ms32_state,ms32_common)
2203	2202	{
2204	2203	m_nvram_8 = auto_alloc_array(machine(), UINT8, 0x2000);
2205		configure_banks(machine());
	2204	configure_banks();
2206	2205	}
2207	2206
2208	2207	/* SS91022-10: desertwr, gratiaa, tp2m32, gametngk */

trunk/src/mame/drivers/mcr3.c

r20931	r20932
1523	1523	*
1524	1524	*************************************/
1525	1525
1526		static void mcr_common_init(running_machine &machine)
	1526	void mcr3_state::mcr_common_init()
1527	1527	{
1528		mcr3_state *state = machine.driver_data<mcr3_state>();
1529
1530		state_save_register_global(machine, state->m_input_mux);
1531		state_save_register_global(machine, state->m_latched_input);
1532		state_save_register_global(machine, state->m_last_op4);
	1528	state_save_register_global(machine(), m_input_mux);
	1529	state_save_register_global(machine(), m_latched_input);
	1530	state_save_register_global(machine(), m_last_op4);
1533	1531	}
1534	1532
1535	1533
1536	1534	DRIVER_INIT_MEMBER(mcr3_state,demoderm)
1537	1535	{
1538		mcr_common_init(machine());
	1536	mcr_common_init();
1539	1537	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x01, 0x01, read8_delegate(FUNC(mcr3_state::demoderm_ip1_r),this));
1540	1538	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x02, 0x02, read8_delegate(FUNC(mcr3_state::demoderm_ip2_r),this));
1541	1539	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x06, 0x06, write8_delegate(FUNC(mcr3_state::demoderm_op6_w),this));
r20931	r20932
1544	1542
1545	1543	DRIVER_INIT_MEMBER(mcr3_state,sarge)
1546	1544	{
1547		mcr_common_init(machine());
	1545	mcr_common_init();
1548	1546	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x06, 0x06, write8_delegate(FUNC(midway_turbo_chip_squeak_device::write),m_turbo_chip_squeak.target()));
1549	1547	}
1550	1548
1551	1549
1552	1550	DRIVER_INIT_MEMBER(mcr3_state,maxrpm)
1553	1551	{
1554		mcr_common_init(machine());
	1552	mcr_common_init();
1555	1553	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x01, 0x01, read8_delegate(FUNC(mcr3_state::maxrpm_ip1_r),this));
1556	1554	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x02, 0x02, read8_delegate(FUNC(mcr3_state::maxrpm_ip2_r),this));
1557	1555	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x05, 0x05, write8_delegate(FUNC(mcr3_state::maxrpm_op5_w),this));
r20931	r20932
1567	1565
1568	1566	DRIVER_INIT_MEMBER(mcr3_state,rampage)
1569	1567	{
1570		mcr_common_init(machine());
	1568	mcr_common_init();
1571	1569	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x04, 0x04, read8_delegate(FUNC(mcr3_state::rampage_ip4_r),this));
1572	1570	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x06, 0x06, write8_delegate(FUNC(mcr3_state::rampage_op6_w),this));
1573	1571	}
r20931	r20932
1575	1573
1576	1574	DRIVER_INIT_MEMBER(mcr3_state,powerdrv)
1577	1575	{
1578		mcr_common_init(machine());
	1576	mcr_common_init();
1579	1577	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x02, 0x02, read8_delegate(FUNC(mcr3_state::powerdrv_ip2_r),this));
1580	1578	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x05, 0x05, write8_delegate(FUNC(mcr3_state::powerdrv_op5_w),this));
1581	1579	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x06, 0x06, write8_delegate(FUNC(mcr3_state::powerdrv_op6_w),this));
r20931	r20932
1584	1582
1585	1583	DRIVER_INIT_MEMBER(mcr3_state,stargrds)
1586	1584	{
1587		mcr_common_init(machine());
	1585	mcr_common_init();
1588	1586	machine().device("maincpu")->memory().space(AS_IO).install_read_handler(0x00, 0x00, read8_delegate(FUNC(mcr3_state::stargrds_ip0_r),this));
1589	1587	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x05, 0x05, write8_delegate(FUNC(mcr3_state::stargrds_op5_w),this));
1590	1588	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0x06, 0x06, write8_delegate(FUNC(mcr3_state::stargrds_op6_w),this));
r20931	r20932
1593	1591
1594	1592	DRIVER_INIT_MEMBER(mcr3_state,spyhunt)
1595	1593	{
1596		mcr_common_init(machine());
	1594	mcr_common_init();
1597	1595	machine().device<midway_ssio_device>("ssio")->set_custom_input(1, 0x60, read8_delegate(FUNC(mcr3_state::spyhunt_ip1_r),this));
1598	1596	machine().device<midway_ssio_device>("ssio")->set_custom_input(2, 0xff, read8_delegate(FUNC(mcr3_state::spyhunt_ip2_r),this));
1599	1597	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0xff, write8_delegate(FUNC(mcr3_state::spyhunt_op4_w),this));
r20931	r20932
1605	1603
1606	1604	DRIVER_INIT_MEMBER(mcr3_state,crater)
1607	1605	{
1608		mcr_common_init(machine());
	1606	mcr_common_init();
1609	1607
1610	1608	m_spyhunt_sprite_color_mask = 0x03;
1611	1609	m_spyhunt_scroll_offset = 96;
r20931	r20932
1614	1612
1615	1613	DRIVER_INIT_MEMBER(mcr3_state,turbotag)
1616	1614	{
1617		mcr_common_init(machine());
	1615	mcr_common_init();
1618	1616	machine().device<midway_ssio_device>("ssio")->set_custom_input(1, 0x60, read8_delegate(FUNC(mcr3_state::spyhunt_ip1_r),this));
1619	1617	machine().device<midway_ssio_device>("ssio")->set_custom_input(2, 0xff, read8_delegate(FUNC(mcr3_state::turbotag_ip2_r),this));
1620	1618	machine().device<midway_ssio_device>("ssio")->set_custom_output(4, 0xff, write8_delegate(FUNC(mcr3_state::spyhunt_op4_w),this));

trunk/src/mame/drivers/maygay1b.c

r20931	r20932
99	99	*
100	100	*************************************/
101	101
102		static void update_outputs(i8279_state *chip, UINT16 which)
	102	void maygay1b_state::update_outputs(i8279_state *chip, UINT16 which)
103	103	{
104	104	static const UINT8 ls48_map[16] =
105	105	{ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x67,0x58,0x4c,0x62,0x69,0x78,0x00 };
r20931	r20932
456	456	// called if board is reset ///////////////////////////////////////////////
457	457	///////////////////////////////////////////////////////////////////////////
458	458
459		static void m1_stepper_reset(running_machine &machine)
	459	void maygay1b_state::m1_stepper_reset()
460	460	{
461		maygay1b_state *state = machine.driver_data<maygay1b_state>();
462	461	int pattern = 0,i;
463	462	for ( i = 0; i < 6; i++)
464	463	{
465	464	stepper_reset_position(i);
466	465	if ( stepper_optic_state(i) ) pattern |= 1<<i;
467	466	}
468		state->m_optic_pattern = pattern;
	467	m_optic_pattern = pattern;
469	468	}
470	469
471	470	void maygay1b_state::machine_reset()
472	471	{
473	472	m_vfd->reset(); // reset display1
474	473	m_duart68681 = machine().device( "duart68681" );
475		m1_stepper_reset(machine());
	474	m1_stepper_reset();
476	475	}
477	476
478	477	///////////////////////////////////////////////////////////////////////////

trunk/src/mame/drivers/mcr68.c

r20931	r20932
1534	1534	*
1535	1535	*************************************/
1536	1536
1537		static void mcr68_common_init(running_machine &machine, int clip, int xoffset)
	1537	void mcr68_state::mcr68_common_init(int clip, int xoffset)
1538	1538	{
1539		mcr68_state *state = machine.driver_data<mcr68_state>();
1540	1539
1541		state->m_sprite_clip = clip;
1542		state->m_sprite_xoffset = xoffset;
	1540	m_sprite_clip = clip;
	1541	m_sprite_xoffset = xoffset;
1543	1542
1544		state_save_register_global(machine, state->m_control_word);
	1543	state_save_register_global(machine(), m_control_word);
1545	1544	}
1546	1545
1547	1546
1548	1547	DRIVER_INIT_MEMBER(mcr68_state,zwackery)
1549	1548	{
1550		mcr68_common_init(machine(), 0, 0);
	1549	mcr68_common_init(0, 0);
1551	1550
1552	1551	/* Zwackery doesn't care too much about this value; currently taken from Blasted */
1553	1552	m_timing_factor = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10) * (256 + 16);
r20931	r20932
1556	1555
1557	1556	DRIVER_INIT_MEMBER(mcr68_state,xenophob)
1558	1557	{
1559		mcr68_common_init(machine(), 0, -4);
	1558	mcr68_common_init(0, -4);
1560	1559
1561	1560	/* Xenophobe doesn't care too much about this value; currently taken from Blasted */
1562	1561	m_timing_factor = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10) * (256 + 16);
r20931	r20932
1568	1567
1569	1568	DRIVER_INIT_MEMBER(mcr68_state,spyhunt2)
1570	1569	{
1571		mcr68_common_init(machine(), 0, -6);
	1570	mcr68_common_init(0, -6);
1572	1571
1573	1572	/* Spy Hunter II doesn't care too much about this value; currently taken from Blasted */
1574	1573	m_timing_factor = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10) * (256 + 16);
r20931	r20932
1582	1581
1583	1582	DRIVER_INIT_MEMBER(mcr68_state,blasted)
1584	1583	{
1585		mcr68_common_init(machine(), 0, 0);
	1584	mcr68_common_init(0, 0);
1586	1585
1587	1586	/* Blasted checks the timing of VBLANK relative to the 493 interrupt */
1588	1587	/* VBLANK is required to come within 220-256 E clocks (i.e., 2200-2560 CPU clocks) */
r20931	r20932
1598	1597
1599	1598	DRIVER_INIT_MEMBER(mcr68_state,intlaser)
1600	1599	{
1601		mcr68_common_init(machine(), 0, 0);
	1600	mcr68_common_init(0, 0);
1602	1601
1603	1602	/* Copied from Blasted */
1604	1603	m_timing_factor = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10) * (256 + 16);
r20931	r20932
1612	1611
1613	1612	DRIVER_INIT_MEMBER(mcr68_state,archrivl)
1614	1613	{
1615		mcr68_common_init(machine(), 16, 0);
	1614	mcr68_common_init(16, 0);
1616	1615
1617	1616	/* Arch Rivals doesn't care too much about this value; currently taken from Blasted */
1618	1617	m_timing_factor = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10) * (256 + 16);
r20931	r20932
1630	1629
1631	1630	DRIVER_INIT_MEMBER(mcr68_state,pigskin)
1632	1631	{
1633		mcr68_common_init(machine(), 16, 0);
	1632	mcr68_common_init(16, 0);
1634	1633
1635	1634	/* Pigskin doesn't care too much about this value; currently taken from Tri-Sports */
1636	1635	m_timing_factor = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10) * 115;
r20931	r20932
1641	1640
1642	1641	DRIVER_INIT_MEMBER(mcr68_state,trisport)
1643	1642	{
1644		mcr68_common_init(machine(), 0, 0);
	1643	mcr68_common_init(0, 0);
1645	1644
1646	1645	/* Tri-Sports checks the timing of VBLANK relative to the 493 interrupt */
1647	1646	/* VBLANK is required to come within 87-119 E clocks (i.e., 870-1190 CPU clocks) */

trunk/src/mame/drivers/m72.c

r20931	r20932
412	412	***************************************************************************/
413	413
414	414	#if 0
415		static int find_sample(int num)
	415	int m72_state::find_sample(int num)
416	416	{
417		UINT8 *rom = machine.root_device().memregion("samples")->base();
418		int len = machine.root_device().memregion("samples")->bytes();
	417	UINT8 *rom = machine().root_device().memregion("samples")->base();
	418	int len = machine().root_device().memregion("samples")->bytes();
419	419	int addr = 0;
420	420
421	421	while (num--)
r20931	r20932
683	683
684	684
685	685
686		static void copy_le(UINT16 *dest, const UINT8 *src, UINT8 bytes)
	686	void m72_state::copy_le(UINT16 *dest, const UINT8 *src, UINT8 bytes)
687	687	{
688	688	int i;
689	689
r20931	r20932
708	708	copy_le(&m_protection_ram[0x0fe0],m_protection_crc,CRC_LEN);
709	709	}
710	710
711		static void install_protection_handler(running_machine &machine, const UINT8 *code,const UINT8 *crc)
	711	void m72_state::install_protection_handler(const UINT8 *code,const UINT8 *crc)
712	712	{
713		m72_state *state = machine.driver_data<m72_state>();
714		state->m_protection_ram = auto_alloc_array(machine, UINT16, 0x1000/2);
715		state->m_protection_code = code;
716		state->m_protection_crc =  crc;
717		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xb0000, 0xb0fff, "bank1");
718		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0xb0ffa, 0xb0ffb, read16_delegate(FUNC(m72_state::protection_r),state));
719		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0xb0000, 0xb0fff, write16_delegate(FUNC(m72_state::protection_w),state));
720		state->membank("bank1")->set_base(state->m_protection_ram);
	713	m_protection_ram = auto_alloc_array(machine(), UINT16, 0x1000/2);
	714	m_protection_code = code;
	715	m_protection_crc =  crc;
	716	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xb0000, 0xb0fff, "bank1");
	717	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0xb0ffa, 0xb0ffb, read16_delegate(FUNC(m72_state::protection_r),this));
	718	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0xb0000, 0xb0fff, write16_delegate(FUNC(m72_state::protection_w),this));
	719	membank("bank1")->set_base(m_protection_ram);
721	720	}
722	721
723	722	DRIVER_INIT_MEMBER(m72_state,bchopper)
724	723	{
725		install_protection_handler(machine(), bchopper_code,bchopper_crc);
	724	install_protection_handler(bchopper_code,bchopper_crc);
726	725	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::bchopper_sample_trigger_w),this));
727	726	}
728	727
729	728	DRIVER_INIT_MEMBER(m72_state,mrheli)
730	729	{
731		install_protection_handler(machine(), bchopper_code,mrheli_crc);
	730	install_protection_handler(bchopper_code,mrheli_crc);
732	731	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::bchopper_sample_trigger_w),this));
733	732	}
734	733
735	734	DRIVER_INIT_MEMBER(m72_state,nspirit)
736	735	{
737		install_protection_handler(machine(), nspirit_code,nspirit_crc);
	736	install_protection_handler(nspirit_code,nspirit_crc);
738	737	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::nspirit_sample_trigger_w),this));
739	738	}
740	739
741	740	DRIVER_INIT_MEMBER(m72_state,imgfight)
742	741	{
743		install_protection_handler(machine(), imgfight_code,imgfightj_crc);
	742	install_protection_handler(imgfight_code,imgfightj_crc);
744	743	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::imgfight_sample_trigger_w),this));
745	744	}
746	745
747	746	DRIVER_INIT_MEMBER(m72_state,loht)
748	747	{
749		install_protection_handler(machine(), loht_code,loht_crc);
	748	install_protection_handler(loht_code,loht_crc);
750	749
751	750	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::loht_sample_trigger_w),this));
752	751
r20931	r20932
756	755
757	756	DRIVER_INIT_MEMBER(m72_state,xmultiplm72)
758	757	{
759		install_protection_handler(machine(), xmultiplm72_code,xmultiplm72_crc);
	758	install_protection_handler(xmultiplm72_code,xmultiplm72_crc);
760	759	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::xmultiplm72_sample_trigger_w),this));
761	760	}
762	761
763	762	DRIVER_INIT_MEMBER(m72_state,dbreedm72)
764	763	{
765		install_protection_handler(machine(), dbreedm72_code,dbreedm72_crc);
	764	install_protection_handler(dbreedm72_code,dbreedm72_crc);
766	765	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::dbreedm72_sample_trigger_w),this));
767	766	}
768	767
769	768	DRIVER_INIT_MEMBER(m72_state,airduel)
770	769	{
771		install_protection_handler(machine(), airduel_code,airduel_crc);
	770	install_protection_handler(airduel_code,airduel_crc);
772	771	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::airduel_sample_trigger_w),this));
773	772	}
774	773
775	774	DRIVER_INIT_MEMBER(m72_state,dkgenm72)
776	775	{
777		install_protection_handler(machine(), dkgenm72_code,dkgenm72_crc);
	776	install_protection_handler(dkgenm72_code,dkgenm72_crc);
778	777	machine().device("maincpu")->memory().space(AS_IO).install_write_handler(0xc0, 0xc1, write16_delegate(FUNC(m72_state::dkgenm72_sample_trigger_w),this));
779	778	}
780	779

trunk/src/mame/audio/mw8080bw.c

r20931	r20932
337	337
338	338	/* if (data & 0x10)  enable CHEER sound */
339	339
340		if (tornbase_get_cabinet_type(machine()) == TORNBASE_CAB_TYPE_UPRIGHT_OLD)
	340	if (tornbase_get_cabinet_type() == TORNBASE_CAB_TYPE_UPRIGHT_OLD)
341	341	{
342	342	/* if (data & 0x20)  enable WHISTLE sound */
343	343
r20931	r20932
4195	4195	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_SAUCER_HIT_EN, 1), data & 0x10);
4196	4196
4197	4197	/* the flip screen line is only connected on the cocktail PCB */
4198		if (invaders_is_cabinet_cocktail(machine()))
	4198	if (invaders_is_cabinet_cocktail())
4199	4199	{
4200	4200	m_flip_screen = (data >> 5) & 0x01;
4201	4201	}

trunk/src/mame/machine/mexico86.c

r20931	r20932
41	41
42	42	***************************************************************************/
43	43
44		static void mcu_simulate( running_machine &machine )
	44	void mexico86_state::mcu_simulate(  )
45	45	{
46		mexico86_state *state = machine.driver_data<mexico86_state>();
47	46
48		if (!state->m_mcu_initialised)
	47	if (!m_mcu_initialised)
49	48	{
50		if (state->m_protection_ram[0x01] == 0x00)
	49	if (m_protection_ram[0x01] == 0x00)
51	50	{
52	51	logerror("initialising MCU\n");
53		state->m_protection_ram[0x04] = 0xfc;   // coin inputs
54		state->m_protection_ram[0x02] = 0xff;   // player 1
55		state->m_protection_ram[0x03] = 0xff;   // player 2
56		state->m_protection_ram[0x1b] = 0xff;   // active player
57		state->m_protection_ram[0x06] = 0xff;   // must be FF otherwise PS4 ERROR
58		state->m_protection_ram[0x07] = 0x03;   // must be 03 otherwise PS4 ERROR
59		state->m_protection_ram[0x00] = 0x00;
60		state->m_mcu_initialised = 1;
	52	m_protection_ram[0x04] = 0xfc;   // coin inputs
	53	m_protection_ram[0x02] = 0xff;   // player 1
	54	m_protection_ram[0x03] = 0xff;   // player 2
	55	m_protection_ram[0x1b] = 0xff;   // active player
	56	m_protection_ram[0x06] = 0xff;   // must be FF otherwise PS4 ERROR
	57	m_protection_ram[0x07] = 0x03;   // must be 03 otherwise PS4 ERROR
	58	m_protection_ram[0x00] = 0x00;
	59	m_mcu_initialised = 1;
61	60	}
62	61	}
63	62
64		if (state->m_mcu_initialised)
	63	if (m_mcu_initialised)
65	64	{
66	65	int i;
67	66	int coin_curr;
68	67
69		coin_curr = ~machine.root_device().ioport("IN0")->read() & 1;
70		if (coin_curr && !state->m_coin_last && state->m_protection_ram[0x01] < 9)
	68	coin_curr = ~machine().root_device().ioport("IN0")->read() & 1;
	69	if (coin_curr && !m_coin_last && m_protection_ram[0x01] < 9)
71	70	{
72		state->m_protection_ram[0x01]++;    // increase credits counter
73		state->m_protection_ram[0x0a] = 0x01;   // set flag (coin inserted sound is not played otherwise)
	71	m_protection_ram[0x01]++;    // increase credits counter
	72	m_protection_ram[0x0a] = 0x01;   // set flag (coin inserted sound is not played otherwise)
74	73	}
75		state->m_coin_last = coin_curr;
	74	m_coin_last = coin_curr;
76	75
77		state->m_protection_ram[0x04] = 0x3c;   // coin inputs
	76	m_protection_ram[0x04] = 0x3c;   // coin inputs
78	77
79		state->m_protection_ram[0x02] = BITSWAP8(machine.root_device().ioport("IN1")->read(), 7,6,5,4,2,3,1,0); // player 1
80		state->m_protection_ram[0x03] = BITSWAP8(machine.root_device().ioport("IN2")->read(), 7,6,5,4,2,3,1,0); // player 2
	78	m_protection_ram[0x02] = BITSWAP8(machine().root_device().ioport("IN1")->read(), 7,6,5,4,2,3,1,0); // player 1
	79	m_protection_ram[0x03] = BITSWAP8(machine().root_device().ioport("IN2")->read(), 7,6,5,4,2,3,1,0); // player 2
81	80
82		if (state->m_protection_ram[0x19] == 0xaa)  // player 2 active
83		state->m_protection_ram[0x1b] = state->m_protection_ram[0x03];
	81	if (m_protection_ram[0x19] == 0xaa)  // player 2 active
	82	m_protection_ram[0x1b] = m_protection_ram[0x03];
84	83	else
85		state->m_protection_ram[0x1b] = state->m_protection_ram[0x02];
	84	m_protection_ram[0x1b] = m_protection_ram[0x02];
86	85
87	86
88	87	for (i = 0; i < 0x10; i += 2)
89		state->m_protection_ram[i + 0xb1] = state->m_protection_ram[i + 0xb0];
	88	m_protection_ram[i + 0xb1] = m_protection_ram[i + 0xb0];
90	89
91	90	for (i = 0; i < 0x0a; i++)
92		state->m_protection_ram[i + 0xc0] = state->m_protection_ram[i + 0x90] + 1;
	91	m_protection_ram[i + 0xc0] = m_protection_ram[i + 0x90] + 1;
93	92
94		if (state->m_protection_ram[0xd1] == 0xff)
	93	if (m_protection_ram[0xd1] == 0xff)
95	94	{
96		if (state->m_protection_ram[0xd0] > 0 && state->m_protection_ram[0xd0] < 4)
	95	if (m_protection_ram[0xd0] > 0 && m_protection_ram[0xd0] < 4)
97	96	{
98		state->m_protection_ram[0xd2] = 0x81;
99		state->m_protection_ram[0xd0] = 0xff;
	97	m_protection_ram[0xd2] = 0x81;
	98	m_protection_ram[0xd0] = 0xff;
100	99	}
101	100	}
102	101
103		if (state->m_protection_ram[0xe0] > 0 && state->m_protection_ram[0xe0] < 4)
	102	if (m_protection_ram[0xe0] > 0 && m_protection_ram[0xe0] < 4)
104	103	{
105	104	static const UINT8 answers[3][16] =
106	105	{
r20931	r20932
108	107	{ 0x00,0x04,0x08,0x0C,0x10,0x14,0x18,0x1C,0x20,0x31,0x2B,0x35,0x00,0x00,0x00,0x00 },
109	108	{ 0x00,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x03,0x0A,0x0B,0x14,0x00,0x00,0x00,0x00 },
110	109	};
111		int table = state->m_protection_ram[0xe0] - 1;
	110	int table = m_protection_ram[0xe0] - 1;
112	111
113	112	for (i = 1; i < 0x10; i++)
114		state->m_protection_ram[0xe0 + i] = answers[table][i];
115		state->m_protection_ram[0xe0] = 0xff;
	113	m_protection_ram[0xe0 + i] = answers[table][i];
	114	m_protection_ram[0xe0] = 0xff;
116	115	}
117	116
118		if (state->m_protection_ram[0xf0] > 0 && state->m_protection_ram[0xf0] < 4)
	117	if (m_protection_ram[0xf0] > 0 && m_protection_ram[0xf0] < 4)
119	118	{
120		state->m_protection_ram[0xf1] = 0xb3;
121		state->m_protection_ram[0xf0] = 0xff;
	119	m_protection_ram[0xf1] = 0xb3;
	120	m_protection_ram[0xf0] = 0xff;
122	121	}
123	122
124	123
r20931	r20932
126	125	// this should be equivalent to the obfuscated kiki_clogic() below
127	126	{
128	127	static const UINT8 db[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x10,0x18,0x00,0x00,0x00,0x00};
129		UINT16 sy = state->m_protection_ram[0xa0] + ((0x18) >> 1);
130		UINT16 sx = state->m_protection_ram[0xa1] + ((0x18) >> 1);
	128	UINT16 sy = m_protection_ram[0xa0] + ((0x18) >> 1);
	129	UINT16 sx = m_protection_ram[0xa1] + ((0x18) >> 1);
131	130
132	131	for (i = 0; i < 0x38; i += 8)
133	132	{
134		UINT8 hw = db[state->m_protection_ram[0x20 + i] & 0xf];
	133	UINT8 hw = db[m_protection_ram[0x20 + i] & 0xf];
135	134
136	135	if (hw)
137	136	{
138		UINT16 xdiff = sx - ((UINT16)state->m_protection_ram[0x20 + i + 6] << 8 | state->m_protection_ram[0x20 + i + 7]);
	137	UINT16 xdiff = sx - ((UINT16)m_protection_ram[0x20 + i + 6] << 8 | m_protection_ram[0x20 + i + 7]);
139	138	if (xdiff < hw)
140	139	{
141		UINT16 ydiff = sy - ((UINT16)state->m_protection_ram[0x20 + i + 4] << 8 | state->m_protection_ram[0x20 + i + 5]);
	140	UINT16 ydiff = sy - ((UINT16)m_protection_ram[0x20 + i + 4] << 8 | m_protection_ram[0x20 + i + 5]);
142	141	if (ydiff < hw)
143		state->m_protection_ram[0xa2] = 1; // we have a collision
	142	m_protection_ram[0xa2] = 1; // we have a collision
144	143	}
145	144	}
146	145	}
r20931	r20932
152	151	INTERRUPT_GEN_MEMBER(mexico86_state::kikikai_interrupt)
153	152	{
154	153	if (m_mcu_running)
155		mcu_simulate(machine());
	154	mcu_simulate();
156	155
157	156	device.execute().set_input_line_vector(0, m_protection_ram[0]);
158	157	device.execute().set_input_line(0, HOLD_LINE);
r20931	r20932
171	170	#define DCWIDTH 0
172	171	#define DCHEIGHT 0
173	172
174		static void kiki_clogic(running_machine &machine, int address, int latch)
	173	void mexico86_state::kiki_clogic(int address, int latch)
175	174	{
176		mexico86_state *state = machine.driver_data<mexico86_state>();
177	175	static const UINT8 db[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x10,0x18,0x00,0x00,0x00,0x00};
178	176	int sy, sx, hw, i, qptr, diff1, diff2;
179	177
180		if (address != KIKI_CL_TRIGGER) // state->m_queue latched data
	178	if (address != KIKI_CL_TRIGGER) // m_queue latched data
181	179	{
182		state->m_queue[state->m_qfront++] = latch;
183		state->m_qfront &= 0x3f;
	180	m_queue[m_qfront++] = latch;
	181	m_qfront &= 0x3f;
184	182	}
185		else if (state->m_qstate ^= 1) // scan state->m_queue
	183	else if (m_qstate ^= 1) // scan m_queue
186	184	{
187		sy = state->m_queue[(state->m_qfront-0x3a)&0x3f] + ((0x18-DCHEIGHT)>>1);
188		sx = state->m_queue[(state->m_qfront-0x39)&0x3f] + ((0x18-DCWIDTH)>>1);
	185	sy = m_queue[(m_qfront-0x3a)&0x3f] + ((0x18-DCHEIGHT)>>1);
	186	sx = m_queue[(m_qfront-0x39)&0x3f] + ((0x18-DCWIDTH)>>1);
189	187
190	188	for (i=0x38; i; i-=8)
191	189	{
192		qptr = state->m_qfront - i;
193		if (!(hw = db[state->m_queue[qptr&0x3f]&0xf])) continue;
	190	qptr = m_qfront - i;
	191	if (!(hw = db[m_queue[qptr&0x3f]&0xf])) continue;
194	192
195		diff1 = sx - (short)(state->m_queue[(qptr+6)&0x3f]<<8|state->m_queue[(qptr+7)&0x3f]) + DCWIDTH;
	193	diff1 = sx - (short)(m_queue[(qptr+6)&0x3f]<<8|m_queue[(qptr+7)&0x3f]) + DCWIDTH;
196	194	diff2 = diff1 - (hw + DCWIDTH);
197	195	if ((diff1^diff2)<0)
198	196	{
199		diff1 = sy - (short)(state->m_queue[(qptr+4)&0x3f]<<8|state->m_queue[(qptr+5)&0x3f]) + DCHEIGHT;
	197	diff1 = sy - (short)(m_queue[(qptr+4)&0x3f]<<8|m_queue[(qptr+5)&0x3f]) + DCHEIGHT;
200	198	diff2 = diff1 - (hw + DCHEIGHT);
201	199	if ((diff1^diff2)<0)
202		state->m_protection_ram[KIKI_CL_OUT] = 1; // we have a collision
	200	m_protection_ram[KIKI_CL_OUT] = 1; // we have a collision
203	201	}
204	202	}
205	203	}

trunk/src/mame/machine/midwunit.c

r20931	r20932
18	18	*
19	19	*************************************/
20	20
21		static void register_state_saving(running_machine &machine)
	21	void midwunit_state::register_state_saving()
22	22	{
23		midwunit_state *state = machine.driver_data<midwunit_state>();
24		state_save_register_global(machine, state->m_cmos_write_enable);
25		state_save_register_global_array(machine, state->m_iodata);
26		state_save_register_global_array(machine, state->m_ioshuffle);
27		state_save_register_global_array(machine, state->m_uart);
28		state_save_register_global(machine, state->m_security_bits);
	23	state_save_register_global(machine(), m_cmos_write_enable);
	24	state_save_register_global_array(machine(), m_iodata);
	25	state_save_register_global_array(machine(), m_ioshuffle);
	26	state_save_register_global_array(machine(), m_uart);
	27	state_save_register_global(machine(), m_security_bits);
29	28	}
30	29
31	30
r20931	r20932
146	145	*
147	146	*************************************/
148	147
149		static void init_wunit_generic(running_machine &machine)
	148	void midwunit_state::init_wunit_generic()
150	149	{
151	150	/* register for state saving */
152		register_state_saving(machine);
	151	register_state_saving();
153	152
154	153	/* init sound */
155		dcs_init(machine);
	154	dcs_init(machine());
156	155	}
157	156
158	157
r20931	r20932
194	193	/*  printf("in=%04X%04X  out=%04X%04X\n", m_umk3_palette[3], m_umk3_palette[2], m_umk3_palette[1], m_umk3_palette[0]); */
195	194	}
196	195
197		static void init_mk3_common(running_machine &machine)
	196	void midwunit_state::init_mk3_common()
198	197	{
199	198	/* common init */
200		init_wunit_generic(machine);
	199	init_wunit_generic();
201	200
202	201	/* serial prefixes 439, 528 */
203		midway_serial_pic_init(machine, 528);
	202	midway_serial_pic_init(machine(), 528);
204	203	}
205	204
206	205	DRIVER_INIT_MEMBER(midwunit_state,mk3)
207	206	{
208		init_mk3_common(machine());
	207	init_mk3_common();
209	208	}
210	209
211	210	DRIVER_INIT_MEMBER(midwunit_state,mk3r20)
212	211	{
213		init_mk3_common(machine());
	212	init_mk3_common();
214	213	}
215	214
216	215	DRIVER_INIT_MEMBER(midwunit_state,mk3r10)
217	216	{
218		init_mk3_common(machine());
	217	init_mk3_common();
219	218	}
220	219
221	220	DRIVER_INIT_MEMBER(midwunit_state,umk3)
222	221	{
223		init_mk3_common(machine());
	222	init_mk3_common();
224	223	m_umk3_palette = machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x0106a060, 0x0106a09f, write16_delegate(FUNC(midwunit_state::umk3_palette_hack_w),this));
225	224	}
226	225
227	226	DRIVER_INIT_MEMBER(midwunit_state,umk3r11)
228	227	{
229		init_mk3_common(machine());
	228	init_mk3_common();
230	229	m_umk3_palette = machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x0106a060, 0x0106a09f,write16_delegate(FUNC(midwunit_state::umk3_palette_hack_w),this));
231	230	}
232	231
r20931	r20932
236	235	DRIVER_INIT_MEMBER(midwunit_state,openice)
237	236	{
238	237	/* common init */
239		init_wunit_generic(machine());
	238	init_wunit_generic();
240	239
241	240	/* serial prefixes 438, 528 */
242	241	midway_serial_pic_init(machine(), 528);
r20931	r20932
248	247	DRIVER_INIT_MEMBER(midwunit_state,nbahangt)
249	248	{
250	249	/* common init */
251		init_wunit_generic(machine());
	250	init_wunit_generic();
252	251
253	252	/* serial prefixes 459, 470, 528 */
254	253	midway_serial_pic_init(machine(), 528);
r20931	r20932
309	308	DRIVER_INIT_MEMBER(midwunit_state,wwfmania)
310	309	{
311	310	/* common init */
312		init_wunit_generic(machine());
	311	init_wunit_generic();
313	312
314	313	/* enable I/O shuffling */
315	314	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x01800000, 0x0180000f, write16_delegate(FUNC(midwunit_state::wwfmania_io_0_w),this));
r20931	r20932
324	323	DRIVER_INIT_MEMBER(midwunit_state,rmpgwt)
325	324	{
326	325	/* common init */
327		init_wunit_generic(machine());
	326	init_wunit_generic();
328	327
329	328	/* serial prefixes 465, 528 */
330	329	midway_serial_pic_init(machine(), 528);

trunk/src/mame/machine/mw8080bw.c

r20931	r20932
13	13	*
14	14	*************************************/
15	15
16		static UINT8 vpos_to_vysnc_chain_counter( int vpos )
	16	UINT8 mw8080bw_state::vpos_to_vysnc_chain_counter( int vpos )
17	17	{
18	18	/* convert from a vertical position to the actual values on the vertical sync counters */
19	19	UINT8 counter;
r20931	r20932
28	28	}
29	29
30	30
31		static int vysnc_chain_counter_to_vpos( UINT8 counter, int vblank )
	31	int mw8080bw_state::vysnc_chain_counter_to_vpos( UINT8 counter, int vblank )
32	32	{
33	33	/* convert from the vertical sync counters to an actual vertical position */
34	34	int vpos;
r20931	r20932
71	71	}
72	72
73	73
74		static void mw8080bw_create_interrupt_timer( running_machine &machine )
	74	void mw8080bw_state::mw8080bw_create_interrupt_timer(  )
75	75	{
76		mw8080bw_state *state = machine.driver_data<mw8080bw_state>();
77		state->m_interrupt_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(mw8080bw_state::mw8080bw_interrupt_callback),state));
	76	m_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(mw8080bw_state::mw8080bw_interrupt_callback),this));
78	77	}
79	78
80	79
81		static void mw8080bw_start_interrupt_timer( running_machine &machine )
	80	void mw8080bw_state::mw8080bw_start_interrupt_timer(  )
82	81	{
83		mw8080bw_state *state = machine.driver_data<mw8080bw_state>();
84	82	int vpos = vysnc_chain_counter_to_vpos(MW8080BW_INT_TRIGGER_COUNT_1, MW8080BW_INT_TRIGGER_VBLANK_1);
85		state->m_interrupt_timer->adjust(machine.primary_screen->time_until_pos(vpos));
	83	m_interrupt_timer->adjust(machine().primary_screen->time_until_pos(vpos));
86	84	}
87	85
88	86
r20931	r20932
95	93
96	94	MACHINE_START_MEMBER(mw8080bw_state,mw8080bw)
97	95	{
98		mw8080bw_create_interrupt_timer(machine());
	96	mw8080bw_create_interrupt_timer();
99	97
100	98	m_samples = machine().device<samples_device>("samples");
101	99	m_samples1 = machine().device<samples_device>("samples1");
r20931	r20932
115	113
116	114	MACHINE_RESET_MEMBER(mw8080bw_state,mw8080bw)
117	115	{
118		mw8080bw_start_interrupt_timer(machine());
	116	mw8080bw_start_interrupt_timer();
119	117	}

trunk/src/mame/machine/mcr68.c

r20931	r20932
12	12	#define VERBOSE 0
13	13	#define LOG(x) do { if (VERBOSE) logerror x; } while (0)
14	14
15
16	15	/*************************************
17	16	*
18		*  Function prototypes
19		*
20		*************************************/
21
22		static void subtract_from_counter(running_machine &machine, int counter, int count);
23
24		/*************************************
25		*
26	17	*  6821 PIA declarations
27	18	*
28	19	*************************************/
r20931	r20932
131	122	}
132	123
133	124
134		static void mcr68_common_init(running_machine &machine)
	125	void mcr68_state::mcr68_common_init()
135	126	{
136		mcr68_state *state = machine.driver_data<mcr68_state>();
137	127	int i;
138	128
139	129	/* reset the 6840's */
140		state->m_m6840_counter_periods[0] = attotime::from_hz(30);          /* clocked by /VBLANK */
141		state->m_m6840_counter_periods[1] = attotime::never;                    /* grounded */
142		state->m_m6840_counter_periods[2] = attotime::from_hz(512 * 30);    /* clocked by /HSYNC */
	130	m_m6840_counter_periods[0] = attotime::from_hz(30);          /* clocked by /VBLANK */
	131	m_m6840_counter_periods[1] = attotime::never;                    /* grounded */
	132	m_m6840_counter_periods[2] = attotime::from_hz(512 * 30);    /* clocked by /HSYNC */
143	133
144		state->m_m6840_status = 0x00;
145		state->m_m6840_status_read_since_int = 0x00;
146		state->m_m6840_msb_buffer = state->m_m6840_lsb_buffer = 0;
	134	m_m6840_status = 0x00;
	135	m_m6840_status_read_since_int = 0x00;
	136	m_m6840_msb_buffer = m_m6840_lsb_buffer = 0;
147	137	for (i = 0; i < 3; i++)
148	138	{
149		struct counter_state *m6840 = &state->m_m6840_state[i];
	139	struct counter_state *m6840 = &m_m6840_state[i];
150	140
151	141	m6840->control = 0x00;
152	142	m6840->latch = 0xffff;
153	143	m6840->count = 0xffff;
154	144	m6840->timer->enable(false);
155	145	m6840->timer_active = 0;
156		m6840->period = state->m_m6840_counter_periods[i];
	146	m6840->period = m_m6840_counter_periods[i];
157	147	}
158	148
159	149	/* initialize the clock */
160		state->m_m6840_internal_counter_period = attotime::from_hz(machine.device("maincpu")->unscaled_clock() / 10);
	150	m_m6840_internal_counter_period = attotime::from_hz(machine().device("maincpu")->unscaled_clock() / 10);
161	151	}
162	152
163	153
164	154	MACHINE_RESET_MEMBER(mcr68_state,mcr68)
165	155	{
166	156	/* for the most part all MCR/68k games are the same */
167		mcr68_common_init(machine());
	157	mcr68_common_init();
168	158	m_v493_callback = timer_expired_delegate(FUNC(mcr68_state::mcr68_493_callback),this);
169	159
170	160	/* vectors are 1 and 2 */
r20931	r20932
182	172	MACHINE_RESET_MEMBER(mcr68_state,zwackery)
183	173	{
184	174	/* for the most part all MCR/68k games are the same */
185		mcr68_common_init(machine());
	175	mcr68_common_init();
186	176	m_v493_callback = timer_expired_delegate(FUNC(mcr68_state::zwackery_493_callback),this);
187	177
188	178	/* vectors are 5 and 6 */
r20931	r20932
202	192	{
203	193	/* update the 6840 VBLANK clock */
204	194	if (!m_m6840_state[0].timer_active)
205		subtract_from_counter(machine(), 0, 1);
	195	subtract_from_counter(0, 1);
206	196
207	197	logerror("--- VBLANK ---\n");
208	198
r20931	r20932
220	210	*
221	211	*************************************/
222	212
223		static void update_mcr68_interrupts(running_machine &machine)
	213	void mcr68_state::update_mcr68_interrupts()
224	214	{
225		mcr68_state *state = machine.driver_data<mcr68_state>();
226		machine.device("maincpu")->execute().set_input_line(state->m_v493_irq_vector, state->m_v493_irq_state ? ASSERT_LINE : CLEAR_LINE);
227		machine.device("maincpu")->execute().set_input_line(state->m_m6840_irq_vector, state->m_m6840_irq_state ? ASSERT_LINE : CLEAR_LINE);
	215	machine().device("maincpu")->execute().set_input_line(m_v493_irq_vector, m_v493_irq_state ? ASSERT_LINE : CLEAR_LINE);
	216	machine().device("maincpu")->execute().set_input_line(m_m6840_irq_vector, m_m6840_irq_state ? ASSERT_LINE : CLEAR_LINE);
228	217	}
229	218
230	219
231	220	TIMER_CALLBACK_MEMBER(mcr68_state::mcr68_493_off_callback)
232	221	{
233	222	m_v493_irq_state = 0;
234		update_mcr68_interrupts(machine());
	223	update_mcr68_interrupts();
235	224	}
236	225
237	226
238	227	TIMER_CALLBACK_MEMBER(mcr68_state::mcr68_493_callback)
239	228	{
240	229	m_v493_irq_state = 1;
241		update_mcr68_interrupts(machine());
	230	update_mcr68_interrupts();
242	231	machine().scheduler().timer_set(machine().primary_screen->scan_period(), timer_expired_delegate(FUNC(mcr68_state::mcr68_493_off_callback),this));
243	232	logerror("--- (INT1) ---\n");
244	233	}
r20931	r20932
279	268	{
280	269	pia6821_device *pia = machine().device<pia6821_device>("pia0");
281	270	m_v493_irq_state = pia->irq_a_state() | pia->irq_b_state();
282		update_mcr68_interrupts(machine());
	271	update_mcr68_interrupts();
283	272	}
284	273
285	274
r20931	r20932
306	295	*
307	296	*************************************/
308	297
309		INLINE void update_interrupts(running_machine &machine)
	298	inline void mcr68_state::update_interrupts()
310	299	{
311		mcr68_state *state = machine.driver_data<mcr68_state>();
312		state->m_m6840_status &= ~0x80;
	300	m_m6840_status &= ~0x80;
313	301
314		if ((state->m_m6840_status & 0x01) && (state->m_m6840_state[0].control & 0x40)) state->m_m6840_status |= 0x80;
315		if ((state->m_m6840_status & 0x02) && (state->m_m6840_state[1].control & 0x40)) state->m_m6840_status |= 0x80;
316		if ((state->m_m6840_status & 0x04) && (state->m_m6840_state[2].control & 0x40)) state->m_m6840_status |= 0x80;
	302	if ((m_m6840_status & 0x01) && (m_m6840_state[0].control & 0x40)) m_m6840_status |= 0x80;
	303	if ((m_m6840_status & 0x02) && (m_m6840_state[1].control & 0x40)) m_m6840_status |= 0x80;
	304	if ((m_m6840_status & 0x04) && (m_m6840_state[2].control & 0x40)) m_m6840_status |= 0x80;
317	305
318		state->m_m6840_irq_state = state->m_m6840_status >> 7;
319		update_mcr68_interrupts(machine);
	306	m_m6840_irq_state = m_m6840_status >> 7;
	307	update_mcr68_interrupts();
320	308	}
321	309
322	310
323		static void subtract_from_counter(running_machine &machine, int counter, int count)
	311	void mcr68_state::subtract_from_counter(int counter, int count)
324	312	{
325		mcr68_state *state = machine.driver_data<mcr68_state>();
326		struct counter_state *m6840 = &state->m_m6840_state[counter];
	313	struct counter_state *m6840 = &m_m6840_state[counter];
327	314
328	315	/* dual-byte mode */
329	316	if (m6840->control & 0x04)
r20931	r20932
344	331	/* if MSB goes less than zero, we've expired */
345	332	if (msb < 0)
346	333	{
347		state->m_m6840_status |= 1 << counter;
348		state->m_m6840_status_read_since_int &= ~(1 << counter);
349		update_interrupts(machine);
	334	m_m6840_status |= 1 << counter;
	335	m_m6840_status_read_since_int &= ~(1 << counter);
	336	update_interrupts();
350	337	msb = (m6840->latch >> 8) + 1;
351	338	LOG(("** Counter %d fired\n", counter));
352	339	}
r20931	r20932
371	358	word += m6840->latch + 1;
372	359
373	360	/* we've expired */
374		state->m_m6840_status |= 1 << counter;
375		state->m_m6840_status_read_since_int &= ~(1 << counter);
376		update_interrupts(machine);
	361	m_m6840_status |= 1 << counter;
	362	m_m6840_status_read_since_int &= ~(1 << counter);
	363	update_interrupts();
377	364	LOG(("** Counter %d fired\n", counter));
378	365	}
379	366
r20931	r20932
393	380	m6840->timer_active = 0;
394	381
395	382	/* subtract it all from the counter; this will generate an interrupt */
396		subtract_from_counter(machine(), counter, count);
	383	subtract_from_counter(counter, count);
397	384	}
398	385
399	386
r20931	r20932
508	495	}
509	496
510	497	m_m6840_status = 0;
511		update_interrupts(machine());
	498	update_interrupts();
512	499	}
513	500
514	501	/* changing the clock source? (needed for Zwackery) */
r20931	r20932
534	521
535	522	/* clear the interrupt */
536	523	m_m6840_status &= ~(1 << counter);
537		update_interrupts(machine());
	524	update_interrupts();
538	525
539	526	/* reload the count if in an appropriate mode */
540	527	if (!(m6840->control & 0x10))
r20931	r20932
568	555	/* clear the interrupt if the status has been read */
569	556	if (m_m6840_status_read_since_int & (1 << counter))
570	557	m_m6840_status &= ~(1 << counter);
571		update_interrupts(machine());
	558	update_interrupts();
572	559
573	560	m_m6840_lsb_buffer = result & 0xff;
574	561

trunk/src/mame/machine/midxunit.c

r20931	r20932
24	24	*
25	25	*************************************/
26	26
27		static void register_state_saving(running_machine &machine)
	27	void midxunit_state::register_state_saving()
28	28	{
29		midxunit_state *state = machine.driver_data<midxunit_state>();
30		state_save_register_global(machine, state->m_cmos_write_enable);
31		state_save_register_global_array(machine, state->m_iodata);
32		state_save_register_global_array(machine, state->m_ioshuffle);
33		state_save_register_global(machine, state->m_analog_port);
34		state_save_register_global_array(machine, state->m_uart);
35		state_save_register_global(machine, state->m_security_bits);
	29	state_save_register_global(machine(), m_cmos_write_enable);
	30	state_save_register_global_array(machine(), m_iodata);
	31	state_save_register_global_array(machine(), m_ioshuffle);
	32	state_save_register_global(machine(), m_analog_port);
	33	state_save_register_global_array(machine(), m_uart);
	34	state_save_register_global(machine(), m_security_bits);
36	35	}
37	36
38	37
r20931	r20932
292	291	DRIVER_INIT_MEMBER(midxunit_state,revx)
293	292	{
294	293	/* register for state saving */
295		register_state_saving(machine());
	294	register_state_saving();
296	295
297	296	/* init sound */
298	297	dcs_init(machine());

trunk/src/mame/includes/momoko.h

r20931	r20932
46	46	virtual void machine_start();
47	47	virtual void machine_reset();
48	48	UINT32 screen_update_momoko(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	49	void momoko_draw_bg_pri( bitmap_ind16 &bitmap, int chr, int col, int flipx, int flipy, int x, int y, int pri );
49	50	};

trunk/src/mame/includes/midwunit.h

r20931	r20932
41	41	DECLARE_DRIVER_INIT(mk3r20);
42	42	DECLARE_MACHINE_RESET(midwunit);
43	43	DECLARE_VIDEO_START(midwunit);
	44	void register_state_saving();
	45	void init_wunit_generic();
	46	void init_mk3_common();
44	47	};

trunk/src/mame/includes/m107.h

r20931	r20932
53	53	virtual void video_start();
54	54	UINT32 screen_update_m107(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
55	55	TIMER_DEVICE_CALLBACK_MEMBER(m107_scanline_interrupt);
	56	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	57	void m107_update_scroll_positions();
	58	void m107_tilemap_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int laynum, int category,int opaque);
	59	void m107_screenrefresh(bitmap_ind16 &bitmap, const rectangle &cliprect);
56	60	};

trunk/src/mame/includes/m52.h

r20931	r20932
35	35	virtual void video_start();
36	36	virtual void palette_init();
37	37	UINT32 screen_update_m52(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	38	void draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect, int xpos, int ypos, int image);
38	39	};

trunk/src/mame/includes/madalien.h

r20931	r20932
63	63	DECLARE_VIDEO_START(madalien);
64	64	DECLARE_PALETTE_INIT(madalien);
65	65	UINT32 screen_update_madalien(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	66	inline int scan_helper(int col, int row, int section);
	67	void draw_edges(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip, int scroll_mode);
	68	void draw_headlight(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip);
	69	void draw_foreground(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip);
	70	inline UINT8 shift_common(UINT8 hi, UINT8 lo);
66	71	};
67	72	/*----------- defined in video/madalien.c -----------*/
68	73

trunk/src/mame/includes/mermaid.h

r20931	r20932
80	80	UINT32 screen_update_mermaid(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
81	81	void screen_eof_mermaid(screen_device &screen, bool state);
82	82	INTERRUPT_GEN_MEMBER(vblank_irq);
	83	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	84	UINT8 collision_check( rectangle& rect );
83	85	};

trunk/src/mame/includes/metro.h

r20931	r20932
178	178	TIMER_CALLBACK_MEMBER(metro_blit_done);
179	179	void update_irq_state();
180	180	IRQ_CALLBACK_MEMBER(metro_irq_callback);
	181	inline UINT8 get_tile_pix( UINT16 code, UINT8 x, UINT8 y, int big, UINT16 *pix );
	182	inline void metro_vram_w( offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram );
	183	void metro_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	184	void draw_layers( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl );
	185	inline int blt_read( const UINT8 *ROM, const int offs );
	186	void metro_common(  );
	187	void draw_tilemap( bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 flags, UINT32 pcode,
	188	int sx, int sy, int wx, int wy, int big, UINT16 *tilemapram, int layer );
181	189	};
182	190
183	191

trunk/src/mame/includes/mikie.h

r20931	r20932
45	45	virtual void palette_init();
46	46	UINT32 screen_update_mikie(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
47	47	INTERRUPT_GEN_MEMBER(vblank_irq);
	48	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
48	49	};

trunk/src/mame/includes/m62.h

r20931	r20932
106	106	UINT32 screen_update_spelunk2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
107	107	UINT32 screen_update_youjyudn(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
108	108	UINT32 screen_update_horizon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	109	void m62_amplify_contrast(palette_t *palette, UINT32 numcolors);
	110	void register_savestate(  );
	111	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int colormask, int prioritymask, int priority );
	112	void m62_start( tilemap_get_info_delegate tile_get_info, int rows, int cols, int x1, int y1, int x2, int y2 );
	113	void m62_textlayer( tilemap_get_info_delegate tile_get_info, int rows, int cols, int x1, int y1, int x2, int y2 );
109	114	};

trunk/src/mame/includes/mustache.h

r20931	r20932
19	19	virtual void palette_init();
20	20	UINT32 screen_update_mustache(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
21	21	TIMER_DEVICE_CALLBACK_MEMBER(mustache_scanline);
	22	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
22	23	};

trunk/src/mame/includes/mcatadv.h

r20931	r20932
43	43	virtual void video_start();
44	44	UINT32 screen_update_mcatadv(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
45	45	void screen_eof_mcatadv(screen_device &screen, bool state);
	46	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	47	void mcatadv_draw_tilemap_part( UINT16* current_scroll, UINT16* current_videoram1, int i, tilemap_t* current_tilemap, bitmap_ind16 &bitmap, const rectangle &cliprect );
46	48	};

trunk/src/mame/includes/midxunit.h

r20931	r20932
37	37	DECLARE_DRIVER_INIT(revx);
38	38	DECLARE_MACHINE_RESET(midxunit);
39	39	DECLARE_VIDEO_START(midxunit);
	40	void register_state_saving();
40	41	};

trunk/src/mame/includes/munchmo.h

r20931	r20932
49	49	UINT32 screen_update_mnchmobl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50	50	INTERRUPT_GEN_MEMBER(mnchmobl_vblank_irq);
51	51	INTERRUPT_GEN_MEMBER(mnchmobl_sound_irq);
	52	void draw_status( bitmap_ind16 &bitmap, const rectangle &cliprect );
	53	void draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect );
	54	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
52	55	};

trunk/src/mame/includes/mugsmash.h

r20931	r20932
31	31	virtual void machine_start();
32	32	virtual void video_start();
33	33	UINT32 screen_update_mugsmash(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	34	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
34	35	};

trunk/src/mame/includes/macrossp.h

r20931	r20932
73	73	virtual void video_start();
74	74	UINT32 screen_update_macrossp(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
75	75	void screen_eof_macrossp(screen_device &screen, bool state);
	76	void draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect, int priority );
	77	void draw_layer( bitmap_rgb32 &bitmap, const rectangle &cliprect, int layer );
	78	void sortlayers(int *layer,int *pri);
	79	void update_colors(  );
76	80	};

trunk/src/mame/includes/m72.h

r20931	r20932
123	123	TIMER_CALLBACK_MEMBER(m72_scanline_interrupt);
124	124	TIMER_CALLBACK_MEMBER(kengo_scanline_interrupt);
125	125	TIMER_CALLBACK_MEMBER(delayed_ram16_w);
	126	inline void m72_get_tile_info(tile_data &tileinfo,int tile_index,const UINT16 *vram,int gfxnum);
	127	inline void rtype2_get_tile_info(tile_data &tileinfo,int tile_index,const UINT16 *vram,int gfxnum);
	128	void register_savestate();
	129	inline void changecolor(int color,int r,int g,int b);
	130	void m72_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	131	void majtitle_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	132	int find_sample(int num);
	133	void copy_le(UINT16 *dest, const UINT8 *src, UINT8 bytes);
	134	void install_protection_handler(const UINT8 *code,const UINT8 *crc);
126	135	};

trunk/src/mame/includes/megasys1.h

r20931	r20932
116	116	INTERRUPT_GEN_MEMBER(megasys1D_irq);
117	117	TIMER_DEVICE_CALLBACK_MEMBER(megasys1A_scanline);
118	118	TIMER_DEVICE_CALLBACK_MEMBER(megasys1B_scanline);
	119	inline void scrollram_w(offs_t offset, UINT16 data, UINT16 mem_mask, int which);
	120	void create_tilemaps();
	121	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	122	void rodlandj_gfx_unmangle(const char *region);
	123	void jitsupro_gfx_unmangle(const char *region);
	124	void stdragona_gfx_unmangle(const char *region);
119	125	};

trunk/src/mame/includes/m90.h

r20931	r20932
48	48	INTERRUPT_GEN_MEMBER(m90_interrupt);
49	49	INTERRUPT_GEN_MEMBER(dynablsb_interrupt);
50	50	INTERRUPT_GEN_MEMBER(bomblord_interrupt);
	51	inline void get_tile_info(tile_data &tileinfo,int tile_index,int layer,int page_mask);
	52	inline void bomblord_get_tile_info(tile_data &tileinfo,int tile_index,int layer);
	53	inline void dynablsb_get_tile_info(tile_data &tileinfo,int tile_index,int layer);
	54	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	55	void bomblord_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	56	void dynablsb_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	57	void markdirty(tilemap_t *tmap,int page,offs_t offset);
51	58	};

trunk/src/mame/includes/ms32.h

r20931	r20932
92	92	IRQ_CALLBACK_MEMBER(irq_callback);
93	93	void irq_init();
94	94	void irq_raise(int level);
	95	void update_color(int color);
	96	void draw_sprites(bitmap_ind16 &bitmap, bitmap_ind8 &bitmap_pri, const rectangle &cliprect, UINT16 *sprram_top, size_t sprram_size, int gfxnum, int reverseorder);
	97	void draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect,int priority);
	98	void configure_banks();
95	99	};

trunk/src/mame/includes/mcr3.h

r20931	r20932
65	65	DECLARE_PALETTE_INIT(spyhunt);
66	66	UINT32 screen_update_mcr3(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
67	67	UINT32 screen_update_spyhunt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	68	void mcr3_update_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int color_mask, int code_xor, int dx, int dy);
	69	void mcr_common_init();
68	70	};

trunk/src/mame/includes/mitchell.h

r20931	r20932
104	104	DECLARE_VIDEO_START(pang);
105	105	UINT32 screen_update_pang(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
106	106	TIMER_DEVICE_CALLBACK_MEMBER(mitchell_irq);
	107	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	108	void bootleg_decode(  );
	109	void configure_banks(  );
107	110	};

trunk/src/mame/includes/m57.h

r20931	r20932
21	21	virtual void video_start();
22	22	virtual void palette_init();
23	23	UINT32 screen_update_m57(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	24	void draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	25	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
24	26	};

trunk/src/mame/includes/mcr68.h

r20931	r20932
109	109	DECLARE_WRITE8_MEMBER(zwackery_pia1_w);
110	110	DECLARE_WRITE_LINE_MEMBER(zwackery_ca2_w);
111	111	DECLARE_WRITE_LINE_MEMBER(zwackery_pia_irq);
	112	void mcr68_update_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority);
	113	void zwackery_update_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority);
	114	void mcr68_common_init();
	115	void update_mcr68_interrupts();
	116	inline void update_interrupts();
	117	void subtract_from_counter(int counter, int count);
	118	void mcr68_common_init(int clip, int xoffset);
112	119	};
113	120
114	121	/*----------- defined in machine/mcr68.c -----------*/

trunk/src/mame/includes/mystston.h

r20931	r20932
48	48	DECLARE_VIDEO_RESET(mystston);
49	49	UINT32 screen_update_mystston(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50	50	TIMER_CALLBACK_MEMBER(interrupt_callback);
	51	void set_palette();
	52	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int flip);
	53	void mystston_on_scanline_interrupt();
51	54	};
52	55
53		/*----------- defined in drivers/mystston.c -----------*/
54
55		void mystston_on_scanline_interrupt(running_machine &machine);
56
57	56	/*----------- defined in video/mystston.c -----------*/
58	57
59	58	MACHINE_CONFIG_EXTERN( mystston_video );

trunk/src/mame/includes/mario.h

r20931	r20932
90	90	DECLARE_WRITE8_MEMBER(mario_sh_sound_w);
91	91	DECLARE_WRITE8_MEMBER(mario_sh1_w);
92	92	DECLARE_WRITE8_MEMBER(mario_sh2_w);
	93	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
93	94	};
94	95
95	96	/*----------- defined in audio/mario.c -----------*/

trunk/src/mame/includes/maygay1b.h

r20931	r20932
81	81	DECLARE_DRIVER_INIT(m1);
82	82	virtual void machine_start();
83	83	virtual void machine_reset();
	84	void update_outputs(i8279_state *chip, UINT16 which);
	85	void m1_stepper_reset();
84	86	};

trunk/src/mame/includes/m92.h

r20931	r20932
79	79	UINT32 screen_update_ppan(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
80	80	TIMER_CALLBACK_MEMBER(spritebuffer_callback);
81	81	TIMER_DEVICE_CALLBACK_MEMBER(m92_scanline_interrupt);
	82	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	83	void ppan_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	84	void m92_update_scroll_positions();
	85	void m92_draw_tiles(bitmap_ind16 &bitmap,const rectangle &cliprect);
	86	void m92_sprite_interrupt();
82	87	};
83	88
84	89	/*----------- defined in drivers/m92.c -----------*/

trunk/src/mame/includes/m58.h

r20931	r20932
31	31	virtual void video_start();
32	32	virtual void palette_init();
33	33	UINT32 screen_update_yard(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	34	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
	35	void draw_panel( bitmap_ind16 &bitmap, const rectangle &cliprect );
34	36	};

trunk/src/mame/includes/mappy.h

r20931	r20932
62	62	TIMER_CALLBACK_MEMBER(pacnpal_io_run);
63	63	TIMER_CALLBACK_MEMBER(phozon_io_run);
64	64	TIMER_CALLBACK_MEMBER(mappy_io_run);
	65	void mappy_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base);
	66	void phozon_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base);
65	67	};

trunk/src/mame/includes/mcr.h

r20931	r20932
109	109	DECLARE_WRITE16_MEMBER(mcr_ipu_sio_transmit);
110	110	DECLARE_WRITE_LINE_MEMBER(ipu_ctc_interrupt);
111	111	DECLARE_WRITE8_MEMBER(ipu_break_changed);
	112	void mcr_set_color(int index, int data);
	113	void journey_set_color(int index, int data);
	114	void render_sprites_91399(bitmap_ind16 &bitmap, const rectangle &cliprect);
	115	void render_sprites_91464(bitmap_ind16 &bitmap, const rectangle &cliprect, int primask, int sprmask, int colormask);
	116	void mcr_init(int cpuboard, int vidboard, int ssioboard);
112	117	};
113	118
114	119	/*----------- defined in machine/mcr.c -----------*/

trunk/src/mame/includes/meadows.h

r20931	r20932
49	49	INTERRUPT_GEN_MEMBER(meadows_interrupt);
50	50	INTERRUPT_GEN_MEMBER(minferno_interrupt);
51	51	INTERRUPT_GEN_MEMBER(audio_interrupt);
	52	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &clip);
52	53	};
53	54
54	55

trunk/src/mame/includes/mexico86.h

r20931	r20932
57	57	UINT32 screen_update_kikikai(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
58	58	INTERRUPT_GEN_MEMBER(kikikai_interrupt);
59	59	INTERRUPT_GEN_MEMBER(mexico86_m68705_interrupt);
	60	void mcu_simulate(  );
	61	void kiki_clogic(int address, int latch);
60	62	};

trunk/src/mame/includes/m10.h

r20931	r20932
94	94	TIMER_CALLBACK_MEMBER(interrupt_callback);
95	95	DECLARE_WRITE8_MEMBER(ic8j1_output_changed);
96	96	DECLARE_WRITE8_MEMBER(ic8j2_output_changed);
	97	inline void plot_pixel_m10( bitmap_ind16 &bm, int x, int y, int col );
97	98	};

trunk/src/mame/includes/metlclsh.h

r20931	r20932
50	50	virtual void machine_reset();
51	51	virtual void video_start();
52	52	UINT32 screen_update_metlclsh(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	53	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
53	54	};

trunk/src/mame/includes/markham.h

r20931	r20932
27	27	virtual void video_start();
28	28	virtual void palette_init();
29	29	UINT32 screen_update_markham(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	30	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
30	31	};

trunk/src/mame/includes/msisaac.h

r20931	r20932
74	74	DECLARE_MACHINE_RESET(ta7630);
75	75	UINT32 screen_update_msisaac(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
76	76	TIMER_CALLBACK_MEMBER(nmi_callback);
	77	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
77	78	};

trunk/src/mame/includes/mw8080bw.h

r20931	r20932
174	174	DECLARE_WRITE8_MEMBER(invad2ct_audio_3_w);
175	175	DECLARE_WRITE8_MEMBER(invad2ct_audio_4_w);
176	176	void maze_update_discrete();
	177	UINT8 vpos_to_vysnc_chain_counter( int vpos );
	178	int vysnc_chain_counter_to_vpos( UINT8 counter, int vblank );
	179	void mw8080bw_create_interrupt_timer(  );
	180	void mw8080bw_start_interrupt_timer(  );
	181	UINT8 tornbase_get_cabinet_type();
	182	UINT8 spcenctr_get_trench_width();
	183	UINT8 spcenctr_get_trench_center();
	184	UINT8 spcenctr_get_trench_slope(UINT8 addr );
	185	int invaders_is_cabinet_cocktail();
	186	UINT32 invad2ct_coin_input_r(void *param);
177	187	};
178	188
179	189

trunk/src/mame/includes/mrflea.h

r20931	r20932
46	46	virtual void machine_reset();
47	47	UINT32 screen_update_mrflea(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
48	48	TIMER_DEVICE_CALLBACK_MEMBER(mrflea_slave_interrupt);
	49	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	50	void draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect );
49	51	};

trunk/src/mame/includes/marineb.h

r20931	r20932
46	46	UINT32 screen_update_hopprobo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
47	47	INTERRUPT_GEN_MEMBER(marineb_vblank_irq);
48	48	INTERRUPT_GEN_MEMBER(wanted_vblank_irq);
	49	void set_tilemap_scrolly( int cols );
49	50	};

trunk/src/mame/includes/mrdo.h

r20931	r20932
33	33	virtual void video_start();
34	34	virtual void palette_init();
35	35	UINT32 screen_update_mrdo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	36	void draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect );
36	37	};

trunk/src/mame/includes/mjkjidai.h

r20931	r20932
30	30	virtual void video_start();
31	31	UINT32 screen_update_mjkjidai(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
32	32	INTERRUPT_GEN_MEMBER(vblank_irq);
	33	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
33	34	};

trunk/src/mame/includes/mainsnk.h

r20931	r20932
28	28	virtual void video_start();
29	29	virtual void palette_init();
30	30	UINT32 screen_update_mainsnk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	31	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int scrollx, int scrolly );
31	32	};

trunk/src/mame/includes/mrjong.h

r20931	r20932
26	26	virtual void video_start();
27	27	virtual void palette_init();
28	28	UINT32 screen_update_mrjong(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	29	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
29	30	};

trunk/src/mame/video/mrdo.c

r20931	r20932
233	233
234	234	***************************************************************************/
235	235
236		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect )
	236	void mrdo_state::draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect )
237	237	{
238		mrdo_state *state = machine.driver_data<mrdo_state>();
239		UINT8 *spriteram = state->m_spriteram;
	238	UINT8 *spriteram = m_spriteram;
240	239	int offs;
241	240
242		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	241	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
243	242	{
244	243	if (spriteram[offs + 1] != 0)
245	244	{
246		drawgfx_transpen(bitmap, cliprect, machine.gfx[2],
	245	drawgfx_transpen(bitmap, cliprect, machine().gfx[2],
247	246	spriteram[offs], spriteram[offs + 2] & 0x0f,
248	247	spriteram[offs + 2] & 0x10, spriteram[offs + 2] & 0x20,
249	248	spriteram[offs + 3], 256 - spriteram[offs + 1], 0);
r20931	r20932
256	255	bitmap.fill(0, cliprect);
257	256	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
258	257	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
259		draw_sprites(machine(), bitmap, cliprect);
	258	draw_sprites(bitmap, cliprect);
260	259	return 0;
261	260	}

trunk/src/mame/video/mugsmash.c

r20931	r20932
3	3	#include "emu.h"
4	4	#include "includes/mugsmash.h"
5	5
6		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	6	void mugsmash_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
7	7	{
8	8	/* Each Sprite takes 16 bytes, 5 used? */
9	9
r20931	r20932
24	24
25	25	*/
26	26
27		mugsmash_state *state = machine.driver_data<mugsmash_state>();
28		const UINT16 *source = state->m_spriteram;
	27	const UINT16 *source = m_spriteram;
29	28	const UINT16 *finish = source + 0x2000;
30		gfx_element *gfx = machine.gfx[0];
	29	gfx_element *gfx = machine().gfx[0];
31	30
32	31	while (source < finish)
33	32	{
r20931	r20932
142	141	{
143	142	m_tilemap2->draw(bitmap, cliprect, 0, 0);
144	143	m_tilemap1->draw(bitmap, cliprect, 0, 0);
145		draw_sprites(machine(), bitmap, cliprect);
	144	draw_sprites(bitmap, cliprect);
146	145	return 0;
147	146	}

trunk/src/mame/video/macrossp.c

r20931	r20932
159	159
160	160
161	161
162		static void draw_sprites(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int priority )
	162	void macrossp_state::draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect, int priority )
163	163	{
164		macrossp_state *state = machine.driver_data<macrossp_state>();
165		gfx_element *gfx = machine.gfx[0];
166		//  UINT32 *source = state->m_spriteram;
167		UINT32 *source = state->m_spriteram_old2; /* buffers by two frames */
168		UINT32 *finish = source + state->m_spriteram.bytes() / 4;
	164	gfx_element *gfx = machine().gfx[0];
	165	//  UINT32 *source = m_spriteram;
	166	UINT32 *source = m_spriteram_old2; /* buffers by two frames */
	167	UINT32 *finish = source + m_spriteram.bytes() / 4;
169	168
170	169	while (source < finish)
171	170	{
r20931	r20932
217	216	break;
218	217
219	218	default:
220		col = machine.rand();
	219	col = machine().rand();
221	220	break;
222	221	}
223	222
r20931	r20932
305	304	}
306	305
307	306
308		static void draw_layer( running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int layer )
	307	void macrossp_state::draw_layer( bitmap_rgb32 &bitmap, const rectangle &cliprect, int layer )
309	308	{
310		macrossp_state *state = machine.driver_data<macrossp_state>();
311	309	tilemap_t *tm;
312	310	UINT32 *vr;
313	311
r20931	r20932
315	313	{
316	314	case 0:
317	315	default:
318		tm = state->m_scra_tilemap;
319		vr = state->m_scra_videoregs;
	316	tm = m_scra_tilemap;
	317	vr = m_scra_videoregs;
320	318	break;
321	319
322	320	case 1:
323		tm = state->m_scrb_tilemap;
324		vr = state->m_scrb_videoregs;
	321	tm = m_scrb_tilemap;
	322	vr = m_scrb_videoregs;
325	323	break;
326	324
327	325	case 2:
328		tm = state->m_scrc_tilemap;
329		vr = state->m_scrc_videoregs;
	326	tm = m_scrc_tilemap;
	327	vr = m_scrc_videoregs;
330	328	break;
331	329	}
332	330
r20931	r20932
357	355	}
358	356
359	357	/* useful function to sort the three tile layers by priority order */
360		static void sortlayers(int *layer,int *pri)
	358	void macrossp_state::sortlayers(int *layer,int *pri)
361	359	{
362	360	#define SWAP(a,b) \
363	361	if (pri[a] >= pri[b]) \
r20931	r20932
387	385
388	386	sortlayers(layers, layerpri);
389	387
390		draw_layer(machine(), bitmap, cliprect, layers[0]);
391		draw_sprites(machine(), bitmap, cliprect, 0);
392		draw_layer(machine(), bitmap, cliprect, layers[1]);
393		draw_sprites(machine(), bitmap, cliprect, 1);
394		draw_layer(machine(), bitmap, cliprect, layers[2]);
395		draw_sprites(machine(), bitmap, cliprect, 2);
396		draw_sprites(machine(), bitmap, cliprect, 3);
	388	draw_layer(bitmap, cliprect, layers[0]);
	389	draw_sprites(bitmap, cliprect, 0);
	390	draw_layer(bitmap, cliprect, layers[1]);
	391	draw_sprites(bitmap, cliprect, 1);
	392	draw_layer(bitmap, cliprect, layers[2]);
	393	draw_sprites(bitmap, cliprect, 2);
	394	draw_sprites(bitmap, cliprect, 3);
397	395	m_text_tilemap->draw(bitmap, cliprect, 0, 0);
398	396
399	397	#if 0

trunk/src/mame/video/momoko.c

r20931	r20932
66	66
67	67	/****************************************************************************/
68	68
69		static void momoko_draw_bg_pri( running_machine &machine, bitmap_ind16 &bitmap, int chr, int col, int flipx, int flipy, int x, int y, int pri )
	69	void momoko_state::momoko_draw_bg_pri( bitmap_ind16 &bitmap, int chr, int col, int flipx, int flipy, int x, int y, int pri )
70	70	{
71	71	int xx, sx, sy, px, py, dot;
72	72	UINT32 gfxadr;
73	73	UINT8 d0, d1;
74		UINT8 *BG_GFX = machine.root_device().memregion("gfx2")->base();
	74	UINT8 *BG_GFX = machine().root_device().memregion("gfx2")->base();
75	75
76	76	for (sy = 0; sy < 8; sy++)
77	77	{
r20931	r20932
210	210	{
211	211	col = col & 0x0f;
212	212	chr = chr + m_bg_select * 512;
213		momoko_draw_bg_pri(machine(), bitmap, chr, col, flip, flip, px, py, pri);
	213	momoko_draw_bg_pri(bitmap, chr, col, flip, flip, px, py, pri);
214	214	}
215	215	}
216	216	}

trunk/src/mame/video/mcr68.c

r20931	r20932
195	195	*
196	196	*************************************/
197	197
198		static void mcr68_update_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
	198	void mcr68_state::mcr68_update_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
199	199	{
200		mcr68_state *state = machine.driver_data<mcr68_state>();
201		rectangle sprite_clip = machine.primary_screen->visible_area();
202		UINT16 *spriteram = state->m_spriteram;
	200	rectangle sprite_clip = machine().primary_screen->visible_area();
	201	UINT16 *spriteram = m_spriteram;
203	202	int offs;
204	203
205	204	/* adjust for clipping */
206		sprite_clip.min_x += state->m_sprite_clip;
207		sprite_clip.max_x -= state->m_sprite_clip;
	205	sprite_clip.min_x += m_sprite_clip;
	206	sprite_clip.max_x -= m_sprite_clip;
208	207	sprite_clip &= cliprect;
209	208
210		machine.priority_bitmap.fill(1, sprite_clip);
	209	machine().priority_bitmap.fill(1, sprite_clip);
211	210
212	211	/* loop over sprite RAM */
213		for (offs = state->m_spriteram.bytes() / 2 - 4;offs >= 0;offs -= 4)
	212	for (offs = m_spriteram.bytes() / 2 - 4;offs >= 0;offs -= 4)
214	213	{
215	214	int code, color, flipx, flipy, x, y, flags;
216	215
r20931	r20932
229	228	color = ~flags & 0x03;
230	229	flipx = flags & 0x10;
231	230	flipy = flags & 0x20;
232		x = LOW_BYTE(spriteram[offs + 3]) * 2 + state->m_sprite_xoffset;
	231	x = LOW_BYTE(spriteram[offs + 3]) * 2 + m_sprite_xoffset;
233	232	y = (241 - LOW_BYTE(spriteram[offs])) * 2;
234	233
235	234	/* allow sprites to clip off the left side */
r20931	r20932
239	238	The color 8 is used to cover over other sprites. */
240	239
241	240	/* first draw the sprite, visible */
242		pdrawgfx_transmask(bitmap, sprite_clip, machine.gfx[1], code, color, flipx, flipy, x, y,
243		machine.priority_bitmap, 0x00, 0x0101);
	241	pdrawgfx_transmask(bitmap, sprite_clip, machine().gfx[1], code, color, flipx, flipy, x, y,
	242	machine().priority_bitmap, 0x00, 0x0101);
244	243
245	244	/* then draw the mask, behind the background but obscuring following sprites */
246		pdrawgfx_transmask(bitmap, sprite_clip, machine.gfx[1], code, color, flipx, flipy, x, y,
247		machine.priority_bitmap, 0x02, 0xfeff);
	245	pdrawgfx_transmask(bitmap, sprite_clip, machine().gfx[1], code, color, flipx, flipy, x, y,
	246	machine().priority_bitmap, 0x02, 0xfeff);
248	247	}
249	248	}
250	249
251	250
252		static void zwackery_update_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
	251	void mcr68_state::zwackery_update_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
253	252	{
254		mcr68_state *state = machine.driver_data<mcr68_state>();
255		UINT16 *spriteram = state->m_spriteram;
	253	UINT16 *spriteram = m_spriteram;
256	254	int offs;
257	255
258		machine.priority_bitmap.fill(1, cliprect);
	256	machine().priority_bitmap.fill(1, cliprect);
259	257
260	258	/* loop over sprite RAM */
261		for (offs = state->m_spriteram.bytes() / 2 - 4;offs >= 0;offs -= 4)
	259	for (offs = m_spriteram.bytes() / 2 - 4;offs >= 0;offs -= 4)
262	260	{
263	261	int code, color, flipx, flipy, x, y, flags;
264	262
r20931	r20932
297	295	The color 8 is used to cover over other sprites. */
298	296
299	297	/* first draw the sprite, visible */
300		pdrawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, x, y,
301		machine.priority_bitmap, 0x00, 0x0101);
	298	pdrawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, x, y,
	299	machine().priority_bitmap, 0x00, 0x0101);
302	300
303	301	/* then draw the mask, behind the background but obscuring following sprites */
304		pdrawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, x, y,
305		machine.priority_bitmap, 0x02, 0xfeff);
	302	pdrawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, x, y,
	303	machine().priority_bitmap, 0x02, 0xfeff);
306	304	}
307	305	}
308	306
r20931	r20932
320	318	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES, 0);
321	319
322	320	/* draw the low-priority sprites */
323		mcr68_update_sprites(machine(), bitmap, cliprect, 0);
	321	mcr68_update_sprites(bitmap, cliprect, 0);
324	322
325	323	/* redraw tiles with priority over sprites */
326	324	m_bg_tilemap->draw(bitmap, cliprect, 1, 0);
327	325
328	326	/* draw the high-priority sprites */
329		mcr68_update_sprites(machine(), bitmap, cliprect, 1);
	327	mcr68_update_sprites(bitmap, cliprect, 1);
330	328	return 0;
331	329	}
332	330
r20931	r20932
337	335	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
338	336
339	337	/* draw the low-priority sprites */
340		zwackery_update_sprites(machine(), bitmap, cliprect, 0);
	338	zwackery_update_sprites(bitmap, cliprect, 0);
341	339
342	340	/* redraw tiles with priority over sprites */
343	341	m_fg_tilemap->draw(bitmap, cliprect, 1, 0);
344	342
345	343	/* draw the high-priority sprites */
346		zwackery_update_sprites(machine(), bitmap, cliprect, 1);
	344	zwackery_update_sprites(bitmap, cliprect, 1);
347	345	return 0;
348	346	}

trunk/src/mame/video/m62.c

r20931	r20932
180	180	};
181	181
182	182
183		static void m62_amplify_contrast(palette_t *palette, UINT32 numcolors)
	183	void m62_state::m62_amplify_contrast(palette_t *palette, UINT32 numcolors)
184	184	{
185	185	// m62 palette is very dark, so amplify default contrast
186	186	UINT32 i, ymax=1;
r20931	r20932
283	283	}
284	284
285	285
286		static void register_savestate( running_machine &machine )
	286	void m62_state::register_savestate(  )
287	287	{
288		m62_state *state = machine.driver_data<m62_state>();
289	288
290		state->save_item(NAME(state->m_flipscreen));
291		state->save_item(NAME(state->m_m62_background_hscroll));
292		state->save_item(NAME(state->m_m62_background_vscroll));
	289	save_item(NAME(m_flipscreen));
	290	save_item(NAME(m_m62_background_hscroll));
	291	save_item(NAME(m_m62_background_vscroll));
293	292
294		state->save_item(NAME(state->m_kidniki_background_bank));
295		state->save_item(NAME(state->m_kidniki_text_vscroll));
296		state->save_item(NAME(state->m_ldrun3_topbottom_mask));
297		state->save_item(NAME(state->m_spelunkr_palbank));
	293	save_item(NAME(m_kidniki_background_bank));
	294	save_item(NAME(m_kidniki_text_vscroll));
	295	save_item(NAME(m_ldrun3_topbottom_mask));
	296	save_item(NAME(m_spelunkr_palbank));
298	297	}
299	298
300	299
r20931	r20932
346	345	}
347	346
348	347
349		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int colormask, int prioritymask, int priority )
	348	void m62_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int colormask, int prioritymask, int priority )
350	349	{
351		m62_state *state = machine.driver_data<m62_state>();
352	350	int offs;
353	351
354		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 8)
	352	for (offs = 0; offs < m_spriteram.bytes(); offs += 8)
355	353	{
356	354	int i, incr, code, col, flipx, flipy, sx, sy;
357	355
358		if ((state->m_spriteram[offs] & prioritymask) == priority)
	356	if ((m_spriteram[offs] & prioritymask) == priority)
359	357	{
360		code = state->m_spriteram[offs + 4] + ((state->m_spriteram[offs + 5] & 0x07) << 8);
361		col = state->m_spriteram[offs + 0] & colormask;
362		sx = 256 * (state->m_spriteram[offs + 7] & 1) + state->m_spriteram[offs + 6],
363		sy = 256 + 128 - 15 - (256 * (state->m_spriteram[offs + 3] & 1) + state->m_spriteram[offs + 2]),
364		flipx = state->m_spriteram[offs + 5] & 0x40;
365		flipy = state->m_spriteram[offs + 5] & 0x80;
	358	code = m_spriteram[offs + 4] + ((m_spriteram[offs + 5] & 0x07) << 8);
	359	col = m_spriteram[offs + 0] & colormask;
	360	sx = 256 * (m_spriteram[offs + 7] & 1) + m_spriteram[offs + 6],
	361	sy = 256 + 128 - 15 - (256 * (m_spriteram[offs + 3] & 1) + m_spriteram[offs + 2]),
	362	flipx = m_spriteram[offs + 5] & 0x40;
	363	flipy = m_spriteram[offs + 5] & 0x80;
366	364
367		i = state->m_sprite_height_prom[(code >> 5) & 0x1f];
	365	i = m_sprite_height_prom[(code >> 5) & 0x1f];
368	366	if (i == 1) /* double height */
369	367	{
370	368	code &= ~1;
r20931	r20932
377	375	sy -= 3*16;
378	376	}
379	377
380		if (state->m_flipscreen)
	378	if (m_flipscreen)
381	379	{
382	380	sx = 496 - sx;
383	381	sy = 242 - i*16 - sy;   /* sprites are slightly misplaced by the hardware */
r20931	r20932
394	392
395	393	do
396	394	{
397		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	395	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
398	396	code + i * incr,col,
399	397	flipx,flipy,
400	398	sx,sy + 16 * i,0);
r20931	r20932
405	403	}
406	404	}
407	405
408		static void m62_start( running_machine &machine, tilemap_get_info_delegate tile_get_info, int rows, int cols, int x1, int y1, int x2, int y2 )
	406	void m62_state::m62_start( tilemap_get_info_delegate tile_get_info, int rows, int cols, int x1, int y1, int x2, int y2 )
409	407	{
410		m62_state *state = machine.driver_data<m62_state>();
411		state->m_bg_tilemap = &machine.tilemap().create(tile_get_info, TILEMAP_SCAN_ROWS,  x1, y1, x2, y2);
	408	m_bg_tilemap = &machine().tilemap().create(tile_get_info, TILEMAP_SCAN_ROWS,  x1, y1, x2, y2);
412	409
413		register_savestate(machine);
	410	register_savestate();
414	411
415	412	if (rows != 0)
416		state->m_bg_tilemap->set_scroll_rows(rows);
	413	m_bg_tilemap->set_scroll_rows(rows);
417	414
418	415	if (cols != 0)
419		state->m_bg_tilemap->set_scroll_cols(cols);
	416	m_bg_tilemap->set_scroll_cols(cols);
420	417	}
421	418
422		static void m62_textlayer( running_machine &machine, tilemap_get_info_delegate tile_get_info, int rows, int cols, int x1, int y1, int x2, int y2 )
	419	void m62_state::m62_textlayer( tilemap_get_info_delegate tile_get_info, int rows, int cols, int x1, int y1, int x2, int y2 )
423	420	{
424		m62_state *state = machine.driver_data<m62_state>();
425		state->m_fg_tilemap = &machine.tilemap().create(tile_get_info, TILEMAP_SCAN_ROWS,  x1, y1, x2, y2);
	421	m_fg_tilemap = &machine().tilemap().create(tile_get_info, TILEMAP_SCAN_ROWS,  x1, y1, x2, y2);
426	422
427	423	if (rows != 0)
428		state->m_fg_tilemap->set_scroll_rows(rows);
	424	m_fg_tilemap->set_scroll_rows(rows);
429	425
430	426	if (cols != 0)
431		state->m_fg_tilemap->set_scroll_cols(cols);
	427	m_fg_tilemap->set_scroll_cols(cols);
432	428	}
433	429
434	430	WRITE8_MEMBER(m62_state::kungfum_tileram_w)
r20931	r20932
460	456
461	457	VIDEO_START_MEMBER(m62_state,kungfum)
462	458	{
463		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_kungfum_bg_tile_info),this), 32, 0, 8, 8, 64, 32);
	459	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_kungfum_bg_tile_info),this), 32, 0, 8, 8, 64, 32);
464	460	}
465	461
466	462	UINT32 m62_state::screen_update_kungfum(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20931	r20932
475	471	m_bg_tilemap->set_scrollx(i, m_m62_background_hscroll);
476	472	}
477	473	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
478		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	474	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
479	475	m_bg_tilemap->draw(bitmap, cliprect, 1, 0);
480	476	return 0;
481	477	}
r20931	r20932
502	498
503	499	void m62_state::video_start()
504	500	{
505		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_ldrun_bg_tile_info),this), 1, 1, 8, 8, 64, 32);
	501	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_ldrun_bg_tile_info),this), 1, 1, 8, 8, 64, 32);
506	502	m_bg_tilemap->set_transmask(0, 0xffff, 0x0000); /* split type 0 is totally transparent in front half */
507	503	m_bg_tilemap->set_transmask(1, 0x0001, 0xfffe); /* split type 1 has pen 0 transparent in front half */
508	504	}
r20931	r20932
513	509	m_bg_tilemap->set_scrolly(0, m_m62_background_vscroll);
514	510
515	511	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
516		draw_sprites(machine(), bitmap, cliprect, 0x0f, 0x10, 0x00);
	512	draw_sprites(bitmap, cliprect, 0x0f, 0x10, 0x00);
517	513	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
518		draw_sprites(machine(), bitmap, cliprect, 0x0f, 0x10, 0x10);
	514	draw_sprites(bitmap, cliprect, 0x0f, 0x10, 0x10);
519	515	return 0;
520	516	}
521	517
r20931	r20932
540	536
541	537	VIDEO_START_MEMBER(m62_state,ldrun2)
542	538	{
543		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_ldrun2_bg_tile_info),this), 1, 1, 8, 8, 64, 32);
	539	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_ldrun2_bg_tile_info),this), 1, 1, 8, 8, 64, 32);
544	540	m_bg_tilemap->set_transmask(0, 0xffff, 0x0000); /* split type 0 is totally transparent in front half */
545	541	m_bg_tilemap->set_transmask(1, 0x0001, 0xfffe); /* split type 1 has pen 0 transparent in front half */
546	542	}
r20931	r20932
602	598
603	599	VIDEO_START_MEMBER(m62_state,battroad)
604	600	{
605		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_battroad_bg_tile_info),this), 1, 1, 8, 8, 64, 32);
606		m62_textlayer(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_battroad_fg_tile_info),this), 1, 1, 8, 8, 32, 32);
	601	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_battroad_bg_tile_info),this), 1, 1, 8, 8, 64, 32);
	602	m62_textlayer(tilemap_get_info_delegate(FUNC(m62_state::get_battroad_fg_tile_info),this), 1, 1, 8, 8, 32, 32);
607	603	m_bg_tilemap->set_transmask(0, 0xffff, 0x0000); /* split type 0 is totally transparent in front half */
608	604	m_bg_tilemap->set_transmask(1, 0x0001, 0xfffe); /* split type 1 has pen 0 transparent in front half */
609	605	}
r20931	r20932
617	613	m_fg_tilemap->set_transparent_pen(0);
618	614
619	615	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
620		draw_sprites(machine(), bitmap, cliprect, 0x0f, 0x10, 0x00);
	616	draw_sprites(bitmap, cliprect, 0x0f, 0x10, 0x00);
621	617	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
622		draw_sprites(machine(), bitmap, cliprect, 0x0f, 0x10, 0x10);
	618	draw_sprites(bitmap, cliprect, 0x0f, 0x10, 0x10);
623	619	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
624	620	return 0;
625	621	}
r20931	r20932
638	634
639	635	VIDEO_START_MEMBER(m62_state,ldrun4)
640	636	{
641		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_ldrun4_bg_tile_info),this), 1, 0, 8, 8, 64, 32);
	637	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_ldrun4_bg_tile_info),this), 1, 0, 8, 8, 64, 32);
642	638	}
643	639
644	640	UINT32 m62_state::screen_update_ldrun4(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20931	r20932
646	642	m_bg_tilemap->set_scrollx(0, m_m62_background_hscroll - 2);
647	643
648	644	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
649		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	645	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
650	646	return 0;
651	647	}
652	648
r20931	r20932
677	673
678	674	VIDEO_START_MEMBER(m62_state,lotlot)
679	675	{
680		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_lotlot_bg_tile_info),this), 1, 1, 12, 10, 32, 64);
681		m62_textlayer(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_lotlot_fg_tile_info),this), 1, 1, 12, 10, 32, 64);
	676	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_lotlot_bg_tile_info),this), 1, 1, 12, 10, 32, 64);
	677	m62_textlayer(tilemap_get_info_delegate(FUNC(m62_state::get_lotlot_fg_tile_info),this), 1, 1, 12, 10, 32, 64);
682	678	}
683	679
684	680	UINT32 m62_state::screen_update_lotlot(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20931	r20932
691	687
692	688	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
693	689	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
694		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	690	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
695	691	return 0;
696	692	}
697	693
r20931	r20932
740	736	m_bg_tilemap->set_transmask(0, 0xffff, 0x0000); /* split type 0 is totally transparent in front half */
741	737	m_bg_tilemap->set_transmask(1, 0x0001, 0xfffe); /* split type 1 has pen 0 transparent in front half */
742	738
743		register_savestate(machine());
	739	register_savestate();
744	740
745		m62_textlayer(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_kidniki_fg_tile_info),this), 1, 1, 12, 8, 32, 64);
	741	m62_textlayer(tilemap_get_info_delegate(FUNC(m62_state::get_kidniki_fg_tile_info),this), 1, 1, 12, 8, 32, 64);
746	742	}
747	743
748	744	UINT32 m62_state::screen_update_kidniki(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20931	r20932
753	749	m_fg_tilemap->set_transparent_pen(0);
754	750
755	751	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
756		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	752	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
757	753	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
758	754	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
759	755	return 0;
r20931	r20932
791	787
792	788	VIDEO_START_MEMBER(m62_state,spelunkr)
793	789	{
794		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_spelunkr_bg_tile_info),this), 1, 1, 8, 8, 64, 64);
795		m62_textlayer(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_spelunkr_fg_tile_info),this), 1, 1, 12, 8, 32, 32);
	790	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_spelunkr_bg_tile_info),this), 1, 1, 8, 8, 64, 64);
	791	m62_textlayer(tilemap_get_info_delegate(FUNC(m62_state::get_spelunkr_fg_tile_info),this), 1, 1, 12, 8, 32, 32);
796	792	}
797	793
798	794	UINT32 m62_state::screen_update_spelunkr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20931	r20932
804	800	m_fg_tilemap->set_transparent_pen(0);
805	801
806	802	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
807		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	803	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
808	804	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
809	805	return 0;
810	806	}
r20931	r20932
833	829
834	830	VIDEO_START_MEMBER(m62_state,spelunk2)
835	831	{
836		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_spelunk2_bg_tile_info),this), 1, 1, 8, 8, 64, 64);
837		m62_textlayer(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_spelunkr_fg_tile_info),this), 1, 1, 12, 8, 32, 32);
	832	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_spelunk2_bg_tile_info),this), 1, 1, 8, 8, 64, 64);
	833	m62_textlayer(tilemap_get_info_delegate(FUNC(m62_state::get_spelunkr_fg_tile_info),this), 1, 1, 12, 8, 32, 32);
838	834	}
839	835
840	836	UINT32 m62_state::screen_update_spelunk2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r20931	r20932
846	842	m_fg_tilemap->set_transparent_pen(0);
847	843
848	844	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
849		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	845	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
850	846	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
851	847	return 0;
852	848	}
r20931	r20932
876	872
877	873	VIDEO_START_MEMBER(m62_state,youjyudn)
878	874	{
879		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_youjyudn_bg_tile_info),this), 1, 0, 8, 16, 64, 16);
880		m62_textlayer(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_youjyudn_fg_tile_info),this), 1, 1, 12, 8, 32, 32);
	875	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_youjyudn_bg_tile_info),this), 1, 0, 8, 16, 64, 16);
	876	m62_textlayer(tilemap_get_info_delegate(FUNC(m62_state::get_youjyudn_fg_tile_info),this), 1, 1, 12, 8, 32, 32);
881	877	m_bg_tilemap->set_transmask(0, 0xffff, 0x0000); /* split type 0 is totally transparent in front half */
882	878	m_bg_tilemap->set_transmask(1, 0x0001, 0xfffe); /* split type 1 has pen 0 transparent in front half */
883	879	}
r20931	r20932
890	886	m_fg_tilemap->set_transparent_pen(0);
891	887
892	888	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
893		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	889	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
894	890	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
895	891	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
896	892	return 0;
r20931	r20932
918	914
919	915	VIDEO_START_MEMBER(m62_state,horizon)
920	916	{
921		m62_start(machine(), tilemap_get_info_delegate(FUNC(m62_state::get_horizon_bg_tile_info),this), 32, 0, 8, 8, 64, 32);
	917	m62_start(tilemap_get_info_delegate(FUNC(m62_state::get_horizon_bg_tile_info),this), 32, 0, 8, 8, 64, 32);
922	918	m_bg_tilemap->set_transmask(0, 0xffff, 0x0000); /* split type 0 is totally transparent in front half */
923	919	m_bg_tilemap->set_transmask(1, 0x0001, 0xfffe); /* split type 1 has pen 0 transparent in front half */
924	920	}
r20931	r20932
931	927	m_bg_tilemap->set_scrollx(i, m_scrollram[i << 1] | (m_scrollram[(i << 1) | 1] << 8));
932	928	}
933	929	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
934		draw_sprites(machine(), bitmap, cliprect, 0x1f, 0x00, 0x00);
	930	draw_sprites(bitmap, cliprect, 0x1f, 0x00, 0x00);
935	931	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
936	932	return 0;
937	933	}

trunk/src/mame/video/mario.c

r20931	r20932
149	149	* confirmed on mametests.org as being present on real PCB as well.
150	150	*/
151	151
152		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	152	void mario_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
153	153	{
154	154	/* TODO: draw_sprites should adopt the scanline logic from dkong.c
155	155	* The schematics have the same logic for sprite buffering.
156	156	*/
157		mario_state *state = machine.driver_data<mario_state>();
158	157	int offs;
159	158
160		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	159	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
161	160	{
162		if (state->m_spriteram[offs])
	161	if (m_spriteram[offs])
163	162	{
164	163	int x, y;
165	164
166	165	// from schematics ....
167		y = (state->m_spriteram[offs] + (state->m_flip ? 0xF7 : 0xF9) + 1) & 0xFF;
168		x = state->m_spriteram[offs+3];
	166	y = (m_spriteram[offs] + (m_flip ? 0xF7 : 0xF9) + 1) & 0xFF;
	167	x = m_spriteram[offs+3];
169	168	// sprite will be drawn if (y + scanline) & 0xF0 = 0xF0
170	169	y = 240 - y; /* logical screen position */
171	170
172		y = y ^ (state->m_flip ? 0xFF : 0x00); /* physical screen location */
173		x = x ^ (state->m_flip ? 0xFF : 0x00); /* physical screen location */
	171	y = y ^ (m_flip ? 0xFF : 0x00); /* physical screen location */
	172	x = x ^ (m_flip ? 0xFF : 0x00); /* physical screen location */
174	173
175		if (state->m_flip)
	174	if (m_flip)
176	175	{
177	176	y -= 14;
178	177	x -= 7;
179		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
180		state->m_spriteram[offs + 2],
181		(state->m_spriteram[offs + 1] & 0x0f) + 16 * state->m_palette_bank + 32 * state->m_monitor,
182		!(state->m_spriteram[offs + 1] & 0x80),!(state->m_spriteram[offs + 1] & 0x40),
	178	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
	179	m_spriteram[offs + 2],
	180	(m_spriteram[offs + 1] & 0x0f) + 16 * m_palette_bank + 32 * m_monitor,
	181	!(m_spriteram[offs + 1] & 0x80),!(m_spriteram[offs + 1] & 0x40),
183	182	x, y,0);
184	183	}
185	184	else
186	185	{
187	186	y += 1;
188	187	x -= 8;
189		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
190		state->m_spriteram[offs + 2],
191		(state->m_spriteram[offs + 1] & 0x0f) + 16 * state->m_palette_bank + 32 * state->m_monitor,
192		(state->m_spriteram[offs + 1] & 0x80),(state->m_spriteram[offs + 1] & 0x40),
	188	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
	189	m_spriteram[offs + 2],
	190	(m_spriteram[offs + 1] & 0x0f) + 16 * m_palette_bank + 32 * m_monitor,
	191	(m_spriteram[offs + 1] & 0x80),(m_spriteram[offs + 1] & 0x40),
193	192	x, y,0);
194	193	}
195	194	}
r20931	r20932
211	210	m_bg_tilemap->set_scrolly(0, m_gfx_scroll - (m_flip ? 8 : 0));
212	211
213	212	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
214		draw_sprites(machine(), bitmap, cliprect);
	213	draw_sprites(bitmap, cliprect);
215	214
216	215	return 0;
217	216	}

trunk/src/mame/video/megasys1.c

r20931	r20932
194	194	#include "emu.h"
195	195	#include "includes/megasys1.h"
196	196
197		static void create_tilemaps(running_machine &machine);
198
199
200	197	#ifdef MAME_DEBUG
201	198
202	199	#define SHOW_WRITE_ERROR(_format_,_offset_,_data_)\
r20931	r20932
231	228	m_buffer2_objectram = auto_alloc_array(machine(), UINT16, 0x2000);
232	229	m_buffer2_spriteram16 = auto_alloc_array(machine(), UINT16, 0x2000);
233	230
234		create_tilemaps(machine());
	231	create_tilemaps();
235	232	m_tmap[0] = m_tilemap[0][0][0];
236	233	m_tmap[1] = m_tilemap[1][0][0];
237	234	m_tmap[2] = m_tilemap[2][0][0];
r20931	r20932
290	287	#define TILES_PER_PAGE_Y (0x20)
291	288	#define TILES_PER_PAGE (TILES_PER_PAGE_X * TILES_PER_PAGE_Y)
292	289
293		INLINE void scrollram_w(address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask, int which)
	290	inline void megasys1_state::scrollram_w(offs_t offset, UINT16 data, UINT16 mem_mask, int which)
294	291	{
295		megasys1_state *state = space.machine().driver_data<megasys1_state>();
296		COMBINE_DATA(&state->m_scrollram[which][offset]);
297		if (offset < 0x40000/2 && state->m_tmap[which])
	292	COMBINE_DATA(&m_scrollram[which][offset]);
	293	if (offset < 0x40000/2 && m_tmap[which])
298	294	{
299		if (state->m_scroll_flag[which] & 0x10) /* tiles are 8x8 */
	295	if (m_scroll_flag[which] & 0x10) /* tiles are 8x8 */
300	296	{
301		state->m_tmap[which]->mark_tile_dirty(offset );
	297	m_tmap[which]->mark_tile_dirty(offset );
302	298	}
303	299	else
304	300	{
305		state->m_tmap[which]->mark_tile_dirty(offset*4 + 0);
306		state->m_tmap[which]->mark_tile_dirty(offset*4 + 1);
307		state->m_tmap[which]->mark_tile_dirty(offset*4 + 2);
308		state->m_tmap[which]->mark_tile_dirty(offset*4 + 3);
	301	m_tmap[which]->mark_tile_dirty(offset*4 + 0);
	302	m_tmap[which]->mark_tile_dirty(offset*4 + 1);
	303	m_tmap[which]->mark_tile_dirty(offset*4 + 2);
	304	m_tmap[which]->mark_tile_dirty(offset*4 + 3);
309	305	}
310	306	}
311	307	}
312	308
313		WRITE16_MEMBER(megasys1_state::megasys1_scrollram_0_w){ scrollram_w(space, offset, data, mem_mask, 0); }
314		WRITE16_MEMBER(megasys1_state::megasys1_scrollram_1_w){ scrollram_w(space, offset, data, mem_mask, 1); }
315		WRITE16_MEMBER(megasys1_state::megasys1_scrollram_2_w){ scrollram_w(space, offset, data, mem_mask, 2); }
	309	WRITE16_MEMBER(megasys1_state::megasys1_scrollram_0_w){ scrollram_w(offset, data, mem_mask, 0); }
	310	WRITE16_MEMBER(megasys1_state::megasys1_scrollram_1_w){ scrollram_w(offset, data, mem_mask, 1); }
	311	WRITE16_MEMBER(megasys1_state::megasys1_scrollram_2_w){ scrollram_w(offset, data, mem_mask, 2); }
316	312
317	313
318	314
r20931	r20932
362	358	SET_TILE_INFO_MEMBER(tmap, (code & 0xfff) * m_16x16_scroll_factor[tmap] + (tile_index & 3), code >> (16 - m_bits_per_color_code), 0);
363	359	}
364	360
365		static void create_tilemaps(running_machine &machine)
	361	void megasys1_state::create_tilemaps()
366	362	{
367		megasys1_state *state = machine.driver_data<megasys1_state>();
368	363	int layer, i;
369	364
370	365	for (layer = 0; layer < 3; layer++)
371	366	{
372	367	/* 16x16 tilemaps */
373		state->m_tilemap[layer][0][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),state),
	368	m_tilemap[layer][0][0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),this),
374	369	8,8, TILES_PER_PAGE_X * 16, TILES_PER_PAGE_Y * 2);
375		state->m_tilemap[layer][0][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),state),
	370	m_tilemap[layer][0][1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),this),
376	371	8,8, TILES_PER_PAGE_X * 8, TILES_PER_PAGE_Y * 4);
377		state->m_tilemap[layer][0][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),state),
	372	m_tilemap[layer][0][2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),this),
378	373	8,8, TILES_PER_PAGE_X * 4, TILES_PER_PAGE_Y * 8);
379		state->m_tilemap[layer][0][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),state),
	374	m_tilemap[layer][0][3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_16x16),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_16x16),this),
380	375	8,8, TILES_PER_PAGE_X * 2, TILES_PER_PAGE_Y * 16);
381	376
382	377	/* 8x8 tilemaps */
383		state->m_tilemap[layer][1][0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),state),
	378	m_tilemap[layer][1][0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),this),
384	379	8,8, TILES_PER_PAGE_X * 8, TILES_PER_PAGE_Y * 1);
385		state->m_tilemap[layer][1][1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),state),
	380	m_tilemap[layer][1][1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),this),
386	381	8,8, TILES_PER_PAGE_X * 4, TILES_PER_PAGE_Y * 2);
387		state->m_tilemap[layer][1][2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),state),
	382	m_tilemap[layer][1][2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),this),
388	383	8,8, TILES_PER_PAGE_X * 4, TILES_PER_PAGE_Y * 2);
389		state->m_tilemap[layer][1][3] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),state), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),state),
	384	m_tilemap[layer][1][3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(megasys1_state::megasys1_get_scroll_tile_info_8x8),this), tilemap_mapper_delegate(FUNC(megasys1_state::megasys1_scan_8x8),this),
390	385	8,8, TILES_PER_PAGE_X * 2, TILES_PER_PAGE_Y * 4);
391	386
392	387	/* set user data and transparency */
393	388	for (i = 0; i < 8; i++)
394	389	{
395		state->m_tilemap[layer][i/4][i%4]->set_user_data((void *)(FPTR)layer);
396		state->m_tilemap[layer][i/4][i%4]->set_transparent_pen(15);
	390	m_tilemap[layer][i/4][i%4]->set_user_data((void *)(FPTR)layer);
	391	m_tilemap[layer][i/4][i%4]->set_transparent_pen(15);
397	392	}
398	393	}
399	394	}
r20931	r20932
560	555	0C      Y position
561	556	0E      Code                                            */
562	557
563		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	558	void megasys1_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
564	559	{
565		megasys1_state *state = machine.driver_data<megasys1_state>();
566	560	int color,code,sx,sy,flipx,flipy,attr,sprite,offs,color_mask;
567	561
568	562	/* objram: 0x100*4 entries      spritedata: 0x80 entries */
569	563
570	564	/* sprite order is from first in Sprite Data RAM (frontmost) to last */
571	565
572		if (state->m_hardware_type_z == 0)  /* standard sprite hardware */
	566	if (m_hardware_type_z == 0)  /* standard sprite hardware */
573	567	{
574		color_mask = (state->m_sprite_flag & 0x100) ? 0x07 : 0x0f;
	568	color_mask = (m_sprite_flag & 0x100) ? 0x07 : 0x0f;
575	569
576	570	for (offs = (0x800-8)/2;offs >= 0;offs -= 8/2)
577	571	{
578	572	for (sprite = 0; sprite < 4 ; sprite ++)
579	573	{
580		UINT16 *objectdata = &state->m_buffer2_objectram[offs + (0x800/2) * sprite];
581		UINT16 *spritedata = &state->m_buffer2_spriteram16[ (objectdata[ 0 ] & 0x7f) * 0x10/2];
	574	UINT16 *objectdata = &m_buffer2_objectram[offs + (0x800/2) * sprite];
	575	UINT16 *spritedata = &m_buffer2_spriteram16[ (objectdata[ 0 ] & 0x7f) * 0x10/2];
582	576
583	577	attr = spritedata[ 8/2 ];
584	578	if (((attr & 0xc0)>>6) != sprite)   continue;   // flipping
r20931	r20932
593	587	flipx = attr & 0x40;
594	588	flipy = attr & 0x80;
595	589
596		if (state->m_screen_flag & 1)
	590	if (m_screen_flag & 1)
597	591	{
598	592	flipx = !flipx;     flipy = !flipy;
599	593	sx = 240-sx;        sy = 240-sy;
r20931	r20932
604	598	color = (attr & color_mask);
605	599
606	600	pdrawgfx_transpen(bitmap,cliprect,
607		machine.gfx[3],
608		(code & 0xfff ) + ((state->m_sprite_bank & 1) << 12),
	601	machine().gfx[3],
	602	(code & 0xfff ) + ((m_sprite_bank & 1) << 12),
609	603	color,
610	604	flipx, flipy,
611	605	sx, sy,
612		machine.priority_bitmap,
	606	machine().priority_bitmap,
613	607	(attr & 0x08) ? 0x0c : 0x0a,15);
614	608	}   /* sprite */
615	609	}   /* offs */
616	610	}   /* non Z hw */
617	611	else
618	612	{
619		UINT16 *spriteram16 = state->m_spriteram;
	613	UINT16 *spriteram16 = m_spriteram;
620	614
621	615	/* MS1-Z just draws Sprite Data, and in reverse order */
622	616
r20931	r20932
638	632	flipx = attr & 0x40;
639	633	flipy = attr & 0x80;
640	634
641		if (state->m_screen_flag & 1)
	635	if (m_screen_flag & 1)
642	636	{
643	637	flipx = !flipx;     flipy = !flipy;
644	638	sx = 240-sx;        sy = 240-sy;
645	639	}
646	640
647	641	pdrawgfx_transpen(bitmap,cliprect,
648		machine.gfx[2],
	642	machine().gfx[2],
649	643	code,
650	644	color,
651	645	flipx, flipy,
652	646	sx, sy,
653		machine.priority_bitmap,
	647	machine().priority_bitmap,
654	648	(attr & 0x08) ? 0x0c : 0x0a,15);
655	649	}   /* sprite */
656	650	}   /* Z hw */
r20931	r20932
1008	1002	}
1009	1003
1010	1004	if (active_layers & 0x08)
1011		draw_sprites(machine(),bitmap,cliprect);
	1005	draw_sprites(bitmap,cliprect);
1012	1006	return 0;
1013	1007	}
1014	1008

trunk/src/mame/video/marineb.c

r20931	r20932
150	150	*
151	151	*************************************/
152	152
153		static void set_tilemap_scrolly( running_machine &machine, int cols )
	153	void marineb_state::set_tilemap_scrolly( int cols )
154	154	{
155		marineb_state *state = machine.driver_data<marineb_state>();
156	155	int col;
157	156
158	157	for (col = 0; col < cols; col++)
159		state->m_bg_tilemap->set_scrolly(col, state->m_column_scroll);
	158	m_bg_tilemap->set_scrolly(col, m_column_scroll);
160	159
161	160	for (; col < 32; col++)
162		state->m_bg_tilemap->set_scrolly(col, 0);
	161	m_bg_tilemap->set_scrolly(col, 0);
163	162	}
164	163
165	164
r20931	r20932
167	166	{
168	167	int offs;
169	168
170		set_tilemap_scrolly(machine(), 24);
	169	set_tilemap_scrolly(24);
171	170	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
172	171
173	172	/* draw the sprites */
r20931	r20932
228	227	{
229	228	int offs, sx, sy, code, col, flipx, flipy;
230	229
231		set_tilemap_scrolly(machine(), 26);
	230	set_tilemap_scrolly(26);
232	231	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
233	232
234	233	/* draw the small sprites */
r20931	r20932
306	305	{
307	306	int offs;
308	307
309		set_tilemap_scrolly(machine(), 0);
	308	set_tilemap_scrolly(0);
310	309	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
311	310
312	311	/* draw the sprites */
r20931	r20932
365	364	{
366	365	int offs;
367	366
368		set_tilemap_scrolly(machine(), 0);
	367	set_tilemap_scrolly(0);
369	368	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
370	369
371	370	/* draw the sprites */
r20931	r20932
408	407	{
409	408	int offs;
410	409
411		set_tilemap_scrolly(machine(), 0);
	410	set_tilemap_scrolly(0);
412	411	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
413	412
414	413	/* draw the sprites */

trunk/src/mame/video/mappy.c

r20931	r20932
387	387
388	388	***************************************************************************/
389	389
390		static void mappy_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base)
	390	void mappy_state::mappy_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base)
391	391	{
392		mappy_state *state = machine.driver_data<mappy_state>();
393	392	UINT8 *spriteram = spriteram_base + 0x780;
394	393	UINT8 *spriteram_2 = spriteram + 0x800;
395	394	UINT8 *spriteram_3 = spriteram_2 + 0x800;
r20931	r20932
422	421	sy -= 16 * sizey;
423	422	sy = (sy & 0xff) - 32;  // fix wraparound
424	423
425		if (state->flip_screen())
	424	if (flip_screen())
426	425	{
427	426	flipx ^= 1;
428	427	flipy ^= 1;
r20931	r20932
434	433	{
435	434	for (x = 0;x <= sizex;x++)
436	435	{
437		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	436	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
438	437	sprite + gfx_offs[y ^ (sizey * flipy)][x ^ (sizex * flipx)],
439	438	color,
440	439	flipx,flipy,
441	440	sx + 16*x,sy + 16*y,
442		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 15));
	441	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 15));
443	442	}
444	443	}
445	444	}
r20931	r20932
468	467	1   -------x  X position MSB
469	468	*/
470	469
471		static void phozon_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base)
	470	void mappy_state::phozon_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *spriteram_base)
472	471	{
473		mappy_state *state = machine.driver_data<mappy_state>();
474	472	UINT8 *spriteram = spriteram_base + 0x780;
475	473	UINT8 *spriteram_2 = spriteram + 0x800;
476	474	UINT8 *spriteram_3 = spriteram_2 + 0x800;
r20931	r20932
502	500	sy -= 8 * sizey;
503	501	sy = (sy & 0xff) - 32;  // fix wraparound
504	502
505		if (state->flip_screen())
	503	if (flip_screen())
506	504	{
507	505	flipx ^= 1;
508	506	flipy ^= 1;
r20931	r20932
514	512	{
515	513	for (x = 0;x <= sizex;x++)
516	514	{
517		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	515	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
518	516	sprite + gfx_offs[y ^ (sizey * flipy)][x ^ (sizex * flipx)],
519	517	color,
520	518	flipx,flipy,
521	519	sx + 8*x,sy + 8*y,
522		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 31));
	520	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 31));
523	521	}
524	522	}
525	523	}
r20931	r20932
535	533	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES,0);
536	534
537	535	sprite_bitmap.fill(15, cliprect);
538		mappy_draw_sprites(machine(),sprite_bitmap,cliprect,m_spriteram);
	536	mappy_draw_sprites(sprite_bitmap,cliprect,m_spriteram);
539	537	copybitmap_trans(bitmap,sprite_bitmap,0,0,0,0,cliprect,15);
540	538
541	539	/* Redraw the high priority characters */
r20931	r20932
562	560
563	561	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES,0);
564	562
565		phozon_draw_sprites(machine(),bitmap,cliprect,m_spriteram);
	563	phozon_draw_sprites(bitmap,cliprect,m_spriteram);
566	564
567	565	/* Redraw the high priority characters */
568	566	m_bg_tilemap->draw(bitmap, cliprect, 1,0);
r20931	r20932
578	576
579	577	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES,0);
580	578
581		mappy_draw_sprites(machine(),bitmap,cliprect,m_spriteram);
	579	mappy_draw_sprites(bitmap,cliprect,m_spriteram);
582	580
583	581	/* Redraw the high priority characters */
584	582	m_bg_tilemap->draw(bitmap, cliprect, 1,0);

trunk/src/mame/video/mitchell.c

r20931	r20932
270	270
271	271	***************************************************************************/
272	272
273		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	273	void mitchell_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
274	274	{
275		mitchell_state *state = machine.driver_data<mitchell_state>();
276	275	int offs, sx, sy;
277	276
278	277	/* the last entry is not a sprite, we skip it otherwise spang shows a bubble */
279	278	/* moving diagonally across the screen */
280	279	for (offs = 0x1000 - 0x40; offs >= 0; offs -= 0x20)
281	280	{
282		int code = state->m_objram[offs];
283		int attr = state->m_objram[offs + 1];
	281	int code = m_objram[offs];
	282	int attr = m_objram[offs + 1];
284	283	int color = attr & 0x0f;
285		sx = state->m_objram[offs + 3] + ((attr & 0x10) << 4);
286		sy = ((state->m_objram[offs + 2] + 8) & 0xff) - 8;
	284	sx = m_objram[offs + 3] + ((attr & 0x10) << 4);
	285	sy = ((m_objram[offs + 2] + 8) & 0xff) - 8;
287	286	code += (attr & 0xe0) << 3;
288		if (state->m_flipscreen)
	287	if (m_flipscreen)
289	288	{
290	289	sx = 496 - sx;
291	290	sy = 240 - sy;
292	291	}
293		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	292	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
294	293	code,
295	294	color,
296		state->m_flipscreen, state->m_flipscreen,
	295	m_flipscreen, m_flipscreen,
297	296	sx,sy,15);
298	297	}
299	298	}
r20931	r20932
302	301	{
303	302	bitmap.fill(0, cliprect);
304	303	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
305		draw_sprites(machine(), bitmap, cliprect);
	304	draw_sprites(bitmap, cliprect);
306	305	return 0;
307	306	}

trunk/src/mame/video/m72.c

r20931	r20932
8	8
9	9	***************************************************************************/
10	10
11		INLINE void m72_get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,const UINT16 *vram,int gfxnum)
	11	inline void m72_state::m72_get_tile_info(tile_data &tileinfo,int tile_index,const UINT16 *vram,int gfxnum)
12	12	{
13	13	int code,attr,color,pri;
14	14
r20931	r20932
23	23	else pri = 0;
24	24	/* color & 0x10 is used in bchopper and hharry, more priority? */
25	25
26		SET_TILE_INFO(
	26	SET_TILE_INFO_MEMBER(
27	27	gfxnum,
28	28	code + ((attr & 0x3f) << 8),
29	29	color & 0x0f,
r20931	r20932
31	31	tileinfo.group = pri;
32	32	}
33	33
34		INLINE void rtype2_get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,const UINT16 *vram,int gfxnum)
	34	inline void m72_state::rtype2_get_tile_info(tile_data &tileinfo,int tile_index,const UINT16 *vram,int gfxnum)
35	35	{
36	36	int code,attr,color,pri;
37	37
r20931	r20932
48	48	/* (vram[tile_index+2] & 0x10) is used by majtitle on the green, but it's not clear for what */
49	49	/* (vram[tile_index+3] & 0xfe) are used as well */
50	50
51		SET_TILE_INFO(
	51	SET_TILE_INFO_MEMBER(
52	52	gfxnum,
53	53	code,
54	54	color & 0x0f,
r20931	r20932
59	59
60	60	TILE_GET_INFO_MEMBER(m72_state::m72_get_bg_tile_info)
61	61	{
62		m72_get_tile_info(machine(),tileinfo,tile_index,m_videoram2,2);
	62	m72_get_tile_info(tileinfo,tile_index,m_videoram2,2);
63	63	}
64	64
65	65	TILE_GET_INFO_MEMBER(m72_state::m72_get_fg_tile_info)
66	66	{
67		m72_get_tile_info(machine(),tileinfo,tile_index,m_videoram1,1);
	67	m72_get_tile_info(tileinfo,tile_index,m_videoram1,1);
68	68	}
69	69
70	70	TILE_GET_INFO_MEMBER(m72_state::hharry_get_bg_tile_info)
71	71	{
72		m72_get_tile_info(machine(),tileinfo,tile_index,m_videoram2,1);
	72	m72_get_tile_info(tileinfo,tile_index,m_videoram2,1);
73	73	}
74	74
75	75	TILE_GET_INFO_MEMBER(m72_state::rtype2_get_bg_tile_info)
76	76	{
77		rtype2_get_tile_info(machine(),tileinfo,tile_index,m_videoram2,1);
	77	rtype2_get_tile_info(tileinfo,tile_index,m_videoram2,1);
78	78	}
79	79
80	80	TILE_GET_INFO_MEMBER(m72_state::rtype2_get_fg_tile_info)
81	81	{
82		rtype2_get_tile_info(machine(),tileinfo,tile_index,m_videoram1,1);
	82	rtype2_get_tile_info(tileinfo,tile_index,m_videoram1,1);
83	83	}
84	84
85	85
r20931	r20932
96	96
97	97	***************************************************************************/
98	98
99		static void register_savestate(running_machine &machine)
	99	void m72_state::register_savestate()
100	100	{
101		m72_state *state = machine.driver_data<m72_state>();
102		state->save_item(NAME(state->m_raster_irq_position));
103		state->save_item(NAME(state->m_video_off));
104		state->save_item(NAME(state->m_scrollx1));
105		state->save_item(NAME(state->m_scrolly1));
106		state->save_item(NAME(state->m_scrollx2));
107		state->save_item(NAME(state->m_scrolly2));
108		state->save_pointer(NAME(state->m_buffered_spriteram), state->m_spriteram.bytes()/2);
	101	save_item(NAME(m_raster_irq_position));
	102	save_item(NAME(m_video_off));
	103	save_item(NAME(m_scrollx1));
	104	save_item(NAME(m_scrolly1));
	105	save_item(NAME(m_scrollx2));
	106	save_item(NAME(m_scrolly2));
	107	save_pointer(NAME(m_buffered_spriteram), m_spriteram.bytes()/2);
109	108	}
110	109
111	110
r20931	r20932
136	135	m_bg_tilemap->set_scrolldx(0,0);
137	136	m_bg_tilemap->set_scrolldy(-128,-128);
138	137
139		register_savestate(machine());
	138	register_savestate();
140	139	}
141	140
142	141	VIDEO_START_MEMBER(m72_state,xmultipl)
r20931	r20932
171	170	m_bg_tilemap->set_scrolldx(4,0);
172	171	m_bg_tilemap->set_scrolldy(-128,16);
173	172
174		register_savestate(machine());
	173	register_savestate();
175	174	}
176	175
177	176	VIDEO_START_MEMBER(m72_state,poundfor)
r20931	r20932
221	220	m_bg_tilemap->set_scrolldx(4,0);
222	221	m_bg_tilemap->set_scrolldy(-128,-128);
223	222
224		register_savestate(machine());
	223	register_savestate();
225	224	}
226	225
227	226	VIDEO_START_MEMBER(m72_state,hharry)
r20931	r20932
247	246	m_bg_tilemap->set_scrolldx(6,0);
248	247	m_bg_tilemap->set_scrolldy(-128,16);
249	248
250		register_savestate(machine());
	249	register_savestate();
251	250	}
252	251
253	252
r20931	r20932
273	272	return m_generic_paletteram2_16[offset] | 0xffe0;   /* only D0-D4 are connected */
274	273	}
275	274
276		INLINE void changecolor(running_machine &machine,int color,int r,int g,int b)
	275	inline void m72_state::changecolor(int color,int r,int g,int b)
277	276	{
278		palette_set_color_rgb(machine,color,pal5bit(r),pal5bit(g),pal5bit(b));
	277	palette_set_color_rgb(machine(),color,pal5bit(r),pal5bit(g),pal5bit(b));
279	278	}
280	279
281	280	WRITE16_MEMBER(m72_state::m72_palette1_w)
r20931	r20932
285	284
286	285	COMBINE_DATA(&m_generic_paletteram_16[offset]);
287	286	offset &= 0x0ff;
288		changecolor(machine(),
289		offset,
	287	changecolor(offset,
290	288	m_generic_paletteram_16[offset + 0x000],
291	289	m_generic_paletteram_16[offset + 0x200],
292	290	m_generic_paletteram_16[offset + 0x400]);
r20931	r20932
299	297
300	298	COMBINE_DATA(&m_generic_paletteram2_16[offset]);
301	299	offset &= 0x0ff;
302		changecolor(machine(),
303		offset + 256,
	300	changecolor(offset + 256,
304	301	m_generic_paletteram2_16[offset + 0x000],
305	302	m_generic_paletteram2_16[offset + 0x200],
306	303	m_generic_paletteram2_16[offset + 0x400]);
r20931	r20932
415	412
416	413	***************************************************************************/
417	414
418		static void m72_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	415	void m72_state::m72_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
419	416	{
420		m72_state *state = machine.driver_data<m72_state>();
421		UINT16 *spriteram = state->m_buffered_spriteram;
	417	UINT16 *spriteram = m_buffered_spriteram;
422	418	int offs;
423	419
424	420	offs = 0;
425		while (offs < state->m_spriteram.bytes()/2)
	421	while (offs < m_spriteram.bytes()/2)
426	422	{
427	423	int code,color,sx,sy,flipx,flipy,w,h,x,y;
428	424
r20931	r20932
438	434	h = 1 << ((spriteram[offs+2] & 0x3000) >> 12);
439	435	sy -= 16 * h;
440	436
441		if (state->flip_screen())
	437	if (flip_screen())
442	438	{
443	439	sx = 512 - 16*w - sx;
444	440	sy = 284 - 16*h - sy;
r20931	r20932
457	453	if (flipy) c += h-1-y;
458	454	else c += y;
459	455
460		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	456	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
461	457	c,
462	458	color,
463	459	flipx,flipy,
r20931	r20932
469	465	}
470	466	}
471	467
472		static void majtitle_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	468	void m72_state::majtitle_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
473	469	{
474		m72_state *state = machine.driver_data<m72_state>();
475		UINT16 *spriteram16_2 = state->m_spriteram2;
	470	UINT16 *spriteram16_2 = m_spriteram2;
476	471	int offs;
477	472
478		for (offs = 0;offs < state->m_spriteram.bytes();offs += 4)
	473	for (offs = 0;offs < m_spriteram.bytes();offs += 4)
479	474	{
480	475	int code,color,sx,sy,flipx,flipy,w,h,x,y;
481	476
r20931	r20932
491	486	h = 1 << ((spriteram16_2[offs+2] & 0x3000) >> 12);
492	487	sy -= 16 * h;
493	488
494		if (state->flip_screen())
	489	if (flip_screen())
495	490	{
496	491	sx = 512 - 16*w - sx;
497	492	sy = 256 - 16*h - sy;
r20931	r20932
510	505	if (flipy) c += h-1-y;
511	506	else c += y;
512	507
513		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	508	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
514	509	c,
515	510	color,
516	511	flipx,flipy,
r20931	r20932
536	531
537	532	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1,0);
538	533	m_fg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1,0);
539		m72_draw_sprites(machine(), bitmap,cliprect);
	534	m72_draw_sprites(bitmap,cliprect);
540	535	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0,0);
541	536	m_fg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0,0);
542	537	return 0;
r20931	r20932
572	567
573	568	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1,0);
574	569	m_fg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1,0);
575		majtitle_draw_sprites(machine(), bitmap,cliprect);
576		m72_draw_sprites(machine(), bitmap,cliprect);
	570	majtitle_draw_sprites(bitmap,cliprect);
	571	m72_draw_sprites(bitmap,cliprect);
577	572	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0,0);
578	573	m_fg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0,0);
579	574	return 0;

trunk/src/mame/video/mystston.c

r20931	r20932
49	49	{
50	50	int scanline = param;
51	51
52		mystston_on_scanline_interrupt(machine());
	52	mystston_on_scanline_interrupt();
53	53
54	54	scanline = scanline + 16;
55	55	if (scanline >= VTOTAL)
r20931	r20932
67	67	*
68	68	*************************************/
69	69
70		static void set_palette(running_machine &machine, mystston_state *state)
	70	void mystston_state::set_palette()
71	71	{
72	72	int i;
73	73	static const int resistances_rg[3] = { 4700, 3300, 1500 };
74	74	static const int resistances_b [2] = { 3300, 1500 };
75	75	double weights_rg[3], weights_b[2];
76	76
77		UINT8 *color_prom = machine.root_device().memregion("proms")->base();
	77	UINT8 *color_prom = machine().root_device().memregion("proms")->base();
78	78
79	79	compute_resistor_weights(0, 255, -1.0,
80	80	3, resistances_rg, weights_rg, 0, 4700,
r20931	r20932
91	91	if (i & 0x20)
92	92	data = color_prom[i & 0x1f];
93	93	else
94		data = state->m_paletteram[i];
	94	data = m_paletteram[i];
95	95
96	96	/* red component */
97	97	bit0 = (data >> 0) & 0x01;
r20931	r20932
110	110	bit1 = (data >> 7) & 0x01;
111	111	b = combine_2_weights(weights_b, bit0, bit1);
112	112
113		palette_set_color(machine, i, MAKE_RGB(r, g, b));
	113	palette_set_color(machine(), i, MAKE_RGB(r, g, b));
114	114	}
115	115	}
116	116
r20931	r20932
172	172	*
173	173	*************************************/
174	174
175		static void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int flip)
	175	void mystston_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int flip)
176	176	{
177		mystston_state *state = gfx->machine().driver_data<mystston_state>();
178	177	int offs;
179	178
180	179	for (offs = 0; offs < 0x60; offs += 4)
181	180	{
182		int attr = state->m_spriteram[offs];
	181	int attr = m_spriteram[offs];
183	182
184	183	if (attr & 0x01)
185	184	{
186		int code = ((attr & 0x10) << 4) | state->m_spriteram[offs + 1];
	185	int code = ((attr & 0x10) << 4) | m_spriteram[offs + 1];
187	186	int color = (attr & 0x08) >> 3;
188	187	int flipx = attr & 0x04;
189	188	int flipy = attr & 0x02;
190		int x = 240 - state->m_spriteram[offs + 3];
191		int y = (240 - state->m_spriteram[offs + 2]) & 0xff;
	189	int x = 240 - m_spriteram[offs + 3];
	190	int y = (240 - m_spriteram[offs + 2]) & 0xff;
192	191
193	192	if (flip)
194	193	{
r20931	r20932
247	246	{
248	247	int flip = (*m_video_control & 0x80) ^ ((machine().root_device().ioport("DSW1")->read() & 0x20) << 2);
249	248
250		set_palette(machine(), this);
	249	set_palette();
251	250
252	251	machine().tilemap().mark_all_dirty();
253	252	m_bg_tilemap->set_scrolly(0, *m_scroll);

trunk/src/mame/video/m90.c

r20931	r20932
30	30	#include "includes/m90.h"
31	31
32	32
33		INLINE void get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,int layer,int page_mask)
	33	inline void m90_state::get_tile_info(tile_data &tileinfo,int tile_index,int layer,int page_mask)
34	34	{
35		m90_state *state = machine.driver_data<m90_state>();
36	35	int tile,color;
37		tile_index = 2*tile_index + ((state->m_video_control_data[5+layer] & page_mask) * 0x2000);
	36	tile_index = 2*tile_index + ((m_video_control_data[5+layer] & page_mask) * 0x2000);
38	37
39		tile=state->m_video_data[tile_index];
40		color=state->m_video_data[tile_index+1];
41		SET_TILE_INFO(
	38	tile=m_video_data[tile_index];
	39	color=m_video_data[tile_index+1];
	40	SET_TILE_INFO_MEMBER(
42	41	0,
43	42	tile,
44	43	color&0xf,
r20931	r20932
46	45	tileinfo.category = (color & 0x30) ? 1 : 0;
47	46	}
48	47
49		INLINE void bomblord_get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,int layer)
	48	inline void m90_state::bomblord_get_tile_info(tile_data &tileinfo,int tile_index,int layer)
50	49	{
51		m90_state *state = machine.driver_data<m90_state>();
52	50	int tile,color;
53	51	tile_index = 2*tile_index + (layer * 0x2000);
54	52
55		tile=state->m_video_data[tile_index];
56		color=state->m_video_data[tile_index+1];
57		SET_TILE_INFO(
	53	tile=m_video_data[tile_index];
	54	color=m_video_data[tile_index+1];
	55	SET_TILE_INFO_MEMBER(
58	56	0,
59	57	tile,
60	58	color&0xf,
r20931	r20932
62	60	tileinfo.category = (color & 0x30) ? 1 : 0;
63	61	}
64	62
65		INLINE void dynablsb_get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,int layer)
	63	inline void m90_state::dynablsb_get_tile_info(tile_data &tileinfo,int tile_index,int layer)
66	64	{
67		m90_state *state = machine.driver_data<m90_state>();
68	65	int tile,color;
69	66	tile_index = 2*tile_index + (layer * 0x2000);
70	67
71		tile=state->m_video_data[tile_index];
72		color=state->m_video_data[tile_index+1];
73		SET_TILE_INFO(
	68	tile=m_video_data[tile_index];
	69	color=m_video_data[tile_index+1];
	70	SET_TILE_INFO_MEMBER(
74	71	0,
75	72	tile,
76	73	color&0xf,
r20931	r20932
78	75	tileinfo.category = (color & 0x30) ? 1 : 0;
79	76	}
80	77
81		TILE_GET_INFO_MEMBER(m90_state::get_pf1_tile_info){ get_tile_info(machine(),tileinfo,tile_index,0,0x3); }
82		TILE_GET_INFO_MEMBER(m90_state::get_pf1w_tile_info){ get_tile_info(machine(),tileinfo,tile_index,0,0x2); }
83		TILE_GET_INFO_MEMBER(m90_state::get_pf2_tile_info){ get_tile_info(machine(),tileinfo,tile_index,1,0x3); }
84		TILE_GET_INFO_MEMBER(m90_state::get_pf2w_tile_info){ get_tile_info(machine(),tileinfo,tile_index,1,0x2); }
	78	TILE_GET_INFO_MEMBER(m90_state::get_pf1_tile_info){ get_tile_info(tileinfo,tile_index,0,0x3); }
	79	TILE_GET_INFO_MEMBER(m90_state::get_pf1w_tile_info){ get_tile_info(tileinfo,tile_index,0,0x2); }
	80	TILE_GET_INFO_MEMBER(m90_state::get_pf2_tile_info){ get_tile_info(tileinfo,tile_index,1,0x3); }
	81	TILE_GET_INFO_MEMBER(m90_state::get_pf2w_tile_info){ get_tile_info(tileinfo,tile_index,1,0x2); }
85	82
86		TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf1_tile_info){ bomblord_get_tile_info(machine(),tileinfo,tile_index,0); }
87		TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf1w_tile_info){ bomblord_get_tile_info(machine(),tileinfo,tile_index,0); }
88		TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf2_tile_info){ bomblord_get_tile_info(machine(),tileinfo,tile_index,2); }
89		TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf2w_tile_info){ bomblord_get_tile_info(machine(),tileinfo,tile_index,2); }
	83	TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf1_tile_info){ bomblord_get_tile_info(tileinfo,tile_index,0); }
	84	TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf1w_tile_info){ bomblord_get_tile_info(tileinfo,tile_index,0); }
	85	TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf2_tile_info){ bomblord_get_tile_info(tileinfo,tile_index,2); }
	86	TILE_GET_INFO_MEMBER(m90_state::bomblord_get_pf2w_tile_info){ bomblord_get_tile_info(tileinfo,tile_index,2); }
90	87
91		TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf1_tile_info){ dynablsb_get_tile_info(machine(),tileinfo,tile_index,0); }
92		TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf1w_tile_info){ dynablsb_get_tile_info(machine(),tileinfo,tile_index,0); }
93		TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf2_tile_info){ dynablsb_get_tile_info(machine(),tileinfo,tile_index,2); }
94		TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf2w_tile_info){ dynablsb_get_tile_info(machine(),tileinfo,tile_index,2); }
	88	TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf1_tile_info){ dynablsb_get_tile_info(tileinfo,tile_index,0); }
	89	TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf1w_tile_info){ dynablsb_get_tile_info(tileinfo,tile_index,0); }
	90	TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf2_tile_info){ dynablsb_get_tile_info(tileinfo,tile_index,2); }
	91	TILE_GET_INFO_MEMBER(m90_state::dynablsb_get_pf2w_tile_info){ dynablsb_get_tile_info(tileinfo,tile_index,2); }
95	92
96	93	void m90_state::video_start()
97	94	{
r20931	r20932
136	133	state_save_register_global_array(machine(), m_video_control_data);
137	134	}
138	135
139		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	136	void m90_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
140	137	{
141		m90_state *state = machine.driver_data<m90_state>();
142		UINT16 *spriteram = state->m_video_data + 0xee00/2;;
	138	UINT16 *spriteram = m_video_data + 0xee00/2;;
143	139	int offs;
144	140
145	141	for (offs = 0x1f2/2; offs >= 0; offs -= 3)
r20931	r20932
163	159
164	160	for (i = 0;i < y_multi;i++)
165	161
166		if (state->m_video_control_data[7] & 0x01)
167		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	162	if (m_video_control_data[7] & 0x01)
	163	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
168	164	sprite + (fy ? y_multi-1 - i : i),
169	165	colour,
170	166	fx,fy,
171	167	x,y+i*16,
172		machine.priority_bitmap,
	168	machine().priority_bitmap,
173	169	(colour & 0x08) ? 0x00 : 0x02,0);
174		else if (state->m_video_control_data[7] & 0x02)
175		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	170	else if (m_video_control_data[7] & 0x02)
	171	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
176	172	sprite + (fy ? y_multi-1 - i : i),
177	173	colour,
178	174	fx,fy,
179	175	x,y+i*16,
180		machine.priority_bitmap,
	176	machine().priority_bitmap,
181	177	((colour & 0x0c)==0x0c) ? 0x00 : 0x02,0);
182	178	else
183		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	179	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
184	180	sprite + (fy ? y_multi-1 - i : i),
185	181	colour,
186	182	fx,fy,
187	183	x,y+i*16,
188		machine.priority_bitmap,
	184	machine().priority_bitmap,
189	185	0x02,0);
190	186	}
191	187	}
192	188
193		static void bomblord_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	189	void m90_state::bomblord_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
194	190	{
195		m90_state *state = machine.driver_data<m90_state>();
196		UINT16 *spriteram16 = state->m_spriteram;
	191	UINT16 *spriteram16 = m_spriteram;
197	192	int offs = 0, last_sprite = 0;
198	193	int x,y,sprite,colour,fx,fy;
199	194
200	195
201		while ((offs < state->m_spriteram.bytes()/2) & (spriteram16[offs+0] != 0x8000))
	196	while ((offs < m_spriteram.bytes()/2) & (spriteram16[offs+0] != 0x8000))
202	197	{
203	198	last_sprite = offs;
204	199	offs += 4;
r20931	r20932
220	215	fx = (spriteram16[offs+3] >> 8) & 0x02;
221	216	fy = (spriteram16[offs+2] >> 8) & 0x80;
222	217
223		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	218	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
224	219	sprite,
225	220	colour,
226	221	fx,fy,
227	222	x,y,
228		machine.priority_bitmap,
	223	machine().priority_bitmap,
229	224	(colour & 0x08) ? 0x00 : 0x02,0);
230	225	}
231	226	}
232	227
233		static void dynablsb_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	228	void m90_state::dynablsb_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
234	229	{
235		m90_state *state = machine.driver_data<m90_state>();
236		UINT16 *spriteram16 = state->m_spriteram;
	230	UINT16 *spriteram16 = m_spriteram;
237	231	int offs = 0, last_sprite = 0;
238	232	int x,y,sprite,colour,fx,fy;
239	233
240		while ((offs < state->m_spriteram.bytes()/2) & (spriteram16[offs+0] != 0xffff))
	234	while ((offs < m_spriteram.bytes()/2) & (spriteram16[offs+0] != 0xffff))
241	235	{
242	236	last_sprite = offs;
243	237	offs += 4;
r20931	r20932
259	253	fx = (spriteram16[offs+3] >> 8) & 0x02;
260	254	fy = (spriteram16[offs+2] >> 8) & 0x80;
261	255
262		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	256	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
263	257	sprite,
264	258	colour,
265	259	fx,fy,
266	260	x,y,
267		machine.priority_bitmap,
	261	machine().priority_bitmap,
268	262	(colour & 0x08) ? 0x00 : 0x02,0);
269	263	}
270	264	}
r20931	r20932
274	268	COMBINE_DATA(&m_video_control_data[offset]);
275	269	}
276	270
277		static void markdirty(tilemap_t *tmap,int page,offs_t offset)
	271	void m90_state::markdirty(tilemap_t *tmap,int page,offs_t offset)
278	272	{
279	273	offset -= page * 0x2000;
280	274
r20931	r20932
447	441	}
448	442	}
449	443
450		draw_sprites(machine(),bitmap,cliprect);
	444	draw_sprites(bitmap,cliprect);
451	445
452	446	} else {
453	447	bitmap.fill(get_black_pen(machine()), cliprect);
r20931	r20932
503	497	m_pf1_layer->draw(bitmap, cliprect, 1,1);
504	498	}
505	499
506		bomblord_draw_sprites(machine(),bitmap,cliprect);
	500	bomblord_draw_sprites(bitmap,cliprect);
507	501
508	502	return 0;
509	503	}
r20931	r20932
545	539	m_pf2_layer->draw(bitmap, cliprect, 1,1);
546	540	}
547	541
548		dynablsb_draw_sprites(machine(),bitmap,cliprect);
	542	dynablsb_draw_sprites(bitmap,cliprect);
549	543
550	544	return 0;
551	545	}

trunk/src/mame/video/mainsnk.c

r20931	r20932
117	117
118	118
119	119
120		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int scrollx, int scrolly )
	120	void mainsnk_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int scrollx, int scrolly )
121	121	{
122		mainsnk_state *state = machine.driver_data<mainsnk_state>();
123		gfx_element *gfx = machine.gfx[1];
	122	gfx_element *gfx = machine().gfx[1];
124	123	const UINT8 *source, *finish;
125		source =  state->m_spriteram;
	124	source =  m_spriteram;
126	125	finish =  source + 25*4;
127	126
128	127	while( source<finish )
r20931	r20932
141	140	sx = 288-16 - sx;
142	141	sy += 8;
143	142
144		if (state->flip_screen())
	143	if (flip_screen())
145	144	{
146	145	sx = 288-16 - sx;
147	146	sy = 224-16 - sy;
r20931	r20932
163	162	UINT32 mainsnk_state::screen_update_mainsnk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
164	163	{
165	164	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
166		draw_sprites(machine(), bitmap, cliprect, 0, 0);
	165	draw_sprites(bitmap, cliprect, 0, 0);
167	166	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);
168	167
169	168	return 0;

trunk/src/mame/video/m57.c

r20931	r20932
170	170	*
171	171	*************************************/
172	172
173		static void draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	173	void m57_state::draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
174	174	{
175		m57_state *state = machine.driver_data<m57_state>();
176	175	int y,x;
177	176	INT16 scrolly;
178	177
179	178	// from 64 to 127: not wrapped
180	179	for (y = 64; y < 128; y++)
181		state->m_bg_tilemap->set_scrollx(y, state->m_scrollram[0x40]);
	180	m_bg_tilemap->set_scrollx(y, m_scrollram[0x40]);
182	181
183		state->m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
	182	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
184	183
185	184	// from 128 to 255: wrapped
186	185	for (y = 128; y <= cliprect.max_y; y++)
187	186	{
188		scrolly = state->m_scrollram[y] + (state->m_scrollram[y + 0x100] << 8);
	187	scrolly = m_scrollram[y] + (m_scrollram[y + 0x100] << 8);
189	188
190	189	if (scrolly >= 0)
191	190	{
r20931	r20932
214	213	*
215	214	*************************************/
216	215
217		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	216	void m57_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
218	217	{
219		m57_state *state = machine.driver_data<m57_state>();
220	218	int offs;
221	219
222		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	220	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
223	221	{
224		UINT8 attributes = state->m_spriteram[offs + 1];
225		int sx = state->m_spriteram[offs + 3];
226		int sy = ((224 - state->m_spriteram[offs + 0] - 32) & 0xff) + 32;
227		int code = state->m_spriteram[offs + 2];
	222	UINT8 attributes = m_spriteram[offs + 1];
	223	int sx = m_spriteram[offs + 3];
	224	int sy = ((224 - m_spriteram[offs + 0] - 32) & 0xff) + 32;
	225	int code = m_spriteram[offs + 2];
228	226	int color = attributes & 0x1f;
229	227	int flipy = attributes & 0x80;
230	228	int flipx = attributes & 0x40;
r20931	r20932
235	233	if (code & 0x80) bank += 1;
236	234	if (attributes & 0x20) bank += 2;
237	235
238		if (state->m_flipscreen)
	236	if (m_flipscreen)
239	237	{
240	238	sx = 240 - sx;
241	239	sy = 224 - sy;
r20931	r20932
243	241	flipy = !flipy;
244	242	}
245	243
246		drawgfx_transmask(bitmap, cliprect, machine.gfx[1 + bank],
	244	drawgfx_transmask(bitmap, cliprect, machine().gfx[1 + bank],
247	245	tile_number,
248	246	color,
249	247	flipx, flipy,
250	248	sx, sy,
251		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 256 + 15));
	249	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 256 + 15));
252	250	}
253	251	}
254	252
r20931	r20932
262	260
263	261	UINT32 m57_state::screen_update_m57(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
264	262	{
265		draw_background(machine(), bitmap, cliprect);
266		draw_sprites(machine(), bitmap, cliprect);
	263	draw_background(bitmap, cliprect);
	264	draw_sprites(bitmap, cliprect);
267	265	return 0;
268	266	}

trunk/src/mame/video/m107.c

r20931	r20932
146	146
147	147	/*****************************************************************************/
148	148
149		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	149	void m107_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
150	150	{
151		m107_state *state = machine.driver_data<m107_state>();
152		UINT16 *spriteram = state->m_buffered_spriteram;
	151	UINT16 *spriteram = m_buffered_spriteram;
153	152	int offs;
154		UINT8 *rom = state->memregion("user1")->base();
	153	UINT8 *rom = memregion("user1")->base();
155	154
156	155	for (offs = 0;offs < 0x800;offs += 4)
157	156	{
r20931	r20932
176	175	fy=(spriteram[offs+2]>>8)&0x2;
177	176	y_multi=(spriteram[offs+0]>>11)&0x3;
178	177
179		if (state->m_spritesystem == 0)
	178	if (m_spritesystem == 0)
180	179	{
181	180	y_multi=1 << y_multi; /* 1, 2, 4 or 8 */
182	181
r20931	r20932
185	184
186	185	for (i=0; i<y_multi; i++)
187	186	{
188		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	187	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
189	188	sprite + s_ptr,
190	189	colour,
191	190	fx,fy,
192	191	x,y-i*16,
193		machine.priority_bitmap,pri_mask,0);
	192	machine().priority_bitmap,pri_mask,0);
194	193
195	194	/* wrap-around y */
196		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	195	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
197	196	sprite + s_ptr,
198	197	colour,
199	198	fx,fy,
200	199	x,(y-i*16) - 0x200,
201		machine.priority_bitmap,pri_mask,0);
	200	machine().priority_bitmap,pri_mask,0);
202	201
203	202	if (fy) s_ptr++; else s_ptr--;
204	203	}
r20931	r20932
242	241	if (!ffy) sprite+=y_multi-1;
243	242	for (i=0; i<y_multi; i++)
244	243	{
245		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	244	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
246	245	sprite+(ffy?i:-i),
247	246	colour,
248	247	ffx,ffy,
249	248	(x+xdisp)&0x1ff,(y-ydisp-16*i)&0x1ff,
250		machine.priority_bitmap,pri_mask,0);
	249	machine().priority_bitmap,pri_mask,0);
251	250
252	251	/* wrap-around y */
253		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	252	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
254	253	sprite+(ffy?i:-i),
255	254	colour,
256	255	ffx,ffy,
257	256	(x+xdisp)&0x1ff,((y-ydisp-16*i)&0x1ff)-0x200,
258		machine.priority_bitmap,pri_mask,0);
	257	machine().priority_bitmap,pri_mask,0);
259	258	}
260	259
261	260	if (rom[rom_offs+1]&0x80) break;    /* end of block */
r20931	r20932
269	268
270	269	/*****************************************************************************/
271	270
272		static void m107_update_scroll_positions(running_machine &machine)
	271	void m107_state::m107_update_scroll_positions()
273	272	{
274		m107_state *state = machine.driver_data<m107_state>();
275	273	int laynum;
276	274	int i;
277	275
r20931	r20932
283	281
284	282	for (laynum = 0; laynum < 4; laynum++)
285	283	{
286		pf_layer_info *layer = &state->m_pf_layer[laynum];
	284	pf_layer_info *layer = &m_pf_layer[laynum];
287	285
288		int scrolly = state->m_control[0 + 2 * laynum];
289		int scrollx = state->m_control[1 + 2 * laynum];
	286	int scrolly = m_control[0 + 2 * laynum];
	287	int scrollx = m_control[1 + 2 * laynum];
290	288
291		if (state->m_control[0x08 + laynum] & 0x01) //used by World PK Soccer goal scrolling and Fire Barrel sea wave effect (stage 2) / canyon parallax effect (stage 6)
	289	if (m_control[0x08 + laynum] & 0x01) //used by World PK Soccer goal scrolling and Fire Barrel sea wave effect (stage 2) / canyon parallax effect (stage 6)
292	290	{
293		const UINT16 *scrolldata = state->m_vram_data + (0xe000 + 0x200 * laynum) / 2;
	291	const UINT16 *scrolldata = m_vram_data + (0xe000 + 0x200 * laynum) / 2;
294	292
295	293	layer->tmap->set_scroll_rows(512);
296	294	for (i = 0; i < 512; i++)
r20931	r20932
309	307
310	308	/*****************************************************************************/
311	309
312		static void m107_tilemap_draw(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int laynum, int category,int opaque)
	310	void m107_state::m107_tilemap_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int laynum, int category,int opaque)
313	311	{
314		m107_state *state = machine.driver_data<m107_state>();
315	312	int line;
316	313	rectangle clip;
317		const rectangle &visarea = machine.primary_screen->visible_area();
	314	const rectangle &visarea = machine().primary_screen->visible_area();
318	315	clip = visarea;
319	316
320		if (state->m_control[0x08 + laynum] & 0x02)
	317	if (m_control[0x08 + laynum] & 0x02)
321	318	{
322	319	for (line = cliprect.min_y; line <= cliprect.max_y;line++)
323	320	{
324		const UINT16 *scrolldata = state->m_vram_data + (0xe800 + 0x200 * laynum) / 2;
	321	const UINT16 *scrolldata = m_vram_data + (0xe800 + 0x200 * laynum) / 2;
325	322	clip.min_y = clip.max_y = line;
326	323
327		state->m_pf_layer[laynum].tmap->set_scrollx(0,  state->m_control[1 + 2 * laynum]);
328		state->m_pf_layer[laynum].tmap->set_scrolly(0,  (state->m_control[0 + 2 * laynum] + scrolldata[line]));
	324	m_pf_layer[laynum].tmap->set_scrollx(0,  m_control[1 + 2 * laynum]);
	325	m_pf_layer[laynum].tmap->set_scrolly(0,  (m_control[0 + 2 * laynum] + scrolldata[line]));
329	326
330		state->m_pf_layer[laynum].tmap->draw(bitmap, clip, category | opaque, category);
	327	m_pf_layer[laynum].tmap->draw(bitmap, clip, category | opaque, category);
331	328	}
332	329	}
333	330	else
334		state->m_pf_layer[laynum].tmap->draw(bitmap, cliprect, category | opaque, category);
	331	m_pf_layer[laynum].tmap->draw(bitmap, cliprect, category | opaque, category);
335	332	}
336	333
337	334
338		static void m107_screenrefresh(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	335	void m107_state::m107_screenrefresh(bitmap_ind16 &bitmap, const rectangle &cliprect)
339	336	{
340		m107_state *state = machine.driver_data<m107_state>();
341		machine.priority_bitmap.fill(0, cliprect);
	337	machine().priority_bitmap.fill(0, cliprect);
342	338
343		if ((~state->m_control[0x0b] >> 7) & 1)
	339	if ((~m_control[0x0b] >> 7) & 1)
344	340	{
345		m107_tilemap_draw(machine, bitmap, cliprect, 3, 0,0);
346		m107_tilemap_draw(machine, bitmap, cliprect, 3, 1,0);
	341	m107_tilemap_draw(bitmap, cliprect, 3, 0,0);
	342	m107_tilemap_draw(bitmap, cliprect, 3, 1,0);
347	343	}
348	344	else
349	345	bitmap.fill(0, cliprect);
350	346
351	347	/* note: the opaque flag is used if layer 3 is disabled, noticeable in World PK Soccer title and gameplay screens */
352		m107_tilemap_draw(machine, bitmap, cliprect, 2, 0,(((state->m_control[0x0b] >> 7) & 1) ? TILEMAP_DRAW_OPAQUE : 0));
353		m107_tilemap_draw(machine, bitmap, cliprect, 1, 0,0);
354		m107_tilemap_draw(machine, bitmap, cliprect, 0, 0,0);
355		m107_tilemap_draw(machine, bitmap, cliprect, 2, 1,0);
356		m107_tilemap_draw(machine, bitmap, cliprect, 1, 1,0);
357		m107_tilemap_draw(machine, bitmap, cliprect, 0, 1,0);
	348	m107_tilemap_draw(bitmap, cliprect, 2, 0,(((m_control[0x0b] >> 7) & 1) ? TILEMAP_DRAW_OPAQUE : 0));
	349	m107_tilemap_draw(bitmap, cliprect, 1, 0,0);
	350	m107_tilemap_draw(bitmap, cliprect, 0, 0,0);
	351	m107_tilemap_draw(bitmap, cliprect, 2, 1,0);
	352	m107_tilemap_draw(bitmap, cliprect, 1, 1,0);
	353	m107_tilemap_draw(bitmap, cliprect, 0, 1,0);
358	354
359		if(state->m_sprite_display)
360		draw_sprites(machine, bitmap, cliprect);
	355	if(m_sprite_display)
	356	draw_sprites(bitmap, cliprect);
361	357
362	358	/* This hardware probably has more priority values - but I haven't found
363	359	any used yet */
r20931	r20932
382	378
383	379	UINT32 m107_state::screen_update_m107(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
384	380	{
385		m107_update_scroll_positions(machine());
386		m107_screenrefresh(machine(), bitmap, cliprect);
	381	m107_update_scroll_positions();
	382	m107_screenrefresh(bitmap, cliprect);
387	383	return 0;
388	384	}

trunk/src/mame/video/m92.c

r20931	r20932
48	48	{
49	49	m_sprite_buffer_busy = 1;
50	50	if (m_game_kludge!=2) /* Major Title 2 doesn't like this interrupt!? */
51		m92_sprite_interrupt(machine());
	51	m92_sprite_interrupt();
52	52	}
53	53
54	54	WRITE16_MEMBER(m92_state::m92_spritecontrol_w)
r20931	r20932
308	308
309	309	/*****************************************************************************/
310	310
311		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	311	void m92_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
312	312	{
313		m92_state *state = machine.driver_data<m92_state>();
314		UINT16 *source = state->m_spriteram->buffer();
	313	UINT16 *source = m_spriteram->buffer();
315	314	int offs, layer;
316	315
317	316	for (layer = 0; layer < 8; layer++)
318	317	{
319		for (offs = 0; offs < state->m_sprite_list; )
	318	for (offs = 0; offs < m_sprite_list; )
320	319	{
321	320	int x = source[offs+3] & 0x1ff;
322	321	int y = source[offs+0] & 0x1ff;
r20931	r20932
345	344
346	345	for (row = 0; row < numrows; row++)
347	346	{
348		if (state->flip_screen())
	347	if (flip_screen())
349	348	{
350		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	349	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
351	350	code + s_ptr, color, !flipx, !flipy,
352	351	464 - x, 240 - (y - row * 16),
353		machine.priority_bitmap, pri, 0);
	352	machine().priority_bitmap, pri, 0);
354	353
355	354	// wrap around x
356		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	355	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
357	356	code + s_ptr, color, !flipx, !flipy,
358	357	464 - x + 512, 240 - (y - row * 16),
359		machine.priority_bitmap, pri, 0);
	358	machine().priority_bitmap, pri, 0);
360	359	}
361	360	else
362	361	{
363		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	362	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
364	363	code + s_ptr, color, flipx, flipy,
365	364	x, y - row * 16,
366		machine.priority_bitmap, pri, 0);
	365	machine().priority_bitmap, pri, 0);
367	366
368	367	// wrap around x
369		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	368	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
370	369	code + s_ptr, color, flipx, flipy,
371	370	x - 512, y - row * 16,
372		machine.priority_bitmap, pri, 0);
	371	machine().priority_bitmap, pri, 0);
373	372	}
374	373	if (flipy) s_ptr++;
375	374	else s_ptr--;
r20931	r20932
382	381	}
383	382
384	383	// This needs a lot of work...
385		static void ppan_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	384	void m92_state::ppan_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
386	385	{
387		m92_state *state = machine.driver_data<m92_state>();
388		UINT16 *source = state->m_spriteram->live(); // sprite buffer control is never triggered
	386	UINT16 *source = m_spriteram->live(); // sprite buffer control is never triggered
389	387	int offs, layer;
390	388
391	389	for (layer = 0; layer < 8; layer++)
392	390	{
393		for (offs = 0; offs < state->m_sprite_list; )
	391	for (offs = 0; offs < m_sprite_list; )
394	392	{
395	393	int x = source[offs+3] & 0x1ff;
396	394	int y = source[offs+0] & 0x1ff;
r20931	r20932
420	418
421	419	for (row = 0; row < numrows; row++)
422	420	{
423		if (state->flip_screen())
	421	if (flip_screen())
424	422	{
425		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	423	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
426	424	code + s_ptr, color, !flipx, !flipy,
427	425	464 - x, 240 - (y - row * 16),
428		machine.priority_bitmap, pri, 0);
	426	machine().priority_bitmap, pri, 0);
429	427
430	428	// wrap around x
431		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	429	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
432	430	code + s_ptr, color, !flipx, !flipy,
433	431	464 - x + 512, 240 - (y - row * 16),
434		machine.priority_bitmap, pri, 0);
	432	machine().priority_bitmap, pri, 0);
435	433	}
436	434	else
437	435	{
438		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	436	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
439	437	code + s_ptr, color, flipx, flipy,
440	438	x, y - row * 16,
441		machine.priority_bitmap, pri, 0);
	439	machine().priority_bitmap, pri, 0);
442	440
443	441	// wrap around x
444		pdrawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	442	pdrawgfx_transpen(bitmap,cliprect,machine().gfx[1],
445	443	code + s_ptr, color, flipx, flipy,
446	444	x - 512, y - row * 16,
447		machine.priority_bitmap, pri, 0);
	445	machine().priority_bitmap, pri, 0);
448	446	}
449	447	if (flipy) s_ptr++;
450	448	else s_ptr--;
r20931	r20932
458	456
459	457	/*****************************************************************************/
460	458
461		static void m92_update_scroll_positions(running_machine &machine)
	459	void m92_state::m92_update_scroll_positions()
462	460	{
463		m92_state *state = machine.driver_data<m92_state>();
464	461	int laynum;
465	462	int i;
466	463
r20931	r20932
477	474
478	475	for (laynum = 0; laynum < 3; laynum++)
479	476	{
480		pf_layer_info *layer = &state->m_pf_layer[laynum];
	477	pf_layer_info *layer = &m_pf_layer[laynum];
481	478
482		if (state->m_pf_master_control[laynum] & 0x40)
	479	if (m_pf_master_control[laynum] & 0x40)
483	480	{
484		const UINT16 *scrolldata = state->m_vram_data + (0xf400 + 0x400 * laynum) / 2;
	481	const UINT16 *scrolldata = m_vram_data + (0xf400 + 0x400 * laynum) / 2;
485	482
486	483	layer->tmap->set_scroll_rows(512);
487	484	layer->wide_tmap->set_scroll_rows(512);
r20931	r20932
506	503
507	504	/*****************************************************************************/
508	505
509		static void m92_draw_tiles(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	506	void m92_state::m92_draw_tiles(bitmap_ind16 &bitmap,const rectangle &cliprect)
510	507	{
511		m92_state *state = machine.driver_data<m92_state>();
512	508
513		if ((~state->m_pf_master_control[2] >> 4) & 1)
	509	if ((~m_pf_master_control[2] >> 4) & 1)
514	510	{
515		state->m_pf_layer[2].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
516		state->m_pf_layer[2].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
517		state->m_pf_layer[2].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
518		state->m_pf_layer[2].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
	511	m_pf_layer[2].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
	512	m_pf_layer[2].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
	513	m_pf_layer[2].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
	514	m_pf_layer[2].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
519	515	}
520	516
521		state->m_pf_layer[1].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
522		state->m_pf_layer[1].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
523		state->m_pf_layer[1].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
524		state->m_pf_layer[1].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
	517	m_pf_layer[1].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
	518	m_pf_layer[1].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
	519	m_pf_layer[1].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
	520	m_pf_layer[1].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
525	521
526		state->m_pf_layer[0].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
527		state->m_pf_layer[0].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
528		state->m_pf_layer[0].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
529		state->m_pf_layer[0].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
	522	m_pf_layer[0].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
	523	m_pf_layer[0].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
	524	m_pf_layer[0].wide_tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
	525	m_pf_layer[0].tmap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 1);
530	526	}
531	527
532	528
r20931	r20932
534	530	{
535	531	machine().priority_bitmap.fill(0, cliprect);
536	532	bitmap.fill(0, cliprect);
537		m92_update_scroll_positions(machine());
538		m92_draw_tiles(machine(), bitmap, cliprect);
	533	m92_update_scroll_positions();
	534	m92_draw_tiles(bitmap, cliprect);
539	535
540		draw_sprites(machine(), bitmap, cliprect);
	536	draw_sprites(bitmap, cliprect);
541	537
542	538	/* Flipscreen appears hardwired to the dipswitch - strange */
543	539	if (machine().root_device().ioport("DSW")->read() & 0x100)
r20931	r20932
551	547	{
552	548	machine().priority_bitmap.fill(0, cliprect);
553	549	bitmap.fill(0, cliprect);
554		m92_update_scroll_positions(machine());
555		m92_draw_tiles(machine(), bitmap, cliprect);
	550	m92_update_scroll_positions();
	551	m92_draw_tiles(bitmap, cliprect);
556	552
557		ppan_draw_sprites(machine(), bitmap, cliprect);
	553	ppan_draw_sprites(bitmap, cliprect);
558	554
559	555	/* Flipscreen appears hardwired to the dipswitch - strange */
560	556	if (machine().root_device().ioport("DSW")->read() & 0x100)

trunk/src/mame/video/m58.c

r20931	r20932
209	209	*
210	210	*************************************/
211	211
212		#define DRAW_SPRITE(code, sy) drawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy, colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 512));
	212	#define DRAW_SPRITE(code, sy) drawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy, colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 512));
213	213
214		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	214	void m58_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
215	215	{
216		m58_state *state = machine.driver_data<m58_state>();
217	216	int offs;
218		const rectangle &visarea = machine.primary_screen->visible_area();
	217	const rectangle &visarea = machine().primary_screen->visible_area();
219	218
220		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	219	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
221	220	{
222		int attr = state->m_spriteram[offs + 1];
	221	int attr = m_spriteram[offs + 1];
223	222	int bank = (attr & 0x20) >> 5;
224		int code1 = state->m_spriteram[offs + 2] & 0xbf;
	223	int code1 = m_spriteram[offs + 2] & 0xbf;
225	224	int code2 = 0;
226	225	int color = attr & 0x1f;
227	226	int flipx = attr & 0x40;
228	227	int flipy = attr & 0x80;
229		int sx = state->m_spriteram[offs + 3];
230		int sy1 = 233 - state->m_spriteram[offs];
	228	int sx = m_spriteram[offs + 3];
	229	int sy1 = 233 - m_spriteram[offs];
231	230	int sy2 = 0;
232	231
233	232	if (flipy)
r20931	r20932
240	239	code2 = code1 + 0x40;
241	240	}
242	241
243		if (state->flip_screen())
	242	if (flip_screen())
244	243	{
245	244	sx = 240 - sx;
246	245	sy2 = 192 - sy1;
r20931	r20932
266	265	*
267	266	*************************************/
268	267
269		static void draw_panel( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	268	void m58_state::draw_panel( bitmap_ind16 &bitmap, const rectangle &cliprect )
270	269	{
271		m58_state *state = machine.driver_data<m58_state>();
272	270
273		if (!*state->m_yard_score_panel_disabled)
	271	if (!*m_yard_score_panel_disabled)
274	272	{
275	273	const rectangle clippanel(26*8, 32*8-1, 1*8, 31*8-1);
276	274	const rectangle clippanelflip(0*8, 6*8-1, 1*8, 31*8-1);
277		rectangle clip = state->flip_screen() ? clippanelflip : clippanel;
278		const rectangle &visarea = machine.primary_screen->visible_area();
279		int sx = state->flip_screen() ? cliprect.min_x - 8 : cliprect.max_x + 1 - SCROLL_PANEL_WIDTH;
280		int yoffs = state->flip_screen() ? -40 : -16;
	275	rectangle clip = flip_screen() ? clippanelflip : clippanel;
	276	const rectangle &visarea = machine().primary_screen->visible_area();
	277	int sx = flip_screen() ? cliprect.min_x - 8 : cliprect.max_x + 1 - SCROLL_PANEL_WIDTH;
	278	int yoffs = flip_screen() ? -40 : -16;
281	279
282	280	clip.min_y += visarea.min_y + yoffs;
283	281	clip.max_y += visarea.max_y + yoffs;
284	282	clip &= cliprect;
285	283
286		copybitmap(bitmap, *state->m_scroll_panel_bitmap, state->flip_screen(), state->flip_screen(),
	284	copybitmap(bitmap, *m_scroll_panel_bitmap, flip_screen(), flip_screen(),
287	285	sx, visarea.min_y + yoffs, clip);
288	286	}
289	287	}
r20931	r20932
302	300	m_bg_tilemap->set_scrolly(0, *m_yard_scroll_y_low);
303	301
304	302	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
305		draw_sprites(machine(), bitmap, cliprect);
306		draw_panel(machine(), bitmap, cliprect);
	303	draw_sprites(bitmap, cliprect);
	304	draw_panel(bitmap, cliprect);
307	305	return 0;
308	306	}

trunk/src/mame/video/metlclsh.c

r20931	r20932
163	163
164	164	***************************************************************************/
165	165
166		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	166	void metlclsh_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
167	167	{
168		metlclsh_state *state = machine.driver_data<metlclsh_state>();
169		UINT8 *spriteram = state->m_spriteram;
170		gfx_element *gfx = machine.gfx[0];
	168	UINT8 *spriteram = m_spriteram;
	169	gfx_element *gfx = machine().gfx[0];
171	170	int offs;
172	171
173		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	172	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
174	173	{
175	174	int attr, code, color, sx, sy, flipx, flipy, wrapy, sizey;
176	175
r20931	r20932
190	189
191	190	sy = 240 - spriteram[offs + 2];
192	191
193		if (state->flip_screen())
	192	if (flip_screen())
194	193	{
195	194	sx = 240 - sx;  flipx = !flipx;
196	195	sy = 240 - sy;  flipy = !flipy;     if (sizey)  sy += 16;
r20931	r20932
244	243	m_bg_tilemap->set_scrollx(0, m_scrollx[1] + ((m_scrollx[0] & 0x02) << 7) );
245	244	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
246	245	}
247		draw_sprites(machine(), bitmap, cliprect);          // sprites
	246	draw_sprites(bitmap, cliprect);          // sprites
248	247	m_fg_tilemap->draw(bitmap, cliprect, 2, 0); // high priority tiles of foreground
249	248
250	249	//  popmessage("%02X", m_scrollx[0]);

trunk/src/mame/video/mcr.c

r20931	r20932
130	130	*
131	131	*************************************/
132	132
133		static void mcr_set_color(running_machine &machine, int index, int data)
	133	void mcr_state::mcr_set_color(int index, int data)
134	134	{
135		palette_set_color_rgb(machine, index, pal3bit(data >> 6), pal3bit(data >> 0), pal3bit(data >> 3));
	135	palette_set_color_rgb(machine(), index, pal3bit(data >> 6), pal3bit(data >> 0), pal3bit(data >> 3));
136	136	}
137	137
138	138
139		static void journey_set_color(running_machine &machine, int index, int data)
	139	void mcr_state::journey_set_color(int index, int data)
140	140	{
141	141	/* 3 bits each, RGB */
142	142	int r = (data >> 6) & 7;
r20931	r20932
149	149	b = (b << 5) | (b << 1);
150	150
151	151	/* set the BG color */
152		palette_set_color(machine, index, MAKE_RGB(r, g, b));
	152	palette_set_color(machine(), index, MAKE_RGB(r, g, b));
153	153
154	154	/* if this is an odd entry in the upper palette bank, the hardware */
155	155	/* hard-codes a low 1 bit -- this is used for better grayscales */
r20931	r20932
161	161	}
162	162
163	163	/* set the FG color */
164		palette_set_color(machine, index + 64, MAKE_RGB(r, g, b));
	164	palette_set_color(machine(), index + 64, MAKE_RGB(r, g, b));
165	165	}
166	166
167	167
r20931	r20932
169	169	{
170	170	m_generic_paletteram_8[offset] = data;
171	171	offset &= 0x7f;
172		mcr_set_color(machine(), (offset / 2) & 0x3f, data | ((offset & 1) << 8));
	172	mcr_set_color((offset / 2) & 0x3f, data | ((offset & 1) << 8));
173	173	}
174	174
175	175
r20931	r20932
198	198	if ((offset & 0x780) == 0x780)
199	199	{
200	200	if (mcr_cpu_board != 91475)
201		mcr_set_color(machine(), (offset / 2) & 0x3f, data | ((offset & 1) << 8));
	201	mcr_set_color((offset / 2) & 0x3f, data | ((offset & 1) << 8));
202	202	else
203		journey_set_color(machine(), (offset / 2) & 0x3f, data | ((offset & 1) << 8));
	203	journey_set_color((offset / 2) & 0x3f, data | ((offset & 1) << 8));
204	204	}
205	205	}
206	206
r20931	r20932
224	224
225	225	/* palette RAM is mapped into the upper 0x80 bytes here */
226	226	if ((effoffs & 0x780) == 0x780)
227		mcr_set_color(machine(), ((offset & 0x400) >> 5) | ((offset >> 1) & 0x1f), data | ((offset & 1) << 8));
	227	mcr_set_color(((offset & 0x400) >> 5) | ((offset >> 1) & 0x1f), data | ((offset & 1) << 8));
228	228	}
229	229
230	230
r20931	r20932
247	247	*
248	248	*************************************/
249	249
250		static void render_sprites_91399(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	250	void mcr_state::render_sprites_91399(bitmap_ind16 &bitmap, const rectangle &cliprect)
251	251	{
252		mcr_state *state = machine.driver_data<mcr_state>();
253		UINT8 *spriteram = state->m_spriteram;
254		gfx_element *gfx = machine.gfx[1];
	252	UINT8 *spriteram = m_spriteram;
	253	gfx_element *gfx = machine().gfx[1];
255	254	int offs;
256	255
257	256	/* render the sprites into the bitmap, ORing together */
258		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	257	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
259	258	{
260	259	int code, x, y, sx, sy, hflip, vflip;
261	260
r20931	r20932
287	286	{
288	287	const UINT8 *src = gfx->get_data(code) + gfx->rowbytes() * (y ^ vflip);
289	288	UINT16 *dst = &bitmap.pix16(sy);
290		UINT8 *pri = &machine.priority_bitmap.pix8(sy);
	289	UINT8 *pri = &machine().priority_bitmap.pix8(sy);
291	290
292	291	/* loop over columns */
293	292	for (x = 0; x < 32; x++)
r20931	r20932
320	319	*
321	320	*************************************/
322	321
323		static void render_sprites_91464(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int primask, int sprmask, int colormask)
	322	void mcr_state::render_sprites_91464(bitmap_ind16 &bitmap, const rectangle &cliprect, int primask, int sprmask, int colormask)
324	323	{
325		mcr_state *state = machine.driver_data<mcr_state>();
326		UINT8 *spriteram = state->m_spriteram;
327		gfx_element *gfx = machine.gfx[1];
	324	UINT8 *spriteram = m_spriteram;
	325	gfx_element *gfx = machine().gfx[1];
328	326	int offs;
329	327
330	328	/* render the sprites into the bitmap, working from topmost to bottommost */
331		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	329	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
332	330	{
333	331	int code, color, x, y, sx, sy, hflip, vflip;
334	332
r20931	r20932
359	357	{
360	358	const UINT8 *src = gfx->get_data(code) + gfx->rowbytes() * (y ^ vflip);
361	359	UINT16 *dst = &bitmap.pix16(sy);
362		UINT8 *pri = &machine.priority_bitmap.pix8(sy);
	360	UINT8 *pri = &machine().priority_bitmap.pix8(sy);
363	361
364	362	/* loop over columns */
365	363	for (x = 0; x < 32; x++)
r20931	r20932
411	409	switch (mcr_sprite_board)
412	410	{
413	411	case 91399:
414		render_sprites_91399(machine(), bitmap, cliprect);
	412	render_sprites_91399(bitmap, cliprect);
415	413	break;
416	414
417	415	case 91464:
418	416	if (mcr_cpu_board == 91442)
419		render_sprites_91464(machine(), bitmap, cliprect, 0x00, 0x30, 0x00);
	417	render_sprites_91464(bitmap, cliprect, 0x00, 0x30, 0x00);
420	418	else if (mcr_cpu_board == 91475)
421		render_sprites_91464(machine(), bitmap, cliprect, 0x00, 0x30, 0x40);
	419	render_sprites_91464(bitmap, cliprect, 0x00, 0x30, 0x40);
422	420	else if (mcr_cpu_board == 91490)
423		render_sprites_91464(machine(), bitmap, cliprect, 0x00, 0x30, 0x00);
	421	render_sprites_91464(bitmap, cliprect, 0x00, 0x30, 0x00);
424	422	else if (mcr_cpu_board == 91721)
425		render_sprites_91464(machine(), bitmap, cliprect, 0x00, 0x30, 0x00);
	423	render_sprites_91464(bitmap, cliprect, 0x00, 0x30, 0x00);
426	424	break;
427	425	}
428	426	return 0;

trunk/src/mame/video/m10.c

r20931	r20932
84	84	}
85	85
86	86
87		INLINE void plot_pixel_m10( running_machine &machine, bitmap_ind16 &bm, int x, int y, int col )
	87	inline void m10_state::plot_pixel_m10( bitmap_ind16 &bm, int x, int y, int col )
88	88	{
89		m10_state *state = machine.driver_data<m10_state>();
90	89
91		if (!state->m_flip)
	90	if (!m_flip)
92	91	bm.pix16(y, x) = col;
93	92	else
94	93	bm.pix16((IREMM10_VBSTART - 1) - (y - IREMM10_VBEND) + 6,
r20931	r20932
145	144	int y;
146	145
147	146	for (y = IREMM10_VBEND; y < IREMM10_VBSTART; y++)
148		plot_pixel_m10(machine(), bitmap, 16, y, 1);
	147	plot_pixel_m10(bitmap, 16, y, 1);
149	148	}
150	149
151	150	for (offs = m_videoram.bytes() - 1; offs >= 0; offs--)

trunk/src/mame/video/mermaid.c

r20931	r20932
178	178	machine().primary_screen->register_screen_bitmap(m_helper2);
179	179	}
180	180
181		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	181	void mermaid_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
182	182	{
183	183	const rectangle spritevisiblearea(0 * 8, 26 * 8 - 1, 2 * 8, 30 * 8 - 1);
184	184	const rectangle flip_spritevisiblearea(6 * 8, 31 * 8 - 1, 2 * 8, 30 * 8 - 1);
185	185
186		mermaid_state *state = machine.driver_data<mermaid_state>();
187		UINT8 *spriteram = state->m_spriteram;
	186	UINT8 *spriteram = m_spriteram;
188	187	int offs;
189	188
190		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	189	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
191	190	{
192	191	int attr = spriteram[offs + 2];
193	192	int bank = (attr & 0x30) >> 4;
r20931	r20932
200	199
201	200	if (sx >= 0xf0) sx -= 256;
202	201
203		code |= state->m_rougien_gfxbank1 * 0x2800;
204		code |= state->m_rougien_gfxbank2 * 0x2400;
	202	code |= m_rougien_gfxbank1 * 0x2800;
	203	code |= m_rougien_gfxbank2 * 0x2400;
205	204
206		if (state->flip_screen_x())
	205	if (flip_screen_x())
207	206	{
208	207	flipx = !flipx;
209	208	sx = 240 - sx;
210	209	}
211	210
212		if (state->flip_screen_y())
	211	if (flip_screen_y())
213	212	{
214	213	flipy = !flipy;
215	214	sy = 240 - sy;
216	215	}
217	216
218		drawgfx_transpen(bitmap, (state->flip_screen_x() ? flip_spritevisiblearea : spritevisiblearea),
219		machine.gfx[1], code, color, flipx, flipy, sx, sy, 0);
	217	drawgfx_transpen(bitmap, (flip_screen_x() ? flip_spritevisiblearea : spritevisiblearea),
	218	machine().gfx[1], code, color, flipx, flipy, sx, sy, 0);
220	219	}
221	220	}
222	221
r20931	r20932
224	223	{
225	224	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
226	225	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
227		draw_sprites(machine(), bitmap, cliprect);
	226	draw_sprites(bitmap, cliprect);
228	227	return 0;
229	228	}
230	229
231		static UINT8 collision_check( running_machine &machine, rectangle& rect )
	230	UINT8 mermaid_state::collision_check( rectangle& rect )
232	231	{
233		mermaid_state *state = machine.driver_data<mermaid_state>();
234	232	UINT8 data = 0;
235	233
236	234	int x;
r20931	r20932
239	237	for (y = rect.min_y; y <= rect.max_y; y++)
240	238	for (x = rect.min_x; x <= rect.max_x; x++)
241	239	{
242		UINT16 a = colortable_entry_get_value(machine.colortable, state->m_helper.pix16(y, x)) & 0x3f;
243		UINT16 b = colortable_entry_get_value(machine.colortable, state->m_helper2.pix16(y, x)) & 0x3f;
	240	UINT16 a = colortable_entry_get_value(machine().colortable, m_helper.pix16(y, x)) & 0x3f;
	241	UINT16 b = colortable_entry_get_value(machine().colortable, m_helper2.pix16(y, x)) & 0x3f;
244	242
245	243	if (b)
246	244	if (a)
r20931	r20932
314	312
315	313	drawgfx_transpen(m_helper2, rect, machine().gfx[1], code, 0, flipx, flipy, sx, sy, 0);
316	314
317		m_coll_bit2 |= collision_check(machine(), rect);
	315	m_coll_bit2 |= collision_check(rect);
318	316
319	317	// check collision sprite - foreground
320	318
r20931	r20932
325	323
326	324	drawgfx_transpen(m_helper2, rect, machine().gfx[1], code, 0, flipx, flipy, sx, sy, 0);
327	325
328		m_coll_bit1 |= collision_check(machine(), rect);
	326	m_coll_bit1 |= collision_check(rect);
329	327
330	328	// check collision sprite - sprite
331	329
r20931	r20932
366	364
367	365	drawgfx_transpen(m_helper2, rect, machine().gfx[1], code, 0, flipx, flipy, sx, sy, 0);
368	366
369		m_coll_bit0 |= collision_check(machine(), rect);
	367	m_coll_bit0 |= collision_check(rect);
370	368	}
371	369
372	370	// check for bit 3 (sprite-sprite)
r20931	r20932
447	445
448	446	drawgfx_transpen(m_helper2, rect, machine().gfx[1], code, 0, flipx, flipy, sx, sy, 0);
449	447
450		m_coll_bit3 |= collision_check(machine(), rect);
	448	m_coll_bit3 |= collision_check(rect);
451	449	}
452	450
453	451	// check for bit 6
r20931	r20932
528	526
529	527	drawgfx_transpen(m_helper2, rect, machine().gfx[1], code, 0, flipx, flipy, sx, sy, 0);
530	528
531		m_coll_bit6 |= collision_check(machine(), rect);
	529	m_coll_bit6 |= collision_check(rect);
532	530	}
533	531	}
534	532	}

trunk/src/mame/video/mjkjidai.c

r20931	r20932
81	81
82	82	***************************************************************************/
83	83
84		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	84	void mjkjidai_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
85	85	{
86		mjkjidai_state *state = machine.driver_data<mjkjidai_state>();
87		UINT8 *spriteram = state->m_spriteram1;
88		UINT8 *spriteram_2 = state->m_spriteram2;
89		UINT8 *spriteram_3 = state->m_spriteram3;
	86	UINT8 *spriteram = m_spriteram1;
	87	UINT8 *spriteram_2 = m_spriteram2;
	88	UINT8 *spriteram_3 = m_spriteram3;
90	89	int offs;
91	90
92	91	for (offs = 0x20-2;offs >= 0;offs -= 2)
r20931	r20932
102	101
103	102	sx += (spriteram_2[offs] & 0x20) >> 5;  // not sure about this
104	103
105		if (state->flip_screen())
	104	if (flip_screen())
106	105	{
107	106	sx = 496 - sx;
108	107	sy = 240 - sy;
r20931	r20932
113	112	sx += 16;
114	113	sy += 1;
115	114
116		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	115	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
117	116	code,
118	117	color,
119	118	flipx,flipy,
r20931	r20932
130	129	else
131	130	{
132	131	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
133		draw_sprites(machine(), bitmap,cliprect);
	132	draw_sprites(bitmap,cliprect);
134	133	}
135	134	return 0;
136	135	}

trunk/src/mame/video/mcatadv.c

r20931	r20932
46	46	}
47	47
48	48
49		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	49	void mcatadv_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
50	50	{
51		mcatadv_state *state = machine.driver_data<mcatadv_state>();
52		UINT16 *source = state->m_spriteram_old;
53		UINT16 *finish = source + (state->m_spriteram.bytes() / 2) /2;
54		int global_x = state->m_vidregs[0] - 0x184;
55		int global_y = state->m_vidregs[1] - 0x1f1;
	51	UINT16 *source = m_spriteram_old;
	52	UINT16 *finish = source + (m_spriteram.bytes() / 2) /2;
	53	int global_x = m_vidregs[0] - 0x184;
	54	int global_y = m_vidregs[1] - 0x1f1;
56	55
57	56	UINT16 *destline;
58	57	UINT8 *priline;
59		UINT8 *sprdata = state->memregion("gfx1")->base();
60		int sprmask = state->memregion("gfx1")->bytes()-1;
	58	UINT8 *sprdata = memregion("gfx1")->base();
	59	int sprmask = memregion("gfx1")->bytes()-1;
61	60
62	61	int xstart, xend, xinc;
63	62	int ystart, yend, yinc;
64	63
65		if (state->m_vidregs_old[2] == 0x0001) /* Double Buffered */
	64	if (m_vidregs_old[2] == 0x0001) /* Double Buffered */
66	65	{
67		source += (state->m_spriteram.bytes() / 2) / 2;
68		finish += (state->m_spriteram.bytes() / 2) / 2;
	66	source += (m_spriteram.bytes() / 2) / 2;
	67	finish += (m_spriteram.bytes() / 2) / 2;
69	68	}
70		else if (state->m_vidregs_old[2]) /* I suppose it's possible that there is 4 banks, haven't seen it used though */
	69	else if (m_vidregs_old[2]) /* I suppose it's possible that there is 4 banks, haven't seen it used though */
71	70	{
72	71	logerror("Spritebank != 0/1\n");
73	72	}
r20931	r20932
94	93	if (y & 0x200) y-=0x400;
95	94
96	95	#if 0 // For Flipscreen/Cocktail
97		if(state->m_vidregs[0] & 0x8000)
	96	if(m_vidregs[0] & 0x8000)
98	97	{
99	98	flipx = !flipx;
100	99	}
101		if(state->m_vidregs[1] & 0x8000)
	100	if(m_vidregs[1] & 0x8000)
102	101	{
103	102	flipy = !flipy;
104	103	}
r20931	r20932
118	117	if ((drawypos >= cliprect.min_y) && (drawypos <= cliprect.max_y))
119	118	{
120	119	destline = &bitmap.pix16(drawypos);
121		priline = &machine.priority_bitmap.pix8(drawypos);
	120	priline = &machine().priority_bitmap.pix8(drawypos);
122	121
123	122	for (xcnt = xstart; xcnt != xend; xcnt += xinc)
124	123	{
r20931	r20932
152	151	}
153	152	}
154	153
155		static void mcatadv_draw_tilemap_part( UINT16* current_scroll, UINT16* current_videoram1, int i, tilemap_t* current_tilemap, bitmap_ind16 &bitmap, const rectangle &cliprect )
	154	void mcatadv_state::mcatadv_draw_tilemap_part( UINT16* current_scroll, UINT16* current_videoram1, int i, tilemap_t* current_tilemap, bitmap_ind16 &bitmap, const rectangle &cliprect )
156	155	{
157	156	int flip;
158	157	UINT32 drawline;
r20931	r20932
240	239	#ifdef MAME_DEBUG
241	240	if (!machine().input().code_pressed(KEYCODE_E))
242	241	#endif
243		draw_sprites (machine(), bitmap, cliprect);
	242	draw_sprites (bitmap, cliprect);
244	243	g_profiler.stop();
245	244	return 0;
246	245	}

trunk/src/mame/video/ms32.c

r20931	r20932
119	119	/********** PALETTE WRITES **********/
120	120
121	121
122		static void update_color(running_machine &machine, int color)
	122	void ms32_state::update_color(int color)
123	123	{
124		ms32_state *state = machine.driver_data<ms32_state>();
125	124	int r,g,b;
126	125
127	126	/* I'm not sure how the brightness should be applied, currently I'm only
r20931	r20932
130	129	*/
131	130	if (~color & 0x4000)
132	131	{
133		r = ((state->m_palram_16[color*2] & 0xff00) >>8 ) * state->m_brt_r / 0x100;
134		g = ((state->m_palram_16[color*2] & 0x00ff) >>0 ) * state->m_brt_g / 0x100;
135		b = ((state->m_palram_16[color*2+1] & 0x00ff) >>0 ) * state->m_brt_b / 0x100;
	132	r = ((m_palram_16[color*2] & 0xff00) >>8 ) * m_brt_r / 0x100;
	133	g = ((m_palram_16[color*2] & 0x00ff) >>0 ) * m_brt_g / 0x100;
	134	b = ((m_palram_16[color*2+1] & 0x00ff) >>0 ) * m_brt_b / 0x100;
136	135	}
137	136	else
138	137	{
139		r = ((state->m_palram_16[color*2] & 0xff00) >>8 );
140		g = ((state->m_palram_16[color*2] & 0x00ff) >>0 );
141		b = ((state->m_palram_16[color*2+1] & 0x00ff) >>0 );
	138	r = ((m_palram_16[color*2] & 0xff00) >>8 );
	139	g = ((m_palram_16[color*2] & 0x00ff) >>0 );
	140	b = ((m_palram_16[color*2+1] & 0x00ff) >>0 );
142	141	}
143	142
144		palette_set_color(machine,color,MAKE_RGB(r,g,b));
	143	palette_set_color(machine(),color,MAKE_RGB(r,g,b));
145	144	}
146	145
147	146	WRITE32_MEMBER(ms32_state::ms32_brightness_w)
r20931	r20932
194	193
195	194
196	195	/* SPRITES based on tetrisp2 for now, readd priority bits later */
197		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, bitmap_ind8 &bitmap_pri, const rectangle &cliprect, UINT16 *sprram_top, size_t sprram_size, int gfxnum, int reverseorder)
	196	void ms32_state::draw_sprites(bitmap_ind16 &bitmap, bitmap_ind8 &bitmap_pri, const rectangle &cliprect, UINT16 *sprram_top, size_t sprram_size, int gfxnum, int reverseorder)
198	197	{
199	198	int tx, ty, sx, sy, flipx, flipy;
200	199	int xsize, ysize;
201	200	int code, attr, color, size;
202	201	int pri;
203	202	int xzoom, yzoom;
204		gfx_element *gfx = machine.gfx[gfxnum];
	203	gfx_element *gfx = machine().gfx[gfxnum];
205	204
206	205	UINT16      *source =   sprram_top;
207	206	UINT16  *finish =   sprram_top + (sprram_size - 0x10) / 2;
r20931	r20932
264	263	}
265	264
266	265
267		static void draw_roz(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,int priority)
	266	void ms32_state::draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect,int priority)
268	267	{
269		ms32_state *state = machine.driver_data<ms32_state>();
270	268	/* TODO: registers 0x40/4 / 0x44/4 and 0x50/4 / 0x54/4 are used, meaning unknown */
271	269
272		if (state->m_roz_ctrl[0x5c/4] & 1)  /* "super" mode */
	270	if (m_roz_ctrl[0x5c/4] & 1)  /* "super" mode */
273	271	{
274	272	rectangle my_clip;
275	273	int y,maxy;
r20931	r20932
282	280
283	281	while (y <= maxy)
284	282	{
285		UINT16 *lineaddr = state->m_lineram_16 + 8 * (y & 0xff);
	283	UINT16 *lineaddr = m_lineram_16 + 8 * (y & 0xff);
286	284
287	285	int start2x = (lineaddr[0x00/4] & 0xffff) | ((lineaddr[0x04/4] & 3) << 16);
288	286	int start2y = (lineaddr[0x08/4] & 0xffff) | ((lineaddr[0x0c/4] & 3) << 16);
289	287	int incxx  = (lineaddr[0x10/4] & 0xffff) | ((lineaddr[0x14/4] & 1) << 16);
290	288	int incxy  = (lineaddr[0x18/4] & 0xffff) | ((lineaddr[0x1c/4] & 1) << 16);
291		int startx = (state->m_roz_ctrl[0x00/4] & 0xffff) | ((state->m_roz_ctrl[0x04/4] & 3) << 16);
292		int starty = (state->m_roz_ctrl[0x08/4] & 0xffff) | ((state->m_roz_ctrl[0x0c/4] & 3) << 16);
293		int offsx  = state->m_roz_ctrl[0x30/4];
294		int offsy  = state->m_roz_ctrl[0x34/4];
	289	int startx = (m_roz_ctrl[0x00/4] & 0xffff) | ((m_roz_ctrl[0x04/4] & 3) << 16);
	290	int starty = (m_roz_ctrl[0x08/4] & 0xffff) | ((m_roz_ctrl[0x0c/4] & 3) << 16);
	291	int offsx  = m_roz_ctrl[0x30/4];
	292	int offsy  = m_roz_ctrl[0x34/4];
295	293
296	294	my_clip.min_y = my_clip.max_y = y;
297	295
298		offsx += (state->m_roz_ctrl[0x38/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
299		offsy += (state->m_roz_ctrl[0x3c/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
	296	offsx += (m_roz_ctrl[0x38/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
	297	offsy += (m_roz_ctrl[0x3c/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
300	298
301	299	/* extend sign */
302	300	if (start2x & 0x20000) start2x |= ~0x3ffff;
r20931	r20932
306	304	if (incxx & 0x10000) incxx |= ~0x1ffff;
307	305	if (incxy & 0x10000) incxy |= ~0x1ffff;
308	306
309		state->m_roz_tilemap->draw_roz(bitmap, my_clip,
	307	m_roz_tilemap->draw_roz(bitmap, my_clip,
310	308	(start2x+startx+offsx)<<16, (start2y+starty+offsy)<<16,
311	309	incxx<<8, incxy<<8, 0, 0,
312	310	1, // Wrap
r20931	r20932
317	315	}
318	316	else    /* "simple" mode */
319	317	{
320		int startx = (state->m_roz_ctrl[0x00/4] & 0xffff) | ((state->m_roz_ctrl[0x04/4] & 3) << 16);
321		int starty = (state->m_roz_ctrl[0x08/4] & 0xffff) | ((state->m_roz_ctrl[0x0c/4] & 3) << 16);
322		int incxx  = (state->m_roz_ctrl[0x10/4] & 0xffff) | ((state->m_roz_ctrl[0x14/4] & 1) << 16);
323		int incxy  = (state->m_roz_ctrl[0x18/4] & 0xffff) | ((state->m_roz_ctrl[0x1c/4] & 1) << 16);
324		int incyy  = (state->m_roz_ctrl[0x20/4] & 0xffff) | ((state->m_roz_ctrl[0x24/4] & 1) << 16);
325		int incyx  = (state->m_roz_ctrl[0x28/4] & 0xffff) | ((state->m_roz_ctrl[0x2c/4] & 1) << 16);
326		int offsx  = state->m_roz_ctrl[0x30/4];
327		int offsy  = state->m_roz_ctrl[0x34/4];
	318	int startx = (m_roz_ctrl[0x00/4] & 0xffff) | ((m_roz_ctrl[0x04/4] & 3) << 16);
	319	int starty = (m_roz_ctrl[0x08/4] & 0xffff) | ((m_roz_ctrl[0x0c/4] & 3) << 16);
	320	int incxx  = (m_roz_ctrl[0x10/4] & 0xffff) | ((m_roz_ctrl[0x14/4] & 1) << 16);
	321	int incxy  = (m_roz_ctrl[0x18/4] & 0xffff) | ((m_roz_ctrl[0x1c/4] & 1) << 16);
	322	int incyy  = (m_roz_ctrl[0x20/4] & 0xffff) | ((m_roz_ctrl[0x24/4] & 1) << 16);
	323	int incyx  = (m_roz_ctrl[0x28/4] & 0xffff) | ((m_roz_ctrl[0x2c/4] & 1) << 16);
	324	int offsx  = m_roz_ctrl[0x30/4];
	325	int offsy  = m_roz_ctrl[0x34/4];
328	326
329		offsx += (state->m_roz_ctrl[0x38/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
330		offsy += (state->m_roz_ctrl[0x3c/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
	327	offsx += (m_roz_ctrl[0x38/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
	328	offsy += (m_roz_ctrl[0x3c/4] & 1) * 0x400;   // ??? gratia, hayaosi1...
331	329
332	330	/* extend sign */
333	331	if (startx & 0x20000) startx |= ~0x3ffff;
r20931	r20932
337	335	if (incyy & 0x10000) incyy |= ~0x1ffff;
338	336	if (incyx & 0x10000) incyx |= ~0x1ffff;
339	337
340		state->m_roz_tilemap->draw_roz(bitmap, cliprect,
	338	m_roz_tilemap->draw_roz(bitmap, cliprect,
341	339	(startx+offsx)<<16, (starty+offsy)<<16,
342	340	incxx<<8, incxy<<8, incyx<<8, incyy<<8,
343	341	1, // Wrap
r20931	r20932
365	363	int i;
366	364
367	365	for (i = 0;i < 0x10000;i++) // colors 0x3000-0x3fff are not used
368		update_color(machine(), i);
	366	update_color(i);
369	367
370	368	scrollx = m_tx_scroll[0x00/4] + m_tx_scroll[0x08/4] + 0x18;
371	369	scrolly = m_tx_scroll[0x0c/4] + m_tx_scroll[0x14/4];
r20931	r20932
392	390	m_temp_bitmap_sprites.fill(0, cliprect);
393	391	m_temp_bitmap_sprites_pri.fill(0, cliprect);
394	392
395		draw_sprites(machine(), m_temp_bitmap_sprites, m_temp_bitmap_sprites_pri, cliprect, m_sprram_16, 0x20000, 0, m_reverse_sprite_order);
	393	draw_sprites(m_temp_bitmap_sprites, m_temp_bitmap_sprites_pri, cliprect, m_sprram_16, 0x20000, 0, m_reverse_sprite_order);
396	394
397	395
398	396
r20931	r20932
415	413	rot_pri++;
416	414
417	415	if (rot_pri == 0)
418		draw_roz(machine(), m_temp_bitmap_tilemaps, cliprect, 1 << 1);
	416	draw_roz(m_temp_bitmap_tilemaps, cliprect, 1 << 1);
419	417	else if (scr_pri == 0)
420	418	if (m_tilemaplayoutcontrol&1)
421	419	{
r20931	r20932
429	427	m_tx_tilemap->draw(m_temp_bitmap_tilemaps, cliprect, 0, 1 << 2);
430	428
431	429	if (rot_pri == 1)
432		draw_roz(machine(), m_temp_bitmap_tilemaps, cliprect, 1 << 1);
	430	draw_roz(m_temp_bitmap_tilemaps, cliprect, 1 << 1);
433	431	else if (scr_pri == 1)
434	432	if (m_tilemaplayoutcontrol&1)
435	433	{
r20931	r20932
443	441	m_tx_tilemap->draw(m_temp_bitmap_tilemaps, cliprect, 0, 1 << 2);
444	442
445	443	if (rot_pri == 2)
446		draw_roz(machine(), m_temp_bitmap_tilemaps, cliprect, 1 << 1);
	444	draw_roz(m_temp_bitmap_tilemaps, cliprect, 1 << 1);
447	445	else if (scr_pri == 2)
448	446	if (m_tilemaplayoutcontrol&1)
449	447	{

trunk/src/mame/video/mcr3.c

r20931	r20932
194	194	*
195	195	*************************************/
196	196
197		static void mcr3_update_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int color_mask, int code_xor, int dx, int dy)
	197	void mcr3_state::mcr3_update_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int color_mask, int code_xor, int dx, int dy)
198	198	{
199		mcr3_state *state = machine.driver_data<mcr3_state>();
200		UINT8 *spriteram = state->m_spriteram;
	199	UINT8 *spriteram = m_spriteram;
201	200	int offs;
202	201
203		machine.priority_bitmap.fill(1, cliprect);
	202	machine().priority_bitmap.fill(1, cliprect);
204	203
205	204	/* loop over sprite RAM */
206		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	205	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
207	206	{
208	207	int code, color, flipx, flipy, sx, sy, flags;
209	208
r20931	r20932
241	240	if (!mcr_cocktail_flip)
242	241	{
243	242	/* first draw the sprite, visible */
244		pdrawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy,
245		machine.priority_bitmap, 0x00, 0x0101);
	243	pdrawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy,
	244	machine().priority_bitmap, 0x00, 0x0101);
246	245
247	246	/* then draw the mask, behind the background but obscuring following sprites */
248		pdrawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy,
249		machine.priority_bitmap, 0x02, 0xfeff);
	247	pdrawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy,
	248	machine().priority_bitmap, 0x02, 0xfeff);
250	249	}
251	250	else
252	251	{
253	252	/* first draw the sprite, visible */
254		pdrawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, !flipx, !flipy, 480 - sx, 452 - sy,
255		machine.priority_bitmap, 0x00, 0x0101);
	253	pdrawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, !flipx, !flipy, 480 - sx, 452 - sy,
	254	machine().priority_bitmap, 0x00, 0x0101);
256	255
257	256	/* then draw the mask, behind the background but obscuring following sprites */
258		pdrawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, !flipx, !flipy, 480 - sx, 452 - sy,
259		machine.priority_bitmap, 0x02, 0xfeff);
	257	pdrawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, !flipx, !flipy, 480 - sx, 452 - sy,
	258	machine().priority_bitmap, 0x02, 0xfeff);
260	259	}
261	260	}
262	261	}
r20931	r20932
278	277	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
279	278
280	279	/* draw the sprites */
281		mcr3_update_sprites(machine(), bitmap, cliprect, 0x03, 0, 0, 0);
	280	mcr3_update_sprites(bitmap, cliprect, 0x03, 0, 0, 0);
282	281	return 0;
283	282	}
284	283
r20931	r20932
292	291	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
293	292
294	293	/* draw the sprites */
295		mcr3_update_sprites(machine(), bitmap, cliprect, m_spyhunt_sprite_color_mask, 0, -12, 0);
	294	mcr3_update_sprites(bitmap, cliprect, m_spyhunt_sprite_color_mask, 0, -12, 0);
296	295
297	296	/* render any characters on top */
298	297	m_alpha_tilemap->draw(bitmap, cliprect, 0, 0);

trunk/src/mame/video/munchmo.c

r20931	r20932
46	46	m_tmpbitmap = auto_bitmap_ind16_alloc(machine(), 512, 512);
47	47	}
48	48
49		static void draw_status( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	49	void munchmo_state::draw_status( bitmap_ind16 &bitmap, const rectangle &cliprect )
50	50	{
51		munchmo_state *state = machine.driver_data<munchmo_state>();
52		gfx_element *gfx = machine.gfx[0];
	51	gfx_element *gfx = machine().gfx[0];
53	52	int row;
54	53
55	54	for (row = 0; row < 4; row++)
56	55	{
57	56	int sy, sx = (row & 1) * 8;
58		const UINT8 *source = state->m_status_vram + (~row & 1) * 32;
	57	const UINT8 *source = m_status_vram + (~row & 1) * 32;
59	58	if (row <= 1)
60	59	{
61	60	source += 2 * 32;
r20931	r20932
74	73	}
75	74	}
76	75
77		static void draw_background( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	76	void munchmo_state::draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect )
78	77	{
79	78	/*
80	79	ROM B1.2C contains 256 tilemaps defining 4x4 configurations of
81	80	the tiles in ROM B2.2B
82	81	*/
83		munchmo_state *state = machine.driver_data<munchmo_state>();
84		UINT8 *rom = state->memregion("gfx2")->base();
85		gfx_element *gfx = machine.gfx[1];
	82	UINT8 *rom = memregion("gfx2")->base();
	83	gfx_element *gfx = machine().gfx[1];
86	84	int offs;
87	85
88	86	for (offs = 0; offs < 0x100; offs++)
89	87	{
90	88	int sy = (offs % 16) * 32;
91	89	int sx = (offs / 16) * 32;
92		int tile_number = state->m_videoram[offs];
	90	int tile_number = m_videoram[offs];
93	91	int row, col;
94	92
95	93	for (row = 0; row < 4; row++)
96	94	{
97	95	for (col = 0; col < 4; col++)
98	96	{
99		drawgfx_opaque(*state->m_tmpbitmap, state->m_tmpbitmap->cliprect(), gfx,
	97	drawgfx_opaque(*m_tmpbitmap, m_tmpbitmap->cliprect(), gfx,
100	98	rom[col + tile_number * 4 + row * 0x400],
101		state->m_palette_bank,
	99	m_palette_bank,
102	100	0,0, /* flip */
103	101	sx + col * 8, sy + row * 8 );
104	102	}
r20931	r20932
106	104	}
107	105
108	106	{
109		int scrollx = -(state->m_vreg[6] *2 + (state->m_vreg[7] >> 7)) - 64 - 128 - 16;
	107	int scrollx = -(m_vreg[6] *2 + (m_vreg[7] >> 7)) - 64 - 128 - 16;
110	108	int scrolly = 0;
111	109
112		copyscrollbitmap(bitmap, *state->m_tmpbitmap, 1, &scrollx, 1, &scrolly, cliprect);
	110	copyscrollbitmap(bitmap, *m_tmpbitmap, 1, &scrollx, 1, &scrolly, cliprect);
113	111	}
114	112	}
115	113
116		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	114	void munchmo_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
117	115	{
118		munchmo_state *state = machine.driver_data<munchmo_state>();
119		int scroll = state->m_vreg[6];
120		int flags = state->m_vreg[7];                           /*   XB?????? */
	116	int scroll = m_vreg[6];
	117	int flags = m_vreg[7];                           /*   XB?????? */
121	118	int xadjust = - 128 - 16 - ((flags & 0x80) ? 1 : 0);
122	119	int bank = (flags & 0x40) ? 1 : 0;
123		gfx_element *gfx = machine.gfx[2 + bank];
124		int color_base = state->m_palette_bank * 4 + 3;
	120	gfx_element *gfx = machine().gfx[2 + bank];
	121	int color_base = m_palette_bank * 4 + 3;
125	122	int i, j;
126		int firstsprite = state->m_vreg[4] & 0x3f;
	123	int firstsprite = m_vreg[4] & 0x3f;
127	124	for (i = firstsprite; i < firstsprite + 0x40; i++)
128	125	{
129	126	for (j = 0; j < 8; j++)
130	127	{
131	128	int offs = (j << 6) | (i & 0x3f);
132		int tile_number = state->m_sprite_tile[offs];       /*   ETTTTTTT */
133		int attributes = state->m_sprite_attr[offs];        /*   XYYYYYCC */
134		int sx = state->m_sprite_xpos[offs];                /*   XXXXXXX? */
	129	int tile_number = m_sprite_tile[offs];       /*   ETTTTTTT */
	130	int attributes = m_sprite_attr[offs];        /*   XYYYYYCC */
	131	int sx = m_sprite_xpos[offs];                /*   XXXXXXX? */
135	132	int sy = (offs >> 6) << 5;                  /* Y YY------ */
136	133	sy += (attributes >> 2) & 0x1f;
137	134	if( attributes & 0x80 )
r20931	r20932
150	147
151	148	UINT32 munchmo_state::screen_update_mnchmobl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
152	149	{
153		draw_background(machine(), bitmap, cliprect);
154		draw_sprites(machine(), bitmap, cliprect);
155		draw_status(machine(), bitmap, cliprect);
	150	draw_background(bitmap, cliprect);
	151	draw_sprites(bitmap, cliprect);
	152	draw_status(bitmap, cliprect);
156	153	return 0;
157	154	}

trunk/src/mame/video/mrflea.c

r20931	r20932
39	39	m_spriteram[offset] = data;
40	40	}
41	41
42		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	42	void mrflea_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
43	43	{
44		mrflea_state *state = machine.driver_data<mrflea_state>();
45		gfx_element *gfx = machine.gfx[0];
46		const UINT8 *source = state->m_spriteram;
	44	gfx_element *gfx = machine().gfx[0];
	45	const UINT8 *source = m_spriteram;
47	46	const UINT8 *finish = source + 0x100;
48		rectangle clip = machine.primary_screen->visible_area();
	47	rectangle clip = machine().primary_screen->visible_area();
49	48
50	49	clip.max_x -= 24;
51	50	clip.min_x += 16;
r20931	r20932
70	69	}
71	70	}
72	71
73		static void draw_background( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	72	void mrflea_state::draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect )
74	73	{
75		mrflea_state *state = machine.driver_data<mrflea_state>();
76		const UINT8 *source = state->m_videoram;
77		gfx_element *gfx = machine.gfx[1];
	74	const UINT8 *source = m_videoram;
	75	gfx_element *gfx = machine().gfx[1];
78	76	int sx, sy;
79	77	int base = 0;
80	78
81		if (BIT(state->m_gfx_bank, 2))
	79	if (BIT(m_gfx_bank, 2))
82	80	base |= 0x400;
83	81
84		if (BIT(state->m_gfx_bank, 4))
	82	if (BIT(m_gfx_bank, 4))
85	83	base |= 0x200;
86	84
87	85	for (sy = 0; sy < 256; sy += 8)
r20931	r20932
102	100
103	101	UINT32 mrflea_state::screen_update_mrflea(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
104	102	{
105		draw_background(machine(), bitmap, cliprect);
106		draw_sprites(machine(), bitmap, cliprect);
	103	draw_background(bitmap, cliprect);
	104	draw_sprites(bitmap, cliprect);
107	105	return 0;
108	106	}

trunk/src/mame/video/metro.c

r20931	r20932
139	139	/* This looks up a single pixel in a tile, given the tile code.
140	140	The Metro hardware has an indirection table, which is used here.
141	141	Returns if to draw the pixel or not, pixel colour is placed in pix */
142		INLINE UINT8 get_tile_pix( running_machine &machine, UINT16 code, UINT8 x, UINT8 y, int big, UINT16 *pix )
	142	inline UINT8 metro_state::get_tile_pix( UINT16 code, UINT8 x, UINT8 y, int big, UINT16 *pix )
143	143	{
144		metro_state *state = machine.driver_data<metro_state>();
145	144	int table_index;
146	145	UINT32 tile;
147	146
148	147	// Use code as an index into the tiles set table
149	148	table_index = ((code & 0x1ff0) >> 4) * 2;
150		tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1];
	149	tile = (m_tiletable[table_index + 0] << 16) + m_tiletable[table_index + 1];
151	150
152	151	if (code & 0x8000) // Special: draw a tile of a single color (i.e. not from the gfx ROMs)
153	152	{
r20931	r20932
158	157	else
159	158	return 0;
160	159	}
161		else if (((tile & 0x00f00000) == 0x00f00000)    && (state->m_support_8bpp)) /* draw tile as 8bpp (e.g. balcube bg) */
	160	else if (((tile & 0x00f00000) == 0x00f00000)    && (m_support_8bpp)) /* draw tile as 8bpp (e.g. balcube bg) */
162	161	{
163		gfx_element *gfx1 = machine.gfx[big?3:1];
	162	gfx_element *gfx1 = machine().gfx[big?3:1];
164	163	UINT32 tile2 = big ? ((tile & 0xfffff) + 8*(code & 0xf)) :
165	164	((tile & 0xfffff) + 2*(code & 0xf));
166	165	const UINT8* data;
r20931	r20932
192	191	}
193	192	else
194	193	{
195		gfx_element *gfx1 = machine.gfx[big?2:0];
	194	gfx_element *gfx1 = machine().gfx[big?2:0];
196	195	UINT32 tile2 = big ? ((tile & 0xfffff) + 4*(code & 0xf)) :
197	196	((tile & 0xfffff) +   (code & 0xf));
198	197	const UINT8* data;
r20931	r20932
228	227	}
229	228
230	229
231		INLINE void metro_vram_w( running_machine &machine, offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram )
	230	inline void metro_state::metro_vram_w( offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram )
232	231	{
233	232	COMBINE_DATA(&vram[offset]);
234	233	}
235	234
236		WRITE16_MEMBER(metro_state::metro_vram_0_w){ metro_vram_w(machine(), offset, data, mem_mask, 0, m_vram_0); }
237		WRITE16_MEMBER(metro_state::metro_vram_1_w){ metro_vram_w(machine(), offset, data, mem_mask, 1, m_vram_1); }
238		WRITE16_MEMBER(metro_state::metro_vram_2_w){ metro_vram_w(machine(), offset, data, mem_mask, 2, m_vram_2); }
	235	WRITE16_MEMBER(metro_state::metro_vram_0_w){ metro_vram_w(offset, data, mem_mask, 0, m_vram_0); }
	236	WRITE16_MEMBER(metro_state::metro_vram_1_w){ metro_vram_w(offset, data, mem_mask, 1, m_vram_1); }
	237	WRITE16_MEMBER(metro_state::metro_vram_2_w){ metro_vram_w(offset, data, mem_mask, 2, m_vram_2); }
239	238
240	239
241	240
r20931	r20932
408	407
409	408	***************************************************************************/
410	409
411		void metro_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	410	void metro_state::metro_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
412	411	{
413		metro_state *state = machine.driver_data<metro_state>();
414		UINT8 *base_gfx4 = state->m_expanded_gfx1;
415		UINT8 *base_gfx8 = state->memregion("gfx1")->base();
416		UINT32 gfx_size = state->memregion("gfx1")->bytes();
	412	UINT8 *base_gfx4 = m_expanded_gfx1;
	413	UINT8 *base_gfx8 = memregion("gfx1")->base();
	414	UINT32 gfx_size = memregion("gfx1")->bytes();
417	415
418		int max_x = machine.primary_screen->width();
419		int max_y = machine.primary_screen->height();
	416	int max_x = machine().primary_screen->width();
	417	int max_y = machine().primary_screen->height();
420	418
421		int max_sprites = state->m_spriteram.bytes() / 8;
422		int sprites     = state->m_videoregs[0x00/2] % max_sprites;
	419	int max_sprites = m_spriteram.bytes() / 8;
	420	int sprites     = m_videoregs[0x00/2] % max_sprites;
423	421
424		int color_start = (state->m_videoregs[0x08/2] & 0x0f) << 4;
	422	int color_start = (m_videoregs[0x08/2] & 0x0f) << 4;
425	423
426	424	int i, j, pri;
427	425	static const int primask[4] = { 0x0000, 0xff00, 0xff00 | 0xf0f0, 0xff00 | 0xf0f0 | 0xcccc };
r20931	r20932
434	432
435	433	for (i = 0; i < 0x20; i++)
436	434	{
437		if (!(state->m_videoregs[0x02/2] & 0x8000))
	435	if (!(m_videoregs[0x02/2] & 0x8000))
438	436	{
439		src = state->m_spriteram + (sprites - 1) * (8 / 2);
	437	src = m_spriteram + (sprites - 1) * (8 / 2);
440	438	inc = -(8 / 2);
441	439	} else {
442		src = state->m_spriteram;
	440	src = m_spriteram;
443	441	inc = (8 / 2);
444	442	}
445	443
r20931	r20932
467	465	continue;
468	466	}
469	467
470		pri = (state->m_videoregs[0x02/2] & 0x0300) >> 8;
	468	pri = (m_videoregs[0x02/2] & 0x0300) >> 8;
471	469
472		if (!(state->m_videoregs[0x02/2] & 0x8000))
	470	if (!(m_videoregs[0x02/2] & 0x8000))
473	471	{
474		if (curr_pri > (state->m_videoregs[0x02/2] & 0x1f))
475		pri = (state->m_videoregs[0x02/2] & 0x0c00) >> 10;
	472	if (curr_pri > (m_videoregs[0x02/2] & 0x1f))
	473	pri = (m_videoregs[0x02/2] & 0x0c00) >> 10;
476	474	}
477	475
478	476	y     = src[1];
r20931	r20932
485	483
486	484	zoom = zoomtable[(y & 0xfc00) >> 10] << (16 - 8);
487	485
488		x = (x & 0x07ff) - state->m_sprite_xoffs;
489		y = (y & 0x03ff) - state->m_sprite_yoffs;
	486	x = (x & 0x07ff) - m_sprite_xoffs;
	487	y = (y & 0x03ff) - m_sprite_yoffs;
490	488
491	489	width  = (((attr >> 11) & 0x7) + 1) * 8;
492	490	height = (((attr >>  8) & 0x7) + 1) * 8;
493	491
494	492	UINT32 gfxstart = (8 * 8 * 4 / 8) * (((attr & 0x000f) << 16) + code);
495	493
496		if (state->m_flip_screen)
	494	if (m_flip_screen)
497	495	{
498	496	flipx = !flipx;     x = max_x - x - width;
499	497	flipy = !flipy;     y = max_y - y - height;
500	498	}
501	499
502		if (state->m_support_8bpp && color == 0xf)  /* 8bpp */
	500	if (m_support_8bpp && color == 0xf)  /* 8bpp */
503	501	{
504	502	/* Bounds checking */
505	503	if ((gfxstart + width * height - 1) >= gfx_size)
506	504	continue;
507	505
508		gfx_element gfx(machine, base_gfx8 + gfxstart, width, height, width, 0, 256);
	506	gfx_element gfx(machine(), base_gfx8 + gfxstart, width, height, width, 0, 256);
509	507
510	508	pdrawgfxzoom_transpen(  bitmap,cliprect, &gfx,
511	509	0,
r20931	r20932
513	511	flipx, flipy,
514	512	x, y,
515	513	zoom, zoom,
516		machine.priority_bitmap,primask[pri], 255);
	514	machine().priority_bitmap,primask[pri], 255);
517	515	}
518	516	else
519	517	{
r20931	r20932
521	519	if ((gfxstart + width / 2 * height - 1) >= gfx_size)
522	520	continue;
523	521
524		gfx_element gfx(machine, base_gfx4 + 2 * gfxstart, width, height, width, 0, 16);
	522	gfx_element gfx(machine(), base_gfx4 + 2 * gfxstart, width, height, width, 0, 16);
525	523
526	524	pdrawgfxzoom_transpen(  bitmap,cliprect, &gfx,
527	525	0,
r20931	r20932
529	527	flipx, flipy,
530	528	x, y,
531	529	zoom, zoom,
532		machine.priority_bitmap,primask[pri], 15);
	530	machine().priority_bitmap,primask[pri], 15);
533	531	}
534	532	#if 0
535	533	{   /* Display priority + zoom on each sprite */
r20931	r20932
555	553
556	554	// Copy a 'window' from the large 2048x2048 (or 4096x4096 for 16x16 tiles) tilemap
557	555
558		static void draw_tilemap( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 flags, UINT32 pcode,
	556	void metro_state::draw_tilemap( bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 flags, UINT32 pcode,
559	557	int sx, int sy, int wx, int wy, int big, UINT16 *tilemapram, int layer )
560	558	{
561		metro_state *state = machine.driver_data<metro_state>();
562	559	int y;
563	560
564		bitmap_ind8 &priority_bitmap = machine.priority_bitmap;
	561	bitmap_ind8 &priority_bitmap = machine().priority_bitmap;
565	562
566	563	int width  = big ? 4096 : 2048;
567	564	int height = big ? 4096 : 2048;
r20931	r20932
572	569	int windowwidth  = width >> 2;
573	570	int windowheight = height >> 3;
574	571
575		sx += state->m_tilemap_scrolldx[layer] * (state->m_flip_screen ? 1 : -1);
	572	sx += m_tilemap_scrolldx[layer] * (m_flip_screen ? 1 : -1);
576	573
577	574	for (y = 0; y < scrheight; y++)
578	575	{
r20931	r20932
583	580	int srcline = (wy+scrolly)&(height-1);
584	581	int srctilerow = srcline >> (big ? 4 : 3);
585	582
586		if (!state->m_flip_screen)
	583	if (!m_flip_screen)
587	584	{
588	585	dst = &bitmap.pix16(y);
589	586	priority_baseaddr = &priority_bitmap.pix8(y);
r20931	r20932
598	595	UINT16 dat = 0;
599	596
600	597	UINT16 tile = tilemapram[tileoffs];
601		UINT8 draw = get_tile_pix(machine, tile, big ? (srccol&0xf) : (srccol&0x7), big ? (srcline&0xf) : (srcline&0x7), big, &dat);
	598	UINT8 draw = get_tile_pix(tile, big ? (srccol&0xf) : (srccol&0x7), big ? (srcline&0xf) : (srcline&0x7), big, &dat);
602	599
603	600	if (draw)
604	601	{
r20931	r20932
622	619	UINT16 dat = 0;
623	620
624	621	UINT16 tile = tilemapram[tileoffs];
625		UINT8 draw = get_tile_pix(machine, tile, big ? (srccol&0xf) : (srccol&0x7), big ? (srcline&0xf) : (srcline&0x7), big, &dat);
	622	UINT8 draw = get_tile_pix(tile, big ? (srccol&0xf) : (srccol&0x7), big ? (srcline&0xf) : (srcline&0x7), big, &dat);
626	623
627	624	if (draw)
628	625	{
r20931	r20932
636	633
637	634	// Draw all the layers that match the given priority
638	635
639		static void draw_layers( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl )
	636	void metro_state::draw_layers( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl )
640	637	{
641		metro_state *state = machine.driver_data<metro_state>();
642		UINT16 layers_pri = state->m_videoregs[0x10 / 2];
	638	UINT16 layers_pri = m_videoregs[0x10 / 2];
643	639	int layer;
644	640
645	641	// Draw all the layers with priority == pri
r20931	r20932
648	644	if (pri == ((layers_pri >> (layer * 2)) & 3))
649	645	{
650	646	// Scroll and Window values
651		UINT16 sy = state->m_scroll[layer * 2 + 0]; UINT16 sx = state->m_scroll[layer * 2 + 1];
652		UINT16 wy = state->m_window[layer * 2 + 0]; UINT16 wx = state->m_window[layer * 2 + 1];
	647	UINT16 sy = m_scroll[layer * 2 + 0]; UINT16 sx = m_scroll[layer * 2 + 1];
	648	UINT16 wy = m_window[layer * 2 + 0]; UINT16 wx = m_window[layer * 2 + 1];
653	649
654	650	if (BIT(layers_ctrl, layer))    // for debug
655	651	{
r20931	r20932
657	653
658	654	switch (layer)
659	655	{
660		case 0: tilemapram = state->m_vram_0;   break;
661		case 1: tilemapram = state->m_vram_1;   break;
662		case 2: tilemapram = state->m_vram_2;   break;
	656	case 0: tilemapram = m_vram_0;   break;
	657	case 1: tilemapram = m_vram_1;   break;
	658	case 2: tilemapram = m_vram_2;   break;
663	659	}
664	660
665		int big = state->m_support_16x16 && (*state->m_screenctrl & (0x0020 << layer));
	661	int big = m_support_16x16 && (*m_screenctrl & (0x0020 << layer));
666	662
667		draw_tilemap(machine, bitmap, cliprect, 0, 1 << (3 - pri), sx, sy, wx, wy, big, tilemapram, layer);
	663	draw_tilemap(bitmap, cliprect, 0, 1 << (3 - pri), sx, sy, wx, wy, big, tilemapram, layer);
668	664	}
669	665	}
670	666	}
r20931	r20932
723	719	k053936_zoom_draw(m_k053936, bitmap, cliprect, m_k053936_tilemap, 0, 0, 1);
724	720
725	721	for (pri = 3; pri >= 0; pri--)
726		draw_layers(machine(), bitmap, cliprect, pri, layers_ctrl);
	722	draw_layers(bitmap, cliprect, pri, layers_ctrl);
727	723
728	724	if (layers_ctrl & 0x08)
729		metro_draw_sprites(machine(), bitmap, cliprect);
	725	metro_draw_sprites(bitmap, cliprect);
730	726
731	727	return 0;
732	728	}

trunk/src/mame/video/mikie.c

r20931	r20932
138	138	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(mikie_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
139	139	}
140	140
141		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	141	void mikie_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
142	142	{
143		mikie_state *state = machine.driver_data<mikie_state>();
144		UINT8 *spriteram = state->m_spriteram;
	143	UINT8 *spriteram = m_spriteram;
145	144	int offs;
146	145
147		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	146	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
148	147	{
149	148	int gfxbank = (spriteram[offs + 2] & 0x40) ? 2 : 1;
150	149	int code = (spriteram[offs + 2] & 0x3f) + ((spriteram[offs + 2] & 0x80) >> 1) + ((spriteram[offs] & 0x40) << 1);
151		int color = (spriteram[offs] & 0x0f) + 16 * state->m_palettebank;
	150	int color = (spriteram[offs] & 0x0f) + 16 * m_palettebank;
152	151	int sx = spriteram[offs + 3];
153	152	int sy = 244 - spriteram[offs + 1];
154	153	int flipx = ~spriteram[offs] & 0x10;
155	154	int flipy = spriteram[offs] & 0x20;
156	155
157		if (state->flip_screen())
	156	if (flip_screen())
158	157	{
159	158	sy = 242 - sy;
160	159	flipy = !flipy;
161	160	}
162	161
163	162	drawgfx_transpen(bitmap, cliprect,
164		machine.gfx[gfxbank],
	163	machine().gfx[gfxbank],
165	164	code, color,
166	165	flipx,flipy,
167	166	sx,sy, 0);
r20931	r20932
171	170	UINT32 mikie_state::screen_update_mikie(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
172	171	{
173	172	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(0), 0);
174		draw_sprites(machine(), bitmap, cliprect);
	173	draw_sprites(bitmap, cliprect);
175	174	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1), 0);
176	175	return 0;
177	176	}

trunk/src/mame/video/madalien.c

r20931	r20932
65	65	}
66	66
67	67
68		INLINE int scan_helper(int col, int row, int section)
	68	inline int madalien_state::scan_helper(int col, int row, int section)
69	69	{
70	70	return (section << 8) | ((~col & 0x0f) << 3) | row;
71	71	}
r20931	r20932
159	159	}
160	160
161	161
162		static void draw_edges(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int flip, int scroll_mode)
	162	void madalien_state::draw_edges(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip, int scroll_mode)
163	163	{
164		madalien_state *state = machine.driver_data<madalien_state>();
165	164	rectangle clip_edge1;
166	165	rectangle clip_edge2;
167	166
r20931	r20932
170	169
171	170	if (flip)
172	171	{
173		clip_edge1.min_y = *state->m_edge1_pos | 0x80;
174		clip_edge2.max_y = (*state->m_edge2_pos & 0x7f) ^ 0x7f;
	172	clip_edge1.min_y = *m_edge1_pos | 0x80;
	173	clip_edge2.max_y = (*m_edge2_pos & 0x7f) ^ 0x7f;
175	174	}
176	175	else
177	176	{
178		clip_edge1.max_y = (*state->m_edge1_pos & 0x7f) ^ 0x7f;
179		clip_edge2.min_y = *state->m_edge2_pos | 0x80;
	177	clip_edge1.max_y = (*m_edge1_pos & 0x7f) ^ 0x7f;
	178	clip_edge2.min_y = *m_edge2_pos | 0x80;
180	179	}
181	180
182	181	clip_edge1 &= cliprect;
183	182	clip_edge2 &= cliprect;
184	183
185		state->m_tilemap_edge1[scroll_mode]->mark_all_dirty();
186		state->m_tilemap_edge2[scroll_mode]->mark_all_dirty();
	184	m_tilemap_edge1[scroll_mode]->mark_all_dirty();
	185	m_tilemap_edge2[scroll_mode]->mark_all_dirty();
187	186
188		state->m_tilemap_edge1[scroll_mode]->set_flip(flip ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);
189		state->m_tilemap_edge1[scroll_mode]->set_scrollx(0, -(*state->m_scroll & 0xfc));
190		state->m_tilemap_edge1[scroll_mode]->set_scrolly(0, *state->m_edge1_pos & 0x7f);
	187	m_tilemap_edge1[scroll_mode]->set_flip(flip ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);
	188	m_tilemap_edge1[scroll_mode]->set_scrollx(0, -(*m_scroll & 0xfc));
	189	m_tilemap_edge1[scroll_mode]->set_scrolly(0, *m_edge1_pos & 0x7f);
191	190
192		state->m_tilemap_edge2[scroll_mode]->set_flip(flip ? TILEMAP_FLIPX : TILEMAP_FLIPY);
193		state->m_tilemap_edge2[scroll_mode]->set_scrollx(0, -(*state->m_scroll & 0xfc));
194		state->m_tilemap_edge2[scroll_mode]->set_scrolly(0, *state->m_edge2_pos & 0x7f);
	191	m_tilemap_edge2[scroll_mode]->set_flip(flip ? TILEMAP_FLIPX : TILEMAP_FLIPY);
	192	m_tilemap_edge2[scroll_mode]->set_scrollx(0, -(*m_scroll & 0xfc));
	193	m_tilemap_edge2[scroll_mode]->set_scrolly(0, *m_edge2_pos & 0x7f);
195	194
196		state->m_tilemap_edge1[scroll_mode]->draw(bitmap, clip_edge1, 0, 0);
197		state->m_tilemap_edge2[scroll_mode]->draw(bitmap, clip_edge2, 0, 0);
	195	m_tilemap_edge1[scroll_mode]->draw(bitmap, clip_edge1, 0, 0);
	196	m_tilemap_edge2[scroll_mode]->draw(bitmap, clip_edge2, 0, 0);
198	197	}
199	198
200	199
201		static void draw_headlight(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
	200	void madalien_state::draw_headlight(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
202	201	{
203		madalien_state *state = machine.driver_data<madalien_state>();
204		if (BIT(*state->m_video_flags, 0))
	202	if (BIT(*m_video_flags, 0))
205	203	{
206	204	UINT8 y;
207	205
208	206	for (y = 0; y < 0x80; y++)
209	207	{
210	208	UINT8 x;
211		UINT8 hy = y - *state->m_headlight_pos;
	209	UINT8 hy = y - *m_headlight_pos;
212	210
213	211	if (flip)
214	212	hy = ~hy;
r20931	r20932
226	224	if ((hx < cliprect.min_x) || (hx > cliprect.max_x))
227	225	continue;
228	226
229		if (state->m_headlight_bitmap->pix16(y, x) != 0)
	227	if (m_headlight_bitmap->pix16(y, x) != 0)
230	228	bitmap.pix16(hy, hx) |= 8;
231	229	}
232	230	}
r20931	r20932
234	232	}
235	233
236	234
237		static void draw_foreground(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
	235	void madalien_state::draw_foreground(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
238	236	{
239		madalien_state *state = machine.driver_data<madalien_state>();
240		state->m_tilemap_fg->set_flip(flip ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);
241		state->m_tilemap_fg->draw(bitmap, cliprect, 0, 0);
	237	m_tilemap_fg->set_flip(flip ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);
	238	m_tilemap_fg->draw(bitmap, cliprect, 0, 0);
242	239	}
243	240
244	241
r20931	r20932
263	260	int scroll_mode = *m_scroll & 3;
264	261
265	262	bitmap.fill(0, cliprect);
266		draw_edges(machine(), bitmap, cliprect, flip, scroll_mode);
267		draw_foreground(machine(), bitmap, cliprect, flip);
	263	draw_edges(bitmap, cliprect, flip, scroll_mode);
	264	draw_foreground(bitmap, cliprect, flip);
268	265
269	266	/* highlight section A (outside of tunnels).
270	267	* also, bit 1 of the video_flags register (6A) is
r20931	r20932
298	295	bitmap.pix16(y, x) |= 8;
299	296	}
300	297
301		draw_headlight(machine(), bitmap, cliprect, flip);
	298	draw_headlight(bitmap, cliprect, flip);
302	299
303	300	return 0;
304	301	}

trunk/src/mame/video/mrjong.c

r20931	r20932
107	107	/*
108	108	Note: First 0x40 entries in the videoram are actually spriteram
109	109	*/
110		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	110	void mrjong_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
111	111	{
112		mrjong_state *state = machine.driver_data<mrjong_state>();
113	112	int offs;
114	113
115	114	for (offs = (0x40 - 4); offs >= 0; offs -= 4)
r20931	r20932
119	118	int sx, sy;
120	119	int flipx, flipy;
121	120
122		sprt = (((state->m_videoram[offs + 1] >> 2) & 0x3f) | ((state->m_videoram[offs + 3] & 0x20) << 1));
123		flipx = (state->m_videoram[offs + 1] & 0x01) >> 0;
124		flipy = (state->m_videoram[offs + 1] & 0x02) >> 1;
125		color = (state->m_videoram[offs + 3] & 0x1f);
	121	sprt = (((m_videoram[offs + 1] >> 2) & 0x3f) | ((m_videoram[offs + 3] & 0x20) << 1));
	122	flipx = (m_videoram[offs + 1] & 0x01) >> 0;
	123	flipy = (m_videoram[offs + 1] & 0x02) >> 1;
	124	color = (m_videoram[offs + 3] & 0x1f);
126	125
127		sx = 224 - state->m_videoram[offs + 2];
128		sy = state->m_videoram[offs + 0];
129		if (state->flip_screen())
	126	sx = 224 - m_videoram[offs + 2];
	127	sy = m_videoram[offs + 0];
	128	if (flip_screen())
130	129	{
131	130	sx = 208 - sx;
132	131	sy = 240 - sy;
r20931	r20932
134	133	flipy = !flipy;
135	134	}
136	135
137		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	136	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
138	137	sprt,
139	138	color,
140	139	flipx, flipy,
r20931	r20932
145	144	UINT32 mrjong_state::screen_update_mrjong(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
146	145	{
147	146	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
148		draw_sprites(machine(), bitmap, cliprect);
	147	draw_sprites(bitmap, cliprect);
149	148	return 0;
150	149	}

trunk/src/mame/video/meadows.c

r20931	r20932
74	74	*
75	75	*************************************/
76	76
77		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &clip)
	77	void meadows_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &clip)
78	78	{
79		meadows_state *state = machine.driver_data<meadows_state>();
80		UINT8 *spriteram = state->m_spriteram;
	79	UINT8 *spriteram = m_spriteram;
81	80	int i;
82	81
83	82	for (i = 0; i < 4; i++)
r20931	r20932
89	88	int bank = i;                           /* that fixes it for now :-/ */
90	89	int flip = spriteram[i+8] >> 5;         /* bit #5 flip vertical flag */
91	90
92		drawgfx_transpen(bitmap, clip, machine.gfx[bank + 1], code, 0, flip, 0, x, y, 0);
	91	drawgfx_transpen(bitmap, clip, machine().gfx[bank + 1], code, 0, flip, 0, x, y, 0);
93	92	}
94	93	}
95	94
r20931	r20932
108	107
109	108	/* draw the sprites */
110	109	if (machine().gfx[1])
111		draw_sprites(machine(), bitmap, cliprect);
	110	draw_sprites(bitmap, cliprect);
112	111	return 0;
113	112	}

trunk/src/mame/video/m52.c

r20931	r20932
290	290	*
291	291	*************************************/
292	292
293		void draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int xpos, int ypos, int image)
	293	void m52_state::draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect, int xpos, int ypos, int image)
294	294	{
295	295	rectangle rect;
296		const rectangle &visarea = machine.primary_screen->visible_area();
	296	const rectangle &visarea = machine().primary_screen->visible_area();
297	297
298		m52_state *state = machine.driver_data<m52_state>();
299	298
300		if (state->flip_screen())
	299	if (flip_screen())
301	300	{
302	301	xpos = 127 - xpos;
303	302	ypos = 255 - ypos - BGHEIGHT;
r20931	r20932
309	308	ypos = ypos + (22 - 8);
310	309
311	310	drawgfx_transpen(bitmap, cliprect,
312		machine.gfx[image],
	311	machine().gfx[image],
313	312	0, 0,
314		state->flip_screen(),
315		state->flip_screen(),
	313	flip_screen(),
	314	flip_screen(),
316	315	xpos,
317	316	ypos, 0);
318	317
319	318	drawgfx_transpen(bitmap, cliprect,
320		machine.gfx[image],
	319	machine().gfx[image],
321	320	0, 0,
322		state->flip_screen(),
323		state->flip_screen(),
	321	flip_screen(),
	322	flip_screen(),
324	323	xpos - 256,
325	324	ypos, 0);
326	325
327	326	rect.min_x = visarea.min_x;
328	327	rect.max_x = visarea.max_x;
329	328
330		if (state->flip_screen())
	329	if (flip_screen())
331	330	{
332	331	rect.min_y = ypos - BGHEIGHT;
333	332	rect.max_y = ypos - 1;
r20931	r20932
338	337	rect.max_y = ypos + 2 * BGHEIGHT - 1;
339	338	}
340	339
341		bitmap.fill(machine.gfx[image]->colorbase() + 3, rect);
	340	bitmap.fill(machine().gfx[image]->colorbase() + 3, rect);
342	341	}
343	342
344	343
r20931	r20932
358	357	if (!(m_bgcontrol & 0x20))
359	358	{
360	359	if (!(m_bgcontrol & 0x10))
361		draw_background(machine(), bitmap, cliprect, m_bg2xpos, m_bg2ypos, 2); /* distant mountains */
	360	draw_background(bitmap, cliprect, m_bg2xpos, m_bg2ypos, 2); /* distant mountains */
362	361
363	362	if (!(m_bgcontrol & 0x02))
364		draw_background(machine(), bitmap, cliprect, m_bg1xpos, m_bg1ypos, 3); /* hills */
	363	draw_background(bitmap, cliprect, m_bg1xpos, m_bg1ypos, 3); /* hills */
365	364
366	365	if (!(m_bgcontrol & 0x04))
367		draw_background(machine(), bitmap, cliprect, m_bg1xpos, m_bg1ypos, 4); /* cityscape */
	366	draw_background(bitmap, cliprect, m_bg1xpos, m_bg1ypos, 4); /* cityscape */
368	367	}
369	368
370	369	m_bg_tilemap->set_flip(flip_screen() ? TILEMAP_FLIPX | TILEMAP_FLIPY : 0);

trunk/src/mame/video/mustache.c

r20931	r20932
96	96	m_bg_tilemap->set_scroll_rows(4);
97	97	}
98	98
99		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	99	void mustache_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
100	100	{
101		mustache_state *state = machine.driver_data<mustache_state>();
102	101	rectangle clip = cliprect;
103		gfx_element *gfx = machine.gfx[1];
104		const rectangle &visarea = machine.primary_screen->visible_area();
105		UINT8 *spriteram = state->m_spriteram;
	102	gfx_element *gfx = machine().gfx[1];
	103	const rectangle &visarea = machine().primary_screen->visible_area();
	104	UINT8 *spriteram = m_spriteram;
106	105	int offs;
107	106
108		for (offs = 0;offs < state->m_spriteram.bytes();offs += 4)
	107	for (offs = 0;offs < m_spriteram.bytes();offs += 4)
109	108	{
110	109	int sy = 240-spriteram[offs];
111	110	int sx = 240-spriteram[offs+3];
r20931	r20932
117	116
118	117	code+=(attr&0x0c)<<6;
119	118
120		if ((state->m_control_byte & 0xa))
	119	if ((m_control_byte & 0xa))
121	120	clip.max_y = visarea.max_y;
122	121	else
123		if (state->flip_screen())
	122	if (flip_screen())
124	123	clip.min_y = visarea.min_y + 56;
125	124	else
126	125	clip.max_y = visarea.max_y - 56;
127	126
128		if (state->flip_screen())
	127	if (flip_screen())
129	128	{
130	129	sx = 240 - sx;
131	130	sy = 240 - sy;
r20931	r20932
134	133	drawgfx_transpen(bitmap,clip,gfx,
135	134	code,
136	135	color,
137		state->flip_screen(),state->flip_screen(),
	136	flip_screen(),flip_screen(),
138	137	sx,sy,0);
139	138	}
140	139	}
r20931	r20932
142	141	UINT32 mustache_state::screen_update_mustache(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
143	142	{
144	143	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
145		draw_sprites(machine(), bitmap, cliprect);
	144	draw_sprites(bitmap, cliprect);
146	145	return 0;
147	146	}

trunk/src/mame/video/msisaac.c

r20931	r20932
147	147	Display refresh
148	148
149	149	***************************************************************************/
150		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	150	void msisaac_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
151	151	{
152		msisaac_state *state = machine.driver_data<msisaac_state>();
153		const UINT8 *source = state->m_spriteram + 32 * 4 - 4;
154		const UINT8 *finish = state->m_spriteram; /* ? */
	152	const UINT8 *source = m_spriteram + 32 * 4 - 4;
	153	const UINT8 *finish = m_spriteram; /* ? */
155	154
156	155	while (source >= finish)
157	156	{
r20931	r20932
164	163	int flipx = (attributes & 0x1);
165	164	int flipy = (attributes & 0x2);
166	165
167		gfx_element *gfx = machine.gfx[2];
	166	gfx_element *gfx = machine().gfx[2];
168	167
169	168	if (attributes & 4)
170	169	{
171	170	//color = rand() & 15;
172		gfx = machine.gfx[3];
	171	gfx = machine().gfx[3];
173	172	}
174	173
175	174	if (attributes & 8) /* double size sprite */
r20931	r20932
234	233	{
235	234	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
236	235	m_bg2_tilemap->draw(bitmap, cliprect, 0, 0);
237		draw_sprites(machine(), bitmap, cliprect);
	236	draw_sprites(bitmap, cliprect);
238	237	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
239	238	return 0;
240	239	}

trunk/src/mame/video/markham.c

r20931	r20932
71	71	m_bg_tilemap->set_scroll_rows(32);
72	72	}
73	73
74		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	74	void markham_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
75	75	{
76		markham_state *state = machine.driver_data<markham_state>();
77		UINT8 *spriteram = state->m_spriteram;
	76	UINT8 *spriteram = m_spriteram;
78	77	int offs;
79	78
80	79	for (offs = 0x60; offs < 0x100; offs += 4)
r20931	r20932
82	81	int chr = spriteram[offs + 1];
83	82	int col = spriteram[offs + 2];
84	83
85		int fx = state->flip_screen();
86		int fy = state->flip_screen();
	84	int fx = flip_screen();
	85	int fy = flip_screen();
87	86
88	87	int x = spriteram[offs + 3];
89	88	int y = spriteram[offs + 0];
90	89	int px, py;
91	90	col &= 0x3f ;
92	91
93		if (state->flip_screen() == 0)
	92	if (flip_screen() == 0)
94	93	{
95	94	px = x - 2;
96	95	py = 240 - y;
r20931	r20932
106	105	if (px > 248)
107	106	px = px - 256;
108	107
109		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	108	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
110	109	chr,
111	110	col,
112	111	fx,fy,
113	112	px,py,
114		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], col, 0));
	113	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], col, 0));
115	114	}
116	115	}
117	116
r20931	r20932
128	127	}
129	128
130	129	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
131		draw_sprites(machine(), bitmap, cliprect);
	130	draw_sprites(bitmap, cliprect);
132	131	return 0;
133	132	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team