Previous

199869 Revisions

Next

r20825 Friday 8th February, 2013 at 11:39:01 UTC by Miodrag Milanović
Modernization of drivers part 6 (no whatsnew)

[src/mame/drivers]	gaiden.c galaga.c galaxian.c galpani2.c gijoe.c gladiatr.c glass.c goldstar.c gottlieb.c gridlee.c gstriker.c gsword.c
[src/mame/includes]	gaelco.h gaelco2.h gaelco3d.h gaiden.h galaga.h galastrm.h galaxian.h galaxold.h galivan.h galpani2.h galpanic.h galspnbl.h gameplan.h gaplus.h gberet.h gcpinbal.h gijoe.h ginganin.h gladiatr.h glass.h gng.h goal92.h goindol.h goldstar.h gotcha.h gottlieb.h gotya.h grchamp.h gridlee.h groundfx.h gstriker.h gsword.h gunbustr.h gunsmoke.h gyruss.h
[src/mame/machine]	gaelco2.c galaxold.c
[src/mame/video]	bosco.c digdug.c fastfred.c gaelco.c gaelco2.c gaelco3d.c gaiden.c galaga.c galastrm.c galaxian.c galaxold.c galivan.c galpanic.c galspnbl.c gameplan.c gaplus.c gberet.c gcpinbal.c ginganin.c gladiatr.c glass.c gng.c goal92.c goindol.c gotcha.c gottlieb.c gotya.c grchamp.c groundfx.c gstriker.c gsword.c gunbustr.c gunsmoke.c gyruss.c xevious.c

trunk/src/mame/drivers/gstriker.c

r20824	r20825
1018	1018	}
1019	1019	}
1020	1020
1021		static void mcu_init( running_machine &machine )
	1021	void gstriker_state::mcu_init( )
1022	1022	{
1023		gstriker_state *state = machine.driver_data<gstriker_state>();
1024		state->m_dmmy_8f_ret = 0xFFFF;
1025		state->m_pending_command = 0;
1026		state->m_mcu_data = 0;
	1023	m_dmmy_8f_ret = 0xFFFF;
	1024	m_pending_command = 0;
	1025	m_mcu_data = 0;
1027	1026
1028		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x20008a, 0x20008b, write16_delegate(FUNC(gstriker_state::twrldc94_mcu_w),state));
1029		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x20008a, 0x20008b, read16_delegate(FUNC(gstriker_state::twrldc94_mcu_r),state));
	1027	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x20008a, 0x20008b, write16_delegate(FUNC(gstriker_state::twrldc94_mcu_w),this));
	1028	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x20008a, 0x20008b, read16_delegate(FUNC(gstriker_state::twrldc94_mcu_r),this));
1030	1029
1031		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x20008e, 0x20008f, write16_delegate(FUNC(gstriker_state::twrldc94_prot_reg_w),state));
1032		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x20008e, 0x20008f, read16_delegate(FUNC(gstriker_state::twrldc94_prot_reg_r),state));
	1030	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x20008e, 0x20008f, write16_delegate(FUNC(gstriker_state::twrldc94_prot_reg_w),this));
	1031	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x20008e, 0x20008f, read16_delegate(FUNC(gstriker_state::twrldc94_prot_reg_r),this));
1033	1032	}
1034	1033
1035	1034	DRIVER_INIT_MEMBER(gstriker_state,twrldc94)
1036	1035	{
1037	1036	m_gametype = 1;
1038		mcu_init( machine() );
	1037	mcu_init();
1039	1038	}
1040	1039
1041	1040	DRIVER_INIT_MEMBER(gstriker_state,twrldc94a)
1042	1041	{
1043	1042	m_gametype = 2;
1044		mcu_init( machine() );
	1043	mcu_init();
1045	1044	}
1046	1045
1047	1046	DRIVER_INIT_MEMBER(gstriker_state,vgoalsoc)
1048	1047	{
1049	1048	m_gametype = 3;
1050		mcu_init( machine() );
	1049	mcu_init();
1051	1050
1052	1051	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x200090, 0x200091, write16_delegate(FUNC(gstriker_state::vbl_toggle_w),this)); // vblank toggle
1053	1052	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x200090, 0x200091, read16_delegate(FUNC(gstriker_state::vbl_toggle_r),this));

trunk/src/mame/drivers/gottlieb.c

r20824	r20825
483	483	*
484	484	*************************************/
485	485
486		INLINE void audio_end_state(gottlieb_state *state)
	486	inline void gottlieb_state::audio_end_state()
487	487	{
488	488	/* this occurs either when the "break in transmission" condition is hit (no zero crossings
489	489	for 400usec) or when the entire audio buffer is full */
490		state->m_laserdisc_status |= 0x08;
491		state->m_laserdisc_audio_bit_count = 0;
492		state->m_laserdisc_audio_address = 0;
493		if (state->m_laserdisc_audio_address != 0)
494		printf("Got %d bytes\n", state->m_laserdisc_audio_address);
	490	m_laserdisc_status |= 0x08;
	491	m_laserdisc_audio_bit_count = 0;
	492	m_laserdisc_audio_address = 0;
	493	if (m_laserdisc_audio_address != 0)
	494	printf("Got %d bytes\n", m_laserdisc_audio_address);
495	495	}
496	496
497	497
498		static void audio_process_clock(gottlieb_state *state, int logit)
	498	void gottlieb_state::audio_process_clock(int logit)
499	499	{
500	500	/* clock the bit through the shift register */
501		state->m_laserdisc_audio_bits >>= 1;
502		if (state->m_laserdisc_zero_seen)
503		state->m_laserdisc_audio_bits |= 0x80;
504		state->m_laserdisc_zero_seen = 0;
	501	m_laserdisc_audio_bits >>= 1;
	502	if (m_laserdisc_zero_seen)
	503	m_laserdisc_audio_bits |= 0x80;
	504	m_laserdisc_zero_seen = 0;
505	505
506	506	/* if the buffer ready flag is set, then we are looking for the magic $67 pattern */
507		if (state->m_laserdisc_status & 0x08)
	507	if (m_laserdisc_status & 0x08)
508	508	{
509		if (state->m_laserdisc_audio_bits == 0x67)
	509	if (m_laserdisc_audio_bits == 0x67)
510	510	{
511	511	if (logit)
512	512	logerror(" -- got 0x67");
513		state->m_laserdisc_status &= ~0x08;
514		state->m_laserdisc_audio_address = 0;
	513	m_laserdisc_status &= ~0x08;
	514	m_laserdisc_audio_address = 0;
515	515	}
516	516	}
517	517
518	518	/* otherwise, we keep clocking bytes into the audio buffer */
519	519	else
520	520	{
521		state->m_laserdisc_audio_bit_count++;
	521	m_laserdisc_audio_bit_count++;
522	522
523	523	/* if we collect 8 bits, add to the buffer */
524		if (state->m_laserdisc_audio_bit_count == 8)
	524	if (m_laserdisc_audio_bit_count == 8)
525	525	{
526	526	if (logit)
527		logerror(" -- got new byte %02X", state->m_laserdisc_audio_bits);
528		state->m_laserdisc_audio_bit_count = 0;
529		state->m_laserdisc_audio_buffer[state->m_laserdisc_audio_address++] = state->m_laserdisc_audio_bits;
	527	logerror(" -- got new byte %02X", m_laserdisc_audio_bits);
	528	m_laserdisc_audio_bit_count = 0;
	529	m_laserdisc_audio_buffer[m_laserdisc_audio_address++] = m_laserdisc_audio_bits;
530	530
531	531	/* if we collect a full buffer, signal */
532		if (state->m_laserdisc_audio_address >= AUDIORAM_SIZE)
533		audio_end_state(state);
	532	if (m_laserdisc_audio_address >= AUDIORAM_SIZE)
	533	audio_end_state();
534	534	}
535	535	}
536	536	}
537	537
538	538
539		static void audio_handle_zero_crossing(gottlieb_state *state, attotime zerotime, int logit)
	539	void gottlieb_state::audio_handle_zero_crossing(attotime zerotime, int logit)
540	540	{
541	541	/* compute time from last clock */
542		attotime deltaclock = zerotime - state->m_laserdisc_last_clock;
	542	attotime deltaclock = zerotime - m_laserdisc_last_clock;
543	543	if (logit)
544	544	logerror(" -- zero @ %s (delta=%s)", zerotime.as_string(6), deltaclock.as_string(6));
545	545
r20824	r20825
548	548	{
549	549	if (logit)
550	550	logerror(" -- count as bit");
551		state->m_laserdisc_zero_seen++;
	551	m_laserdisc_zero_seen++;
552	552	return;
553	553	}
554	554
r20824	r20825
556	556	else if (deltaclock < attotime::from_usec(215))
557	557	{
558	558	if (logit)
559		logerror(" -- clock, bit=%d", state->m_laserdisc_zero_seen);
560		state->m_laserdisc_last_clock = zerotime;
	559	logerror(" -- clock, bit=%d", m_laserdisc_zero_seen);
	560	m_laserdisc_last_clock = zerotime;
561	561	}
562	562
563	563	/* if we are outside of 215usec, we are technically a missing clock
r20824	r20825
567	567	{
568	568	if (logit)
569	569	logerror(" -- skewed clock, correcting");
570		state->m_laserdisc_last_clock += attotime::from_usec(200);
	570	m_laserdisc_last_clock += attotime::from_usec(200);
571	571	}
572	572
573	573	/* we'll count anything more than 275us as an actual missing clock */
r20824	r20825
575	575	{
576	576	if (logit)
577	577	logerror(" -- missing clock");
578		state->m_laserdisc_last_clock = zerotime;
	578	m_laserdisc_last_clock = zerotime;
579	579	}
580	580
581	581	/* we have a clock, process it */
582		audio_process_clock(state, logit);
	582	audio_process_clock(logit);
583	583	}
584	584
585	585
r20824	r20825
612	612
613	613	/* if we are past the "break in transmission" time, reset everything */
614	614	if ((curtime - state->m_laserdisc_last_clock) > attotime::from_usec(400))
615		audio_end_state(state);
	615	state->audio_end_state();
616	616
617	617	/* if this sample reinforces that the previous one ended a zero crossing, count it */
618	618	if ((sample >= 256 && state->m_laserdisc_last_samples[1] >= 0 && state->m_laserdisc_last_samples[0] < 0) ||
r20824	r20825
628	628	zerotime = curtime + time_per_sample * fractime / 1000;
629	629
630	630	/* determine if this is a clock; if it is, process */
631		audio_handle_zero_crossing(state, zerotime, logit);
	631	state->audio_handle_zero_crossing(zerotime, logit);
632	632	}
633	633	if (logit)
634	634	logerror(" \n");

trunk/src/mame/drivers/galpani2.c

r20824	r20825
118	118	machine().device("sub")->execute().set_input_line(INPUT_LINE_IRQ7, HOLD_LINE); //MCU Initialised
119	119	}
120	120
121		static void galpani2_mcu_nmi1(running_machine &machine)
	121	void galpani2_state::galpani2_mcu_nmi1()
122	122	{
123		address_space &srcspace = machine.device("maincpu")->memory().space(AS_PROGRAM);
124		address_space &dstspace = machine.device("sub")->memory().space(AS_PROGRAM);
	123	address_space &srcspace = machine().device("maincpu")->memory().space(AS_PROGRAM);
	124	address_space &dstspace = machine().device("sub")->memory().space(AS_PROGRAM);
125	125	UINT32 mcu_list, mcu_command, mcu_address, mcu_extra, mcu_src, mcu_dst, mcu_size;
126	126
127	127	for ( mcu_list = 0x100021; mcu_list < (0x100021 + 0x40); mcu_list += 4 )
r20824	r20825
137	137	if (mcu_command != 0)
138	138	{
139	139	logerror("%s : MCU [$%06X] endidx = $%02X / command = $%02X addr = $%04X ? = $%02X.\n",
140		machine.describe_context(),
	140	machine().describe_context(),
141	141	mcu_list,
142	142	srcspace.read_byte(0x100020),
143	143	mcu_command,
r20824	r20825
160	160
161	161	mcu_size    =   (srcspace.read_byte(mcu_address + 8)<<8) +
162	162	(srcspace.read_byte(mcu_address + 9)<<0) ;
163		logerror("%s : MCU executes command $%02X, %04X %02X-> %04x\n",machine.describe_context(),mcu_command,mcu_src,mcu_size,mcu_dst);
	163	logerror("%s : MCU executes command $%02X, %04X %02X-> %04x\n",machine().describe_context(),mcu_command,mcu_src,mcu_size,mcu_dst);
164	164
165	165	for( ; mcu_size > 0 ; mcu_size-- )
166	166	{
r20824	r20825
185	185	mcu_size    =   (srcspace.read_byte(mcu_address + 8)<<8) +
186	186	(srcspace.read_byte(mcu_address + 9)<<0) ;
187	187
188		logerror("%s : MCU executes command $%02X, %04X %02X-> %04x\n",machine.describe_context(),mcu_command,mcu_src,mcu_size,mcu_dst);
	188	logerror("%s : MCU executes command $%02X, %04X %02X-> %04x\n",machine().describe_context(),mcu_command,mcu_src,mcu_size,mcu_dst);
189	189
190	190	for( ; mcu_size > 0 ; mcu_size-- )
191	191	{
r20824	r20825
213	213	srcspace.write_byte(mcu_address+0,0xff);
214	214	srcspace.write_byte(mcu_address+1,0xff);
215	215
216		logerror("%s : MCU ERROR, unknown command $%02X\n",machine.describe_context(),mcu_command);
	216	logerror("%s : MCU ERROR, unknown command $%02X\n",machine().describe_context(),mcu_command);
217	217	}
218	218
219	219	/* Erase command (so that it won't be processed again)? */
r20824	r20825
221	221	}
222	222	}
223	223
224		static void galpani2_mcu_nmi2(running_machine &machine)
	224	void galpani2_state::galpani2_mcu_nmi2()
225	225	{
226		galpani2_write_kaneko(machine.device("maincpu"));
227		//logerror("%s : MCU executes CHECKs synchro\n", machine.describe_context());
	226	galpani2_write_kaneko(machine().device("maincpu"));
	227	//logerror("%s : MCU executes CHECKs synchro\n", machine().describe_context());
228	228	}
229	229
230	230	WRITE8_MEMBER(galpani2_state::galpani2_mcu_nmi1_w)//driven by CPU1's int5 ISR
r20824	r20825
233	233	//Triggered from 'maincpu' (00007D60),once, with no command, using alternate line, during init
234	234	//Triggered from 'maincpu' (000080BE),once, for unknown command, during init
235	235	//Triggered from 'maincpu' (0000741E),from here on...driven by int5, even if there's no command
236		if ( (data & 1) && !(m_old_mcu_nmi1 & 1) )  galpani2_mcu_nmi1(machine());
	236	if ( (data & 1) && !(m_old_mcu_nmi1 & 1) )  galpani2_mcu_nmi1();
237	237	//if ( (data & 0x10) && !(m_old_mcu_nmi1 & 0x10) )    galpani2_mcu_nmi1(machine());
238	238	//alternate line, same function?
239	239	m_old_mcu_nmi1 = data;
r20824	r20825
241	241
242	242	WRITE8_MEMBER(galpani2_state::galpani2_mcu_nmi2_w)//driven by CPU2's int5 ISR
243	243	{
244		if ( (data & 1) && !(m_old_mcu_nmi2 & 1) )  galpani2_mcu_nmi2(machine());
	244	if ( (data & 1) && !(m_old_mcu_nmi2 & 1) )  galpani2_mcu_nmi2();
245	245	m_old_mcu_nmi2 = data;
246	246	}
247	247

trunk/src/mame/drivers/gridlee.c

r20824	r20825
87	87	/* constants */
88	88	#define FIRQ_SCANLINE 92
89	89
90
91		/* local prototypes */
92		static void poly17_init(running_machine &machine);
93
94	90	/*************************************
95	91	*
96	92	*  Interrupt handling
r20824	r20825
142	138	m_maincpu = machine().device<cpu_device>("maincpu");
143	139
144	140	/* create the polynomial tables */
145		poly17_init(machine());
	141	poly17_init();
146	142
147	143	state_save_register_global_array(machine(), m_last_analog_input);
148	144	state_save_register_global_array(machine(), m_last_analog_output);
r20824	r20825
221	217	#define POLY17_SHR  10
222	218	#define POLY17_ADD  0x18000
223	219
224		static void poly17_init(running_machine &machine)
	220	void gridlee_state::poly17_init()
225	221	{
226		gridlee_state *state = machine.driver_data<gridlee_state>();
227	222	UINT32 i, x = 0;
228	223	UINT8 *p, *r;
229	224
230	225	/* allocate memory */
231		p = state->m_poly17 = auto_alloc_array(machine, UINT8, 2 * (POLY17_SIZE + 1));
232		r = state->m_rand17 = state->m_poly17 + POLY17_SIZE + 1;
	226	p = m_poly17 = auto_alloc_array(machine(), UINT8, 2 * (POLY17_SIZE + 1));
	227	r = m_rand17 = m_poly17 + POLY17_SIZE + 1;
233	228
234	229	/* generate the polynomial */
235	230	for (i = 0; i < POLY17_SIZE; i++)

trunk/src/mame/drivers/goldstar.c

r20824	r20825
10906	10906
10907	10907	// this block swapping is the same for chry10, chrygld and cb3
10908	10908	//  the underlying bitswaps / xors are different however
10909		static void do_blockswaps(running_machine &machine, UINT8* ROM)
	10909	void goldstar_state::do_blockswaps(UINT8* ROM)
10910	10910	{
10911	10911	int A;
10912	10912	UINT8 *buffer;
r20824	r20825
10925	10925	0xa000, 0xa800, 0xb000, 0xb800,
10926	10926	};
10927	10927
10928		buffer = auto_alloc_array(machine, UINT8, 0x10000);
	10928	buffer = auto_alloc_array(machine(), UINT8, 0x10000);
10929	10929	memcpy(buffer,ROM,0x10000);
10930	10930
10931	10931	// swap some 0x800 blocks around..
r20824	r20825
10934	10934	memcpy(ROM+A*0x800,buffer+cherry_swaptables[A],0x800);
10935	10935	}
10936	10936
10937		auto_free(machine, buffer);
	10937	auto_free(machine(), buffer);
10938	10938	}
10939	10939
10940		static void dump_to_file(running_machine& machine, UINT8* ROM)
	10940	void goldstar_state::dump_to_file( UINT8* ROM)
10941	10941	{
10942	10942	#if 0
10943	10943	{
10944	10944	FILE *fp;
10945	10945	char filename[256];
10946		sprintf(filename,"decrypted_%s", machine.system().name);
	10946	sprintf(filename,"decrypted_%s", machine().system().name);
10947	10947	fp=fopen(filename, "w+b");
10948	10948	if (fp)
10949	10949	{
r20824	r20825
10954	10954	#endif
10955	10955	}
10956	10956
10957		static UINT8 decrypt(UINT8 cipherText, UINT16 address)
	10957	UINT8 goldstar_state::decrypt(UINT8 cipherText, UINT16 address)
10958	10958	{
10959	10959	int idx;
10960	10960	UINT8 output;
r20824	r20825
10971	10971	return output ^ sbox[idx];
10972	10972	}
10973	10973
10974		static UINT8 chry10_decrypt(UINT8 cipherText)
	10974	UINT8 goldstar_state::chry10_decrypt(UINT8 cipherText)
10975	10975	{
10976	10976	return cipherText ^ (BIT(cipherText, 4) << 3) ^ (BIT(cipherText, 1) << 5) ^ (BIT(cipherText, 6) << 7);
10977	10977	}
r20824	r20825
10989	10989	ROM[i] = chry10_decrypt(ROM[i]);
10990	10990	}
10991	10991
10992		do_blockswaps(machine(), ROM);
	10992	do_blockswaps(ROM);
10993	10993
10994	10994	/* The game has a PIC for protection.
10995	10995	If the code enter to this sub, just
r20824	r20825
10997	10997	*/
10998	10998	ROM[0xA5DC] = 0xc9;
10999	10999
11000		dump_to_file(machine(), ROM);
	11000	dump_to_file(ROM);
11001	11001	}
11002	11002
11003	11003	DRIVER_INIT_MEMBER(goldstar_state,cb3)
r20824	r20825
11013	11013	ROM[i] = decrypt(ROM[i], i);
11014	11014	}
11015	11015
11016		do_blockswaps(machine(), ROM);
11017		dump_to_file(machine(), ROM);
	11016	do_blockswaps(ROM);
	11017	dump_to_file(ROM);
11018	11018	}
11019	11019
11020	11020
r20824	r20825
11022	11022	{
11023	11023	int A;
11024	11024	UINT8 *ROM = machine().root_device().memregion("maincpu")->base();
11025		do_blockswaps(machine(), ROM);
	11025	do_blockswaps(ROM);
11026	11026
11027	11027	// a data bitswap
11028	11028	for (A = 0;A < 0x10000;A++)
r20824	r20825
11032	11032	ROM[A] = dat;
11033	11033	}
11034	11034
11035		dump_to_file(machine(), ROM);
	11035	dump_to_file(ROM);
11036	11036	}
11037	11037
11038	11038	DRIVER_INIT_MEMBER(goldstar_state,cm)

trunk/src/mame/drivers/galaxian.c

r20824	r20825
827	827	}
828	828
829	829
830		static void monsterz_set_latch(running_machine &machine)
	830	void galaxian_state::monsterz_set_latch()
831	831	{
832	832	// read from a rom (which one?? "a-3e.k3" from audiocpu ($2700-$2fff) looks very suspicious)
833		galaxian_state *state = machine.driver_data<galaxian_state>();
834		UINT8 *rom = state->memregion("audiocpu")->base();
835		state->m_protection_result = rom[0x2000 | (state->m_protection_state & 0x1fff)]; // probably needs a BITSWAP8
	833	UINT8 *rom = memregion("audiocpu")->base();
	834	m_protection_result = rom[0x2000 | (m_protection_state & 0x1fff)]; // probably needs a BITSWAP8
836	835
837	836	// and an irq on the main z80 afterwards
838		machine.device("maincpu")->execute().set_input_line(0, HOLD_LINE );
	837	machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE );
839	838	}
840	839
841	840
r20824	r20825
844	843	// d7 high: set latch + advance address high bits (and reset low bits?)
845	844	if (data & 0x80)
846	845	{
847		monsterz_set_latch(machine());
	846	monsterz_set_latch();
848	847	m_protection_state = (m_protection_state + 0x100) & 0xff00;
849	848	}
850	849	}
r20824	r20825
854	853	// d3 high: set latch + advance address low bits
855	854	if (data & 0x08)
856	855	{
857		monsterz_set_latch(machine());
	856	monsterz_set_latch();
858	857	m_protection_state = ((m_protection_state + 1) & 0x00ff) | (m_protection_state & 0xff00);
859	858	}
860	859	}
r20824	r20825
2514	2513	*
2515	2514	*************************************/
2516	2515
2517		static void decode_mooncrst(running_machine &machine, int length, UINT8 *dest)
	2516	void galaxian_state::decode_mooncrst(int length, UINT8 *dest)
2518	2517	{
2519		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
	2518	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
2520	2519	int offs;
2521	2520
2522	2521	for (offs = 0; offs < length; offs++)
r20824	r20825
2531	2530	}
2532	2531
2533	2532
2534		static void decode_checkman(running_machine &machine)
	2533	void galaxian_state::decode_checkman()
2535	2534	{
2536	2535	/*
2537	2536	Encryption Table
r20824	r20825
2578	2577	{ 0,2,0,2 },
2579	2578	{ 1,4,1,4 }
2580	2579	};
2581		UINT8 *rombase = machine.root_device().memregion("maincpu")->base();
2582		UINT32 romlength = machine.root_device().memregion("maincpu")->bytes();
	2580	UINT8 *rombase = machine().root_device().memregion("maincpu")->base();
	2581	UINT32 romlength = machine().root_device().memregion("maincpu")->bytes();
2583	2582	UINT32 offs;
2584	2583
2585	2584	for (offs = 0; offs < romlength; offs++)
r20824	r20825
2593	2592	}
2594	2593
2595	2594
2596		static void decode_dingoe(running_machine &machine)
	2595	void galaxian_state::decode_dingoe()
2597	2596	{
2598		UINT8 *rombase = machine.root_device().memregion("maincpu")->base();
2599		UINT32 romlength = machine.root_device().memregion("maincpu")->bytes();
	2597	UINT8 *rombase = machine().root_device().memregion("maincpu")->base();
	2598	UINT32 romlength = machine().root_device().memregion("maincpu")->bytes();
2600	2599	UINT32 offs;
2601	2600
2602	2601	for (offs = 0; offs < romlength; offs++)
r20824	r20825
2616	2615	}
2617	2616
2618	2617
2619		static void decode_frogger_sound(running_machine &machine)
	2618	void galaxian_state::decode_frogger_sound()
2620	2619	{
2621		UINT8 *rombase = machine.root_device().memregion("audiocpu")->base();
	2620	UINT8 *rombase = machine().root_device().memregion("audiocpu")->base();
2622	2621	UINT32 offs;
2623	2622
2624	2623	/* the first ROM of the sound CPU has data lines D0 and D1 swapped */
r20824	r20825
2627	2626	}
2628	2627
2629	2628
2630		static void decode_frogger_gfx(running_machine &machine)
	2629	void galaxian_state::decode_frogger_gfx()
2631	2630	{
2632		UINT8 *rombase = machine.root_device().memregion("gfx1")->base();
	2631	UINT8 *rombase = machine().root_device().memregion("gfx1")->base();
2633	2632	UINT32 offs;
2634	2633
2635	2634	/* the 2nd gfx ROM has data lines D0 and D1 swapped */
r20824	r20825
2638	2637	}
2639	2638
2640	2639
2641		static void decode_anteater_gfx(running_machine &machine)
	2640	void galaxian_state::decode_anteater_gfx()
2642	2641	{
2643		UINT32 romlength = machine.root_device().memregion("gfx1")->bytes();
2644		UINT8 *rombase = machine.root_device().memregion("gfx1")->base();
2645		UINT8 *scratch = auto_alloc_array(machine, UINT8, romlength);
	2642	UINT32 romlength = machine().root_device().memregion("gfx1")->bytes();
	2643	UINT8 *rombase = machine().root_device().memregion("gfx1")->base();
	2644	UINT8 *scratch = auto_alloc_array(machine(), UINT8, romlength);
2646	2645	UINT32 offs;
2647	2646
2648	2647	memcpy(scratch, rombase, romlength);
r20824	r20825
2654	2653	srcoffs |= (BIT(offs,0) ^ BIT(offs,6) ^ 1) << 10;
2655	2654	rombase[offs] = scratch[srcoffs];
2656	2655	}
2657		auto_free(machine, scratch);
	2656	auto_free(machine(), scratch);
2658	2657	}
2659	2658
2660	2659
2661		static void decode_losttomb_gfx(running_machine &machine)
	2660	void galaxian_state::decode_losttomb_gfx()
2662	2661	{
2663		UINT32 romlength = machine.root_device().memregion("gfx1")->bytes();
2664		UINT8 *rombase = machine.root_device().memregion("gfx1")->base();
2665		UINT8 *scratch = auto_alloc_array(machine, UINT8, romlength);
	2662	UINT32 romlength = machine().root_device().memregion("gfx1")->bytes();
	2663	UINT8 *rombase = machine().root_device().memregion("gfx1")->base();
	2664	UINT8 *scratch = auto_alloc_array(machine(), UINT8, romlength);
2666	2665	UINT32 offs;
2667	2666
2668	2667	memcpy(scratch, rombase, romlength);
r20824	r20825
2674	2673	srcoffs |= ((BIT(offs,1) & BIT(offs,7)) | ((1 ^ BIT(offs,1)) & (BIT(offs,8)))) << 10;
2675	2674	rombase[offs] = scratch[srcoffs];
2676	2675	}
2677		auto_free(machine, scratch);
	2676	auto_free(machine(), scratch);
2678	2677	}
2679	2678
2680	2679
2681		static void decode_superbon(running_machine &machine)
	2680	void galaxian_state::decode_superbon()
2682	2681	{
2683	2682	offs_t i;
2684	2683	UINT8 *RAM;
2685	2684
2686	2685	/* Deryption worked out by hand by Chris Hardy. */
2687	2686
2688		RAM = machine.root_device().memregion("maincpu")->base();
	2687	RAM = machine().root_device().memregion("maincpu")->base();
2689	2688
2690	2689	for (i = 0;i < 0x1000;i++)
2691	2690	{
r20824	r20825
2715	2714	*
2716	2715	*************************************/
2717	2716
2718		static void common_init(
2719		running_machine &machine,
2720		galaxian_draw_bullet_func draw_bullet,
2721		galaxian_draw_background_func draw_background,
2722		galaxian_extend_tile_info_func extend_tile_info,
2723		galaxian_extend_sprite_info_func extend_sprite_info)
	2717	void galaxian_state::common_init(galaxian_draw_bullet_func draw_bullet,galaxian_draw_background_func draw_background,
	2718	galaxian_extend_tile_info_func extend_tile_info,galaxian_extend_sprite_info_func extend_sprite_info)
2724	2719	{
2725		galaxian_state *state = machine.driver_data<galaxian_state>();
2726		state->m_irq_enabled = 0;
2727		state->m_irq_line = INPUT_LINE_NMI;
2728		state->m_numspritegens = 1;
2729		state->m_bullets_base = 0x60;
2730		state->m_frogger_adjust = FALSE;
2731		state->m_sfx_tilemap = FALSE;
2732		state->m_draw_bullet_ptr = (draw_bullet != NULL) ? draw_bullet : galaxian_draw_bullet;
2733		state->m_draw_background_ptr = (draw_background != NULL) ? draw_background : galaxian_draw_background;
2734		state->m_extend_tile_info_ptr = extend_tile_info;
2735		state->m_extend_sprite_info_ptr = extend_sprite_info;
	2720	m_irq_enabled = 0;
	2721	m_irq_line = INPUT_LINE_NMI;
	2722	m_numspritegens = 1;
	2723	m_bullets_base = 0x60;
	2724	m_frogger_adjust = FALSE;
	2725	m_sfx_tilemap = FALSE;
	2726	m_draw_bullet_ptr = (draw_bullet != NULL) ? draw_bullet : &galaxian_state::galaxian_draw_bullet;
	2727	m_draw_background_ptr = (draw_background != NULL) ? draw_background : &galaxian_state::galaxian_draw_background;
	2728	m_extend_tile_info_ptr = extend_tile_info;
	2729	m_extend_sprite_info_ptr = extend_sprite_info;
2736	2730	}
2737	2731
2738	2732
2739		static void unmap_galaxian_sound(running_machine &machine, offs_t base)
	2733	void galaxian_state::unmap_galaxian_sound(offs_t base)
2740	2734	{
2741		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	2735	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2742	2736
2743	2737	space.unmap_write(base + 0x0004, base + 0x0007, 0, 0x07f8);
2744	2738	space.unmap_write(base + 0x0800, base + 0x0807, 0, 0x07f8);
r20824	r20825
2755	2749
2756	2750	DRIVER_INIT_MEMBER(galaxian_state,galaxian)
2757	2751	{
2758		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
	2752	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
2759	2753	}
2760	2754
2761	2755
r20824	r20825
2776	2770	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2777	2771
2778	2772	/* yellow bullets instead of white ones */
2779		common_init(machine(), scramble_draw_bullet, galaxian_draw_background, NULL, NULL);
	2773	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
2780	2774
2781	2775	/* coin lockout disabled */
2782	2776	space.unmap_write(0x6002, 0x6002, 0, 0x7f8);
r20824	r20825
2788	2782	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2789	2783
2790	2784	/* video extensions */
2791		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, gmgalax_extend_tile_info, gmgalax_extend_sprite_info);
	2785	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::gmgalax_extend_tile_info, &galaxian_state::gmgalax_extend_sprite_info);
2792	2786
2793	2787	/* ROM is banked */
2794	2788	space.install_read_bank(0x0000, 0x3fff, "bank1");
r20824	r20825
2805	2799	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2806	2800
2807	2801	/* video extensions */
2808		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, pisces_extend_tile_info, pisces_extend_sprite_info);
	2802	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::pisces_extend_tile_info, &galaxian_state::pisces_extend_sprite_info);
2809	2803
2810	2804	/* coin lockout replaced by graphics bank */
2811	2805	space.install_write_handler(0x6002, 0x6002, 0, 0x7f8, write8_delegate(FUNC(galaxian_state::galaxian_gfxbank_w),this));
r20824	r20825
2817	2811	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2818	2812
2819	2813	/* video extensions */
2820		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
	2814	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::batman2_extend_tile_info, &galaxian_state::upper_extend_sprite_info);
2821	2815
2822	2816	/* coin lockout replaced by graphics bank */
2823	2817	space.install_write_handler(0x6002, 0x6002, 0, 0x7f8, write8_delegate(FUNC(galaxian_state::galaxian_gfxbank_w),this));
r20824	r20825
2829	2823	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2830	2824
2831	2825	/* same as galaxian... */
2832		common_init(machine(), galaxian_draw_bullet, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
	2826	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::frogger_draw_background, &galaxian_state::frogger_extend_tile_info, &galaxian_state::frogger_extend_sprite_info);
2833	2827
2834	2828	/* ...but needs a full 2k of RAM */
2835	2829	space.install_ram(0x4000, 0x47ff);
r20824	r20825
2846	2840	DRIVER_INIT_MEMBER(galaxian_state,mooncrst)
2847	2841	{
2848	2842	/* video extensions */
2849		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
	2843	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mooncrst_extend_tile_info, &galaxian_state::mooncrst_extend_sprite_info);
2850	2844
2851	2845	/* decrypt program code */
2852		decode_mooncrst(machine(), 0x8000, machine().root_device().memregion("maincpu")->base());
	2846	decode_mooncrst(0x8000, machine().root_device().memregion("maincpu")->base());
2853	2847	}
2854	2848
2855	2849
2856	2850	DRIVER_INIT_MEMBER(galaxian_state,mooncrsu)
2857	2851	{
2858	2852	/* video extensions */
2859		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
	2853	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mooncrst_extend_tile_info, &galaxian_state::mooncrst_extend_sprite_info);
2860	2854	}
2861	2855
2862	2856
r20824	r20825
2865	2859	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2866	2860
2867	2861	/* video extensions */
2868		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
	2862	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mooncrst_extend_tile_info, &galaxian_state::mooncrst_extend_sprite_info);
2869	2863
2870	2864	/* LEDs and coin lockout replaced by graphics banking */
2871	2865	space.install_write_handler(0x6000, 0x6002, 0, 0x7f8, write8_delegate(FUNC(galaxian_state::galaxian_gfxbank_w),this));
r20824	r20825
2878	2872	UINT8 *decrypt = auto_alloc_array(machine(), UINT8, 0x8000);
2879	2873
2880	2874	/* video extensions */
2881		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, moonqsr_extend_tile_info, moonqsr_extend_sprite_info);
	2875	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::moonqsr_extend_tile_info, &galaxian_state::moonqsr_extend_sprite_info);
2882	2876
2883	2877	/* decrypt program code */
2884		decode_mooncrst(machine(), 0x8000, decrypt);
	2878	decode_mooncrst(0x8000, decrypt);
2885	2879	space.set_decrypted_region(0x0000, 0x7fff, decrypt);
2886	2880	}
2887	2881
r20824	r20825
2957	2951	which tenspot appears to have copied */
2958	2952
2959	2953	/* video extensions */
2960		//common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
	2954	//common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::batman2_extend_tile_info, &galaxian_state::upper_extend_sprite_info);
2961	2955
2962	2956	/* coin lockout replaced by graphics bank */
2963	2957	//space.install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
r20824	r20825
2979	2973	DRIVER_INIT_MEMBER(galaxian_state,devilfsg)
2980	2974	{
2981	2975	/* video extensions */
2982		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
	2976	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
2983	2977
2984	2978	/* IRQ line is INT, not NMI */
2985	2979	m_irq_line = 0;
r20824	r20825
2991	2985	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
2992	2986
2993	2987	/* video extensions */
2994		common_init(machine(), NULL, galaxian_draw_background, NULL, NULL);
	2988	common_init(NULL, &galaxian_state::galaxian_draw_background, NULL, NULL);
2995	2989	m_draw_bullet_ptr = NULL;
2996	2990
2997	2991	/* two sprite generators */
r20824	r20825
3016	3010	space.unmap_write(0x6002, 0x6002, 0, 0x7f8);
3017	3011
3018	3012	/* remove the galaxian sound hardware */
3019		unmap_galaxian_sound(machine(), 0x6000);
	3013	unmap_galaxian_sound( 0x6000);
3020	3014
3021	3015	/* install our AY-8910 handler */
3022	3016	space.install_write_handler(0x4800, 0x4fff, write8_delegate(FUNC(galaxian_state::zigzag_ay8910_w),this));
r20824	r20825
3026	3020	DRIVER_INIT_MEMBER(galaxian_state,jumpbug)
3027	3021	{
3028	3022	/* video extensions */
3029		common_init(machine(), scramble_draw_bullet, jumpbug_draw_background, jumpbug_extend_tile_info, jumpbug_extend_sprite_info);
	3023	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::jumpbug_draw_background, &galaxian_state::jumpbug_extend_tile_info, &galaxian_state::jumpbug_extend_sprite_info);
3030	3024	}
3031	3025
3032	3026
r20824	r20825
3036	3030	address_space &iospace = machine().device("maincpu")->memory().space(AS_IO);
3037	3031
3038	3032	/* video extensions */
3039		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
	3033	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mooncrst_extend_tile_info, &galaxian_state::mooncrst_extend_sprite_info);
3040	3034
3041	3035	/* move the interrupt enable from $b000 to $b001 */
3042	3036	space.unmap_write(0xb000, 0xb000, 0, 0x7f8);
r20824	r20825
3046	3040	iospace.install_write_handler(0x00, 0x00, 0, 0xffff, write8_delegate(FUNC(galaxian_state::checkman_sound_command_w),this));
3047	3041
3048	3042	/* decrypt program code */
3049		decode_checkman(machine());
	3043	decode_checkman();
3050	3044	}
3051	3045
3052	3046
r20824	r20825
3055	3049	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3056	3050
3057	3051	/* video extensions */
3058		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
	3052	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
3059	3053
3060	3054	/* attach the sound command handler */
3061	3055	space.install_write_handler(0x7800, 0x7800, 0, 0x7ff, write8_delegate(FUNC(galaxian_state::checkman_sound_command_w),this));
r20824	r20825
3070	3064	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3071	3065
3072	3066	/* video extensions */
3073		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
	3067	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
3074	3068
3075	3069	/* attach the sound command handler */
3076	3070	space.install_write_handler(0x7800, 0x7800, 0, 0x7ff, write8_delegate(FUNC(galaxian_state::checkman_sound_command_w),this));
r20824	r20825
3086	3080	address_space &iospace = machine().device("maincpu")->memory().space(AS_IO);
3087	3081
3088	3082	/* video extensions */
3089		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
	3083	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mooncrst_extend_tile_info, &galaxian_state::mooncrst_extend_sprite_info);
3090	3084
3091	3085	/* move the interrupt enable from $b000 to $b001 */
3092	3086	space.unmap_write(0xb000, 0xb000, 0, 0x7f8);
r20824	r20825
3098	3092	space.install_read_handler(0x3001, 0x3001, read8_delegate(FUNC(galaxian_state::dingoe_3001_r),this));   /* Protection check */
3099	3093
3100	3094	/* decrypt program code */
3101		decode_dingoe(machine());
	3095	decode_dingoe();
3102	3096	}
3103	3097
3104	3098
r20824	r20825
3107	3101	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3108	3102
3109	3103	/* video extensions */
3110		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, pisces_extend_tile_info, pisces_extend_sprite_info);
	3104	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::pisces_extend_tile_info, &galaxian_state::pisces_extend_sprite_info);
3111	3105
3112	3106	/* coin lockout replaced by graphics bank */
3113	3107	space.install_write_handler(0xa002, 0xa002, 0, 0x7f8, write8_delegate(FUNC(galaxian_state::galaxian_gfxbank_w),this));
r20824	r20825
3125	3119	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3126	3120
3127	3121	/* video extensions */
3128		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, upper_extend_sprite_info);
	3122	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, &galaxian_state::upper_extend_sprite_info);
3129	3123
3130	3124	/* needs a full 2k of RAM */
3131	3125	space.install_ram(0x8000, 0x87ff);
r20824	r20825
3135	3129	}
3136	3130
3137	3131
3138		static void mshuttle_decode(running_machine &machine, const UINT8 convtable[8][16])
	3132	void galaxian_state::mshuttle_decode(const UINT8 convtable[8][16])
3139	3133	{
3140		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
3141		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
3142		UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x10000);
	3134	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	3135	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
	3136	UINT8 *decrypt = auto_alloc_array(machine(), UINT8, 0x10000);
3143	3137	int A;
3144	3138
3145	3139	space.set_decrypted_region(0x0000, 0xffff, decrypt);
r20824	r20825
3178	3172	};
3179	3173
3180	3174	/* video extensions */
3181		common_init(machine(), mshuttle_draw_bullet, galaxian_draw_background, mshuttle_extend_tile_info, mshuttle_extend_sprite_info);
	3175	common_init(&galaxian_state::mshuttle_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mshuttle_extend_tile_info, &galaxian_state::mshuttle_extend_sprite_info);
3182	3176
3183	3177	/* IRQ line is INT, not NMI */
3184	3178	m_irq_line = 0;
3185	3179
3186	3180	/* decrypt the code */
3187		mshuttle_decode(machine(), convtable);
	3181	mshuttle_decode(convtable);
3188	3182	}
3189	3183
3190	3184
r20824	r20825
3203	3197	};
3204	3198
3205	3199	/* video extensions */
3206		common_init(machine(), mshuttle_draw_bullet, galaxian_draw_background, mshuttle_extend_tile_info, mshuttle_extend_sprite_info);
	3200	common_init(&galaxian_state::mshuttle_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mshuttle_extend_tile_info, &galaxian_state::mshuttle_extend_sprite_info);
3207	3201
3208	3202	/* IRQ line is INT, not NMI */
3209	3203	m_irq_line = 0;
3210	3204
3211	3205	/* decrypt the code */
3212		mshuttle_decode(machine(), convtable);
	3206	mshuttle_decode(convtable);
3213	3207	}
3214	3208
3215	3209
3216	3210	DRIVER_INIT_MEMBER(galaxian_state,fantastc)
3217	3211	{
3218	3212	/* video extensions */
3219		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, upper_extend_sprite_info);
	3213	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, &galaxian_state::upper_extend_sprite_info);
3220	3214
3221	3215	/* two sprite generators */
3222	3216	m_numspritegens = 2;
r20824	r20825
3251	3245	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3252	3246
3253	3247	/* video extensions */
3254		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
	3248	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
3255	3249
3256	3250	/* disable the stars */
3257	3251	space.unmap_write(0xb004, 0xb004, 0, 0x07f8);
r20824	r20825
3271	3265	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3272	3266
3273	3267	/* video extensions */
3274		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
	3268	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::batman2_extend_tile_info, &galaxian_state::upper_extend_sprite_info);
3275	3269
3276	3270	/* move the interrupt enable from $b000 to $b001 */
3277	3271	space.unmap_write(0xb000, 0xb000, 0, 0x7f8);
r20824	r20825
3292	3286	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3293	3287
3294	3288	/* video extensions */
3295		common_init(machine(), galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
	3289	common_init(&galaxian_state::galaxian_draw_bullet, &galaxian_state::galaxian_draw_background, &galaxian_state::mooncrst_extend_tile_info, &galaxian_state::mooncrst_extend_sprite_info);
3296	3290
3297	3291	/* move the interrupt enable from $b000 to $b001 */
3298	3292	space.unmap_write(0xb000, 0xb000, 0, 0x7f8);
r20824	r20825
3316	3310	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3317	3311
3318	3312	/* video extensions */
3319		common_init(machine(), theend_draw_bullet, galaxian_draw_background, NULL, NULL);
	3313	common_init(&galaxian_state::theend_draw_bullet, &galaxian_state::galaxian_draw_background, NULL, NULL);
3320	3314
3321	3315	/* coin counter on the upper bit of port C */
3322	3316	space.unmap_write(0x6802, 0x6802, 0, 0x7f8);
r20824	r20825
3326	3320	DRIVER_INIT_MEMBER(galaxian_state,scramble)
3327	3321	{
3328	3322	/* video extensions */
3329		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3323	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3330	3324	}
3331	3325
3332	3326
r20824	r20825
3335	3329	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3336	3330
3337	3331	/* video extensions */
3338		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3332	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3339	3333
3340	3334	/* watchdog works for writes as well? (or is it just disabled?) */
3341	3335	space.install_write_handler(0x7000, 0x7000, 0, 0x7ff, write8_delegate(FUNC(galaxian_state::watchdog_reset_w),this));
r20824	r20825
3354	3348	DRIVER_INIT_MEMBER(galaxian_state,sfx)
3355	3349	{
3356	3350	/* basic configuration */
3357		common_init(machine(), scramble_draw_bullet, scramble_draw_background, upper_extend_tile_info, NULL);
	3351	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, &galaxian_state::upper_extend_tile_info, NULL);
3358	3352	m_sfx_tilemap = TRUE;
3359	3353
3360	3354	/* sound board has space for extra ROM */
r20824	r20825
3368	3362	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3369	3363
3370	3364	/* video extensions */
3371		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3365	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3372	3366
3373	3367	/* watchdog is at $7800? (or is it just disabled?) */
3374	3368	space.unmap_read(0x7000, 0x7000, 0, 0x7ff);
r20824	r20825
3379	3373	DRIVER_INIT_MEMBER(galaxian_state,scobra)
3380	3374	{
3381	3375	/* video extensions */
3382		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3376	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3383	3377	}
3384	3378
3385	3379
3386	3380	DRIVER_INIT_MEMBER(galaxian_state,losttomb)
3387	3381	{
3388	3382	/* video extensions */
3389		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3383	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3390	3384
3391	3385	/* decrypt */
3392		decode_losttomb_gfx(machine());
	3386	decode_losttomb_gfx();
3393	3387	}
3394	3388
3395	3389
3396	3390	DRIVER_INIT_MEMBER(galaxian_state,frogger)
3397	3391	{
3398	3392	/* video extensions */
3399		common_init(machine(), NULL, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
	3393	common_init(NULL, &galaxian_state::frogger_draw_background, &galaxian_state::frogger_extend_tile_info, &galaxian_state::frogger_extend_sprite_info);
3400	3394	m_frogger_adjust = TRUE;
3401	3395
3402	3396	/* decrypt */
3403		decode_frogger_sound(machine());
3404		decode_frogger_gfx(machine());
	3397	decode_frogger_sound();
	3398	decode_frogger_gfx();
3405	3399	}
3406	3400
3407	3401
r20824	r20825
3410	3404	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3411	3405
3412	3406	/* video extensions */
3413		common_init(machine(), NULL, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
	3407	common_init(NULL, &galaxian_state::frogger_draw_background, &galaxian_state::frogger_extend_tile_info, &galaxian_state::frogger_extend_sprite_info);
3414	3408
3415	3409	space.install_write_handler(0xa800, 0xa800, 0, 0x7ff, write8_delegate(FUNC(galaxian_state::soundlatch_byte_w),this));
3416	3410	space.install_write_handler(0xb001, 0xb001, 0, 0x7f8, write8_delegate(FUNC(galaxian_state::froggrmc_sound_control_w),this));
r20824	r20825
3419	3413	space.install_ram(0x8000, 0x87ff);
3420	3414
3421	3415	/* decrypt */
3422		decode_frogger_sound(machine());
	3416	decode_frogger_sound();
3423	3417	}
3424	3418
3425	3419
3426	3420	DRIVER_INIT_MEMBER(galaxian_state,froggers)
3427	3421	{
3428	3422	/* video extensions */
3429		common_init(machine(), NULL, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
	3423	common_init(NULL, &galaxian_state::frogger_draw_background, &galaxian_state::frogger_extend_tile_info, &galaxian_state::frogger_extend_sprite_info);
3430	3424
3431	3425	/* decrypt */
3432		decode_frogger_sound(machine());
	3426	decode_frogger_sound();
3433	3427	}
3434	3428
3435	3429
3436	3430	DRIVER_INIT_MEMBER(galaxian_state,turtles)
3437	3431	{
3438	3432	/* video extensions */
3439		common_init(machine(), NULL, turtles_draw_background, NULL, NULL);
	3433	common_init(NULL, &galaxian_state::turtles_draw_background, NULL, NULL);
3440	3434	}
3441	3435
3442	3436
r20824	r20825
3445	3439	{
3446	3440	/* no existing amidar sets run on Amidar hardware as described by Amidar schematics! */
3447	3441	/* video extensions */
3448		common_init(machine(), scramble_draw_bullet, amidar_draw_background, NULL, NULL);
	3442	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::amidar_draw_background, NULL, NULL);
3449	3443	}
3450	3444	#endif
3451	3445
r20824	r20825
3454	3448	{
3455	3449	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
3456	3450
3457		common_init(machine(), scramble_draw_bullet, scramble_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
	3451	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, &galaxian_state::batman2_extend_tile_info, &galaxian_state::upper_extend_sprite_info);
3458	3452
3459	3453	/* hook up AY8910 */
3460	3454	machine().device("audiocpu")->memory().space(AS_IO).install_readwrite_handler(0x00, 0xff, read8_delegate(FUNC(galaxian_state::scorpion_ay8910_r),this), write8_delegate(FUNC(galaxian_state::scorpion_ay8910_w),this));
r20824	r20825
3490	3484	DRIVER_INIT_MEMBER(galaxian_state,anteater)
3491	3485	{
3492	3486	/* video extensions */
3493		common_init(machine(), scramble_draw_bullet, anteater_draw_background, NULL, NULL);
	3487	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::anteater_draw_background, NULL, NULL);
3494	3488
3495	3489	/* decode graphics */
3496		decode_anteater_gfx(machine());
	3490	decode_anteater_gfx();
3497	3491	}
3498	3492
3499	3493
3500	3494	DRIVER_INIT_MEMBER(galaxian_state,anteateruk)
3501	3495	{
3502	3496	/* video extensions */
3503		common_init(machine(), scramble_draw_bullet, anteater_draw_background, NULL, NULL);
	3497	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::anteater_draw_background, NULL, NULL);
3504	3498	}
3505	3499
3506	3500
3507	3501	DRIVER_INIT_MEMBER(galaxian_state,superbon)
3508	3502	{
3509	3503	/* video extensions */
3510		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3504	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3511	3505
3512	3506	/* decode code */
3513		decode_superbon(machine());
	3507	decode_superbon();
3514	3508	}
3515	3509
3516	3510
3517	3511	DRIVER_INIT_MEMBER(galaxian_state,calipso)
3518	3512	{
3519	3513	/* video extensions */
3520		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, calipso_extend_sprite_info);
	3514	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, &galaxian_state::calipso_extend_sprite_info);
3521	3515	}
3522	3516
3523	3517
3524	3518	DRIVER_INIT_MEMBER(galaxian_state,moonwar)
3525	3519	{
3526	3520	/* video extensions */
3527		common_init(machine(), scramble_draw_bullet, scramble_draw_background, NULL, NULL);
	3521	common_init(&galaxian_state::scramble_draw_bullet, &galaxian_state::scramble_draw_background, NULL, NULL);
3528	3522
3529	3523	state_save_register_global(machine(), m_moonwar_port_select);
3530	3524	}
r20824	r20825
3543	3537	DRIVER_INIT_MEMBER( galaxian_state, froggrs )
3544	3538	{
3545	3539	/* video extensions */
3546		common_init(machine(), NULL, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
	3540	common_init(NULL, &galaxian_state::frogger_draw_background, &galaxian_state::frogger_extend_tile_info, &galaxian_state::frogger_extend_sprite_info);
3547	3541
3548	3542	/* decrypt */
3549		decode_frogger_sound(machine());
3550		decode_frogger_gfx(machine());
	3543	decode_frogger_sound();
	3544	decode_frogger_gfx();
3551	3545	}
3552	3546
3553	3547

trunk/src/mame/drivers/gaiden.c

r20824	r20825
1506	1506	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x07a804, 0x07a805, write16_delegate(FUNC(gaiden_state::raiga_protection_w),this));
1507	1507	}
1508	1508
1509		static void descramble_drgnbowl_gfx(running_machine &machine)
	1509	void gaiden_state::descramble_drgnbowl_gfx()
1510	1510	{
1511	1511	int i;
1512		UINT8 *ROM = machine.root_device().memregion("maincpu")->base();
1513		size_t size = machine.root_device().memregion("maincpu")->bytes();
1514		UINT8 *buffer = auto_alloc_array(machine, UINT8, size);
	1512	UINT8 *ROM = machine().root_device().memregion("maincpu")->base();
	1513	size_t size = machine().root_device().memregion("maincpu")->bytes();
	1514	UINT8 *buffer = auto_alloc_array(machine(), UINT8, size);
1515	1515
1516	1516	memcpy(buffer, ROM, size);
1517	1517	for( i = 0; i < size; i++ )
r20824	r20825
1524	1524	3, 2, 1, 0)];
1525	1525	}
1526	1526
1527		auto_free(machine, buffer);
	1527	auto_free(machine(), buffer);
1528	1528
1529		ROM = machine.root_device().memregion("gfx2")->base();
1530		size = machine.root_device().memregion("gfx2")->bytes();
1531		buffer = auto_alloc_array(machine, UINT8, size);
	1529	ROM = machine().root_device().memregion("gfx2")->base();
	1530	size = machine().root_device().memregion("gfx2")->bytes();
	1531	buffer = auto_alloc_array(machine(), UINT8, size);
1532	1532
1533	1533	memcpy(buffer,ROM,size);
1534	1534	for( i = 0; i < size; i++ )
r20824	r20825
1541	1541	5, 2, 1, 0)];
1542	1542	}
1543	1543
1544		auto_free(machine, buffer);
	1544	auto_free(machine(), buffer);
1545	1545	}
1546	1546
1547	1547	DRIVER_INIT_MEMBER(gaiden_state,drgnbowl)
1548	1548	{
1549	1549	m_raiga_jumppoints = jumppoints_00;
1550	1550
1551		descramble_drgnbowl_gfx(machine());
	1551	descramble_drgnbowl_gfx();
1552	1552	}
1553	1553
1554		static void descramble_mastninj_gfx(running_machine &machine, UINT8* src)
	1554	void gaiden_state::descramble_mastninj_gfx(UINT8* src)
1555	1555	{
1556	1556	UINT8 *buffer;
1557	1557	int len = 0x80000;
1558	1558
1559	1559	/*  rearrange gfx */
1560		buffer = auto_alloc_array(machine, UINT8, len);
	1560	buffer = auto_alloc_array(machine(), UINT8, len);
1561	1561	{
1562	1562	int i;
1563	1563	for (i = 0;i < len; i++)
r20824	r20825
1571	1571	3,2,1,0)];
1572	1572	}
1573	1573	memcpy(src, buffer, len);
1574		auto_free(machine, buffer);
	1574	auto_free(machine(), buffer);
1575	1575	}
1576	1576
1577		buffer = auto_alloc_array(machine, UINT8, len);
	1577	buffer = auto_alloc_array(machine(), UINT8, len);
1578	1578	{
1579	1579	int i;
1580	1580	for (i = 0; i < len; i++)
r20824	r20825
1588	1588	3,2,1,0)];
1589	1589	}
1590	1590	memcpy(src, buffer, len);
1591		auto_free(machine, buffer);
	1591	auto_free(machine(), buffer);
1592	1592	}
1593	1593	}
1594	1594
1595	1595	DRIVER_INIT_MEMBER(gaiden_state,mastninj)
1596	1596	{
1597	1597	// rearrange the graphic roms into a format that MAME can decode
1598		descramble_mastninj_gfx(machine(), machine().root_device().memregion("gfx2")->base());
1599		descramble_mastninj_gfx(machine(), machine().root_device().memregion("gfx3")->base());
	1598	descramble_mastninj_gfx(machine().root_device().memregion("gfx2")->base());
	1599	descramble_mastninj_gfx(machine().root_device().memregion("gfx3")->base());
1600	1600	DRIVER_INIT_CALL(shadoww);
1601	1601	}
1602	1602

trunk/src/mame/drivers/gijoe.c

r20824	r20825
82	82	}
83	83	}
84	84
85		static void gijoe_objdma( running_machine &machine )
	85	void gijoe_state::gijoe_objdma(  )
86	86	{
87		gijoe_state *state = machine.driver_data<gijoe_state>();
88	87	UINT16 *src_head, *src_tail, *dst_head, *dst_tail;
89	88
90		src_head = state->m_spriteram;
91		src_tail = state->m_spriteram + 255 * 8;
92		k053247_get_ram(state->m_k053246, &dst_head);
	89	src_head = m_spriteram;
	90	src_tail = m_spriteram + 255 * 8;
	91	k053247_get_ram(m_k053246, &dst_head);
93	92	dst_tail = dst_head + 255 * 8;
94	93
95	94	for (; src_head <= src_tail; src_head += 8)
r20824	r20825
121	120
122	121	if (k053246_is_irq_enabled(m_k053246))
123	122	{
124		gijoe_objdma(machine());
	123	gijoe_objdma();
125	124
126	125	// 42.7us(clr) + 341.3us(xfer) delay at 6Mhz dotclock
127	126	m_dmadelay_timer->adjust(JOE_DMADELAY);

trunk/src/mame/drivers/galaga.c

r20824	r20825
882	882	save_item(NAME(m_sub2_nmi_mask));
883	883	}
884	884
885		static void bosco_latch_reset(running_machine &machine)
	885	void galaga_state::bosco_latch_reset()
886	886	{
887		galaga_state *state = machine.driver_data<galaga_state>();
888		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	887	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
889	888	int i;
890	889
891	890	/* Reset all latches */
892	891	for (i = 0;i < 8;i++)
893		state->bosco_latch_w(space,i,0);
	892	bosco_latch_w(space,i,0);
894	893	}
895	894
896	895	MACHINE_RESET_MEMBER(galaga_state,galaga)
897	896	{
898	897	/* Reset all latches */
899		bosco_latch_reset(machine());
	898	bosco_latch_reset();
900	899
901	900	m_cpu3_interrupt_timer->adjust(machine().primary_screen->time_until_pos(64), 64);
902	901	}

trunk/src/mame/drivers/gladiatr.c

r20824	r20825
982	982	ROM_END
983	983
984	984
985		static void swap_block(UINT8 *src1,UINT8 *src2,int len)
	985	void gladiatr_state::swap_block(UINT8 *src1,UINT8 *src2,int len)
986	986	{
987	987	int i,t;
988	988

trunk/src/mame/drivers/gsword.c

r20824	r20825
150	150
151	151
152	152	#if 0
153		static int gsword_coins_in(void)
	153	int ::gsword_coins_in(void)
154	154	{
155	155	/* emulate 8741 coin slot */
156		if (machine.root_device().ioport("IN4")->read() & 0xc0)
	156	if (machine().root_device().ioport("IN4")->read() & 0xc0)
157	157	{
158	158	logerror("Coin In\n");
159	159	return 0x80;

trunk/src/mame/drivers/glass.c

r20824	r20825
284	284
285	285	***************************************************************************/
286	286
287		static void glass_ROM16_split_gfx( running_machine &machine, const char *src_reg, const char *dst_reg, int start, int length, int dest1, int dest2 )
	287	void glass_state::glass_ROM16_split_gfx( const char *src_reg, const char *dst_reg, int start, int length, int dest1, int dest2 )
288	288	{
289	289	int i;
290	290
291	291	/* get a pointer to the source data */
292		UINT8 *src = (UINT8 *)machine.root_device().memregion(src_reg)->base();
	292	UINT8 *src = (UINT8 *)machine().root_device().memregion(src_reg)->base();
293	293
294	294	/* get a pointer to the destination data */
295		UINT8 *dst = (UINT8 *)machine.root_device().memregion(dst_reg)->base();
	295	UINT8 *dst = (UINT8 *)machine().root_device().memregion(dst_reg)->base();
296	296
297	297	/* fill destination areas with the proper data */
298	298	for (i = 0; i < length / 2; i++)
r20824	r20825
404	404	*/
405	405
406	406	/* split ROM H13 */
407		glass_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0000000, 0x0200000, 0x0000000, 0x0100000);
	407	glass_ROM16_split_gfx("gfx2", "gfx1", 0x0000000, 0x0200000, 0x0000000, 0x0100000);
408	408
409	409	/* split ROM H11 */
410		glass_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0200000, 0x0200000, 0x0200000, 0x0300000);
	410	glass_ROM16_split_gfx("gfx2", "gfx1", 0x0200000, 0x0200000, 0x0200000, 0x0300000);
411	411
412	412	/* install custom handler over RAM for protection */
413	413	machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfec000, 0xfeffff, read16_delegate(FUNC(glass_state::glass_mainram_r), this), write16_delegate(FUNC(glass_state::glass_mainram_w),this));

trunk/src/mame/machine/galaxold.c

r20824	r20825
64	64	}
65	65
66	66
67		static void machine_reset_common(running_machine &machine, int line)
	67	void galaxold_state::machine_reset_common(int line)
68	68	{
69		galaxold_state *state = machine.driver_data<galaxold_state>();
70		ttl7474_device *ttl7474_9m_1 = machine.device<ttl7474_device>("7474_9m_1");
71		ttl7474_device *ttl7474_9m_2 = machine.device<ttl7474_device>("7474_9m_2");
72		state->m_irq_line = line;
	69	ttl7474_device *ttl7474_9m_1 = machine().device<ttl7474_device>("7474_9m_1");
	70	ttl7474_device *ttl7474_9m_2 = machine().device<ttl7474_device>("7474_9m_2");
	71	m_irq_line = line;
73	72
74	73	/* initalize main CPU interrupt generator flip-flops */
75	74	ttl7474_9m_2->preset_w(1);
r20824	r20825
80	79	ttl7474_9m_1->preset_w(0);
81	80
82	81	/* start a timer to generate interrupts */
83		timer_device *int_timer = machine.device<timer_device>("int_timer");
84		int_timer->adjust(machine.primary_screen->time_until_pos(0));
	82	timer_device *int_timer = machine().device<timer_device>("int_timer");
	83	int_timer->adjust(machine().primary_screen->time_until_pos(0));
85	84	}
86	85
87	86	MACHINE_RESET_MEMBER(galaxold_state,galaxold)
88	87	{
89		machine_reset_common(machine(), INPUT_LINE_NMI);
	88	machine_reset_common(INPUT_LINE_NMI);
90	89	}
91	90
92	91	MACHINE_RESET_MEMBER(galaxold_state,devilfsg)
93	92	{
94		machine_reset_common(machine(), 0);
	93	machine_reset_common(0);
95	94	}
96	95
97	96	MACHINE_RESET_MEMBER(galaxold_state,hunchbkg)
98	97	{
99		machine_reset_common(machine(), 0);
	98	machine_reset_common(0);
100	99	machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(galaxold_state::hunchbkg_irq_callback),this));
101	100	}
102	101
r20824	r20825
281	280	}
282	281
283	282
284		static UINT8 decode_mooncrst(UINT8 data,offs_t addr)
	283	UINT8 galaxold_state::decode_mooncrst(UINT8 data,offs_t addr)
285	284	{
286	285	UINT8 res;
287	286

trunk/src/mame/machine/gaelco2.c

r20824	r20825
17	17
18	18	***************************************************************************/
19	19
20		static void gaelco2_ROM16_split_gfx(running_machine &machine, const char *src_reg, const char *dst_reg, int start, int length, int dest1, int dest2)
	20	void gaelco2_state::gaelco2_ROM16_split_gfx(const char *src_reg, const char *dst_reg, int start, int length, int dest1, int dest2)
21	21	{
22	22	int i;
23	23
24	24	/* get a pointer to the source data */
25		UINT8 *src = (UINT8 *)machine.root_device().memregion(src_reg)->base();
	25	UINT8 *src = (UINT8 *)machine().root_device().memregion(src_reg)->base();
26	26
27	27	/* get a pointer to the destination data */
28		UINT8 *dst = (UINT8 *)machine.root_device().memregion(dst_reg)->base();
	28	UINT8 *dst = (UINT8 *)machine().root_device().memregion(dst_reg)->base();
29	29
30	30	/* fill destination areas with the proper data */
31	31	for (i = 0; i < length/2; i++){
r20824	r20825
62	62	*/
63	63
64	64	/* split ROM u48 */
65		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0000000, 0x0400000, 0x0000000, 0x0400000);
	65	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0000000, 0x0400000, 0x0000000, 0x0400000);
66	66
67	67	/* split ROM u47 */
68		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0400000, 0x0400000, 0x0200000, 0x0600000);
	68	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0400000, 0x0400000, 0x0200000, 0x0600000);
69	69
70	70	/* split ROM u50 */
71		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0800000, 0x0400000, 0x0800000, 0x0c00000);
	71	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0800000, 0x0400000, 0x0800000, 0x0c00000);
72	72
73	73	/* split ROM u49 */
74		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0c00000, 0x0400000, 0x0a00000, 0x0e00000);
	74	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0c00000, 0x0400000, 0x0a00000, 0x0e00000);
75	75	}
76	76
77	77
r20824	r20825
93	93	*/
94	94
95	95	/* split ROM ic65 */
96		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0000000, 0x0400000, 0x0000000, 0x0400000);
	96	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0000000, 0x0400000, 0x0000000, 0x0400000);
97	97
98	98	/* split ROM ic66 */
99		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0400000, 0x0200000, 0x0200000, 0x0600000);
	99	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0400000, 0x0200000, 0x0200000, 0x0600000);
100	100
101	101	/* split ROM ic67 */
102		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0800000, 0x0400000, 0x0800000, 0x0c00000);
	102	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0800000, 0x0400000, 0x0800000, 0x0c00000);
103	103	}
104	104
105	105
r20824	r20825
121	121	*/
122	122
123	123	/* split ROM sb44 */
124		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0000000, 0x0400000, 0x0000000, 0x0400000);
	124	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0000000, 0x0400000, 0x0000000, 0x0400000);
125	125
126	126	/* split ROM sb45 */
127		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0400000, 0x0400000, 0x0200000, 0x0600000);
	127	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0400000, 0x0400000, 0x0200000, 0x0600000);
128	128
129	129	/* split ROM sb46 */
130		gaelco2_ROM16_split_gfx(machine(), "gfx2", "gfx1", 0x0800000, 0x0400000, 0x0800000, 0x0c00000);
	130	gaelco2_ROM16_split_gfx("gfx2", "gfx1", 0x0800000, 0x0400000, 0x0800000, 0x0c00000);
131	131	}
132	132
133	133	/***************************************************************************

trunk/src/mame/video/goindol.c

r20824	r20825
80	80
81	81	***************************************************************************/
82	82
83		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int gfxbank, UINT8 *sprite_ram )
	83	void goindol_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int gfxbank, UINT8 *sprite_ram )
84	84	{
85		goindol_state *state = machine.driver_data<goindol_state>();
86	85	int offs, sx, sy, tile, palette;
87	86
88		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	87	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
89	88	{
90	89	sx = sprite_ram[offs];
91	90	sy = 240 - sprite_ram[offs + 1];
92	91
93		if (state->flip_screen())
	92	if (flip_screen())
94	93	{
95	94	sx = 248 - sx;
96	95	sy = 248 - sy;
r20824	r20825
103	102	palette = sprite_ram[offs + 2] >> 3;
104	103
105	104	drawgfx_transpen(bitmap,cliprect,
106		machine.gfx[gfxbank],
	105	machine().gfx[gfxbank],
107	106	tile,
108	107	palette,
109		state->flip_screen(),state->flip_screen(),
	108	flip_screen(),flip_screen(),
110	109	sx,sy, 0);
111	110	drawgfx_transpen(bitmap,cliprect,
112		machine.gfx[gfxbank],
	111	machine().gfx[gfxbank],
113	112	tile+1,
114	113	palette,
115		state->flip_screen(),state->flip_screen(),
116		sx,sy + (state->flip_screen() ? -8 : 8), 0);
	114	flip_screen(),flip_screen(),
	115	sx,sy + (flip_screen() ? -8 : 8), 0);
117	116	}
118	117	}
119	118	}
r20824	r20825
125	124
126	125	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
127	126	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
128		draw_sprites(machine(), bitmap, cliprect, 1, m_spriteram);
129		draw_sprites(machine(), bitmap, cliprect, 0, m_spriteram2);
	127	draw_sprites(bitmap, cliprect, 1, m_spriteram);
	128	draw_sprites(bitmap, cliprect, 0, m_spriteram2);
130	129	return 0;
131	130	}

trunk/src/mame/video/gsword.c

r20824	r20825
158	158	8, 8, 32, 64);
159	159	}
160	160
161		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	161	void gsword_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
162	162	{
163		gsword_state *state = machine.driver_data<gsword_state>();
164	163	int offs;
165	164
166		for (offs = 0; offs < state->m_spritexy_ram.bytes() - 1; offs+=2)
	165	for (offs = 0; offs < m_spritexy_ram.bytes() - 1; offs+=2)
167	166	{
168	167	int sx,sy,flipx,flipy,spritebank,tile,color;
169	168
170		if (state->m_spritexy_ram[offs]!=0xf1)
	169	if (m_spritexy_ram[offs]!=0xf1)
171	170	{
172	171	spritebank = 0;
173		tile = state->m_spritetile_ram[offs];
174		color = state->m_spritetile_ram[offs+1] & 0x3f;
175		sy = 241-state->m_spritexy_ram[offs];
176		sx = state->m_spritexy_ram[offs+1]-56;
177		flipx = state->m_spriteattrib_ram[offs] & 0x02;
178		flipy = state->m_spriteattrib_ram[offs] & 0x01;
	172	tile = m_spritetile_ram[offs];
	173	color = m_spritetile_ram[offs+1] & 0x3f;
	174	sy = 241-m_spritexy_ram[offs];
	175	sx = m_spritexy_ram[offs+1]-56;
	176	flipx = m_spriteattrib_ram[offs] & 0x02;
	177	flipy = m_spriteattrib_ram[offs] & 0x01;
179	178
180	179	// Adjust sprites that should be far far right!
181	180	if (sx<0) sx+=256;
r20824	r20825
187	186	tile -= 128;
188	187	sy-=16;
189	188	}
190		if (state->m_flipscreen)
	189	if (m_flipscreen)
191	190	{
192	191	flipx = !flipx;
193	192	flipy = !flipy;
194	193	}
195		drawgfx_transmask(bitmap,cliprect,machine.gfx[1+spritebank],
	194	drawgfx_transmask(bitmap,cliprect,machine().gfx[1+spritebank],
196	195	tile,
197	196	color,
198	197	flipx,flipy,
199	198	sx,sy,
200		colortable_get_transpen_mask(machine.colortable, machine.gfx[1+spritebank], color, 0x8f));
	199	colortable_get_transpen_mask(machine().colortable, machine().gfx[1+spritebank], color, 0x8f));
201	200	}
202	201	}
203	202	}
r20824	r20825
205	204	UINT32 gsword_state::screen_update_gsword(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
206	205	{
207	206	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
208		draw_sprites(machine(), bitmap, cliprect);
	207	draw_sprites(bitmap, cliprect);
209	208	return 0;
210	209	}

trunk/src/mame/video/digdug.c

r20824	r20825
237	237
238	238	***************************************************************************/
239	239
240		static void draw_sprites(running_machine& machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	240	void digdug_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
241	241	{
242		digdug_state *state =  machine.driver_data<digdug_state>();
243		UINT8 *spriteram = state->m_digdug_objram + 0x380;
244		UINT8 *spriteram_2 = state->m_digdug_posram + 0x380;
245		UINT8 *spriteram_3 = state->m_digdug_flpram + 0x380;
	242	UINT8 *spriteram = m_digdug_objram + 0x380;
	243	UINT8 *spriteram_2 = m_digdug_posram + 0x380;
	244	UINT8 *spriteram_3 = m_digdug_flpram + 0x380;
246	245	int offs;
247	246
248	247	// mask upper and lower columns
249	248	rectangle visarea = cliprect;
250	249	visarea.min_x = 2*8;
251	250	visarea.max_x = 34*8-1;
252		if (state->flip_screen())
	251	if (flip_screen())
253	252	{
254	253	visarea.min_x += 12*8;
255	254	visarea.max_x += 12*8;
r20824	r20825
277	276	sy -= 16 * size;
278	277	sy = (sy & 0xff) - 32;  // fix wraparound
279	278
280		if (state->flip_screen())
	279	if (flip_screen())
281	280	{
282	281	flipx ^= 1;
283	282	flipy ^= 1;
r20824	r20825
289	288	{
290	289	for (x = 0;x <= size;x++)
291	290	{
292		UINT32 transmask = colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0x1f);
293		drawgfx_transmask(bitmap,visarea,machine.gfx[1],
	291	UINT32 transmask = colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0x1f);
	292	drawgfx_transmask(bitmap,visarea,machine().gfx[1],
294	293	sprite + gfx_offs[y ^ (size * flipy)][x ^ (size * flipx)],
295	294	color,
296	295	flipx,flipy,
297	296	((sx + 16*x) & 0xff), sy + 16*y,transmask);
298	297	/* wraparound */
299		drawgfx_transmask(bitmap,visarea,machine.gfx[1],
	298	drawgfx_transmask(bitmap,visarea,machine().gfx[1],
300	299	sprite + gfx_offs[y ^ (size * flipy)][x ^ (size * flipx)],
301	300	color,
302	301	flipx,flipy,
r20824	r20825
311	310	{
312	311	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
313	312	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
314		draw_sprites(machine(),bitmap,cliprect);
	313	draw_sprites(bitmap,cliprect);
315	314	return 0;
316	315	}

trunk/src/mame/video/gaelco2.c

r20824	r20825
332	332
333	333	***************************************************************************/
334	334
335		static void draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int mask, int xoffs)
	335	void gaelco2_state::draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int mask, int xoffs)
336	336	{
337		gaelco2_state *state = screen.machine().driver_data<gaelco2_state>();
338		UINT16 *buffered_spriteram16 = state->m_spriteram->buffer();
	337	UINT16 *buffered_spriteram16 = m_spriteram->buffer();
339	338	int j, x, y, ex, ey, px, py;
340	339	gfx_element *gfx = screen.machine().gfx[0];
341	340
342	341	/* get sprite ram start and end offsets */
343		int start_offset = (state->m_vregs[1] & 0x10)*0x100;
	342	int start_offset = (m_vregs[1] & 0x10)*0x100;
344	343	int end_offset = start_offset + 0x1000;
345	344
346	345	/* sprite offset is based on the visible area */
347		int spr_x_adjust = (screen.visible_area().max_x - 320 + 1) - (511 - 320 - 1) - ((state->m_vregs[0] >> 4) & 0x01) + xoffs;
	346	int spr_x_adjust = (screen.visible_area().max_x - 320 + 1) - (511 - 320 - 1) - ((m_vregs[0] >> 4) & 0x01) + xoffs;
348	347
349	348	for (j = start_offset; j < end_offset; j += 8){
350	349	int data = buffered_spriteram16[(j/2) + 0];
r20824	r20825
361	360	int xsize = ((data3 >> 12) & 0x0f) + 1;
362	361	int ysize = ((data2 >> 12) & 0x0f) + 1;
363	362
364		if (state->m_dual_monitor && ((data & 0x8000) != mask)) continue;
	363	if (m_dual_monitor && ((data & 0x8000) != mask)) continue;
365	364
366	365	/* if it's enabled, draw it */
367	366	if ((data2 & 0x0200) != 0){
r20824	r20825
371	370	int data5 = buffered_spriteram16[((data4/2) + (y*xsize + x)) & 0x7fff];
372	371	int number = ((data & 0x1ff) << 10) + (data5 & 0x0fff);
373	372	int color = ((data >> 9) & 0x7f) + ((data5 >> 12) & 0x0f);
374		int color_effect = state->m_dual_monitor ? ((color & 0x3f) == 0x3f) : (color == 0x7f);
	373	int color_effect = m_dual_monitor ? ((color & 0x3f) == 0x3f) : (color == 0x7f);
375	374
376	375	ex = xflip ? (xsize - 1 - x) : x;
377	376	ey = yflip ? (ysize - 1 - y) : y;
r20824	r20825
458	457	return 0;
459	458	}
460	459
461		static UINT32 dual_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int index)
	460	UINT32 gaelco2_state::dual_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int index)
462	461	{
463		gaelco2_state *state = screen.machine().driver_data<gaelco2_state>();
464	462	int i;
465	463
466	464	/* read scroll values */
467		int scroll0x = state->m_videoram[0x2802/2] + 0x14;
468		int scroll1x = state->m_videoram[0x2806/2] + 0x10;
469		int scroll0y = state->m_videoram[0x2800/2] + 0x01;
470		int scroll1y = state->m_videoram[0x2804/2] + 0x01;
	465	int scroll0x = m_videoram[0x2802/2] + 0x14;
	466	int scroll1x = m_videoram[0x2806/2] + 0x10;
	467	int scroll0y = m_videoram[0x2800/2] + 0x01;
	468	int scroll1y = m_videoram[0x2804/2] + 0x01;
471	469
472	470	/* set y scroll registers */
473		state->m_pant[0]->set_scrolly(0, scroll0y & 0x1ff);
474		state->m_pant[1]->set_scrolly(0, scroll1y & 0x1ff);
	471	m_pant[0]->set_scrolly(0, scroll0y & 0x1ff);
	472	m_pant[1]->set_scrolly(0, scroll1y & 0x1ff);
475	473
476	474	/* set x linescroll registers */
477	475	for (i = 0; i < 512; i++){
478		state->m_pant[0]->set_scrollx(i & 0x1ff, (state->m_vregs[0] & 0x8000) ? (state->m_videoram[(0x2000/2) + i] + 0x14) & 0x3ff : scroll0x & 0x3ff);
479		state->m_pant[1]->set_scrollx(i & 0x1ff, (state->m_vregs[1] & 0x8000) ? (state->m_videoram[(0x2400/2) + i] + 0x10) & 0x3ff : scroll1x & 0x3ff);
	476	m_pant[0]->set_scrollx(i & 0x1ff, (m_vregs[0] & 0x8000) ? (m_videoram[(0x2000/2) + i] + 0x14) & 0x3ff : scroll0x & 0x3ff);
	477	m_pant[1]->set_scrollx(i & 0x1ff, (m_vregs[1] & 0x8000) ? (m_videoram[(0x2400/2) + i] + 0x10) & 0x3ff : scroll1x & 0x3ff);
480	478	}
481	479
482	480	/* draw screen */
483	481	bitmap.fill(0, cliprect);
484	482
485		state->m_pant[index]->draw(bitmap, cliprect, 0, 0);
	483	m_pant[index]->draw(bitmap, cliprect, 0, 0);
486	484	draw_sprites(screen,bitmap,cliprect, 0x8000 * index, 0);
487	485
488	486	return 0;

trunk/src/mame/video/gotya.c

r20824	r20825
110	110	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gotya_state::get_bg_tile_info),this), tilemap_mapper_delegate(FUNC(gotya_state::tilemap_scan_rows_thehand),this), 8, 8, 64, 32);
111	111	}
112	112
113		static void draw_status_row( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int sx, int col )
	113	void gotya_state::draw_status_row( bitmap_ind16 &bitmap, const rectangle &cliprect, int sx, int col )
114	114	{
115		gotya_state *state = machine.driver_data<gotya_state>();
116	115	int row;
117	116
118		if (state->flip_screen())
	117	if (flip_screen())
119	118	{
120	119	sx = 35 - sx;
121	120	}
r20824	r20825
124	123	{
125	124	int sy;
126	125
127		if (state->flip_screen())
	126	if (flip_screen())
128	127	sy = row;
129	128	else
130	129	sy = 31 - row;
131	130
132	131	drawgfx_opaque(bitmap,cliprect,
133		machine.gfx[0],
134		state->m_videoram2[row * 32 + col],
135		state->m_videoram2[row * 32 + col + 0x10] & 0x0f,
136		state->flip_screen_x(), state->flip_screen_y(),
	132	machine().gfx[0],
	133	m_videoram2[row * 32 + col],
	134	m_videoram2[row * 32 + col + 0x10] & 0x0f,
	135	flip_screen_x(), flip_screen_y(),
137	136	8 * sx, 8 * sy);
138	137	}
139	138	}
140	139
141		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	140	void gotya_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
142	141	{
143		gotya_state *state = machine.driver_data<gotya_state>();
144		UINT8 *spriteram = state->m_spriteram;
	142	UINT8 *spriteram = m_spriteram;
145	143	int offs;
146	144
147	145	for (offs = 2; offs < 0x0e; offs += 2)
r20824	r20825
151	149	int sx = 256 - spriteram[offs + 0x10] + (spriteram[offs + 0x01] & 0x01) * 256;
152	150	int sy = spriteram[offs + 0x00];
153	151
154		if (state->flip_screen())
	152	if (flip_screen())
155	153	sy = 240 - sy;
156	154
157	155	drawgfx_transpen(bitmap,cliprect,
158		machine.gfx[1],
	156	machine().gfx[1],
159	157	code, color,
160		state->flip_screen_x(), state->flip_screen_y(),
	158	flip_screen_x(), flip_screen_y(),
161	159	sx, sy, 0);
162	160	}
163	161	}
164	162
165		static void draw_status( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	163	void gotya_state::draw_status( bitmap_ind16 &bitmap, const rectangle &cliprect )
166	164	{
167		draw_status_row(machine, bitmap, cliprect, 0,  1);
168		draw_status_row(machine, bitmap, cliprect, 1,  0);
169		draw_status_row(machine, bitmap, cliprect, 2,  2);  /* these two are blank, but I dont' know if the data comes */
170		draw_status_row(machine, bitmap, cliprect, 33, 13); /* from RAM or 'hardcoded' into the hardware. Likely the latter */
171		draw_status_row(machine, bitmap, cliprect, 35, 14);
172		draw_status_row(machine, bitmap, cliprect, 34, 15);
	165	draw_status_row(bitmap, cliprect, 0,  1);
	166	draw_status_row(bitmap, cliprect, 1,  0);
	167	draw_status_row(bitmap, cliprect, 2,  2);  /* these two are blank, but I dont' know if the data comes */
	168	draw_status_row(bitmap, cliprect, 33, 13); /* from RAM or 'hardcoded' into the hardware. Likely the latter */
	169	draw_status_row(bitmap, cliprect, 35, 14);
	170	draw_status_row(bitmap, cliprect, 34, 15);
173	171	}
174	172
175	173	UINT32 gotya_state::screen_update_gotya(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
176	174	{
177	175	m_bg_tilemap->set_scrollx(0, -(*m_scroll + (m_scroll_bit_8 * 256)) - 2 * 8);
178	176	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
179		draw_sprites(machine(), bitmap, cliprect);
180		draw_status(machine(), bitmap, cliprect);
	177	draw_sprites(bitmap, cliprect);
	178	draw_status(bitmap, cliprect);
181	179	return 0;
182	180	}

trunk/src/mame/video/fastfred.c

r20824	r20825
352	352	m_fg_tilemap->set_transparent_pen(0);
353	353
354	354	/* the game has a galaxian starfield */
355		galaxold_init_stars(machine(), 256);
	355	galaxold_init_stars(256);
356	356	m_stars_on = 1;
357	357
358	358	/* web colors */
r20824	r20825
363	363	UINT32 fastfred_state::screen_update_imago(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
364	364	{
365	365	m_web_tilemap->draw(bitmap, cliprect, 0,0);
366		galaxold_draw_stars(machine(), bitmap, cliprect);
	366	galaxold_draw_stars(bitmap, cliprect);
367	367	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
368	368	draw_sprites(bitmap, cliprect);
369	369	m_fg_tilemap->draw(bitmap, cliprect, 0,0);

trunk/src/mame/video/xevious.c

r20824	r20825
410	410
411	411	***************************************************************************/
412	412
413		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	413	void xevious_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
414	414	{
415		xevious_state *state =  machine.driver_data<xevious_state>();
416
417		UINT8 *spriteram = state->m_xevious_sr3 + 0x780;
418		UINT8 *spriteram_2 = state->m_xevious_sr1 + 0x780;
419		UINT8 *spriteram_3 = state->m_xevious_sr2 + 0x780;
	415	UINT8 *spriteram = m_xevious_sr3 + 0x780;
	416	UINT8 *spriteram_2 = m_xevious_sr1 + 0x780;
	417	UINT8 *spriteram_3 = m_xevious_sr2 + 0x780;
420	418	int offs,sx,sy;
421	419
422	420	for (offs = 0;offs < 0x80;offs += 2)
r20824	r20825
444	442	sx = spriteram_2[offs + 1] - 40 + 0x100*(spriteram_3[offs + 1] & 1);
445	443	sy = 28*8-spriteram_2[offs]-1;
446	444
447		if (state->flip_screen())
	445	if (flip_screen())
448	446	{
449	447	flipx = !flipx;
450	448	flipy = !flipy;
r20824	r20825
452	450	sx += 96;
453	451	}
454	452
455		transmask = colortable_get_transpen_mask(machine.colortable, machine.gfx[bank], color, 0x80);
	453	transmask = colortable_get_transpen_mask(machine().colortable, machine().gfx[bank], color, 0x80);
456	454
457	455	if (spriteram_3[offs] & 2)  /* double height (?) */
458	456	{
459	457	if (spriteram_3[offs] & 1)  /* double width, double height */
460	458	{
461	459	code &= ~3;
462		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	460	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
463	461	code+3,color,flipx,flipy,
464	462	flipx ? sx : sx+16,flipy ? sy-16 : sy,transmask);
465		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	463	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
466	464	code+1,color,flipx,flipy,
467	465	flipx ? sx : sx+16,flipy ? sy : sy-16,transmask);
468	466	}
469	467	code &= ~2;
470		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	468	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
471	469	code+2,color,flipx,flipy,
472	470	flipx ? sx+16 : sx,flipy ? sy-16 : sy,transmask);
473		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	471	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
474	472	code,color,flipx,flipy,
475	473	flipx ? sx+16 : sx,flipy ? sy : sy-16,transmask);
476	474	}
477	475	else if (spriteram_3[offs] & 1) /* double width */
478	476	{
479	477	code &= ~1;
480		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	478	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
481	479	code,color,flipx,flipy,
482	480	flipx ? sx+16 : sx,flipy ? sy-16 : sy,transmask);
483		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	481	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
484	482	code+1,color,flipx,flipy,
485	483	flipx ? sx : sx+16,flipy ? sy-16 : sy,transmask);
486	484	}
487	485	else    /* normal */
488	486	{
489		drawgfx_transmask(bitmap,cliprect,machine.gfx[bank],
	487	drawgfx_transmask(bitmap,cliprect,machine().gfx[bank],
490	488	code,color,flipx,flipy,sx,sy,transmask);
491	489	}
492	490	}
r20824	r20825
497	495	UINT32 xevious_state::screen_update_xevious(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
498	496	{
499	497	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
500		draw_sprites(machine(), bitmap,cliprect);
	498	draw_sprites(bitmap,cliprect);
501	499	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
502	500	return 0;
503	501	}

trunk/src/mame/video/gotcha.c

r20824	r20825
13	13	return (col & 0x1f) | (row << 5) | ((col & 0x20) << 5);
14	14	}
15	15
16		INLINE void get_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index ,UINT16 *vram, int color_offs)
	16	inline void gotcha_state::get_tile_info( tile_data &tileinfo, int tile_index ,UINT16 *vram, int color_offs)
17	17	{
18		gotcha_state *state = machine.driver_data<gotcha_state>();
19	18	UINT16 data = vram[tile_index];
20		int code = (data & 0x3ff) | (state->m_gfxbank[(data & 0x0c00) >> 10] << 10);
	19	int code = (data & 0x3ff) | (m_gfxbank[(data & 0x0c00) >> 10] << 10);
21	20
22		SET_TILE_INFO(0, code, (data >> 12) + color_offs, 0);
	21	SET_TILE_INFO_MEMBER(0, code, (data >> 12) + color_offs, 0);
23	22	}
24	23
25	24	TILE_GET_INFO_MEMBER(gotcha_state::fg_get_tile_info)
26	25	{
27		get_tile_info(machine(), tileinfo, tile_index, m_fgvideoram, 0);
	26	get_tile_info(tileinfo, tile_index, m_fgvideoram, 0);
28	27	}
29	28
30	29	TILE_GET_INFO_MEMBER(gotcha_state::bg_get_tile_info)
31	30	{
32		get_tile_info(machine(), tileinfo, tile_index, m_bgvideoram, 16);
	31	get_tile_info(tileinfo, tile_index, m_bgvideoram, 16);
33	32	}
34	33
35	34

trunk/src/mame/video/gberet.c

r20824	r20825
125	125	m_bg_tilemap->set_scroll_rows(32);
126	126	}
127	127
128		static void gberet_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	128	void gberet_state::gberet_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
129	129	{
130		gberet_state *state = machine.driver_data<gberet_state>();
131	130	int offs;
132	131	UINT8 *sr;
133	132
134		if (state->m_spritebank & 0x08)
135		sr = state->m_spriteram2;
	133	if (m_spritebank & 0x08)
	134	sr = m_spriteram2;
136	135	else
137		sr = state->m_spriteram;
	136	sr = m_spriteram;
138	137
139	138	for (offs = 0; offs < 0xc0; offs += 4)
140	139	{
r20824	r20825
148	147	int flipx = attr & 0x10;
149	148	int flipy = attr & 0x20;
150	149
151		if (state->flip_screen())
	150	if (flip_screen())
152	151	{
153	152	sx = 240 - sx;
154	153	sy = 240 - sy;
r20824	r20825
156	155	flipy = !flipy;
157	156	}
158	157
159		drawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy,
160		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0));
	158	drawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy,
	159	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0));
161	160	}
162	161	}
163	162	}
r20824	r20825
165	164	UINT32 gberet_state::screen_update_gberet(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
166	165	{
167	166	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES, 0);
168		gberet_draw_sprites(machine(), bitmap, cliprect);
	167	gberet_draw_sprites(bitmap, cliprect);
169	168	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
170	169	return 0;
171	170	}
r20824	r20825
183	182	m_bg_tilemap->set_scrollx(offset, scroll + 64 - 8);
184	183	}
185	184
186		static void gberetb_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	185	void gberet_state::gberetb_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
187	186	{
188		gberet_state *state = machine.driver_data<gberet_state>();
189		UINT8 *spriteram = state->m_spriteram;
	187	UINT8 *spriteram = m_spriteram;
190	188	int offs;
191	189
192		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	190	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
193	191	{
194	192	if (spriteram[offs + 1])
195	193	{
r20824	r20825
201	199	int flipx = attr & 0x10;
202	200	int flipy = attr & 0x20;
203	201
204		if (state->flip_screen())
	202	if (flip_screen())
205	203	{
206	204	sx = 240 - sx;
207	205	sy = 240 - sy;
r20824	r20825
209	207	flipy = !flipy;
210	208	}
211	209
212		drawgfx_transmask(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy,
213		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0));
	210	drawgfx_transmask(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy,
	211	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0));
214	212	}
215	213	}
216	214	}
r20824	r20825
218	216	UINT32 gberet_state::screen_update_gberetb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
219	217	{
220	218	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES, 0);
221		gberetb_draw_sprites(machine(), bitmap, cliprect);
	219	gberetb_draw_sprites(bitmap, cliprect);
222	220	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
223	221	return 0;
224	222	}

trunk/src/mame/video/galpanic.c

r20824	r20825
45	45	}
46	46
47	47
48		static void comad_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	48	void galpanic_state::comad_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
49	49	{
50		galpanic_state *state = machine.driver_data<galpanic_state>();
51		UINT16 *spriteram16 = state->m_spriteram;
	50	UINT16 *spriteram16 = m_spriteram;
52	51	int offs;
53	52	int sx=0, sy=0;
54	53
55		for (offs = 0;offs < state->m_spriteram.bytes()/2;offs += 4)
	54	for (offs = 0;offs < m_spriteram.bytes()/2;offs += 4)
56	55	{
57	56	int code,color,flipx,flipy;
58	57
r20824	r20825
75	74	sx = (sx&0x1ff) - (sx&0x200);
76	75	sy = (sy&0x1ff) - (sy&0x200);
77	76
78		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	77	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
79	78	code,
80	79	color,
81	80	flipx,flipy,
r20824	r20825
83	82	}
84	83	}
85	84
86		static void draw_fgbitmap(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	85	void galpanic_state::draw_fgbitmap(bitmap_ind16 &bitmap, const rectangle &cliprect)
87	86	{
88		galpanic_state *state = machine.driver_data<galpanic_state>();
89	87	int offs;
90	88
91		for (offs = 0;offs < state->m_fgvideoram.bytes()/2;offs++)
	89	for (offs = 0;offs < m_fgvideoram.bytes()/2;offs++)
92	90	{
93	91	int sx,sy,color;
94	92
95	93	sx = offs % 256;
96	94	sy = offs / 256;
97		color = state->m_fgvideoram[offs];
	95	color = m_fgvideoram[offs];
98	96	if (color)
99	97	bitmap.pix16(sy, sx) = color;
100	98	}
r20824	r20825
107	105	/* copy the temporary bitmap to the screen */
108	106	copybitmap(bitmap,m_bitmap,0,0,0,0,cliprect);
109	107
110		draw_fgbitmap(machine(), bitmap, cliprect);
	108	draw_fgbitmap(bitmap, cliprect);
111	109
112	110	pandora_update(pandora, bitmap, cliprect);
113	111
r20824	r20825
119	117	/* copy the temporary bitmap to the screen */
120	118	copybitmap(bitmap,m_bitmap,0,0,0,0,cliprect);
121	119
122		draw_fgbitmap(machine(), bitmap, cliprect);
	120	draw_fgbitmap(bitmap, cliprect);
123	121
124	122
125	123	//  if(galpanic_clear_sprites)
126	124	{
127	125	m_sprites_bitmap.fill(0, cliprect);
128		comad_draw_sprites(machine(),bitmap,cliprect);
	126	comad_draw_sprites(bitmap,cliprect);
129	127	}
130	128	//  else
131	129	//  {

trunk/src/mame/video/gyruss.c

r20824	r20825
127	127	}
128	128
129	129
130		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element **gfx )
	130	void gyruss_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element **gfx )
131	131	{
132		gyruss_state *state = machine.driver_data<gyruss_state>();
133	132	int offs;
134	133
135	134	for (offs = 0xbc; offs >= 0; offs -= 4)
136	135	{
137		int x = state->m_spriteram[offs];
138		int y = 241 - state->m_spriteram[offs + 3];
	136	int x = m_spriteram[offs];
	137	int y = 241 - m_spriteram[offs + 3];
139	138
140		int gfx_bank = state->m_spriteram[offs + 1] & 0x01;
141		int code = ((state->m_spriteram[offs + 2] & 0x20) << 2) | ( state->m_spriteram[offs + 1] >> 1);
142		int color = state->m_spriteram[offs + 2] & 0x0f;
143		int flip_x = ~state->m_spriteram[offs + 2] & 0x40;
144		int flip_y =  state->m_spriteram[offs + 2] & 0x80;
	139	int gfx_bank = m_spriteram[offs + 1] & 0x01;
	140	int code = ((m_spriteram[offs + 2] & 0x20) << 2) | ( m_spriteram[offs + 1] >> 1);
	141	int color = m_spriteram[offs + 2] & 0x0f;
	142	int flip_x = ~m_spriteram[offs + 2] & 0x40;
	143	int flip_y =  m_spriteram[offs + 2] & 0x80;
145	144
146	145	drawgfx_transpen(bitmap, cliprect, gfx[gfx_bank], code, color, flip_x, flip_y, x, y, 0);
147	146	}
r20824	r20825
157	156	}
158	157
159	158	m_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
160		draw_sprites(machine(), bitmap, cliprect, machine().gfx);
	159	draw_sprites(bitmap, cliprect, machine().gfx);
161	160	m_tilemap->draw(bitmap, cliprect, 0, 0);
162	161
163	162	return 0;

trunk/src/mame/video/gaelco3d.c

r20824	r20825
346	346	*
347	347	*************************************/
348	348
349		void gaelco3d_render(screen_device &screen)
	349	void gaelco3d_state::gaelco3d_render(screen_device &screen)
350	350	{
351	351	gaelco3d_state *state = screen.machine().driver_data<gaelco3d_state>();
352	352	/* wait for any queued stuff to complete */
353		state->m_poly->wait("Time to render");
	353	m_poly->wait("Time to render");
354	354
355	355	#if DISPLAY_STATS
356	356	{
357	357	int scan = screen.vpos();
358		popmessage("Polys = %4d  Timeleft = %3d", state->m_poly->polygons(), (state->m_lastscan < scan) ? (scan - state->m_lastscan) : (scan + (state->m_lastscan - screen.visible_area().max_y)));
	358	popmessage("Polys = %4d  Timeleft = %3d", m_poly->polygons(), (m_lastscan < scan) ? (scan - m_lastscan) : (scan + (m_lastscan - screen.visible_area().max_y)));
359	359	}
360	360	#endif
361	361

trunk/src/mame/video/galaxian.c

r20824	r20825
227	227	#define RGB_MAXIMUM         224
228	228
229	229
230
231	230	/*************************************
232	231	*
233		*  Function prototypes
234		*
235		*************************************/
236
237		static void state_save_register(running_machine &machine);
238
239
240		static void sprites_draw(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *spritebase);
241
242		static void stars_init(running_machine &machine);
243		static void stars_update_origin(running_machine &machine);
244		static void stars_draw_row(galaxian_state *state, bitmap_rgb32 &bitmap, int maxx, int y, UINT32 star_offs, UINT8 starmask);
245
246		static void bullets_draw(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *base);
247
248
249
250		/*************************************
251		*
252	232	*  Palette setup
253	233	*
254	234	*************************************/
r20824	r20825
417	397	m_background_green = 0;
418	398
419	399	/* initialize stars */
420		stars_init(machine());
	400	stars_init();
421	401
422	402	/* register for save states */
423		state_save_register(machine());
	403	state_save_register();
424	404	}
425	405
426	406
427		static void state_save_register(running_machine &machine)
	407	void galaxian_state::state_save_register()
428	408	{
429		galaxian_state *state = machine.driver_data<galaxian_state>();
430		state_save_register_global(machine, state->m_flipscreen_x);
431		state_save_register_global(machine, state->m_flipscreen_y);
432		state_save_register_global(machine, state->m_background_enable);
433		state_save_register_global(machine, state->m_background_red);
434		state_save_register_global(machine, state->m_background_green);
435		state_save_register_global(machine, state->m_background_blue);
	409	state_save_register_global(machine(), m_flipscreen_x);
	410	state_save_register_global(machine(), m_flipscreen_y);
	411	state_save_register_global(machine(), m_background_enable);
	412	state_save_register_global(machine(), m_background_red);
	413	state_save_register_global(machine(), m_background_green);
	414	state_save_register_global(machine(), m_background_blue);
436	415
437		state_save_register_global_array(machine, state->m_gfxbank);
	416	state_save_register_global_array(machine(), m_gfxbank);
438	417
439		state_save_register_global(machine, state->m_stars_enabled);
440		state_save_register_global(machine, state->m_star_rng_origin);
441		state_save_register_global(machine, state->m_star_rng_origin_frame);
442		state_save_register_global(machine, state->m_stars_blink_state);
	418	state_save_register_global(machine(), m_stars_enabled);
	419	state_save_register_global(machine(), m_star_rng_origin);
	420	state_save_register_global(machine(), m_star_rng_origin_frame);
	421	state_save_register_global(machine(), m_stars_blink_state);
443	422	}
444	423
445	424
r20824	r20825
453	432	UINT32 galaxian_state::screen_update_galaxian(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
454	433	{
455	434	/* draw the background layer (including stars) */
456		(*m_draw_background_ptr)(machine(), bitmap, cliprect);
	435	(this->*m_draw_background_ptr)(bitmap, cliprect);
457	436
458	437	/* draw the tilemap characters over top */
459	438	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
460	439
461	440	/* render the sprites next. Some custom pcbs (eg. zigzag, fantastc) have more than one sprite generator (ideally, this should be rendered in parallel) */
462	441	for (int i = 0; i < m_numspritegens; i++)
463		sprites_draw(machine(), bitmap, cliprect, &m_spriteram[0x40 + i * 0x20]);
	442	sprites_draw(bitmap, cliprect, &m_spriteram[0x40 + i * 0x20]);
464	443
465	444	/* if we have bullets to draw, render them following */
466	445	if (m_draw_bullet_ptr != NULL)
467		bullets_draw(machine(), bitmap, cliprect, &m_spriteram[m_bullets_base]);
	446	bullets_draw(bitmap, cliprect, &m_spriteram[m_bullets_base]);
468	447
469	448	return 0;
470	449	}
r20824	r20825
487	466	UINT8 color = attrib & 7;
488	467
489	468	if (m_extend_tile_info_ptr != NULL)
490		(*m_extend_tile_info_ptr)(machine(), &code, &color, attrib, x);
	469	(this->*m_extend_tile_info_ptr)(&code, &color, attrib, x);
491	470
492	471	SET_TILE_INFO_MEMBER(0, code, color, 0);
493	472	}
r20824	r20825
545	524	*
546	525	*************************************/
547	526
548		static void sprites_draw(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *spritebase)
	527	void galaxian_state::sprites_draw(bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *spritebase)
549	528	{
550		galaxian_state *state = machine.driver_data<galaxian_state>();
551	529	rectangle clip = cliprect;
552	530	int sprnum;
553	531
r20824	r20825
556	534
557	535	/* 16 of the 256 pixels of the sprites are hard-clipped at the line buffer */
558	536	/* according to the schematics, it should be the first 16 pixels */
559		clip.min_x = MAX(clip.min_x, (!state->m_flipscreen_x) * (16 + hoffset) * GALAXIAN_XSCALE);
560		clip.max_x = MIN(clip.max_x, (256 - state->m_flipscreen_x * (16 + hoffset)) * GALAXIAN_XSCALE - 1);
	537	clip.min_x = MAX(clip.min_x, (!m_flipscreen_x) * (16 + hoffset) * GALAXIAN_XSCALE);
	538	clip.max_x = MIN(clip.max_x, (256 - m_flipscreen_x * (16 + hoffset)) * GALAXIAN_XSCALE - 1);
561	539
562	540	/* The line buffer is only written if it contains a '0' currently; */
563	541	/* it is cleared during the visible area, and populated during HBLANK */
r20824	r20825
567	545	{
568	546	const UINT8 *base = &spritebase[sprnum * 4];
569	547	/* Frogger: top and bottom 4 bits swapped entering the adder */
570		UINT8 base0 = state->m_frogger_adjust ? ((base[0] >> 4) | (base[0] << 4)) : base[0];
	548	UINT8 base0 = m_frogger_adjust ? ((base[0] >> 4) | (base[0] << 4)) : base[0];
571	549	/* the first three sprites match against y-1 */
572	550	UINT8 sy = 240 - (base0 - (sprnum < 3));
573	551	UINT16 code = base[1] & 0x3f;
r20824	r20825
577	555	UINT8 sx = base[3] + hoffset;
578	556
579	557	/* extend the sprite information */
580		if (state->m_extend_sprite_info_ptr != NULL)
581		(*state->m_extend_sprite_info_ptr)(machine, base, &sx, &sy, &flipx, &flipy, &code, &color);
	558	if (m_extend_sprite_info_ptr != NULL)
	559	(this->*m_extend_sprite_info_ptr)(base, &sx, &sy, &flipx, &flipy, &code, &color);
582	560
583	561	/* apply flipscreen in X direction */
584		if (state->m_flipscreen_x)
	562	if (m_flipscreen_x)
585	563	{
586	564	sx = 240 - sx;
587	565	flipx = !flipx;
588	566	}
589	567
590	568	/* apply flipscreen in Y direction */
591		if (state->m_flipscreen_y)
	569	if (m_flipscreen_y)
592	570	{
593	571	sy = 240 - sy;
594	572	flipy = !flipy;
r20824	r20825
596	574
597	575	/* draw */
598	576	drawgfx_transpen(bitmap, clip,
599		machine.gfx[1],
	577	machine().gfx[1],
600	578	code, color,
601	579	flipx, flipy,
602	580	GALAXIAN_H0START + GALAXIAN_XSCALE * sx, sy, 0);
r20824	r20825
611	589	*
612	590	*************************************/
613	591
614		static void bullets_draw(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *base)
	592	void galaxian_state::bullets_draw(bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *base)
615	593	{
616		galaxian_state *state = machine.driver_data<galaxian_state>();
617	594	int y;
618	595
619	596	/* iterate over scanlines */
r20824	r20825
624	601	int which;
625	602
626	603	/* the first 3 entries match Y-1 */
627		effy = state->m_flipscreen_y ? ((y - 1) ^ 255) : (y - 1);
	604	effy = m_flipscreen_y ? ((y - 1) ^ 255) : (y - 1);
628	605	for (which = 0; which < 3; which++)
629	606	if ((UINT8)(base[which*4+1] + effy) == 0xff)
630	607	shell = which;
631	608
632	609	/* remaining entries match Y */
633		effy = state->m_flipscreen_y ? (y ^ 255) : y;
	610	effy = m_flipscreen_y ? (y ^ 255) : y;
634	611	for (which = 3; which < 8; which++)
635	612	if ((UINT8)(base[which*4+1] + effy) == 0xff)
636	613	{
r20824	r20825
642	619
643	620	/* draw the shell */
644	621	if (shell != 0xff)
645		(*state->m_draw_bullet_ptr)(machine, bitmap, cliprect, shell, 255 - base[shell*4+3], y);
	622	(this->*m_draw_bullet_ptr)(bitmap, cliprect, shell, 255 - base[shell*4+3], y);
646	623	if (missile != 0xff)
647		(*state->m_draw_bullet_ptr)(machine, bitmap, cliprect, missile, 255 - base[missile*4+3], y);
	624	(this->*m_draw_bullet_ptr)(bitmap, cliprect, missile, 255 - base[missile*4+3], y);
648	625	}
649	626	}
650	627
r20824	r20825
665	642	/* when the direction changes, we count a different number of clocks */
666	643	/* per frame, so we need to reset the origin of the stars to the current */
667	644	/* frame before we flip */
668		stars_update_origin(machine());
	645	stars_update_origin();
669	646
670	647	m_flipscreen_x = data & 0x01;
671	648	m_bg_tilemap->set_flip((m_flipscreen_x ? TILEMAP_FLIPX : 0) | (m_flipscreen_y ? TILEMAP_FLIPY : 0));
r20824	r20825
774	751	*
775	752	*************************************/
776	753
777		static void stars_init(running_machine &machine)
	754	void galaxian_state::stars_init()
778	755	{
779		galaxian_state *state = machine.driver_data<galaxian_state>();
780	756	UINT32 shiftreg;
781	757	int i;
782	758
783	759	/* reset the blink and enabled states */
784		state->m_stars_enabled = FALSE;
785		state->m_stars_blink_state = 0;
	760	m_stars_enabled = FALSE;
	761	m_stars_blink_state = 0;
786	762
787	763	/* precalculate the RNG */
788		state->m_stars = auto_alloc_array(machine, UINT8, STAR_RNG_PERIOD);
	764	m_stars = auto_alloc_array(machine(), UINT8, STAR_RNG_PERIOD);
789	765	shiftreg = 0;
790	766	for (i = 0; i < STAR_RNG_PERIOD; i++)
791	767	{
r20824	r20825
796	772	int color = (~shiftreg & 0x1f8) >> 3;
797	773
798	774	/* store the color value in the low 6 bits and the enable in the upper bit */
799		state->m_stars[i] = color | (enabled << 7);
	775	m_stars[i] = color | (enabled << 7);
800	776
801	777	/* the LFSR is fed based on the XOR of bit 12 and the inverse of bit 0 */
802	778	shiftreg = (shiftreg >> 1) | ((((shiftreg >> 12) ^ ~shiftreg) & 1) << 16);
r20824	r20825
811	787	*
812	788	*************************************/
813	789
814		static void stars_update_origin(running_machine &machine)
	790	void galaxian_state::stars_update_origin()
815	791	{
816		galaxian_state *state = machine.driver_data<galaxian_state>();
817		int curframe = machine.primary_screen->frame_number();
	792	int curframe = machine().primary_screen->frame_number();
818	793
819	794	/* only update on a different frame */
820		if (curframe != state->m_star_rng_origin_frame)
	795	if (curframe != m_star_rng_origin_frame)
821	796	{
822	797	/* The RNG period is 2^17-1; each frame, the shift register is clocked */
823	798	/* 512*256 = 2^17 times. This means that we clock one extra time each */
r20824	r20825
825	800	/* at 6B which delay the count so that we count 512*256-2 = 2^17-2 times. */
826	801	/* In this case, we only one time less than the period each frame. Both */
827	802	/* of these off-by-one countings produce the horizontal star scrolling. */
828		int per_frame_delta = state->m_flipscreen_x ? 1 : -1;
829		int total_delta = per_frame_delta * (curframe - state->m_star_rng_origin_frame);
	803	int per_frame_delta = m_flipscreen_x ? 1 : -1;
	804	int total_delta = per_frame_delta * (curframe - m_star_rng_origin_frame);
830	805
831	806	/* we can't just use % here because mod of a negative number is undefined */
832	807	while (total_delta < 0)
833	808	total_delta += STAR_RNG_PERIOD;
834	809
835	810	/* now that everything is positive, do the mod */
836		state->m_star_rng_origin = (state->m_star_rng_origin + total_delta) % STAR_RNG_PERIOD;
837		state->m_star_rng_origin_frame = curframe;
	811	m_star_rng_origin = (m_star_rng_origin + total_delta) % STAR_RNG_PERIOD;
	812	m_star_rng_origin_frame = curframe;
838	813	}
839	814	}
840	815
r20824	r20825
859	834	*
860	835	*************************************/
861	836
862		static void stars_draw_row(galaxian_state *state, bitmap_rgb32 &bitmap, int maxx, int y, UINT32 star_offs, UINT8 starmask)
	837	void galaxian_state::stars_draw_row(bitmap_rgb32 &bitmap, int maxx, int y, UINT32 star_offs, UINT8 starmask)
863	838	{
864	839	int x;
865	840
r20824	r20825
891	866	*/
892	867
893	868	/* first RNG clock: one pixel */
894		star = state->m_stars[star_offs++];
	869	star = m_stars[star_offs++];
895	870	if (star_offs >= STAR_RNG_PERIOD)
896	871	star_offs = 0;
897	872	if (enable_star && (star & 0x80) != 0 && (star & starmask) != 0)
898		bitmap.pix32(y, GALAXIAN_XSCALE*x + 0) = state->m_star_color[star & 0x3f];
	873	bitmap.pix32(y, GALAXIAN_XSCALE*x + 0) = m_star_color[star & 0x3f];
899	874
900	875	/* second RNG clock: two pixels */
901		star = state->m_stars[star_offs++];
	876	star = m_stars[star_offs++];
902	877	if (star_offs >= STAR_RNG_PERIOD)
903	878	star_offs = 0;
904	879	if (enable_star && (star & 0x80) != 0 && (star & starmask) != 0)
905	880	{
906		bitmap.pix32(y, GALAXIAN_XSCALE*x + 1) = state->m_star_color[star & 0x3f];
907		bitmap.pix32(y, GALAXIAN_XSCALE*x + 2) = state->m_star_color[star & 0x3f];
	881	bitmap.pix32(y, GALAXIAN_XSCALE*x + 1) = m_star_color[star & 0x3f];
	882	bitmap.pix32(y, GALAXIAN_XSCALE*x + 2) = m_star_color[star & 0x3f];
908	883	}
909	884	}
910	885	}
r20824	r20825
917	892	*
918	893	*************************************/
919	894
920		void galaxian_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	895	void galaxian_state::galaxian_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
921	896	{
922		galaxian_state *state = machine.driver_data<galaxian_state>();
923	897	/* erase the background to black first */
924	898	bitmap.fill(RGB_BLACK, cliprect);
925	899
926	900	/* update the star origin to the current frame */
927		stars_update_origin(machine);
	901	stars_update_origin();
928	902
929	903	/* render stars if enabled */
930		if (state->m_stars_enabled)
	904	if (m_stars_enabled)
931	905	{
932	906	int y;
933	907
934	908	/* iterate over scanlines */
935	909	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
936	910	{
937		UINT32 star_offs = state->m_star_rng_origin + y * 512;
938		stars_draw_row(state, bitmap, 256, y, star_offs, 0xff);
	911	UINT32 star_offs = m_star_rng_origin + y * 512;
	912	stars_draw_row(bitmap, 256, y, star_offs, 0xff);
939	913	}
940	914	}
941	915	}
942	916
943	917
944		static void background_draw_colorsplit(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, rgb_t color, int split, int split_flipped)
	918	void galaxian_state::background_draw_colorsplit(bitmap_rgb32 &bitmap, const rectangle &cliprect, rgb_t color, int split, int split_flipped)
945	919	{
946		galaxian_state *state = machine.driver_data<galaxian_state>();
947	920	/* horizontal bgcolor split */
948		if (state->m_flipscreen_x)
	921	if (m_flipscreen_x)
949	922	{
950	923	rectangle draw = cliprect;
951	924	draw.max_x = MIN(draw.max_x, split_flipped * GALAXIAN_XSCALE - 1);
r20824	r20825
972	945	}
973	946
974	947
975		static void scramble_draw_stars(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int maxx)
	948	void galaxian_state::scramble_draw_stars(bitmap_rgb32 &bitmap, const rectangle &cliprect, int maxx)
976	949	{
977		galaxian_state *state = machine.driver_data<galaxian_state>();
978	950	/* update the star origin to the current frame */
979		stars_update_origin(machine);
	951	stars_update_origin();
980	952
981	953	/* render stars if enabled */
982		if (state->m_stars_enabled)
	954	if (m_stars_enabled)
983	955	{
984		int blink_state = state->m_stars_blink_state & 3;
	956	int blink_state = m_stars_blink_state & 3;
985	957	int y;
986	958
987	959	/* iterate over scanlines */
r20824	r20825
992	964	{
993	965	/* blink states 0 and 1 suppress stars when certain bits of the color == 0 */
994	966	static const UINT8 colormask_table[4] = { 0x20, 0x08, 0xff, 0xff };
995		stars_draw_row(state, bitmap, maxx, y, y * 512, colormask_table[blink_state]);
	967	stars_draw_row(bitmap, maxx, y, y * 512, colormask_table[blink_state]);
996	968	}
997	969	}
998	970	}
999	971	}
1000	972
1001	973
1002		void scramble_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	974	void galaxian_state::scramble_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
1003	975	{
1004		galaxian_state *state = machine.driver_data<galaxian_state>();
1005	976	/* blue background - 390 ohm resistor */
1006		bitmap.fill(state->m_background_enable ? MAKE_RGB(0,0,0x56) : RGB_BLACK, cliprect);
	977	bitmap.fill(m_background_enable ? MAKE_RGB(0,0,0x56) : RGB_BLACK, cliprect);
1007	978
1008		scramble_draw_stars(machine, bitmap, cliprect, 256);
	979	scramble_draw_stars(bitmap, cliprect, 256);
1009	980	}
1010	981
1011	982
1012		void anteater_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	983	void galaxian_state::anteater_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
1013	984	{
1014		galaxian_state *state = machine.driver_data<galaxian_state>();
1015	985	/* blue background, horizontal split as seen on flyer and real cabinet */
1016		background_draw_colorsplit(machine, bitmap, cliprect, state->m_background_enable ? MAKE_RGB(0,0,0x56) : RGB_BLACK, 56, 256-56);
	986	background_draw_colorsplit(bitmap, cliprect, m_background_enable ? MAKE_RGB(0,0,0x56) : RGB_BLACK, 56, 256-56);
1017	987
1018		scramble_draw_stars(machine, bitmap, cliprect, 256);
	988	scramble_draw_stars(bitmap, cliprect, 256);
1019	989	}
1020	990
1021	991
1022		void jumpbug_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	992	void galaxian_state::jumpbug_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
1023	993	{
1024		galaxian_state *state = machine.driver_data<galaxian_state>();
1025	994	/* blue background - 390 ohm resistor */
1026		bitmap.fill(state->m_background_enable ? MAKE_RGB(0,0,0x56) : RGB_BLACK, cliprect);
	995	bitmap.fill(m_background_enable ? MAKE_RGB(0,0,0x56) : RGB_BLACK, cliprect);
1027	996
1028	997	/* render stars same as scramble but nothing in the status area */
1029		scramble_draw_stars(machine, bitmap, cliprect, 240);
	998	scramble_draw_stars(bitmap, cliprect, 240);
1030	999	}
1031	1000
1032	1001
1033		void turtles_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	1002	void galaxian_state::turtles_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
1034	1003	{
1035		galaxian_state *state = machine.driver_data<galaxian_state>();
1036	1004	/*
1037	1005	The background color generator is connected this way:
1038	1006
r20824	r20825
1040	1008	GREEN - 470 ohm resistor
1041	1009	BLUE  - 390 ohm resistor
1042	1010	*/
1043		bitmap.fill(MAKE_RGB(state->m_background_red * 0x55, state->m_background_green * 0x47, state->m_background_blue * 0x55), cliprect);
	1011	bitmap.fill(MAKE_RGB(m_background_red * 0x55, m_background_green * 0x47, m_background_blue * 0x55), cliprect);
1044	1012	}
1045	1013
1046	1014
1047		void frogger_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	1015	void galaxian_state::frogger_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
1048	1016	{
1049	1017	/* color split point verified on real machine */
1050	1018	/* hmmm, according to schematics it is at 128+8; which is right? */
1051		background_draw_colorsplit(machine, bitmap, cliprect, MAKE_RGB(0,0,0x47), 128+8, 128-8);
	1019	background_draw_colorsplit(bitmap, cliprect, MAKE_RGB(0,0,0x47), 128+8, 128-8);
1052	1020	}
1053	1021
1054	1022
1055	1023	#ifdef UNUSED_FUNCTION
1056		static int flip_and_clip(rectangle &draw, int xstart, int xend, const rectangle &cliprect)
	1024	int galaxian_state::flip_and_clip(rectangle &draw, int xstart, int xend, const rectangle &cliprect)
1057	1025	{
1058		galaxian_state *state = machine.driver_data<galaxian_state>();
1059	1026	draw = cliprect;
1060		if (!state->m_flipscreen_x)
	1027	if (!m_flipscreen_x)
1061	1028	{
1062	1029	draw.min_x = xstart * GALAXIAN_XSCALE;
1063	1030	draw.max_x = xend * GALAXIAN_XSCALE + (GALAXIAN_XSCALE - 1);
r20824	r20825
1071	1038	return (draw.min_x <= draw.max_x);
1072	1039	}
1073	1040
1074		void amidar_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	1041	void galaxian_state::amidar_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect)
1075	1042	{
1076		galaxian_state *state = machine.driver_data<galaxian_state>();
1077		const UINT8 *prom = state->memregion("user1")->base();
	1043	const UINT8 *prom = memregion("user1")->base();
1078	1044	rectangle draw;
1079	1045	int x;
1080	1046
r20824	r20825
1095	1061	GREEN - 560 ohm resistor
1096	1062	BLUE  - 470 ohm resistor
1097	1063	*/
1098		UINT8 red = ((~prom[x] & 0x02) && state->m_background_red) ? 0x7c : 0x00;
1099		UINT8 green = ((~prom[x] & 0x02) && state->m_background_green) ? 0x3c : 0x00;
1100		UINT8 blue = ((~prom[x] & 0x01) && state->m_background_blue) ? 0x47 : 0x00;
	1064	UINT8 red = ((~prom[x] & 0x02) && m_background_red) ? 0x7c : 0x00;
	1065	UINT8 green = ((~prom[x] & 0x02) && m_background_green) ? 0x3c : 0x00;
	1066	UINT8 blue = ((~prom[x] & 0x01) && m_background_blue) ? 0x47 : 0x00;
1101	1067	bitmap.fill(MAKE_RGB(red, green, blue, draw));
1102	1068	}
1103	1069	}
r20824	r20825
1111	1077	*
1112	1078	*************************************/
1113	1079
1114		INLINE void galaxian_draw_pixel(bitmap_rgb32 &bitmap, const rectangle &cliprect, int y, int x, rgb_t color)
	1080	inline void galaxian_state::galaxian_draw_pixel(bitmap_rgb32 &bitmap, const rectangle &cliprect, int y, int x, rgb_t color)
1115	1081	{
1116	1082	if (y >= cliprect.min_y && y <= cliprect.max_y)
1117	1083	{
r20824	r20825
1131	1097	}
1132	1098
1133	1099
1134		void galaxian_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1100	void galaxian_state::galaxian_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1135	1101	{
1136		galaxian_state *state = machine.driver_data<galaxian_state>();
1137	1102	/*
1138	1103	Both "shells" and "missiles" begin displaying when the horizontal counter
1139	1104	reaches $FC, and they stop displaying when it reaches $00, resulting in
r20824	r20825
1141	1106	white; the final entry is called a "missile" and renders as yellow.
1142	1107	*/
1143	1108	x -= 4;
1144		galaxian_draw_pixel(bitmap, cliprect, y, x++, state->m_bullet_color[offs]);
1145		galaxian_draw_pixel(bitmap, cliprect, y, x++, state->m_bullet_color[offs]);
1146		galaxian_draw_pixel(bitmap, cliprect, y, x++, state->m_bullet_color[offs]);
1147		galaxian_draw_pixel(bitmap, cliprect, y, x++, state->m_bullet_color[offs]);
	1109	galaxian_draw_pixel(bitmap, cliprect, y, x++, m_bullet_color[offs]);
	1110	galaxian_draw_pixel(bitmap, cliprect, y, x++, m_bullet_color[offs]);
	1111	galaxian_draw_pixel(bitmap, cliprect, y, x++, m_bullet_color[offs]);
	1112	galaxian_draw_pixel(bitmap, cliprect, y, x++, m_bullet_color[offs]);
1148	1113	}
1149	1114
1150	1115
1151		void mshuttle_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1116	void galaxian_state::mshuttle_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1152	1117	{
1153	1118	/* verified by schematics:
1154	1119	* both "W" and "Y" bullets are 4 pixels long
r20824	r20825
1177	1142	}
1178	1143
1179	1144
1180		void scramble_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1145	void galaxian_state::scramble_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1181	1146	{
1182	1147	/*
1183	1148	Scramble only has "shells", which begin displaying when the counter
r20824	r20825
1189	1154	}
1190	1155
1191	1156
1192		void theend_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1157	void galaxian_state::theend_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1193	1158	{
1194		galaxian_state *state = machine.driver_data<galaxian_state>();
1195	1159	/* Same as galaxian except blue/green are swapped */
1196	1160	x -= 4;
1197		galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(state->m_bullet_color[offs]), RGB_BLUE(state->m_bullet_color[offs]), RGB_GREEN(state->m_bullet_color[offs])));
1198		galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(state->m_bullet_color[offs]), RGB_BLUE(state->m_bullet_color[offs]), RGB_GREEN(state->m_bullet_color[offs])));
1199		galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(state->m_bullet_color[offs]), RGB_BLUE(state->m_bullet_color[offs]), RGB_GREEN(state->m_bullet_color[offs])));
1200		galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(state->m_bullet_color[offs]), RGB_BLUE(state->m_bullet_color[offs]), RGB_GREEN(state->m_bullet_color[offs])));
	1161	galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(m_bullet_color[offs]), RGB_BLUE(m_bullet_color[offs]), RGB_GREEN(m_bullet_color[offs])));
	1162	galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(m_bullet_color[offs]), RGB_BLUE(m_bullet_color[offs]), RGB_GREEN(m_bullet_color[offs])));
	1163	galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(m_bullet_color[offs]), RGB_BLUE(m_bullet_color[offs]), RGB_GREEN(m_bullet_color[offs])));
	1164	galaxian_draw_pixel(bitmap, cliprect, y, x++, MAKE_RGB(RGB_RED(m_bullet_color[offs]), RGB_BLUE(m_bullet_color[offs]), RGB_GREEN(m_bullet_color[offs])));
1201	1165	}
1202	1166
1203	1167
r20824	r20825
1209	1173	*************************************/
1210	1174
1211	1175	/*** generic ***/
1212		void upper_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1176	void galaxian_state::upper_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1213	1177	{
1214	1178	/* tiles are in the upper half of a larger ROM */
1215	1179	*code += 0x100;
1216	1180	}
1217	1181
1218		void upper_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1182	void galaxian_state::upper_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1219	1183	{
1220	1184	/* sprites are in the upper half of a larger ROM */
1221	1185	*code += 0x40;
r20824	r20825
1223	1187
1224	1188
1225	1189	/*** Frogger ***/
1226		void frogger_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1190	void galaxian_state::frogger_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1227	1191	{
1228	1192	*color = ((*color >> 1) & 0x03) | ((*color << 2) & 0x04);
1229	1193	}
1230	1194
1231		void frogger_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1195	void galaxian_state::frogger_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1232	1196	{
1233	1197	*color = ((*color >> 1) & 0x03) | ((*color << 2) & 0x04);
1234	1198	}
1235	1199
1236	1200
1237	1201	/*** Ghostmuncher Galaxian ***/
1238		void gmgalax_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1202	void galaxian_state::gmgalax_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1239	1203	{
1240		galaxian_state *state = machine.driver_data<galaxian_state>();
1241		*code |= state->m_gfxbank[0] << 9;
1242		//  *color |= state->m_gfxbank[0] << 3;
	1204	*code |= m_gfxbank[0] << 9;
	1205	//  *color |= m_gfxbank[0] << 3;
1243	1206	}
1244	1207
1245		void gmgalax_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1208	void galaxian_state::gmgalax_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1246	1209	{
1247		galaxian_state *state = machine.driver_data<galaxian_state>();
1248		*code |= (state->m_gfxbank[0] << 7) | 0x40;
1249		*color |= state->m_gfxbank[0] << 3;
	1210	*code |= (m_gfxbank[0] << 7) | 0x40;
	1211	*color |= m_gfxbank[0] << 3;
1250	1212	}
1251	1213
1252	1214
1253	1215	/*** Pisces ***/
1254		void pisces_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1216	void galaxian_state::pisces_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1255	1217	{
1256		galaxian_state *state = machine.driver_data<galaxian_state>();
1257		*code |= state->m_gfxbank[0] << 8;
	1218	*code |= m_gfxbank[0] << 8;
1258	1219	}
1259	1220
1260		void pisces_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1221	void galaxian_state::pisces_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1261	1222	{
1262		galaxian_state *state = machine.driver_data<galaxian_state>();
1263		*code |= state->m_gfxbank[0] << 6;
	1223	*code |= m_gfxbank[0] << 6;
1264	1224	}
1265	1225
1266	1226
1267	1227	/*** Batman Part 2 ***/
1268		void batman2_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1228	void galaxian_state::batman2_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1269	1229	{
1270		galaxian_state *state = machine.driver_data<galaxian_state>();
1271	1230	if (*code & 0x80)
1272		*code |= state->m_gfxbank[0] << 8;
	1231	*code |= m_gfxbank[0] << 8;
1273	1232	}
1274	1233
1275	1234
1276	1235	/*** Moon Cresta ***/
1277		void mooncrst_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1236	void galaxian_state::mooncrst_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1278	1237	{
1279		galaxian_state *state = machine.driver_data<galaxian_state>();
1280		if (state->m_gfxbank[2] && (*code & 0xc0) == 0x80)
1281		*code = (*code & 0x3f) | (state->m_gfxbank[0] << 6) | (state->m_gfxbank[1] << 7) | 0x0100;
	1238	if (m_gfxbank[2] && (*code & 0xc0) == 0x80)
	1239	*code = (*code & 0x3f) | (m_gfxbank[0] << 6) | (m_gfxbank[1] << 7) | 0x0100;
1282	1240	}
1283	1241
1284		void mooncrst_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1242	void galaxian_state::mooncrst_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1285	1243	{
1286		galaxian_state *state = machine.driver_data<galaxian_state>();
1287		if (state->m_gfxbank[2] && (*code & 0x30) == 0x20)
1288		*code = (*code & 0x0f) | (state->m_gfxbank[0] << 4) | (state->m_gfxbank[1] << 5) | 0x40;
	1244	if (m_gfxbank[2] && (*code & 0x30) == 0x20)
	1245	*code = (*code & 0x0f) | (m_gfxbank[0] << 4) | (m_gfxbank[1] << 5) | 0x40;
1289	1246	}
1290	1247
1291	1248
1292	1249	/*** Moon Quasar ***/
1293		void moonqsr_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1250	void galaxian_state::moonqsr_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1294	1251	{
1295	1252	*code |= (attrib & 0x20) << 3;
1296	1253	}
1297	1254
1298		void moonqsr_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1255	void galaxian_state::moonqsr_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1299	1256	{
1300	1257	*code |= (base[2] & 0x20) << 1;
1301	1258	}
1302	1259
1303	1260
1304	1261	/*** Moon Shuttle ***/
1305		void mshuttle_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1262	void galaxian_state::mshuttle_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1306	1263	{
1307	1264	*code |= (attrib & 0x30) << 4;
1308	1265	}
1309	1266
1310		void mshuttle_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1267	void galaxian_state::mshuttle_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1311	1268	{
1312	1269	*code |= (base[2] & 0x30) << 2;
1313	1270	}
1314	1271
1315	1272
1316	1273	/*** Calipso ***/
1317		void calipso_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1274	void galaxian_state::calipso_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1318	1275	{
1319	1276	/* same as the others, but no sprite flipping, but instead the bits are used
1320	1277	as extra sprite code bits, giving 256 sprite images */
r20824	r20825
1326	1283
1327	1284
1328	1285	/*** Jumpbug ***/
1329		void jumpbug_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
	1286	void galaxian_state::jumpbug_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x)
1330	1287	{
1331		galaxian_state *state = machine.driver_data<galaxian_state>();
1332		if ((*code & 0xc0) == 0x80 && (state->m_gfxbank[2] & 0x01))
1333		*code += 128 + (( state->m_gfxbank[0] & 0x01) << 6) +
1334		(( state->m_gfxbank[1] & 0x01) << 7) +
1335		((~state->m_gfxbank[4] & 0x01) << 8);
	1288	if ((*code & 0xc0) == 0x80 && (m_gfxbank[2] & 0x01))
	1289	*code += 128 + (( m_gfxbank[0] & 0x01) << 6) +
	1290	(( m_gfxbank[1] & 0x01) << 7) +
	1291	((~m_gfxbank[4] & 0x01) << 8);
1336	1292	}
1337	1293
1338		void jumpbug_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
	1294	void galaxian_state::jumpbug_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color)
1339	1295	{
1340		galaxian_state *state = machine.driver_data<galaxian_state>();
1341		if ((*code & 0x30) == 0x20 && (state->m_gfxbank[2] & 0x01) != 0)
	1296	if ((*code & 0x30) == 0x20 && (m_gfxbank[2] & 0x01) != 0)
1342	1297	{
1343		*code += 32 + (( state->m_gfxbank[0] & 0x01) << 4) +
1344		(( state->m_gfxbank[1] & 0x01) << 5) +
1345		((~state->m_gfxbank[4] & 0x01) << 6);
	1298	*code += 32 + (( m_gfxbank[0] & 0x01) << 4) +
	1299	(( m_gfxbank[1] & 0x01) << 5) +
	1300	((~m_gfxbank[4] & 0x01) << 6);
1346	1301	}
1347	1302	}

trunk/src/mame/video/gstriker.c

r20824	r20825
50	50	m_VS920A[1].tmap->mark_tile_dirty(offset);
51	51	}
52	52
53		static void VS920A_init(running_machine &machine, int numchips)
	53	void gstriker_state::VS920A_init(int numchips)
54	54	{
55		gstriker_state *state = machine.driver_data<gstriker_state>();
56	55	int i;
57	56
58	57	if (numchips > MAX_VS920A)
r20824	r20825
60	59
61	60	for (i=0;i<numchips;i++)
62	61	{
63		state->m_VS920A[i].tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gstriker_state::VS920A_get_tile_info),state),TILEMAP_SCAN_ROWS,8,8,64,32);
	62	m_VS920A[i].tmap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gstriker_state::VS920A_get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,64,32);
64	63
65		state->m_VS920A[i].tmap->set_transparent_pen(0);
	64	m_VS920A[i].tmap->set_transparent_pen(0);
66	65	}
67	66	}
68	67
69		static tilemap_t* VS920A_get_tilemap(gstriker_state *state, int numchip)
	68	tilemap_t* gstriker_state::VS920A_get_tilemap(int numchip)
70	69	{
71		return state->m_VS920A[numchip].tmap;
	70	return m_VS920A[numchip].tmap;
72	71	}
73	72
74		static void VS920A_set_pal_base(gstriker_state *state, int numchip, int pal_base)
	73	void gstriker_state::VS920A_set_pal_base(int numchip, int pal_base)
75	74	{
76		state->m_VS920A[numchip].pal_base = pal_base;
	75	m_VS920A[numchip].pal_base = pal_base;
77	76	}
78	77
79		static void VS920A_set_gfx_region(gstriker_state *state, int numchip, int gfx_region)
	78	void gstriker_state::VS920A_set_gfx_region(int numchip, int gfx_region)
80	79	{
81		state->m_VS920A[numchip].gfx_region = gfx_region;
	80	m_VS920A[numchip].gfx_region = gfx_region;
82	81	}
83	82
84		static void VS920A_draw(gstriker_state *state, int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority)
	83	void gstriker_state::VS920A_draw(int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority)
85	84	{
86		state->m_VS920A_cur_chip = &state->m_VS920A[numchip];
	85	m_VS920A_cur_chip = &m_VS920A[numchip];
87	86
88		state->m_VS920A_cur_chip->tmap->draw(screen, cliprect, 0, priority);
	87	m_VS920A_cur_chip->tmap->draw(screen, cliprect, 0, priority);
89	88	}
90	89
91	90
r20824	r20825
207	206	return (row*64) + (col&63) + ((col&64)<<6);
208	207	}
209	208
210		static void MB60553_init(running_machine &machine, int numchips)
	209	void gstriker_state::MB60553_init(int numchips)
211	210	{
212		gstriker_state *state = machine.driver_data<gstriker_state>();
213	211	int i;
214	212
215	213	if (numchips > MAX_MB60553)
r20824	r20825
217	215
218	216	for (i=0;i<numchips;i++)
219	217	{
220		state->m_MB60553[i].tmap = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gstriker_state::MB60553_get_tile_info),state),tilemap_mapper_delegate(FUNC(gstriker_state::twc94_scan),state), 16,16,128,64);
	218	m_MB60553[i].tmap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gstriker_state::MB60553_get_tile_info),this),tilemap_mapper_delegate(FUNC(gstriker_state::twc94_scan),this), 16,16,128,64);
221	219
222		state->m_MB60553[i].tmap->set_transparent_pen(0);
	220	m_MB60553[i].tmap->set_transparent_pen(0);
223	221	}
224	222	}
225	223
226		static void MB60553_set_pal_base(gstriker_state *state, int numchip, int pal_base)
	224	void gstriker_state::MB60553_set_pal_base(int numchip, int pal_base)
227	225	{
228		state->m_MB60553[numchip].pal_base = pal_base;
	226	m_MB60553[numchip].pal_base = pal_base;
229	227	}
230	228
231		static void MB60553_set_gfx_region(gstriker_state *state, int numchip, int gfx_region)
	229	void gstriker_state::MB60553_set_gfx_region(int numchip, int gfx_region)
232	230	{
233		state->m_MB60553[numchip].gfx_region = gfx_region;
	231	m_MB60553[numchip].gfx_region = gfx_region;
234	232	}
235	233
236	234	/* THIS IS STILL WRONG! */
237		static void MB60553_draw(running_machine &machine, int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority)
	235	void gstriker_state::MB60553_draw(int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority)
238	236	{
239		gstriker_state *state = machine.driver_data<gstriker_state>();
240	237	int line;
241	238	rectangle clip;
242		state->m_MB60553_cur_chip = &state->m_MB60553[numchip];
	239	m_MB60553_cur_chip = &m_MB60553[numchip];
243	240
244		clip.min_x = machine.primary_screen->visible_area().min_x;
245		clip.max_x = machine.primary_screen->visible_area().max_x;
	241	clip.min_x = machine().primary_screen->visible_area().min_x;
	242	clip.max_x = machine().primary_screen->visible_area().max_x;
246	243
247	244	for (line = 0; line < 224;line++)
248	245	{
r20824	r20825
253	250
254	251	UINT32 incxx,incyy;
255	252
256		startx = state->m_MB60553_cur_chip->regs[0];
257		starty = state->m_MB60553_cur_chip->regs[1];
	253	startx = m_MB60553_cur_chip->regs[0];
	254	starty = m_MB60553_cur_chip->regs[1];
258	255
259	256	startx += (24<<4); // maybe not..
260	257
261		startx -=  state->m_lineram[(line)*8+7]/2;
	258	startx -=  m_lineram[(line)*8+7]/2;
262	259
263		incxx = state->m_lineram[(line)*8+0]<<4;
264		incyy = state->m_lineram[(line)*8+3]<<4;
	260	incxx = m_lineram[(line)*8+0]<<4;
	261	incyy = m_lineram[(line)*8+3]<<4;
265	262
266	263	clip.min_y = clip.max_y = line;
267	264
268		state->m_MB60553_cur_chip->tmap->draw_roz(screen, clip, startx<<12,starty<<12,
	265	m_MB60553_cur_chip->tmap->draw_roz(screen, clip, startx<<12,starty<<12,
269	266	incxx,0,0,incyy,
270	267	1,
271	268	0,priority);
r20824	r20825
276	273
277	274	}
278	275
279		static tilemap_t* MB60553_get_tilemap(gstriker_state *state, int numchip)
	276	tilemap_t* gstriker_state::MB60553_get_tilemap(int numchip)
280	277	{
281		return state->m_MB60553[numchip].tmap;
	278	return m_MB60553[numchip].tmap;
282	279	}
283	280
284	281
r20824	r20825
338	335
339	336	// Sandwitched screen/sprite0/score/sprite1. Surely wrong, probably
340	337	//  needs sprite orthogonality
341		MB60553_draw(machine(), 0, bitmap,cliprect, 0);
	338	MB60553_draw(0, bitmap,cliprect, 0);
342	339
343	340	m_spr->draw_sprites(m_CG10103_vram, 0x2000, machine(), bitmap, cliprect, 0x2, 0x0);
344	341
345		VS920A_draw(this, 0, bitmap, cliprect, 0);
	342	VS920A_draw(0, bitmap, cliprect, 0);
346	343
347	344	m_spr->draw_sprites(m_CG10103_vram, 0x2000, machine(), bitmap, cliprect, 0x2, 0x2);
348	345
r20824	r20825
367	364	// Palette bases are hardcoded, but should be probably extracted from the mixer registers
368	365
369	366	// Initalize the chip for the score plane
370		VS920A_init(machine(), 1);
371		VS920A_set_gfx_region(this, 0, 0);
372		VS920A_set_pal_base(this, 0, 0x30);
373		VS920A_get_tilemap(this, 0)->set_transparent_pen(0xf);
	367	VS920A_init(1);
	368	VS920A_set_gfx_region(0, 0);
	369	VS920A_set_pal_base(0, 0x30);
	370	VS920A_get_tilemap(0)->set_transparent_pen(0xf);
374	371
375	372	// Initalize the chip for the screen plane
376		MB60553_init(machine(), 1);
377		MB60553_set_gfx_region(this, 0, 1);
378		MB60553_set_pal_base(this, 0, 0);
379		MB60553_get_tilemap(this, 0)->set_transparent_pen(0xf);
	373	MB60553_init(1);
	374	MB60553_set_gfx_region(0, 1);
	375	MB60553_set_pal_base(0, 0);
	376	MB60553_get_tilemap(0)->set_transparent_pen(0xf);
380	377	}
381	378
382	379	VIDEO_START_MEMBER(gstriker_state,twrldc94)
r20824	r20825
384	381	// Palette bases are hardcoded, but should be probably extracted from the mixer registers
385	382
386	383	// Initalize the chip for the score plane
387		VS920A_init(machine(), 1);
388		VS920A_set_gfx_region(this, 0, 0);
389		VS920A_set_pal_base(this, 0, 0x40);
390		VS920A_get_tilemap(this, 0)->set_transparent_pen(0xf);
	384	VS920A_init(1);
	385	VS920A_set_gfx_region(0, 0);
	386	VS920A_set_pal_base(0, 0x40);
	387	VS920A_get_tilemap(0)->set_transparent_pen(0xf);
391	388
392	389	// Initalize the chip for the screen plane
393		MB60553_init(machine(), 1);
394		MB60553_set_gfx_region(this, 0, 1);
395		MB60553_set_pal_base(this, 0, 0x50);
396		MB60553_get_tilemap(this, 0)->set_transparent_pen(0xf);
	390	MB60553_init(1);
	391	MB60553_set_gfx_region(0, 1);
	392	MB60553_set_pal_base(0, 0x50);
	393	MB60553_get_tilemap(0)->set_transparent_pen(0xf);
397	394	}
398	395
399	396	VIDEO_START_MEMBER(gstriker_state,vgoalsoc)
r20824	r20825
401	398	// Palette bases are hardcoded, but should be probably extracted from the mixer registers
402	399
403	400	// Initalize the chip for the score plane
404		VS920A_init(machine(), 1);
405		VS920A_set_gfx_region(this, 0, 0);
406		VS920A_set_pal_base(this, 0, 0x30);
407		VS920A_get_tilemap(this, 0)->set_transparent_pen(0xf);
	401	VS920A_init(1);
	402	VS920A_set_gfx_region(0, 0);
	403	VS920A_set_pal_base(0, 0x30);
	404	VS920A_get_tilemap(0)->set_transparent_pen(0xf);
408	405
409	406	// Initalize the chip for the screen plane
410		MB60553_init(machine(), 1);
411		MB60553_set_gfx_region(this, 0, 1);
412		MB60553_set_pal_base(this, 0, 0x20);
413		MB60553_get_tilemap(this, 0)->set_transparent_pen(0xf);
	407	MB60553_init(1);
	408	MB60553_set_gfx_region(0, 1);
	409	MB60553_set_pal_base(0, 0x20);
	410	MB60553_get_tilemap(0)->set_transparent_pen(0xf);
414	411	}

trunk/src/mame/video/gng.c

r20824	r20825
101	101
102	102	***************************************************************************/
103	103
104		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	104	void gng_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
105	105	{
106		gng_state *state = machine.driver_data<gng_state>();
107		UINT8 *buffered_spriteram = state->m_spriteram->buffer();
108		gfx_element *gfx = machine.gfx[2];
	106	UINT8 *buffered_spriteram = m_spriteram->buffer();
	107	gfx_element *gfx = machine().gfx[2];
109	108	int offs;
110	109
111	110
112		for (offs = state->m_spriteram->bytes() - 4; offs >= 0; offs -= 4)
	111	for (offs = m_spriteram->bytes() - 4; offs >= 0; offs -= 4)
113	112	{
114	113	UINT8 attributes = buffered_spriteram[offs + 1];
115	114	int sx = buffered_spriteram[offs + 3] - 0x100 * (attributes & 0x01);
r20824	r20825
117	116	int flipx = attributes & 0x04;
118	117	int flipy = attributes & 0x08;
119	118
120		if (state->flip_screen())
	119	if (flip_screen())
121	120	{
122	121	sx = 240 - sx;
123	122	sy = 240 - sy;
r20824	r20825
136	135	UINT32 gng_state::screen_update_gng(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
137	136	{
138	137	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
139		draw_sprites(machine(), bitmap, cliprect);
	138	draw_sprites(bitmap, cliprect);
140	139	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
141	140	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
142	141	return 0;

trunk/src/mame/video/grchamp.c

r20824	r20825
108	108	}
109	109
110	110	#if 0
111		static int collision_check(running_machine &machine, grchamp_state *state, bitmap_ind16 &bitmap, int which )
	111	int grchamp_state::collision_check(grchamp_state *state, bitmap_ind16 &bitmap, int which )
112	112	{
113		int bgcolor = machine.pens[0];
114		int sprite_transp = machine.pens[0x24];
115		const rectangle &visarea = machine.primary_screen->visible_area();
116		int y0 = 240 - state->m_cpu0_out[3];
117		int x0 = 256 - state->m_cpu0_out[2];
	113	int bgcolor = machine().pens[0];
	114	int sprite_transp = machine().pens[0x24];
	115	const rectangle &visarea = machine().primary_screen->visible_area();
	116	int y0 = 240 - m_cpu0_out[3];
	117	int x0 = 256 - m_cpu0_out[2];
118	118	int x,y,sx,sy;
119	119	int pixel;
120	120	int result = 0;
r20824	r20825
122	122	if( which==0 )
123	123	{
124	124	/* draw the current player sprite into a work bitmap */
125		drawgfx_opaque( state->m_work_bitmap,
126		state->m_work_bitmap.cliprect(),
127		machine.gfx[4],
128		state->m_cpu0_out[4]&0xf,
	125	drawgfx_opaque( m_work_bitmap,
	126	m_work_bitmap.cliprect(),
	127	machine().gfx[4],
	128	m_cpu0_out[4]&0xf,
129	129	1, /* color */
130	130	0,0,
131	131	0,0 );
r20824	r20825
135	135	{
136	136	for( x = 0; x<32; x++ )
137	137	{
138		pixel = state->m_work_bitmap.pix16(y, x);
	138	pixel = m_work_bitmap.pix16(y, x);
139	139	if( pixel != sprite_transp ){
140	140	sx = x+x0;
141	141	sy = y+y0;
r20824	r20825
158	158	return result?(1<<which):0;
159	159	}
160	160
161		static void draw_fog(grchamp_state *state, bitmap_ind16 &bitmap, const rectangle &cliprect, int fog)
	161	void grchamp_state::draw_fog(grchamp_state *state, bitmap_ind16 &bitmap, const rectangle &cliprect, int fog)
162	162	{
163	163	int x,y,offs;
164	164
r20824	r20825
175	175	}
176	176	}
177	177
178		static void draw_sprites(running_machine &machine, grchamp_state *state, bitmap_ind16 &bitmap, const rectangle &cliprect)
	178	void grchamp_state::draw_sprites(grchamp_state *state, bitmap_ind16 &bitmap, const rectangle &cliprect)
179	179	{
180		gfx_element *gfx = machine.gfx[5];
181		int bank = (state->m_cpu0_out[0] & 0x20) ? 0x40 : 0x00;
182		const UINT8 *source = state->m_spriteram + 0x40;
	180	gfx_element *gfx = machine().gfx[5];
	181	int bank = (m_cpu0_out[0] & 0x20) ? 0x40 : 0x00;
	182	const UINT8 *source = m_spriteram + 0x40;
183	183	const UINT8 *finish = source + 0x40;
184	184
185	185	while (source < finish)
r20824	r20825
201	201	#endif
202	202
203	203
204		static void draw_objects(running_machine &machine, grchamp_state *state, int y, UINT8 *objdata)
	204	void grchamp_state::draw_objects(int y, UINT8 *objdata)
205	205	{
206	206	/*
207	207	CPU 5/7:
r20824	r20825
238	238
239	239
240	240	*/
241		const UINT8 *prom = machine.root_device().memregion("proms")->base() + 0x20;
	241	const UINT8 *prom = machine().root_device().memregion("proms")->base() + 0x20;
242	242	gfx_element *gfx;
243		int change = (state->m_cpu0_out[0] & 0x20) << 3;
	243	int change = (m_cpu0_out[0] & 0x20) << 3;
244	244	int num;
245	245
246	246	/* first clear to 0; this is done as the previous scanline was scanned */
247	247	memset(objdata, 0, 256);
248	248
249	249	/* now draw the sprites; this is done during HBLANK */
250		gfx = machine.gfx[4];
	250	gfx = machine().gfx[4];
251	251	for (num = 0; num < 16; num++)
252	252	{
253	253	/*
r20824	r20825
261	261
262	262	/* the first of the 4 bytes is the Y position; this is used to match the scanline */
263	263	/* we match this scanline if the sum & 0xf0 == 0 */
264		int sy = state->m_spriteram[0x40 + (dataoffs & ~0x20)];
	264	int sy = m_spriteram[0x40 + (dataoffs & ~0x20)];
265	265	int dy = sy + ~y;
266	266	if ((dy & 0xf0) == 0)
267	267	{
268	268	/* the second byte is: code is in bits 0-5, xflip in bit 6, yflip in bit 7 */
269	269	/* note that X flip is reversed (on purpose) */
270		int codeflip = state->m_spriteram[0x41 + dataoffs];
	270	int codeflip = m_spriteram[0x41 + dataoffs];
271	271	int code = (codeflip & 0x3f) + (change >> 2);
272	272	int yflip = (codeflip & 0x80) ? 0x0f : 0x00;
273	273	int xflip = (codeflip & 0x40) ? 0x0f : 0x00;
274	274	const UINT8 *src = gfx->get_data(code) + ((dy ^ yflip) & 15) * gfx->rowbytes();
275	275
276	276	/* the third byte is: color in bits 0-2 */
277		int color = (state->m_spriteram[0x42 + (dataoffs & ~0x20)] & 0x07) << 2;
	277	int color = (m_spriteram[0x42 + (dataoffs & ~0x20)] & 0x07) << 2;
278	278
279	279	/* the fourth byte is the X position */
280		int sx = state->m_spriteram[0x43 + dataoffs];
	280	int sx = m_spriteram[0x43 + dataoffs];
281	281	int x;
282	282
283	283	/* draw 16 pixels */
r20824	r20825
299	299	}
300	300
301	301	/* finally draw the text characters; this is done as we read out the object buffers */
302		gfx = machine.gfx[0];
	302	gfx = machine().gfx[0];
303	303	for (num = 0; num < 32; num++)
304	304	{
305	305	/*
r20824	r20825
311	311	*/
312	312	int hprime = num ^ 0x1f;
313	313	int dataoffs = hprime << 1;
314		int sy = state->m_spriteram[0x00 + dataoffs];
	314	int sy = m_spriteram[0x00 + dataoffs];
315	315	int dy = sy + ~y;
316		int color = (state->m_spriteram[0x01 + dataoffs] & 0x07) << 2;
317		int code = state->m_videoram[hprime | ((dy & 0xf8) << 2)] + change;
	316	int color = (m_spriteram[0x01 + dataoffs] & 0x07) << 2;
	317	int code = m_videoram[hprime | ((dy & 0xf8) << 2)] + change;
318	318	const UINT8 *src = gfx->get_data(code) + (dy & 7) * gfx->rowbytes();
319	319	int x;
320	320
r20824	r20825
398	398	UINT8 objdata[256];
399	399
400	400	/* draw the objects for this scanline */
401		draw_objects(machine(), this, y, objdata);
	401	draw_objects(y, objdata);
402	402
403	403	/* iterate over columns */
404	404	for (x = cliprect.min_x; x <= cliprect.max_x; x++)

trunk/src/mame/video/gameplan.c

r20824	r20825
36	36	*
37	37	*************************************/
38	38
39		static void gameplan_get_pens( pen_t *pens )
	39	void gameplan_state::gameplan_get_pens( pen_t *pens )
40	40	{
41	41	offs_t i;
42	42
r20824	r20825
46	46
47	47
48	48	/* RGBI palette. Is it correct, or does it use the standard RGB? */
49		static void leprechn_get_pens( pen_t *pens )
	49	void gameplan_state::leprechn_get_pens( pen_t *pens )
50	50	{
51	51	offs_t i;
52	52

trunk/src/mame/video/gaplus.c

r20824	r20825
125	125	#define SPEED_2 1.0
126	126	#define SPEED_3 2.0
127	127
128		static void starfield_init(running_machine &machine)
	128	void gaplus_state::starfield_init()
129	129	{
130		gaplus_state *state = machine.driver_data<gaplus_state>();
131		struct star *stars = state->m_stars;
	130	struct star *stars = m_stars;
132	131	int generator = 0;
133	132	int x,y;
134	133	int set = 0;
135	134
136		int width = machine.primary_screen->width();
137		int height = machine.primary_screen->height();
	135	int width = machine().primary_screen->width();
	136	int height = machine().primary_screen->height();
138	137
139		state->m_total_stars = 0;
	138	m_total_stars = 0;
140	139
141	140	/* precalculate the star background */
142	141	/* this comes from the Galaxian hardware, Gaplus is probably different */
r20824	r20825
155	154	int color;
156	155
157	156	color = (~(generator >> 8)) & 0x3f;
158		if ( color && state->m_total_stars < MAX_STARS ) {
159		stars[state->m_total_stars].x = x;
160		stars[state->m_total_stars].y = y;
161		stars[state->m_total_stars].col = color;
162		stars[state->m_total_stars].set = set++;
	157	if ( color && m_total_stars < MAX_STARS ) {
	158	stars[m_total_stars].x = x;
	159	stars[m_total_stars].y = y;
	160	stars[m_total_stars].col = color;
	161	stars[m_total_stars].set = set++;
163	162
164	163	if ( set == 3 )
165	164	set = 0;
166	165
167		state->m_total_stars++;
	166	m_total_stars++;
168	167	}
169	168	}
170	169	}
r20824	r20825
185	184
186	185	colortable_configure_tilemap_groups(machine().colortable, m_bg_tilemap, machine().gfx[0], 0xff);
187	186
188		starfield_init(machine());
	187	starfield_init();
189	188	}
190	189
191	190
r20824	r20825
221	220
222	221	***************************************************************************/
223	222
224		static void starfield_render(running_machine &machine, bitmap_ind16 &bitmap)
	223	void gaplus_state::starfield_render(bitmap_ind16 &bitmap)
225	224	{
226		gaplus_state *state = machine.driver_data<gaplus_state>();
227		struct star *stars = state->m_stars;
	225	struct star *stars = m_stars;
228	226	int i;
229	227
230		int width = machine.primary_screen->width();
231		int height = machine.primary_screen->height();
	228	int width = machine().primary_screen->width();
	229	int height = machine().primary_screen->height();
232	230
233	231	/* check if we're running */
234		if ( ( state->m_starfield_control[0] & 1 ) == 0 )
	232	if ( ( m_starfield_control[0] & 1 ) == 0 )
235	233	return;
236	234
237	235	/* draw the starfields */
238		for ( i = 0; i < state->m_total_stars; i++ )
	236	for ( i = 0; i < m_total_stars; i++ )
239	237	{
240	238	int x, y;
241	239
r20824	r20825
249	247	}
250	248	}
251	249
252		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	250	void gaplus_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
253	251	{
254		gaplus_state *state = machine.driver_data<gaplus_state>();
255		UINT8 *spriteram = state->m_spriteram + 0x780;
	252	UINT8 *spriteram = m_spriteram + 0x780;
256	253	UINT8 *spriteram_2 = spriteram + 0x800;
257	254	UINT8 *spriteram_3 = spriteram_2 + 0x800;
258	255	int offs;
r20824	r20825
278	275	int duplicate = spriteram_3[offs] & 0x80;
279	276	int x,y;
280	277
281		if (state->flip_screen())
	278	if (flip_screen())
282	279	{
283	280	flipx ^= 1;
284	281	flipy ^= 1;
r20824	r20825
291	288	{
292	289	for (x = 0;x <= sizex;x++)
293	290	{
294		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	291	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
295	292	sprite + (duplicate ? 0 : (gfx_offs[y ^ (sizey * flipy)][x ^ (sizex * flipx)])),
296	293	color,
297	294	flipx,flipy,
298	295	sx + 16*x,sy + 16*y,
299		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0xff));
	296	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0xff));
300	297	}
301	298	}
302	299	}
r20824	r20825
310	307
311	308	bitmap.fill(0, cliprect);
312	309
313		starfield_render(machine(), bitmap);
	310	starfield_render(bitmap);
314	311
315	312	/* draw the low priority characters */
316	313	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
317	314
318		draw_sprites(machine(), bitmap, cliprect);
	315	draw_sprites(bitmap, cliprect);
319	316
320	317	/* draw the high priority characters */
321	318	/* (I don't know if this feature is used by Gaplus, but it's shown in the schematics) */

trunk/src/mame/video/galastrm.c

r20824	r20825
82	82
83	83	********************************************************/
84	84
85		static void draw_sprites_pre(running_machine &machine, int x_offs, int y_offs)
	85	void galastrm_state::draw_sprites_pre(int x_offs, int y_offs)
86	86	{
87		galastrm_state *state = machine.driver_data<galastrm_state>();
88		UINT32 *spriteram32 = state->m_spriteram;
89		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
	87	UINT32 *spriteram32 = m_spriteram;
	88	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
90	89	int offs, data, tilenum, color, flipx, flipy;
91	90	int x, y, priority, dblsize, curx, cury;
92	91	int sprites_flipscreen = 0;
r20824	r20825
96	95
97	96	/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
98	97	while processing sprite ram and then draw them all at the end */
99		state->m_sprite_ptr_pre = state->m_spritelist;
	98	m_sprite_ptr_pre = m_spritelist;
100	99
101		for (offs = (state->m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
	100	for (offs = (m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
102	101	{
103	102	data = spriteram32[offs+0];
104	103	flipx =    (data & 0x00800000) >> 23;
r20824	r20825
171	170	flipy = !flipy;
172	171	}
173	172
174		state->m_sprite_ptr_pre->gfx = 0;
175		state->m_sprite_ptr_pre->code = code;
176		state->m_sprite_ptr_pre->color = color;
177		state->m_sprite_ptr_pre->flipx = !flipx;
178		state->m_sprite_ptr_pre->flipy = flipy;
179		state->m_sprite_ptr_pre->x = curx;
180		state->m_sprite_ptr_pre->y = cury;
181		state->m_sprite_ptr_pre->zoomx = zx << 12;
182		state->m_sprite_ptr_pre->zoomy = zy << 12;
183		state->m_sprite_ptr_pre->primask = priority;
	173	m_sprite_ptr_pre->gfx = 0;
	174	m_sprite_ptr_pre->code = code;
	175	m_sprite_ptr_pre->color = color;
	176	m_sprite_ptr_pre->flipx = !flipx;
	177	m_sprite_ptr_pre->flipy = flipy;
	178	m_sprite_ptr_pre->x = curx;
	179	m_sprite_ptr_pre->y = cury;
	180	m_sprite_ptr_pre->zoomx = zx << 12;
	181	m_sprite_ptr_pre->zoomy = zy << 12;
	182	m_sprite_ptr_pre->primask = priority;
184	183
185		state->m_sprite_ptr_pre++;
	184	m_sprite_ptr_pre++;
186	185	}
187	186	if (bad_chunks)
188	187	logerror("Sprite number %04x had %02x invalid chunks\n",tilenum,bad_chunks);
189	188	}
190	189	}
191	190
192		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, const int *primasks, int priority)
	191	void galastrm_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, const int *primasks, int priority)
193	192	{
194		galastrm_state *state = machine.driver_data<galastrm_state>();
195		struct tempsprite *sprite_ptr = state->m_sprite_ptr_pre;
	193	struct tempsprite *sprite_ptr = m_sprite_ptr_pre;
196	194
197		while (sprite_ptr != state->m_spritelist)
	195	while (sprite_ptr != m_spritelist)
198	196	{
199	197	sprite_ptr--;
200	198
201	199	if ((priority != 0 && sprite_ptr->primask != 0) ||
202	200	(priority == 0 && sprite_ptr->primask == 0))
203	201	{
204		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	202	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
205	203	sprite_ptr->code,
206	204	sprite_ptr->color,
207	205	sprite_ptr->flipx,sprite_ptr->flipy,
208	206	sprite_ptr->x,sprite_ptr->y,
209	207	sprite_ptr->zoomx,sprite_ptr->zoomy,
210		machine.priority_bitmap,primasks[sprite_ptr->primask],0);
	208	machine().priority_bitmap,primasks[sprite_ptr->primask],0);
211	209	}
212	210	}
213	211	}
r20824	r20825
238	236	}
239	237	}
240	238
241		static void tc0610_rotate_draw(running_machine &machine, bitmap_ind16 &bitmap, bitmap_ind16 &srcbitmap, const rectangle &clip)
	239	void galastrm_state::tc0610_rotate_draw(bitmap_ind16 &bitmap, bitmap_ind16 &srcbitmap, const rectangle &clip)
242	240	{
243		galastrm_state *state = machine.driver_data<galastrm_state>();
244		poly_extra_data *extra = (poly_extra_data *)poly_get_extra_data(state->m_poly);
	241	poly_extra_data *extra = (poly_extra_data *)poly_get_extra_data(m_poly);
245	242	poly_draw_scanline_func callback;
246	243	poly_vertex vert[4];
247		int rsx = state->m_tc0610_ctrl_reg[1][0];
248		int rsy = state->m_tc0610_ctrl_reg[1][1];
249		const int rzx = state->m_tc0610_ctrl_reg[1][2];
250		const int rzy = state->m_tc0610_ctrl_reg[1][3];
251		const int ryx = state->m_tc0610_ctrl_reg[1][5];
252		const int ryy = state->m_tc0610_ctrl_reg[1][4];
	244	int rsx = m_tc0610_ctrl_reg[1][0];
	245	int rsy = m_tc0610_ctrl_reg[1][1];
	246	const int rzx = m_tc0610_ctrl_reg[1][2];
	247	const int rzy = m_tc0610_ctrl_reg[1][3];
	248	const int ryx = m_tc0610_ctrl_reg[1][5];
	249	const int ryy = m_tc0610_ctrl_reg[1][4];
253	250	const int lx  = srcbitmap.width();
254	251	const int ly  = srcbitmap.height();
255	252
r20824	r20825
283	280	zcs = ((float)pxx/4096.0) / (float)(lx / 2);
284	281
285	282
286		if ((rsx == -240 && rsy == 1072) || !state->m_tc0610_ctrl_reg[1][7])
	283	if ((rsx == -240 && rsy == 1072) || !m_tc0610_ctrl_reg[1][7])
287	284	{
288		state->m_rsxoffs = 0;
289		state->m_rsyoffs = 0;
	285	m_rsxoffs = 0;
	286	m_rsyoffs = 0;
290	287	}
291	288	else
292	289	{
293		if (rsx > state->m_rsxb && state->m_rsxb < 0 && rsx-state->m_rsxb > 0x8000)
	290	if (rsx > m_rsxb && m_rsxb < 0 && rsx-m_rsxb > 0x8000)
294	291	{
295		if (state->m_rsxoffs == 0)
296		state->m_rsxoffs = -0x10000;
	292	if (m_rsxoffs == 0)
	293	m_rsxoffs = -0x10000;
297	294	else
298		state->m_rsxoffs = 0;
	295	m_rsxoffs = 0;
299	296	}
300		if (rsx < state->m_rsxb && state->m_rsxb > 0 && state->m_rsxb-rsx > 0x8000)
	297	if (rsx < m_rsxb && m_rsxb > 0 && m_rsxb-rsx > 0x8000)
301	298	{
302		if (state->m_rsxoffs == 0)
303		state->m_rsxoffs = 0x10000-1;
	299	if (m_rsxoffs == 0)
	300	m_rsxoffs = 0x10000-1;
304	301	else
305		state->m_rsxoffs = 0;
	302	m_rsxoffs = 0;
306	303	}
307		if (rsy > state->m_rsyb && state->m_rsyb < 0 && rsy-state->m_rsyb > 0x8000)
	304	if (rsy > m_rsyb && m_rsyb < 0 && rsy-m_rsyb > 0x8000)
308	305	{
309		if (state->m_rsyoffs == 0)
310		state->m_rsyoffs = -0x10000;
	306	if (m_rsyoffs == 0)
	307	m_rsyoffs = -0x10000;
311	308	else
312		state->m_rsyoffs = 0;
	309	m_rsyoffs = 0;
313	310	}
314		if (rsy < state->m_rsyb && state->m_rsyb > 0 && state->m_rsyb-rsy > 0x8000)
	311	if (rsy < m_rsyb && m_rsyb > 0 && m_rsyb-rsy > 0x8000)
315	312	{
316		if (state->m_rsyoffs == 0)
317		state->m_rsyoffs = 0x10000-1;
	313	if (m_rsyoffs == 0)
	314	m_rsyoffs = 0x10000-1;
318	315	else
319		state->m_rsyoffs = 0;
	316	m_rsyoffs = 0;
320	317	}
321	318	}
322		state->m_rsxb = rsx;
323		state->m_rsyb = rsy;
324		if (state->m_rsxoffs) rsx += state->m_rsxoffs;
325		if (state->m_rsyoffs) rsy += state->m_rsyoffs;
326		if (rsx < -0x14000 || rsx >= 0x14000) state->m_rsxoffs = 0;
327		if (rsy < -0x14000 || rsy >= 0x14000) state->m_rsyoffs = 0;
	319	m_rsxb = rsx;
	320	m_rsyb = rsy;
	321	if (m_rsxoffs) rsx += m_rsxoffs;
	322	if (m_rsyoffs) rsy += m_rsyoffs;
	323	if (rsx < -0x14000 || rsx >= 0x14000) m_rsxoffs = 0;
	324	if (rsy < -0x14000 || rsy >= 0x14000) m_rsyoffs = 0;
328	325
329	326
330	327	pxx = 0;
r20824	r20825
338	335	//ysn = 0.0;
339	336	//ycs = 0.0;
340	337
341		if (state->m_tc0610_ctrl_reg[1][7])
	338	if (m_tc0610_ctrl_reg[1][7])
342	339	{
343	340	if (ryx != 0 || ryy != 0)
344	341	{
r20824	r20825
423	420
424	421	extra->texbase = &srcbitmap;
425	422	callback = tc0610_draw_scanline;
426		poly_render_quad(state->m_poly, &bitmap, clip, callback, 2, &vert[0], &vert[1], &vert[2], &vert[3]);
	423	poly_render_quad(m_poly, &bitmap, clip, callback, 2, &vert[0], &vert[1], &vert[2], &vert[3]);
427	424	}
428	425
429	426	/**************************************************************
r20824	r20825
542	539	}
543	540	}
544	541
545		draw_sprites_pre(machine(), 42-X_OFFSET, -571+Y_OFFSET);
546		draw_sprites(machine(),m_tmpbitmaps,clip,primasks,1);
	542	draw_sprites_pre(42-X_OFFSET, -571+Y_OFFSET);
	543	draw_sprites(m_tmpbitmaps,clip,primasks,1);
547	544
548	545	copybitmap_trans(bitmap,m_polybitmap,0,0, 0,0,cliprect,0);
549	546	m_polybitmap.fill(0, clip);
550		tc0610_rotate_draw(machine(),m_polybitmap,m_tmpbitmaps,cliprect);
	547	tc0610_rotate_draw(m_polybitmap,m_tmpbitmaps,cliprect);
551	548
552	549	priority_bitmap.fill(0, cliprect);
553		draw_sprites(machine(),bitmap,cliprect,primasks,0);
	550	draw_sprites(bitmap,cliprect,primasks,0);
554	551
555	552	tc0480scp_tilemap_draw(tc0480scp, bitmap, cliprect, layer[4], 0, 0);
556	553	tc0100scn_tilemap_draw(tc0100scn, bitmap, cliprect, pivlayer[2], 0, 0);

trunk/src/mame/video/galaxold.c

r20824	r20825
7	7	#include "emu.h"
8	8	#include "includes/galaxold.h"
9	9
10		#define STARS_COLOR_BASE_LEGACY (machine.root_device().memregion("proms")->bytes())
11	10	#define STARS_COLOR_BASE        (machine().root_device().memregion("proms")->bytes())
12	11	#define BULLETS_COLOR_BASE      (STARS_COLOR_BASE + 64)
13		#define BULLETS_COLOR_BASE_LEGACY       (STARS_COLOR_BASE_LEGACY + 64)
14	12	#define BACKGROUND_COLOR_BASE   (BULLETS_COLOR_BASE + 2)
15		#define BACKGROUND_COLOR_BASE_LEGACY    (BULLETS_COLOR_BASE_LEGACY + 2)
16	13
17
18
19
20		static void mooncrst_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x);
21		static void   pisces_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x);
22		static void mimonkey_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x);
23		static void  mariner_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x);
24		static void dambustr_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x);
25
26		static void mshuttle_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
27		static void mimonkey_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
28		static void  batman2_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
29		static void dkongjrm_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
30		static void   ad2083_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
31		static void dambustr_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
32
33		static void drivfrcg_modify_color(UINT8 *color);
34
35
36
37
38		void galaxold_init_stars(running_machine &machine, int colors_offset);
39		static void     noop_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
40		void galaxold_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
41		static void scrambold_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
42		static void   rescue_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
43		static void  mariner_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
44		static void start_stars_blink_timer(running_machine &machine, double ra, double rb, double c);
45		static void start_stars_scroll_timer(running_machine &machine);
46
47		/* bullets circuit */
48		static void galaxold_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
49		static void scrambold_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
50		static void darkplnt_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
51		static void dambustr_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
52
53		/* background circuit */
54		static void galaxold_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
55		static void scrambold_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
56		static void  ad2083_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
57		static void  mariner_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
58		static void stratgyx_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
59		static void  minefld_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
60		static void   rescue_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
61		static void dambustr_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
62
63
64
65
66	14	/***************************************************************************
67	15
68	16	Convert the color PROMs into a more useable format.
r20824	r20825
127	75	}
128	76
129	77
130		galaxold_init_stars(machine(), STARS_COLOR_BASE);
	78	galaxold_init_stars(STARS_COLOR_BASE);
131	79
132	80
133	81	/* bullets - yellow and white */
r20824	r20825
372	320	}
373	321
374	322
375		galaxold_init_stars(machine(), STARS_COLOR_BASE);
	323	galaxold_init_stars(STARS_COLOR_BASE);
376	324
377	325
378	326	/* bullets - yellow and white */
r20824	r20825
430	378
431	379	***************************************************************************/
432	380
433		static void state_save_register(running_machine &machine)
	381	void galaxold_state::state_save_register()
434	382	{
435		galaxold_state *state = machine.driver_data<galaxold_state>();
436		state_save_register_global_array(machine, state->m_gfxbank);
437		state_save_register_global(machine, state->m_flipscreen_x);
438		state_save_register_global(machine, state->m_flipscreen_y);
	383	state_save_register_global_array(machine(), m_gfxbank);
	384	state_save_register_global(machine(), m_flipscreen_x);
	385	state_save_register_global(machine(), m_flipscreen_y);
439	386
440		state_save_register_global(machine, state->m_stars_on);
441		state_save_register_global(machine, state->m_stars_scrollpos);
442		state_save_register_global(machine, state->m_stars_blink_state);
	387	state_save_register_global(machine(), m_stars_on);
	388	state_save_register_global(machine(), m_stars_scrollpos);
	389	state_save_register_global(machine(), m_stars_blink_state);
443	390
444		state_save_register_global(machine, state->m_darkplnt_bullet_color);
	391	state_save_register_global(machine(), m_darkplnt_bullet_color);
445	392
446		state_save_register_global(machine, state->m_background_enable);
447		state_save_register_global(machine, state->m_background_red);
448		state_save_register_global(machine, state->m_background_green);
449		state_save_register_global(machine, state->m_background_blue);
	393	state_save_register_global(machine(), m_background_enable);
	394	state_save_register_global(machine(), m_background_red);
	395	state_save_register_global(machine(), m_background_green);
	396	state_save_register_global(machine(), m_background_blue);
450	397	}
451	398
452		static void video_start_common(running_machine &machine)
	399	void galaxold_state::video_start_common()
453	400	{
454		galaxold_state *state = machine.driver_data<galaxold_state>();
455		state->m_modify_charcode = 0;
456		state->m_modify_spritecode = 0;
457		state->m_modify_color = 0;
458		state->m_modify_ypos = 0;
	401	m_modify_charcode = 0;
	402	m_modify_spritecode = 0;
	403	m_modify_color = 0;
	404	m_modify_ypos = 0;
459	405
460		state->m_mooncrst_gfxextend = 0;
	406	m_mooncrst_gfxextend = 0;
461	407
462		state->m_draw_bullets = 0;
	408	m_draw_bullets = 0;
463	409
464		state->m_draw_background = galaxold_draw_background;
465		state->m_background_enable = 0;
466		state->m_background_blue = 0;
467		state->m_background_red = 0;
468		state->m_background_green = 0;
	410	m_draw_background = &galaxold_state::galaxold_draw_background;
	411	m_background_enable = 0;
	412	m_background_blue = 0;
	413	m_background_red = 0;
	414	m_background_green = 0;
469	415
470		state->m_draw_stars = noop_draw_stars;
	416	m_draw_stars = &galaxold_state::noop_draw_stars;
471	417
472		state->m_flipscreen_x = 0;
473		state->m_flipscreen_y = 0;
	418	m_flipscreen_x = 0;
	419	m_flipscreen_y = 0;
474	420
475		state->m_spriteram2_present = 0;
	421	m_spriteram2_present = 0;
476	422
477		state_save_register(machine);
	423	state_save_register();
478	424	}
479	425
480	426	VIDEO_START_MEMBER(galaxold_state,galaxold_plain)
481	427	{
482		video_start_common(machine());
	428	video_start_common();
483	429	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxold_state::get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,32,32);
484	430	m_bg_tilemap->set_transparent_pen(0);
485	431
r20824	r20825
492	438	{
493	439	VIDEO_START_CALL_MEMBER(galaxold_plain);
494	440
495		m_draw_stars = galaxold_draw_stars;
	441	m_draw_stars = &galaxold_state::galaxold_draw_stars;
496	442
497		m_draw_bullets = galaxold_draw_bullets;
	443	m_draw_bullets = &galaxold_state::galaxold_draw_bullets;
498	444	}
499	445
500	446	VIDEO_START_MEMBER(galaxold_state,scrambold)
r20824	r20825
506	452	*/
507	453	m_bg_tilemap->set_scrolldx(0, 0);
508	454
509		m_draw_stars = scrambold_draw_stars;
	455	m_draw_stars = &galaxold_state::scrambold_draw_stars;
510	456
511		m_draw_bullets = scrambold_draw_bullets;
	457	m_draw_bullets = &galaxold_state::scrambold_draw_bullets;
512	458
513		m_draw_background = scrambold_draw_background;
	459	m_draw_background = &galaxold_state::scrambold_draw_background;
514	460	}
515	461
516	462	VIDEO_START_MEMBER(galaxold_state,darkplnt)
r20824	r20825
518	464	VIDEO_START_CALL_MEMBER(galaxold_plain);
519	465
520	466	m_bg_tilemap->set_scrolldx(0, 0);
521		m_draw_bullets = darkplnt_draw_bullets;
	467	m_draw_bullets = &galaxold_state::darkplnt_draw_bullets;
522	468	}
523	469
524	470	VIDEO_START_MEMBER(galaxold_state,rescue)
525	471	{
526	472	VIDEO_START_CALL_MEMBER(scrambold);
527	473
528		m_draw_stars = rescue_draw_stars;
	474	m_draw_stars = &galaxold_state::rescue_draw_stars;
529	475
530		m_draw_background = rescue_draw_background;
	476	m_draw_background = &galaxold_state::rescue_draw_background;
531	477	}
532	478
533	479	VIDEO_START_MEMBER(galaxold_state,minefld)
534	480	{
535	481	VIDEO_START_CALL_MEMBER(scrambold);
536	482
537		m_draw_stars = rescue_draw_stars;
	483	m_draw_stars = &galaxold_state::rescue_draw_stars;
538	484
539		m_draw_background = minefld_draw_background;
	485	m_draw_background = &galaxold_state::minefld_draw_background;
540	486	}
541	487
542	488	VIDEO_START_MEMBER(galaxold_state,stratgyx)
543	489	{
544	490	VIDEO_START_CALL_MEMBER(galaxold_plain);
545	491
546		m_draw_background = stratgyx_draw_background;
	492	m_draw_background = &galaxold_state::stratgyx_draw_background;
547	493	}
548	494
549	495	VIDEO_START_MEMBER(galaxold_state,ckongs)
550	496	{
551	497	VIDEO_START_CALL_MEMBER(scrambold);
552	498
553		m_modify_spritecode = mshuttle_modify_spritecode;
	499	m_modify_spritecode = &galaxold_state::mshuttle_modify_spritecode;
554	500	}
555	501
556	502	VIDEO_START_MEMBER(galaxold_state,mariner)
557	503	{
558	504	VIDEO_START_CALL_MEMBER(galaxold_plain);
559	505
560		m_draw_stars = mariner_draw_stars;
	506	m_draw_stars = &galaxold_state::mariner_draw_stars;
561	507
562		m_draw_bullets = scrambold_draw_bullets;
	508	m_draw_bullets = &galaxold_state::scrambold_draw_bullets;
563	509
564		m_draw_background = mariner_draw_background;
	510	m_draw_background = &galaxold_state::mariner_draw_background;
565	511
566		m_modify_charcode = mariner_modify_charcode;
	512	m_modify_charcode = &galaxold_state::mariner_modify_charcode;
567	513	}
568	514
569	515	VIDEO_START_MEMBER(galaxold_state,mimonkey)
570	516	{
571	517	VIDEO_START_CALL_MEMBER(scrambold);
572	518
573		m_modify_charcode   = mimonkey_modify_charcode;
574		m_modify_spritecode = mimonkey_modify_spritecode;
	519	m_modify_charcode   = &galaxold_state::mimonkey_modify_charcode;
	520	m_modify_spritecode = &galaxold_state::mimonkey_modify_spritecode;
575	521	}
576	522
577	523	VIDEO_START_MEMBER(galaxold_state,dkongjrm)
578	524	{
579	525	VIDEO_START_CALL_MEMBER(galaxold_plain);
580	526
581		m_modify_charcode   = pisces_modify_charcode;
582		m_modify_spritecode = dkongjrm_modify_spritecode;
	527	m_modify_charcode   = &galaxold_state::pisces_modify_charcode;
	528	m_modify_spritecode = &galaxold_state::dkongjrm_modify_spritecode;
583	529
584	530	m_spriteram2_present= 1;
585	531	}
r20824	r20825
588	534	{
589	535	VIDEO_START_CALL_MEMBER(scrambold);
590	536
591		m_modify_spritecode = batman2_modify_spritecode;
	537	m_modify_spritecode = &galaxold_state::batman2_modify_spritecode;
592	538	}
593	539
594		static void pisces_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	540	void galaxold_state::pisces_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
595	541	{
596		galaxold_state *state = machine.driver_data<galaxold_state>();
597		*code |= (state->m_gfxbank[0] << 6);
	542	*code |= (m_gfxbank[0] << 6);
598	543	}
599	544
600	545	VIDEO_START_MEMBER(galaxold_state,pisces)
601	546	{
602	547	VIDEO_START_CALL_MEMBER(galaxold);
603	548
604		m_modify_charcode   = pisces_modify_charcode;
605		m_modify_spritecode = pisces_modify_spritecode;
	549	m_modify_charcode   = &galaxold_state::pisces_modify_charcode;
	550	m_modify_spritecode = &galaxold_state::pisces_modify_spritecode;
606	551	}
607	552
608	553	#ifdef UNUSED_FUNCTION
609		static void theend_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	554	void galaxold_state::theend_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
610	555	{
611	556	int i;
612	557
r20824	r20825
625	570	{
626	571	VIDEO_START_CALL_MEMBER(galaxold);
627	572
628		m_draw_bullets = theend_draw_bullets;
	573	m_draw_bullets = &galaxold_state::theend_draw_bullets;
629	574	}
630	575	#endif
631	576
632		static void mooncrst_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	577	void galaxold_state::mooncrst_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
633	578	{
634		galaxold_state *state = machine.driver_data<galaxold_state>();
635		if (state->m_gfxbank[2] && ((*code & 0x30) == 0x20))
	579	if (m_gfxbank[2] && ((*code & 0x30) == 0x20))
636	580	{
637		*code = (*code & 0x0f) | (state->m_gfxbank[0] << 4) | (state->m_gfxbank[1] << 5) | 0x40;
	581	*code = (*code & 0x0f) | (m_gfxbank[0] << 4) | (m_gfxbank[1] << 5) | 0x40;
638	582	}
639	583	}
640	584
r20824	r20825
642	586	{
643	587	VIDEO_START_CALL_MEMBER(galaxold);
644	588
645		m_modify_charcode   = mooncrst_modify_charcode;
646		m_modify_spritecode = mooncrst_modify_spritecode;
	589	m_modify_charcode   = &galaxold_state::mooncrst_modify_charcode;
	590	m_modify_spritecode = &galaxold_state::mooncrst_modify_spritecode;
647	591	}
648	592
649		static void batman2_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	593	void galaxold_state::batman2_modify_charcode(UINT16 *code, UINT8 x)
650	594	{
651		galaxold_state *state = machine.driver_data<galaxold_state>();
652	595	if (*code & 0x80)
653	596	{
654		*code |= (state->m_gfxbank[0] << 8);
	597	*code |= (m_gfxbank[0] << 8);
655	598	}
656	599	}
657	600
r20824	r20825
659	602	{
660	603	VIDEO_START_CALL_MEMBER(galaxold);
661	604
662		m_modify_charcode   = batman2_modify_charcode;
663		m_modify_spritecode = batman2_modify_spritecode;
	605	m_modify_charcode   = &galaxold_state::batman2_modify_charcode;
	606	m_modify_spritecode = &galaxold_state::batman2_modify_spritecode;
664	607	}
665	608
666	609
667	610
668		static void rockclim_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	611	void galaxold_state::rockclim_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
669	612	{
670		galaxold_state *state = machine.driver_data<galaxold_state>();
671		state->m_rockclim_tilemap->draw(bitmap, cliprect, 0,0);
	613	m_rockclim_tilemap->draw(bitmap, cliprect, 0,0);
672	614	}
673	615
674		static void rockclim_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	616	void galaxold_state::rockclim_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
675	617	{
676		galaxold_state *state = machine.driver_data<galaxold_state>();
677		if (state->m_gfxbank[2])    *code|=0x40;
	618	if (m_gfxbank[2])    *code|=0x40;
678	619	}
679	620
680	621	VIDEO_START_MEMBER(galaxold_state,rockclim)
r20824	r20825
682	623	VIDEO_START_CALL_MEMBER(galaxold);
683	624	m_rockclim_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxold_state::rockclim_get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,64,32);
684	625
685		m_draw_background = rockclim_draw_background;
686		m_modify_charcode = mooncrst_modify_charcode;
687		m_modify_spritecode = rockclim_modify_spritecode;
	626	m_draw_background = &galaxold_state::rockclim_draw_background;
	627	m_modify_charcode = &galaxold_state::mooncrst_modify_charcode;
	628	m_modify_spritecode = &galaxold_state::rockclim_modify_spritecode;
688	629
689	630	m_rockclim_v = m_rockclim_h = 0;
690	631	state_save_register_global(machine(), m_rockclim_v);
r20824	r20825
706	647
707	648	VIDEO_START_MEMBER(galaxold_state,drivfrcg)
708	649	{
709		video_start_common(machine());
	650	video_start_common();
710	651	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxold_state::drivfrcg_get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,32,32);
711	652
712	653	m_bg_tilemap->set_transparent_pen(0);
713	654	m_bg_tilemap->set_scroll_cols(32);
714	655
715		m_modify_spritecode = mshuttle_modify_spritecode;
716		m_modify_color = drivfrcg_modify_color;
	656	m_modify_spritecode = &galaxold_state::mshuttle_modify_spritecode;
	657	m_modify_color = &galaxold_state::drivfrcg_modify_color;
717	658
718	659	m_color_mask = 0xff;
719	660	}
720	661
721	662	VIDEO_START_MEMBER(galaxold_state,ad2083)
722	663	{
723		video_start_common(machine());
	664	video_start_common();
724	665	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxold_state::drivfrcg_get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,32,32);
725	666
726	667	m_bg_tilemap->set_transparent_pen(0);
727	668	m_bg_tilemap->set_scroll_cols(32);
728	669
729		m_modify_spritecode = ad2083_modify_spritecode;
	670	m_modify_spritecode = &galaxold_state::ad2083_modify_spritecode;
730	671
731		m_draw_bullets = scrambold_draw_bullets;
	672	m_draw_bullets = &galaxold_state::scrambold_draw_bullets;
732	673
733		m_draw_background = ad2083_draw_background;
	674	m_draw_background = &galaxold_state::ad2083_draw_background;
734	675
735	676	m_color_mask = 7;
736	677	}
r20824	r20825
756	697
757	698	VIDEO_START_MEMBER(galaxold_state,racknrol)
758	699	{
759		video_start_common(machine());
	700	video_start_common();
760	701	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxold_state::racknrol_get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,32,32);
761	702
762	703	m_bg_tilemap->set_transparent_pen(0);
r20824	r20825
780	721	SET_TILE_INFO_MEMBER(0, code, color, 0);
781	722	}
782	723
783		static void harem_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	724	void galaxold_state::harem_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
784	725	{
785		galaxold_state *state = machine.driver_data<galaxold_state>();
786		*code |= (state->m_gfxbank[0] << 7) | 0x40;
	726	*code |= (m_gfxbank[0] << 7) | 0x40;
787	727	}
788	728
789	729	VIDEO_START_MEMBER(galaxold_state,harem)
790	730	{
791		video_start_common(machine());
	731	video_start_common();
792	732	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(galaxold_state::harem_get_tile_info),this),TILEMAP_SCAN_ROWS,8,8,32,32);
793	733	//  m_bg_tilemap->set_transparent_pen(0);   // opaque tilemap to get sky and sand colors
794	734
r20824	r20825
796	736
797	737	m_color_mask = (machine().gfx[0]->granularity() == 4) ? 7 : 3;
798	738
799		m_modify_spritecode = harem_modify_spritecode;
	739	m_modify_spritecode = &galaxold_state::harem_modify_spritecode;
800	740	}
801	741
802	742	VIDEO_START_MEMBER(galaxold_state,ozon1)
r20824	r20825
812	752
813	753	m_bg_tilemap->set_scrolldx(0, 384-256);
814	754
815		m_modify_spritecode = batman2_modify_spritecode;
	755	m_modify_spritecode = &galaxold_state::batman2_modify_spritecode;
816	756	}
817	757
818	758	TILE_GET_INFO_MEMBER(galaxold_state::dambustr_get_tile_info2)
r20824	r20825
824	764
825	765	if (m_modify_charcode)
826	766	{
827		(*m_modify_charcode)(machine(), &code, x);
	767	(this->*m_modify_charcode)(&code, x);
828	768	}
829	769
830	770	if (m_modify_color)
831	771	{
832		(*m_modify_color)(&color);
	772	(this->*m_modify_color)(&color);
833	773	}
834	774
835	775	SET_TILE_INFO_MEMBER(0, code, color, 0);
r20824	r20825
845	785	m_dambustr_bg_priority = 0;
846	786	m_dambustr_char_bank = 0;
847	787
848		m_draw_background = dambustr_draw_background;
	788	m_draw_background = &galaxold_state::dambustr_draw_background;
849	789
850		m_modify_charcode   = dambustr_modify_charcode;
851		m_modify_spritecode = dambustr_modify_spritecode;
	790	m_modify_charcode   = &galaxold_state::dambustr_modify_charcode;
	791	m_modify_spritecode = &galaxold_state::dambustr_modify_spritecode;
852	792
853		m_draw_bullets = dambustr_draw_bullets;
	793	m_draw_bullets = &galaxold_state::dambustr_draw_bullets;
854	794
855	795	/* allocate the temporary bitmap for the background priority */
856	796	m_dambustr_tmpbitmap = auto_bitmap_ind16_alloc(machine(), machine().primary_screen->width(), machine().primary_screen->height());
r20824	r20825
891	831	{
892	832	if (m_modify_ypos)
893	833	{
894		(*m_modify_ypos)(&data);
	834	(this->*m_modify_ypos)(&data);
895	835	}
896	836
897	837	m_bg_tilemap->set_scrolly(offset >> 1, data);
r20824	r20825
1036	976
1037	977	/* character banking functions */
1038	978
1039		static void mooncrst_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	979	void galaxold_state::mooncrst_modify_charcode(UINT16 *code, UINT8 x)
1040	980	{
1041		galaxold_state *state = machine.driver_data<galaxold_state>();
1042		if (state->m_gfxbank[2] && ((*code & 0xc0) == 0x80))
	981	if (m_gfxbank[2] && ((*code & 0xc0) == 0x80))
1043	982	{
1044		*code = (*code & 0x3f) | (state->m_gfxbank[0] << 6) | (state->m_gfxbank[1] << 7) | 0x0100;
	983	*code = (*code & 0x3f) | (m_gfxbank[0] << 6) | (m_gfxbank[1] << 7) | 0x0100;
1045	984	}
1046	985	}
1047	986
1048		static void pisces_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	987	void galaxold_state::pisces_modify_charcode(UINT16 *code, UINT8 x)
1049	988	{
1050		galaxold_state *state = machine.driver_data<galaxold_state>();
1051		*code |= (state->m_gfxbank[0] << 8);
	989	*code |= (m_gfxbank[0] << 8);
1052	990	}
1053	991
1054		static void mimonkey_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	992	void galaxold_state::mimonkey_modify_charcode(UINT16 *code, UINT8 x)
1055	993	{
1056		galaxold_state *state = machine.driver_data<galaxold_state>();
1057		*code |= (state->m_gfxbank[0] << 8) | (state->m_gfxbank[2] << 9);
	994	*code |= (m_gfxbank[0] << 8) | (m_gfxbank[2] << 9);
1058	995	}
1059	996
1060		static void mariner_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	997	void galaxold_state::mariner_modify_charcode(UINT16 *code, UINT8 x)
1061	998	{
1062	999	UINT8 *prom;
1063	1000
1064	1001
1065	1002	/* bit 0 of the PROM controls character banking */
1066	1003
1067		prom = machine.root_device().memregion("user2")->base();
	1004	prom = machine().root_device().memregion("user2")->base();
1068	1005
1069	1006	*code |= ((prom[x] & 0x01) << 8);
1070	1007	}
1071	1008
1072		static void dambustr_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	1009	void galaxold_state::dambustr_modify_charcode(UINT16 *code, UINT8 x)
1073	1010	{
1074		galaxold_state *state = machine.driver_data<galaxold_state>();
1075		if (state->m_dambustr_char_bank == 0) { // text mode
	1011	if (m_dambustr_char_bank == 0) { // text mode
1076	1012	*code |= 0x0300;
1077	1013	}
1078	1014	else {              // graphics mode
r20824	r20825
1087	1023
1088	1024	/* sprite banking functions */
1089	1025
1090		static void mshuttle_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1026	void galaxold_state::mshuttle_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1091	1027	{
1092	1028	*code |= ((spriteram[offs + 2] & 0x30) << 2);
1093	1029	}
1094	1030
1095	1031
1096		static void mimonkey_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1032	void galaxold_state::mimonkey_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1097	1033	{
1098		galaxold_state *state = machine.driver_data<galaxold_state>();
1099		*code |= (state->m_gfxbank[0] << 6) | (state->m_gfxbank[2] << 7);
	1034	*code |= (m_gfxbank[0] << 6) | (m_gfxbank[2] << 7);
1100	1035	}
1101	1036
1102		static void batman2_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1037	void galaxold_state::batman2_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1103	1038	{
1104	1039	/* only the upper 64 sprites are used */
1105	1040	*code |= 0x40;
1106	1041	}
1107	1042
1108		static void dkongjrm_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1043	void galaxold_state::dkongjrm_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1109	1044	{
1110	1045	/* No x flip */
1111	1046	*code = (spriteram[offs + 1] & 0x7f) | 0x80;
1112	1047	*flipx = 0;
1113	1048	}
1114	1049
1115		static void ad2083_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1050	void galaxold_state::ad2083_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1116	1051	{
1117	1052	/* No x flip */
1118	1053	*code = (spriteram[offs + 1] & 0x7f) | ((spriteram[offs + 2] & 0x30) << 2);
1119	1054	*flipx = 0;
1120	1055	}
1121	1056
1122		static void dambustr_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1057	void galaxold_state::dambustr_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1123	1058	{
1124	1059	*code += 0x40;
1125	1060	}
r20824	r20825
1127	1062
1128	1063	/* color PROM mapping functions */
1129	1064
1130		static void drivfrcg_modify_color(UINT8 *color)
	1065	void galaxold_state::drivfrcg_modify_color(UINT8 *color)
1131	1066	{
1132	1067	*color = ((*color & 0x40) >> 3) | (*color & 7);
1133	1068	}
r20824	r20825
1137	1072
1138	1073	/* bullet drawing functions */
1139	1074
1140		static void galaxold_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1075	void galaxold_state::galaxold_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1141	1076	{
1142	1077	int i;
1143	1078
r20824	r20825
1152	1087
1153	1088
1154	1089	/* yellow missile, white shells (this is the terminology on the schematics) */
1155		color = ((offs == 7*4) ? BULLETS_COLOR_BASE_LEGACY : BULLETS_COLOR_BASE_LEGACY + 1);
	1090	color = ((offs == 7*4) ? BULLETS_COLOR_BASE : BULLETS_COLOR_BASE + 1);
1156	1091
1157	1092	bitmap.pix16(y, x) = color;
1158	1093	}
1159	1094	}
1160	1095	}
1161	1096
1162		static void scrambold_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1097	void galaxold_state::scrambold_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1163	1098	{
1164		galaxold_state *state = machine.driver_data<galaxold_state>();
1165		if (state->m_flipscreen_x)  x++;
	1099	if (m_flipscreen_x)  x++;
1166	1100
1167	1101	x = x - 6;
1168	1102
1169	1103	if (cliprect.contains(x, y))
1170	1104	/* yellow bullets */
1171		bitmap.pix16(y, x) = BULLETS_COLOR_BASE_LEGACY;
	1105	bitmap.pix16(y, x) = BULLETS_COLOR_BASE;
1172	1106	}
1173	1107
1174		static void darkplnt_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1108	void galaxold_state::darkplnt_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1175	1109	{
1176		galaxold_state *state = machine.driver_data<galaxold_state>();
1177		if (state->m_flipscreen_x)  x++;
	1110	if (m_flipscreen_x)  x++;
1178	1111
1179	1112	x = x - 6;
1180	1113
1181	1114	if (cliprect.contains(x, y))
1182		bitmap.pix16(y, x) = 32 + state->m_darkplnt_bullet_color;
	1115	bitmap.pix16(y, x) = 32 + m_darkplnt_bullet_color;
1183	1116	}
1184	1117
1185		static void dambustr_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
	1118	void galaxold_state::dambustr_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
1186	1119	{
1187		galaxold_state *state = machine.driver_data<galaxold_state>();
1188	1120	int i, color;
1189	1121
1190		if (state->flip_screen_x())  x++;
	1122	if (flip_screen_x())  x++;
1191	1123
1192	1124	x = x - 6;
1193	1125
r20824	r20825
1196	1128	{
1197	1129	if (offs < 4*4)
1198	1130	{
1199		color = BULLETS_COLOR_BASE_LEGACY;
	1131	color = BULLETS_COLOR_BASE;
1200	1132	y--;
1201	1133	}
1202	1134	else {
1203		color = BULLETS_COLOR_BASE_LEGACY + 1;
	1135	color = BULLETS_COLOR_BASE + 1;
1204	1136	x--;
1205	1137	}
1206	1138
r20824	r20825
1213	1145
1214	1146	/* background drawing functions */
1215	1147
1216		static void galaxold_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1148	void galaxold_state::galaxold_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1217	1149	{
1218	1150	/* plain black background */
1219	1151	bitmap.fill(0, cliprect);
1220	1152	}
1221	1153
1222		static void scrambold_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1154	void galaxold_state::scrambold_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1223	1155	{
1224		galaxold_state *state = machine.driver_data<galaxold_state>();
1225		if (state->m_background_enable)
1226		bitmap.fill(BACKGROUND_COLOR_BASE_LEGACY, cliprect);
	1156	if (m_background_enable)
	1157	bitmap.fill(BACKGROUND_COLOR_BASE, cliprect);
1227	1158	else
1228	1159	bitmap.fill(0, cliprect);
1229	1160	}
1230	1161
1231		static void ad2083_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1162	void galaxold_state::ad2083_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1232	1163	{
1233		galaxold_state *state = machine.driver_data<galaxold_state>();
1234		int color = (state->m_background_blue << 2) | (state->m_background_green << 1) | state->m_background_red;
	1164	int color = (m_background_blue << 2) | (m_background_green << 1) | m_background_red;
1235	1165
1236		bitmap.fill(BACKGROUND_COLOR_BASE_LEGACY + color, cliprect);
	1166	bitmap.fill(BACKGROUND_COLOR_BASE + color, cliprect);
1237	1167	}
1238	1168
1239		static void stratgyx_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1169	void galaxold_state::stratgyx_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1240	1170	{
1241		galaxold_state *state = machine.driver_data<galaxold_state>();
1242	1171	UINT8 x;
1243	1172	UINT8 *prom;
1244		int base = BACKGROUND_COLOR_BASE_LEGACY;
	1173	int base = BACKGROUND_COLOR_BASE;
1245	1174
1246	1175
1247	1176	/* the background PROM is connected the following way:
r20824	r20825
1251	1180	the green gun if BCG is asserted
1252	1181	bits 2-7 are unconnected */
1253	1182
1254		prom = state->memregion("user1")->base();
	1183	prom = memregion("user1")->base();
1255	1184
1256	1185	for (x = 0; x < 32; x++)
1257	1186	{
r20824	r20825
1260	1189
1261	1190	color = 0;
1262	1191
1263		if ((~prom[x] & 0x02) && state->m_background_red)   color |= 0x01;
1264		if ((~prom[x] & 0x02) && state->m_background_green) color |= 0x02;
1265		if ((~prom[x] & 0x01) && state->m_background_blue)  color |= 0x04;
	1192	if ((~prom[x] & 0x02) && m_background_red)   color |= 0x01;
	1193	if ((~prom[x] & 0x02) && m_background_green) color |= 0x02;
	1194	if ((~prom[x] & 0x01) && m_background_blue)  color |= 0x04;
1266	1195
1267		if (state->m_flipscreen_x)
	1196	if (m_flipscreen_x)
1268	1197	sx = 8 * (31 - x);
1269	1198	else
1270	1199	sx = 8 * x;
r20824	r20825
1273	1202	}
1274	1203	}
1275	1204
1276		static void minefld_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1205	void galaxold_state::minefld_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1277	1206	{
1278		galaxold_state *state = machine.driver_data<galaxold_state>();
1279		if (state->m_background_enable)
	1207	if (m_background_enable)
1280	1208	{
1281		int base = BACKGROUND_COLOR_BASE_LEGACY;
	1209	int base = BACKGROUND_COLOR_BASE;
1282	1210	int x;
1283	1211
1284	1212
r20824	r20825
1294	1222	bitmap.fill(0, cliprect);
1295	1223	}
1296	1224
1297		static void rescue_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1225	void galaxold_state::rescue_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1298	1226	{
1299		galaxold_state *state = machine.driver_data<galaxold_state>();
1300		if (state->m_background_enable)
	1227	if (m_background_enable)
1301	1228	{
1302		int base = BACKGROUND_COLOR_BASE_LEGACY;
	1229	int base = BACKGROUND_COLOR_BASE;
1303	1230	int x;
1304	1231
1305	1232	for (x = 0; x < 128; x++)
r20824	r20825
1314	1241	bitmap.fill(0, cliprect);
1315	1242	}
1316	1243
1317		static void mariner_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1244	void galaxold_state::mariner_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1318	1245	{
1319		galaxold_state *state = machine.driver_data<galaxold_state>();
1320		int base = BACKGROUND_COLOR_BASE_LEGACY;
	1246	int base = BACKGROUND_COLOR_BASE;
1321	1247	UINT8 x;
1322	1248	UINT8 *prom;
1323	1249
r20824	r20825
1326	1252	line (column) of the screen.  The first 0x20 bytes for unflipped,
1327	1253	and the 2nd 0x20 bytes for flipped screen. */
1328	1254
1329		prom = state->memregion("user1")->base();
	1255	prom = memregion("user1")->base();
1330	1256
1331		if (state->m_flipscreen_x)
	1257	if (m_flipscreen_x)
1332	1258	{
1333	1259	for (x = 0; x < 32; x++)
1334	1260	{
r20824	r20825
1358	1284	}
1359	1285	}
1360	1286
1361		static void dambustr_draw_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1287	void galaxold_state::dambustr_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1362	1288	{
1363		galaxold_state *state = machine.driver_data<galaxold_state>();
1364		int base = BACKGROUND_COLOR_BASE_LEGACY;
1365		int col1 = base + state->m_dambustr_bg_color_1;
1366		int col2 = base + state->m_dambustr_bg_color_2;
	1289	int base = BACKGROUND_COLOR_BASE;
	1290	int col1 = base + m_dambustr_bg_color_1;
	1291	int col2 = base + m_dambustr_bg_color_2;
1367	1292
1368		if (state->flip_screen_x())
	1293	if (flip_screen_x())
1369	1294	{
1370		bitmap.plot_box(  0, 0, 256-state->m_dambustr_bg_split_line, 256, col2);
1371		bitmap.plot_box(256-state->m_dambustr_bg_split_line, 0, state->m_dambustr_bg_split_line, 256, col1);
	1295	bitmap.plot_box(  0, 0, 256-m_dambustr_bg_split_line, 256, col2);
	1296	bitmap.plot_box(256-m_dambustr_bg_split_line, 0, m_dambustr_bg_split_line, 256, col1);
1372	1297	}
1373	1298	else
1374	1299	{
1375		bitmap.plot_box(  0, 0, 256-state->m_dambustr_bg_split_line, 256, col1);
1376		bitmap.plot_box(256-state->m_dambustr_bg_split_line, 0, state->m_dambustr_bg_split_line, 256, col2);
	1300	bitmap.plot_box(  0, 0, 256-m_dambustr_bg_split_line, 256, col1);
	1301	bitmap.plot_box(256-m_dambustr_bg_split_line, 0, m_dambustr_bg_split_line, 256, col2);
1377	1302	}
1378	1303
1379	1304	}
1380	1305
1381		static void dambustr_draw_upper_background(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1306	void galaxold_state::dambustr_draw_upper_background(bitmap_ind16 &bitmap, const rectangle &cliprect)
1382	1307	{
1383		galaxold_state *state = machine.driver_data<galaxold_state>();
1384	1308
1385		if (state->flip_screen_x())
	1309	if (flip_screen_x())
1386	1310	{
1387		rectangle clip(254 - state->m_dambustr_bg_split_line, state->m_dambustr_bg_split_line, 0, 255);
1388		copybitmap(bitmap, *state->m_dambustr_tmpbitmap, 0, 0, 0, 0, clip);
	1311	rectangle clip(254 - m_dambustr_bg_split_line, m_dambustr_bg_split_line, 0, 255);
	1312	copybitmap(bitmap, *m_dambustr_tmpbitmap, 0, 0, 0, 0, clip);
1389	1313	}
1390	1314	else
1391	1315	{
1392		rectangle clip(0, 254 - state->m_dambustr_bg_split_line, 0, 255);
1393		copybitmap(bitmap, *state->m_dambustr_tmpbitmap, 0, 0, 0, 0, clip);
	1316	rectangle clip(0, 254 - m_dambustr_bg_split_line, 0, 255);
	1317	copybitmap(bitmap, *m_dambustr_tmpbitmap, 0, 0, 0, 0, clip);
1394	1318	}
1395	1319	}
1396	1320
r20824	r20825
1398	1322
1399	1323	/* star drawing functions */
1400	1324
1401		void galaxold_init_stars(running_machine &machine, int colors_offset)
	1325	void galaxold_state::galaxold_init_stars(int colors_offset)
1402	1326	{
1403		galaxold_state *state = machine.driver_data<galaxold_state>();
1404		struct star *stars = state->m_stars;
	1327	struct star *stars = m_stars;
1405	1328	int i;
1406	1329	int total_stars;
1407	1330	UINT32 generator;
1408	1331	int x,y;
1409	1332
1410	1333
1411		state->m_stars_on = 0;
1412		state->m_stars_blink_state = 0;
1413		state->m_stars_blink_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(galaxold_state::stars_blink_callback),state));
1414		state->m_stars_scroll_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(galaxold_state::stars_scroll_callback),state));
1415		state->m_timer_adjusted = 0;
1416		state->m_stars_colors_start = colors_offset;
	1334	m_stars_on = 0;
	1335	m_stars_blink_state = 0;
	1336	m_stars_blink_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(galaxold_state::stars_blink_callback),this));
	1337	m_stars_scroll_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(galaxold_state::stars_scroll_callback),this));
	1338	m_timer_adjusted = 0;
	1339	m_stars_colors_start = colors_offset;
1417	1340
1418	1341	for (i = 0;i < 64;i++)
1419	1342	{
r20824	r20825
1427	1350	g = map[bits];
1428	1351	bits = (i >> 4) & 0x03;
1429	1352	b = map[bits];
1430		palette_set_color_rgb(machine,colors_offset+i,r,g,b);
	1353	palette_set_color_rgb(machine(),colors_offset+i,r,g,b);
1431	1354	}
1432	1355
1433	1356
r20824	r20825
1471	1394	}
1472	1395	}
1473	1396
1474		static void plot_star(galaxold_state *state, bitmap_ind16 &bitmap, int x, int y, int color, const rectangle &cliprect)
	1397	void galaxold_state::plot_star(bitmap_ind16 &bitmap, int x, int y, int color, const rectangle &cliprect)
1475	1398	{
1476		if (state->m_flipscreen_x)
	1399	if (m_flipscreen_x)
1477	1400	x = 255 - x;
1478	1401
1479		if (state->m_flipscreen_y)
	1402	if (m_flipscreen_y)
1480	1403	y = 255 - y;
1481	1404
1482	1405	if (cliprect.contains(x, y))
1483		bitmap.pix16(y, x) = state->m_stars_colors_start + color;
	1406	bitmap.pix16(y, x) = m_stars_colors_start + color;
1484	1407	}
1485	1408
1486		static void noop_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1409	void galaxold_state::noop_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect)
1487	1410	{
1488	1411	}
1489	1412
1490		void galaxold_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1413	void galaxold_state::galaxold_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect)
1491	1414	{
1492		galaxold_state *state = machine.driver_data<galaxold_state>();
1493		struct star *stars = state->m_stars;
	1415	struct star *stars = m_stars;
1494	1416	int offs;
1495	1417
1496	1418
1497		if (!state->m_timer_adjusted)
	1419	if (!m_timer_adjusted)
1498	1420	{
1499		start_stars_scroll_timer(machine);
1500		state->m_timer_adjusted = 1;
	1421	start_stars_scroll_timer();
	1422	m_timer_adjusted = 1;
1501	1423	}
1502	1424
1503	1425
r20824	r20825
1506	1428	int x,y;
1507	1429
1508	1430
1509		x = ((stars[offs].x +   state->m_stars_scrollpos) & 0x01ff) >> 1;
1510		y = ( stars[offs].y + ((state->m_stars_scrollpos + stars[offs].x) >> 9)) & 0xff;
	1431	x = ((stars[offs].x +   m_stars_scrollpos) & 0x01ff) >> 1;
	1432	y = ( stars[offs].y + ((m_stars_scrollpos + stars[offs].x) >> 9)) & 0xff;
1511	1433
1512	1434	if ((y & 0x01) ^ ((x >> 3) & 0x01))
1513	1435	{
1514		plot_star(state, bitmap, x, y, stars[offs].color, cliprect);
	1436	plot_star(bitmap, x, y, stars[offs].color, cliprect);
1515	1437	}
1516	1438	}
1517	1439	}
1518	1440
1519		static void scrambold_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1441	void galaxold_state::scrambold_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect)
1520	1442	{
1521		galaxold_state *state = machine.driver_data<galaxold_state>();
1522		struct star *stars = state->m_stars;
	1443	struct star *stars = m_stars;
1523	1444	int offs;
1524	1445
1525	1446
1526		if (!state->m_timer_adjusted)
	1447	if (!m_timer_adjusted)
1527	1448	{
1528		start_stars_blink_timer(machine, 100000, 10000, 0.00001);
1529		state->m_timer_adjusted = 1;
	1449	start_stars_blink_timer(100000, 10000, 0.00001);
	1450	m_timer_adjusted = 1;
1530	1451	}
1531	1452
1532	1453
r20824	r20825
1541	1462	if ((y & 0x01) ^ ((x >> 3) & 0x01))
1542	1463	{
1543	1464	/* determine when to skip plotting */
1544		switch (state->m_stars_blink_state & 0x03)
	1465	switch (m_stars_blink_state & 0x03)
1545	1466	{
1546	1467	case 0:
1547	1468	if (!(stars[offs].color & 0x01))  continue;
r20824	r20825
1557	1478	break;
1558	1479	}
1559	1480
1560		plot_star(state, bitmap, x, y, stars[offs].color, cliprect);
	1481	plot_star(bitmap, x, y, stars[offs].color, cliprect);
1561	1482	}
1562	1483	}
1563	1484	}
1564	1485
1565		static void rescue_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1486	void galaxold_state::rescue_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect)
1566	1487	{
1567		galaxold_state *state = machine.driver_data<galaxold_state>();
1568		struct star *stars = state->m_stars;
	1488	struct star *stars = m_stars;
1569	1489	int offs;
1570	1490
1571	1491
1572	1492	/* same as Scramble, but only top (left) half of screen */
1573	1493
1574		if (!state->m_timer_adjusted)
	1494	if (!m_timer_adjusted)
1575	1495	{
1576		start_stars_blink_timer(machine, 100000, 10000, 0.00001);
1577		state->m_timer_adjusted = 1;
	1496	start_stars_blink_timer(100000, 10000, 0.00001);
	1497	m_timer_adjusted = 1;
1578	1498	}
1579	1499
1580	1500
r20824	r20825
1589	1509	if ((x < 128) && ((y & 0x01) ^ ((x >> 3) & 0x01)))
1590	1510	{
1591	1511	/* determine when to skip plotting */
1592		switch (state->m_stars_blink_state & 0x03)
	1512	switch (m_stars_blink_state & 0x03)
1593	1513	{
1594	1514	case 0:
1595	1515	if (!(stars[offs].color & 0x01))  continue;
r20824	r20825
1605	1525	break;
1606	1526	}
1607	1527
1608		plot_star(state, bitmap, x, y, stars[offs].color, cliprect);
	1528	plot_star(bitmap, x, y, stars[offs].color, cliprect);
1609	1529	}
1610	1530	}
1611	1531	}
1612	1532
1613		static void mariner_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1533	void galaxold_state::mariner_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect)
1614	1534	{
1615		galaxold_state *state = machine.driver_data<galaxold_state>();
1616		struct star *stars = state->m_stars;
	1535	struct star *stars = m_stars;
1617	1536	int offs;
1618	1537	UINT8 *prom;
1619	1538
1620	1539
1621		if (!state->m_timer_adjusted)
	1540	if (!m_timer_adjusted)
1622	1541	{
1623		start_stars_scroll_timer(machine);
1624		state->m_timer_adjusted = 1;
	1542	start_stars_scroll_timer();
	1543	m_timer_adjusted = 1;
1625	1544	}
1626	1545
1627	1546
1628	1547	/* bit 2 of the PROM controls star visibility */
1629	1548
1630		prom = machine.root_device().memregion("user2")->base();
	1549	prom = machine().root_device().memregion("user2")->base();
1631	1550
1632	1551	for (offs = 0;offs < STAR_COUNT;offs++)
1633	1552	{
1634	1553	int x,y;
1635	1554
1636	1555
1637		x = ((stars[offs].x +   -state->m_stars_scrollpos) & 0x01ff) >> 1;
1638		y = ( stars[offs].y + ((-state->m_stars_scrollpos + stars[offs].x) >> 9)) & 0xff;
	1556	x = ((stars[offs].x +   -m_stars_scrollpos) & 0x01ff) >> 1;
	1557	y = ( stars[offs].y + ((-m_stars_scrollpos + stars[offs].x) >> 9)) & 0xff;
1639	1558
1640	1559	if ((y & 0x01) ^ ((x >> 3) & 0x01))
1641	1560	{
1642	1561	if (prom[(x/8 + 1) & 0x1f] & 0x04)
1643	1562	{
1644		plot_star(state, bitmap, x, y, stars[offs].color, cliprect);
	1563	plot_star(bitmap, x, y, stars[offs].color, cliprect);
1645	1564	}
1646	1565	}
1647	1566	}
r20824	r20825
1652	1571	m_stars_blink_state++;
1653	1572	}
1654	1573
1655		static void start_stars_blink_timer(running_machine &machine, double ra, double rb, double c)
	1574	void galaxold_state::start_stars_blink_timer(double ra, double rb, double c)
1656	1575	{
1657		galaxold_state *state = machine.driver_data<galaxold_state>();
1658	1576	/* calculate the period using the formula given in the 555 datasheet */
1659	1577
1660	1578	int period_in_ms = 693 * (ra + 2.0 * rb) * c;
1661	1579
1662		state->m_stars_blink_timer->adjust(attotime::from_msec(period_in_ms), 0, attotime::from_msec(period_in_ms));
	1580	m_stars_blink_timer->adjust(attotime::from_msec(period_in_ms), 0, attotime::from_msec(period_in_ms));
1663	1581	}
1664	1582
1665	1583
r20824	r20825
1671	1589	}
1672	1590	}
1673	1591
1674		static void start_stars_scroll_timer(running_machine &machine)
	1592	void galaxold_state::start_stars_scroll_timer()
1675	1593	{
1676		galaxold_state *state = machine.driver_data<galaxold_state>();
1677		state->m_stars_scroll_timer->adjust(machine.primary_screen->frame_period(), 0, machine.primary_screen->frame_period());
	1594	m_stars_scroll_timer->adjust(machine().primary_screen->frame_period(), 0, machine().primary_screen->frame_period());
1678	1595	}
1679	1596
1680	1597
r20824	r20825
1688	1605
1689	1606	if (m_modify_charcode)
1690	1607	{
1691		(*m_modify_charcode)(machine(), &code, x);
	1608	(this->*m_modify_charcode)(&code, x);
1692	1609	}
1693	1610
1694	1611	if (m_modify_color)
1695	1612	{
1696		(*m_modify_color)(&color);
	1613	(this->*m_modify_color)(&color);
1697	1614	}
1698	1615
1699	1616	SET_TILE_INFO_MEMBER(0, code, color, 0);
r20824	r20825
1705	1622	SET_TILE_INFO_MEMBER(2, code, 0, 0);
1706	1623	}
1707	1624
1708		static void draw_bullets_common(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1625	void galaxold_state::draw_bullets_common(bitmap_ind16 &bitmap, const rectangle &cliprect)
1709	1626	{
1710		galaxold_state *state = machine.driver_data<galaxold_state>();
1711	1627	int offs;
1712	1628
1713	1629
1714		for (offs = 0;offs < state->m_bulletsram.bytes();offs += 4)
	1630	for (offs = 0;offs < m_bulletsram.bytes();offs += 4)
1715	1631	{
1716	1632	UINT8 sx,sy;
1717	1633
1718		sy = 255 - state->m_bulletsram[offs + 1];
1719		sx = 255 - state->m_bulletsram[offs + 3];
	1634	sy = 255 - m_bulletsram[offs + 1];
	1635	sx = 255 - m_bulletsram[offs + 3];
1720	1636
1721		if (state->m_flipscreen_y)  sy = 255 - sy;
	1637	if (m_flipscreen_y)  sy = 255 - sy;
1722	1638
1723		(*state->m_draw_bullets)(machine, bitmap, cliprect, offs, sx, sy);
	1639	(this->*m_draw_bullets)(bitmap, cliprect, offs, sx, sy);
1724	1640	}
1725	1641	}
1726	1642
1727	1643
1728		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, UINT8 *spriteram, size_t spriteram_size)
	1644	void galaxold_state::draw_sprites(bitmap_ind16 &bitmap, UINT8 *spriteram, size_t spriteram_size)
1729	1645	{
1730	1646	const rectangle spritevisiblearea(2*8+1, 32*8-1, 2*8,   30*8-1);
1731	1647	const rectangle spritevisibleareaflipx(0*8, 30*8-2, 2*8, 30*8-1);
1732	1648
1733		galaxold_state *state = machine.driver_data<galaxold_state>();
1734	1649	int offs;
1735	1650
1736	1651
r20824	r20825
1745	1660	flipx = spriteram[offs + 1] & 0x40;
1746	1661	flipy = spriteram[offs + 1] & 0x80;
1747	1662	code = spriteram[offs + 1] & 0x3f;
1748		color = spriteram[offs + 2] & state->m_color_mask;
	1663	color = spriteram[offs + 2] & m_color_mask;
1749	1664
1750		if (state->m_modify_spritecode)
	1665	if (m_modify_spritecode)
1751	1666	{
1752		(*state->m_modify_spritecode)(machine, spriteram, &code, &flipx, &flipy, offs);
	1667	(this->*m_modify_spritecode)(spriteram, &code, &flipx, &flipy, offs);
1753	1668	}
1754	1669
1755		if (state->m_modify_color)
	1670	if (m_modify_color)
1756	1671	{
1757		(*state->m_modify_color)(&color);
	1672	(this->*m_modify_color)(&color);
1758	1673	}
1759	1674
1760		if (state->m_modify_ypos)
	1675	if (m_modify_ypos)
1761	1676	{
1762		(*state->m_modify_ypos)(&sy);
	1677	(this->*m_modify_ypos)(&sy);
1763	1678	}
1764	1679
1765		if (state->m_flipscreen_x)
	1680	if (m_flipscreen_x)
1766	1681	{
1767	1682	sx = 240 - sx;
1768	1683	flipx = !flipx;
1769	1684	}
1770	1685
1771		if (state->m_flipscreen_y)
	1686	if (m_flipscreen_y)
1772	1687	{
1773	1688	flipy = !flipy;
1774	1689	}
r20824	r20825
1786	1701	if (offs < 3*4)  sy++;
1787	1702
1788	1703
1789		drawgfx_transpen(bitmap, state->m_flipscreen_x ? spritevisibleareaflipx : spritevisiblearea, machine.gfx[1],
	1704	drawgfx_transpen(bitmap, m_flipscreen_x ? spritevisibleareaflipx : spritevisiblearea, machine().gfx[1],
1790	1705	code,color,
1791	1706	flipx,flipy,
1792	1707	sx,sy,0);
r20824	r20825
1796	1711
1797	1712	UINT32 galaxold_state::screen_update_galaxold(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
1798	1713	{
1799		(*m_draw_background)(machine(), bitmap, cliprect);
	1714	(this->*m_draw_background)(bitmap, cliprect);
1800	1715
1801	1716	if (m_stars_on)
1802	1717	{
1803		(*m_draw_stars)(machine(), bitmap, cliprect);
	1718	(this->*m_draw_stars)(bitmap, cliprect);
1804	1719	}
1805	1720
1806	1721
r20824	r20825
1808	1723
1809	1724	if (m_draw_bullets)
1810	1725	{
1811		draw_bullets_common(machine(), bitmap, cliprect);
	1726	draw_bullets_common(bitmap, cliprect);
1812	1727	}
1813	1728
1814	1729
1815		draw_sprites(machine(), bitmap, m_spriteram, m_spriteram.bytes());
	1730	draw_sprites(bitmap, m_spriteram, m_spriteram.bytes());
1816	1731
1817	1732	if (m_spriteram2_present)
1818	1733	{
1819		draw_sprites(machine(), bitmap, m_spriteram2, m_spriteram2.bytes());
	1734	draw_sprites(bitmap, m_spriteram2, m_spriteram2.bytes());
1820	1735	}
1821	1736	return 0;
1822	1737	}
r20824	r20825
1827	1742	int i, j;
1828	1743	UINT8 color;
1829	1744
1830		(*m_draw_background)(machine(), bitmap, cliprect);
	1745	(this->*m_draw_background)(bitmap, cliprect);
1831	1746
1832	1747	if (m_stars_on)
1833	1748	{
1834		(*m_draw_stars)(machine(), bitmap, cliprect);
	1749	(this->*m_draw_stars)(bitmap, cliprect);
1835	1750	}
1836	1751
1837	1752	/* save the background for drawing it again later, if background has priority over characters */
r20824	r20825
1841	1756
1842	1757	if (m_draw_bullets)
1843	1758	{
1844		draw_bullets_common(machine(), bitmap, cliprect);
	1759	draw_bullets_common(bitmap, cliprect);
1845	1760	}
1846	1761
1847		draw_sprites(machine(), bitmap, m_spriteram, m_spriteram.bytes());
	1762	draw_sprites(bitmap, m_spriteram, m_spriteram.bytes());
1848	1763
1849	1764	if (m_dambustr_bg_priority)
1850	1765	{
1851	1766	/* draw the upper part of the background, as it has priority */
1852		dambustr_draw_upper_background(machine(), bitmap, cliprect);
	1767	dambustr_draw_upper_background(bitmap, cliprect);
1853	1768
1854	1769	/* only rows with color code > 3 are stronger than the background */
1855	1770	memset(m_dambustr_videoram2, 0x20, 0x0400);
r20824	r20825
1867	1782	return 0;
1868	1783	}
1869	1784
1870		static void bagmanmc_modify_charcode(running_machine &machine, UINT16 *code, UINT8 x)
	1785	void galaxold_state::bagmanmc_modify_charcode(UINT16 *code, UINT8 x)
1871	1786	{
1872		galaxold_state *state = machine.driver_data<galaxold_state>();
1873		*code |= (state->m_gfxbank[0] << 9);
	1787	*code |= (m_gfxbank[0] << 9);
1874	1788	}
1875	1789
1876		static void bagmanmc_modify_spritecode(running_machine &machine, UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
	1790	void galaxold_state::bagmanmc_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs)
1877	1791	{
1878		galaxold_state *state = machine.driver_data<galaxold_state>();
1879		*code |= (state->m_gfxbank[0] << 7) | 0x40;
	1792	*code |= (m_gfxbank[0] << 7) | 0x40;
1880	1793	}
1881	1794
1882	1795	VIDEO_START_MEMBER(galaxold_state,bagmanmc)
1883	1796	{
1884	1797	VIDEO_START_CALL_MEMBER(galaxold);
1885	1798
1886		m_modify_charcode = bagmanmc_modify_charcode;
1887		m_modify_spritecode = bagmanmc_modify_spritecode;
	1799	m_modify_charcode = &galaxold_state::bagmanmc_modify_charcode;
	1800	m_modify_spritecode = &galaxold_state::bagmanmc_modify_spritecode;
1888	1801	}

trunk/src/mame/video/gaiden.c

r20824	r20825
272	272	to blend into the final 32-bit rgb bitmaps, this is currently broken (due to zsolt's core
273	273	changes?) it appears that the sprite drawing is no longer putting the correct raw data
274	274	in the bitmaps? */
275		static void blendbitmaps(running_machine &machine,
276		bitmap_rgb32 &dest,bitmap_ind16 &src1,bitmap_ind16 &src2,bitmap_ind16 &src3,
	275	void gaiden_state::blendbitmaps(bitmap_rgb32 &dest,bitmap_ind16 &src1,bitmap_ind16 &src2,bitmap_ind16 &src3,
277	276	int sx,int sy,const rectangle &cliprect)
278	277	{
279	278	int y,x;
280		const pen_t *paldata = machine.pens;
	279	const pen_t *paldata = machine().pens;
281	280
282	281	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
283	282	{
r20824	r20825
330	329	*         |---------x------- | x position (high bit)
331	330	*/
332	331
333		static void drgnbowl_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	332	void gaiden_state::drgnbowl_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
334	333	{
335		gaiden_state *state = machine.driver_data<gaiden_state>();
336		UINT16 *spriteram = state->m_spriteram;
	334	UINT16 *spriteram = m_spriteram;
337	335	int i, code, color, x, y, flipx, flipy, priority_mask;
338	336
339	337	for( i = 0; i < 0x800/2; i += 4 )
r20824	r20825
355	353	else
356	354	priority_mask = 0;
357	355
358		pdrawgfx_transpen_raw(bitmap,cliprect,machine.gfx[3],
	356	pdrawgfx_transpen_raw(bitmap,cliprect,machine().gfx[3],
359	357	code,
360		machine.gfx[3]->colorbase() + color * machine.gfx[3]->granularity(),
	358	machine().gfx[3]->colorbase() + color * machine().gfx[3]->granularity(),
361	359	flipx,flipy,x,y,
362		machine.priority_bitmap, priority_mask,15);
	360	machine().priority_bitmap, priority_mask,15);
363	361
364	362	/* wrap x*/
365		pdrawgfx_transpen_raw(bitmap,cliprect,machine.gfx[3],
	363	pdrawgfx_transpen_raw(bitmap,cliprect,machine().gfx[3],
366	364	code,
367		machine.gfx[3]->colorbase() + color * machine.gfx[3]->granularity(),
	365	machine().gfx[3]->colorbase() + color * machine().gfx[3]->granularity(),
368	366	flipx,flipy,x-512,y,
369		machine.priority_bitmap, priority_mask,15);
	367	machine().priority_bitmap, priority_mask,15);
370	368
371	369	}
372	370	}
r20824	r20825
391	389	gaiden_draw_sprites(machine(), m_tile_bitmap_bg, m_tile_bitmap_fg, m_sprite_bitmap, cliprect, m_spriteram, m_sprite_sizey, m_spr_offset_y, flip_screen());
392	390
393	391	/* mix & blend the tilemaps and sprites into a 32-bit bitmap */
394		blendbitmaps(machine(), bitmap, m_tile_bitmap_bg, m_tile_bitmap_fg, m_sprite_bitmap, 0, 0, cliprect);
	392	blendbitmaps(bitmap, m_tile_bitmap_bg, m_tile_bitmap_fg, m_sprite_bitmap, 0, 0, cliprect);
395	393	return 0;
396	394
397	395	}
r20824	r20825
416	414	raiga_draw_sprites(machine(), m_tile_bitmap_bg, m_tile_bitmap_fg, m_sprite_bitmap, cliprect, m_spriteram, m_sprite_sizey, m_spr_offset_y, flip_screen());
417	415
418	416	/* mix & blend the tilemaps and sprites into a 32-bit bitmap */
419		blendbitmaps(machine(), bitmap, m_tile_bitmap_bg, m_tile_bitmap_fg, m_sprite_bitmap, 0, 0, cliprect);
	417	blendbitmaps(bitmap, m_tile_bitmap_bg, m_tile_bitmap_fg, m_sprite_bitmap, 0, 0, cliprect);
420	418	return 0;
421	419	}
422	420
r20824	r20825
427	425	m_background->draw(bitmap, cliprect, 0, 1);
428	426	m_foreground->draw(bitmap, cliprect, 0, 2);
429	427	m_text_layer->draw(bitmap, cliprect, 0, 4);
430		drgnbowl_draw_sprites(machine(), bitmap, cliprect);
	428	drgnbowl_draw_sprites(bitmap, cliprect);
431	429	return 0;
432	430	}

trunk/src/mame/video/gunsmoke.c

r20824	r20825
133	133	colortable_configure_tilemap_groups(machine().colortable, m_fg_tilemap, machine().gfx[0], 0x4f);
134	134	}
135	135
136		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	136	void gunsmoke_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
137	137	{
138		gunsmoke_state *state = machine.driver_data<gunsmoke_state>();
139		UINT8 *spriteram = state->m_spriteram;
	138	UINT8 *spriteram = m_spriteram;
140	139	int offs;
141	140
142		for (offs = state->m_spriteram.bytes() - 32; offs >= 0; offs -= 32)
	141	for (offs = m_spriteram.bytes() - 32; offs >= 0; offs -= 32)
143	142	{
144	143	int attr = spriteram[offs + 1];
145	144	int bank = (attr & 0xc0) >> 6;
r20824	r20825
151	150	int sy = spriteram[offs + 2];
152	151
153	152	if (bank == 3)
154		bank += state->m_sprite3bank;
	153	bank += m_sprite3bank;
155	154
156	155	code += 256 * bank;
157	156
158		if (state->flip_screen())
	157	if (flip_screen())
159	158	{
160	159	sx = 240 - sx;
161	160	sy = 240 - sy;
r20824	r20825
163	162	flipy = !flipy;
164	163	}
165	164
166		drawgfx_transpen(bitmap, cliprect, machine.gfx[2], code, color, flipx, flipy, sx, sy, 0);
	165	drawgfx_transpen(bitmap, cliprect, machine().gfx[2], code, color, flipx, flipy, sx, sy, 0);
167	166	}
168	167	}
169	168
r20824	r20825
178	177	bitmap.fill(get_black_pen(machine()), cliprect);
179	178
180	179	if (m_objon)
181		draw_sprites(machine(), bitmap, cliprect);
	180	draw_sprites(bitmap, cliprect);
182	181
183	182	if (m_chon)
184	183	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);

trunk/src/mame/video/gcpinbal.c

r20824	r20825
40	40	0);
41	41	}
42	42
43		static void gcpinbal_core_vh_start( running_machine &machine )
	43	void gcpinbal_state::gcpinbal_core_vh_start(  )
44	44	{
45		gcpinbal_state *state = machine.driver_data<gcpinbal_state>();
46	45	int xoffs = 0;
47	46	int yoffs = 0;
48	47
49		state->m_tilemap[0] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gcpinbal_state::get_bg0_tile_info),state),TILEMAP_SCAN_ROWS,16,16,32,32);
50		state->m_tilemap[1] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gcpinbal_state::get_bg1_tile_info),state),TILEMAP_SCAN_ROWS,16,16,32,32);
51		state->m_tilemap[2] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(gcpinbal_state::get_fg_tile_info),state), TILEMAP_SCAN_ROWS,8,8,64,64);
	48	m_tilemap[0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gcpinbal_state::get_bg0_tile_info),this),TILEMAP_SCAN_ROWS,16,16,32,32);
	49	m_tilemap[1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gcpinbal_state::get_bg1_tile_info),this),TILEMAP_SCAN_ROWS,16,16,32,32);
	50	m_tilemap[2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gcpinbal_state::get_fg_tile_info),this), TILEMAP_SCAN_ROWS,8,8,64,64);
52	51
53		state->m_tilemap[0]->set_transparent_pen(0);
54		state->m_tilemap[1]->set_transparent_pen(0);
55		state->m_tilemap[2]->set_transparent_pen(0);
	52	m_tilemap[0]->set_transparent_pen(0);
	53	m_tilemap[1]->set_transparent_pen(0);
	54	m_tilemap[2]->set_transparent_pen(0);
56	55
57	56	/* flipscreen n/a */
58		state->m_tilemap[0]->set_scrolldx(-xoffs, 0);
59		state->m_tilemap[1]->set_scrolldx(-xoffs, 0);
60		state->m_tilemap[2]->set_scrolldx(-xoffs, 0);
61		state->m_tilemap[0]->set_scrolldy(-yoffs, 0);
62		state->m_tilemap[1]->set_scrolldy(-yoffs, 0);
63		state->m_tilemap[2]->set_scrolldy(-yoffs, 0);
	57	m_tilemap[0]->set_scrolldx(-xoffs, 0);
	58	m_tilemap[1]->set_scrolldx(-xoffs, 0);
	59	m_tilemap[2]->set_scrolldx(-xoffs, 0);
	60	m_tilemap[0]->set_scrolldy(-yoffs, 0);
	61	m_tilemap[1]->set_scrolldy(-yoffs, 0);
	62	m_tilemap[2]->set_scrolldy(-yoffs, 0);
64	63	}
65	64
66	65	void gcpinbal_state::video_start()
67	66	{
68		gcpinbal_core_vh_start(machine());
	67	gcpinbal_core_vh_start();
69	68	}
70	69
71	70
r20824	r20825
164	163
165	164	****************************************************************/
166	165
167		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
	166	void gcpinbal_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs )
168	167	{
169		gcpinbal_state *state = machine.driver_data<gcpinbal_state>();
170		UINT16 *spriteram = state->m_spriteram;
	168	UINT16 *spriteram = m_spriteram;
171	169	int offs, chain_pos;
172	170	int x, y, curx, cury;
173	171	int priority = 0;
r20824	r20825
175	173	UINT16 code;
176	174
177	175	/* According to Raine, word in ioc_ram determines sprite/tile priority... */
178		priority = (state->m_ioc_ram[0x68 / 2] & 0x8800) ? 0 : 1;
	176	priority = (m_ioc_ram[0x68 / 2] & 0x8800) ? 0 : 1;
179	177
180		for (offs = state->m_spriteram.bytes() / 2 - 8; offs >= 0; offs -= 8)
	178	for (offs = m_spriteram.bytes() / 2 - 8; offs >= 0; offs -= 8)
181	179	{
182	180	code = ((spriteram[offs + 5]) & 0xff) + (((spriteram[offs + 6]) & 0xff) << 8);
183	181	code &= 0x3fff;
r20824	r20825
204	202
205	203	for (chain_pos = chain; chain_pos >= 0; chain_pos--)
206	204	{
207		pdrawgfx_transpen(bitmap, cliprect,machine.gfx[0],
	205	pdrawgfx_transpen(bitmap, cliprect,machine().gfx[0],
208	206	code,
209	207	col,
210	208	flipx, flipy,
211	209	curx,cury,
212		machine.priority_bitmap,
	210	machine().priority_bitmap,
213	211	priority ? 0xfc : 0xf0,0);
214	212
215	213	code++;
r20824	r20825
310	308	m_tilemap[layer[2]]->draw(bitmap, cliprect, 0, 4);
311	309
312	310
313		draw_sprites(machine(), bitmap, cliprect, 16);
	311	draw_sprites(bitmap, cliprect, 16);
314	312
315	313	#if 0
316	314	{

trunk/src/mame/video/ginganin.c

r20824	r20825
203	203
204	204	------------------------------------------------------------------------ */
205	205
206		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect )
	206	void ginganin_state::draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect )
207	207	{
208		ginganin_state *state = machine.driver_data<ginganin_state>();
209		UINT16 *spriteram = state->m_spriteram;
	208	UINT16 *spriteram = m_spriteram;
210	209	int offs;
211	210
212		for (offs = 0; offs < (state->m_spriteram.bytes() >> 1); offs += 4)
	211	for (offs = 0; offs < (m_spriteram.bytes() >> 1); offs += 4)
213	212	{
214	213	int y = spriteram[offs + 0];
215	214	int x = spriteram[offs + 1];
r20824	r20825
221	220	x = (x & 0xff) - (x & 0x100);
222	221	y = (y & 0xff) - (y & 0x100);
223	222
224		if (state->m_flipscreen)
	223	if (m_flipscreen)
225	224	{
226	225	x = 240 - x;
227	226	y = 240 - y;
r20824	r20825
229	228	flipy = !flipy;
230	229	}
231	230
232		drawgfx_transpen(bitmap,cliprect,machine.gfx[3],
	231	drawgfx_transpen(bitmap,cliprect,machine().gfx[3],
233	232	code & 0x3fff,
234	233	attr >> 12,
235	234	flipx, flipy,
r20824	r20825
279	278	if (layers_ctrl1 & 2)
280	279	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
281	280	if (layers_ctrl1 & 8)
282		draw_sprites(machine(), bitmap, cliprect);
	281	draw_sprites(bitmap, cliprect);
283	282	if (layers_ctrl1 & 4)
284	283	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);
285	284

trunk/src/mame/video/gaelco.c

r20824	r20825
116	116	3  | xxxxxxxx xxxxxx-- | sprite code
117	117	*/
118	118
119		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	119	void gaelco_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
120	120	{
121		gaelco_state *state = machine.driver_data<gaelco_state>();
122	121	int i, x, y, ex, ey;
123		gfx_element *gfx = machine.gfx[0];
	122	gfx_element *gfx = machine().gfx[0];
124	123
125	124	static const int x_offset[2] = {0x0,0x2};
126	125	static const int y_offset[2] = {0x0,0x1};
127	126
128	127	for (i = 0x800 - 4 - 1; i >= 3; i -= 4)
129	128	{
130		int sx = state->m_spriteram[i + 2] & 0x01ff;
131		int sy = (240 - (state->m_spriteram[i] & 0x00ff)) & 0x00ff;
132		int number = state->m_spriteram[i + 3];
133		int color = (state->m_spriteram[i + 2] & 0x7e00) >> 9;
134		int attr = (state->m_spriteram[i] & 0xfe00) >> 9;
135		int priority = (state->m_spriteram[i] & 0x3000) >> 12;
	129	int sx = m_spriteram[i + 2] & 0x01ff;
	130	int sy = (240 - (m_spriteram[i] & 0x00ff)) & 0x00ff;
	131	int number = m_spriteram[i + 3];
	132	int color = (m_spriteram[i + 2] & 0x7e00) >> 9;
	133	int attr = (m_spriteram[i] & 0xfe00) >> 9;
	134	int priority = (m_spriteram[i] & 0x3000) >> 12;
136	135
137	136	int xflip = attr & 0x20;
138	137	int yflip = attr & 0x40;
r20824	r20825
170	169	pdrawgfx_transpen(bitmap,cliprect,gfx,number + x_offset[ex] + y_offset[ey],
171	170	color,xflip,yflip,
172	171	sx-0x0f+x*8,sy+y*8,
173		machine.priority_bitmap,pri_mask,0);
	172	machine().priority_bitmap,pri_mask,0);
174	173	}
175	174	}
176	175	}
r20824	r20825
205	204	m_tilemap[1]->draw(bitmap, cliprect, 0, 4);
206	205	m_tilemap[0]->draw(bitmap, cliprect, 0, 4);
207	206
208		draw_sprites(machine(), bitmap, cliprect);
	207	draw_sprites(bitmap, cliprect);
209	208	return 0;
210	209	}
211	210
r20824	r20825
244	243	m_tilemap[1]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0, 8);
245	244	m_tilemap[0]->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0, 8);
246	245
247		draw_sprites(machine(), bitmap, cliprect);
	246	draw_sprites(bitmap, cliprect);
248	247	return 0;
249	248	}

trunk/src/mame/video/gunbustr.c

r20824	r20825
55	55
56	56	********************************************************/
57	57
58		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs)
	58	void gunbustr_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs)
59	59	{
60		gunbustr_state *state = machine.driver_data<gunbustr_state>();
61		UINT32 *spriteram32 = state->m_spriteram;
62		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
	60	UINT32 *spriteram32 = m_spriteram;
	61	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
63	62	int offs, data, tilenum, color, flipx, flipy;
64	63	int x, y, priority, dblsize, curx, cury;
65	64	int sprites_flipscreen = 0;
r20824	r20825
69	68
70	69	/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
71	70	while processing sprite ram and then draw them all at the end */
72		struct tempsprite *sprite_ptr = state->m_spritelist;
	71	struct tempsprite *sprite_ptr = m_spritelist;
73	72
74		for (offs = (state->m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
	73	for (offs = (m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
75	74	{
76	75	data = spriteram32[offs+0];
77	76	flipx =    (data & 0x00800000) >> 23;
r20824	r20825
166	165	}
167	166	else
168	167	{
169		drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	168	drawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
170	169	sprite_ptr->code,
171	170	sprite_ptr->color,
172	171	sprite_ptr->flipx,sprite_ptr->flipy,
r20824	r20825
181	180	}
182	181
183	182	/* this happens only if primsks != NULL */
184		while (sprite_ptr != state->m_spritelist)
	183	while (sprite_ptr != m_spritelist)
185	184	{
186	185	sprite_ptr--;
187	186
188		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_ptr->gfx],
	187	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[sprite_ptr->gfx],
189	188	sprite_ptr->code,
190	189	sprite_ptr->color,
191	190	sprite_ptr->flipx,sprite_ptr->flipy,
192	191	sprite_ptr->x,sprite_ptr->y,
193	192	sprite_ptr->zoomx,sprite_ptr->zoomy,
194		machine.priority_bitmap,sprite_ptr->primask,0);
	193	machine().priority_bitmap,sprite_ptr->primask,0);
195	194	}
196	195	}
197	196
r20824	r20825
235	234	tc0480scp_tilemap_draw(tc0480scp, bitmap, cliprect, layer[2], 0, 2);
236	235	tc0480scp_tilemap_draw(tc0480scp, bitmap, cliprect, layer[3], 0, 4);
237	236	tc0480scp_tilemap_draw(tc0480scp, bitmap, cliprect, layer[4], 0, 8);    /* text layer */
238		draw_sprites(machine(), bitmap, cliprect, primasks, 48, -116);
	237	draw_sprites(bitmap, cliprect, primasks, 48, -116);
239	238	#endif
240	239	return 0;
241	240	}

trunk/src/mame/video/galivan.c

r20824	r20825
294	294
295	295	***************************************************************************/
296	296
297		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	297	void galivan_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
298	298	{
299		galivan_state *state = machine.driver_data<galivan_state>();
300		const UINT8 *spritepalettebank = state->memregion("user1")->base();
301		UINT8 *spriteram = state->m_spriteram;
	299	const UINT8 *spritepalettebank = memregion("user1")->base();
	300	UINT8 *spriteram = m_spriteram;
302	301	int offs;
303	302
304	303	/* draw the sprites */
305		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	304	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
306	305	{
307	306	int code;
308	307	int attr = spriteram[offs + 2];
r20824	r20825
313	312
314	313	sx = (spriteram[offs + 3] - 0x80) + 256 * (attr & 0x01);
315	314	sy = 240 - spriteram[offs];
316		if (state->m_flipscreen)
	315	if (m_flipscreen)
317	316	{
318	317	sx = 240 - sx;
319	318	sy = 240 - sy;
r20824	r20825
324	323	//      code = spriteram[offs + 1] + ((attr & 0x02) << 7);
325	324	code = spriteram[offs + 1] + ((attr & 0x06) << 7);  // for ninjemak, not sure ?
326	325
327		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	326	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
328	327	code,
329	328	color + 16 * (spritepalettebank[code >> 2] & 0x0f),
330	329	flipx,flipy,
r20824	r20825
347	346	{
348	347	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);
349	348	m_tx_tilemap->draw(bitmap, cliprect, 1, 0);
350		draw_sprites(machine(), bitmap, cliprect);
	349	draw_sprites(bitmap, cliprect);
351	350	}
352	351	else
353	352	{
354		draw_sprites(machine(), bitmap, cliprect);
	353	draw_sprites(bitmap, cliprect);
355	354	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);
356	355	m_tx_tilemap->draw(bitmap, cliprect, 1, 0);
357	356	}
r20824	r20825
370	369	else
371	370	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
372	371
373		draw_sprites(machine(), bitmap, cliprect);
	372	draw_sprites(bitmap, cliprect);
374	373	m_tx_tilemap->draw(bitmap, cliprect, 0, 0);
375	374	return 0;
376	375	}

trunk/src/mame/video/gottlieb.c

r20824	r20825
198	198	*
199	199	*************************************/
200	200
201		static void draw_sprites(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	201	void gottlieb_state::draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect)
202	202	{
203		gottlieb_state *state = machine.driver_data<gottlieb_state>();
204		UINT8 *spriteram = state->m_spriteram;
	203	UINT8 *spriteram = m_spriteram;
205	204	rectangle clip = cliprect;
206	205	int offs;
207	206
r20824	r20825
215	214	/* of level animation. */
216	215	int sx = (spriteram[offs + 1]) - 4;
217	216	int sy = (spriteram[offs]) - 13;
218		int code = (255 ^ spriteram[offs + 2]) + 256 * state->m_spritebank;
	217	int code = (255 ^ spriteram[offs + 2]) + 256 * m_spritebank;
219	218
220		if (state->flip_screen_x()) sx = 233 - sx;
221		if (state->flip_screen_y()) sy = 244 - sy;
	219	if (flip_screen_x()) sx = 233 - sx;
	220	if (flip_screen_y()) sy = 244 - sy;
222	221
223	222	drawgfx_transpen(bitmap, clip,
224		machine.gfx[2],
	223	machine().gfx[2],
225	224	code, 0,
226		state->flip_screen_x(), state->flip_screen_y(),
	225	flip_screen_x(), flip_screen_y(),
227	226	sx,sy, 0);
228	227	}
229	228	}
r20824	r20825
245	244	bitmap.fill(machine().pens[0], cliprect);
246	245
247	246	/* draw the sprites */
248		draw_sprites(machine(), bitmap, cliprect);
	247	draw_sprites(bitmap, cliprect);
249	248
250	249	/* if the background has higher priority, render it now */
251	250	if (m_background_priority)

trunk/src/mame/video/glass.c

r20824	r20825
159	159	3  | xxxxxxxx xxxxxxxx | sprite code
160	160	*/
161	161
162		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	162	void glass_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
163	163	{
164		glass_state *state = machine.driver_data<glass_state>();
165	164	int i;
166		gfx_element *gfx = machine.gfx[0];
	165	gfx_element *gfx = machine().gfx[0];
167	166
168	167	for (i = 3; i < (0x1000 - 6) / 2; i += 4)
169	168	{
170		int sx = state->m_spriteram[i + 2] & 0x01ff;
171		int sy = (240 - (state->m_spriteram[i] & 0x00ff)) & 0x00ff;
172		int number = state->m_spriteram[i + 3];
173		int color = (state->m_spriteram[i + 2] & 0x1e00) >> 9;
174		int attr = (state->m_spriteram[i] & 0xfe00) >> 9;
	169	int sx = m_spriteram[i + 2] & 0x01ff;
	170	int sy = (240 - (m_spriteram[i] & 0x00ff)) & 0x00ff;
	171	int number = m_spriteram[i + 3];
	172	int color = (m_spriteram[i + 2] & 0x1e00) >> 9;
	173	int attr = (m_spriteram[i] & 0xfe00) >> 9;
175	174
176	175	int xflip = attr & 0x20;
177	176	int yflip = attr & 0x40;
r20824	r20825
203	202	copybitmap(bitmap, *m_screen_bitmap, 0, 0, 0x18, 0x24, cliprect);
204	203	m_pant[1]->draw(bitmap, cliprect, 0, 0);
205	204	m_pant[0]->draw(bitmap, cliprect, 0, 0);
206		draw_sprites(machine(), bitmap, cliprect);
	205	draw_sprites(bitmap, cliprect);
207	206	return 0;
208	207	}

trunk/src/mame/video/gladiatr.c

r20824	r20825
189	189
190	190	***************************************************************************/
191	191
192		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	192	void gladiatr_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
193	193	{
194		gladiatr_state *state = machine.driver_data<gladiatr_state>();
195	194	int offs;
196	195
197	196	for (offs = 0;offs < 0x80;offs += 2)
r20824	r20825
201	200	{0x0,0x1},
202	201	{0x2,0x3},
203	202	};
204		UINT8 *src = &state->m_spriteram[offs + (state->m_sprite_buffer << 7)];
	203	UINT8 *src = &m_spriteram[offs + (m_sprite_buffer << 7)];
205	204	int attributes = src[0x800];
206	205	int size = (attributes & 0x10) >> 4;
207		int bank = (attributes & 0x01) + ((attributes & 0x02) ? state->m_sprite_bank : 0);
	206	int bank = (attributes & 0x01) + ((attributes & 0x02) ? m_sprite_bank : 0);
208	207	int tile_number = (src[0]+256*bank);
209	208	int sx = src[0x400+1] + 256*(src[0x801]&1) - 0x38;
210	209	int sy = 240 - src[0x400] - (size ? 16 : 0);
r20824	r20825
213	212	int color = src[1] & 0x1f;
214	213	int x,y;
215	214
216		if (state->flip_screen())
	215	if (flip_screen())
217	216	{
218	217	xflip = !xflip;
219	218	yflip = !yflip;
r20824	r20825
228	227
229	228	int t = tile_offset[ey][ex] + tile_number;
230	229
231		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	230	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
232	231	t,
233	232	color,
234	233	xflip, yflip,
r20824	r20825
243	242	UINT32 gladiatr_state::screen_update_ppking(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
244	243	{
245	244	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
246		draw_sprites(machine(), bitmap,cliprect);
	245	draw_sprites(bitmap,cliprect);
247	246
248	247	/* the fg layer just selects the upper palette bank on underlying pixels */
249	248	{
r20824	r20825
290	289	m_fg_tilemap->set_scrolly(0, m_fg_scrolly);
291	290
292	291	m_bg_tilemap->draw(bitmap, cliprect, 0,0);
293		draw_sprites(machine(), bitmap,cliprect);
	292	draw_sprites(bitmap,cliprect);
294	293	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
295	294	}
296	295	else

trunk/src/mame/video/groundfx.c

r20824	r20825
59	59
60	60	***************************************************************/
61	61
62		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,int do_hack,int x_offs,int y_offs)
	62	void groundfx_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,int do_hack,int x_offs,int y_offs)
63	63	{
64		groundfx_state *state = machine.driver_data<groundfx_state>();
65		UINT32 *spriteram32 = state->m_spriteram;
66		UINT16 *spritemap = (UINT16 *)state->memregion("user1")->base();
	64	UINT32 *spriteram32 = m_spriteram;
	65	UINT16 *spritemap = (UINT16 *)memregion("user1")->base();
67	66	int offs, data, tilenum, color, flipx, flipy;
68	67	int x, y, priority, dblsize, curx, cury;
69	68	int sprites_flipscreen = 0;
r20824	r20825
74	73
75	74	/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
76	75	while processing sprite ram and then draw them all at the end */
77		struct tempsprite *sprite_ptr = state->m_spritelist;
	76	struct tempsprite *sprite_ptr = m_spritelist;
78	77
79		for (offs = (state->m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
	78	for (offs = (m_spriteram.bytes()/4-4);offs >= 0;offs -= 4)
80	79	{
81	80	data = spriteram32[offs+0];
82	81	flipx =    (data & 0x00800000) >> 23;
r20824	r20825
170	169	}
171	170
172	171	/* this happens only if primsks != NULL */
173		while (sprite_ptr != state->m_spritelist)
	172	while (sprite_ptr != m_spritelist)
174	173	{
175	174	const rectangle *clipper;
176	175
177	176	sprite_ptr--;
178	177
179	178	if (do_hack && sprite_ptr->pri==1 && sprite_ptr->y<100)
180		clipper=&state->m_hack_cliprect;
	179	clipper=&m_hack_cliprect;
181	180	else
182	181	clipper=&cliprect;
183	182
184		pdrawgfxzoom_transpen(bitmap,*clipper,machine.gfx[sprite_ptr->gfx],
	183	pdrawgfxzoom_transpen(bitmap,*clipper,machine().gfx[sprite_ptr->gfx],
185	184	sprite_ptr->code,
186	185	sprite_ptr->color,
187	186	sprite_ptr->flipx,sprite_ptr->flipy,
188	187	sprite_ptr->x,sprite_ptr->y,
189	188	sprite_ptr->zoomx,sprite_ptr->zoomy,
190		machine.priority_bitmap,primasks[sprite_ptr->pri],0);
	189	machine().priority_bitmap,primasks[sprite_ptr->pri],0);
191	190	}
192	191	}
193	192
r20824	r20825
252	251
253	252	if (tc0480scp_long_r(tc0480scp, space, 0x20 / 4, 0xffffffff) != 0x240866) /* Stupid hack for start of race */
254	253	tc0480scp_tilemap_draw(tc0480scp, bitmap, m_hack_cliprect, layer[0], 0, 0);
255		draw_sprites(machine(), bitmap, cliprect, 1, 44, -574);
	254	draw_sprites(bitmap, cliprect, 1, 44, -574);
256	255	}
257	256	else
258	257	{
r20824	r20825
263	262
264	263	tc0100scn_tilemap_draw(tc0100scn, bitmap, cliprect, pivlayer[2], 0, 0);
265	264
266		draw_sprites(machine(), bitmap, cliprect, 0, 44, -574);
	265	draw_sprites(bitmap, cliprect, 0, 44, -574);
267	266	}
268	267
269	268	tc0480scp_tilemap_draw(tc0480scp, bitmap, cliprect, layer[4], 0, 0);    /* TC0480SCP text layer */

trunk/src/mame/video/goal92.c

r20824	r20825
84	84	SET_TILE_INFO_MEMBER(region, tile, color, 0);
85	85	}
86	86
87		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
	87	void goal92_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
88	88	{
89		goal92_state *state = machine.driver_data<goal92_state>();
90		UINT16 *buffered_spriteram16 = state->m_buffered_spriteram;
	89	UINT16 *buffered_spriteram16 = m_buffered_spriteram;
91	90	int offs, fx, fy, x, y, color, sprite;
92	91
93	92	for (offs = 3; offs <= 0x400 - 5; offs += 4)
r20824	r20825
122	121
123	122	y = 256 - (y + 7);
124	123
125		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	124	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
126	125	sprite,
127	126	color,fx,fy,x,y,15);
128	127	}
r20824	r20825
162	161	bitmap.fill(get_black_pen(machine()), cliprect);
163	162
164	163	m_bg_layer->draw(bitmap, cliprect, 0, 0);
165		draw_sprites(machine(), bitmap, cliprect, 2);
	164	draw_sprites(bitmap, cliprect, 2);
166	165
167	166	if (!(m_fg_bank & 0xff))
168		draw_sprites(machine(), bitmap, cliprect, 1);
	167	draw_sprites(bitmap, cliprect, 1);
169	168
170	169	m_fg_layer->draw(bitmap, cliprect, 0, 0);
171	170
172	171	if(m_fg_bank & 0xff)
173		draw_sprites(machine(), bitmap, cliprect, 1);
	172	draw_sprites(bitmap, cliprect, 1);
174	173
175		draw_sprites(machine(), bitmap, cliprect, 0);
176		draw_sprites(machine(), bitmap, cliprect, 3);
	174	draw_sprites(bitmap, cliprect, 0);
	175	draw_sprites(bitmap, cliprect, 3);
177	176	m_tx_layer->draw(bitmap, cliprect, 0, 0);
178	177	return 0;
179	178	}

trunk/src/mame/video/bosco.c

r20824	r20825
92	92	}
93	93
94	94
95		INLINE void get_tile_info_bosco(running_machine &machine,tile_data &tileinfo,int tile_index,int ram_offs)
	95	inline void bosco_state::get_tile_info_bosco(tile_data &tileinfo,int tile_index,int ram_offs)
96	96	{
97		bosco_state *state =  machine.driver_data<bosco_state>();
98
99		UINT8 attr = state->m_videoram[ram_offs + tile_index + 0x800];
	97	UINT8 attr = m_videoram[ram_offs + tile_index + 0x800];
100	98	tileinfo.category = (attr & 0x20) >> 5;
101	99	tileinfo.group = attr & 0x3f;
102		SET_TILE_INFO(
	100	SET_TILE_INFO_MEMBER(
103	101	0,
104		state->m_videoram[ram_offs + tile_index],
	102	m_videoram[ram_offs + tile_index],
105	103	attr & 0x3f,
106	104	TILE_FLIPYX(attr >> 6) ^ TILE_FLIPX);
107	105	}
108	106
109	107	TILE_GET_INFO_MEMBER(bosco_state::bg_get_tile_info )
110	108	{
111		get_tile_info_bosco(machine(),tileinfo,tile_index,0x400);
	109	get_tile_info_bosco(tileinfo,tile_index,0x400);
112	110	}
113	111
114	112	TILE_GET_INFO_MEMBER(bosco_state::fg_get_tile_info )
115	113	{
116		get_tile_info_bosco(machine(),tileinfo,tile_index,0x000);
	114	get_tile_info_bosco(tileinfo,tile_index,0x000);
117	115	}
118	116
119	117
r20824	r20825
188	186
189	187	***************************************************************************/
190	188
191		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	189	void bosco_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
192	190	{
193		bosco_state *state =  machine.driver_data<bosco_state>();
194		UINT8 *spriteram = state->m_spriteram;
195		UINT8 *spriteram_2 = state->m_spriteram2;
	191	UINT8 *spriteram = m_spriteram;
	192	UINT8 *spriteram_2 = m_spriteram2;
196	193	int offs;
197	194
198		for (offs = 0;offs < state->m_spriteram_size;offs += 2)
	195	for (offs = 0;offs < m_spriteram_size;offs += 2)
199	196	{
200	197	int sx = spriteram[offs + 1] - 1;
201	198	int sy = 240 - spriteram_2[offs];
r20824	r20825
203	200	int flipy = spriteram[offs] & 2;
204	201	int color = spriteram_2[offs + 1] & 0x3f;
205	202
206		if (state->flip_screen())
	203	if (flip_screen())
207	204	{
208	205	sx += 128-2;
209	206	sy += 8;
210	207	}
211	208
212		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	209	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
213	210	(spriteram[offs] & 0xfc) >> 2,
214	211	color,
215	212	flipx,flipy,
216	213	sx,sy,
217		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0x0f));
	214	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0x0f));
218	215	}
219	216	}
220	217
221	218
222		static void draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	219	void bosco_state::draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect)
223	220	{
224		bosco_state *state =  machine.driver_data<bosco_state>();
225	221	int offs;
226	222
227	223	for (offs = 4; offs < 0x10;offs++)
228	224	{
229		int x = state->m_bosco_radarx[offs] + ((~state->m_bosco_radarattr[offs] & 0x01) << 8);
230		int y = 253 - state->m_bosco_radary[offs];
	225	int x = m_bosco_radarx[offs] + ((~m_bosco_radarattr[offs] & 0x01) << 8);
	226	int y = 253 - m_bosco_radary[offs];
231	227
232		if (state->flip_screen())
	228	if (flip_screen())
233	229	{
234	230	x += 96-2;
235	231	y += 8;
236	232	}
237	233
238		drawgfx_transmask(bitmap,cliprect,machine.gfx[2],
239		((state->m_bosco_radarattr[offs] & 0x0e) >> 1) ^ 0x07,
	234	drawgfx_transmask(bitmap,cliprect,machine().gfx[2],
	235	((m_bosco_radarattr[offs] & 0x0e) >> 1) ^ 0x07,
240	236	0,
241	237	0,0,
242	238	x,y,0xf0);
r20824	r20825
244	240	}
245	241
246	242
247		static void draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
	243	void bosco_state::draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
248	244	{
249		bosco_state *state = machine.driver_data<bosco_state>();
250
251	245	if (1)
252	246	{
253	247	int star_cntr;
254	248	int set_a, set_b;
255	249
256	250	/* two sets of stars controlled by these bits */
257		set_a = (state->m_bosco_starblink[0] & 1);
258		set_b = (state->m_bosco_starblink[1] & 1) | 2;
	251	set_a = (m_bosco_starblink[0] & 1);
	252	set_b = (m_bosco_starblink[1] & 1) | 2;
259	253
260	254	for (star_cntr = 0;star_cntr < MAX_STARS;star_cntr++)
261	255	{
r20824	r20825
263	257
264	258	if ( (set_a == star_seed_tab[star_cntr].set) || ( set_b == star_seed_tab[star_cntr].set) )
265	259	{
266		x = (star_seed_tab[star_cntr].x + state->m_stars_scrollx) % 256;
267		y = (star_seed_tab[star_cntr].y + state->m_stars_scrolly) % 256;
	260	x = (star_seed_tab[star_cntr].x + m_stars_scrollx) % 256;
	261	y = (star_seed_tab[star_cntr].y + m_stars_scrolly) % 256;
268	262
269	263	/* dont draw the stars that are off the screen */
270	264	if ( x < 224 )
r20824	r20825
298	292	}
299	293
300	294	bitmap.fill(get_black_pen(machine()), cliprect);
301		draw_stars(machine(),bitmap,cliprect,flip_screen());
	295	draw_stars(bitmap,cliprect,flip_screen());
302	296
303	297	m_bg_tilemap->draw(bitmap, bg_clip, 0,0);
304	298	m_fg_tilemap->draw(bitmap, fg_clip, 0,0);
305	299
306		draw_sprites(machine(), bitmap,cliprect);
	300	draw_sprites(bitmap,cliprect);
307	301
308	302	/* draw the high priority characters */
309	303	m_bg_tilemap->draw(bitmap, bg_clip, 1,0);
310	304	m_fg_tilemap->draw(bitmap, fg_clip, 1,0);
311	305
312		draw_bullets(machine(), bitmap,cliprect);
	306	draw_bullets(bitmap,cliprect);
313	307
314	308	return 0;
315	309	}

trunk/src/mame/video/galaga.c

r20824	r20825
470	470
471	471	***************************************************************************/
472	472
473		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	473	void galaga_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
474	474	{
475		galaga_state *state =  machine.driver_data<galaga_state>();
476	475
477		UINT8 *spriteram = state->m_galaga_ram1 + 0x380;
478		UINT8 *spriteram_2 = state->m_galaga_ram2 + 0x380;
479		UINT8 *spriteram_3 = state->m_galaga_ram3 + 0x380;
	476	UINT8 *spriteram = m_galaga_ram1 + 0x380;
	477	UINT8 *spriteram_2 = m_galaga_ram2 + 0x380;
	478	UINT8 *spriteram_3 = m_galaga_ram3 + 0x380;
480	479	int offs;
481	480
482	481
r20824	r20825
500	499	sy -= 16 * sizey;
501	500	sy = (sy & 0xff) - 32;  // fix wraparound
502	501
503		if (state->flip_screen())
	502	if (flip_screen())
504	503	{
505	504	flipx ^= 1;
506	505	flipy ^= 1;
r20824	r20825
512	511	{
513	512	for (x = 0;x <= sizex;x++)
514	513	{
515		drawgfx_transmask(bitmap,cliprect,machine.gfx[1],
	514	drawgfx_transmask(bitmap,cliprect,machine().gfx[1],
516	515	sprite + gfx_offs[y ^ (sizey * flipy)][x ^ (sizex * flipx)],
517	516	color,
518	517	flipx,flipy,
519	518	sx + 16*x, sy + 16*y,
520		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0x0f));
	519	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0x0f));
521	520	}
522	521	}
523	522	}
524	523	}
525	524
526	525
527		static void draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	526	void galaga_state::draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect )
528	527	{
529		galaga_state *state =  machine.driver_data<galaga_state>();
530	528	/* draw the stars */
531	529
532	530	/* $a005 controls the stars ON/OFF */
533		if ( (state->m_galaga_starcontrol[5] & 1) == 1 )
	531	if ( (m_galaga_starcontrol[5] & 1) == 1 )
534	532	{
535	533	int y_align = 112; /* 112 is a tweak to get alignment about perfect */
536		int x_align = state->flip_screen() ? 112 : 16;
	534	int x_align = flip_screen() ? 112 : 16;
537	535
538	536	int star_cntr;
539	537	int set_a, set_b;
540	538
541	539	/* two sets of stars controlled by these bits */
542		set_a = (state->m_galaga_starcontrol[3] & 1);
543		set_b = (state->m_galaga_starcontrol[4] & 1) | 2;
	540	set_a = (m_galaga_starcontrol[3] & 1);
	541	set_b = (m_galaga_starcontrol[4] & 1) | 2;
544	542
545	543	for (star_cntr = 0;star_cntr < MAX_STARS ;star_cntr++)
546	544	{
r20824	r20825
548	546
549	547	if ( (set_a == star_seed_tab[star_cntr].set) || ( set_b == star_seed_tab[star_cntr].set) )
550	548	{
551		x = (star_seed_tab[star_cntr].x + state->m_stars_scrollx) % 256 + x_align;
552		y = (y_align + star_seed_tab[star_cntr].y + state->m_stars_scrolly) % 256;
	549	x = (star_seed_tab[star_cntr].x + m_stars_scrollx) % 256 + x_align;
	550	y = (y_align + star_seed_tab[star_cntr].y + m_stars_scrolly) % 256;
553	551
554	552	if (cliprect.contains(x, y))
555	553	bitmap.pix16(y, x) = STARS_COLOR_BASE + star_seed_tab[ star_cntr ].col;
r20824	r20825
562	560	UINT32 galaga_state::screen_update_galaga(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
563	561	{
564	562	bitmap.fill(get_black_pen(machine()), cliprect);
565		draw_stars(machine(),bitmap,cliprect);
566		draw_sprites(machine(),bitmap,cliprect);
	563	draw_stars(bitmap,cliprect);
	564	draw_sprites(bitmap,cliprect);
567	565	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
568	566	return 0;
569	567	}

trunk/src/mame/video/galspnbl.c

r20824	r20825
13	13
14	14
15	15
16		static void draw_background( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	16	void galspnbl_state::draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect )
17	17	{
18		galspnbl_state *state = machine.driver_data<galspnbl_state>();
19	18	offs_t offs;
20	19
21		//  int screenscroll = 4 - (state->m_scroll[0] & 0xff);
	20	//  int screenscroll = 4 - (m_scroll[0] & 0xff);
22	21
23	22	for (offs = 0; offs < 0x20000; offs++)
24	23	{
25	24	int y = offs >> 9;
26	25	int x = offs & 0x1ff;
27	26
28		bitmap.pix16(y, x) = 1024 + (state->m_bgvideoram[offs] >> 1);
	27	bitmap.pix16(y, x) = 1024 + (m_bgvideoram[offs] >> 1);
29	28	}
30	29	}
31	30
r20824	r20825
34	33	{
35	34	int offs;
36	35
37		draw_background(machine(), bitmap, cliprect);
	36	draw_background(bitmap, cliprect);
38	37
39	38	galspnbl_draw_sprites(machine(), bitmap, cliprect, 0,  m_spriteram, m_spriteram.bytes());
40	39

trunk/src/mame/includes/gsword.h

r20824	r20825
47	47	DECLARE_PALETTE_INIT(josvolly);
48	48	UINT32 screen_update_gsword(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
49	49	INTERRUPT_GEN_MEMBER(gsword_snd_interrupt);
	50	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	51	int gsword_coins_in(void);
50	52	};

trunk/src/mame/includes/gaelco2.h

r20824	r20825
56	56	DECLARE_WRITE16_MEMBER(gaelco2_eeprom_cs_w);
57	57	DECLARE_WRITE16_MEMBER(gaelco2_eeprom_sk_w);
58	58	DECLARE_WRITE16_MEMBER(gaelco2_eeprom_data_w);
	59	void draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int mask, int xoffs);
	60	UINT32 dual_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int index);
	61	void gaelco2_ROM16_split_gfx(const char *src_reg, const char *dst_reg, int start, int length, int dest1, int dest2);
59	62	};

trunk/src/mame/includes/galpanic.h

r20824	r20825
29	29	void screen_eof_galpanic(screen_device &screen, bool state);
30	30	TIMER_DEVICE_CALLBACK_MEMBER(galpanic_scanline);
31	31	TIMER_DEVICE_CALLBACK_MEMBER(galhustl_scanline);
	32	void comad_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	33	void draw_fgbitmap(bitmap_ind16 &bitmap, const rectangle &cliprect);
32	34	};
33	35
34	36	/*----------- defined in video/galpanic.c -----------*/

trunk/src/mame/includes/goldstar.h

r20824	r20825
150	150	UINT32 screen_update_amcoe1a(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
151	151	UINT32 screen_update_unkch(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
152	152	INTERRUPT_GEN_MEMBER(lucky8_irq);
	153	void do_blockswaps(UINT8* ROM);
	154	void dump_to_file( UINT8* ROM);
	155	UINT8 decrypt(UINT8 cipherText, UINT16 address);
	156	UINT8 chry10_decrypt(UINT8 cipherText);
153	157	};

trunk/src/mame/includes/gotcha.h

r20824	r20825
47	47	virtual void machine_reset();
48	48	virtual void video_start();
49	49	UINT32 screen_update_gotcha(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	50	inline void get_tile_info( tile_data &tileinfo, int tile_index ,UINT16 *vram, int color_offs);
50	51	};

trunk/src/mame/includes/gberet.h

r20824	r20825
58	58	UINT32 screen_update_gberet(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
59	59	UINT32 screen_update_gberetb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
60	60	TIMER_DEVICE_CALLBACK_MEMBER(gberet_interrupt_tick);
	61	void gberet_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	62	void gberetb_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
61	63	};

trunk/src/mame/includes/gotya.h

r20824	r20825
38	38	virtual void video_start();
39	39	virtual void palette_init();
40	40	UINT32 screen_update_gotya(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	41	void draw_status_row( bitmap_ind16 &bitmap, const rectangle &cliprect, int sx, int col );
	42	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	43	void draw_status( bitmap_ind16 &bitmap, const rectangle &cliprect );
41	44	};

trunk/src/mame/includes/gyruss.h

r20824	r20825
56	56	UINT32 screen_update_gyruss(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
57	57	INTERRUPT_GEN_MEMBER(master_vblank_irq);
58	58	INTERRUPT_GEN_MEMBER(slave_vblank_irq);
	59	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element **gfx );
59	60	};

trunk/src/mame/includes/gaelco3d.h

r20824	r20825
119	119	INTERRUPT_GEN_MEMBER(vblank_gen);
120	120	TIMER_CALLBACK_MEMBER(delayed_sound_w);
121	121	TIMER_DEVICE_CALLBACK_MEMBER(adsp_autobuffer_irq);
	122	void gaelco3d_render(screen_device &screen);
122	123	};
123
124		/*----------- defined in video/gaelco3d.c -----------*/
125
126		void gaelco3d_render(screen_device &screen);

trunk/src/mame/includes/galaxian.h

r20824	r20825
27	27	#define GALAXIAN_VBEND          (16)
28	28	#define GALAXIAN_VBSTART        (224+16)
29	29
30		/* video extension callbacks */
31		typedef void (*galaxian_extend_tile_info_func)(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
32		typedef void (*galaxian_extend_sprite_info_func)(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
33		typedef void (*galaxian_draw_bullet_func)(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
34		typedef void (*galaxian_draw_background_func)(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
35	30
36
37	31	class galaxian_state : public driver_device
38	32	{
39	33	public:
r20824	r20825
70	64	int m_tenspot_current_game;
71	65	UINT8 m_frogger_adjust;
72	66	UINT8 m_sfx_tilemap;
	67
	68	/* video extension callbacks */
	69	typedef void (galaxian_state::*galaxian_extend_tile_info_func)(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	70	typedef void (galaxian_state::*galaxian_extend_sprite_info_func)(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	71	typedef void (galaxian_state::*galaxian_draw_bullet_func)(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	72	typedef void (galaxian_state::*galaxian_draw_background_func)(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	73
73	74	galaxian_extend_tile_info_func m_extend_tile_info_ptr;
74	75	galaxian_extend_sprite_info_func m_extend_sprite_info_ptr;
75	76	galaxian_draw_bullet_func m_draw_bullet_ptr;
76	77	galaxian_draw_background_func m_draw_background_ptr;
	78
77	79	tilemap_t *m_bg_tilemap;
78	80	UINT8 m_flipscreen_x;
79	81	UINT8 m_flipscreen_y;
r20824	r20825
230	232	INTERRUPT_GEN_MEMBER(fakechange_interrupt_gen);
231	233	TIMER_DEVICE_CALLBACK_MEMBER(checkmaj_irq0_gen);
232	234	TIMER_DEVICE_CALLBACK_MEMBER(galaxian_stars_blink_timer);
	235	void state_save_register();
	236	void sprites_draw(bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *spritebase);
	237	void bullets_draw(bitmap_rgb32 &bitmap, const rectangle &cliprect, const UINT8 *base);
	238	void stars_init();
	239	void stars_update_origin();
	240	void stars_draw_row(bitmap_rgb32 &bitmap, int maxx, int y, UINT32 star_offs, UINT8 starmask);
	241	void galaxian_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	242	void background_draw_colorsplit(bitmap_rgb32 &bitmap, const rectangle &cliprect, rgb_t color, int split, int split_flipped);
	243	void scramble_draw_stars(bitmap_rgb32 &bitmap, const rectangle &cliprect, int maxx);
	244	void scramble_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	245	void anteater_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	246	void jumpbug_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	247	void turtles_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	248	void frogger_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	249	int flip_and_clip(rectangle &draw, int xstart, int xend, const rectangle &cliprect);
	250	void amidar_draw_background(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	251	inline void galaxian_draw_pixel(bitmap_rgb32 &bitmap, const rectangle &cliprect, int y, int x, rgb_t color);
	252	void galaxian_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	253	void mshuttle_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	254	void scramble_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	255	void theend_draw_bullet(bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	256	void upper_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	257	void upper_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	258	void frogger_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	259	void frogger_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	260	void gmgalax_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	261	void gmgalax_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	262	void pisces_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	263	void pisces_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	264	void batman2_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	265	void mooncrst_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	266	void mooncrst_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	267	void moonqsr_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	268	void moonqsr_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	269	void mshuttle_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	270	void mshuttle_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	271	void calipso_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	272	void jumpbug_extend_tile_info(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
	273	void jumpbug_extend_sprite_info(const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
	274	void monsterz_set_latch();
	275	void decode_mooncrst(int length, UINT8 *dest);
	276	void decode_checkman();
	277	void decode_dingoe();
	278	void decode_frogger_sound();
	279	void decode_frogger_gfx();
	280	void decode_anteater_gfx();
	281	void decode_losttomb_gfx();
	282	void decode_superbon();
	283	void unmap_galaxian_sound(offs_t base);
	284	void mshuttle_decode(const UINT8 convtable[8][16]);
	285	void common_init(galaxian_draw_bullet_func draw_bullet,galaxian_draw_background_func draw_background,
	286	galaxian_extend_tile_info_func extend_tile_info,galaxian_extend_sprite_info_func extend_sprite_info);
233	287	};
234
235
236		/*----------- defined in video/galaxian.c -----------*/
237
238		/* special purpose background rendering */
239		void galaxian_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
240		void frogger_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
241		//void amidar_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
242		void turtles_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
243		void scramble_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
244		void anteater_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
245		void jumpbug_draw_background(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect);
246
247		/* special purpose bullet rendering */
248		void galaxian_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
249		void mshuttle_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
250		void scramble_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
251		void theend_draw_bullet(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int offs, int x, int y);
252
253		/* generic extensions */
254		void upper_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
255		void upper_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
256
257		/* Frogger extensions */
258		void frogger_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
259		void frogger_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
260
261		/* Ghostmuncher Galaxian extensions */
262		void gmgalax_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
263		void gmgalax_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
264
265		/* Pisces extensions */
266		void pisces_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
267		void pisces_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
268
269		/* Batman Part 2 extensions */
270		void batman2_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
271
272		/* Moon Cresta extensions */
273		void mooncrst_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
274		void mooncrst_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
275
276		/* Moon Quasar extensions */
277		void moonqsr_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
278		void moonqsr_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
279
280		/* Moon Shuttle extensions */
281		void mshuttle_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
282		void mshuttle_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
283
284		/* Calipso extensions */
285		void calipso_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);
286
287		/* Jumpbug extensions */
288		void jumpbug_extend_tile_info(running_machine &machine, UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);
289		void jumpbug_extend_sprite_info(running_machine &machine, const UINT8 *base, UINT8 *sx, UINT8 *sy, UINT8 *flipx, UINT8 *flipy, UINT16 *code, UINT8 *color);

trunk/src/mame/includes/gstriker.h

r20824	r20825
99	99	DECLARE_VIDEO_START(vgoalsoc);
100	100	DECLARE_VIDEO_START(twrldc94);
101	101	UINT32 screen_update_gstriker(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	102	void VS920A_init(int numchips);
	103	tilemap_t* VS920A_get_tilemap(int numchip);
	104	void VS920A_set_pal_base(int numchip, int pal_base);
	105	void VS920A_set_gfx_region(int numchip, int gfx_region);
	106	void VS920A_draw(int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority);
	107	void MB60553_init(int numchips);
	108	void MB60553_set_pal_base(int numchip, int pal_base);
	109	void MB60553_set_gfx_region(int numchip, int gfx_region);
	110	void MB60553_draw(int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority);
	111	tilemap_t* MB60553_get_tilemap(int numchip);
	112	void mcu_init(  );
102	113	};
103	114
104	115	#endif

trunk/src/mame/includes/grchamp.h

r20824	r20825
75	75	INTERRUPT_GEN_MEMBER(grchamp_cpu0_interrupt);
76	76	INTERRUPT_GEN_MEMBER(grchamp_cpu1_interrupt);
77	77	TIMER_CALLBACK_MEMBER(main_to_sub_comm_sync_w);
	78	void draw_objects(int y, UINT8 *objdata);
78	79	};
79	80
80	81	/* Discrete Sound Input Nodes */

trunk/src/mame/includes/gijoe.h

r20824	r20825
47	47	UINT32 screen_update_gijoe(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
48	48	INTERRUPT_GEN_MEMBER(gijoe_interrupt);
49	49	TIMER_CALLBACK_MEMBER(dmaend_callback);
	50	void gijoe_objdma(  );
50	51	};
51	52
52	53	/*----------- defined in video/gijoe.c -----------*/

trunk/src/mame/includes/gameplan.h

r20824	r20825
79	79	DECLARE_WRITE8_MEMBER(leprechn_video_command_w);
80	80	DECLARE_WRITE_LINE_MEMBER(video_command_trigger_w);
81	81	DECLARE_READ8_MEMBER(vblank_r);
	82	void gameplan_get_pens( pen_t *pens );
	83	void leprechn_get_pens( pen_t *pens );
82	84	};
83	85
84	86	/*----------- defined in video/gameplan.c -----------*/

trunk/src/mame/includes/galastrm.h

r20824	r20825
51	51	INTERRUPT_GEN_MEMBER(galastrm_interrupt);
52	52	TIMER_CALLBACK_MEMBER(galastrm_interrupt6);
53	53	void galastrm_exit();
	54	void draw_sprites_pre(int x_offs, int y_offs);
	55	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, const int *primasks, int priority);
	56	void tc0610_rotate_draw(bitmap_ind16 &bitmap, bitmap_ind16 &srcbitmap, const rectangle &clip);
54	57	};

trunk/src/mame/includes/galaxold.h

r20824	r20825
54	54	UINT8 m_color_mask;
55	55	tilemap_t *m_dambustr_tilemap2;
56	56	UINT8 *m_dambustr_videoram2;
57		void (*m_modify_charcode)(running_machine &machine, UINT16 *code, UINT8 x);     /* function to call to do character banking */
58		void (*m_modify_spritecode)(running_machine &machine, UINT8 *spriteram, int*, int*, int*, int); /* function to call to do sprite banking */
59		void (*m_modify_color)(UINT8 *color);   /* function to call to do modify how the color codes map to the PROM */
60		void (*m_modify_ypos)(UINT8*);  /* function to call to do modify how vertical positioning bits are connected */
	57	void (galaxold_state::*m_modify_charcode)(UINT16 *code, UINT8 x);     /* function to call to do character banking */
	58	void (galaxold_state::*m_modify_spritecode)(UINT8 *spriteram, int*, int*, int*, int); /* function to call to do sprite banking */
	59	void (galaxold_state::*m_modify_color)(UINT8 *color);   /* function to call to do modify how the color codes map to the PROM */
	60	void (galaxold_state::*m_modify_ypos)(UINT8*);  /* function to call to do modify how vertical positioning bits are connected */
61	61
62	62	UINT8 m_timer_adjusted;
63	63	UINT8 m_darkplnt_bullet_color;
64		void (*m_draw_bullets)(running_machine &,bitmap_ind16 &,const rectangle &, int, int, int);  /* function to call to draw a bullet */
	64	void (galaxold_state::*m_draw_bullets)(bitmap_ind16 &,const rectangle &, int, int, int);  /* function to call to draw a bullet */
65	65
66	66	UINT8 m_background_enable;
67	67	UINT8 m_background_red;
68	68	UINT8 m_background_green;
69	69	UINT8 m_background_blue;
70		void (*m_draw_background)(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);   /* function to call to draw the background */
	70	void (galaxold_state::*m_draw_background)(bitmap_ind16 &bitmap, const rectangle &cliprect);   /* function to call to draw the background */
71	71	UINT16 m_rockclim_v;
72	72	UINT16 m_rockclim_h;
73	73	int m_dambustr_bg_split_line;
r20824	r20825
77	77	int m_dambustr_char_bank;
78	78	bitmap_ind16 *m_dambustr_tmpbitmap;
79	79
80		void (*m_draw_stars)(running_machine &machine, bitmap_ind16 &, const rectangle &);      /* function to call to draw the star layer */
	80	void (galaxold_state::*m_draw_stars)(bitmap_ind16 &, const rectangle &);      /* function to call to draw the star layer */
81	81	int m_stars_colors_start;
82	82	INT32 m_stars_scrollpos;
83	83	UINT8 m_stars_on;
r20824	r20825
188	188	DECLARE_WRITE_LINE_MEMBER(galaxold_7474_9m_1_callback);
189	189	DECLARE_VIDEO_START(bagmanmc);
190	190	IRQ_CALLBACK_MEMBER(hunchbkg_irq_callback);
	191	void state_save_register();
	192	void video_start_common();
	193	void pisces_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	194	void theend_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	195	void mooncrst_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	196	void batman2_modify_charcode(UINT16 *code, UINT8 x);
	197	void rockclim_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	198	void rockclim_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	199	void harem_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	200	void mooncrst_modify_charcode(UINT16 *code, UINT8 x);
	201	void pisces_modify_charcode(UINT16 *code, UINT8 x);
	202	void mimonkey_modify_charcode(UINT16 *code, UINT8 x);
	203	void mariner_modify_charcode(UINT16 *code, UINT8 x);
	204	void dambustr_modify_charcode(UINT16 *code, UINT8 x);
	205	void mshuttle_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	206	void mimonkey_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	207	void batman2_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	208	void dkongjrm_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	209	void ad2083_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	210	void dambustr_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	211	void drivfrcg_modify_color(UINT8 *color);
	212	void galaxold_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	213	void scrambold_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	214	void darkplnt_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	215	void dambustr_draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y);
	216	void galaxold_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	217	void scrambold_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	218	void ad2083_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	219	void stratgyx_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	220	void minefld_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	221	void rescue_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	222	void mariner_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	223	void dambustr_draw_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	224	void dambustr_draw_upper_background(bitmap_ind16 &bitmap, const rectangle &cliprect);
	225	void galaxold_init_stars(int colors_offset);
	226	void plot_star(bitmap_ind16 &bitmap, int x, int y, int color, const rectangle &cliprect);
	227	void noop_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect);
	228	void galaxold_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect);
	229	void scrambold_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect);
	230	void rescue_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect);
	231	void mariner_draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect);
	232	void start_stars_blink_timer(double ra, double rb, double c);
	233	void start_stars_scroll_timer();
	234	void draw_bullets_common(bitmap_ind16 &bitmap, const rectangle &cliprect);
	235	void draw_sprites(bitmap_ind16 &bitmap, UINT8 *spriteram, size_t spriteram_size);
	236	void bagmanmc_modify_charcode(UINT16 *code, UINT8 x);
	237	void bagmanmc_modify_spritecode(UINT8 *spriteram, int *code, int *flipx, int *flipy, int offs);
	238	void machine_reset_common(int line);
	239	UINT8 decode_mooncrst(UINT8 data,offs_t addr);
191	240	};
192	241
193		/*----------- defined in video/galaxold.c -----------*/
194		void galaxold_init_stars(running_machine &machine, int colors_offset);
195		void galaxold_draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect);
196
197	242	#define galaxold_coin_counter_0_w galaxold_coin_counter_w
198	243
199	244	#endif

trunk/src/mame/includes/gng.h

r20824	r20825
43	43	virtual void machine_reset();
44	44	virtual void video_start();
45	45	UINT32 screen_update_gng(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	46	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
46	47	};

trunk/src/mame/includes/gaplus.h

r20824	r20825
51	51	INTERRUPT_GEN_MEMBER(gaplus_vblank_sub_irq);
52	52	INTERRUPT_GEN_MEMBER(gaplus_vblank_sub2_irq);
53	53	TIMER_CALLBACK_MEMBER(namcoio_run);
	54	void starfield_init();
	55	void starfield_render(bitmap_ind16 &bitmap);
	56	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
54	57	};

trunk/src/mame/includes/gaiden.h

r20824	r20825
88	88	UINT32 screen_update_gaiden(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
89	89	UINT32 screen_update_drgnbowl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
90	90	UINT32 screen_update_raiga(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	91	void drgnbowl_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	92	void descramble_drgnbowl_gfx();
	93	void descramble_mastninj_gfx(UINT8* src);
	94	void blendbitmaps(bitmap_rgb32 &dest,bitmap_ind16 &src1,bitmap_ind16 &src2,bitmap_ind16 &src3,
	95	int sx,int sy,const rectangle &cliprect);
91	96	};

trunk/src/mame/includes/gunsmoke.h

r20824	r20825
41	41	virtual void video_start();
42	42	virtual void palette_init();
43	43	UINT32 screen_update_gunsmoke(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	44	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
44	45	};

trunk/src/mame/includes/gcpinbal.h

r20824	r20825
62	62	INTERRUPT_GEN_MEMBER(gcpinbal_interrupt);
63	63	TIMER_CALLBACK_MEMBER(gcpinbal_interrupt1);
64	64	TIMER_CALLBACK_MEMBER(gcpinbal_interrupt3);
	65	void gcpinbal_core_vh_start(  );
	66	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int y_offs );
65	67	};

trunk/src/mame/includes/ginganin.h

r20824	r20825
46	46	virtual void machine_reset();
47	47	virtual void video_start();
48	48	UINT32 screen_update_ginganin(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	49	void draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect );
49	50	};

trunk/src/mame/includes/gunbustr.h

r20824	r20825
42	42	UINT32 screen_update_gunbustr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
43	43	INTERRUPT_GEN_MEMBER(gunbustr_interrupt);
44	44	TIMER_CALLBACK_MEMBER(gunbustr_interrupt5);
	45	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,const int *primasks,int x_offs,int y_offs);
45	46	};

trunk/src/mame/includes/gridlee.h

r20824	r20825
61	61	TIMER_CALLBACK_MEMBER(firq_off_tick);
62	62	TIMER_CALLBACK_MEMBER(firq_timer_tick);
63	63	void expand_pixels();
	64	void poly17_init();
64	65	};
65	66
66	67

trunk/src/mame/includes/gaelco.h

r20824	r20825
41	41	DECLARE_VIDEO_START(maniacsq);
42	42	UINT32 screen_update_bigkarnk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
43	43	UINT32 screen_update_maniacsq(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	44	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
44	45	};

trunk/src/mame/includes/galivan.h

r20824	r20825
58	58	DECLARE_VIDEO_START(ninjemak);
59	59	UINT32 screen_update_galivan(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
60	60	UINT32 screen_update_ninjemak(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	61	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
61	62	};
62	63
63	64	/*----------- defined in video/galivan.c -----------*/

trunk/src/mame/includes/gottlieb.h

r20824	r20825
314	314	TIMER_CALLBACK_MEMBER(laserdisc_bit_off_callback);
315	315	TIMER_CALLBACK_MEMBER(laserdisc_bit_callback);
316	316	TIMER_CALLBACK_MEMBER(nmi_clear);
	317	void draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	318	inline void audio_end_state();
	319	void audio_process_clock(int logit);
	320	void audio_handle_zero_crossing(attotime zerotime, int logit);
317	321	};
318	322
319	323	/*----------- defined in audio/gottlieb.c -----------*/

trunk/src/mame/includes/gladiatr.h

r20824	r20825
66	66	DECLARE_VIDEO_START(gladiatr);
67	67	UINT32 screen_update_ppking(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
68	68	UINT32 screen_update_gladiatr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	69	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	70	void swap_block(UINT8 *src1,UINT8 *src2,int len);
69	71	};

trunk/src/mame/includes/groundfx.h

r20824	r20825
40	40	UINT32 screen_update_groundfx(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
41	41	INTERRUPT_GEN_MEMBER(groundfx_interrupt);
42	42	TIMER_CALLBACK_MEMBER(groundfx_interrupt5);
	43	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect,int do_hack,int x_offs,int y_offs);
43	44	};

trunk/src/mame/includes/goal92.h

r20824	r20825
53	53	virtual void video_start();
54	54	UINT32 screen_update_goal92(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
55	55	void screen_eof_goal92(screen_device &screen, bool state);
	56	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
56	57	};

trunk/src/mame/includes/glass.h

r20824	r20825
48	48	virtual void video_start();
49	49	UINT32 screen_update_glass(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50	50	INTERRUPT_GEN_MEMBER(glass_interrupt);
	51	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	52	void glass_ROM16_split_gfx( const char *src_reg, const char *dst_reg, int start, int length, int dest1, int dest2 );
51	53	};

trunk/src/mame/includes/galaga.h

r20824	r20825
61	61	INTERRUPT_GEN_MEMBER(main_vblank_irq);
62	62	INTERRUPT_GEN_MEMBER(sub_vblank_irq);
63	63	TIMER_CALLBACK_MEMBER(cpu3_interrupt_callback);
	64	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
	65	void draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect );
	66	void bosco_latch_reset();
64	67	};
65	68
66	69	class xevious_state : public galaga_state
r20824	r20825
98	101	UINT32 screen_update_xevious(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
99	102	INTERRUPT_GEN_MEMBER(battles_interrupt_4);
100	103	TIMER_DEVICE_CALLBACK_MEMBER(battles_nmi_generate);
	104	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
101	105	};
102	106
103	107
r20824	r20825
129	133	DECLARE_PALETTE_INIT(bosco);
130	134	UINT32 screen_update_bosco(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
131	135	void screen_eof_bosco(screen_device &screen, bool state);
	136
	137	inline void get_tile_info_bosco(tile_data &tileinfo,int tile_index,int ram_offs);
	138	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	139	void draw_bullets(bitmap_ind16 &bitmap, const rectangle &cliprect);
	140	void draw_stars(bitmap_ind16 &bitmap, const rectangle &cliprect, int flip);
132	141	};
133	142
134	143	class digdug_state : public galaga_state
r20824	r20825
155	164	DECLARE_VIDEO_START(digdug);
156	165	DECLARE_PALETTE_INIT(digdug);
157	166	UINT32 screen_update_digdug(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	167	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
158	168	};
159	169
160	170	/*----------- defined in video/bosco.c -----------*/

trunk/src/mame/includes/galspnbl.h

r20824	r20825
32	32	virtual void machine_start();
33	33	virtual void palette_init();
34	34	UINT32 screen_update_galspnbl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	35	void draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect );
35	36	};

trunk/src/mame/includes/goindol.h

r20824	r20825
48	48	virtual void machine_reset();
49	49	virtual void video_start();
50	50	UINT32 screen_update_goindol(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	51	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int gfxbank, UINT8 *sprite_ram );
51	52	};

trunk/src/mame/includes/galpani2.h

r20824	r20825
53	53	UINT32 screen_update_galpani2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
54	54	TIMER_DEVICE_CALLBACK_MEMBER(galpani2_interrupt1);
55	55	TIMER_DEVICE_CALLBACK_MEMBER(galpani2_interrupt2);
	56	void galpani2_mcu_nmi1();
	57	void galpani2_mcu_nmi2();
56	58	};
57	59
58	60

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team