Previous

199869 Revisions

Next

r21024 Wednesday 13th February, 2013 at 10:46:49 UTC by Miodrag Milanović
Modernization of drivers part 20 (no whatsnew)

[src/mame/drivers]	vball.c vendetta.c vicdual.c videopin.c volfied.c
[src/mame/includes]	undrfire.h unico.h vaportra.h vastar.h vball.h vectrex.h vendetta.h vertigo.h vicdual.h victory.h videopin.h vigilant.h volfied.h vsnes.h vulgus.h
[src/mame/machine]	vectrex.c vertigo.c volfied.c vsnes.c
[src/mame/video]	undrfire.c unico.c vaportra.c vastar.c vball.c vertigo.c vicdual.c victory.c vigilant.c volfied.c vulgus.c

trunk/src/mame/drivers/vendetta.c

r21023	r21024
99	99
100	100	/* prototypes */
101	101	static KONAMI_SETLINES_CALLBACK( vendetta_banking );
102		static void vendetta_video_banking( running_machine &machine, int select );
103	102
104	103	/***************************************************************************
105	104
r21023	r21024
138	137
139	138	m_irq_enabled = (data >> 6) & 1;
140	139
141		vendetta_video_banking(machine(), data & 1);
	140	vendetta_video_banking(data & 1);
142	141	}
143	142
144	143	/********************************************/
r21023	r21024
160	159	}
161	160
162	161
163		static void vendetta_video_banking( running_machine &machine, int select )
	162	void vendetta_state::vendetta_video_banking( int select )
164	163	{
165		vendetta_state *state = machine.driver_data<vendetta_state>();
166		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	164	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
167	165
168	166	if (select & 1)
169	167	{
170		space.install_read_bank(state->m_video_banking_base + 0x2000, state->m_video_banking_base + 0x2fff, "bank4" );
171		space.install_write_handler(state->m_video_banking_base + 0x2000, state->m_video_banking_base + 0x2fff, write8_delegate(FUNC(vendetta_state::paletteram_xBBBBBGGGGGRRRRR_byte_be_w), state) );
172		space.install_legacy_readwrite_handler(*state->m_k053246, state->m_video_banking_base + 0x0000, state->m_video_banking_base + 0x0fff, FUNC(k053247_r), FUNC(k053247_w) );
173		state->membank("bank4")->set_base(state->m_generic_paletteram_8);
	168	space.install_read_bank(m_video_banking_base + 0x2000, m_video_banking_base + 0x2fff, "bank4" );
	169	space.install_write_handler(m_video_banking_base + 0x2000, m_video_banking_base + 0x2fff, write8_delegate(FUNC(vendetta_state::paletteram_xBBBBBGGGGGRRRRR_byte_be_w), this) );
	170	space.install_legacy_readwrite_handler(*m_k053246, m_video_banking_base + 0x0000, m_video_banking_base + 0x0fff, FUNC(k053247_r), FUNC(k053247_w) );
	171	membank("bank4")->set_base(m_generic_paletteram_8);
174	172	}
175	173	else
176	174	{
177		space.install_readwrite_handler(state->m_video_banking_base + 0x2000, state->m_video_banking_base + 0x2fff, read8_delegate(FUNC(vendetta_state::vendetta_K052109_r),state), write8_delegate(FUNC(vendetta_state::vendetta_K052109_w),state) );
178		space.install_legacy_readwrite_handler(*state->m_k052109, state->m_video_banking_base + 0x0000, state->m_video_banking_base + 0x0fff, FUNC(k052109_r), FUNC(k052109_w) );
	175	space.install_readwrite_handler(m_video_banking_base + 0x2000, m_video_banking_base + 0x2fff, read8_delegate(FUNC(vendetta_state::vendetta_K052109_r),this), write8_delegate(FUNC(vendetta_state::vendetta_K052109_w),this) );
	176	space.install_legacy_readwrite_handler(*m_k052109, m_video_banking_base + 0x0000, m_video_banking_base + 0x0fff, FUNC(k052109_r), FUNC(k052109_w) );
179	177	}
180	178	}
181	179
r21023	r21024
492	490	m_irq_enabled = 0;
493	491
494	492	/* init banks */
495		vendetta_video_banking(machine(), 0);
	493	vendetta_video_banking(0);
496	494	}
497	495
498	496	static MACHINE_CONFIG_START( vendetta, vendetta_state )

trunk/src/mame/drivers/vicdual.c

r21023	r21024
135	135	*
136	136	*************************************/
137	137
138		static int get_vcounter(running_machine &machine)
	138	int vicdual_state::get_vcounter()
139	139	{
140		int vcounter = machine.primary_screen->vpos();
	140	int vcounter = machine().primary_screen->vpos();
141	141
142	142	/* the vertical synch counter gets incremented at the end of HSYNC,
143	143	compensate for this */
144		if (machine.primary_screen->hpos() >= VICDUAL_HSEND)
	144	if (machine().primary_screen->hpos() >= VICDUAL_HSEND)
145	145	vcounter = (vcounter + 1) % VICDUAL_VTOTAL;
146	146
147	147	return vcounter;
r21023	r21024
150	150
151	151	CUSTOM_INPUT_MEMBER(vicdual_state::vicdual_get_64v)
152	152	{
153		return (get_vcounter(machine()) >> 6) & 0x01;
	153	return (get_vcounter() >> 6) & 0x01;
154	154	}
155	155
156	156
157	157	CUSTOM_INPUT_MEMBER(vicdual_state::vicdual_get_vblank_comp)
158	158	{
159		return (get_vcounter(machine()) < VICDUAL_VBSTART);
	159	return (get_vcounter() < VICDUAL_VBSTART);
160	160	}
161	161
162	162
r21023	r21024
182	182	#define COLOR_BW_PORT_TAG       "COLOR_BW"
183	183
184	184
185		int vicdual_is_cabinet_color(running_machine &machine)
	185	int vicdual_state::vicdual_is_cabinet_color()
186	186	{
187		return (machine.root_device().ioport(COLOR_BW_PORT_TAG)->read_safe(0) & 1) ? 0 : 1;
	187	return (machine().root_device().ioport(COLOR_BW_PORT_TAG)->read_safe(0) & 1) ? 0 : 1;
188	188	}
189	189
190	190

trunk/src/mame/drivers/vball.c

r21023	r21024
94	94	#define PIXEL_CLOCK     MAIN_CLOCK / 2
95	95
96	96	/* Based on ddragon driver */
97		INLINE int scanline_to_vcount(int scanline)
	97	inline int vball_state::scanline_to_vcount(int scanline)
98	98	{
99	99	int vcount = scanline + 8;
100	100	if (vcount < 0x100)
r21023	r21024
162	162	if (m_gfxset != ((data  & 0x20) ^ 0x20))
163	163	{
164	164	m_gfxset = (data  & 0x20) ^ 0x20;
165		vb_mark_all_dirty(machine());
	165	vb_mark_all_dirty();
166	166	}
167	167	m_vb_scrolly_hi = (data & 0x40) << 2;
168	168	}
r21023	r21024
188	188	{
189	189	flip_screen_set(~data&1);
190	190	m_vb_scrollx_hi = (data & 0x02) << 7;
191		vb_bgprombank_w(machine(), (data >> 2) & 0x07);
192		vb_spprombank_w(machine(), (data >> 5) & 0x07);
	191	vb_bgprombank_w((data >> 2) & 0x07);
	192	vb_spprombank_w((data >> 5) & 0x07);
193	193	//logerror("%04x: vb_scrollx_hi = %d\n", space.device().safe_pcbase(), m_vb_scrollx_hi);
194	194	}
195	195

trunk/src/mame/drivers/videopin.c

r21023	r21024
22	22
23	23
24	24
25		static void update_plunger(running_machine &machine)
	25	void videopin_state::update_plunger()
26	26	{
27		videopin_state *state = machine.driver_data<videopin_state>();
28		UINT8 val = state->ioport("IN2")->read();
	27	UINT8 val = ioport("IN2")->read();
29	28
30		if (state->m_prev != val)
	29	if (m_prev != val)
31	30	{
32	31	if (val == 0)
33	32	{
34		state->m_time_released = machine.time();
	33	m_time_released = machine().time();
35	34
36		if (!state->m_mask)
37		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	35	if (!m_mask)
	36	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
38	37	}
39	38	else
40		state->m_time_pushed = machine.time();
	39	m_time_pushed = machine().time();
41	40
42		state->m_prev = val;
	41	m_prev = val;
43	42	}
44	43	}
45	44
r21023	r21024
48	47	{
49	48	int scanline = param;
50	49
51		update_plunger(machine());
	50	update_plunger();
52	51
53	52	machine().device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
54	53
r21023	r21024
72	71	}
73	72
74	73
75		static double calc_plunger_pos(running_machine &machine)
	74	double videopin_state::calc_plunger_pos()
76	75	{
77		videopin_state *state = machine.driver_data<videopin_state>();
78		return (machine.time().as_double() - state->m_time_released.as_double()) * (state->m_time_released.as_double() - state->m_time_pushed.as_double() + 0.2);
	76	return (machine().time().as_double() - m_time_released.as_double()) * (m_time_released.as_double() - m_time_pushed.as_double() + 0.2);
79	77	}
80	78
81	79
82	80	READ8_MEMBER(videopin_state::videopin_misc_r)
83	81	{
84		double plunger = calc_plunger_pos(machine());
	82	double plunger = calc_plunger_pos();
85	83
86	84	// The plunger of the ball shooter has a black piece of
87	85	// plastic (flag) attached to it. When the plunger flag passes

trunk/src/mame/drivers/volfied.c

r21023	r21024
233	233
234	234	void volfied_state::machine_start()
235	235	{
236		volfied_cchip_init(machine());
	236	volfied_cchip_init();
237	237
238	238	m_maincpu = machine().device<cpu_device>("maincpu");
239	239	m_audiocpu = machine().device<cpu_device>("audiocpu");
r21023	r21024
242	242
243	243	void volfied_state::machine_reset()
244	244	{
245		volfied_cchip_reset(machine());
	245	volfied_cchip_reset();
246	246	}
247	247
248	248	static const pc090oj_interface volfied_pc090oj_intf =

trunk/src/mame/machine/vectrex.c

r21023	r21024
48	48	static const double unknown_game_angles[3] = {0,0.16666666, 0.33333333};
49	49
50	50
51		static int vectrex_verify_cart(char *data)
	51	int vectrex_state::vectrex_verify_cart(char *data)
52	52	{
53	53	/* Verify the file is accepted by the Vectrex bios */
54	54	if (!memcmp(data,"g GCE", 5))

trunk/src/mame/machine/vsnes.c

r21023	r21024
163	163	*
164	164	*************************************/
165	165
166		static void v_set_videorom_bank( running_machine& machine, int start, int count, int vrom_start_bank )
	166	void vsnes_state::v_set_videorom_bank(  int start, int count, int vrom_start_bank )
167	167	{
168		vsnes_state *state = machine.driver_data<vsnes_state>();
169	168	int i;
170	169
171	170	assert(start + count <= 8);
172	171
173		vrom_start_bank &= (state->m_vrom_banks - 1);
174		assert(vrom_start_bank + count <= state->m_vrom_banks);
	172	vrom_start_bank &= (m_vrom_banks - 1);
	173	assert(vrom_start_bank + count <= m_vrom_banks);
175	174
176	175	/* bank_size_in_kb is used to determine how large the "bank" parameter is */
177	176	/* count determines the size of the area mapped */
178	177	for (i = 0; i < count; i++)
179	178	{
180		state->membank(chr_banknames[i + start])->set_entry(vrom_start_bank + i);
	179	membank(chr_banknames[i + start])->set_entry(vrom_start_bank + i);
181	180	}
182	181	}
183	182
r21023	r21024
210	209	ppu1_space.install_read_bank(0x0400 * i, 0x0400 * i + 0x03ff, chr_banknames[i]);
211	210	membank(chr_banknames[i])->configure_entries(0, m_vrom_banks, m_vrom[0], 0x400);
212	211	}
213		v_set_videorom_bank(machine(), 0, 8, 0);
	212	v_set_videorom_bank(0, 8, 0);
214	213	}
215	214	else
216	215	{
r21023	r21024
325	324	WRITE8_MEMBER(vsnes_state::vsnormal_vrom_banking)
326	325	{
327	326	/* switch vrom */
328		v_set_videorom_bank(machine(), 0, 8, (data & 4) ? 8 : 0);
	327	v_set_videorom_bank(0, 8, (data & 4) ? 8 : 0);
329	328
330	329	/* bit 1 ( data & 2 ) enables writes to extra ram, we ignore it */
331	330
r21023	r21024
349	348	if (m_do_vrom_bank)
350	349	{
351	350	/* switch vrom */
352		v_set_videorom_bank(machine(), 0, 8, (data & 4) ? 8 : 0);
	351	v_set_videorom_bank(0, 8, (data & 4) ? 8 : 0);
353	352	}
354	353
355	354	/* here we do things a little different */
r21023	r21024
415	414	break;
416	415
417	416	case 6: /* vrom bank 0 */
418		v_set_videorom_bank(machine(), 0, 4, data * 4);
	417	v_set_videorom_bank(0, 4, data * 4);
419	418	break;
420	419
421	420	case 7: /* vrom bank 1 */
422		v_set_videorom_bank(machine(), 4, 4, data * 4);
	421	v_set_videorom_bank(4, 4, data * 4);
423	422	break;
424	423	}
425	424	}
r21023	r21024
539	538
540	539	case 1: /* video rom banking - bank 0 - 4k or 8k */
541	540	if (!m_vram)
542		v_set_videorom_bank(machine(), 0, (m_vrom4k) ? 4 : 8, m_drmario_shiftreg * 4);
	541	v_set_videorom_bank(0, (m_vrom4k) ? 4 : 8, m_drmario_shiftreg * 4);
543	542	break;
544	543
545	544	case 2: /* video rom banking - bank 1 - 4k only */
546	545	if (m_vrom4k && !m_vram)
547		v_set_videorom_bank(machine(), 4, 4, m_drmario_shiftreg * 4);
	546	v_set_videorom_bank(4, 4, m_drmario_shiftreg * 4);
548	547	break;
549	548
550	549	case 3: /* program banking */
r21023	r21024
621	620	/**********************************************************************************/
622	621
623	622
624		static void mapper4_set_prg( running_machine &machine )
	623	void vsnes_state::mapper4_set_prg(  )
625	624	{
626		vsnes_state *state = machine.driver_data<vsnes_state>();
627		UINT8 *prg = state->memregion("maincpu")->base();
628		UINT8 prg_flip = (state->m_MMC3_cmd & 0x40) ? 2 : 0;
	625	UINT8 *prg = memregion("maincpu")->base();
	626	UINT8 prg_flip = (m_MMC3_cmd & 0x40) ? 2 : 0;
629	627
630		memcpy(&prg[0x8000], &prg[0x2000 * (state->m_MMC3_prg_bank[0 ^ prg_flip] & state->m_MMC3_prg_mask) + 0x10000], 0x2000);
631		memcpy(&prg[0xa000], &prg[0x2000 * (state->m_MMC3_prg_bank[1] & state->m_MMC3_prg_mask) + 0x10000], 0x2000);
632		memcpy(&prg[0xc000], &prg[0x2000 * (state->m_MMC3_prg_bank[2 ^ prg_flip] & state->m_MMC3_prg_mask) + 0x10000], 0x2000);
633		memcpy(&prg[0xe000], &prg[0x2000 * (state->m_MMC3_prg_bank[3] & state->m_MMC3_prg_mask) + 0x10000], 0x2000);
	628	memcpy(&prg[0x8000], &prg[0x2000 * (m_MMC3_prg_bank[0 ^ prg_flip] & m_MMC3_prg_mask) + 0x10000], 0x2000);
	629	memcpy(&prg[0xa000], &prg[0x2000 * (m_MMC3_prg_bank[1] & m_MMC3_prg_mask) + 0x10000], 0x2000);
	630	memcpy(&prg[0xc000], &prg[0x2000 * (m_MMC3_prg_bank[2 ^ prg_flip] & m_MMC3_prg_mask) + 0x10000], 0x2000);
	631	memcpy(&prg[0xe000], &prg[0x2000 * (m_MMC3_prg_bank[3] & m_MMC3_prg_mask) + 0x10000], 0x2000);
634	632	}
635	633
636		static void mapper4_set_chr( running_machine &machine )
	634	void vsnes_state::mapper4_set_chr(  )
637	635	{
638		vsnes_state *state = machine.driver_data<vsnes_state>();
639		UINT8 chr_page = (state->m_MMC3_cmd & 0x80) >> 5;
	636	UINT8 chr_page = (m_MMC3_cmd & 0x80) >> 5;
640	637
641		v_set_videorom_bank(machine, chr_page ^ 0, 1, state->m_MMC3_chr_bank[0] & ~0x01);
642		v_set_videorom_bank(machine, chr_page ^ 1, 1, state->m_MMC3_chr_bank[0] |  0x01);
643		v_set_videorom_bank(machine, chr_page ^ 2, 1, state->m_MMC3_chr_bank[1] & ~0x01);
644		v_set_videorom_bank(machine, chr_page ^ 3, 1, state->m_MMC3_chr_bank[1] |  0x01);
645		v_set_videorom_bank(machine, chr_page ^ 4, 1, state->m_MMC3_chr_bank[2]);
646		v_set_videorom_bank(machine, chr_page ^ 5, 1, state->m_MMC3_chr_bank[3]);
647		v_set_videorom_bank(machine, chr_page ^ 6, 1, state->m_MMC3_chr_bank[4]);
648		v_set_videorom_bank(machine, chr_page ^ 7, 1, state->m_MMC3_chr_bank[5]);
	638	v_set_videorom_bank(chr_page ^ 0, 1, m_MMC3_chr_bank[0] & ~0x01);
	639	v_set_videorom_bank(chr_page ^ 1, 1, m_MMC3_chr_bank[0] |  0x01);
	640	v_set_videorom_bank(chr_page ^ 2, 1, m_MMC3_chr_bank[1] & ~0x01);
	641	v_set_videorom_bank(chr_page ^ 3, 1, m_MMC3_chr_bank[1] |  0x01);
	642	v_set_videorom_bank(chr_page ^ 4, 1, m_MMC3_chr_bank[2]);
	643	v_set_videorom_bank(chr_page ^ 5, 1, m_MMC3_chr_bank[3]);
	644	v_set_videorom_bank(chr_page ^ 6, 1, m_MMC3_chr_bank[4]);
	645	v_set_videorom_bank(chr_page ^ 7, 1, m_MMC3_chr_bank[5]);
649	646	}
650	647
651	648	#define BOTTOM_VISIBLE_SCANLINE 239     /* The bottommost visible scanline */
r21023	r21024
684	681
685	682	/* Has PRG Mode changed? */
686	683	if (MMC3_helper & 0x40)
687		mapper4_set_prg(machine());
	684	mapper4_set_prg();
688	685
689	686	/* Has CHR Mode changed? */
690	687	if (MMC3_helper & 0x80)
691		mapper4_set_chr(machine());
	688	mapper4_set_chr();
692	689	break;
693	690
694	691	case 0x0001: /* $8001 */
r21023	r21024
698	695	case 0: case 1: // these do not need to be separated: we take care of them in set_chr!
699	696	case 2: case 3: case 4: case 5:
700	697	m_MMC3_chr_bank[cmd] = data;
701		mapper4_set_chr(machine());
	698	mapper4_set_chr();
702	699	break;
703	700	case 6:
704	701	case 7:
705	702	m_MMC3_prg_bank[cmd - 6] = data;
706		mapper4_set_prg(machine());
	703	mapper4_set_prg();
707	704	break;
708	705	}
709	706	break;
r21023	r21024
915	912	switch (offset & 0x7000)
916	913	{
917	914	case 0x0000:
918		v_set_videorom_bank(machine(), 0, 2, data * 2);
	915	v_set_videorom_bank(0, 2, data * 2);
919	916
920	917	break;
921	918	case 0x1000:
922		v_set_videorom_bank(machine(), 2, 2, data * 2);
	919	v_set_videorom_bank(2, 2, data * 2);
923	920
924	921	break;
925	922	case 0x2000:
926		v_set_videorom_bank(machine(), 4, 2, data * 2);
	923	v_set_videorom_bank(4, 2, data * 2);
927	924
928	925	break;
929	926	case 0x3000: /* ok? */
930		v_set_videorom_bank(machine(), 6, 2, data * 2);
	927	v_set_videorom_bank(6, 2, data * 2);
931	928
932	929	break;
933	930

trunk/src/mame/machine/volfied.c

r21023	r21024
478	478	*
479	479	*************************************/
480	480
481		void volfied_cchip_init( running_machine &machine )
	481	void volfied_state::volfied_cchip_init(  )
482	482	{
483		volfied_state *state = machine.driver_data<volfied_state>();
484	483
485		state->m_cchip_ram = auto_alloc_array_clear(machine, UINT8, 0x400 * 8);
	484	m_cchip_ram = auto_alloc_array_clear(machine(), UINT8, 0x400 * 8);
486	485
487		state->save_item(NAME(state->m_current_bank));
488		state->save_item(NAME(state->m_current_cmd));
489		state->save_item(NAME(state->m_current_flag));
490		state->save_item(NAME(state->m_cc_port));
491		state->save_pointer(NAME(state->m_cchip_ram), 0x400 * 8);
	486	save_item(NAME(m_current_bank));
	487	save_item(NAME(m_current_cmd));
	488	save_item(NAME(m_current_flag));
	489	save_item(NAME(m_cc_port));
	490	save_pointer(NAME(m_cchip_ram), 0x400 * 8);
492	491	}
493	492
494		void volfied_cchip_reset( running_machine &machine )
	493	void volfied_state::volfied_cchip_reset(  )
495	494	{
496		volfied_state *state = machine.driver_data<volfied_state>();
497	495
498		state->m_current_bank = 0;
499		state->m_current_flag = 0;
500		state->m_cc_port = 0;
501		state->m_current_cmd = 0;
	496	m_current_bank = 0;
	497	m_current_flag = 0;
	498	m_cc_port = 0;
	499	m_current_cmd = 0;
502	500	}

trunk/src/mame/machine/vertigo.c

r21023	r21024
79	79	}
80	80
81	81
82		static void update_irq_encoder(running_machine &machine, int line, int state)
	82	void vertigo_state::update_irq_encoder(int line, int state)
83	83	{
84		vertigo_state *drvstate = machine.driver_data<vertigo_state>();
85		ttl74148_input_line_w(drvstate->m_ttl74148, line, !state);
86		ttl74148_update(drvstate->m_ttl74148);
	84	ttl74148_input_line_w(m_ttl74148, line, !state);
	85	ttl74148_update(m_ttl74148);
87	86	}
88	87
89	88
90	89	WRITE_LINE_MEMBER(vertigo_state::v_irq4_w)
91	90	{
92		update_irq_encoder(machine(), INPUT_LINE_IRQ4, state);
93		vertigo_vproc(machine(), machine().device<cpu_device>("maincpu")->attotime_to_cycles(machine().time() - m_irq4_time), state);
	91	update_irq_encoder(INPUT_LINE_IRQ4, state);
	92	vertigo_vproc(machine().device<cpu_device>("maincpu")->attotime_to_cycles(machine().time() - m_irq4_time), state);
94	93	m_irq4_time = machine().time();
95	94	}
96	95
r21023	r21024
100	99	if (state)
101	100	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
102	101
103		update_irq_encoder(machine(), INPUT_LINE_IRQ3, state);
	102	update_irq_encoder(INPUT_LINE_IRQ3, state);
104	103	}
105	104
106	105
r21023	r21024
120	119	else
121	120	m_adc_result = ioport(adcnames[offset])->read();
122	121
123		update_irq_encoder(machine(), INPUT_LINE_IRQ2, ASSERT_LINE);
	122	update_irq_encoder(INPUT_LINE_IRQ2, ASSERT_LINE);
124	123	return 0;
125	124	}
126	125
127	126
128	127	READ16_MEMBER(vertigo_state::vertigo_io_adc)
129	128	{
130		update_irq_encoder(machine(), INPUT_LINE_IRQ2, CLEAR_LINE);
	129	update_irq_encoder(INPUT_LINE_IRQ2, CLEAR_LINE);
131	130	return m_adc_result;
132	131	}
133	132
134	133
135	134	READ16_MEMBER(vertigo_state::vertigo_coin_r)
136	135	{
137		update_irq_encoder(machine(), INPUT_LINE_IRQ6, CLEAR_LINE);
	136	update_irq_encoder(INPUT_LINE_IRQ6, CLEAR_LINE);
138	137	return (ioport("COIN")->read());
139	138	}
140	139
r21023	r21024
143	142	{
144	143	/* Coin inputs cause IRQ6 */
145	144	if ((machine().root_device().ioport("COIN")->read() & 0x7) < 0x7)
146		update_irq_encoder(machine(), INPUT_LINE_IRQ6, ASSERT_LINE);
	145	update_irq_encoder(INPUT_LINE_IRQ6, ASSERT_LINE);
147	146	}
148	147
149	148
r21023	r21024
205	204	state_save_register_global(machine(), m_adc_result);
206	205	state_save_register_global(machine(), m_irq4_time);
207	206
208		vertigo_vproc_init(machine());
	207	vertigo_vproc_init();
209	208	}
210	209
211	210	void vertigo_state::machine_reset()
r21023	r21024
218	217	ttl74148_input_line_w(m_ttl74148, i, 1);
219	218
220	219	ttl74148_update(m_ttl74148);
221		vertigo_vproc_reset(machine());
	220	vertigo_vproc_reset();
222	221
223	222	m_irq4_time = machine().time();
224	223	m_irq_state = 7;

trunk/src/mame/video/vicdual.c

r21023	r21024
138	138
139	139	UINT32 vicdual_state::screen_update_vicdual_bw_or_color(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
140	140	{
141		if (vicdual_is_cabinet_color(machine()))
	141	if (vicdual_is_cabinet_color())
142	142	screen_update_vicdual_color(screen, bitmap, cliprect);
143	143	else
144	144	screen_update_vicdual_bw(screen, bitmap, cliprect);

trunk/src/mame/video/vaportra.c

r21023	r21024
23	23
24	24	/******************************************************************************/
25	25
26		static void update_24bitcol( running_machine &machine, int offset )
	26	void vaportra_state::update_24bitcol( int offset )
27	27	{
28		vaportra_state *state = machine.driver_data<vaportra_state>();
29	28	UINT8 r, g, b;
30	29
31		r = (state->m_generic_paletteram_16[offset] >> 0) & 0xff;
32		g = (state->m_generic_paletteram_16[offset] >> 8) & 0xff;
33		b = (state->m_generic_paletteram2_16[offset] >> 0) & 0xff;
	30	r = (m_generic_paletteram_16[offset] >> 0) & 0xff;
	31	g = (m_generic_paletteram_16[offset] >> 8) & 0xff;
	32	b = (m_generic_paletteram2_16[offset] >> 0) & 0xff;
34	33
35		palette_set_color(machine, offset, MAKE_RGB(r,g,b));
	34	palette_set_color(machine(), offset, MAKE_RGB(r,g,b));
36	35	}
37	36
38	37	WRITE16_MEMBER(vaportra_state::vaportra_palette_24bit_rg_w)
39	38	{
40	39	COMBINE_DATA(&m_generic_paletteram_16[offset]);
41		update_24bitcol(machine(), offset);
	40	update_24bitcol(offset);
42	41	}
43	42
44	43	WRITE16_MEMBER(vaportra_state::vaportra_palette_24bit_b_w)
45	44	{
46	45	COMBINE_DATA(&m_generic_paletteram2_16[offset]);
47		update_24bitcol(machine(), offset);
	46	update_24bitcol(offset);
48	47	}
49	48
50	49	/******************************************************************************/

trunk/src/mame/video/victory.c

r21023	r21024
21	21	#define LOG_MICROCODE       0
22	22	#define LOG_COLLISION       0
23	23
24
25		/* function prototypes */
26		static int command2(running_machine &machine);
27		static int command3(running_machine &machine);
28		static int command4(running_machine &machine);
29		static int command5(running_machine &machine);
30		static int command6(running_machine &machine);
31		static int command7(running_machine &machine);
32
33
34
35	24	/*************************************
36	25	*
37	26	*  Initialize the video system
r21023	r21024
70	59	*
71	60	*************************************/
72	61
73		static void victory_update_irq(running_machine &machine)
	62	void victory_state::victory_update_irq()
74	63	{
75		victory_state *state = machine.driver_data<victory_state>();
76		if (state->m_vblank_irq || state->m_fgcoll || (state->m_bgcoll && (state->m_video_control & 0x20)))
77		machine.device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
	64	if (m_vblank_irq || m_fgcoll || (m_bgcoll && (m_video_control & 0x20)))
	65	machine().device("maincpu")->execute().set_input_line(0, ASSERT_LINE);
78	66	else
79		machine.device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
	67	machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
80	68	}
81	69
82	70
r21023	r21024
84	72	{
85	73	m_vblank_irq = 1;
86	74
87		victory_update_irq(machine());
	75	victory_update_irq();
88	76	}
89	77
90	78
r21023	r21024
101	89	}
102	90
103	91
104		static void set_palette(running_machine &machine)
	92	void victory_state::set_palette()
105	93	{
106		victory_state *state = machine.driver_data<victory_state>();
107	94	offs_t offs;
108	95
109	96	for (offs = 0; offs < 0x40; offs++)
110	97	{
111		UINT16 data = state->m_paletteram[offs];
	98	UINT16 data = m_paletteram[offs];
112	99
113		palette_set_color_rgb(machine, offs, pal3bit(data >> 6), pal3bit(data >> 0), pal3bit(data >> 3));
	100	palette_set_color_rgb(machine(), offs, pal3bit(data >> 6), pal3bit(data >> 0), pal3bit(data >> 3));
114	101	}
115	102	}
116	103
r21023	r21024
138	125	if (m_fgcoll)
139	126	{
140	127	m_fgcoll = 0;
141		victory_update_irq(machine());
	128	victory_update_irq();
142	129	}
143	130	if (LOG_COLLISION) logerror("%04X:5CLFIQ read = %02X\n", space.device().safe_pcbase(), result);
144	131	return result;
r21023	r21024
153	140	if (m_bgcoll)
154	141	{
155	142	m_bgcoll = 0;
156		victory_update_irq(machine());
	143	victory_update_irq();
157	144	}
158	145	if (LOG_COLLISION) logerror("%04X:5BACKY read = %02X\n", space.device().safe_pcbase(), result);
159	146	return result;
r21023	r21024
204	191	if (micro.cmdlo == 5)
205	192	{
206	193	if (LOG_MICROCODE) logerror("  Command 5 triggered by write to IH\n");
207		command5(machine());
	194	command5();
208	195	}
209	196	break;
210	197
r21023	r21024
219	206	else if (micro.cmdlo == 6)
220	207	{
221	208	if (LOG_MICROCODE) logerror("  Command 6 triggered\n");
222		command6(machine());
	209	command6();
223	210	}
224	211	break;
225	212
r21023	r21024
234	221	if (micro.cmdlo == 3)
235	222	{
236	223	if (LOG_MICROCODE) logerror(" Command 3 triggered by write to X\n");
237		command3(machine());
	224	command3();
238	225	}
239	226	break;
240	227
r21023	r21024
244	231	if (micro.cmdlo == 4)
245	232	{
246	233	if (LOG_MICROCODE) logerror("  Command 4 triggered by write to Y\n");
247		command4(machine());
	234	command4();
248	235	}
249	236	break;
250	237
r21023	r21024
259	246	if (micro.cmdlo == 2)
260	247	{
261	248	if (LOG_MICROCODE) logerror("  Command 2 triggered by write to B\n");
262		command2(machine());
	249	command2();
263	250	}
264	251	else if (micro.cmdlo == 7)
265	252	{
266	253	if (LOG_MICROCODE) logerror("  Command 7 triggered by write to B\n");
267		command7(machine());
	254	command7();
268	255	}
269	256	break;
270	257
r21023	r21024
293	280	case 0x0b:  /* CLRVIRQ */
294	281	if (LOG_MICROCODE) logerror("%04X:CLRVIRQ write = %02X\n", space.device().safe_pcbase(), data);
295	282	m_vblank_irq = 0;
296		victory_update_irq(machine());
	283	victory_update_irq();
297	284	break;
298	285
299	286	default:
r21023	r21024
525	512	*
526	513	*************************************/
527	514
528		static int command2(running_machine &machine)
	515	int victory_state::command2()
529	516	{
530		victory_state *state = machine.driver_data<victory_state>();
531		struct micro_t &micro = state->m_micro;
	517	struct micro_t &micro = m_micro;
532	518	/*
533	519	Actual microcode:
534	520	02    00                    0   0  ZERORAM, INCI, SWVRAM
r21023	r21024
541	527	int addr = micro.i++ & 0x3fff;
542	528
543	529	if (micro.cmd & 0x10)
544		state->m_gram[addr] = micro.g;
	530	m_gram[addr] = micro.g;
545	531	if (micro.cmd & 0x20)
546		state->m_bram[addr] = micro.b;
	532	m_bram[addr] = micro.b;
547	533	if (micro.cmd & 0x40)
548		state->m_rram[addr] = micro.r;
	534	m_rram[addr] = micro.r;
549	535
550	536	count_states(micro, 3);
551	537	return 0;
r21023	r21024
559	545	*
560	546	*************************************/
561	547
562		static int command3(running_machine &machine)
	548	int victory_state::command3()
563	549	{
564		victory_state *state = machine.driver_data<victory_state>();
565		struct micro_t &micro = state->m_micro;
	550	struct micro_t &micro = m_micro;
566	551	/*
567	552	Actual microcode:
568	553	03    1C                    2   0  SLOADLH, SXFERY
r21023	r21024
601	586	UINT8 src;
602	587
603	588	/* non-collision-detect case */
604		if (!(micro.cmd & 0x08) || state->m_fgcoll)
	589	if (!(micro.cmd & 0x08) || m_fgcoll)
605	590	{
606	591	if (micro.cmd & 0x10)
607	592	{
608		src = state->m_gram[srcoffs];
609		state->m_gram[dstoffs + 0] ^= src >> shift;
610		state->m_gram[dstoffs + 1] ^= src << nshift;
	593	src = m_gram[srcoffs];
	594	m_gram[dstoffs + 0] ^= src >> shift;
	595	m_gram[dstoffs + 1] ^= src << nshift;
611	596	}
612	597	if (micro.cmd & 0x20)
613	598	{
614		src = state->m_bram[srcoffs];
615		state->m_bram[dstoffs + 0] ^= src >> shift;
616		state->m_bram[dstoffs + 1] ^= src << nshift;
	599	src = m_bram[srcoffs];
	600	m_bram[dstoffs + 0] ^= src >> shift;
	601	m_bram[dstoffs + 1] ^= src << nshift;
617	602	}
618	603	if (micro.cmd & 0x40)
619	604	{
620		src = state->m_rram[srcoffs];
621		state->m_rram[dstoffs + 0] ^= src >> shift;
622		state->m_rram[dstoffs + 1] ^= src << nshift;
	605	src = m_rram[srcoffs];
	606	m_rram[dstoffs + 0] ^= src >> shift;
	607	m_rram[dstoffs + 1] ^= src << nshift;
623	608	}
624	609	}
625	610
r21023	r21024
628	613	{
629	614	if (micro.cmd & 0x10)
630	615	{
631		src = state->m_gram[srcoffs];
632		if ((state->m_gram[dstoffs + 0] & (src >> shift)) | (state->m_gram[dstoffs + 1] & (src << nshift)))
633		state->m_fgcoll = 1, state->m_fgcollx = micro.xp, state->m_fgcolly = sy - 1;
634		state->m_gram[dstoffs + 0] ^= src >> shift;
635		state->m_gram[dstoffs + 1] ^= src << nshift;
	616	src = m_gram[srcoffs];
	617	if ((m_gram[dstoffs + 0] & (src >> shift)) | (m_gram[dstoffs + 1] & (src << nshift)))
	618	m_fgcoll = 1, m_fgcollx = micro.xp, m_fgcolly = sy - 1;
	619	m_gram[dstoffs + 0] ^= src >> shift;
	620	m_gram[dstoffs + 1] ^= src << nshift;
636	621	}
637	622	if (micro.cmd & 0x20)
638	623	{
639		src = state->m_bram[srcoffs];
640		if ((state->m_bram[dstoffs + 0] & (src >> shift)) | (state->m_bram[dstoffs + 1] & (src << nshift)))
641		state->m_fgcoll = 1, state->m_fgcollx = micro.xp, state->m_fgcolly = sy - 1;
642		state->m_bram[dstoffs + 0] ^= src >> shift;
643		state->m_bram[dstoffs + 1] ^= src << nshift;
	624	src = m_bram[srcoffs];
	625	if ((m_bram[dstoffs + 0] & (src >> shift)) | (m_bram[dstoffs + 1] & (src << nshift)))
	626	m_fgcoll = 1, m_fgcollx = micro.xp, m_fgcolly = sy - 1;
	627	m_bram[dstoffs + 0] ^= src >> shift;
	628	m_bram[dstoffs + 1] ^= src << nshift;
644	629	}
645	630	if (micro.cmd & 0x40)
646	631	{
647		src = state->m_rram[srcoffs];
648		if ((state->m_rram[dstoffs + 0] & (src >> shift)) | (state->m_rram[dstoffs + 1] & (src << nshift)))
649		state->m_fgcoll = 1, state->m_fgcollx = micro.xp, state->m_fgcolly = sy - 1;
650		state->m_rram[dstoffs + 0] ^= src >> shift;
651		state->m_rram[dstoffs + 1] ^= src << nshift;
	632	src = m_rram[srcoffs];
	633	if ((m_rram[dstoffs + 0] & (src >> shift)) | (m_rram[dstoffs + 1] & (src << nshift)))
	634	m_fgcoll = 1, m_fgcollx = micro.xp, m_fgcolly = sy - 1;
	635	m_rram[dstoffs + 0] ^= src >> shift;
	636	m_rram[dstoffs + 1] ^= src << nshift;
652	637	}
653		if (state->m_fgcoll) victory_update_irq(machine);
	638	if (m_fgcoll) victory_update_irq();
654	639	}
655	640	}
656	641	}
r21023	r21024
668	653	*
669	654	*************************************/
670	655
671		static int command4(running_machine &machine)
	656	int victory_state::command4()
672	657	{
673		victory_state *state = machine.driver_data<victory_state>();
674		struct micro_t &micro = state->m_micro;
	658	struct micro_t &micro = m_micro;
675	659	/*
676	660	Actual microcode:
677	661	04    1A                    2   0  SLOADPC
r21023	r21024
698	682	micro.pc = micro.yp << 1;
699	683	do
700	684	{
701		micro.cmd = state->m_gram[0x2000 + micro.pc];
	685	micro.cmd = m_gram[0x2000 + micro.pc];
702	686	micro.cmdlo = micro.cmd & 7;
703		micro.i = (state->m_bram[0x2000 + micro.pc] << 8) | state->m_rram[0x2000 + micro.pc];
704		micro.r = state->m_gram[0x2001 + micro.pc];
705		micro.xp = state->m_rram[0x2001 + micro.pc];
706		micro.yp = state->m_bram[0x2001 + micro.pc];
	687	micro.i = (m_bram[0x2000 + micro.pc] << 8) | m_rram[0x2000 + micro.pc];
	688	micro.r = m_gram[0x2001 + micro.pc];
	689	micro.xp = m_rram[0x2001 + micro.pc];
	690	micro.yp = m_bram[0x2001 + micro.pc];
707	691	if (LOG_MICROCODE) logerror("PC=%03X  CMD=%02X I=%04X R=%02X X=%02X Y=%02X\n", micro.pc, micro.cmd, micro.i, micro.r, micro.xp, micro.yp);
708	692	micro.pc = (micro.pc + 2) & 0x1ff;
709	693
r21023	r21024
711	695	{
712	696	case 0:                                             break;
713	697	case 1:                                             break;
714		case 2: keep_going = command2(machine);                 break;
715		case 3: keep_going = command3(machine);             break;
	698	case 2: keep_going = command2();                 break;
	699	case 3: keep_going = command3();             break;
716	700	case 4: micro.pc = micro.yp << 1; keep_going = 1;   break;
717		case 5: keep_going = command5(machine);             break;
718		case 6: keep_going = command6(machine);                 break;
719		case 7: keep_going = command7(machine);             break;
	701	case 5: keep_going = command5();             break;
	702	case 6: keep_going = command6();                 break;
	703	case 7: keep_going = command7();             break;
720	704	}
721	705	} while (keep_going);
722	706
r21023	r21024
733	717	*
734	718	*************************************/
735	719
736		static int command5(running_machine &machine)
	720	int victory_state::command5()
737	721	{
738		victory_state *state = machine.driver_data<victory_state>();
739		struct micro_t &micro = state->m_micro;
	722	struct micro_t &micro = m_micro;
740	723	/*
741	724	Actual microcode:
742	725	05    0A                    1   0  SXFERY, ADD128+SACCCLEAR, SACCCLK
r21023	r21024
790	773	int c;
791	774
792	775	/* non-collision-detect case */
793		if (!(micro.cmd & 0x08) || state->m_fgcoll)
	776	if (!(micro.cmd & 0x08) || m_fgcoll)
794	777	{
795	778	for (c = micro.i & 0xff; c < 0x100; c++)
796	779	{
r21023	r21024
798	781	int shift = x & 7;
799	782	int nshift = 8 - shift;
800	783
801		state->m_gram[addr + 0] ^= micro.g >> shift;
802		state->m_gram[addr + 1] ^= micro.g << nshift;
803		state->m_bram[addr + 0] ^= micro.b >> shift;
804		state->m_bram[addr + 1] ^= micro.b << nshift;
805		state->m_rram[addr + 0] ^= micro.r >> shift;
806		state->m_rram[addr + 1] ^= micro.r << nshift;
	784	m_gram[addr + 0] ^= micro.g >> shift;
	785	m_gram[addr + 1] ^= micro.g << nshift;
	786	m_bram[addr + 0] ^= micro.b >> shift;
	787	m_bram[addr + 1] ^= micro.b << nshift;
	788	m_rram[addr + 0] ^= micro.r >> shift;
	789	m_rram[addr + 1] ^= micro.r << nshift;
807	790
808	791	acc += i;
809	792	if (acc & 0x100)
r21023	r21024
829	812	int shift = x & 7;
830	813	int nshift = 8 - shift;
831	814
832		if ((state->m_gram[addr + 0] & (micro.g >> shift)) | (state->m_gram[addr + 1] & (micro.g << nshift)) |
833		(state->m_bram[addr + 0] & (micro.b >> shift)) | (state->m_bram[addr + 1] & (micro.b << nshift)) |
834		(state->m_rram[addr + 0] & (micro.r >> shift)) | (state->m_rram[addr + 1] & (micro.r << nshift)))
835		state->m_fgcoll = 1, state->m_fgcollx = x, state->m_fgcolly = y;
	815	if ((m_gram[addr + 0] & (micro.g >> shift)) | (m_gram[addr + 1] & (micro.g << nshift)) |
	816	(m_bram[addr + 0] & (micro.b >> shift)) | (m_bram[addr + 1] & (micro.b << nshift)) |
	817	(m_rram[addr + 0] & (micro.r >> shift)) | (m_rram[addr + 1] & (micro.r << nshift)))
	818	m_fgcoll = 1, m_fgcollx = x, m_fgcolly = y;
836	819
837		state->m_gram[addr + 0] ^= micro.g >> shift;
838		state->m_gram[addr + 1] ^= micro.g << nshift;
839		state->m_bram[addr + 0] ^= micro.b >> shift;
840		state->m_bram[addr + 1] ^= micro.b << nshift;
841		state->m_rram[addr + 0] ^= micro.r >> shift;
842		state->m_rram[addr + 1] ^= micro.r << nshift;
	820	m_gram[addr + 0] ^= micro.g >> shift;
	821	m_gram[addr + 1] ^= micro.g << nshift;
	822	m_bram[addr + 0] ^= micro.b >> shift;
	823	m_bram[addr + 1] ^= micro.b << nshift;
	824	m_rram[addr + 0] ^= micro.r >> shift;
	825	m_rram[addr + 1] ^= micro.r << nshift;
843	826
844	827	acc += i;
845	828	if (acc & 0x100)
r21023	r21024
854	837	}
855	838	acc &= 0xff;
856	839	}
857		if (state->m_fgcoll) victory_update_irq(machine);
	840	if (m_fgcoll) victory_update_irq();
858	841	}
859	842
860	843	micro.xp = x;
r21023	r21024
872	855	*
873	856	*************************************/
874	857
875		static int command6(running_machine &machine)
	858	int victory_state::command6()
876	859	{
877		victory_state *state = machine.driver_data<victory_state>();
878		struct micro_t &micro = state->m_micro;
	860	struct micro_t &micro = m_micro;
879	861	/*
880	862	Actual microcode:
881	863	06    0C                    0   0  SLOADLH, SLOADPC
r21023	r21024
903	885	micro.pc &= 0x1ff;
904	886
905	887	if (micro.cmd & 0x10)
906		state->m_gram[daddr] = state->m_gram[saddr];
	888	m_gram[daddr] = m_gram[saddr];
907	889	if (micro.cmd & 0x20)
908		state->m_bram[daddr] = state->m_bram[saddr];
	890	m_bram[daddr] = m_bram[saddr];
909	891	if (micro.cmd & 0x40)
910		state->m_rram[daddr] = state->m_rram[saddr];
	892	m_rram[daddr] = m_rram[saddr];
911	893	}
912	894
913	895	count_states(micro, 3 + 2 * (64 - (micro.r & 31) * 2));
r21023	r21024
923	905	*
924	906	*************************************/
925	907
926		static int command7(running_machine &machine)
	908	int victory_state::command7()
927	909	{
928		victory_state *state = machine.driver_data<victory_state>();
929		struct micro_t &micro = state->m_micro;
	910	struct micro_t &micro = m_micro;
930	911	/*
931	912	Actual microcode:
932	913	07    08                    1   0  SXFERY, SXFERX+INCX
r21023	r21024
945	926	int nshift = 8 - shift;
946	927
947	928	/* non-collision-detect case */
948		if (!(micro.cmd & 0x08) || state->m_fgcoll)
	929	if (!(micro.cmd & 0x08) || m_fgcoll)
949	930	{
950	931	if (micro.cmd & 0x10)
951	932	{
952		state->m_gram[addr + 0] ^= micro.g >> shift;
953		state->m_gram[addr + 1] ^= micro.g << nshift;
	933	m_gram[addr + 0] ^= micro.g >> shift;
	934	m_gram[addr + 1] ^= micro.g << nshift;
954	935	}
955	936	if (micro.cmd & 0x20)
956	937	{
957		state->m_bram[addr + 0] ^= micro.b >> shift;
958		state->m_bram[addr + 1] ^= micro.b << nshift;
	938	m_bram[addr + 0] ^= micro.b >> shift;
	939	m_bram[addr + 1] ^= micro.b << nshift;
959	940	}
960	941	if (micro.cmd & 0x40)
961	942	{
962		state->m_rram[addr + 0] ^= micro.r >> shift;
963		state->m_rram[addr + 1] ^= micro.r << nshift;
	943	m_rram[addr + 0] ^= micro.r >> shift;
	944	m_rram[addr + 1] ^= micro.r << nshift;
964	945	}
965	946	}
966	947
r21023	r21024
969	950	{
970	951	if (micro.cmd & 0x10)
971	952	{
972		if ((state->m_gram[addr + 0] & (micro.g >> shift)) | (state->m_gram[addr + 1] & (micro.g << nshift)))
973		state->m_fgcoll = 1, state->m_fgcollx = micro.xp + 8, state->m_fgcolly = micro.yp;
974		state->m_gram[addr + 0] ^= micro.g >> shift;
975		state->m_gram[addr + 1] ^= micro.g << nshift;
	953	if ((m_gram[addr + 0] & (micro.g >> shift)) | (m_gram[addr + 1] & (micro.g << nshift)))
	954	m_fgcoll = 1, m_fgcollx = micro.xp + 8, m_fgcolly = micro.yp;
	955	m_gram[addr + 0] ^= micro.g >> shift;
	956	m_gram[addr + 1] ^= micro.g << nshift;
976	957	}
977	958	if (micro.cmd & 0x20)
978	959	{
979		if ((state->m_bram[addr + 0] & (micro.b >> shift)) | (state->m_bram[addr + 1] & (micro.b << nshift)))
980		state->m_fgcoll = 1, state->m_fgcollx = micro.xp + 8, state->m_fgcolly = micro.yp;
981		state->m_bram[addr + 0] ^= micro.b >> shift;
982		state->m_bram[addr + 1] ^= micro.b << nshift;
	960	if ((m_bram[addr + 0] & (micro.b >> shift)) | (m_bram[addr + 1] & (micro.b << nshift)))
	961	m_fgcoll = 1, m_fgcollx = micro.xp + 8, m_fgcolly = micro.yp;
	962	m_bram[addr + 0] ^= micro.b >> shift;
	963	m_bram[addr + 1] ^= micro.b << nshift;
983	964	}
984	965	if (micro.cmd & 0x40)
985	966	{
986		if ((state->m_rram[addr + 0] & (micro.r >> shift)) | (state->m_rram[addr + 1] & (micro.r << nshift)))
987		state->m_fgcoll = 1, state->m_fgcollx = micro.xp + 8, state->m_fgcolly = micro.yp;
988		state->m_rram[addr + 0] ^= micro.r >> shift;
989		state->m_rram[addr + 1] ^= micro.r << nshift;
	967	if ((m_rram[addr + 0] & (micro.r >> shift)) | (m_rram[addr + 1] & (micro.r << nshift)))
	968	m_fgcoll = 1, m_fgcollx = micro.xp + 8, m_fgcolly = micro.yp;
	969	m_rram[addr + 0] ^= micro.r >> shift;
	970	m_rram[addr + 1] ^= micro.r << nshift;
990	971	}
991		if (state->m_fgcoll) victory_update_irq(machine);
	972	if (m_fgcoll) victory_update_irq();
992	973	}
993	974
994	975	count_states(micro, 4);
r21023	r21024
1003	984	*
1004	985	*************************************/
1005	986
1006		static void update_background(running_machine &machine)
	987	void victory_state::update_background()
1007	988	{
1008		victory_state *state = machine.driver_data<victory_state>();
1009	989	int x, y, row, offs;
1010	990
1011	991	for (y = offs = 0; y < 32; y++)
1012	992	for (x = 0; x < 32; x++, offs++)
1013	993	{
1014		int code = state->m_videoram[offs];
	994	int code = m_videoram[offs];
1015	995
1016	996	for (row = 0; row < 8; row++)
1017	997	{
1018		UINT8 pix2 = state->m_charram[0x0000 + 8 * code + row];
1019		UINT8 pix1 = state->m_charram[0x0800 + 8 * code + row];
1020		UINT8 pix0 = state->m_charram[0x1000 + 8 * code + row];
1021		UINT8 *dst = &state->m_bgbitmap[(y * 8 + row) * 256 + x * 8];
	998	UINT8 pix2 = m_charram[0x0000 + 8 * code + row];
	999	UINT8 pix1 = m_charram[0x0800 + 8 * code + row];
	1000	UINT8 pix0 = m_charram[0x1000 + 8 * code + row];
	1001	UINT8 *dst = &m_bgbitmap[(y * 8 + row) * 256 + x * 8];
1022	1002
1023	1003	*dst++ = ((pix2 & 0x80) >> 5) | ((pix1 & 0x80) >> 6) | ((pix0 & 0x80) >> 7);
1024	1004	*dst++ = ((pix2 & 0x40) >> 4) | ((pix1 & 0x40) >> 5) | ((pix0 & 0x40) >> 6);
r21023	r21024
1039	1019	*
1040	1020	*************************************/
1041	1021
1042		static void update_foreground(running_machine &machine)
	1022	void victory_state::update_foreground()
1043	1023	{
1044		victory_state *state = machine.driver_data<victory_state>();
1045	1024	int x, y;
1046	1025
1047	1026	for (y = 0; y < 256; y++)
1048	1027	{
1049		UINT8 *dst = &state->m_fgbitmap[y * 256];
	1028	UINT8 *dst = &m_fgbitmap[y * 256];
1050	1029
1051	1030	/* assemble the RGB bits for each 8-pixel chunk */
1052	1031	for (x = 0; x < 256; x += 8)
1053	1032	{
1054		UINT8 g = state->m_gram[y * 32 + x / 8];
1055		UINT8 b = state->m_bram[y * 32 + x / 8];
1056		UINT8 r = state->m_rram[y * 32 + x / 8];
	1033	UINT8 g = m_gram[y * 32 + x / 8];
	1034	UINT8 b = m_bram[y * 32 + x / 8];
	1035	UINT8 r = m_rram[y * 32 + x / 8];
1057	1036
1058	1037	*dst++ = ((r & 0x80) >> 5) | ((b & 0x80) >> 6) | ((g & 0x80) >> 7);
1059	1038	*dst++ = ((r & 0x40) >> 4) | ((b & 0x40) >> 5) | ((g & 0x40) >> 6);
r21023	r21024
1073	1052	m_bgcollx = param & 0xff;
1074	1053	m_bgcolly = param >> 8;
1075	1054	m_bgcoll = 1;
1076		victory_update_irq(machine());
	1055	victory_update_irq();
1077	1056	}
1078	1057
1079	1058
r21023	r21024
1091	1070	int x, y;
1092	1071
1093	1072	/* copy the palette from palette RAM */
1094		set_palette(machine());
	1073	set_palette();
1095	1074
1096	1075	/* update the foreground & background */
1097		update_foreground(machine());
1098		update_background(machine());
	1076	update_foreground();
	1077	update_background();
1099	1078
1100	1079	/* blend the bitmaps and do collision detection */
1101	1080	for (y = 0; y < 256; y++)

trunk/src/mame/video/vulgus.c

r21023	r21024
166	166
167	167	***************************************************************************/
168	168
169		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	169	void vulgus_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
170	170	{
171		vulgus_state *state = machine.driver_data<vulgus_state>();
172		UINT8 *spriteram = state->m_spriteram;
	171	UINT8 *spriteram = m_spriteram;
173	172	int offs;
174	173
175	174
176		for (offs = state->m_spriteram.bytes() - 4;offs >= 0;offs -= 4)
	175	for (offs = m_spriteram.bytes() - 4;offs >= 0;offs -= 4)
177	176	{
178	177	int code,i,col,sx,sy,dir;
179	178
r21023	r21024
183	182	sx = spriteram[offs + 3];
184	183	sy = spriteram[offs + 2];
185	184	dir = 1;
186		if (state->flip_screen())
	185	if (flip_screen())
187	186	{
188	187	sx = 240 - sx;
189	188	sy = 240 - sy;
r21023	r21024
195	194
196	195	do
197	196	{
198		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	197	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
199	198	code + i,
200	199	col,
201		state->flip_screen(),state->flip_screen(),
	200	flip_screen(),flip_screen(),
202	201	sx, sy + 16 * i * dir,15);
203	202
204	203	/* draw again with wraparound */
205		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	204	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
206	205	code + i,
207	206	col,
208		state->flip_screen(),state->flip_screen(),
	207	flip_screen(),flip_screen(),
209	208	sx, sy + 16 * i * dir -  dir * 256,15);
210	209	i--;
211	210	} while (i >= 0);
r21023	r21024
218	217	m_bg_tilemap->set_scrolly(0, m_scroll_low[0] + 256 * m_scroll_high[0]);
219	218
220	219	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
221		draw_sprites(machine(), bitmap,cliprect);
	220	draw_sprites(bitmap,cliprect);
222	221	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
223	222	return 0;
224	223	}

trunk/src/mame/video/vastar.c

r21023	r21024
122	122	// for Planet Probe more cases appear correct if we draw the list in reverse
123	123	// order, but it's also possible we should be drawing 2 swapped lists in
124	124	// forward order instead
125		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	125	void vastar_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
126	126	{
127		vastar_state *state = machine.driver_data<vastar_state>();
128		UINT8 *spriteram = state->m_spriteram1;
129		UINT8 *spriteram_2 = state->m_spriteram2;
130		UINT8 *spriteram_3 = state->m_spriteram3;
	127	UINT8 *spriteram = m_spriteram1;
	128	UINT8 *spriteram_2 = m_spriteram2;
	129	UINT8 *spriteram_3 = m_spriteram3;
131	130	int offs;
132	131
133	132	//  for (offs = 0; offs < 0x40; offs += 2)
r21023	r21024
145	144	flipx = spriteram_3[offs] & 0x02;
146	145	flipy = spriteram_3[offs] & 0x01;
147	146
148		if (state->flip_screen())
	147	if (flip_screen())
149	148	{
150	149	flipx = !flipx;
151	150	flipy = !flipy;
r21023	r21024
153	152
154	153	if (spriteram_2[offs] & 0x08)   /* double width */
155	154	{
156		if (!state->flip_screen())
	155	if (!flip_screen())
157	156	sy = 224 - sy;
158	157
159		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	158	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
160	159	code/2,
161	160	color,
162	161	flipx,flipy,
163	162	sx,sy,0);
164	163	/* redraw with wraparound */
165		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	164	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
166	165	code/2,
167	166	color,
168	167	flipx,flipy,
r21023	r21024
170	169	}
171	170	else
172	171	{
173		if (!state->flip_screen())
	172	if (!flip_screen())
174	173	sy = 240 - sy;
175	174
176		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	175	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
177	176	code,
178	177	color,
179	178	flipx,flipy,
r21023	r21024
196	195	{
197	196	case 0:
198	197	m_bg1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
199		draw_sprites(machine(), bitmap,cliprect);
	198	draw_sprites(bitmap,cliprect);
200	199	m_bg2_tilemap->draw(bitmap, cliprect, 0,0);
201	200	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
202	201	break;
r21023	r21024
204	203	case 1: // ?? planet probe
205	204	m_bg1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
206	205	m_bg2_tilemap->draw(bitmap, cliprect, 0,0);
207		draw_sprites(machine(), bitmap,cliprect);
	206	draw_sprites(bitmap,cliprect);
208	207	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
209	208	break;
210	209
211	210	case 2:
212	211	m_bg1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
213		draw_sprites(machine(), bitmap,cliprect);
	212	draw_sprites(bitmap,cliprect);
214	213	m_bg1_tilemap->draw(bitmap, cliprect, 0,0);
215	214	m_bg2_tilemap->draw(bitmap, cliprect, 0,0);
216	215	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
r21023	r21024
220	219	m_bg1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE,0);
221	220	m_bg2_tilemap->draw(bitmap, cliprect, 0,0);
222	221	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
223		draw_sprites(machine(), bitmap,cliprect);
	222	draw_sprites(bitmap,cliprect);
224	223	break;
225	224
226	225	default:

trunk/src/mame/video/vigilant.c

r21023	r21024
41	41	There are three background ROMs, each one contains a 512x256 picture.
42	42	Redraw them if the palette changes.
43	43	**************************************************************************/
44		static void update_background(running_machine &machine)
	44	void vigilant_state::update_background()
45	45	{
46		vigilant_state *state = machine.driver_data<vigilant_state>();
47	46	int row,col,page;
48	47	int charcode;
49	48
r21023	r21024
57	56	{
58	57	for( col=0; col<512; col+=32 )
59	58	{
60		drawgfx_opaque(*state->m_bg_bitmap,
61		state->m_bg_bitmap->cliprect(),machine.gfx[2],
	59	drawgfx_opaque(*m_bg_bitmap,
	60	m_bg_bitmap->cliprect(),machine().gfx[2],
62	61	charcode,
63	62	row < 128 ? 0 : 1,
64	63	0,0,
r21023	r21024
159	158	???
160	159	**************************************************************************/
161	160
162		static void draw_foreground(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int opaque )
	161	void vigilant_state::draw_foreground(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int opaque )
163	162	{
164		vigilant_state *state = machine.driver_data<vigilant_state>();
165		UINT8 *videoram = state->m_videoram;
	163	UINT8 *videoram = m_videoram;
166	164	int offs;
167		int scroll = -(state->m_horiz_scroll_low + state->m_horiz_scroll_high);
	165	int scroll = -(m_horiz_scroll_low + m_horiz_scroll_high);
168	166
169	167
170	168	for (offs = 0; offs < 0x1000; offs += 2)
r21023	r21024
183	181	{
184	182	sx = (sx + scroll) & 0x1ff;
185	183
186		drawgfx_transmask(bitmap,bottomvisiblearea,machine.gfx[0],
	184	drawgfx_transmask(bitmap,bottomvisiblearea,machine().gfx[0],
187	185	tile_number,
188	186	color,
189	187	0,0,
r21023	r21024
196	194	if (sy >= 48)
197	195	sx = (sx + scroll) & 0x1ff;
198	196
199		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	197	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
200	198	tile_number,
201	199	color,
202	200	0,0,
r21023	r21024
208	206
209	207
210	208
211		static void draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	209	void vigilant_state::draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
212	210	{
213		vigilant_state *state = machine.driver_data<vigilant_state>();
214		int scrollx = 0x17a + 16*8 - (state->m_rear_horiz_scroll_low + state->m_rear_horiz_scroll_high);
	211	int scrollx = 0x17a + 16*8 - (m_rear_horiz_scroll_low + m_rear_horiz_scroll_high);
215	212
216	213
217		if (state->m_rear_refresh)
	214	if (m_rear_refresh)
218	215	{
219		update_background(machine);
220		state->m_rear_refresh=0;
	216	update_background();
	217	m_rear_refresh=0;
221	218	}
222	219
223		copyscrollbitmap(bitmap,*state->m_bg_bitmap,1,&scrollx,0,0,bottomvisiblearea);
	220	copyscrollbitmap(bitmap,*m_bg_bitmap,1,&scrollx,0,0,bottomvisiblearea);
224	221	}
225	222
226	223
227		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	224	void vigilant_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
228	225	{
229		vigilant_state *state = machine.driver_data<vigilant_state>();
230		UINT8 *spriteram = state->m_spriteram;
	226	UINT8 *spriteram = m_spriteram;
231	227	int offs;
232	228
233		for (offs = 0;offs < state->m_spriteram.bytes();offs += 8)
	229	for (offs = 0;offs < m_spriteram.bytes();offs += 8)
234	230	{
235	231	int code,color,sx,sy,flipx,flipy,h,y;
236	232
r21023	r21024
252	248	if (flipy) c += h-1-y;
253	249	else c += y;
254	250
255		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	251	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
256	252	c,
257	253	color,
258	254	flipx,flipy,
r21023	r21024
281	277	sx,sy);
282	278	}
283	279
284		draw_sprites(machine(),bitmap,cliprect);
	280	draw_sprites(bitmap,cliprect);
285	281	return 0;
286	282	}
287	283
r21023	r21024
310	306
311	307	if (m_rear_disable)  /* opaque foreground */
312	308	{
313		draw_foreground(machine(),bitmap,cliprect,0,1);
314		draw_sprites(machine(),bitmap,bottomvisiblearea);
315		draw_foreground(machine(),bitmap,cliprect,1,0);
	309	draw_foreground(bitmap,cliprect,0,1);
	310	draw_sprites(bitmap,bottomvisiblearea);
	311	draw_foreground(bitmap,cliprect,1,0);
316	312	}
317	313	else
318	314	{
319		draw_background(machine(),bitmap,cliprect);
320		draw_foreground(machine(),bitmap,cliprect,0,0);
321		draw_sprites(machine(),bitmap,bottomvisiblearea);
322		draw_foreground(machine(),bitmap,cliprect,1,0); // priority tiles
	315	draw_background(bitmap,cliprect);
	316	draw_foreground(bitmap,cliprect,0,0);
	317	draw_sprites(bitmap,bottomvisiblearea);
	318	draw_foreground(bitmap,cliprect,1,0); // priority tiles
323	319	}
324	320	return 0;
325	321	}

trunk/src/mame/video/volfied.c

r21023	r21024
66	66	SCREEN REFRESH
67	67	*******************************************************/
68	68
69		static void refresh_pixel_layer( running_machine &machine, bitmap_ind16 &bitmap )
	69	void volfied_state::refresh_pixel_layer( bitmap_ind16 &bitmap )
70	70	{
71	71	int x, y;
72	72
r21023	r21024
90	90
91	91	*********************************************************/
92	92
93		volfied_state *state = machine.driver_data<volfied_state>();
94		UINT16* p = state->m_video_ram;
95		int width = machine.primary_screen->width();
96		int height = machine.primary_screen->height();
	93	UINT16* p = m_video_ram;
	94	int width = machine().primary_screen->width();
	95	int height = machine().primary_screen->height();
97	96
98		if (state->m_video_ctrl & 1)
	97	if (m_video_ctrl & 1)
99	98	p += 0x20000;
100	99
101	100	for (y = 0; y < height; y++)
r21023	r21024
124	123	UINT32 volfied_state::screen_update_volfied(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
125	124	{
126	125	machine().priority_bitmap.fill(0, cliprect);
127		refresh_pixel_layer(machine(), bitmap);
	126	refresh_pixel_layer(bitmap);
128	127	pc090oj_draw_sprites(m_pc090oj, bitmap, cliprect, 0);
129	128	return 0;
130	129	}

trunk/src/mame/video/vertigo.c

r21023	r21024
117	117	*
118	118	*************************************/
119	119
120		void vertigo_vproc_init(running_machine &machine)
	120	void vertigo_state::vertigo_vproc_init()
121	121	{
122		vertigo_state *state = machine.driver_data<vertigo_state>();
123		state_save_register_item_array(machine, "vector_proc", NULL, 0, state->m_vs.sram);
124		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vs.ramlatch);
125		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vs.rom_adr);
126		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vs.pc);
127		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vs.ret);
	122	state_save_register_item_array(machine(), "vector_proc", NULL, 0, m_vs.sram);
	123	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vs.ramlatch);
	124	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vs.rom_adr);
	125	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vs.pc);
	126	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vs.ret);
128	127
129		state_save_register_item_array(machine, "vector_proc", NULL, 0, state->m_bsp.ram);
130		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_bsp.d);
131		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_bsp.q);
132		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_bsp.f);
133		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_bsp.y);
	128	state_save_register_item_array(machine(), "vector_proc", NULL, 0, m_bsp.ram);
	129	state_save_register_item(machine(), "vector_proc", NULL, 0, m_bsp.d);
	130	state_save_register_item(machine(), "vector_proc", NULL, 0, m_bsp.q);
	131	state_save_register_item(machine(), "vector_proc", NULL, 0, m_bsp.f);
	132	state_save_register_item(machine(), "vector_proc", NULL, 0, m_bsp.y);
134	133
135		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.sreg);
136		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.l1);
137		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.l2);
138		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.c_v);
139		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.c_h);
140		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.c_l);
141		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.adder_s);
142		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.adder_a);
143		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.color);
144		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.intensity);
145		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.brez);
146		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.vfin);
147		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.hud1);
148		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.hud2);
149		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.vud1);
150		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.vud2);
151		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.hc1);
152		state_save_register_item(machine, "vector_proc", NULL, 0, state->m_vgen.ven);
	134	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.sreg);
	135	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.l1);
	136	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.l2);
	137	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.c_v);
	138	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.c_h);
	139	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.c_l);
	140	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.adder_s);
	141	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.adder_a);
	142	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.color);
	143	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.intensity);
	144	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.brez);
	145	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.vfin);
	146	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.hud1);
	147	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.hud2);
	148	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.vud1);
	149	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.vud2);
	150	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.hc1);
	151	state_save_register_item(machine(), "vector_proc", NULL, 0, m_vgen.ven);
153	152	}
154	153
155	154
156		void vertigo_vproc_reset(running_machine &machine)
	155	void vertigo_state::vertigo_vproc_reset()
157	156	{
158		vertigo_state *state = machine.driver_data<vertigo_state>();
159	157	int i;
160	158	UINT64 *mcode;
161	159
162		state->m_vectorrom = (UINT16 *)state->memregion("user1")->base();
163		mcode = (UINT64 *)state->memregion("proms")->base();
	160	m_vectorrom = (UINT16 *)memregion("user1")->base();
	161	mcode = (UINT64 *)memregion("proms")->base();
164	162
165	163	/* Decode microcode */
166	164	for (i = 0; i < MC_LENGTH; i++)
167	165	{
168		state->m_mc[i].x = (mcode[i] >> 44) & 0x3f;
169		state->m_mc[i].a = (mcode[i] >> 40) & 0xf;
170		state->m_mc[i].b = (mcode[i] >> 36) & 0xf;
171		state->m_mc[i].inst = (mcode[i] >> 27) & 077;
172		state->m_mc[i].dest = (mcode[i] >> 33) & 07;
173		state->m_mc[i].cn = (mcode[i] >> 26) & 0x1;
174		state->m_mc[i].mreq = (mcode[i] >> 25) & 0x1;
175		state->m_mc[i].rwrite = (mcode[i] >> 23) & 0x1;
176		state->m_mc[i].rsel = state->m_mc[i].rwrite & ((mcode[i] >> 24) & 0x1);
177		state->m_mc[i].of =  (mcode[i] >> 20) & 0x7;
178		state->m_mc[i].iif = (mcode[i] >> 18) & 0x3;
179		state->m_mc[i].oa = (mcode[i] >> 16) & 0x3;
180		state->m_mc[i].jpos = (mcode[i] >> 14) & 0x1;
181		state->m_mc[i].jmp = (mcode[i] >> 12) & 0x3;
182		state->m_mc[i].jcon = (mcode[i] >> 9) & 0x7;
183		state->m_mc[i].ma = mcode[i] & 0x1ff;
	166	m_mc[i].x = (mcode[i] >> 44) & 0x3f;
	167	m_mc[i].a = (mcode[i] >> 40) & 0xf;
	168	m_mc[i].b = (mcode[i] >> 36) & 0xf;
	169	m_mc[i].inst = (mcode[i] >> 27) & 077;
	170	m_mc[i].dest = (mcode[i] >> 33) & 07;
	171	m_mc[i].cn = (mcode[i] >> 26) & 0x1;
	172	m_mc[i].mreq = (mcode[i] >> 25) & 0x1;
	173	m_mc[i].rwrite = (mcode[i] >> 23) & 0x1;
	174	m_mc[i].rsel = m_mc[i].rwrite & ((mcode[i] >> 24) & 0x1);
	175	m_mc[i].of =  (mcode[i] >> 20) & 0x7;
	176	m_mc[i].iif = (mcode[i] >> 18) & 0x3;
	177	m_mc[i].oa = (mcode[i] >> 16) & 0x3;
	178	m_mc[i].jpos = (mcode[i] >> 14) & 0x1;
	179	m_mc[i].jmp = (mcode[i] >> 12) & 0x3;
	180	m_mc[i].jcon = (mcode[i] >> 9) & 0x7;
	181	m_mc[i].ma = mcode[i] & 0x1ff;
184	182	}
185	183
186		memset(&state->m_vs, 0, sizeof(state->m_vs));
187		memset(&state->m_bsp, 0, sizeof(state->m_bsp));
188		memset(&state->m_vgen, 0, sizeof(state->m_vgen));
189		state->m_vgen.set_machine(machine);
	184	memset(&m_vs, 0, sizeof(m_vs));
	185	memset(&m_bsp, 0, sizeof(m_bsp));
	186	memset(&m_vgen, 0, sizeof(m_vgen));
	187	m_vgen.set_machine(machine());
190	188	}
191	189
192	190
r21023	r21024
197	195	*
198	196	********************************************/
199	197
200		static void am2901x4 (am2901 *bsp, microcode *mc)
	198	void vertigo_state::am2901x4 (am2901 *bsp, microcode *mc)
201	199	{
202	200	switch (mc->inst)
203	201	{
r21023	r21024
324	322	*
325	323	********************************************/
326	324
327		static void vertigo_vgen (vector_generator *vg)
	325	void vertigo_state::vertigo_vgen (vector_generator *vg)
328	326	{
329	327	if (vg->c_l & 0x800)
330	328	{
r21023	r21024
383	381	*
384	382	*************************************/
385	383
386		void vertigo_vproc(running_machine &machine, int cycles, int irq4)
	384	void vertigo_state::vertigo_vproc(int cycles, int irq4)
387	385	{
388		vertigo_state *state = machine.driver_data<vertigo_state>();
389	386	int jcond;
390	387	microcode *cmc;
391	388
r21023	r21024
396	393	while (cycles--)
397	394	{
398	395	/* Microcode at current PC */
399		cmc = &state->m_mc[state->m_vs.pc];
	396	cmc = &m_mc[m_vs.pc];
400	397
401	398	/* Load data */
402	399	if (cmc->iif == S_RAMDE)
403	400	{
404		state->m_bsp.d = state->m_vs.ramlatch;
	401	m_bsp.d = m_vs.ramlatch;
405	402	}
406	403	else if (cmc->iif == S_ROMDE)
407	404	{
408		if (state->m_vs.rom_adr < 0x2000)
	405	if (m_vs.rom_adr < 0x2000)
409	406	{
410		state->m_bsp.d = state->m_vectorram[state->m_vs.rom_adr & 0xfff];
	407	m_bsp.d = m_vectorram[m_vs.rom_adr & 0xfff];
411	408	}
412	409	else
413	410	{
414		state->m_bsp.d = state->m_vectorrom[state->m_vs.rom_adr & 0x7fff];
	411	m_bsp.d = m_vectorrom[m_vs.rom_adr & 0x7fff];
415	412	}
416	413	}
417	414
r21023	r21024
420	417	{
421	418	if (cmc->rwrite)
422	419	{
423		state->m_bsp.d = state->m_vs.sram[cmc->x];
	420	m_bsp.d = m_vs.sram[cmc->x];
424	421	}
425	422	else
426	423	{
427	424	/* Data can be transferred between vector ROM/RAM
428	425	and SRAM without going through the 2901 */
429		state->m_vs.sram[cmc->x] = state->m_bsp.d;
	426	m_vs.sram[cmc->x] = m_bsp.d;
430	427	}
431	428	}
432	429
433		am2901x4 (&state->m_bsp, cmc);
	430	am2901x4 (&m_bsp, cmc);
434	431
435	432	/* Store data */
436	433	switch (cmc->oa)
437	434	{
438	435	case S_RAMD:
439		state->m_vs.ramlatch = state->m_bsp.y;
	436	m_vs.ramlatch = m_bsp.y;
440	437	if (cmc->iif==S_RAMDE && (cmc->rsel == 0) && (cmc->rwrite == 0))
441		state->m_vs.sram[cmc->x] = state->m_vs.ramlatch;
	438	m_vs.sram[cmc->x] = m_vs.ramlatch;
442	439	break;
443	440	case S_ROMA:
444		state->m_vs.rom_adr = state->m_bsp.y;
	441	m_vs.rom_adr = m_bsp.y;
445	442	break;
446	443	case S_SREG:
447	444	/* FPOS is shifted into sreg */
448		state->m_vgen.sreg = (state->m_vgen.sreg >> 1) | ((state->m_bsp.f >> 9) & 4);
	445	m_vgen.sreg = (m_vgen.sreg >> 1) | ((m_bsp.f >> 9) & 4);
449	446	break;
450	447	default:
451	448	break;
r21023	r21024
455	452	switch (cmc->of)
456	453	{
457	454	case 0:
458		state->m_vgen.color = state->m_bsp.y & 0xfff;
	455	m_vgen.color = m_bsp.y & 0xfff;
459	456	break;
460	457	case 1:
461		state->m_vgen.intensity = state->m_bsp.y & 0xff;
	458	m_vgen.intensity = m_bsp.y & 0xff;
462	459	break;
463	460	case 2:
464		state->m_vgen.l1 = state->m_bsp.y & 0xfff;
465		state->m_vgen.adder_s = 0;
466		state->m_vgen.adder_a = state->m_vgen.l2;
467		state->m_vgen.hud1 = state->m_vgen.sreg & 1;
468		state->m_vgen.vud1 = state->m_vgen.sreg & 2;
469		state->m_vgen.hc1  = state->m_vgen.sreg & 4;
470		state->m_vgen.brez = 1;
	461	m_vgen.l1 = m_bsp.y & 0xfff;
	462	m_vgen.adder_s = 0;
	463	m_vgen.adder_a = m_vgen.l2;
	464	m_vgen.hud1 = m_vgen.sreg & 1;
	465	m_vgen.vud1 = m_vgen.sreg & 2;
	466	m_vgen.hc1  = m_vgen.sreg & 4;
	467	m_vgen.brez = 1;
471	468	break;
472	469	case 3:
473		state->m_vgen.l2 = state->m_bsp.y & 0xfff;
474		state->m_vgen.adder_s = (state->m_vgen.adder_s + state->m_vgen.adder_a) & 0xfff;
475		if (state->m_vgen.adder_s & 0x800)
476		state->m_vgen.adder_a = state->m_vgen.l1;
	470	m_vgen.l2 = m_bsp.y & 0xfff;
	471	m_vgen.adder_s = (m_vgen.adder_s + m_vgen.adder_a) & 0xfff;
	472	if (m_vgen.adder_s & 0x800)
	473	m_vgen.adder_a = m_vgen.l1;
477	474	else
478		state->m_vgen.adder_a = state->m_vgen.l2;
479		state->m_vgen.hud2 = state->m_vgen.sreg & 1;
480		state->m_vgen.vud2 = state->m_vgen.sreg & 2;
	475	m_vgen.adder_a = m_vgen.l2;
	476	m_vgen.hud2 = m_vgen.sreg & 1;
	477	m_vgen.vud2 = m_vgen.sreg & 2;
481	478	break;
482	479	case 4:
483		state->m_vgen.c_v = state->m_bsp.y & 0xfff;
	480	m_vgen.c_v = m_bsp.y & 0xfff;
484	481	break;
485	482	case 5:
486		state->m_vgen.c_h = state->m_bsp.y & 0xfff;
	483	m_vgen.c_h = m_bsp.y & 0xfff;
487	484	break;
488	485	case 6:
489	486	/* Loading the c_l counter starts
490	487	* the vector counters if MSB is set
491	488	*/
492		state->m_vgen.c_l = state->m_bsp.y & 0xfff;
	489	m_vgen.c_l = m_bsp.y & 0xfff;
493	490	break;
494	491	}
495	492
496		vertigo_vgen (&state->m_vgen);
	493	vertigo_vgen (&m_vgen);
497	494
498	495	/* Microcode program flow */
499	496	switch (cmc->jcon)
500	497	{
501	498	case S_MSB:
502	499	/* ALU most significant bit */
503		jcond = (state->m_bsp.f >> 15) & 1;
	500	jcond = (m_bsp.f >> 15) & 1;
504	501	break;
505	502	case S_FEQ0:
506	503	/* ALU is 0 */
507		jcond = (state->m_bsp.f == 0)? 1 : 0;
	504	jcond = (m_bsp.f == 0)? 1 : 0;
508	505	break;
509	506	case S_Y10:
510		jcond = (state->m_bsp.y >> 10) & 1;
	507	jcond = (m_bsp.y >> 10) & 1;
511	508	break;
512	509	case S_VFIN:
513		jcond = state->m_vgen.vfin;
	510	jcond = m_vgen.vfin;
514	511	break;
515	512	case S_FPOS:
516	513	/* FPOS is bit 11 */
517		jcond = (state->m_bsp.f >> 11) & 1;
	514	jcond = (m_bsp.f >> 11) & 1;
518	515	break;
519	516	case S_INTL4:
520	517	jcond = irq4;
r21023	r21024
542	539	{
543	540	case S_JBK:
544	541	/* JBK is the only jump where MA8 is used */
545		state->m_vs.pc = cmc->ma;
	542	m_vs.pc = cmc->ma;
546	543	break;
547	544	case S_CALL:
548	545	/* call and store return address */
549		state->m_vs.ret = (state->m_vs.pc + 1) & 0xff;
550		state->m_vs.pc = (state->m_vs.pc & 0x100) | (cmc->ma & 0xff);
	546	m_vs.ret = (m_vs.pc + 1) & 0xff;
	547	m_vs.pc = (m_vs.pc & 0x100) | (cmc->ma & 0xff);
551	548	break;
552	549	case S_OPT:
553	550	/* OPT is used for microcode jump tables. The first
554	551	four address bits are defined by bits 12-15
555	552	of 2901 input (D) */
556		state->m_vs.pc = (state->m_vs.pc & 0x100) | (cmc->ma & 0xf0) | ((state->m_bsp.d >> 12) & 0xf);
	553	m_vs.pc = (m_vs.pc & 0x100) | (cmc->ma & 0xf0) | ((m_bsp.d >> 12) & 0xf);
557	554	break;
558	555	case S_RETURN:
559	556	/* return from call */
560		state->m_vs.pc = (state->m_vs.pc & 0x100) | state->m_vs.ret;
	557	m_vs.pc = (m_vs.pc & 0x100) | m_vs.ret;
561	558	break;
562	559	}
563	560	}
564	561	else
565	562	{
566		state->m_vs.pc = (state->m_vs.pc & 0x100) | ((state->m_vs.pc + 1) & 0xff);
	563	m_vs.pc = (m_vs.pc & 0x100) | ((m_vs.pc + 1) & 0xff);
567	564	}
568	565	}
569	566

trunk/src/mame/video/vball.c

r21023	r21024
66	66	m_bg_tilemap->mark_tile_dirty(offset);
67	67	}
68	68
69		void vb_bgprombank_w( running_machine &machine, int bank )
	69	void vball_state::vb_bgprombank_w( int bank )
70	70	{
71		vball_state *state = machine.driver_data<vball_state>();
72	71	int i;
73	72	UINT8* color_prom;
74	73
75		if (bank==state->m_vb_bgprombank) return;
	74	if (bank==m_vb_bgprombank) return;
76	75
77		color_prom = state->memregion("proms")->base() + bank*0x80;
	76	color_prom = memregion("proms")->base() + bank*0x80;
78	77	for (i=0;i<128;i++, color_prom++) {
79		palette_set_color_rgb(machine,i,pal4bit(color_prom[0] >> 0),pal4bit(color_prom[0] >> 4),
	78	palette_set_color_rgb(machine(),i,pal4bit(color_prom[0] >> 0),pal4bit(color_prom[0] >> 4),
80	79	pal4bit(color_prom[0x800] >> 0));
81	80	}
82		state->m_vb_bgprombank=bank;
	81	m_vb_bgprombank=bank;
83	82	}
84	83
85		void vb_spprombank_w( running_machine &machine, int bank )
	84	void vball_state::vb_spprombank_w( int bank )
86	85	{
87		vball_state *state = machine.driver_data<vball_state>();
88	86
89	87	int i;
90	88	UINT8* color_prom;
91	89
92		if (bank==state->m_vb_spprombank) return;
	90	if (bank==m_vb_spprombank) return;
93	91
94		color_prom = state->memregion("proms")->base()+0x400 + bank*0x80;
	92	color_prom = memregion("proms")->base()+0x400 + bank*0x80;
95	93	for (i=128;i<256;i++,color_prom++)  {
96		palette_set_color_rgb(machine,i,pal4bit(color_prom[0] >> 0),pal4bit(color_prom[0] >> 4),
	94	palette_set_color_rgb(machine(),i,pal4bit(color_prom[0] >> 0),pal4bit(color_prom[0] >> 4),
97	95	pal4bit(color_prom[0x800] >> 0));
98	96	}
99		state->m_vb_spprombank=bank;
	97	m_vb_spprombank=bank;
100	98	}
101	99
102		void vb_mark_all_dirty( running_machine &machine )
	100	void vball_state::vb_mark_all_dirty(  )
103	101	{
104		vball_state *state = machine.driver_data<vball_state>();
105		state->m_bg_tilemap->mark_all_dirty();
	102	m_bg_tilemap->mark_all_dirty();
106	103	}
107	104
108	105	#define DRAW_SPRITE( order, sx, sy ) drawgfx_transpen( bitmap, \
109	106	cliprect,gfx, \
110	107	(which+order),color,flipx,flipy,sx,sy,0);
111	108
112		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	109	void vball_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
113	110	{
114		vball_state *state = machine.driver_data<vball_state>();
115		gfx_element *gfx = machine.gfx[1];
116		UINT8 *src = state->m_spriteram;
	111	gfx_element *gfx = machine().gfx[1];
	112	UINT8 *src = m_spriteram;
117	113	int i;
118	114
119	115	/*  240-Y    S|X|CLR|WCH WHICH    240-X
120	116	xxxxxxxx x|x|xxx|xxx xxxxxxxx xxxxxxxx
121	117	*/
122		for (i = 0;i < state->m_spriteram.bytes();i += 4)
	118	for (i = 0;i < m_spriteram.bytes();i += 4)
123	119	{
124	120	int attr = src[i+1];
125	121	int which = src[i+2]+((attr & 0x07)<<8);
r21023	r21024
131	127	int flipy = 0;
132	128	int dy = -16;
133	129
134		if (state->flip_screen())
	130	if (flip_screen())
135	131	{
136	132	sx = 240 - sx;
137	133	sy = 240 - sy;
r21023	r21024
168	164	//logerror("scrollx[%d] = %d\n",i,m_vb_scrollx[i]);
169	165	}
170	166	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
171		draw_sprites(machine(),bitmap,cliprect);
	167	draw_sprites(bitmap,cliprect);
172	168	return 0;
173	169	}

trunk/src/mame/video/unico.c

r21023	r21024
217	217
218	218	***************************************************************************/
219	219
220		static void unico_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	220	void unico_state::unico_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
221	221	{
222		unico_state *state = machine.driver_data<unico_state>();
223		UINT16 *spriteram16 = state->m_spriteram;
	222	UINT16 *spriteram16 = m_spriteram;
224	223	int offs;
225	224
226	225	/* Draw them backwards, for pdrawgfx */
227		for ( offs = (state->m_spriteram.bytes()-8)/2; offs >= 0 ; offs -= 8/2 )
	226	for ( offs = (m_spriteram.bytes()-8)/2; offs >= 0 ; offs -= 8/2 )
228	227	{
229	228	int x, startx, endx, incx;
230	229
r21023	r21024
250	249	case 3:     pri_mask = 0x00;            // above all
251	250	}
252	251
253		sx  +=  state->m_sprites_scrolldx;
254		sy  +=  state->m_sprites_scrolldy;
	252	sx  +=  m_sprites_scrolldx;
	253	sy  +=  m_sprites_scrolldy;
255	254
256	255	sx  =   (sx & 0x1ff) - (sx & 0x200);
257	256	sy  =   (sy & 0x1ff) - (sy & 0x200);
r21023	r21024
261	260
262	261	for (x = startx ; x != endx ; x += incx)
263	262	{
264		pdrawgfx_transpen(  bitmap, cliprect, machine.gfx[0],
	263	pdrawgfx_transpen(  bitmap, cliprect, machine().gfx[0],
265	264	code++,
266	265	attr & 0x1f,
267	266	flipx, flipy,
268	267	x, sy,
269		machine.priority_bitmap,
	268	machine().priority_bitmap,
270	269	pri_mask,0x00   );
271	270	}
272	271	}
273	272	}
274	273
275		static void zeropnt2_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	274	void unico_state::zeropnt2_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
276	275	{
277		unico_state *state = machine.driver_data<unico_state>();
278		UINT32 *spriteram32 = reinterpret_cast<UINT32 *>(state->m_spriteram.target());
	276	UINT32 *spriteram32 = reinterpret_cast<UINT32 *>(m_spriteram.target());
279	277	int offs;
280	278
281	279	/* Draw them backwards, for pdrawgfx */
282		for ( offs = (state->m_spriteram.bytes()-8)/4; offs >= 0 ; offs -= 8/4 )
	280	for ( offs = (m_spriteram.bytes()-8)/4; offs >= 0 ; offs -= 8/4 )
283	281	{
284	282	int x, startx, endx, incx;
285	283
r21023	r21024
305	303	case 3:     pri_mask = 0x00;            // above all
306	304	}
307	305
308		sx  +=  state->m_sprites_scrolldx;
309		sy  +=  state->m_sprites_scrolldy;
	306	sx  +=  m_sprites_scrolldx;
	307	sy  +=  m_sprites_scrolldy;
310	308
311	309	sx  =   (sx & 0x1ff) - (sx & 0x200);
312	310	sy  =   (sy & 0x1ff) - (sy & 0x200);
r21023	r21024
316	314
317	315	for (x = startx ; x != endx ; x += incx)
318	316	{
319		pdrawgfx_transpen(  bitmap, cliprect, machine.gfx[0],
	317	pdrawgfx_transpen(  bitmap, cliprect, machine().gfx[0],
320	318	code++,
321	319	attr & 0x1f,
322	320	flipx, flipy,
323	321	x, sy,
324		machine.priority_bitmap,
	322	machine().priority_bitmap,
325	323	pri_mask,0x00   );
326	324	}
327	325	}
r21023	r21024
371	369	if (layers_ctrl & 4)    m_tilemap[2]->draw(bitmap, cliprect, 0,4);
372	370
373	371	/* Sprites are drawn last, using pdrawgfx */
374		if (layers_ctrl & 8)    unico_draw_sprites(screen.machine(), bitmap,cliprect);
	372	if (layers_ctrl & 8)    unico_draw_sprites(bitmap,cliprect);
375	373
376	374	return 0;
377	375	}
r21023	r21024
410	408	if (layers_ctrl & 4)    m_tilemap[2]->draw(bitmap, cliprect, 0,4);
411	409
412	410	/* Sprites are drawn last, using pdrawgfx */
413		if (layers_ctrl & 8)    zeropnt2_draw_sprites(screen.machine(), bitmap,cliprect);
	411	if (layers_ctrl & 8)    zeropnt2_draw_sprites(bitmap,cliprect);
414	412
415	413	return 0;
416	414	}

trunk/src/mame/video/undrfire.c

r21023	r21024
63	63
64	64	***************************************************************/
65	65
66		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs)
	66	void undrfire_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs)
67	67	{
68		undrfire_state *state = machine.driver_data<undrfire_state>();
69		UINT32 *spriteram32 = state->m_spriteram;
70		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
	68	UINT32 *spriteram32 = m_spriteram;
	69	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
71	70	int offs, data, tilenum, color, flipx, flipy;
72	71	int x, y, priority, dblsize, curx, cury;
73	72	int sprites_flipscreen = 0;
r21023	r21024
77	76
78	77	/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
79	78	while processing sprite ram and then draw them all at the end */
80		struct tempsprite *sprite_ptr = state->m_spritelist;
	79	struct tempsprite *sprite_ptr = m_spritelist;
81	80
82		for (offs = (state->m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
	81	for (offs = (m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
83	82	{
84	83	data = spriteram32[offs+0];
85	84	flipx =    (data & 0x00800000) >> 23;
r21023	r21024
177	176	}
178	177	else
179	178	{
180		drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	179	drawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
181	180	sprite_ptr->code,
182	181	sprite_ptr->color,
183	182	sprite_ptr->flipx,sprite_ptr->flipy,
r21023	r21024
192	191	}
193	192
194	193	/* this happens only if primsks != NULL */
195		while (sprite_ptr != state->m_spritelist)
	194	while (sprite_ptr != m_spritelist)
196	195	{
197	196	sprite_ptr--;
198	197
199		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	198	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
200	199	sprite_ptr->code,
201	200	sprite_ptr->color,
202	201	sprite_ptr->flipx,sprite_ptr->flipy,
203	202	sprite_ptr->x,sprite_ptr->y,
204	203	sprite_ptr->zoomx,sprite_ptr->zoomy,
205		machine.priority_bitmap,sprite_ptr->primask,0);
	204	machine().priority_bitmap,sprite_ptr->primask,0);
206	205	}
207	206	}
208	207
209	208
210		static void draw_sprites_cbombers(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs)
	209	void undrfire_state::draw_sprites_cbombers(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs)
211	210	{
212		undrfire_state *state = machine.driver_data<undrfire_state>();
213		UINT32 *spriteram32 = state->m_spriteram;
214		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
215		UINT8 *spritemapHibit = (UINT8 *)state->memregion("user2")->base();
	211	UINT32 *spriteram32 = m_spriteram;
	212	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
	213	UINT8 *spritemapHibit = (UINT8 *)memregion("user2")->base();
216	214
217	215	int offs, data, tilenum, color, flipx, flipy;
218	216	int x, y, priority, dblsize, curx, cury;
r21023	r21024
223	221
224	222	/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
225	223	while processing sprite ram and then draw them all at the end */
226		struct tempsprite *sprite_ptr = state->m_spritelist;
	224	struct tempsprite *sprite_ptr = m_spritelist;
227	225
228		for (offs = (state->m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
	226	for (offs = (m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
229	227	{
230	228	data = spriteram32[offs+0];
231	229	flipx =    (data & 0x00800000) >> 23;
r21023	r21024
316	314	}
317	315	else
318	316	{
319		drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	317	drawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
320	318	sprite_ptr->code,
321	319	sprite_ptr->color,
322	320	sprite_ptr->flipx,sprite_ptr->flipy,
r21023	r21024
327	325	}
328	326
329	327	/* this happens only if primsks != NULL */
330		while (sprite_ptr != state->m_spritelist)
	328	while (sprite_ptr != m_spritelist)
331	329	{
332	330	sprite_ptr--;
333	331
334		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	332	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
335	333	sprite_ptr->code,
336	334	sprite_ptr->color,
337	335	sprite_ptr->flipx,sprite_ptr->flipy,
338	336	sprite_ptr->x,sprite_ptr->y,
339	337	sprite_ptr->zoomx,sprite_ptr->zoomy,
340		machine.priority_bitmap,sprite_ptr->primask,0);
	338	machine().priority_bitmap,sprite_ptr->primask,0);
341	339	}
342	340	}
343	341
r21023	r21024
448	446	if ((tc0480scp_pri_reg_r(tc0480scp, space, 0) & 0x3) == 3)  /* on road levels kludge sprites up 1 priority */
449	447	{
450	448	static const int primasks[4] = {0xfff0, 0xff00, 0x0, 0x0};
451		draw_sprites(machine(), bitmap, cliprect, primasks, 44, -574);
	449	draw_sprites(bitmap, cliprect, primasks, 44, -574);
452	450	}
453	451	else
454	452	{
455	453	static const int primasks[4] = {0xfffc, 0xfff0, 0xff00, 0x0};
456		draw_sprites(machine(), bitmap, cliprect, primasks, 44, -574);
	454	draw_sprites(bitmap, cliprect, primasks, 44, -574);
457	455	}
458	456	}
459	457
r21023	r21024
591	589	if ((tc0480scp_pri_reg_r(tc0480scp, space, 0) & 0x3) == 3)  /* on road levels kludge sprites up 1 priority */
592	590	{
593	591	static const int primasks[4] = {0xfff0, 0xff00, 0x0, 0x0};
594		draw_sprites_cbombers(machine(), bitmap, cliprect, primasks, 80, -208);
	592	draw_sprites_cbombers(bitmap, cliprect, primasks, 80, -208);
595	593	}
596	594	else
597	595	{
598	596	static const int primasks[4] = {0xfffc, 0xfff0, 0xff00, 0x0};
599		draw_sprites_cbombers(machine(), bitmap, cliprect, primasks, 80, -208);
	597	draw_sprites_cbombers(bitmap, cliprect, primasks, 80, -208);
600	598	}
601	599	}
602	600

trunk/src/mame/includes/vicdual.h

r21023	r21024
90	90	UINT32 screen_update_vicdual_bw(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
91	91	UINT32 screen_update_vicdual_bw_or_color(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
92	92	UINT32 screen_update_vicdual_color(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	93	int get_vcounter();
	94	int vicdual_is_cabinet_color();
93	95	};
94	96
95		/*----------- defined in drivers/vicdual.c -----------*/
96	97
97		int vicdual_is_cabinet_color(running_machine &machine);
98
99	98	/*----------- defined in audio/vicdual.c -----------*/
100	99
101	100	MACHINE_CONFIG_EXTERN( frogs_audio );

trunk/src/mame/includes/vigilant.h

r21023	r21024
28	28	virtual void video_reset();
29	29	UINT32 screen_update_vigilant(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
30	30	UINT32 screen_update_kikcubic(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	31	void update_background();
	32	void draw_foreground(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, int opaque );
	33	void draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	34	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
31	35	};

trunk/src/mame/includes/videopin.h

r21023	r21024
43	43	virtual void video_start();
44	44	UINT32 screen_update_videopin(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
45	45	TIMER_CALLBACK_MEMBER(interrupt_callback);
	46	void update_plunger();
	47	double calc_plunger_pos();
46	48	};
47	49
48	50	/*----------- defined in audio/videopin.c -----------*/

trunk/src/mame/includes/victory.h

r21023	r21024
64	64	UINT32 screen_update_victory(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
65	65	INTERRUPT_GEN_MEMBER(victory_vblank_interrupt);
66	66	TIMER_CALLBACK_MEMBER(bgcoll_irq_callback);
	67	void victory_update_irq();
	68	void set_palette();
	69	int command2();
	70	int command3();
	71	int command4();
	72	int command5();
	73	int command6();
	74	int command7();
	75	void update_background();
	76	void update_foreground();
67	77	};

trunk/src/mame/includes/vendetta.h

r21023	r21024
46	46	UINT32 screen_update_vendetta(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
47	47	INTERRUPT_GEN_MEMBER(vendetta_irq);
48	48	TIMER_CALLBACK_MEMBER(z80_nmi_callback);
	49	void vendetta_video_banking( int select );
49	50	};
50	51
51	52	/*----------- defined in video/vendetta.c -----------*/

trunk/src/mame/includes/vectrex.h

r21023	r21024
124	124	void vectrex_multiplexer(int mux);
125	125	void vectrex_add_point(int x, int y, rgb_t color, int intensity);
126	126	void vectrex_add_point_stereo(int x, int y, rgb_t color, int intensity);
	127	int vectrex_verify_cart(char *data);
127	128	};
128	129
129	130	/*---------- defined in video/vectrex.c -----------*/

trunk/src/mame/includes/vball.h

r21023	r21024
33	33	virtual void video_start();
34	34	UINT32 screen_update_vb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
35	35	TIMER_DEVICE_CALLBACK_MEMBER(vball_scanline);
	36	void vb_bgprombank_w( int bank );
	37	void vb_spprombank_w( int bank );
	38	void vb_mark_all_dirty(  );
	39	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	40	inline int scanline_to_vcount(int scanline);
36	41	};
37
38
39		/*----------- defined in video/vball.c -----------*/
40
41		void vb_bgprombank_w(running_machine &machine, int bank);
42		void vb_spprombank_w(running_machine &machine, int bank);
43		void vb_mark_all_dirty(running_machine &machine);

trunk/src/mame/includes/unico.h

r21023	r21024
42	42	DECLARE_VIDEO_START(zeropnt2);
43	43	UINT32 screen_update_unico(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
44	44	UINT32 screen_update_zeropnt2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	45	void unico_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	46	void zeropnt2_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
45	47	};

trunk/src/mame/includes/vsnes.h

r21023	r21024
101	101	DECLARE_PALETTE_INIT(vsdual);
102	102	UINT32 screen_update_vsnes(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
103	103	UINT32 screen_update_vsnes_bottom(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	104	void v_set_videorom_bank(  int start, int count, int vrom_start_bank );
	105	void mapper4_set_prg(  );
	106	void mapper4_set_chr(  );
104	107	};
105	108
106	109	/*----------- defined in video/vsnes.c -----------*/

trunk/src/mame/includes/undrfire.h

r21023	r21024
47	47	UINT32 screen_update_cbombers(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
48	48	INTERRUPT_GEN_MEMBER(undrfire_interrupt);
49	49	TIMER_CALLBACK_MEMBER(interrupt5);
	50	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs);
	51	void draw_sprites_cbombers(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs);
50	52	};

trunk/src/mame/includes/vulgus.h

r21023	r21024
27	27	virtual void palette_init();
28	28	UINT32 screen_update_vulgus(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
29	29	INTERRUPT_GEN_MEMBER(vulgus_vblank_irq);
	30	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
30	31	};

trunk/src/mame/includes/vastar.h

r21023	r21024
42	42	virtual void video_start();
43	43	UINT32 screen_update_vastar(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
44	44	INTERRUPT_GEN_MEMBER(vblank_irq);
	45	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
45	46	};

trunk/src/mame/includes/vaportra.h

r21023	r21024
38	38	virtual void machine_start();
39	39	virtual void machine_reset();
40	40	UINT32 screen_update_vaportra(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	41	void update_24bitcol( int offset );
41	42	};

trunk/src/mame/includes/volfied.h

r21023	r21024
45	45	virtual void video_start();
46	46	UINT32 screen_update_volfied(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
47	47	TIMER_CALLBACK_MEMBER(volfied_timer_callback);
	48	void refresh_pixel_layer( bitmap_ind16 &bitmap );
	49	void volfied_cchip_init(  );
	50	void volfied_cchip_reset(  );
48	51	};
49	52
50	53
51		/*----------- defined in machine/volfied.c -----------*/
52		void volfied_cchip_init(running_machine &machine);
53		void volfied_cchip_reset(running_machine &machine);

trunk/src/mame/includes/vertigo.h

r21023	r21024
114	114	TIMER_CALLBACK_MEMBER(sound_command_w);
115	115	DECLARE_WRITE_LINE_MEMBER(v_irq4_w);
116	116	DECLARE_WRITE_LINE_MEMBER(v_irq3_w);
	117	void vertigo_vproc_init();
	118	void vertigo_vproc_reset();
	119	void am2901x4 (am2901 *bsp, microcode *mc);
	120	void vertigo_vgen (vector_generator *vg);
	121	void vertigo_vproc(int cycles, int irq4);
	122	void update_irq_encoder(int line, int state);
117	123	};
118	124
119	125	/*----------- defined in machine/vertigo.c -----------*/
r21023	r21024
122	128
123	129	extern const struct pit8253_config vertigo_pit8254_config;
124	130
125		/*----------- defined in video/vertigo.c -----------*/
126
127		void vertigo_vproc_init(running_machine &machine);
128		void vertigo_vproc_reset(running_machine &machine);
129		void vertigo_vproc(running_machine &machine, int cycles, int irq4);

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team