Previous

199869 Revisions

Next

r32472 Tuesday 30th September, 2014 at 14:57:36 UTC by Osso
namcos2 and namcos21: moved most remaining functions into classes (nw).

[src/mame/drivers]	namcos21.c
[src/mame/includes]	namcos2.h namcos21.h
[src/mame/machine]	namcos2.c
[src/mame/video]	namcos2.c namcos21.c

trunk/src/mame/machine/namcos2.c

r32471	r32472
16	16	#include "machine/nvram.h"
17	17
18	18
19		static void InitC148(void);
20
21		static emu_timer *namcos2_posirq_timer;
22
23	19	void (*namcos2_kickstart)(running_machine &machine, int internal);
24	20
25		static unsigned mFinalLapProtCount;
26		static int namcos2_mcu_analog_ctrl;
27		static int namcos2_mcu_analog_data;
28		static int namcos2_mcu_analog_complete;
29		static UINT8 *namcos2_eeprom;
30		static int sendval;
31	21
32
33	22	READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r )
34	23	{
35	24	static const UINT16 table0[8] = { 0x0000,0x0040,0x0440,0x2440,0x2480,0xa080,0x8081,0x8041 };
r32471	r32472
47	36	break;
48	37
49	38	case 2:
50		data = table1[mFinalLapProtCount&7];
	39	data = table1[m_finallap_prot_count&7];
51	40	data = (data&0xff00)>>8;
52	41	break;
53	42
54	43	case 3:
55		data = table1[mFinalLapProtCount&7];
56		mFinalLapProtCount++;
	44	data = table1[m_finallap_prot_count&7];
	45	m_finallap_prot_count++;
57	46	data = data&0x00ff;
58	47	break;
59	48
60	49	case 0x3fffc/2:
61		data = table0[mFinalLapProtCount&7];
	50	data = table0[m_finallap_prot_count&7];
62	51	data = data&0xff00;
63	52	break;
64	53
65	54	case 0x3fffe/2:
66		data = table0[mFinalLapProtCount&7];
67		mFinalLapProtCount++;
	55	data = table0[m_finallap_prot_count&7];
	56	m_finallap_prot_count++;
68	57	data = (data&0x00ff)<<8;
69	58	break;
70	59
r32471	r32472
78	67	/* Perform basic machine initialisation                      */
79	68	/*************************************************************/
80	69
81		#define namcos2_eeprom_size 0x2000
	70	#define m_eeprom_size 0x2000
82	71
83		static void
84		ResetAllSubCPUs( running_machine &machine, int state )
	72	void namcos2_shared_state::reset_all_subcpus(int state)
85	73	{
86		namcos2_shared_state *s2state = machine.driver_data<namcos2_shared_state>();
87
88		s2state->m_slave->set_input_line(INPUT_LINE_RESET, state);
89		if (s2state->m_c68)
	74	m_slave->set_input_line(INPUT_LINE_RESET, state);
	75	if (m_c68)
90	76	{
91		s2state->m_c68->set_input_line(INPUT_LINE_RESET, state);
	77	m_c68->set_input_line(INPUT_LINE_RESET, state);
92	78	}
93	79	else
94	80	{
95		s2state->m_mcu->set_input_line(INPUT_LINE_RESET, state);
	81	m_mcu->set_input_line(INPUT_LINE_RESET, state);
96	82	}
97		switch( machine.driver_data<namcos2_shared_state>()->m_gametype )
	83	switch( m_gametype )
98	84	{
99	85	case NAMCOS21_SOLVALOU:
100	86	case NAMCOS21_STARBLADE:
101	87	case NAMCOS21_AIRCOMBAT:
102	88	case NAMCOS21_CYBERSLED:
103		s2state->m_dspmaster->set_input_line(INPUT_LINE_RESET, state);
104		s2state->m_dspslave->set_input_line(INPUT_LINE_RESET, state);
	89	m_dspmaster->set_input_line(INPUT_LINE_RESET, state);
	90	m_dspslave->set_input_line(INPUT_LINE_RESET, state);
105	91	break;
106	92
107	93	//  case NAMCOS21_WINRUN91:
r32471	r32472
114	100	MACHINE_START_MEMBER(namcos2_shared_state,namcos2)
115	101	{
116	102	namcos2_kickstart = NULL;
117		namcos2_eeprom = auto_alloc_array(machine(), UINT8, namcos2_eeprom_size);
118		machine().device<nvram_device>("nvram")->set_base(namcos2_eeprom, namcos2_eeprom_size);
119		namcos2_posirq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(namcos2_shared_state::namcos2_posirq_tick),this));
	103	m_eeprom = auto_alloc_array(machine(), UINT8, m_eeprom_size);
	104	machine().device<nvram_device>("nvram")->set_base(m_eeprom, m_eeprom_size);
	105	m_posirq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(namcos2_shared_state::namcos2_posirq_tick),this));
120	106	}
121	107
122		MACHINE_RESET_MEMBER(namcos2_shared_state,namcos2)
	108	MACHINE_RESET_MEMBER(namcos2_shared_state, namcos2)
123	109	{
124	110	//  address_space &space = m_maincpu->space(AS_PROGRAM);
125	111	address_space &audio_space = m_audiocpu->space(AS_PROGRAM);
126	112
127		mFinalLapProtCount = 0;
128		namcos2_mcu_analog_ctrl = 0;
129		namcos2_mcu_analog_data = 0xaa;
130		namcos2_mcu_analog_complete = 0;
131		sendval = 0;
	113	m_mcu_analog_ctrl = 0;
	114	m_mcu_analog_data = 0xaa;
	115	m_mcu_analog_complete = 0;
132	116
133	117	/* Initialise the bank select in the sound CPU */
134	118	namcos2_sound_bankselect_w(audio_space, 0, 0); /* Page in bank 0 */
r32471	r32472
136	120	m_audiocpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE );
137	121
138	122	/* Place CPU2 & CPU3 into the reset condition */
139		ResetAllSubCPUs( machine(), ASSERT_LINE );
	123	reset_all_subcpus(ASSERT_LINE);
140	124
141	125	/* Initialise interrupt handlers */
142		InitC148();
	126	init_c148();
143	127
144	128	/* reset POSIRQ timer */
145		namcos2_posirq_timer->adjust(attotime::never);
	129	m_posirq_timer->adjust(attotime::never);
146	130
147	131	m_player_mux = 0;
148	132	}
r32471	r32472
153	137
154	138	WRITE8_MEMBER( namcos2_shared_state::namcos2_68k_eeprom_w )
155	139	{
156		namcos2_eeprom[offset] = data;
	140	m_eeprom[offset] = data;
157	141	}
158	142
159	143	READ8_MEMBER( namcos2_shared_state::namcos2_68k_eeprom_r )
160	144	{
161		return namcos2_eeprom[offset];
	145	return m_eeprom[offset];
162	146	}
163	147
164	148
r32471	r32472
301	285	case 1: return 0x110;
302	286	case 4: return 0xBE;
303	287	case 6: return 0x1001;
304		case 7: return (sendval==1)?0xBE:1;
	288	case 7: return (m_sendval==1)?0xBE:1;
305	289	}
306	290	break;
307	291
r32471	r32472
316	300	switch(offset)
317	301	{
318	302	case 4:
319		if( sendval == 1 ){
320		sendval = 0;
	303	if( m_sendval == 1 ){
	304	m_sendval = 0;
321	305	return 0x13F;
322	306	}
323	307	break;
324	308	case 7:
325		if( sendval == 1 ){
326		sendval = 0;
	309	if( m_sendval == 1 ){
	310	m_sendval = 0;
327	311	return 0x13F;
328	312	}
329	313	break;
r32471	r32472
408	392	int gametype = m_gametype;
409	393	if( gametype == NAMCOS2_MARVEL_LAND && offset == 5 )
410	394	{
411		if (data == 0x615E) sendval = 1;
	395	if (data == 0x615E) m_sendval = 1;
412	396	}
413	397	if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 4 )
414	398	{
415		if (data == 0x13EC) sendval = 1;
	399	if (data == 0x13EC) m_sendval = 1;
416	400	}
417	401	if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 7 )
418	402	{
419		if (data == 0x13EC) sendval = 1;
	403	if (data == 0x13EC) m_sendval = 1;
420	404	}
421	405	if( gametype == NAMCOS2_MARVEL_LAND && offset == 6 )
422	406	{
423		if (data == 0x1001) sendval = 0;
	407	if (data == 0x1001) m_sendval = 0;
424	408	}
425	409	}
426	410
r32471	r32472
432	416	#define FRAME_TIME      (1.0/60.0)
433	417	#define LINE_LENGTH     (FRAME_TIME/NO_OF_LINES)
434	418
435		static UINT16  namcos2_68k_master_C148[0x20];
436		static UINT16  namcos2_68k_slave_C148[0x20];
437		static UINT16  namcos2_68k_gpu_C148[0x20];
438	419
439
440	420	bool namcos2_shared_state::is_system21()
441	421	{
442	422	switch (m_gametype)
r32471	r32472
453	433	}
454	434	}
455	435
456		static void InitC148(void)
	436	void namcos2_shared_state::init_c148()
457	437	{
458		int loop;
459
460		for(loop = 0; loop < 0x20; loop++)
	438	for(int loop = 0; loop < 0x20; loop++)
461	439	{
462		namcos2_68k_master_C148[loop] = 0;
463		namcos2_68k_slave_C148[loop] = 0;
464		namcos2_68k_gpu_C148[loop] = 0;
	440	m_68k_master_C148[loop] = 0;
	441	m_68k_slave_C148[loop] = 0;
	442	m_68k_gpu_C148[loop] = 0;
465	443	}
466	444	}
467	445
468		static UINT16
469		ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
	446	UINT16 namcos2_shared_state::readwrite_c148( address_space &space, offs_t offset, UINT16 data, int bWrite )
470	447	{
471	448	offs_t addr = ((offset * 2) + 0x1c0000) & 0x1fe000;
472	449	device_t *altcpu = NULL;
r32471	r32472
476	453
477	454	if (&space.device() == space.machine().device("maincpu"))
478	455	{
479		pC148Reg = namcos2_68k_master_C148;
	456	pC148Reg = m_68k_master_C148;
480	457	altcpu = space.machine().device("slave");
481		pC148RegAlt = namcos2_68k_slave_C148;
	458	pC148RegAlt = m_68k_slave_C148;
482	459	}
483	460	else if (&space.device() == space.machine().device("slave"))
484	461	{
485		pC148Reg = namcos2_68k_slave_C148;
	462	pC148Reg = m_68k_slave_C148;
486	463	altcpu = space.machine().device("maincpu");
487		pC148RegAlt = namcos2_68k_master_C148;
	464	pC148RegAlt = m_68k_master_C148;
488	465	}
489	466	else if (&space.device() == space.machine().device("gpu"))
490	467	{
491		pC148Reg = namcos2_68k_gpu_C148;
	468	pC148Reg = m_68k_gpu_C148;
492	469	altcpu = space.machine().device("maincpu");
493		pC148RegAlt = namcos2_68k_master_C148;
	470	pC148RegAlt = m_68k_master_C148;
494	471	}
495	472
496	473	if( bWrite )
r32471	r32472
600	577	{
601	578	if (data & 0x01)
602	579	{ /* Resume execution */
603		ResetAllSubCPUs(space.machine(), CLEAR_LINE);
	580	reset_all_subcpus(CLEAR_LINE);
604	581	/* Give the new CPU an immediate slice of the action */
605	582	space.device().execute().yield();
606	583	}
607	584	else
608	585	{ /* Suspend execution */
609		ResetAllSubCPUs(space.machine(), ASSERT_LINE);
	586	reset_all_subcpus(ASSERT_LINE);
610	587	}
611	588	}
612	589	break;
r32471	r32472
623	600
624	601	WRITE16_MEMBER( namcos2_shared_state::namcos2_68k_master_C148_w )
625	602	{
626		(void)ReadWriteC148(space, offset, data, 1);
	603	(void)readwrite_c148(space, offset, data, 1);
627	604	}
628	605
629	606	READ16_MEMBER( namcos2_shared_state::namcos2_68k_master_C148_r )
630	607	{
631		return ReadWriteC148(space, offset, 0, 0);
	608	return readwrite_c148(space, offset, 0, 0);
632	609	}
633	610
634	611	WRITE16_MEMBER( namcos2_shared_state::namcos2_68k_slave_C148_w )
635	612	{
636		(void)ReadWriteC148(space, offset, data, 1);
	613	(void)readwrite_c148(space, offset, data, 1);
637	614	}
638	615
639	616	READ16_MEMBER( namcos2_shared_state::namcos2_68k_slave_C148_r )
640	617	{
641		return ReadWriteC148(space, offset, 0, 0);
	618	return readwrite_c148(space, offset, 0, 0);
642	619	}
643	620
644	621	WRITE16_MEMBER( namcos2_shared_state::namcos21_68k_gpu_C148_w )
645	622	{
646		(void)ReadWriteC148(space, offset, data, 1);
	623	(void)readwrite_c148(space, offset, data, 1);
647	624	}
648	625
649	626	READ16_MEMBER( namcos2_shared_state::namcos21_68k_gpu_C148_r )
650	627	{
651		return ReadWriteC148(space, offset, 0, 0);
	628	return readwrite_c148(space, offset, 0, 0);
652	629	}
653	630
654	631
655		static int GetPosIRQScanline( running_machine &machine )
	632	int namcos2_shared_state::get_posirq_scanline()
656	633	{
657		namcos2_shared_state *state = machine.driver_data<namcos2_shared_state>();
658		if (state->is_system21()) return 0;
659		return downcast<namcos2_state *>(state)->get_pos_irq_scanline();
	634	namcos2_state *s2state = machine().driver_data<namcos2_state>();
	635	if (is_system21()) return 0;
	636	return s2state->get_pos_irq_scanline();
660	637	}
661	638
662	639	TIMER_CALLBACK_MEMBER(namcos2_shared_state::namcos2_posirq_tick)
663	640	{
664	641	if (is_system21()) {
665		if (namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) {
	642	if (m_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) {
666	643	m_screen->update_partial(param);
667		machine().device("gpu")->execute().set_input_line(namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
	644	machine().device("gpu")->execute().set_input_line(m_68k_gpu_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
668	645	}
669	646	return;
670	647	}
671	648
672		if (namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ]|namcos2_68k_slave_C148[NAMCOS2_C148_POSIRQ]) {
	649	if (m_68k_master_C148[NAMCOS2_C148_POSIRQ]|m_68k_slave_C148[NAMCOS2_C148_POSIRQ]) {
673	650	m_screen->update_partial(param);
674		if (namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ]) m_maincpu->set_input_line(namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
675		if (namcos2_68k_slave_C148[NAMCOS2_C148_POSIRQ]) m_slave->set_input_line(namcos2_68k_slave_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
	651	if (m_68k_master_C148[NAMCOS2_C148_POSIRQ]) m_maincpu->set_input_line(m_68k_master_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
	652	if (m_68k_slave_C148[NAMCOS2_C148_POSIRQ]) m_slave->set_input_line(m_68k_slave_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
676	653	}
677	654	}
678	655
679	656	void namcos2_shared_state::adjust_posirq_timer( int scanline )
680	657	{
681		namcos2_posirq_timer->adjust(m_screen->time_until_pos(scanline, 80), scanline);
	658	m_posirq_timer->adjust(m_screen->time_until_pos(scanline, 80), scanline);
682	659	}
683	660
684	661	INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_master_vblank)
685	662	{
686		if (!is_system21()) adjust_posirq_timer(GetPosIRQScanline(machine()));
687		device.execute().set_input_line(namcos2_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
	663	if (!is_system21()) adjust_posirq_timer(get_posirq_scanline());
	664	device.execute().set_input_line(m_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
688	665	}
689	666
690	667	INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_slave_vblank)
691	668	{
692		if (!is_system21()) adjust_posirq_timer(GetPosIRQScanline(machine()));
693		device.execute().set_input_line(namcos2_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
	669	if (!is_system21()) adjust_posirq_timer(get_posirq_scanline());
	670	device.execute().set_input_line(m_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
694	671	}
695	672
696	673	INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_gpu_vblank)
697	674	{
698	675	/* only used by namcos21 */
699		int scanline = GetPosIRQScanline(machine());
	676	int scanline = get_posirq_scanline();
700	677	scanline = 0x50+0x89; /* HACK for Winning Run */
701	678
702		//printf( "namcos2_68k_gpu_vblank(%d)\n",namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ] );
	679	//printf( "namcos2_68k_gpu_vblank(%d)\n",m_68k_gpu_C148[NAMCOS2_C148_POSIRQ] );
703	680	adjust_posirq_timer(scanline);
704		device.execute().set_input_line(namcos2_68k_gpu_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
	681	device.execute().set_input_line(m_68k_gpu_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
705	682	}
706	683
707	684	/**************************************************************/
r32471	r32472
724	701
725	702	WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_ctrl_w )
726	703	{
727		namcos2_mcu_analog_ctrl = data & 0xff;
	704	m_mcu_analog_ctrl = data & 0xff;
728	705
729	706	/* Check if this is a start of conversion */
730	707	/* Input ports 2 through 9 are the analog channels */
r32471	r32472
732	709	if(data & 0x40)
733	710	{
734	711	/* Set the conversion complete flag */
735		namcos2_mcu_analog_complete = 2;
	712	m_mcu_analog_complete = 2;
736	713	/* We convert instantly, good eh! */
737	714	switch((data>>2) & 0x07)
738	715	{
739	716	case 0:
740		namcos2_mcu_analog_data=ioport("AN0")->read();
	717	m_mcu_analog_data=ioport("AN0")->read();
741	718	break;
742	719	case 1:
743		namcos2_mcu_analog_data=ioport("AN1")->read();
	720	m_mcu_analog_data=ioport("AN1")->read();
744	721	break;
745	722	case 2:
746		namcos2_mcu_analog_data=ioport("AN2")->read();
	723	m_mcu_analog_data=ioport("AN2")->read();
747	724	break;
748	725	case 3:
749		namcos2_mcu_analog_data=ioport("AN3")->read();
	726	m_mcu_analog_data=ioport("AN3")->read();
750	727	break;
751	728	case 4:
752		namcos2_mcu_analog_data=ioport("AN4")->read();
	729	m_mcu_analog_data=ioport("AN4")->read();
753	730	break;
754	731	case 5:
755		namcos2_mcu_analog_data=ioport("AN5")->read();
	732	m_mcu_analog_data=ioport("AN5")->read();
756	733	break;
757	734	case 6:
758		namcos2_mcu_analog_data=ioport("AN6")->read();
	735	m_mcu_analog_data=ioport("AN6")->read();
759	736	break;
760	737	case 7:
761		namcos2_mcu_analog_data=ioport("AN7")->read();
	738	m_mcu_analog_data=ioport("AN7")->read();
762	739	break;
763	740	default:
764	741	output_set_value("anunk",data);
r32471	r32472
769	746	if( m_gametype == NAMCOS2_DIRT_FOX ||
770	747	m_gametype == NAMCOS2_DIRT_FOX_JP )
771	748	{
772		namcos2_mcu_analog_data ^= 0x80;
	749	m_mcu_analog_data ^= 0x80;
773	750	}
774	751	#endif
775	752	/* If the interrupt enable bit is set trigger an A/D IRQ */
r32471	r32472
785	762	int data=0;
786	763
787	764	/* ADEF flag is only cleared AFTER a read from control THEN a read from DATA */
788		if(namcos2_mcu_analog_complete==2) namcos2_mcu_analog_complete=1;
789		if(namcos2_mcu_analog_complete) data|=0x80;
	765	if(m_mcu_analog_complete==2) m_mcu_analog_complete=1;
	766	if(m_mcu_analog_complete) data|=0x80;
790	767
791	768	/* Mask on the lower 6 register bits, Irq EN/Channel/Clock */
792		data|=namcos2_mcu_analog_ctrl&0x3f;
	769	data|=m_mcu_analog_ctrl&0x3f;
793	770	/* Return the value */
794	771	return data;
795	772	}
r32471	r32472
800	777
801	778	READ8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_port_r )
802	779	{
803		if(namcos2_mcu_analog_complete==1) namcos2_mcu_analog_complete=0;
804		return namcos2_mcu_analog_data;
	780	if(m_mcu_analog_complete==1) m_mcu_analog_complete=0;
	781	return m_mcu_analog_data;
805	782	}
806	783
807	784	WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_port_d_w )

trunk/src/mame/includes/namcos21.h

r32471	r32472
25	25	int slaveActive;
26	26	};
27	27
	28	struct vertex
	29	{
	30	double x,y;
	31	double z;
	32	};
	33
	34	struct edge
	35	{
	36	double x;
	37	double z;
	38	};
	39
	40
28	41	class namcos21_state : public namcos2_shared_state
29	42	{
30	43	public:
r32471	r32472
157	170	DECLARE_MACHINE_START(namcos21);
158	171	DECLARE_VIDEO_START(namcos21);
159	172	UINT32 screen_update_namcos21(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	173	void allocate_poly_framebuffer();
	174	void clear_poly_framebuffer();
	175	void copy_visible_poly_framebuffer(bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi);
	176	void renderscanline_flat(const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable);
	177	void rendertri(const vertex *v0, const vertex *v1, const vertex *v2, unsigned color, int depthcueenable);
	178	void draw_quad(int sx[4], int sy[4], int zcode[4], int color);
	179	INT32 read_pointrom_data(unsigned offset);
	180	void transmit_word_to_slave(UINT16 data);
	181	void transfer_dsp_data();
	182	UINT16 read_word_from_slave_input();
	183	size_t get_input_bytes_advertised_for_slave();
	184	int init_dsp();
	185	void render_slave_output(UINT16 data);
	186	void winrun_flush_poly();
	187	void init(int game_type);
160	188	};
161
162		/*----------- defined in video/namcos21.c -----------*/
163		extern void namcos21_ClearPolyFrameBuffer( running_machine &machine );
164		extern void namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4], int color );

trunk/src/mame/includes/namcos2.h

r32471	r32472
120	120	// game type helpers
121	121	bool is_system21();
122	122	int m_gametype;
	123
	124	emu_timer *m_posirq_timer;
	125	int m_mcu_analog_ctrl;
	126	int m_mcu_analog_data;
	127	int m_mcu_analog_complete;
	128	UINT8 *m_eeprom;
	129	UINT16  m_68k_master_C148[0x20];
	130	UINT16  m_68k_slave_C148[0x20];
	131	UINT16  m_68k_gpu_C148[0x20];
123	132
124	133	// C123 Tilemap Emulation
125	134	// TODO: merge with namcos1.c implementation and convert to device
r32471	r32472
210	219	INTERRUPT_GEN_MEMBER(namcos2_68k_gpu_vblank);
211	220	TIMER_CALLBACK_MEMBER(namcos2_posirq_tick);
212	221	void adjust_posirq_timer( int scanline );
	222	void init_c148();
	223	void reset_all_subcpus(int state);
	224	UINT16 readwrite_c148( address_space &space, offs_t offset, UINT16 data, int bWrite );
	225	int get_posirq_scanline();
213	226
214	227	DECLARE_WRITE8_MEMBER( namcos2_68k_eeprom_w );
215	228	DECLARE_READ8_MEMBER( namcos2_68k_eeprom_r );
r32471	r32472
338	351	tilemap_t *m_tilemap_roz;
339	352	UINT16 m_gfx_ctrl;
340	353	UINT16 m_serial_comms_ctrl[0x8];
	354	unsigned m_finallap_prot_count;
	355	int m_sendval;
341	356
342	357	optional_device<namco_c45_road_device> m_c45_road;
343	358

trunk/src/mame/video/namcos21.c

r32471	r32472
45	45	videoram[(offset+i)&0x7ffff] = color;
46	46	}
47	47	}
48		} /* winrun_gpu_videoram_w */
	48	}
49	49
50	50	READ16_MEMBER(namcos21_state::winrun_gpu_videoram_r)
51	51	{
52	52	UINT8 *videoram = m_videoram;
53	53	return videoram[offset]<<8;
54		} /* winrun_gpu_videoram_r */
	54	}
55	55
56		static void
57		AllocatePolyFrameBuffer( running_machine &machine )
	56	void namcos21_state::allocate_poly_framebuffer()
58	57	{
59		namcos21_state *state = machine.driver_data<namcos21_state>();
60		state->m_mpPolyFrameBufferZ     = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
61		state->m_mpPolyFrameBufferPens  = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
	58	m_mpPolyFrameBufferZ     = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
	59	m_mpPolyFrameBufferPens  = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
62	60
63		state->m_mpPolyFrameBufferZ2    = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
64		state->m_mpPolyFrameBufferPens2 = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
	61	m_mpPolyFrameBufferZ2    = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
	62	m_mpPolyFrameBufferPens2 = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
65	63
66		namcos21_ClearPolyFrameBuffer(machine);
67		namcos21_ClearPolyFrameBuffer(machine);
68		} /* AllocatePolyFrameBuffer */
	64	clear_poly_framebuffer();
	65	clear_poly_framebuffer();
	66	}
69	67
70		void
71		namcos21_ClearPolyFrameBuffer( running_machine &machine )
	68	void namcos21_state::clear_poly_framebuffer()
72	69	{
73		namcos21_state *state = machine.driver_data<namcos21_state>();
74		int i;
75	70	UINT16 *temp2;
76	71
77	72	/* swap work and visible framebuffers */
78		temp2 = state->m_mpPolyFrameBufferZ;
79		state->m_mpPolyFrameBufferZ = state->m_mpPolyFrameBufferZ2;
80		state->m_mpPolyFrameBufferZ2 = temp2;
	73	temp2 = m_mpPolyFrameBufferZ;
	74	m_mpPolyFrameBufferZ = m_mpPolyFrameBufferZ2;
	75	m_mpPolyFrameBufferZ2 = temp2;
81	76
82		temp2 = state->m_mpPolyFrameBufferPens;
83		state->m_mpPolyFrameBufferPens = state->m_mpPolyFrameBufferPens2;
84		state->m_mpPolyFrameBufferPens2 = temp2;
	77	temp2 = m_mpPolyFrameBufferPens;
	78	m_mpPolyFrameBufferPens = m_mpPolyFrameBufferPens2;
	79	m_mpPolyFrameBufferPens2 = temp2;
85	80
86	81	/* wipe work zbuffer */
87		for( i=0; i<NAMCOS21_POLY_FRAME_WIDTH*NAMCOS21_POLY_FRAME_HEIGHT; i++ )
	82	for( int i = 0; i < NAMCOS21_POLY_FRAME_WIDTH*NAMCOS21_POLY_FRAME_HEIGHT; i++ )
88	83	{
89		state->m_mpPolyFrameBufferZ[i] = 0x7fff;
	84	m_mpPolyFrameBufferZ[i] = 0x7fff;
90	85	}
91		} /* namcos21_ClearPolyFrameBuffer */
	86	}
92	87
93		static void
94		CopyVisiblePolyFrameBuffer( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi )
	88	void namcos21_state::copy_visible_poly_framebuffer(bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi)
95	89	{
96		namcos21_state *state = machine.driver_data<namcos21_state>(); /* blit the visible framebuffer */
	90	/* blit the visible framebuffer */
97	91	int sy;
98	92	for( sy=clip.min_y; sy<=clip.max_y; sy++ )
99	93	{
100	94	UINT16 *dest = &bitmap.pix16(sy);
101		const UINT16 *pPen = state->m_mpPolyFrameBufferPens2+NAMCOS21_POLY_FRAME_WIDTH*sy;
102		const UINT16 *pZ = state->m_mpPolyFrameBufferZ2+NAMCOS21_POLY_FRAME_WIDTH*sy;
	95	const UINT16 *pPen = m_mpPolyFrameBufferPens2+NAMCOS21_POLY_FRAME_WIDTH*sy;
	96	const UINT16 *pZ = m_mpPolyFrameBufferZ2+NAMCOS21_POLY_FRAME_WIDTH*sy;
103	97	int sx;
104	98	for( sx=clip.min_x; sx<=clip.max_x; sx++ )
105	99	{
r32471	r32472
111	105	}
112	106	}
113	107	}
114		} /* CopyVisiblePolyFrameBuffer */
	108	}
115	109
116	110	VIDEO_START_MEMBER(namcos21_state,namcos21)
117	111	{
r32471	r32472
119	113	{
120	114	m_videoram = auto_alloc_array(machine(), UINT8, 0x80000);
121	115	}
122		AllocatePolyFrameBuffer(machine());
	116	allocate_poly_framebuffer();
123	117	c355_obj_init(
124	118	0,      /* gfx bank */
125	119	0xf,    /* reverse palette mapping */
r32471	r32472
158	152	c355_obj_draw(screen, bitmap, cliprect, 14 );   //driver's eyes
159	153	}
160	154
161		CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0x7fc0, 0x7ffe );
	155	copy_visible_poly_framebuffer(bitmap, cliprect, 0x7fc0, 0x7ffe);
162	156
163	157	if( m_gametype != NAMCOS21_WINRUN91 )
164	158	{ /* draw low priority 2d sprites */
r32471	r32472
166	160	c355_obj_draw(screen, bitmap, cliprect, 1 );
167	161	}
168	162
169		CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0, 0x7fbf );
	163	copy_visible_poly_framebuffer(bitmap, cliprect, 0, 0x7fbf);
170	164
171	165
172	166	if( m_gametype != NAMCOS21_WINRUN91 )
r32471	r32472
211	205
212	206	/*********************************************************************************************/
213	207
214		struct vertex
215		{
216		double x,y;
217		double z;
218		};
219
220		struct edge
221		{
222		double x;
223		double z;
224		};
225
226	208	#define SWAP(T,A,B) { const T *temp = A; A = B; B = temp; }
227	209
228		static void
229		renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable )
	210	void namcos21_state::renderscanline_flat(const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable)
230	211	{
231	212	if( e1->x > e2->x )
232	213	{
r32471	r32472
234	215	}
235	216
236	217	{
237		UINT16 *pDest = state->m_mpPolyFrameBufferPens + sy*NAMCOS21_POLY_FRAME_WIDTH;
238		UINT16 *pZBuf = state->m_mpPolyFrameBufferZ    + sy*NAMCOS21_POLY_FRAME_WIDTH;
	218	UINT16 *pDest = m_mpPolyFrameBufferPens + sy*NAMCOS21_POLY_FRAME_WIDTH;
	219	UINT16 *pZBuf = m_mpPolyFrameBufferZ    + sy*NAMCOS21_POLY_FRAME_WIDTH;
239	220	int x0 = (int)e1->x;
240	221	int x1 = (int)e2->x;
241	222	int w = x1-x0;
r32471	r32472
264	245	if( depthcueenable && zz>0 )
265	246	{
266	247	int depth = 0;
267		if( state->m_gametype == NAMCOS21_WINRUN91 )
	248	if( m_gametype == NAMCOS21_WINRUN91 )
268	249	{
269	250	depth = (zz>>10)*0x100;
270	251	pen += depth;
271	252	}
272		else if( state->m_gametype == NAMCOS21_DRIVERS_EYES )
	253	else if( m_gametype == NAMCOS21_DRIVERS_EYES )
273	254	{
274	255	depth = (zz>>10)*0x100;
275	256	pen -= depth;
r32471	r32472
287	268	}
288	269	}
289	270	}
290		} /* renderscanline_flat */
	271	}
291	272
292		static void
293		rendertri(
294		namcos21_state *state,
295		const vertex *v0,
296		const vertex *v1,
297		const vertex *v2,
298		unsigned color,
299		int depthcueenable )
	273	void namcos21_state::rendertri(const vertex *v0, const vertex *v1, const vertex *v2, unsigned color, int depthcueenable)
300	274	{
301	275	int dy,ystart,yend,crop;
302	276
r32471	r32472
363	337
364	338	for( y=ystart; y<yend; y++ )
365	339	{
366		renderscanline_flat( state, &e1, &e2, y, color, depthcueenable );
	340	renderscanline_flat(&e1, &e2, y, color, depthcueenable);
367	341
368	342	e2.x += dx2dy;
369	343	e2.z += dz2dy;
r32471	r32472
397	371	}
398	372	for( y=ystart; y<yend; y++ )
399	373	{
400		renderscanline_flat( state, &e1, &e2, y, color, depthcueenable );
	374	renderscanline_flat(&e1, &e2, y, color, depthcueenable);
401	375
402	376	e2.x += dx2dy;
403	377	e2.z += dz2dy;
r32471	r32472
407	381	}
408	382	}
409	383	}
410		} /* rendertri */
	384	}
411	385
412		void
413		namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4], int color )
	386	void namcos21_state::draw_quad(int sx[4], int sy[4], int zcode[4], int color)
414	387	{
415		namcos21_state *state = machine.driver_data<namcos21_state>();
416	388	vertex a,b,c,d;
417	389	int depthcueenable = 1;
418	390	/*
r32471	r32472
421	393	0x4000..0x5fff  polygon palette bank1 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors)
422	394	0x6000..0x7fff  polygon palette bank2 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors)
423	395	*/
424		if( state->m_gametype == NAMCOS21_WINRUN91 )
	396	if( m_gametype == NAMCOS21_WINRUN91 )
425	397	{
426	398	color = 0x4000|(color&0xff);
427	399	}
428		else if ( state->m_gametype == NAMCOS21_DRIVERS_EYES )
	400	else if ( m_gametype == NAMCOS21_DRIVERS_EYES )
429	401	{
430	402	color = 0x3f00|(color&0xff);
431	403	}
r32471	r32472
465	437	d.y = sy[3];
466	438	d.z = zcode[3];
467	439
468		rendertri( state, &a, &b, &c, color, depthcueenable );
469		rendertri( state, &c, &d, &a, color, depthcueenable );
470		} /* namcos21_DrawQuad */
	440	rendertri(&a, &b, &c, color, depthcueenable);
	441	rendertri(&c, &d, &a, color, depthcueenable);
	442	}

trunk/src/mame/video/namcos2.c

r32471	r32472
7	7
8	8	static void
9	9	TilemapCB( running_machine &machine, UINT16 code, int *tile, int *mask )
	10	//void namcos2_shared_state::tilemap_cb(UINT16 code, int *tile, int *mask)
10	11	{
11	12	*mask = code;
12	13
r32471	r32472
23	24	*tile = (code&0x07ff)|((code&0xc000)>>3)|((code&0x3800)<<2);
24	25	break;
25	26	}
26		} /* TilemapCB */
	27	}
27	28
28	29	/**
29	30	* m_gfx_ctrl selects a bank of 128 sprites within spriteram
r32471	r32472
39	40	READ16_MEMBER( namcos2_state::gfx_ctrl_r )
40	41	{
41	42	return m_gfx_ctrl;
42		} /* namcos2_gfx_ctrl_r */
	43	}
43	44
44	45	WRITE16_MEMBER( namcos2_state::gfx_ctrl_w )
45	46	{
46	47	COMBINE_DATA(&m_gfx_ctrl);
47		} /* namcos2_gfx_ctrl_w */
	48	}
48	49
49	50	TILE_GET_INFO_MEMBER( namcos2_state::roz_tile_info )
50	51	{
51	52	int tile = m_rozram[tile_index];
52	53	SET_TILE_INFO_MEMBER(3,tile,0/*color*/,0);
53		} /* roz_tile_info */
	54	}
54	55
55		struct RozParam
	56	struct roz_param
56	57	{
57	58	UINT32 size;
58	59	UINT32 startx,starty;
r32471	r32472
62	63	};
63	64
64	65	INLINE void
65		DrawRozHelperBlock(const struct RozParam *rozInfo, int destx, int desty,
	66	draw_roz_helper_block(const struct roz_param *rozInfo, int destx, int desty,
66	67	int srcx, int srcy, int width, int height,
67	68	bitmap_ind16 &destbitmap, bitmap_ind8 &flagsbitmap,
68	69	bitmap_ind16 &srcbitmap, UINT32 size_mask)
r32471	r32472
109	110	dest += dest_rowinc;
110	111	desty++;
111	112	}
112		} /* DrawRozHelperBlock */
	113	}
113	114
114	115	static void
115		DrawRozHelper(
	116	draw_roz_helper(
116	117	screen_device &screen,
117	118	bitmap_ind16 &bitmap,
118	119	tilemap_t *tmap,
119	120	const rectangle &clip,
120		const struct RozParam *rozInfo )
	121	const struct roz_param *rozInfo )
121	122	{
122	123	tmap->set_palette_offset(rozInfo->color );
123	124
r32471	r32472
186	187	// Do the block columns
187	188	for (j = 0; j < column_block_count; j++)
188	189	{
189		DrawRozHelperBlock(rozInfo, dx, desty, sx, sy, ROZ_BLOCK_SIZE,
	190	draw_roz_helper_block(rozInfo, dx, desty, sx, sy, ROZ_BLOCK_SIZE,
190	191	ROZ_BLOCK_SIZE, bitmap, flagsbitmap, srcbitmap, size_mask);
191	192	// Increment to the next block column
192	193	sx += row_block_size_incxx;
r32471	r32472
196	197	// Do the extra columns
197	198	if (column_extra_count)
198	199	{
199		DrawRozHelperBlock(rozInfo, dx, desty, sx, sy, column_extra_count,
	200	draw_roz_helper_block(rozInfo, dx, desty, sx, sy, column_extra_count,
200	201	ROZ_BLOCK_SIZE, bitmap, flagsbitmap, srcbitmap, size_mask);
201	202	}
202	203	// Increment to the next row block
r32471	r32472
210	211	// Do the block columns
211	212	for (i = 0; i < column_block_count; i++)
212	213	{
213		DrawRozHelperBlock(rozInfo, destx, desty, srcx, srcy, ROZ_BLOCK_SIZE,
	214	draw_roz_helper_block(rozInfo, destx, desty, srcx, srcy, ROZ_BLOCK_SIZE,
214	215	row_extra_count, bitmap, flagsbitmap, srcbitmap, size_mask);
215	216	srcx += row_block_size_incxx;
216	217	srcy += row_block_size_incxy;
r32471	r32472
219	220	// Do the extra columns
220	221	if (column_extra_count)
221	222	{
222		DrawRozHelperBlock(rozInfo, destx, desty, srcx, srcy, column_extra_count,
	223	draw_roz_helper_block(rozInfo, destx, desty, srcx, srcy, column_extra_count,
223	224	row_extra_count, bitmap, flagsbitmap, srcbitmap, size_mask);
224	225	}
225	226	}
r32471	r32472
233	234	rozInfo->incyx, rozInfo->incyy,
234	235	rozInfo->wrap,0,0); // wrap, flags, pri
235	236	}
236		} /* DrawRozHelper */
	237	}
237	238
238	239	void namcos2_state::draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
239	240	{
240	241	const int xoffset = 38,yoffset = 0;
241		struct RozParam rozParam;
	242	struct roz_param rozParam;
242	243
243	244	rozParam.color = (m_gfx_ctrl & 0x0f00);
244	245	rozParam.incxx  = (INT16)m_roz_ctrl[0];
r32471	r32472
282	283	rozParam.incyx<<=8;
283	284	rozParam.incyy<<=8;
284	285
285		DrawRozHelper( screen, bitmap, m_tilemap_roz, cliprect, &rozParam );
	286	draw_roz_helper( screen, bitmap, m_tilemap_roz, cliprect, &rozParam );
286	287	}
287	288
288	289	WRITE16_MEMBER( namcos2_state::rozram_word_w )
r32471	r32472
314	315	if (offset > 0x180b) return 0xff;
315	316	}
316	317	return m_paletteram[offset];
317		} /* namcos2_68k_video_palette_r */
	318	}
318	319
319	320	WRITE16_MEMBER( namcos2_state::paletteram_word_w )
320	321	{
r32471	r32472
361	362	{
362	363	COMBINE_DATA(&m_paletteram[offset]);
363	364	}
364		} /* namcos2_68k_video_palette_w */
	365	}
365	366
366	367
367	368	inline void
r32471	r32472
382	383	offset++;
383	384	}
384	385	}
385		} /* update_palette */
	386	}
386	387
387	388	/**************************************************************************/
388	389
r32471	r32472
413	414	clip.max_y = get_palette_register(3) - 0x21 - 1;
414	415	/* intersect with master clip rectangle */
415	416	clip &= cliprect;
416		} /* apply_clip */
	417	}
417	418
418	419	UINT32 namcos2_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
419	420	{
r32471	r32472
482	483	{
483	484	c169_roz_init(1, "gfx5");
484	485	}
485		} /* luckywld */
	486	}
486	487
487	488	UINT32 namcos2_state::screen_update_luckywld(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
488	489	{

trunk/src/mame/drivers/namcos21.c

r32471	r32472
309	309	#define ENABLE_LOGGING      0
310	310
311	311
312		static INT32
313		ReadPointROMData( running_machine &machine, unsigned offset )
	312	INT32 namcos21_state::read_pointrom_data(unsigned offset)
314	313	{
315		const INT32 *pPointData = (INT32 *)machine.root_device().memregion( "user2" )->base();
	314	const INT32 *pPointData = (INT32 *)memregion( "user2" )->base();
316	315	INT32 result = pPointData[offset];
317	316	return result;
318	317	}
r32471	r32472
378	377	return result;
379	378	}
380	379
381		static void
382		TransmitWordToSlave( namcos21_state *state, UINT16 data )
	380	void namcos21_state::transmit_word_to_slave(UINT16 data)
383	381	{
384		unsigned offs = state->m_mpDspState->slaveInputStart+state->m_mpDspState->slaveBytesAvailable++;
385		state->m_mpDspState->slaveInputBuffer[offs%DSP_BUF_MAX] = data;
386		if (ENABLE_LOGGING) logerror( "+%04x(#%04x)\n", data, state->m_mpDspState->slaveBytesAvailable );
387		state->m_mpDspState->slaveActive = 1;
388		if( state->m_mpDspState->slaveBytesAvailable >= DSP_BUF_MAX )
	382	unsigned offs = m_mpDspState->slaveInputStart+m_mpDspState->slaveBytesAvailable++;
	383	m_mpDspState->slaveInputBuffer[offs%DSP_BUF_MAX] = data;
	384	if (ENABLE_LOGGING) logerror( "+%04x(#%04x)\n", data, m_mpDspState->slaveBytesAvailable );
	385	m_mpDspState->slaveActive = 1;
	386	if( m_mpDspState->slaveBytesAvailable >= DSP_BUF_MAX )
389	387	{
390	388	logerror( "IDC overflow\n" );
391	389	exit(1);
392	390	}
393		} /* TransmitWordToSlave */
	391	}
394	392
395		static void
396		TransferDspData( running_machine &machine )
	393	void namcos21_state::transfer_dsp_data()
397	394	{
398		namcos21_state *state = machine.driver_data<namcos21_state>();
399		UINT16 addr = state->m_mpDspState->masterSourceAddr;
	395	UINT16 addr = m_mpDspState->masterSourceAddr;
400	396	int mode = addr&0x8000;
401	397	addr&=0x7fff;
402	398	if( addr )
r32471	r32472
405	401	{
406	402	int i;
407	403	UINT16 old = addr;
408		UINT16 code = state->m_dspram16[addr++];
	404	UINT16 code = m_dspram16[addr++];
409	405	if( code == 0xffff )
410	406	{
411	407	if( mode )
412	408	{
413		addr = state->m_dspram16[addr];
414		state->m_mpDspState->masterSourceAddr = addr;
	409	addr = m_dspram16[addr];
	410	m_mpDspState->masterSourceAddr = addr;
415	411	if (ENABLE_LOGGING) logerror( "LOOP:0x%04x\n", addr );
416	412	addr&=0x7fff;
417	413	if( old==addr )
r32471	r32472
421	417	}
422	418	else
423	419	{
424		state->m_mpDspState->masterSourceAddr = 0;
	420	m_mpDspState->masterSourceAddr = 0;
425	421	return;
426	422	}
427	423	}
428	424	else if( mode==0 )
429	425	{ /* direct data transfer */
430	426	if (ENABLE_LOGGING) logerror( "DATA TFR(0x%x)\n", code );
431		TransmitWordToSlave( state, code );
	427	transmit_word_to_slave(code);
432	428	for( i=0; i<code; i++ )
433	429	{
434		UINT16 data = state->m_dspram16[addr++];
435		TransmitWordToSlave( state, data );
	430	UINT16 data = m_dspram16[addr++];
	431	transmit_word_to_slave(data);
436	432	}
437	433	}
438	434	else if( code==0x18 || code==0x1a )
439	435	{
440	436	if (ENABLE_LOGGING) logerror( "HEADER TFR(0x%x)\n", code );
441		TransmitWordToSlave( state, code+1 );
	437	transmit_word_to_slave(code+1);
442	438	for( i=0; i<code; i++ )
443	439	{
444		UINT16 data = state->m_dspram16[addr++];
445		TransmitWordToSlave( state, data );
	440	UINT16 data = m_dspram16[addr++];
	441	transmit_word_to_slave(data);
446	442	}
447	443	}
448	444	else
449	445	{
450		INT32 masterAddr = ReadPointROMData(machine, code);
	446	INT32 masterAddr = read_pointrom_data(code);
451	447	if (ENABLE_LOGGING) logerror( "OBJ TFR(0x%x)\n", code );
452	448	{
453		UINT16 len = state->m_dspram16[addr++];
	449	UINT16 len = m_dspram16[addr++];
454	450	for(;;)
455	451	{
456		int subAddr = ReadPointROMData(machine, masterAddr++);
	452	int subAddr = read_pointrom_data(masterAddr++);
457	453	if( subAddr==0xffffff )
458	454	{
459	455	break;
460	456	}
461	457	else
462	458	{
463		int primWords = (UINT16)ReadPointROMData(machine, subAddr++);
	459	int primWords = (UINT16)read_pointrom_data(subAddr++);
464	460	if( primWords>2 )
465	461	{
466		TransmitWordToSlave( state, 0 ); /* pad1 */
467		TransmitWordToSlave( state, len+1 );
	462	transmit_word_to_slave(0); /* pad1 */
	463	transmit_word_to_slave(len+1);
468	464	for( i=0; i<len; i++ )
469	465	{ /* transform */
470		TransmitWordToSlave( state, state->m_dspram16[addr+i] );
	466	transmit_word_to_slave(m_dspram16[addr+i]);
471	467	}
472		TransmitWordToSlave( state, 0 ); /* pad2 */
473		TransmitWordToSlave( state, primWords+1 );
	468	transmit_word_to_slave(0); /* pad2 */
	469	transmit_word_to_slave(primWords+1);
474	470	for( i=0; i<primWords; i++ )
475	471	{
476		TransmitWordToSlave( state, (UINT16)ReadPointROMData(machine, subAddr+i) );
	472	transmit_word_to_slave((UINT16)read_pointrom_data(subAddr+i));
477	473	}
478	474	}
479	475	else
r32471	r32472
487	483	}
488	484	} /* for(;;) */
489	485	}
490		} /* TransferDspData */
	486	}
491	487
492	488
493	489
494		void
495		namcos21_kickstart( running_machine &machine, int internal )
	490	void namcos21_kickstart(running_machine &machine, int internal)
496	491	{
497	492	namcos21_state *state = machine.driver_data<namcos21_state>();
	493
498	494	/* patch dsp watchdog */
499	495	switch( state->m_gametype )
500	496	{
501		case NAMCOS21_AIRCOMBAT:
502		state->m_master_dsp_code[0x008e] = 0x808f;
503		break;
504		case NAMCOS21_SOLVALOU:
505		state->m_master_dsp_code[0x008b] = 0x808c;
506		break;
507		default:
508		break;
	497	case NAMCOS21_AIRCOMBAT:
	498	state->m_master_dsp_code[0x008e] = 0x808f;
	499	break;
	500	case NAMCOS21_SOLVALOU:
	501	state->m_master_dsp_code[0x008b] = 0x808c;
	502	break;
	503	default:
	504	break;
509	505	}
510	506	if( internal )
511	507	{
512	508	if( state->m_mbNeedsKickstart==0 ) return;
513		state->m_mbNeedsKickstart--;
	509	state->m_mbNeedsKickstart--;
514	510	if( state->m_mbNeedsKickstart ) return;
515	511	}
516	512
517		namcos21_ClearPolyFrameBuffer(machine);
	513	state->clear_poly_framebuffer();
518	514	state->m_mpDspState->masterSourceAddr = 0;
519	515	state->m_mpDspState->slaveOutputSize = 0;
520	516	state->m_mpDspState->masterFinished = 0;
r32471	r32472
523	519	state->m_dspslave->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
524	520	}
525	521
526		static UINT16
527		ReadWordFromSlaveInput( address_space &space )
	522	UINT16 namcos21_state::read_word_from_slave_input()
528	523	{
529		namcos21_state *state = space.machine().driver_data<namcos21_state>();
530	524	UINT16 data = 0;
531		if( state->m_mpDspState->slaveBytesAvailable>0 )
	525	if( m_mpDspState->slaveBytesAvailable>0 )
532	526	{
533		data = state->m_mpDspState->slaveInputBuffer[state->m_mpDspState->slaveInputStart++];
534		state->m_mpDspState->slaveInputStart %= DSP_BUF_MAX;
535		state->m_mpDspState->slaveBytesAvailable--;
536		if( state->m_mpDspState->slaveBytesAdvertised>0 )
	527	data = m_mpDspState->slaveInputBuffer[m_mpDspState->slaveInputStart++];
	528	m_mpDspState->slaveInputStart %= DSP_BUF_MAX;
	529	m_mpDspState->slaveBytesAvailable--;
	530	if( m_mpDspState->slaveBytesAdvertised>0 )
537	531	{
538		state->m_mpDspState->slaveBytesAdvertised--;
	532	m_mpDspState->slaveBytesAdvertised--;
539	533	}
540		if (ENABLE_LOGGING) logerror( "%s:-%04x(0x%04x)\n", space.machine().describe_context(), data, state->m_mpDspState->slaveBytesAvailable );
	534	if (ENABLE_LOGGING) logerror( "%s:-%04x(0x%04x)\n", machine().describe_context(), data, m_mpDspState->slaveBytesAvailable );
541	535	}
542	536	return data;
543		} /* ReadWordFromSlaveInput */
	537	}
544	538
545		static size_t
546		GetInputBytesAdvertisedForSlave( running_machine &machine )
	539	size_t namcos21_state::get_input_bytes_advertised_for_slave()
547	540	{
548		namcos21_state *state = machine.driver_data<namcos21_state>();
549		if( state->m_mpDspState->slaveBytesAdvertised < state->m_mpDspState->slaveBytesAvailable )
	541	if( m_mpDspState->slaveBytesAdvertised < m_mpDspState->slaveBytesAvailable )
550	542	{
551		state->m_mpDspState->slaveBytesAdvertised++;
	543	m_mpDspState->slaveBytesAdvertised++;
552	544	}
553		else if( state->m_mpDspState->slaveActive && state->m_mpDspState->masterFinished && state->m_mpDspState->masterSourceAddr )
	545	else if( m_mpDspState->slaveActive && m_mpDspState->masterFinished && m_mpDspState->masterSourceAddr )
554	546	{
555		namcos21_kickstart(machine, 0);
	547	namcos21_kickstart(machine(), 0);
556	548	}
557		return state->m_mpDspState->slaveBytesAdvertised;
558		} /* GetInputBytesAdvertisedForSlave */
	549	return m_mpDspState->slaveBytesAdvertised;
	550	}
559	551
560	552	READ16_MEMBER(namcos21_state::dspram16_r)
561	553	{
562	554	return m_dspram16[offset];
563		} /* dspram16_r */
	555	}
564	556
565	557	WRITE16_MEMBER(namcos21_state::dspram16_w)
566	558	{
r32471	r32472
572	564	offset == 1+(m_mpDspState->masterSourceAddr&0x7fff) )
573	565	{
574	566	if (ENABLE_LOGGING) logerror( "IDC-CONTINUE\n" );
575		TransferDspData(machine());
	567	transfer_dsp_data();
576	568	}
577	569	else if (m_gametype == NAMCOS21_SOLVALOU &&
578	570	offset == 0x103 &&
r32471	r32472
581	573	space.device().execute().yield();
582	574	}
583	575	}
584		} /* dspram16_w */
	576	}
585	577
586	578	/************************************************************************************/
587	579
588		static int
589		InitDSP( running_machine &machine )
	580	int namcos21_state::init_dsp()
590	581	{
591		namcos21_state *state = machine.driver_data<namcos21_state>();
592		UINT16 *pMem = (UINT16 *)state->memregion("dspmaster")->base();
	582	UINT16 *pMem = (UINT16 *)memregion("dspmaster")->base();
593	583	/**
594	584	* DSP BIOS tests "CPU ID" on startup
595	585	* "JAPAN (C)1990 NAMCO LTD. by H.F "
r32471	r32472
598	588	pMem[0x8000] = 0xFF80;
599	589	pMem[0x8001] = 0x0000;
600	590
601		state->m_mpDspState = auto_alloc_clear(machine, dsp_state);
	591	m_mpDspState = auto_alloc_clear(machine(), dsp_state);
602	592
603	593	return 0;
604	594	}
r32471	r32472
609	599
610	600	READ16_MEMBER(namcos21_state::dsp_port0_r)
611	601	{
612		INT32 data = ReadPointROMData(machine(), m_pointrom_idx++);
	602	INT32 data = read_pointrom_data(m_pointrom_idx++);
613	603	m_mPointRomMSB = (UINT8)(data>>16);
614	604	m_mbPointRomDataAvailable = 1;
615	605	return (UINT16)data;
616		} /* dsp_port0_r */
	606	}
617	607
618	608	WRITE16_MEMBER(namcos21_state::dsp_port0_w)
619	609	{ /* unused? */
620	610	if (ENABLE_LOGGING) logerror( "PTRAM_LO(0x%04x)\n", data );
621		} /* dsp_port0_w */
	611	}
622	612
623	613	READ16_MEMBER(namcos21_state::dsp_port1_r)
624	614	{
r32471	r32472
628	618	return m_mPointRomMSB;
629	619	}
630	620	return 0x8000; /* IDC ack? */
631		} /* dsp_port1_r */
	621	}
632	622
633	623	WRITE16_MEMBER(namcos21_state::dsp_port1_w)
634	624	{ /* unused? */
635	625	if (ENABLE_LOGGING) logerror( "PTRAM_HI(0x%04x)\n", data );
636		} /* dsp_port1_w */
	626	}
637	627
638	628	READ16_MEMBER(namcos21_state::dsp_port2_r)
639	629	{ /* IDC TRANSMIT ENABLE? */
640	630	return 0;
641		} /* dsp_port2_r */
	631	}
642	632
643	633	WRITE16_MEMBER(namcos21_state::dsp_port2_w)
644	634	{
645	635	if (ENABLE_LOGGING) logerror( "IDC ADDR INIT(0x%04x)\n", data );
646	636	m_mpDspState->masterSourceAddr = data;
647		TransferDspData(machine());
648		} /* dsp_port2_w */
	637	transfer_dsp_data();
	638	}
649	639
650	640	READ16_MEMBER(namcos21_state::dsp_port3_idc_rcv_enable_r)
651	641	{ /* IDC RECEIVE ENABLE? */
652	642	return 0;
653		} /* dsp_port3_idc_rcv_enable_r */
	643	}
654	644
655	645	WRITE16_MEMBER(namcos21_state::dsp_port3_w)
656	646	{
657	647	m_pointrom_idx<<=16;
658	648	m_pointrom_idx|=data;
659		} /* dsp_port3_w */
	649	}
660	650
661	651	WRITE16_MEMBER(namcos21_state::dsp_port4_w)
662	652	{ /* receives $0B<<4 prior to IDC setup */
663		} /* dsp_port4_w */
	653	}
664	654
665	655	READ16_MEMBER(namcos21_state::dsp_port8_r)
666	656	{ /* SMU status */
667	657	return 1;
668		} /* dsp_port8_r */
	658	}
669	659
670	660
671	661	WRITE16_MEMBER(namcos21_state::dsp_port8_w)
r32471	r32472
676	666	m_mpDspState->masterFinished = 1;
677	667	}
678	668	m_irq_enable = data;
679		} /* dsp_port8_w */
	669	}
680	670
681	671	READ16_MEMBER(namcos21_state::dsp_port9_r)
682	672	{ /* render-device-busy; used for direct-draw */
683	673	return 0;
684		} /* dsp_port9_r */
	674	}
685	675
686	676	READ16_MEMBER(namcos21_state::dsp_porta_r)
687	677	{ /* config */
688	678	return 0;
689		} /* dsp_porta_r */
	679	}
690	680
691	681	WRITE16_MEMBER(namcos21_state::dsp_porta_w)
692	682	{
r32471	r32472
696	686	/* direct-draw begin: 0 */
697	687	/* INT1 begin: 1 */
698	688	//  if (ENABLE_LOGGING) logerror( "dsp_porta_w(0x%04x)\n", data );
699		} /* dsp_porta_w */
	689	}
700	690
701	691	READ16_MEMBER(namcos21_state::dsp_portb_r)
702	692	{ /* config */
703	693	return 1;
704		} /* dsp_portb_r */
	694	}
705	695
706	696	WRITE16_MEMBER(namcos21_state::dsp_portb_w)
707	697	{
r32471	r32472
722	712	}
723	713	if( color&0x8000 )
724	714	{
725		namcos21_DrawQuad( machine(), sx, sy, zcode, color );
	715	draw_quad(sx, sy, zcode, color);
726	716	}
727	717	else
728	718	{
r32471	r32472
734	724	logerror( "unexpected masterDirectDrawSize=%d!\n",m_mpDspState->masterDirectDrawSize );
735	725	}
736	726	m_mpDspState->masterDirectDrawSize = 0;
737		} /* dsp_portb_w */
	727	}
738	728
739	729	WRITE16_MEMBER(namcos21_state::dsp_portc_w)
740	730	{
r32471	r32472
746	736	{
747	737	logerror( "portc overflow\n" );
748	738	}
749		} /* dsp_portc_w */
	739	}
750	740
751	741	READ16_MEMBER(namcos21_state::dsp_portf_r)
752	742	{ /* informs BIOS that this is Master DSP */
753	743	return 0;
754		} /* dsp_portf_r */
	744	}
755	745
756	746	WRITE16_MEMBER(namcos21_state::dsp_xf_w)
757	747	{
r32471	r32472
787	777
788	778	/************************************************************************************/
789	779
790		static void
791		RenderSlaveOutput( running_machine &machine, UINT16 data )
	780	void namcos21_state::render_slave_output(UINT16 data)
792	781	{
793		namcos21_state *state = machine.driver_data<namcos21_state>();
794		if( state->m_mpDspState->slaveOutputSize >= 4096 )
	782	if( m_mpDspState->slaveOutputSize >= 4096 )
795	783	{
796		fatalerror( "FATAL ERROR: SLAVE OVERFLOW (0x%x)\n",state->m_mpDspState->slaveOutputBuffer[0]  );
	784	fatalerror( "FATAL ERROR: SLAVE OVERFLOW (0x%x)\n",m_mpDspState->slaveOutputBuffer[0]  );
797	785	}
798	786
799	787	/* append word to slave output buffer */
800		state->m_mpDspState->slaveOutputBuffer[state->m_mpDspState->slaveOutputSize++] = data;
	788	m_mpDspState->slaveOutputBuffer[m_mpDspState->slaveOutputSize++] = data;
801	789
802	790	{
803		UINT16 *pSource = state->m_mpDspState->slaveOutputBuffer;
	791	UINT16 *pSource = m_mpDspState->slaveOutputBuffer;
804	792	UINT16 count = *pSource++;
805		if( count && state->m_mpDspState->slaveOutputSize > count )
	793	if( count && m_mpDspState->slaveOutputSize > count )
806	794	{
807	795	UINT16 color = *pSource++;
808	796	int sx[4], sy[4],zcode[4];
r32471	r32472
816	804	sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[3*j+1];
817	805	zcode[j] = pSource[3*j+2];
818	806	}
819		namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
	807	draw_quad(sx, sy, zcode, color&0x7fff);
820	808	}
821	809	else
822	810	{
823	811	int quad_idx = color*6;
824	812	for(;;)
825	813	{
826		UINT8 code = state->m_pointram[quad_idx++];
827		color = state->m_pointram[quad_idx++]|(code<<8);
	814	UINT8 code = m_pointram[quad_idx++];
	815	color = m_pointram[quad_idx++]|(code<<8);
828	816	for( j=0; j<4; j++ )
829	817	{
830		UINT8 vi = state->m_pointram[quad_idx++];
	818	UINT8 vi = m_pointram[quad_idx++];
831	819	sx[j] = NAMCOS21_POLY_FRAME_WIDTH/2  + (INT16)pSource[vi*3+0];
832	820	sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1];
833	821	zcode[j] = pSource[vi*3+2];
834	822	}
835		namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
	823	draw_quad(sx, sy, zcode, color&0x7fff);
836	824	if( code&0x80 )
837	825	{ /* end-of-quadlist marker */
838	826	break;
839	827	}
840	828	}
841	829	}
842		state->m_mpDspState->slaveOutputSize = 0;
	830	m_mpDspState->slaveOutputSize = 0;
843	831	}
844	832	else if( count==0 )
845	833	{
r32471	r32472
847	835	exit(1);
848	836	}
849	837	}
850		} /* RenderSlaveOutput */
	838	}
851	839
852	840	READ16_MEMBER(namcos21_state::slave_port0_r)
853	841	{
854		return ReadWordFromSlaveInput(space);
855		} /* slave_port0_r */
	842	return read_word_from_slave_input();
	843	}
856	844
857	845	WRITE16_MEMBER(namcos21_state::slave_port0_w)
858	846	{
859		RenderSlaveOutput( machine(), data );
	847	render_slave_output(data);
860	848	}
861	849
862	850	READ16_MEMBER(namcos21_state::slave_port2_r)
863	851	{
864		return GetInputBytesAdvertisedForSlave(machine());
865		} /* slave_port2_r */
	852	return get_input_bytes_advertised_for_slave();
	853	}
866	854
867	855	READ16_MEMBER(namcos21_state::slave_port3_r)
868	856	{ /* render-device queue size */
r32471	r32472
874	862
875	863	WRITE16_MEMBER(namcos21_state::slave_port3_w)
876	864	{ /* 0=busy, 1=ready? */
877		} /* slave_port3_w */
	865	}
878	866
879	867	WRITE16_MEMBER(namcos21_state::slave_XF_output_w)
880	868	{
881	869	if (ENABLE_LOGGING) logerror( "0x%x:slaveXF(%d)\n", space.device().safe_pc(), data );
882		} /* slave_XF_output_w */
	870	}
883	871
884	872	READ16_MEMBER(namcos21_state::slave_portf_r)
885	873	{ /* informs BIOS that this is Slave DSP */
r32471	r32472
957	945	logerror( "\n" );
958	946	#endif
959	947	m_pointram_idx = 0; /* HACK */
960		} /* pointram_control_w */
	948	}
961	949
962	950	READ16_MEMBER(namcos21_state::pointram_data_r)
963	951	{
964	952	return m_pointram[m_pointram_idx];
965		} /* pointram_data_r */
	953	}
966	954
967	955	WRITE16_MEMBER(namcos21_state::pointram_data_w)
968	956	{
r32471	r32472
973	961	m_pointram[m_pointram_idx++] = data;
974	962	m_pointram_idx &= (PTRAM_SIZE-1);
975	963	}
976		} /* pointram_data_w */
	964	}
977	965
978	966
979	967	READ16_MEMBER(namcos21_state::namcos21_depthcue_r)
r32471	r32472
1123	1111	break;
1124	1112	}
1125	1113	return 0;
1126		} /* winrun_cuskey_r */
	1114	}
1127	1115
1128	1116	WRITE16_MEMBER(namcos21_state::winrun_cuskey_w)
1129	1117	{
1130		} /* winrun_cuskey_w */
	1118	}
1131	1119
1132		static void
1133		winrun_flushpoly( running_machine &machine )
	1120	void namcos21_state::winrun_flush_poly()
1134	1121	{
1135		namcos21_state *state = machine.driver_data<namcos21_state>();
1136		if( state->m_winrun_poly_index>0 )
	1122	if( m_winrun_poly_index>0 )
1137	1123	{
1138		const UINT16 *pSource = state->m_winrun_poly_buf;
	1124	const UINT16 *pSource = m_winrun_poly_buf;
1139	1125	UINT16 color;
1140	1126	int sx[4], sy[4], zcode[4];
1141	1127	int j;
r32471	r32472
1148	1134	sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)*pSource++;
1149	1135	zcode[j] = *pSource++;
1150	1136	}
1151		namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
	1137	draw_quad(sx, sy, zcode, color&0x7fff);
1152	1138	}
1153	1139	else
1154	1140	{
1155	1141	int quad_idx = color*6;
1156	1142	for(;;)
1157	1143	{
1158		UINT8 code = state->m_pointram[quad_idx++];
1159		color = state->m_pointram[quad_idx++];
	1144	UINT8 code = m_pointram[quad_idx++];
	1145	color = m_pointram[quad_idx++];
1160	1146	for( j=0; j<4; j++ )
1161	1147	{
1162		UINT8 vi = state->m_pointram[quad_idx++];
	1148	UINT8 vi = m_pointram[quad_idx++];
1163	1149	sx[j] = NAMCOS21_POLY_FRAME_WIDTH/2  + (INT16)pSource[vi*3+0];
1164	1150	sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1];
1165	1151	zcode[j] = pSource[vi*3+2];
1166	1152	}
1167		namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
	1153	draw_quad(sx, sy, zcode, color&0x7fff);
1168	1154	if( code&0x80 )
1169	1155	{ /* end-of-quadlist marker */
1170	1156	break;
1171	1157	}
1172	1158	}
1173	1159	}
1174		state->m_winrun_poly_index = 0;
	1160	m_winrun_poly_index = 0;
1175	1161	}
1176	1162	} /* winrun_flushpoly */
1177	1163
1178	1164	READ16_MEMBER(namcos21_state::winrun_poly_reset_r)
1179	1165	{
1180		winrun_flushpoly(machine());
	1166	winrun_flush_poly();
1181	1167	return 0;
1182	1168	}
1183	1169
r32471	r32472
1191	1177	{
1192	1178	logerror( "WINRUN_POLY_OVERFLOW\n" );
1193	1179	}
1194		} /* winrun_dsp_render_w */
	1180	}
1195	1181
1196	1182	WRITE16_MEMBER(namcos21_state::winrun_dsp_pointrom_addr_w)
1197	1183	{
r32471	r32472
1209	1195	{
1210	1196	UINT16 *ptrom = (UINT16 *)memregion("user2")->base();
1211	1197	return ptrom[m_winrun_pointrom_addr++];
1212		} /* winrun_dsp_pointrom_data_r */
	1198	}
1213	1199
1214	1200	WRITE16_MEMBER(namcos21_state::winrun_dsp_complete_w)
1215	1201	{
1216	1202	if( data )
1217	1203	{
1218		winrun_flushpoly(machine());
	1204	winrun_flush_poly();
1219	1205	m_dsp->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
1220		namcos21_ClearPolyFrameBuffer(machine());
	1206	clear_poly_framebuffer();
1221	1207	}
1222	1208	}
1223	1209
r32471	r32472
1271	1257	memcpy( mem, m_winrun_dspbios, 0x2000 );
1272	1258	m_winrun_dsp_alive = 1;
1273	1259	}
1274		} /* winrun_dspbios_w */
	1260	}
1275	1261
1276	1262	//380000 : read : dsp status? 1 = busy
1277	1263	//380000 : write(0x01) - done before dsp comram init
r32471	r32472
2254	2240	ROM_LOAD("r911-avo3.11e", 0x180000, 0x80000,CRC(76e22f92) SHA1(0e1b8d35a5b9c20cc3192d935f0c9da1e69679d2) )
2255	2241	ROM_END
2256	2242
2257		static void namcos21_init( running_machine &machine, int game_type )
	2243	void namcos21_state::init(int game_type)
2258	2244	{
2259		namcos21_state *state = machine.driver_data<namcos21_state>();
2260		state->m_gametype = game_type;
2261		state->m_pointram = auto_alloc_array(machine, UINT8, PTRAM_SIZE);
2262		state->m_mpDataROM = (UINT16 *)state->memregion( "user1" )->base();
2263		InitDSP(machine);
2264		state->m_mbNeedsKickstart = 20;
	2245	m_gametype = game_type;
	2246	m_pointram = auto_alloc_array(machine(), UINT8, PTRAM_SIZE);
	2247	m_mpDataROM = (UINT16 *)memregion( "user1" )->base();
	2248	init_dsp();
	2249	m_mbNeedsKickstart = 20;
2265	2250	if( game_type==NAMCOS21_CYBERSLED )
2266	2251	{
2267		state->m_mbNeedsKickstart = 200;
	2252	m_mbNeedsKickstart = 200;
2268	2253	}
2269		} /* namcos21_init */
	2254	}
2270	2255
2271	2256	DRIVER_INIT_MEMBER(namcos21_state,winrun)
2272	2257	{
r32471	r32472
2286	2271
2287	2272	DRIVER_INIT_MEMBER(namcos21_state,aircomb)
2288	2273	{
2289		namcos21_init( machine(), NAMCOS21_AIRCOMBAT );
	2274	init(NAMCOS21_AIRCOMBAT);
2290	2275	}
2291	2276
2292	2277	DRIVER_INIT_MEMBER(namcos21_state,starblad)
2293	2278	{
2294		namcos21_init( machine(), NAMCOS21_STARBLADE );
	2279	init(NAMCOS21_STARBLADE);
2295	2280	}
2296	2281
2297	2282
2298	2283	DRIVER_INIT_MEMBER(namcos21_state,cybsled)
2299	2284	{
2300		namcos21_init( machine(), NAMCOS21_CYBERSLED );
	2285	init(NAMCOS21_CYBERSLED);
2301	2286	}
2302	2287
2303	2288	DRIVER_INIT_MEMBER(namcos21_state,solvalou)
r32471	r32472
2308	2293	mem[0x20cf4/2+1] = 0x4e71;
2309	2294	mem[0x20cf4/2+2] = 0x4e71;
2310	2295
2311		namcos21_init( machine(), NAMCOS21_SOLVALOU );
	2296	init(NAMCOS21_SOLVALOU );
2312	2297	}
2313	2298
2314	2299	DRIVER_INIT_MEMBER(namcos21_state,driveyes)

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team