Previous

199869 Revisions

Next

r17653 Wednesday 5th September, 2012 at 09:47:52 UTC by Aaron Giles
WIP Namco System 2/21/etc cleanup/modernization.

[src/emu]	tilemap.h
[src/mame/drivers]	gal3.c namcofl.c namcoic.c namconb1.c namcos2.c namcos21.c
[src/mame/includes]	namcofl.h namcoic.h namconb1.h namcos2.h namcos21.h
[src/mame/machine]	namcos2.c
[src/mame/video]	namcofl.c namconb1.c namcos2.c namcos21.c

trunk/src/mame/machine/namcos2.c

r17652	r17653
21	21	static emu_timer *namcos2_posirq_timer;
22	22
23	23	void (*namcos2_kickstart)(running_machine &machine, int internal);
24		int namcos2_gametype;
25	24
26	25	static unsigned mFinalLapProtCount;
27	26	static int namcos2_mcu_analog_ctrl;
r17652	r17653
31	30	static int sendval;
32	31
33	32
	33	// not shared
34	34	READ16_HANDLER( namcos2_flap_prot_r )
35	35	{
36	36	static const UINT16 table0[8] = { 0x0000,0x0040,0x0440,0x2440,0x2480,0xa080,0x8081,0x8041 };
r17652	r17653
86	86	{
87	87	cputag_set_input_line(machine, "slave", INPUT_LINE_RESET, state);
88	88	cputag_set_input_line(machine, "mcu", INPUT_LINE_RESET, state);
89		switch( namcos2_gametype )
	89	switch( machine.driver_data<namcos2_shared_state>()->m_gametype )
90	90	{
91	91	case NAMCOS21_SOLVALOU:
92	92	case NAMCOS21_STARBLADE:
r17652	r17653
232	232
233	233	READ16_HANDLER( namcos2_68k_key_r )
234	234	{
235		switch (namcos2_gametype)
	235	switch (space->machine().driver_data<namcos2_shared_state>()->m_gametype)
236	236	{
237	237	case NAMCOS2_ORDYNE:
238	238	switch(offset)
r17652	r17653
406	406
407	407	WRITE16_HANDLER( namcos2_68k_key_w )
408	408	{
409		if( namcos2_gametype == NAMCOS2_MARVEL_LAND && offset == 5 )
	409	int gametype = space->machine().driver_data<namcos2_shared_state>()->m_gametype;
	410	if( gametype == NAMCOS2_MARVEL_LAND && offset == 5 )
410	411	{
411	412	if (data == 0x615E) sendval = 1;
412	413	}
413		if( namcos2_gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 4 )
	414	if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 4 )
414	415	{
415	416	if (data == 0x13EC) sendval = 1;
416	417	}
417		if( namcos2_gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 7 )
	418	if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 7 )
418	419	{
419	420	if (data == 0x13EC) sendval = 1;
420	421	}
421		if( namcos2_gametype == NAMCOS2_MARVEL_LAND && offset == 6 )
	422	if( gametype == NAMCOS2_MARVEL_LAND && offset == 6 )
422	423	{
423	424	if (data == 0x1001) sendval = 0;
424	425	}
r17652	r17653
437	438	static UINT16  namcos2_68k_gpu_C148[0x20];
438	439
439	440
440		static int IsSystem21( void )
	441	bool namcos2_shared_state::is_system21()
441	442	{
442		switch( namcos2_gametype )
	443	switch (m_gametype)
443	444	{
444		case NAMCOS21_AIRCOMBAT:
445		case NAMCOS21_STARBLADE:
446		case NAMCOS21_CYBERSLED:
447		case NAMCOS21_SOLVALOU:
448		case NAMCOS21_WINRUN91:
449		case NAMCOS21_DRIVERS_EYES:
450		return 1;
451		default:
452		return 0;
	445	case NAMCOS21_AIRCOMBAT:
	446	case NAMCOS21_STARBLADE:
	447	case NAMCOS21_CYBERSLED:
	448	case NAMCOS21_SOLVALOU:
	449	case NAMCOS21_WINRUN91:
	450	case NAMCOS21_DRIVERS_EYES:
	451	return 1;
	452	default:
	453	return 0;
453	454	}
454	455	}
455	456
r17652	r17653
654	655
655	656	static int GetPosIRQScanline( running_machine &machine )
656	657	{
657		if (IsSystem21()) return 0;
658		return namcos2_GetPosIrqScanline(machine);
	658	namcos2_shared_state *state = machine.driver_data<namcos2_shared_state>();
	659	if (state->is_system21()) return 0;
	660	return downcast<namcos2_state *>(state)->get_pos_irq_scanline();
659	661	}
660	662
661	663	static TIMER_CALLBACK( namcos2_posirq_tick )
662	664	{
663		if (IsSystem21()) {
	665	namcos2_shared_state *state = machine.driver_data<namcos2_shared_state>();
	666	if (state->is_system21()) {
664	667	if (namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) {
665	668	machine.primary_screen->update_partial(param);
666	669	cputag_set_input_line(machine, "gpu", namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
r17652	r17653
682	685
683	686	INTERRUPT_GEN( namcos2_68k_master_vblank )
684	687	{
685		if (!IsSystem21()) namcos2_adjust_posirq_timer(device->machine(), GetPosIRQScanline(device->machine()));
	688	namcos2_shared_state *state = device->machine().driver_data<namcos2_shared_state>();
	689	if (!state->is_system21()) namcos2_adjust_posirq_timer(device->machine(), GetPosIRQScanline(device->machine()));
686	690	device_set_input_line(device, namcos2_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
687	691	}
688	692
689	693	INTERRUPT_GEN( namcos2_68k_slave_vblank )
690	694	{
691		if (!IsSystem21()) namcos2_adjust_posirq_timer(device->machine(), GetPosIRQScanline(device->machine()));
	695	namcos2_shared_state *state = device->machine().driver_data<namcos2_shared_state>();
	696	if (!state->is_system21()) namcos2_adjust_posirq_timer(device->machine(), GetPosIRQScanline(device->machine()));
692	697	device_set_input_line(device, namcos2_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
693	698	}
694	699
r17652	r17653
765	770	#if 0
766	771	/* Perform the offset handling on the input port */
767	772	/* this converts it to a twos complement number */
768		if( namcos2_gametype == NAMCOS2_DIRT_FOX ||
769		namcos2_gametype == NAMCOS2_DIRT_FOX_JP )
	773	if( m_gametype == NAMCOS2_DIRT_FOX ||
	774	m_gametype == NAMCOS2_DIRT_FOX_JP )
770	775	{
771	776	namcos2_mcu_analog_data ^= 0x80;
772	777	}

trunk/src/mame/video/namcofl.c

r17652	r17653
2	2
3	3	#include "emu.h"
4	4	#include "includes/namcoic.h"
5		#include "includes/namcos2.h"
6	5	#include "includes/namcofl.h"
7	6
8	7
r17652	r17653
83	82
84	83	SCREEN_UPDATE_IND16( namcofl )
85	84	{
	85	namcofl_state *state = screen.machine().driver_data<namcofl_state>();
86	86	int pri;
87	87
88	88	namcofl_install_palette(screen.machine());
r17652	r17653
91	91
92	92	for( pri=0; pri<16; pri++ )
93	93	{
94		namco_roz_draw( bitmap,cliprect,pri );
	94	state->c169_roz_draw(bitmap, cliprect, pri);
95	95	if((pri&1)==0)
96	96	namco_tilemap_draw( bitmap, cliprect, pri>>1 );
97		namco_obj_draw(screen.machine(), bitmap, cliprect, pri );
	97	state->c355_obj_draw(bitmap, cliprect, pri );
98	98	}
99	99
100	100	return 0;
r17652	r17653
119	119
120	120	VIDEO_START( namcofl )
121	121	{
	122	namcofl_state *state = machine.driver_data<namcofl_state>();
122	123	namco_tilemap_init( machine, NAMCOFL_TILEGFX, machine.root_device().memregion(NAMCOFL_TILEMASKREGION)->base(), TilemapCB );
123		namco_obj_init(machine,NAMCOFL_SPRITEGFX,0x0,FLobjcode2tile);
124		namco_roz_init(machine,NAMCOFL_ROTGFX,NAMCOFL_ROTMASKREGION);
	124	state->c355_obj_init(NAMCOFL_SPRITEGFX,0x0,namcos2_shared_state::c355_obj_code2tile_delegate(FUNC(FLobjcode2tile), &machine));
	125	state->c169_roz_init(NAMCOFL_ROTGFX,NAMCOFL_ROTMASKREGION);
125	126	}

trunk/src/mame/video/namconb1.c

r17652	r17653
3	3	#include "emu.h"
4	4	#include "includes/namconb1.h"
5	5	#include "includes/namcoic.h"
6		#include "includes/namcos2.h"
7	6
8	7
9	8	/* nth_word32 is a general-purpose utility function, which allows us to
r17652	r17653
52	51	namconb1_state *state = machine.driver_data<namconb1_state>();
53	52	int mangle;
54	53
55		if( namcos2_gametype == NAMCONB2_MACH_BREAKERS )
	54	if( state->m_gametype == NAMCONB2_MACH_BREAKERS )
56	55	{
57	56	/*  00010203 04050607 00010203 04050607 (normal) */
58	57	/*  00010718 191a1b07 00010708 090a0b07 (alt bank) */
r17652	r17653
105	104	static void
106	105	video_update_common(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int bROZ )
107	106	{
	107	namconb1_state *state = machine.driver_data<namconb1_state>();
108	108	int pri;
109	109	namconb1_install_palette(machine);
110	110
r17652	r17653
112	112	{
113	113	for( pri=0; pri<16; pri++ )
114	114	{
115		namco_roz_draw( bitmap,cliprect,pri );
	115	state->c169_roz_draw(bitmap, cliprect, pri);
116	116	if( (pri&1)==0 )
117	117	{
118	118	namco_tilemap_draw( bitmap, cliprect, pri/2 );
119	119	}
120		namco_obj_draw(machine, bitmap, cliprect, pri );
	120	state->c355_obj_draw(bitmap, cliprect, pri );
121	121	}
122	122	}
123	123	else
r17652	r17653
125	125	for( pri=0; pri<8; pri++ )
126	126	{
127	127	namco_tilemap_draw( bitmap, cliprect, pri );
128		namco_obj_draw(machine, bitmap, cliprect, pri );
	128	state->c355_obj_draw(bitmap, cliprect, pri );
129	129	}
130	130	}
131	131	} /* video_update_common */
r17652	r17653
164	164
165	165	VIDEO_START( namconb1 )
166	166	{
	167	namconb1_state *state = machine.driver_data<namconb1_state>();
167	168	namco_tilemap_init( machine, NAMCONB1_TILEGFX, machine.root_device().memregion(NAMCONB1_TILEMASKREGION)->base(), NB1TilemapCB );
168		namco_obj_init(machine,NAMCONB1_SPRITEGFX,0x0,NB1objcode2tile);
	169	state->c355_obj_init(NAMCONB1_SPRITEGFX,0x0,namcos2_shared_state::c355_obj_code2tile_delegate(FUNC(NB1objcode2tile), &machine));
169	170	} /* namconb1 */
170	171
171	172	/****************************************************************************************************/
r17652	r17653
202	203	namconb1_state *state = machine.driver_data<namconb1_state>();
203	204	int bank = nth_byte32( state->m_spritebank32, (code>>11)&0xf );
204	205	code &= 0x7ff;
205		if( namcos2_gametype == NAMCONB2_MACH_BREAKERS )
	206	if( state->m_gametype == NAMCONB2_MACH_BREAKERS )
206	207	{
207	208	if( bank&0x01 ) code |= 0x01*0x800;
208	209	if( bank&0x02 ) code |= 0x02*0x800;
r17652	r17653
225	226
226	227	VIDEO_START( namconb2 )
227	228	{
	229	namconb1_state *state = machine.driver_data<namconb1_state>();
228	230	namco_tilemap_init(machine, NAMCONB1_TILEGFX, machine.root_device().memregion(NAMCONB1_TILEMASKREGION)->base(), NB2TilemapCB );
229		namco_obj_init(machine,NAMCONB1_SPRITEGFX,0x0,NB2objcode2tile);
230		namco_roz_init(machine, NAMCONB1_ROTGFX,NAMCONB1_ROTMASKREGION);
	231	state->c355_obj_init(NAMCONB1_SPRITEGFX,0x0,namcos2_shared_state::c355_obj_code2tile_delegate(FUNC(NB2objcode2tile), &machine));
	232	state->c169_roz_init(NAMCONB1_ROTGFX,NAMCONB1_ROTMASKREGION);
231	233	} /* namconb2_vh_start */

trunk/src/mame/video/namcos21.c

r17652	r17653
7	7	*/
8	8
9	9	#include "emu.h"
10		#include "includes/namcos2.h"
11	10	#include "includes/namcoic.h"
12	11	#include "includes/namcos21.h"
13	12
r17652	r17653
117	116	VIDEO_START( namcos21 )
118	117	{
119	118	namcos21_state *state = machine.driver_data<namcos21_state>();
120		if( namcos2_gametype == NAMCOS21_WINRUN91 )
	119	if( state->m_gametype == NAMCOS21_WINRUN91 )
121	120	{
122	121	state->m_videoram = auto_alloc_array(machine, UINT8, 0x80000);
123	122	}
124	123	AllocatePolyFrameBuffer(machine);
125		namco_obj_init(machine,
	124	state->c355_obj_init(
126	125	0,      /* gfx bank */
127	126	0xf,   /* reverse palette mapping */
128		NULL );
	127	namcos2_shared_state::c355_obj_code2tile_delegate() );
129	128	} /* VIDEO_START( namcos21 ) */
130	129
131	130	static void
r17652	r17653
176	175	update_palette(screen.machine());
177	176	bitmap.fill(0xff, cliprect );
178	177
179		if( namcos2_gametype != NAMCOS21_WINRUN91 )
	178	if( state->m_gametype != NAMCOS21_WINRUN91 )
180	179	{ /* draw low priority 2d sprites */
181		namco_obj_draw(screen.machine(), bitmap, cliprect, 2 );
182		namco_obj_draw(screen.machine(), bitmap, cliprect, 14 );   //driver's eyes
	180	state->c355_obj_draw(bitmap, cliprect, 2 );
	181	state->c355_obj_draw(bitmap, cliprect, 14 );   //driver's eyes
183	182	}
184	183
185	184	CopyVisiblePolyFrameBuffer( screen.machine(), bitmap, cliprect, 0x7fc0, 0x7ffe );
186	185
187		if( namcos2_gametype != NAMCOS21_WINRUN91 )
	186	if( state->m_gametype != NAMCOS21_WINRUN91 )
188	187	{ /* draw low priority 2d sprites */
189		namco_obj_draw(screen.machine(), bitmap, cliprect, 0 );
190		namco_obj_draw(screen.machine(), bitmap, cliprect, 1 );
	188	state->c355_obj_draw(bitmap, cliprect, 0 );
	189	state->c355_obj_draw(bitmap, cliprect, 1 );
191	190	}
192	191
193	192	CopyVisiblePolyFrameBuffer( screen.machine(), bitmap, cliprect, 0, 0x7fbf );
194	193
195	194
196		if( namcos2_gametype != NAMCOS21_WINRUN91 )
	195	if( state->m_gametype != NAMCOS21_WINRUN91 )
197	196	{ /* draw high priority 2d sprites */
198	197	for( pri=pivot; pri<8; pri++ )
199	198	{
200		namco_obj_draw(screen.machine(), bitmap, cliprect, pri );
	199	state->c355_obj_draw(bitmap, cliprect, pri );
201	200	}
202		namco_obj_draw(screen.machine(), bitmap, cliprect, 15 );   //driver's eyes
	201	state->c355_obj_draw(bitmap, cliprect, 15 );   //driver's eyes
203	202	}
204	203	else
205	204	{ /* winrun bitmap layer */
r17652	r17653
288	287	if( depthcueenable && zz>0 )
289	288	{
290	289	int depth = 0;
291		if( namcos2_gametype == NAMCOS21_WINRUN91 )
	290	if( state->m_gametype == NAMCOS21_WINRUN91 )
292	291	{
293	292	depth = (zz>>10)*0x100;
294	293	pen += depth;
295	294	}
296		else if( namcos2_gametype == NAMCOS21_DRIVERS_EYES )
	295	else if( state->m_gametype == NAMCOS21_DRIVERS_EYES )
297	296	{
298	297	depth = (zz>>10)*0x100;
299	298	pen -= depth;
r17652	r17653
445	444	0x4000..0x5fff  polygon palette bank1 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors)
446	445	0x6000..0x7fff  polygon palette bank2 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors)
447	446	*/
448		if( namcos2_gametype == NAMCOS21_WINRUN91 )
	447	if( state->m_gametype == NAMCOS21_WINRUN91 )
449	448	{
450	449	color = 0x4000|(color&0xff);
451	450	}
452		else if ( namcos2_gametype == NAMCOS21_DRIVERS_EYES )
	451	else if ( state->m_gametype == NAMCOS21_DRIVERS_EYES )
453	452	{
454	453	color = 0x3f00|(color&0xff);
455	454	}

trunk/src/mame/video/namcos2.c

r17652	r17653
10	10	{
11	11	*mask = code;
12	12
13		switch( namcos2_gametype )
	13	namcos2_shared_state *state = machine.driver_data<namcos2_shared_state>();
	14	switch( state->m_gametype )
14	15	{
15	16	case NAMCOS2_FINAL_LAP_2:
16	17	case NAMCOS2_FINAL_LAP_3:
r17652	r17653
25	26	} /* TilemapCB */
26	27
27	28	/**
28		* namcos2_gfx_ctrl selects a bank of 128 sprites within spriteram
	29	* m_gfx_ctrl selects a bank of 128 sprites within spriteram
29	30	*
30		* namcos2_gfx_ctrl also supplies palette and priority information that is applied to the output of the
31		*                  Namco System 2 ROZ chip
	31	* m_gfx_ctrl also supplies palette and priority information that is applied to the output of the
	32	*            Namco System 2 ROZ chip
32	33	*
33	34	* -xxx ---- ---- ---- roz priority
34	35	* ---- xxxx ---- ---- roz palette
35	36	* ---- ---- xxxx ---- always zero?
36	37	* ---- ---- ---- xxxx sprite bank
37	38	*/
38		static UINT16 namcos2_gfx_ctrl;
39
40		READ16_HANDLER( namcos2_gfx_ctrl_r )
	39	READ16_MEMBER( namcos2_state::gfx_ctrl_r )
41	40	{
42		return namcos2_gfx_ctrl;
	41	return m_gfx_ctrl;
43	42	} /* namcos2_gfx_ctrl_r */
44	43
45		WRITE16_HANDLER( namcos2_gfx_ctrl_w )
	44	WRITE16_MEMBER( namcos2_state::gfx_ctrl_w )
46	45	{
47		COMBINE_DATA(&namcos2_gfx_ctrl);
	46	COMBINE_DATA(&m_gfx_ctrl);
48	47	} /* namcos2_gfx_ctrl_w */
49	48
50		static TILE_GET_INFO( get_tile_info_roz )
	49	TILE_GET_INFO_MEMBER( namcos2_state::roz_tile_info )
51	50	{
52		int tile = machine.driver_data<namcos2_state>()->m_rozram[tile_index];
53		SET_TILE_INFO(3,tile,0/*color*/,0);
54		} /* get_tile_info_roz */
	51	int tile = m_rozram[tile_index];
	52	SET_TILE_INFO_MEMBER(3,tile,0/*color*/,0);
	53	} /* roz_tile_info */
55	54
56	55	struct RozParam
57	56	{
r17652	r17653
240	239	const int xoffset = 38,yoffset = 0;
241	240	struct RozParam rozParam;
242	241
243		rozParam.color = (namcos2_gfx_ctrl & 0x0f00);
	242	rozParam.color = (m_gfx_ctrl & 0x0f00);
244	243	rozParam.incxx  = (INT16)m_roz_ctrl[0];
245	244	rozParam.incxy  = (INT16)m_roz_ctrl[1];
246	245	rozParam.incyx  = (INT16)m_roz_ctrl[2];
r17652	r17653
285	284	DrawRozHelper( bitmap, m_tilemap_roz, cliprect, &rozParam );
286	285	}
287	286
288		READ16_MEMBER(namcos2_state::roz_ctrl_word_r)
289		{
290		return m_roz_ctrl[offset];
291		}
292
293		WRITE16_MEMBER( namcos2_state::roz_ctrl_word_w )
294		{
295		COMBINE_DATA(&m_roz_ctrl[offset]);
296		}
297
298		READ16_MEMBER( namcos2_state::rozram_word_r )
299		{
300		return m_rozram[offset];
301		}
302
303	287	WRITE16_MEMBER( namcos2_state::rozram_word_w )
304	288	{
305	289	COMBINE_DATA(&m_rozram[offset]);
r17652	r17653
312	296
313	297	/**************************************************************************/
314	298
315		inline UINT16 namcos2_state::get_palette_register( int which )
	299	UINT16 namcos2_state::get_palette_register( int which )
316	300	{
317	301	const UINT16 *source = &m_paletteram[0x3000/2];
318	302	return ((source[which*2]&0xff)<<8) | (source[which*2+1]&0xff);
r17652	r17653
362	346	/*case 0x180a:*/ case 0x180b:
363	347	if (data^m_paletteram[offset]) {
364	348	m_paletteram[offset] = data;
365		namcos2_adjust_posirq_timer(machine(),namcos2_GetPosIrqScanline(machine()));
	349	namcos2_adjust_posirq_timer(machine(),get_pos_irq_scanline());
366	350	}
367	351	break;
368	352
r17652	r17653
379	363	} /* namcos2_68k_video_palette_w */
380	364
381	365
382		int
383		namcos2_GetPosIrqScanline( running_machine &machine )
384		{
385		return (machine.driver_data<namcos2_state>()->get_palette_register(5) - 32) & 0xff;
386		} /* namcos2_GetPosIrqScanline */
387
388	366	inline void
389	367	namcos2_state::update_palette()
390	368	{
r17652	r17653
407	385
408	386	/**************************************************************************/
409	387
410		static void
411		DrawSpriteInit( running_machine &machine )
	388	void namcos2_state::draw_sprite_init()
412	389	{
413		int i;
414	390	/* set table for sprite color == 0x0f */
415		for( i = 0; i<16*256; i++ )
	391	for( int i = 0; i<16*256; i++ )
416	392	{
417		machine.shadow_table[i] = i+0x2000;
	393	machine().shadow_table[i] = i+0x2000;
418	394	}
419	395	}
420	396
421		WRITE16_MEMBER( namcos2_state::spriteram_word_w )
422		{
423		COMBINE_DATA(&m_spriteram[offset]);
424		}
425
426		READ16_MEMBER( namcos2_state::spriteram_word_r )
427		{
428		return m_spriteram[offset];
429		}
430
431	397	/**************************************************************************/
432	398
433	399	void namcos2_state::video_start()
434	400	{
435	401	namco_tilemap_init(machine(), 2, memregion("gfx4")->base(), TilemapCB);
436		m_tilemap_roz = tilemap_create(machine(), get_tile_info_roz,tilemap_scan_rows,8,8,256,256);
	402	m_tilemap_roz = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos2_state::roz_tile_info), this), tilemap_mapper_delegate(FUNC(tilemap_scan_rows), &machine()), 8,8,256,256);
437	403	m_tilemap_roz->set_transparent_pen(0xff);
438		DrawSpriteInit(machine());
	404	draw_sprite_init();
439	405	}
440	406
441	407	void namcos2_state::apply_clip( rectangle &clip, const rectangle &cliprect )
r17652	r17653
458	424	apply_clip( clip, cliprect );
459	425
460	426	/* HACK: enable ROZ layer only if it has priority > 0 */
461		m_tilemap_roz->enable((namcos2_gfx_ctrl & 0x7000) ? 1 : 0);
	427	m_tilemap_roz->enable((m_gfx_ctrl & 0x7000) ? 1 : 0);
462	428
463	429	for( pri=0; pri<16; pri++ )
464	430	{
r17652	r17653
466	432	{
467	433	namco_tilemap_draw( bitmap, clip, pri/2 );
468	434
469		if( ((namcos2_gfx_ctrl & 0x7000) >> 12)==pri/2 )
	435	if( ((m_gfx_ctrl & 0x7000) >> 12)==pri/2 )
470	436	{
471	437	draw_roz(bitmap,clip);
472	438	}
473		draw_sprites(bitmap, clip, pri/2, namcos2_gfx_ctrl );
	439	draw_sprites(bitmap, clip, pri/2, m_gfx_ctrl );
474	440	}
475	441	}
476	442	return 0;
r17652	r17653
481	447	void namcos2_state::video_start_finallap()
482	448	{
483	449	namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
484		DrawSpriteInit(machine());
	450	draw_sprite_init();
485	451	namco_road_init(machine(), 3);
486	452	}
487	453
r17652	r17653
501	467	namco_tilemap_draw( bitmap, clip, pri/2 );
502	468	}
503	469	namco_road_draw(machine(), bitmap,clip,pri );
504		draw_sprites(bitmap,clip,pri,namcos2_gfx_ctrl );
	470	draw_sprites(bitmap,clip,pri,m_gfx_ctrl );
505	471	}
506	472	return 0;
507	473	}
r17652	r17653
511	477	void namcos2_state::video_start_luckywld()
512	478	{
513	479	namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
514		namco_obj_init( machine(), 0, 0x0, NULL );
515		if( namcos2_gametype==NAMCOS2_LUCKY_AND_WILD )
	480	c355_obj_init( 0, 0x0, namcos2_shared_state::c355_obj_code2tile_delegate() );
	481	if( m_gametype==NAMCOS2_LUCKY_AND_WILD )
516	482	{
517		namco_roz_init( machine(), 1, "gfx5" );
	483	c169_roz_init(1, "gfx5");
518	484	}
519		if( namcos2_gametype!=NAMCOS2_STEEL_GUNNER_2 )
	485	if( m_gametype!=NAMCOS2_STEEL_GUNNER_2 )
520	486	{
521	487	namco_road_init(machine(), 3);
522	488	}
r17652	r17653
538	504	namco_tilemap_draw( bitmap, clip, pri/2 );
539	505	}
540	506	namco_road_draw(machine(), bitmap,clip,pri );
541		if( namcos2_gametype==NAMCOS2_LUCKY_AND_WILD )
	507	if( m_gametype==NAMCOS2_LUCKY_AND_WILD )
542	508	{
543		namco_roz_draw( bitmap, clip, pri );
	509	c169_roz_draw(bitmap, clip, pri);
544	510	}
545		namco_obj_draw(machine(), bitmap, clip, pri );
	511	c355_obj_draw(bitmap, clip, pri );
546	512	}
547	513	return 0;
548	514	}
r17652	r17653
552	518	void namcos2_state::video_start_sgunner()
553	519	{
554	520	namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
555		namco_obj_init( machine(), 0, 0x0, NULL );
	521	c355_obj_init( 0, 0x0, namcos2_shared_state::c355_obj_code2tile_delegate() );
556	522	}
557	523
558	524	UINT32 namcos2_state::screen_update_sgunner(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r17652	r17653
567	533	for( pri=0; pri<8; pri++ )
568	534	{
569	535	namco_tilemap_draw( bitmap, clip, pri );
570		namco_obj_draw(machine(), bitmap, clip, pri );
	536	c355_obj_draw(bitmap, clip, pri );
571	537	}
572	538	return 0;
573	539	}
r17652	r17653
578	544	void namcos2_state::video_start_metlhawk()
579	545	{
580	546	namco_tilemap_init(machine(),2,memregion("gfx4")->base(),TilemapCB);
581		namco_roz_init( machine(), 1, "gfx5" );
	547	c169_roz_init(1, "gfx5");
582	548	}
583	549
584	550	UINT32 namcos2_state::screen_update_metlhawk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r17652	r17653
596	562	{
597	563	namco_tilemap_draw( bitmap, clip, pri/2 );
598	564	}
599		namco_roz_draw( bitmap, clip, pri );
	565	c169_roz_draw(bitmap, clip, pri);
600	566	draw_sprites_metalhawk(bitmap,clip,pri );
601	567	}
602	568	return 0;

trunk/src/mame/includes/namcofl.h

r17652	r17653
	1	#include "namcos2.h"
	2
1	3	#define NAMCOFL_HTOTAL      (288)   /* wrong */
2	4	#define NAMCOFL_HBSTART   (288)
3	5	#define NAMCOFL_VTOTAL      (262)   /* needs to be checked */
r17652	r17653
13	15	#define NAMCOFL_SPRITEGFX      1
14	16	#define NAMCOFL_ROTGFX         2
15	17
16		class namcofl_state : public driver_device
	18	class namcofl_state : public namcos2_shared_state
17	19	{
18	20	public:
19	21	namcofl_state(const machine_config &mconfig, device_type type, const char *tag)
20		: driver_device(mconfig, type, tag),
	22	: namcos2_shared_state(mconfig, type, tag),
21	23	m_maincpu(*this,"maincpu"),
22	24	m_mcu(*this,"mcu"),
23	25	m_shareram(*this, "shareram"){ }

trunk/src/mame/includes/namconb1.h

r17652	r17653
	1	#include "namcos2.h"
	2
1	3	#define NAMCONB1_HTOTAL      (288)   /* wrong */
2	4	#define NAMCONB1_HBSTART   (288)
3	5	#define NAMCONB1_VTOTAL      (262)   /* needs to be checked */
r17652	r17653
13	15	#define NAMCONB1_SPRITEGFX      1
14	16	#define NAMCONB1_ROTGFX         2
15	17
16		class namconb1_state : public driver_device
	18	class namconb1_state : public namcos2_shared_state
17	19	{
18	20	public:
19	21	namconb1_state(const machine_config &mconfig, device_type type, const char *tag)
20		: driver_device(mconfig, type, tag),
	22	: namcos2_shared_state(mconfig, type, tag),
21	23	m_maincpu(*this,"maincpu"),
22	24	m_mcu(*this,"mcu"),
23	25	m_nvmem32(*this, "nvmem32"),

trunk/src/mame/includes/namcos21.h

r17652	r17653
2	2	* @file namcos21.h
3	3	*/
4	4
	5	#include "namcos2.h"
	6
5	7	#define NAMCOS21_POLY_FRAME_WIDTH 496
6	8	#define NAMCOS21_POLY_FRAME_HEIGHT 480
7	9
r17652	r17653
23	25	int slaveActive;
24	26	};
25	27
26		class namcos21_state : public driver_device
	28	class namcos21_state : public namcos2_shared_state
27	29	{
28	30	public:
29	31	namcos21_state(const machine_config &mconfig, device_type type, const char *tag)
30		: driver_device(mconfig, type, tag),
	32	: namcos2_shared_state(mconfig, type, tag),
31	33	m_winrun_dspbios(*this,"winrun_dspbios"),
32	34	m_winrun_polydata(*this,"winrun_polydata"),
33	35	m_winrun_gpucomram(*this,"winrun_comram"),

trunk/src/mame/includes/namcos2.h

r17652	r17653
17	17
18	18	/*********************************************/
19	19	/* IF GAME SPECIFIC HACKS ARE REQUIRED THEN  */
20		/* USE THE namcos2_gametype VARIABLE TO FIND */
	20	/* USE THE m_gametype MEMBER TO FIND */
21	21	/* OUT WHAT GAME IS RUNNING                  */
22	22	/*********************************************/
23	23
r17652	r17653
85	85	NAMCOFL_FINAL_LAP_R
86	86	};
87	87
88		class namcos2_state : public driver_device
	88	// fix me -- most of this should be devices eventually
	89	class namcos2_shared_state : public driver_device
89	90	{
90	91	public:
	92	namcos2_shared_state(const machine_config &mconfig, device_type type, const char *tag)
	93	: driver_device(mconfig, type, tag),
	94	m_gametype(0),
	95	m_c169_roz_videoram(*this, "rozvideoram", 0),
	96	m_c169_roz_gfxbank(0),
	97	m_c169_roz_mask(NULL),
	98	m_c355_obj_ram(*this, "objram", 0),
	99	m_c355_obj_gfxbank(0),
	100	m_c355_obj_palxor(0)
	101	{ }
	102
	103	// game type helpers
	104	bool is_system21();
	105	int m_gametype;
	106
	107	// C169 ROZ Layer Emulation
	108	public:
	109	void c169_roz_init(int gfxbank, const char *maskregion);
	110	void c169_roz_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri);
	111	DECLARE_READ16_MEMBER( c169_roz_control_r );
	112	DECLARE_WRITE16_MEMBER( c169_roz_control_w );
	113	DECLARE_READ16_MEMBER( c169_roz_bank_r );
	114	DECLARE_WRITE16_MEMBER( c169_roz_bank_w );
	115	DECLARE_READ16_MEMBER( c169_roz_videoram_r );
	116	DECLARE_WRITE16_MEMBER( c169_roz_videoram_w );
	117
	118	protected:
	119	struct roz_parameters
	120	{
	121	UINT32 left, top, size;
	122	UINT32 startx, starty;
	123	int incxx, incxy, incyx, incyy;
	124	int color, priority;
	125	};
	126	void c169_roz_unpack_params(const UINT16 *source, roz_parameters &params);
	127	void c169_roz_draw_helper(bitmap_ind16 &bitmap, tilemap_t &tmap, const rectangle &clip, const roz_parameters &params);
	128	void c169_roz_draw_scanline(bitmap_ind16 &bitmap, int line, int which, int pri, const rectangle &cliprect);
	129	void c169_roz_get_info(tile_data &tileinfo, int tile_index, int which);
	130	TILE_GET_INFO_MEMBER( c169_roz_get_info0 );
	131	TILE_GET_INFO_MEMBER( c169_roz_get_info1 );
	132	TILEMAP_MAPPER_MEMBER( c169_roz_mapper );
	133
	134	static const int ROZ_TILEMAP_COUNT = 2;
	135	tilemap_t *m_c169_roz_tilemap[ROZ_TILEMAP_COUNT];
	136	UINT16 m_c169_roz_bank[0x10/2];
	137	UINT16 m_c169_roz_control[0x20/2];
	138	optional_shared_ptr<UINT16> m_c169_roz_videoram;
	139	int m_c169_roz_gfxbank;
	140	UINT8 *m_c169_roz_mask;
	141
	142	// C355 Motion Object Emulation
	143	public:
	144	typedef delegate<int (int)> c355_obj_code2tile_delegate;
	145	// for pal_xor, supply either 0x0 (normal) or 0xf (palette mapping reversed)
	146	void c355_obj_init(int gfxbank, int pal_xor, c355_obj_code2tile_delegate code2tile);
	147	int c355_obj_default_code2tile(int code);
	148	void c355_obj_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri);
	149	void c355_obj_draw(bitmap_rgb32 &bitmap, const rectangle &cliprect, int pri);
	150	DECLARE_READ16_MEMBER( c355_obj_ram_r );
	151	DECLARE_WRITE16_MEMBER( c355_obj_ram_w );
	152	DECLARE_READ16_MEMBER( c355_obj_position_r );
	153	DECLARE_WRITE16_MEMBER( c355_obj_position_w );
	154
	155	protected:
	156	// C355 Motion Object internals
	157	template<class _BitmapClass>
	158	void c355_obj_draw_sprite(_BitmapClass &bitmap, const rectangle &cliprect, const UINT16 *pSource, int pri, int zpos);
	159	template<class _BitmapClass>
	160	void c355_obj_draw_list(_BitmapClass &bitmap, const rectangle &cliprect, int pri, const UINT16 *pSpriteList16, const UINT16 *pSpriteTable);
	161
	162	optional_shared_ptr<UINT16> m_c355_obj_ram;
	163	c355_obj_code2tile_delegate m_c355_obj_code2tile;
	164	int m_c355_obj_gfxbank;
	165	int m_c355_obj_palxor;
	166	UINT16 m_c355_obj_position[4];
	167
	168
	169	public:
	170	// general
	171	void zdrawgfxzoom(bitmap_ind16 &dest_bmp, const rectangle &clip, const gfx_element *gfx, UINT32 code, UINT32 color, int flipx, int flipy, int sx, int sy, int scalex, int scaley, int zpos);
	172	void zdrawgfxzoom(bitmap_rgb32 &dest_bmp, const rectangle &clip, const gfx_element *gfx, UINT32 code, UINT32 color, int flipx, int flipy, int sx, int sy, int scalex, int scaley, int zpos);
	173	};
	174
	175	class namcos2_state : public namcos2_shared_state
	176	{
	177	public:
91	178	namcos2_state(const machine_config &mconfig, device_type type, const char *tag)
92		: driver_device(mconfig, type, tag),
	179	: namcos2_shared_state(mconfig, type, tag),
93	180	m_dpram(*this, "dpram"),
	181	m_paletteram(*this, "paletteram"),
94	182	m_spriteram(*this, "spriteram"),
95		m_paletteram(*this, "paletteram"),
96		m_rozram(*this, "rozram")
	183	m_rozram(*this, "rozram"),
	184	m_roz_ctrl(*this, "rozctrl")
97	185	{ }
98	186	DECLARE_READ16_MEMBER(dpram_word_r);
99	187	DECLARE_WRITE16_MEMBER(dpram_word_w);
r17652	r17653
145	233	UINT32 screen_update_luckywld(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
146	234	UINT32 screen_update_metlhawk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
147	235	UINT32 screen_update_sgunner(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	236
	237	TILE_GET_INFO_MEMBER( roz_tile_info );
148	238
149	239	DECLARE_READ16_MEMBER( paletteram_word_r );
150	240	DECLARE_WRITE16_MEMBER( paletteram_word_w );
151		DECLARE_READ16_MEMBER( spriteram_word_r );
152		DECLARE_WRITE16_MEMBER( spriteram_word_w );
153		DECLARE_READ16_MEMBER( rozram_word_r );
154	241	DECLARE_WRITE16_MEMBER( rozram_word_w );
155		DECLARE_READ16_MEMBER( roz_ctrl_word_r );
156		DECLARE_WRITE16_MEMBER( roz_ctrl_word_w );
	242	DECLARE_READ16_MEMBER( gfx_ctrl_r );
	243	DECLARE_WRITE16_MEMBER( gfx_ctrl_w );
157	244
	245	void draw_sprite_init();
158	246	void update_palette();
159	247	void apply_clip( rectangle &clip, const rectangle &cliprect );
160	248	void draw_roz(bitmap_ind16 &bitmap, const rectangle &cliprect);
r17652	r17653
162	250	void draw_sprites_metalhawk(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
163	251	UINT16 get_palette_register( int which );
164	252
	253	int get_pos_irq_scanline() { return (get_palette_register(5) - 32) & 0xff; }
	254
165	255	required_shared_ptr<UINT8> m_dpram;   /* 2Kx8 */
	256	required_shared_ptr<UINT16> m_paletteram;
166	257	optional_shared_ptr<UINT16> m_spriteram;
167		required_shared_ptr<UINT16> m_paletteram;
168	258	optional_shared_ptr<UINT16> m_rozram;
169
170		UINT16 m_roz_ctrl[0x8];
	259	optional_shared_ptr<UINT16> m_roz_ctrl;
171	260	tilemap_t *m_tilemap_roz;
	261	UINT16 m_gfx_ctrl;
172	262
173	263	};
174	264
r17652	r17653
176	266
177	267	#define NAMCOS21_NUM_COLORS 0x8000
178	268
179		VIDEO_START( namcos2 );
180
181		VIDEO_START( finallap );
182
183		VIDEO_START( luckywld );
184
185		VIDEO_START( metlhawk );
186
187		VIDEO_START( sgunner );
188
189		int namcos2_GetPosIrqScanline( running_machine &machine );
190
191		WRITE16_HANDLER( namcos2_gfx_ctrl_w );
192		READ16_HANDLER( namcos2_gfx_ctrl_r );
193
194	269	/**************************************************************/
195	270	/*  Shared video palette function handlers                    */
196	271	/**************************************************************/
r17652	r17653
204	279	/*----------- defined in machine/namcos2.c -----------*/
205	280
206	281	extern void (*namcos2_kickstart)(running_machine &machine, int internal);
207		extern int namcos2_gametype;
208	282
209	283	MACHINE_START( namcos2 );
210	284	MACHINE_RESET( namcos2 );

trunk/src/mame/includes/namcoic.h

r17652	r17653
111	111	WRITE32_HANDLER( namco_tilemapcontrol32_le_w );
112	112
113	113	/***********************************************************************************/
114		/* C355 Motion Object Emulation */
115	114
116		/* for palXOR, supply either 0x0 (normal) or 0xf (palette mapping reversed) */
117		void namco_obj_init( running_machine &machine, int gfxbank, int palXOR, int (*code2tile)( running_machine &machine, int code ) );
118		void namco_obj_draw( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
119		void namco_obj_draw( running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int pri );
120
121		WRITE16_HANDLER( namco_obj16_w );
122		READ16_HANDLER( namco_obj16_r );
123
124		WRITE32_HANDLER( namco_obj32_w );
125		READ32_HANDLER( namco_obj32_r );
126		WRITE32_HANDLER( namco_obj32_le_w );
127		READ32_HANDLER( namco_obj32_le_r );
128
129		WRITE16_HANDLER( namco_spritepos16_w );
130		READ16_HANDLER( namco_spritepos16_r );
131
132		WRITE32_HANDLER( namco_spritepos32_w );
133		READ32_HANDLER( namco_spritepos32_r );
134
135	115	/***********************************************************************************/
136		/* C169 ROZ Layer Emulation */
137
138		void namco_roz_init( running_machine &machine, int gfxbank, const char *maskregion );
139		void namco_roz_draw( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
140
141		READ16_HANDLER( namco_rozcontrol16_r );
142		WRITE16_HANDLER( namco_rozcontrol16_w );
143		READ16_HANDLER( namco_rozvideoram16_r );
144		WRITE16_HANDLER( namco_rozvideoram16_w );
145
146		READ32_HANDLER( namco_rozcontrol32_r );
147		WRITE32_HANDLER( namco_rozcontrol32_w );
148		READ32_HANDLER( namco_rozcontrol32_le_r );
149		WRITE32_HANDLER( namco_rozcontrol32_le_w );
150		READ32_HANDLER( namco_rozbank32_r );
151		WRITE32_HANDLER( namco_rozbank32_w );
152		READ32_HANDLER( namco_rozvideoram32_r );
153		WRITE32_HANDLER( namco_rozvideoram32_w );
154		READ32_HANDLER( namco_rozvideoram32_le_r );
155		WRITE32_HANDLER( namco_rozvideoram32_le_w );
156
157		/***********************************************************************************/
158	116	/* C45 Land (Road) Emulation */
159	117
160	118	void namco_road_init( running_machine &machine, int gfxbank );

trunk/src/mame/drivers/namconb1.c

r17652	r17653
272	272	#include "emu.h"
273	273	#include "cpu/m68000/m68000.h"
274	274	#include "includes/namconb1.h"
275		#include "includes/namcos2.h"
276	275	#include "includes/namcoic.h"
277	276	#include "sound/c352.h"
278	277	#include "cpu/m37710/m37710.h"
r17652	r17653
590	589	else
591	590	{
592	591	memset( state->m_nvmem32, 0x00, NB1_NVMEM_SIZE );
593		if( namcos2_gametype == NAMCONB1_GUNBULET )
	592	if( state->m_gametype == NAMCONB1_GUNBULET )
594	593	{
595	594	state->m_nvmem32[0] = 0x0f260f26; /* default gun calibration */
596	595	}
r17652	r17653
612	611	size_t numBytes = (0xfe7-0xe6f)*8;
613	612	memset( &pMem[0xe6f*8], 0, numBytes );
614	613
615		namcos2_gametype = NAMCONB1_NEBULRAY;
	614	m_gametype = NAMCONB1_NEBULRAY;
616	615	} /* nebulray */
617	616
618	617	DRIVER_INIT_MEMBER(namconb1_state,gslgr94u)
619	618	{
620		namcos2_gametype = NAMCONB1_GSLGR94U;
	619	m_gametype = NAMCONB1_GSLGR94U;
621	620	} /* gslgr94u */
622	621
623	622	DRIVER_INIT_MEMBER(namconb1_state,gslgr94j)
624	623	{
625		namcos2_gametype = NAMCONB1_GSLGR94J;
	624	m_gametype = NAMCONB1_GSLGR94J;
626	625	} /* gslgr94j */
627	626
628	627	DRIVER_INIT_MEMBER(namconb1_state,sws95)
629	628	{
630		namcos2_gametype = NAMCONB1_SWS95;
	629	m_gametype = NAMCONB1_SWS95;
631	630	} /* sws95 */
632	631
633	632	DRIVER_INIT_MEMBER(namconb1_state,sws96)
634	633	{
635		namcos2_gametype = NAMCONB1_SWS96;
	634	m_gametype = NAMCONB1_SWS96;
636	635	} /* sws96 */
637	636
638	637	DRIVER_INIT_MEMBER(namconb1_state,sws97)
639	638	{
640		namcos2_gametype = NAMCONB1_SWS97;
	639	m_gametype = NAMCONB1_SWS97;
641	640	} /* sws97 */
642	641
643	642	DRIVER_INIT_MEMBER(namconb1_state,gunbulet)
644	643	{
645		namcos2_gametype = NAMCONB1_GUNBULET;
	644	m_gametype = NAMCONB1_GUNBULET;
646	645	} /* gunbulet */
647	646
648	647	DRIVER_INIT_MEMBER(namconb1_state,vshoot)
649	648	{
650		namcos2_gametype = NAMCONB1_VSHOOT;
	649	m_gametype = NAMCONB1_VSHOOT;
651	650	} /* vshoot */
652	651
653	652	DRIVER_INIT_MEMBER(namconb1_state,machbrkr)
654	653	{
655		namcos2_gametype = NAMCONB2_MACH_BREAKERS;
	654	m_gametype = NAMCONB2_MACH_BREAKERS;
656	655	}
657	656
658	657	DRIVER_INIT_MEMBER(namconb1_state,outfxies)
659	658	{
660		namcos2_gametype = NAMCONB2_OUTFOXIES;
	659	m_gametype = NAMCONB2_OUTFOXIES;
661	660	}
662	661
663	662	READ32_MEMBER(namconb1_state::custom_key_r)
r17652	r17653
669	668	m_count = machine().rand();
670	669	} while( m_count==old_count );
671	670
672		switch( namcos2_gametype )
	671	switch( m_gametype )
673	672	{
674	673	case NAMCONB1_GUNBULET:
675	674	return 0; /* no protection */
r17652	r17653
856	855	AM_RANGE(0x208000, 0x2fffff) AM_RAM
857	856	AM_RANGE(0x400000, 0x40001f) AM_READWRITE(namconb_cpureg_r, namconb1_cpureg_w)
858	857	AM_RANGE(0x580000, 0x5807ff) AM_RAM AM_SHARE("nvmem32")
859		AM_RANGE(0x600000, 0x61ffff) AM_READWRITE_LEGACY(namco_obj32_r,namco_obj32_w)
860		AM_RANGE(0x620000, 0x620007) AM_READWRITE_LEGACY(namco_spritepos32_r,namco_spritepos32_w)
	858	AM_RANGE(0x600000, 0x61ffff) AM_READWRITE16(c355_obj_ram_r,c355_obj_ram_w,0xffffffff) AM_SHARE("objram")
	859	AM_RANGE(0x620000, 0x620007) AM_READWRITE16(c355_obj_position_r,c355_obj_position_w,0xffffffff)
861	860	AM_RANGE(0x640000, 0x64ffff) AM_READWRITE_LEGACY(namco_tilemapvideoram32_r,namco_tilemapvideoram32_w )
862	861	AM_RANGE(0x660000, 0x66003f) AM_READWRITE_LEGACY(namco_tilemapcontrol32_r,namco_tilemapcontrol32_w)
863	862	AM_RANGE(0x680000, 0x68000f) AM_RAM AM_SHARE("spritebank32")
r17652	r17653
872	871	AM_RANGE(0x200000, 0x207fff) AM_READWRITE(namconb_share_r, namconb_share_w)
873	872	AM_RANGE(0x208000, 0x2fffff) AM_RAM
874	873	AM_RANGE(0x400000, 0x4fffff) AM_ROM AM_REGION("data", 0)
875		AM_RANGE(0x600000, 0x61ffff) AM_READWRITE_LEGACY(namco_obj32_r,namco_obj32_w)
876		AM_RANGE(0x620000, 0x620007) AM_READWRITE_LEGACY(namco_spritepos32_r,namco_spritepos32_w)
	874	AM_RANGE(0x600000, 0x61ffff) AM_READWRITE16(c355_obj_ram_r,c355_obj_ram_w,0xffffffff) AM_SHARE("objram")
	875	AM_RANGE(0x620000, 0x620007) AM_READWRITE16(c355_obj_position_r,c355_obj_position_w,0xffffffff)
877	876	AM_RANGE(0x640000, 0x64000f) AM_RAM /* unknown xy offset */
878	877	AM_RANGE(0x680000, 0x68ffff) AM_READWRITE_LEGACY(namco_tilemapvideoram32_r, namco_tilemapvideoram32_w )
879	878	AM_RANGE(0x6c0000, 0x6c003f) AM_READWRITE_LEGACY(namco_tilemapcontrol32_r, namco_tilemapcontrol32_w )
880		AM_RANGE(0x700000, 0x71ffff) AM_READWRITE_LEGACY(namco_rozvideoram32_r,namco_rozvideoram32_w)
881		AM_RANGE(0x740000, 0x74001f) AM_READWRITE_LEGACY(namco_rozcontrol32_r,namco_rozcontrol32_w)
	879	AM_RANGE(0x700000, 0x71ffff) AM_READWRITE16(c169_roz_videoram_r,c169_roz_videoram_w,0xffffffff) AM_SHARE("rozvideoram")
	880	AM_RANGE(0x740000, 0x74001f) AM_READWRITE16(c169_roz_control_r,c169_roz_control_w,0xffffffff)
882	881	AM_RANGE(0x800000, 0x807fff) AM_RAM AM_SHARE("paletteram")
883	882	AM_RANGE(0x900008, 0x90000f) AM_RAM AM_SHARE("spritebank32")
884	883	AM_RANGE(0x940000, 0x94000f) AM_RAM AM_SHARE("tilebank32")
885		AM_RANGE(0x980000, 0x98000f) AM_READ_LEGACY(namco_rozbank32_r) AM_WRITE_LEGACY(namco_rozbank32_w)
	884	AM_RANGE(0x980000, 0x98000f) AM_READWRITE16(c169_roz_bank_r,c169_roz_bank_w,0xffffffff)
886	885	AM_RANGE(0xa00000, 0xa007ff) AM_RAM AM_SHARE("nvmem32")
887	886	AM_RANGE(0xc00000, 0xc0001f) AM_READ(custom_key_r) AM_WRITENOP
888	887	AM_RANGE(0xf00000, 0xf0001f) AM_READWRITE(namconb_cpureg_r, namconb2_cpureg_w)

trunk/src/mame/drivers/namcos21.c

r17652	r17653
296	296	#include "emu.h"
297	297	#include "cpu/m68000/m68000.h"
298	298	#include "cpu/m6805/m6805.h"
299		#include "includes/namcos2.h"
300	299	#include "cpu/m6809/m6809.h"
301	300	#include "cpu/tms32025/tms32025.h"
302	301	#include "includes/namcoic.h"
r17652	r17653
341	340	READ16_MEMBER(namcos21_state::dspcuskey_r)
342	341	{
343	342	UINT16 result = 0;
344		if( namcos2_gametype == NAMCOS21_SOLVALOU )
	343	if( m_gametype == NAMCOS21_SOLVALOU )
345	344	{
346	345	switch( cpu_get_pc(&space.device()) )
347	346	{
r17652	r17653
354	353	break;
355	354	}
356	355	}
357		else if( namcos2_gametype == NAMCOS21_CYBERSLED )
	356	else if( m_gametype == NAMCOS21_CYBERSLED )
358	357	{
359	358	switch( cpu_get_pc(&space.device()) )
360	359	{
r17652	r17653
365	364	break;
366	365	}
367	366	}
368		else if( namcos2_gametype == NAMCOS21_AIRCOMBAT )
	367	else if( m_gametype == NAMCOS21_AIRCOMBAT )
369	368	{
370	369	switch( cpu_get_pc(&space.device()) )
371	370	{
r17652	r17653
497	496	{
498	497	namcos21_state *state = machine.driver_data<namcos21_state>();
499	498	/* patch dsp watchdog */
500		switch( namcos2_gametype )
	499	switch( state->m_gametype )
501	500	{
502	501	case NAMCOS21_AIRCOMBAT:
503	502	state->m_master_dsp_code[0x008e] = 0x808f;
r17652	r17653
567	566	{
568	567	COMBINE_DATA( &m_dspram16[offset] );
569	568
570		if( namcos2_gametype != NAMCOS21_WINRUN91 )
	569	if( m_gametype != NAMCOS21_WINRUN91 )
571	570	{
572	571	if( m_mpDspState->masterSourceAddr &&
573	572	offset == 1+(m_mpDspState->masterSourceAddr&0x7fff) )
r17652	r17653
575	574	if (ENABLE_LOGGING) logerror( "IDC-CONTINUE\n" );
576	575	TransferDspData(machine());
577	576	}
578		else if (namcos2_gametype == NAMCOS21_SOLVALOU &&
	577	else if (m_gametype == NAMCOS21_SOLVALOU &&
579	578	offset == 0x103 &&
580	579	&space.device() == machine().device("maincpu"))
581	580	{ /* hack; synchronization for solvalou */
r17652	r17653
1075	1074	AM_RANGE(0x440000, 0x440001) AM_READWRITE(pointram_data_r,pointram_data_w) \
1076	1075	AM_RANGE(0x440002, 0x47ffff) AM_WRITENOP /* (?) Air Combat */ \
1077	1076	AM_RANGE(0x480000, 0x4807ff) AM_READWRITE(namcos21_depthcue_r,namcos21_depthcue_w) /* Air Combat */ \
1078		AM_RANGE(0x700000, 0x71ffff) AM_READWRITE_LEGACY(namco_obj16_r,namco_obj16_w) \
1079		AM_RANGE(0x720000, 0x720007) AM_READWRITE_LEGACY(namco_spritepos16_r,namco_spritepos16_w) \
	1077	AM_RANGE(0x700000, 0x71ffff) AM_READWRITE(c355_obj_ram_r,c355_obj_ram_w) AM_SHARE("objram") \
	1078	AM_RANGE(0x720000, 0x720007) AM_READWRITE(c355_obj_position_r,c355_obj_position_w) \
1080	1079	AM_RANGE(0x740000, 0x75ffff) AM_READWRITE(paletteram16_r,paletteram16_w) AM_SHARE("paletteram") \
1081	1080	AM_RANGE(0x760000, 0x760001) AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w) \
1082	1081	AM_RANGE(0x800000, 0x8fffff) AM_READ(datarom_r) \
r17652	r17653
1415	1414	////////////////////////////////////////////////////////////////////////////////
1416	1415
1417	1416	#define DRIVEYES_68K_COMMON \
1418		AM_RANGE(0x700000, 0x71ffff) AM_READWRITE_LEGACY(namco_obj16_r,namco_obj16_w) \
1419		AM_RANGE(0x720000, 0x720007) AM_READWRITE_LEGACY(namco_spritepos16_r,namco_spritepos16_w) \
	1417	AM_RANGE(0x700000, 0x71ffff) AM_READWRITE(c355_obj_ram_r,c355_obj_ram_w) AM_SHARE("objram") \
	1418	AM_RANGE(0x720000, 0x720007) AM_READWRITE(c355_obj_position_r,c355_obj_position_w) \
1420	1419	AM_RANGE(0x740000, 0x75ffff) AM_READWRITE(paletteram16_r,paletteram16_w) AM_SHARE("paletteram") \
1421	1420	AM_RANGE(0x760000, 0x760001) AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w) \
1422	1421	AM_RANGE(0x800000, 0x8fffff) AM_READ(datarom_r) \
r17652	r17653
2217	2216	static void namcos21_init( running_machine &machine, int game_type )
2218	2217	{
2219	2218	namcos21_state *state = machine.driver_data<namcos21_state>();
2220		namcos2_gametype = game_type;
	2219	state->m_gametype = game_type;
2221	2220	state->m_pointram = auto_alloc_array(machine, UINT8, PTRAM_SIZE);
2222	2221	state->m_mpDataROM = (UINT16 *)state->memregion( "user1" )->base();
2223	2222	InitDSP(machine);
r17652	r17653
2237	2236
2238	2237	m_winrun_dspcomram = auto_alloc_array(machine(), UINT16, 0x1000*2);
2239	2238
2240		namcos2_gametype = NAMCOS21_WINRUN91;
	2239	m_gametype = NAMCOS21_WINRUN91;
2241	2240	m_mpDataROM = (UINT16 *)memregion( "user1" )->base();
2242	2241	m_pointram = auto_alloc_array(machine(), UINT8, PTRAM_SIZE);
2243	2242	m_pointram_idx = 0;
r17652	r17653
2278	2277	pMem[pc++] = 0xff80; /* b */
2279	2278	pMem[pc++] = 0;
2280	2279	m_winrun_dspcomram = auto_alloc_array(machine(), UINT16, 0x1000*2);
2281		namcos2_gametype = NAMCOS21_DRIVERS_EYES;
	2280	m_gametype = NAMCOS21_DRIVERS_EYES;
2282	2281	m_mpDataROM = (UINT16 *)memregion( "user1" )->base();
2283	2282	m_pointram = auto_alloc_array(machine(), UINT8, PTRAM_SIZE);
2284	2283	m_pointram_idx = 0;

trunk/src/mame/drivers/gal3.c

r17652	r17653
133	133	#include "rendlay.h"
134	134
135	135
136		class gal3_state : public driver_device
	136	class gal3_state : public namcos2_shared_state
137	137	{
138	138	public:
139	139	gal3_state(const machine_config &mconfig, device_type type, const char *tag)
140		: driver_device(mconfig, type, tag) ,
	140	: namcos2_shared_state(mconfig, type, tag) ,
141	141	m_nvmem(*this, "nvmem"),
142	142	m_rso_shared_ram(*this, "rso_shared_ram"){ }
143	143
r17652	r17653
166	166	gal3_state *state = machine.driver_data<gal3_state>();
167	167	state->m_generic_paletteram_16.allocate(0x10000);
168	168
169		namco_obj_init(machine,
	169	state->c355_obj_init(
170	170	0,      /* gfx bank */
171	171	0xf,   /* reverse palette mapping */
172		NULL );
	172	namcos2_shared_state::c355_obj_code2tile_delegate() );
173	173
174	174	}
175	175
r17652	r17653
208	208
209	209	for( pri=0; pri<pivot; pri++ )
210	210	{
211		namco_obj_draw(screen.machine(), bitmap, cliprect, pri );
	211	state->c355_obj_draw(bitmap, cliprect, pri);
212	212	}
213	213
214	214	/*  CopyVisiblePolyFrameBuffer( bitmap, cliprect,0,0x7fbf );
215	215
216	216	for( pri=pivot; pri<15; pri++ )
217	217	{
218		namco_obj_draw(screen.machine(), bitmap, cliprect, pri );
	218	state->c355_obj_draw(bitmap, cliprect, pri);
219	219	}*/
220	220
221	221	// CPU Diag LEDs
r17652	r17653
391	391	/// AM_RANGE(0xf1440000, 0xf1440003) AM_READWRITE_LEGACY(pointram_data_r,pointram_data_w)
392	392	/// AM_RANGE(0x440002, 0x47ffff) AM_WRITENOP /* (frame buffer?) */
393	393	/// AM_RANGE(0xf1480000, 0xf14807ff) AM_READWRITE_LEGACY(namcos21_depthcue_r,namcos21_depthcue_w)
394		AM_RANGE(0xf1700000, 0xf170ffff) AM_READWRITE_LEGACY(namco_obj32_r,namco_obj32_w)
395		AM_RANGE(0xf1720000, 0xf1720007) AM_READWRITE_LEGACY(namco_spritepos32_r,namco_spritepos32_w)
	394	AM_RANGE(0xf1700000, 0xf170ffff) AM_READWRITE16(c355_obj_ram_r,c355_obj_ram_w,0xffffffff) AM_SHARE("objram")
	395	AM_RANGE(0xf1720000, 0xf1720007) AM_READWRITE16(c355_obj_position_r,c355_obj_position_w,0xffffffff)
396	396	AM_RANGE(0xf1740000, 0xf175ffff) AM_READWRITE(paletteram32_r,paletteram32_w)
397	397	AM_RANGE(0xf1760000, 0xf1760003) AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w)
398	398
399	399	AM_RANGE(0xf2200000, 0xf220ffff) AM_RAM
400		AM_RANGE(0xf2700000, 0xf270ffff) AM_RAM   //AM_READWRITE_LEGACY(namco_obj16_r,namco_obj16_w)
401		AM_RANGE(0xf2720000, 0xf2720007) AM_RAM   //AM_READWRITE_LEGACY(namco_spritepos16_r,namco_spritepos16_w)
	400	AM_RANGE(0xf2700000, 0xf270ffff) AM_RAM   //AM_READWRITE16(c355_obj_ram_r,c355_obj_ram_w,0xffffffff) AM_SHARE("objram")
	401	AM_RANGE(0xf2720000, 0xf2720007) AM_RAM   //AM_READWRITE16(c355_obj_position_r,c355_obj_position_w,0xffffffff)
402	402	AM_RANGE(0xf2740000, 0xf275ffff) AM_RAM   //AM_READWRITE(paletteram16_r,paletteram16_w) AM_SHARE("paletteram")
403	403	AM_RANGE(0xf2760000, 0xf2760003) AM_RAM   //AM_READWRITE(namcos21_video_enable_r,namcos21_video_enable_w)
404	404	ADDRESS_MAP_END

trunk/src/mame/drivers/namcoic.c

r17652	r17653
3	3	#include "includes/namcoic.h"
4	4
5	5	/**************************************************************************************/
6		static int mPalXOR;      /* XOR'd with palette select register; needed for System21 */
7
8	6	static struct
9	7	{
10	8	UINT16 control[0x40/2];
r17652	r17653
265	263
266	264	/**************************************************************************************/
267	265
268		static void zdrawgfxzoom(
	266	void namcos2_shared_state::zdrawgfxzoom(
269	267	bitmap_ind16 &dest_bmp,const rectangle &clip,const gfx_element *gfx,
270	268	UINT32 code,UINT32 color,int flipx,int flipy,int sx,int sy,
271	269	int scalex, int scaley, int zpos )
r17652	r17653
347	345	UINT16 *dest = &dest_bmp.pix16(y);
348	346	UINT8 *pri = &priority_bitmap.pix8(y);
349	347	int x, x_index = x_index_base;
350		if( mPalXOR )
	348	if( m_c355_obj_palxor )
351	349	{
352	350	for( x=sx; x<ex; x++ )
353	351	{
r17652	r17653
407	405	}
408	406	} /* zdrawgfxzoom */
409	407
410		static void zdrawgfxzoom(
	408	void namcos2_shared_state::zdrawgfxzoom(
411	409	bitmap_rgb32 &dest_bmp,const rectangle &clip,const gfx_element *gfx,
412	410	UINT32 code,UINT32 color,int flipx,int flipy,int sx,int sy,
413	411	int scalex, int scaley, int zpos )
r17652	r17653
618	616
619	617	/**************************************************************************************/
620	618
621		static UINT16 mSpritePos[4];
622		static UINT16 *m_spriteram;
623
624		WRITE16_HANDLER( namco_spritepos16_w )
	619	WRITE16_MEMBER( namcos2_shared_state::c355_obj_position_w )
625	620	{
626		COMBINE_DATA( &mSpritePos[offset] );
	621	COMBINE_DATA(&m_c355_obj_position[offset]);
627	622	}
628		READ16_HANDLER( namco_spritepos16_r )
	623	READ16_MEMBER( namcos2_shared_state::c355_obj_position_r )
629	624	{
630		return mSpritePos[offset];
	625	return m_c355_obj_position[offset];
631	626	}
632	627
633		WRITE32_HANDLER( namco_spritepos32_w )
634		{
635		UINT32 v;
636		offset *= 2;
637		v = (mSpritePos[offset]<<16)|mSpritePos[offset+1];
638		COMBINE_DATA( &v );
639		mSpritePos[offset+0] = v>>16;
640		mSpritePos[offset+1] = v&0xffff;
641		}
642		READ32_HANDLER( namco_spritepos32_r )
643		{
644		offset *= 2;
645		return (mSpritePos[offset]<<16)|mSpritePos[offset+1];
646		}
647
648	628	INLINE UINT8
649	629	nth_byte16( const UINT16 *pSource, int which )
650	630	{
r17652	r17653
698	678
699	679	/**************************************************************************************************************/
700	680
701		static int (*mpCodeToTile)( running_machine &machine, int code ); /* sprite banking callback */
702		static int mGfxC355;   /* gfx bank for sprites */
703
704	681	/**
705	682	* 0x00000 sprite attr (page0)
706	683	* 0x02000 sprite list (page0)
r17652	r17653
712	689	* 0x14000 sprite list (page1)
713	690	*/
714	691	template<class _BitmapClass>
715		static void
716		draw_spriteC355(running_machine &machine, _BitmapClass &bitmap, const rectangle &cliprect, const UINT16 *pSource, int pri, int zpos )
	692	void namcos2_shared_state::c355_obj_draw_sprite(_BitmapClass &bitmap, const rectangle &cliprect, const UINT16 *pSource, int pri, int zpos )
717	693	{
718		UINT16 *spriteram16 = m_spriteram;
	694	UINT16 *spriteram16 = m_c355_obj_ram;
719	695	unsigned screen_height_remaining, screen_width_remaining;
720	696	unsigned source_height_remaining, source_width_remaining;
721	697	int hpos,vpos;
r17652	r17653
762	738
763	739	if( linkno*4>=0x4000/2 ) return; /* avoid garbage memory reads */
764	740
765		xscroll = (INT16)mSpritePos[1];
766		yscroll = (INT16)mSpritePos[0];
	741	xscroll = (INT16)m_c355_obj_position[1];
	742	yscroll = (INT16)m_c355_obj_position[0];
767	743
768	744	//  xscroll &= 0x3ff; if( xscroll & 0x200 ) xscroll |= ~0x3ff;
769	745	xscroll &= 0x1ff; if( xscroll & 0x100 ) xscroll |= ~0x1ff;
r17652	r17653
771	747
772	748	if( bitmap.width() > 384 )
773	749	{ /* Medium Resolution: System21 adjust */
774		xscroll = (INT16)mSpritePos[1];
	750	xscroll = (INT16)m_c355_obj_position[1];
775	751	xscroll &= 0x3ff; if( xscroll & 0x200 ) xscroll |= ~0x3ff;
776	752	if( yscroll<0 )
777	753	{ /* solvalou */
r17652	r17653
781	757	}
782	758	else
783	759	{
784		if ((namcos2_gametype == NAMCOFL_SPEED_RACER) || (namcos2_gametype == NAMCOFL_FINAL_LAP_R))
	760	if ((m_gametype == NAMCOFL_SPEED_RACER) || (m_gametype == NAMCOFL_FINAL_LAP_R))
785	761	{ /* Namco FL: don't adjust and things line up fine */
786	762	}
787	763	else
r17652	r17653
836	812	vpos -= dy;
837	813	}
838	814
839		color = (palette&0xf)^mPalXOR;
	815	color = (palette&0xf)^m_c355_obj_palxor;
840	816
841	817	source_height_remaining = num_rows*16;
842	818	screen_height_remaining = vsize;
r17652	r17653
866	842	zdrawgfxzoom(
867	843	bitmap,
868	844	clip,
869		machine.gfx[mGfxC355],
870		mpCodeToTile(machine, tile) + offset,
	845	machine().gfx[m_c355_obj_gfxbank],
	846	m_c355_obj_code2tile(tile) + offset,
871	847	color,
872	848	flipx,flipy,
873	849	sx,sy,
r17652	r17653
887	863	screen_height_remaining -= tile_screen_height;
888	864	source_height_remaining -= 16;
889	865	} /* next row */
890		} /* draw_spriteC355 */
	866	}
891	867
892	868
893		static int DefaultCodeToTile( running_machine &machine, int code )
	869	int namcos2_shared_state::c355_obj_default_code2tile(int code)
894	870	{
895	871	return code;
896	872	}
897	873
898		void
899		namco_obj_init( running_machine &machine, int gfxbank, int palXOR, int (*codeToTile)( running_machine &machine, int code ) )
	874	void namcos2_shared_state::c355_obj_init(int gfxbank, int pal_xor, c355_obj_code2tile_delegate code2tile)
900	875	{
901		mGfxC355 = gfxbank;
902		mPalXOR = palXOR;
903		if( codeToTile )
904		{
905		mpCodeToTile = codeToTile;
906		}
	876	m_c355_obj_gfxbank = gfxbank;
	877	m_c355_obj_palxor = pal_xor;
	878	if (!code2tile.isnull())
	879	m_c355_obj_code2tile = code2tile;
907	880	else
908		{
909		mpCodeToTile = DefaultCodeToTile;
910		}
911		m_spriteram = auto_alloc_array(machine, UINT16, 0x20000/2);
912		memset( m_spriteram, 0, 0x20000 ); /* needed for Nebulas Ray */
913		memset( mSpritePos,0x00,sizeof(mSpritePos) );
914		} /* namcosC355_init */
	881	m_c355_obj_code2tile = c355_obj_code2tile_delegate(FUNC(namcos2_shared_state::c355_obj_default_code2tile), this);
915	882
	883	memset(&m_c355_obj_ram[0], 0, memshare("objram")->bytes()); // needed for Nebulas Ray
	884	memset(m_c355_obj_position, 0, sizeof(m_c355_obj_position));
	885	}
	886
916	887	template<class _BitmapClass>
917		static void
918		DrawObjectList(running_machine &machine,
919		_BitmapClass &bitmap,
920		const rectangle &cliprect,
921		int pri,
922		const UINT16 *pSpriteList16,
923		const UINT16 *pSpriteTable )
	888	void namcos2_shared_state::c355_obj_draw_list(_BitmapClass &bitmap, const rectangle &cliprect, int pri, const UINT16 *pSpriteList16, const UINT16 *pSpriteTable)
924	889	{
925	890	int i;
926	891	/* draw the sprites */
927	892	for( i=0; i<256; i++ )
928	893	{
929	894	UINT16 which = pSpriteList16[i];
930		draw_spriteC355(machine, bitmap, cliprect, &pSpriteTable[(which&0xff)*8], pri, i );
	895	c355_obj_draw_sprite(bitmap, cliprect, &pSpriteTable[(which&0xff)*8], pri, i );
931	896	if( which&0x100 ) break;
932	897	}
933		} /* DrawObjectList */
	898	}
934	899
935		void
936		namco_obj_draw(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
	900	void namcos2_shared_state::c355_obj_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri)
937	901	{
938	902	//  int offs = spriteram16[0x18000/2]; /* end-of-sprite-list */
939		if( pri==0 )
940		{
941		machine.priority_bitmap.fill(0, cliprect );
942		}
943		//  if( offs==0 )
944		{ /* boot */
945		DrawObjectList(machine, bitmap,cliprect,pri,&m_spriteram[0x02000/2], &m_spriteram[0x00000/2] );
946		}
	903	if (pri == 0)
	904	machine().priority_bitmap.fill(0, cliprect);
	905
	906	//  if (offs == 0)   // boot
	907	c355_obj_draw_list(bitmap, cliprect, pri, &m_c355_obj_ram[0x02000/2], &m_c355_obj_ram[0x00000/2]);
947	908	//  else
948		{
949		DrawObjectList(machine, bitmap,cliprect,pri,&m_spriteram[0x14000/2], &m_spriteram[0x10000/2] );
950		}
951		} /* namco_obj_draw */
	909	c355_obj_draw_list(bitmap, cliprect, pri, &m_c355_obj_ram[0x14000/2], &m_c355_obj_ram[0x10000/2]);
	910	}
952	911
953		void
954		namco_obj_draw(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int pri )
	912	void namcos2_shared_state::c355_obj_draw(bitmap_rgb32 &bitmap, const rectangle &cliprect, int pri)
955	913	{
956	914	//  int offs = spriteram16[0x18000/2]; /* end-of-sprite-list */
957		if( pri==0 )
958		{
959		machine.priority_bitmap.fill(0, cliprect );
960		}
961		//  if( offs==0 )
962		{ /* boot */
963		DrawObjectList(machine, bitmap,cliprect,pri,&m_spriteram[0x02000/2], &m_spriteram[0x00000/2] );
964		}
	915	if (pri == 0)
	916	machine().priority_bitmap.fill(0, cliprect);
	917
	918	//  if (offs == 0)   // boot
	919	c355_obj_draw_list(bitmap, cliprect, pri, &m_c355_obj_ram[0x02000/2], &m_c355_obj_ram[0x00000/2]);
965	920	//  else
966		{
967		DrawObjectList(machine, bitmap,cliprect,pri,&m_spriteram[0x14000/2], &m_spriteram[0x10000/2] );
968		}
969		} /* namco_obj_draw */
	921	c355_obj_draw_list(bitmap, cliprect, pri, &m_c355_obj_ram[0x14000/2], &m_c355_obj_ram[0x10000/2]);
	922	}
970	923
971		WRITE16_HANDLER( namco_obj16_w )
	924	WRITE16_MEMBER( namcos2_shared_state::c355_obj_ram_w )
972	925	{
973		COMBINE_DATA( &m_spriteram[offset] );
974		} /* namco_obj16_w */
	926	COMBINE_DATA(&m_c355_obj_ram[offset]);
	927	}
975	928
976		READ16_HANDLER( namco_obj16_r )
	929	READ16_MEMBER( namcos2_shared_state::c355_obj_ram_r )
977	930	{
978		return m_spriteram[offset];
979		} /* namco_obj16_r */
	931	return m_c355_obj_ram[offset];
	932	}
980	933
981		WRITE32_HANDLER( namco_obj32_w )
982		{
983		UINT16 *spriteram16 = m_spriteram;
984		UINT32 v;
985		offset *= 2;
986		v = (spriteram16[offset]<<16)|spriteram16[offset+1];
987		COMBINE_DATA( &v );
988		spriteram16[offset] = v>>16;
989		spriteram16[offset+1] = v&0xffff;
990		} /* namco_obj32_w */
991
992		READ32_HANDLER( namco_obj32_r )
993		{
994		UINT16 *spriteram16 = m_spriteram;
995		offset *= 2;
996		return (spriteram16[offset]<<16)|spriteram16[offset+1];
997		} /* namco_obj32_r */
998
999		WRITE32_HANDLER( namco_obj32_le_w )
1000		{
1001		UINT16 *spriteram16 = m_spriteram;
1002		UINT32 v;
1003		offset *= 2;
1004		v = (spriteram16[offset+1]<<16)|spriteram16[offset];
1005		COMBINE_DATA( &v );
1006		spriteram16[offset+1] = v>>16;
1007		spriteram16[offset] = v&0xffff;
1008		} /* namco_obj32_w */
1009
1010		READ32_HANDLER( namco_obj32_le_r )
1011		{
1012		UINT16 *spriteram16 = m_spriteram;
1013		offset *= 2;
1014		return (spriteram16[offset+1]<<16)|spriteram16[offset];
1015		} /* namco_obj32_r */
1016
1017	934	/**************************************************************************************************************/
1018	935
1019	936	/**
r17652	r17653
1027	944	*  Namco System 2 - Metal Hawk, Lucky and Wild
1028	945	*  Namco System FL - Final Lap R, Speed Racer
1029	946	*/
1030		#define ROZ_TILEMAP_COUNT 2
1031		static tilemap_t *mRozTilemap[ROZ_TILEMAP_COUNT];
1032		static UINT16 *rozbank16;
1033		static UINT16 *rozvideoram16;
1034		static UINT16 *rozcontrol16;
1035		static int mRozGfxBank;
1036		static const char * mRozMaskRegion;
1037	947
1038	948	/**
1039	949	* Graphics ROM addressing varies across games.
1040	950	*/
1041		static void
1042		roz_get_info( running_machine &machine, tile_data &tileinfo, int tile_index, int which)
	951	void namcos2_shared_state::c169_roz_get_info(tile_data &tileinfo, int tile_index, int which)
1043	952	{
1044		UINT16 tile = rozvideoram16[tile_index];
	953	UINT16 tile = m_c169_roz_videoram[tile_index];
1045	954	int bank, mangle;
1046	955
1047		switch( namcos2_gametype )
	956	switch (m_gametype)
1048	957	{
1049		case NAMCONB2_MACH_BREAKERS:
1050		bank = nth_byte16( &rozbank16[which*8/2], (tile>>11)&0x7 );
1051		tile = (tile&0x7ff)|(bank*0x800);
1052		mangle = tile;
1053		break;
	958	case NAMCONB2_MACH_BREAKERS:
	959	bank = nth_byte16(&m_c169_roz_bank[which * 8 / 2], (tile >> 11) & 0x7);
	960	tile = (tile & 0x7ff) | (bank * 0x800);
	961	mangle = tile;
	962	break;
1054	963
1055		case NAMCONB2_OUTFOXIES:
1056		bank = nth_byte16( &rozbank16[which*8/2], (tile>>11)&0x7 );
1057		tile = (tile&0x7ff)|(bank*0x800);
1058		mangle = tile&~(0x50);
1059		if( tile&0x10 ) mangle |= 0x40;
1060		if( tile&0x40 ) mangle |= 0x10;
1061		break;
	964	case NAMCONB2_OUTFOXIES:
	965	bank = nth_byte16(&m_c169_roz_bank[which * 8 / 2], (tile >> 11) & 0x7);
	966	tile = (tile & 0x7ff) | (bank * 0x800);
	967	mangle = tile & ~0x50;
	968	if (tile & 0x10) mangle |= 0x40;
	969	if (tile & 0x40) mangle |= 0x10;
	970	break;
1062	971
1063		case NAMCOS2_LUCKY_AND_WILD:
1064		mangle   = tile&0x01ff;
1065		tile &= 0x3fff;
1066		switch( tile>>9 )
1067		{
1068		case 0x00: mangle |= 0x1c00; break;
1069		case 0x01: mangle |= 0x0800; break;
1070		case 0x02: mangle |= 0x0000; break;
	972	case NAMCOS2_LUCKY_AND_WILD:
	973	mangle = tile & 0x01ff;
	974	tile &= 0x3fff;
	975	switch (tile >> 9)
	976	{
	977	case 0x00: mangle |= 0x1c00; break;
	978	case 0x01: mangle |= 0x0800; break;
	979	case 0x02: mangle |= 0x0000; break;
1071	980
1072		case 0x08: mangle |= 0x1e00; break;
1073		case 0x09: mangle |= 0x0a00; break;
1074		case 0x0a: mangle |= 0x0200; break;
	981	case 0x08: mangle |= 0x1e00; break;
	982	case 0x09: mangle |= 0x0a00; break;
	983	case 0x0a: mangle |= 0x0200; break;
1075	984
1076		case 0x10: mangle |= 0x2000; break;
1077		case 0x11: mangle |= 0x0c00; break;
1078		case 0x12: mangle |= 0x0400; break;
	985	case 0x10: mangle |= 0x2000; break;
	986	case 0x11: mangle |= 0x0c00; break;
	987	case 0x12: mangle |= 0x0400; break;
1079	988
1080		case 0x18: mangle |= 0x2200; break;
1081		case 0x19: mangle |= 0x0e00; break;
1082		case 0x1a: mangle |= 0x0600; break;
1083		}
1084		break;
	989	case 0x18: mangle |= 0x2200; break;
	990	case 0x19: mangle |= 0x0e00; break;
	991	case 0x1a: mangle |= 0x0600; break;
	992	}
	993	break;
1085	994
1086		case NAMCOS2_METAL_HAWK:
1087		mangle = tile&0x01ff;
1088		if( tile&0x1000 ) mangle |= 0x0200;
1089		if( tile&0x0200 ) mangle |= 0x0400;
1090		if( tile&0x0400 ) mangle |= 0x0800;
1091		if( tile&0x0800 ) mangle |= 0x1000;
1092		tile &= 0x3fff; /* cap mask offset */
1093		break;
	995	case NAMCOS2_METAL_HAWK:
	996	mangle = tile & 0x01ff;
	997	if (tile & 0x1000) mangle |= 0x0200;
	998	if (tile & 0x0200) mangle |= 0x0400;
	999	if (tile & 0x0400) mangle |= 0x0800;
	1000	if (tile & 0x0800) mangle |= 0x1000;
	1001	tile &= 0x3fff; // cap mask offset
	1002	break;
1094	1003
1095		default:
1096		case NAMCOFL_SPEED_RACER:
1097		case NAMCOFL_FINAL_LAP_R:
1098		mangle = tile;
1099		tile &= 0x3fff; /* cap mask offset */
1100		break;
	1004	default:
	1005	case NAMCOFL_SPEED_RACER:
	1006	case NAMCOFL_FINAL_LAP_R:
	1007	mangle = tile;
	1008	tile &= 0x3fff; // cap mask offset
	1009	break;
1101	1010	}
1102		SET_TILE_INFO( mRozGfxBank,mangle,0/*color*/,0/*flag*/ );
1103		tileinfo.mask_data = 32*tile + (UINT8 *)machine.root_device().memregion( mRozMaskRegion )->base();
1104		} /* roz_get_info */
	1011	SET_TILE_INFO_MEMBER(m_c169_roz_gfxbank, mangle, 0/*color*/, 0/*flag*/);
	1012	tileinfo.mask_data = m_c169_roz_mask + 32*tile;
	1013	}
1105	1014
1106		static
1107		TILE_GET_INFO( roz_get_info0 )
	1015	TILE_GET_INFO_MEMBER( namcos2_shared_state::c169_roz_get_info0 )
1108	1016	{
1109		roz_get_info( machine,tileinfo,tile_index,0 );
1110		} /* roz_get_info0 */
	1017	c169_roz_get_info(tileinfo, tile_index, 0);
	1018	}
1111	1019
1112		static
1113		TILE_GET_INFO( roz_get_info1 )
	1020	TILE_GET_INFO_MEMBER( namcos2_shared_state::c169_roz_get_info1 )
1114	1021	{
1115		roz_get_info( machine,tileinfo,tile_index,1 );
1116		} /* roz_get_info1 */
	1022	c169_roz_get_info(tileinfo, tile_index, 1);
	1023	}
1117	1024
1118		static
1119		TILEMAP_MAPPER( namco_roz_scan )
	1025	TILEMAP_MAPPER_MEMBER( namcos2_shared_state::c169_roz_mapper )
1120	1026	{
1121		if( col>=128 )
	1027	if (col >= 128)
1122	1028	{
1123	1029	col %= 128;
1124	1030	row += 256;
1125	1031	}
1126		return row*128+col;
1127		} /* namco_roz_scan*/
	1032	return row * 128 + col;
	1033	}
1128	1034
1129		void
1130		namco_roz_init( running_machine &machine, int gfxbank, const char * maskregion )
	1035	void namcos2_shared_state::c169_roz_init(int gfxbank, const char *maskregion)
1131	1036	{
1132		int i;
1133		static const tile_get_info_func roz_info[ROZ_TILEMAP_COUNT] =
1134		{
1135		roz_get_info0,
1136		roz_get_info1
1137		};
	1037	m_c169_roz_gfxbank = gfxbank;
	1038	m_c169_roz_mask = memregion(maskregion)->base();
1138	1039
1139		mRozGfxBank = gfxbank;
1140		mRozMaskRegion = maskregion;
	1040	m_c169_roz_tilemap[0] = &machine().tilemap().create(
	1041	tilemap_get_info_delegate(FUNC(namcos2_shared_state::c169_roz_get_info0), this),
	1042	tilemap_mapper_delegate(FUNC(namcos2_shared_state::c169_roz_mapper), this),
	1043	16,16,
	1044	256,256);
1141	1045
1142		rozbank16 = auto_alloc_array(machine, UINT16, 0x10/2);
1143		rozvideoram16 = auto_alloc_array(machine, UINT16, 0x20000/2);
1144		rozcontrol16 = auto_alloc_array(machine, UINT16, 0x20/2);
	1046	m_c169_roz_tilemap[1] = &machine().tilemap().create(
	1047	tilemap_get_info_delegate(FUNC(namcos2_shared_state::c169_roz_get_info1), this),
	1048	tilemap_mapper_delegate(FUNC(namcos2_shared_state::c169_roz_mapper), this),
	1049	16,16,
	1050	256,256);
1145	1051
1146		for( i=0; i<ROZ_TILEMAP_COUNT; i++ )
1147		{
1148		mRozTilemap[i] = tilemap_create(machine,
1149		roz_info[i],
1150		namco_roz_scan,
1151		16,16,
1152		256,256 );
1153		}
1154		} /* namco_roz_init */
	1052	}
1155	1053
1156		struct RozParam
	1054	void namcos2_shared_state::c169_roz_unpack_params(const UINT16 *source, roz_parameters &params)
1157	1055	{
1158		UINT32 left, top, size;
1159		UINT32 startx,starty;
1160		int incxx,incxy,incyx,incyy;
1161		int color,priority;
1162		};
1163
1164		static void
1165		UnpackRozParam( const UINT16 *pSource, struct RozParam *pRozParam )
1166		{
1167	1056	const int xoffset = 36, yoffset = 3;
1168	1057
1169	1058	/**
r17652	r17653
1173	1062	* --------.xxxx---- priority
1174	1063	* --------.----xxxx color
1175	1064	*/
1176		UINT16 temp = pSource[1];
1177		pRozParam->size     = 512<<((temp&0x0300)>>8);
1178		if ((namcos2_gametype == NAMCOFL_SPEED_RACER) || (namcos2_gametype == NAMCOFL_FINAL_LAP_R))
1179		{
1180		pRozParam->color    = (temp&0x0007)*256;
1181		}
	1065
	1066	UINT16 temp = source[1];
	1067	params.size = 512 << ((temp & 0x0300) >> 8);
	1068	if (m_gametype == NAMCOFL_SPEED_RACER || m_gametype == NAMCOFL_FINAL_LAP_R)
	1069	params.color = (temp & 0x0007) * 256;
1182	1070	else
1183		{
1184		pRozParam->color    = (temp&0x000f)*256;
1185		}
1186		pRozParam->priority = (temp&0x00f0)>>4;
	1071	params.color = (temp & 0x000f) * 256;
	1072	params.priority = (temp & 0x00f0) >> 4;
1187	1073
1188		temp = pSource[2];
1189		pRozParam->left = (temp&0x7000)>>3;
1190		if( temp&0x8000 ) temp |= 0xf000; else temp&=0x0fff; /* sign extend */
1191		pRozParam->incxx = (INT16)temp;
	1074	temp = source[2];
	1075	params.left = (temp & 0x7000) >> 3;
	1076	if (temp & 0x8000) temp |= 0xf000; else temp &= 0x0fff; // sign extend
	1077	params.incxx = INT16(temp);
1192	1078
1193		temp = pSource[3];
1194		pRozParam->top = (temp&0x7000)>>3;
1195		if( temp&0x8000 ) temp |= 0xf000; else temp&=0x0fff; /* sign extend */
1196		pRozParam->incxy =  (INT16)temp;
	1079	temp = source[3];
	1080	params.top = (temp&0x7000)>>3;
	1081	if (temp & 0x8000) temp |= 0xf000; else temp &= 0x0fff; // sign extend
	1082	params.incxy = INT16(temp);
1197	1083
1198		temp = pSource[4];
1199		if( temp&0x8000 ) temp |= 0xf000; else temp&=0x0fff; /* sign extend */
1200		pRozParam->incyx =  (INT16)temp;
	1084	temp = source[4];
	1085	if (temp & 0x8000) temp |= 0xf000; else temp &= 0x0fff; // sign extend
	1086	params.incyx = INT16(temp);
1201	1087
1202		temp = pSource[5];
1203		if( temp&0x8000 ) temp |= 0xf000; else temp&=0x0fff; /* sign extend */
1204		pRozParam->incyy =  (INT16)temp;
	1088	temp = source[5];
	1089	if (temp & 0x8000) temp |= 0xf000; else temp &= 0x0fff; // sign extend
	1090	params.incyy = INT16(temp);
1205	1091
1206		pRozParam->startx = (INT16)pSource[6];
1207		pRozParam->starty = (INT16)pSource[7];
1208		pRozParam->startx <<= 4;
1209		pRozParam->starty <<= 4;
	1092	params.startx = INT16(source[6]);
	1093	params.starty = INT16(source[7]);
	1094	params.startx <<= 4;
	1095	params.starty <<= 4;
1210	1096
1211		pRozParam->startx += xoffset * pRozParam->incxx + yoffset * pRozParam->incyx;
1212		pRozParam->starty += xoffset * pRozParam->incxy + yoffset * pRozParam->incyy;
	1097	params.startx += xoffset * params.incxx + yoffset * params.incyx;
	1098	params.starty += xoffset * params.incxy + yoffset * params.incyy;
1213	1099
1214		/* normalize */
1215		pRozParam->startx <<= 8;
1216		pRozParam->starty <<= 8;
1217		pRozParam->incxx <<= 8;
1218		pRozParam->incxy <<= 8;
1219		pRozParam->incyx <<= 8;
1220		pRozParam->incyy <<= 8;
1221		} /* UnpackRozParam */
	1100	// normalize
	1101	params.startx <<= 8;
	1102	params.starty <<= 8;
	1103	params.incxx <<= 8;
	1104	params.incxy <<= 8;
	1105	params.incyx <<= 8;
	1106	params.incyy <<= 8;
	1107	}
1222	1108
1223		static void
1224		DrawRozHelper(
1225		bitmap_ind16 &bitmap,
1226		tilemap_t *tmap,
1227		const rectangle &clip,
1228		const struct RozParam *rozInfo )
	1109	void namcos2_shared_state::c169_roz_draw_helper(bitmap_ind16 &bitmap, tilemap_t &tmap, const rectangle &clip, const roz_parameters &params)
1229	1110	{
1230
1231		if( (bitmap.bpp() == 16) &&
1232		(namcos2_gametype != NAMCOFL_SPEED_RACER) &&
1233		(namcos2_gametype != NAMCOFL_FINAL_LAP_R))
	1111	if (m_gametype != NAMCOFL_SPEED_RACER && m_gametype != NAMCOFL_FINAL_LAP_R)
1234	1112	{
1235		UINT32 size_mask = rozInfo->size-1;
1236		bitmap_ind16 &srcbitmap = tmap->pixmap();
1237		bitmap_ind8 &flagsbitmap = tmap->flagsmap();
1238		UINT32 startx = rozInfo->startx + clip.min_x * rozInfo->incxx + clip.min_y * rozInfo->incyx;
1239		UINT32 starty = rozInfo->starty + clip.min_x * rozInfo->incxy + clip.min_y * rozInfo->incyy;
	1113	UINT32 size_mask = params.size - 1;
	1114	bitmap_ind16 &srcbitmap = tmap.pixmap();
	1115	bitmap_ind8 &flagsbitmap = tmap.flagsmap();
	1116	UINT32 startx = params.startx + clip.min_x * params.incxx + clip.min_y * params.incyx;
	1117	UINT32 starty = params.starty + clip.min_x * params.incxy + clip.min_y * params.incyy;
1240	1118	int sx = clip.min_x;
1241	1119	int sy = clip.min_y;
1242		while( sy <= clip.max_y )
	1120	while (sy <= clip.max_y)
1243	1121	{
1244	1122	int x = sx;
1245	1123	UINT32 cx = startx;
1246	1124	UINT32 cy = starty;
1247		UINT16 *dest = &bitmap.pix16(sy, sx);
1248		while( x <= clip.max_x )
	1125	UINT16 *dest = &bitmap.pix(sy, sx);
	1126	while (x <= clip.max_x)
1249	1127	{
1250		UINT32 xpos = (((cx>>16)&size_mask) + rozInfo->left)&0xfff;
1251		UINT32 ypos = (((cy>>16)&size_mask) + rozInfo->top)&0xfff;
1252		if( flagsbitmap.pix8(ypos, xpos)&TILEMAP_PIXEL_LAYER0 )
1253		{
1254		*dest = srcbitmap.pix16(ypos, xpos)+rozInfo->color;
1255		}
1256		cx += rozInfo->incxx;
1257		cy += rozInfo->incxy;
	1128	UINT32 xpos = (((cx >> 16) & size_mask) + params.left) & 0xfff;
	1129	UINT32 ypos = (((cy >> 16) & size_mask) + params.top) & 0xfff;
	1130	if (flagsbitmap.pix(ypos, xpos) & TILEMAP_PIXEL_LAYER0)
	1131	*dest = srcbitmap.pix(ypos, xpos) + params.color;
	1132	cx += params.incxx;
	1133	cy += params.incxy;
1258	1134	x++;
1259	1135	dest++;
1260		} /* next x */
1261		startx += rozInfo->incyx;
1262		starty += rozInfo->incyy;
	1136	}
	1137	startx += params.incyx;
	1138	starty += params.incyy;
1263	1139	sy++;
1264		} /* next y */
	1140	}
1265	1141	}
1266	1142	else
1267
1268	1143	{
1269		tmap->set_palette_offset( rozInfo->color );
1270
1271		tmap->draw_roz(
	1144	tmap.set_palette_offset(params.color);
	1145	tmap.draw_roz(
1272	1146	bitmap,
1273	1147	clip,
1274		rozInfo->startx, rozInfo->starty,
1275		rozInfo->incxx, rozInfo->incxy,
1276		rozInfo->incyx, rozInfo->incyy,
	1148	params.startx, params.starty,
	1149	params.incxx, params.incxy,
	1150	params.incyx, params.incyy,
1277	1151	1,0,0); // wrap, flags, pri
1278	1152	}
1279		} /* DrawRozHelper */
	1153	}
1280	1154
1281		static void
1282		DrawRozScanline( bitmap_ind16 &bitmap, int line, int which, int pri, const rectangle &cliprect )
	1155	void namcos2_shared_state::c169_roz_draw_scanline(bitmap_ind16 &bitmap, int line, int which, int pri, const rectangle &cliprect)
1283	1156	{
1284		if( line>=cliprect.min_y && line<=cliprect.max_y )
	1157	if (line >= cliprect.min_y && line <= cliprect.max_y)
1285	1158	{
1286		struct RozParam rozInfo;
1287		rectangle clip;
1288		int row = line/8;
1289		int offs = row*0x100+(line&7)*0x10 + 0xe080;
1290		UINT16 *pSource = &rozvideoram16[offs/2];
1291		if( (pSource[1]&0x8000)==0 )
	1159	int row = line / 8;
	1160	int offs = row * 0x100 + (line & 7) * 0x10 + 0xe080;
	1161	UINT16 *source = &m_c169_roz_videoram[offs / 2];
	1162
	1163	// if enabled
	1164	if ((source[1] & 0x8000) == 0)
1292	1165	{
1293		UnpackRozParam( pSource, &rozInfo );
1294		if( pri == rozInfo.priority )
	1166	roz_parameters params;
	1167	c169_roz_unpack_params(source, params);
	1168
	1169	// check priority
	1170	if (pri == params.priority)
1295	1171	{
1296		clip.set(0, bitmap.width()-1, line, line);
	1172	rectangle clip(0, bitmap.width() - 1, line, line);
1297	1173	clip &= cliprect;
1298
1299		DrawRozHelper( bitmap, mRozTilemap[which], clip, &rozInfo );
1300		} /* priority */
1301		} /* enabled */
	1174	c169_roz_draw_helper(bitmap, *m_c169_roz_tilemap[which], clip, params);
	1175	}
	1176	}
1302	1177	}
1303		} /* DrawRozScanline */
	1178	}
1304	1179
1305		void
1306		namco_roz_draw( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
	1180	void namcos2_shared_state::c169_roz_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri)
1307	1181	{
1308		int mode = rozcontrol16[0]; /* 0x8000 or 0x1000 */
1309		int which, special = 1;
	1182	int special = (m_gametype == NAMCOFL_SPEED_RACER || m_gametype == NAMCOFL_FINAL_LAP_R) ? 0 : 1;
	1183	int mode = m_c169_roz_control[0]; // 0x8000 or 0x1000
1310	1184
1311		if ((namcos2_gametype == NAMCOFL_SPEED_RACER) || (namcos2_gametype == NAMCOFL_FINAL_LAP_R))
	1185	for (int which = 1; which >= 0; which--)
1312	1186	{
1313		special = 0;
1314		}
1315
1316		for( which=1; which>=0; which-- )
1317		{
1318		const UINT16 *pSource = &rozcontrol16[which*8];
1319		UINT16 attrs = pSource[1];
1320		if( (attrs&0x8000)==0 )
1321		{ /* layer is enabled */
1322		if( which==special && mode==0x8000 )
1323		{ /* second ROZ layer is configured to use per-scanline registers */
1324		int line;
1325		for( line=0; line<224; line++ )
1326		{
1327		DrawRozScanline( bitmap, line, which, pri, cliprect/*, tmap*/ );
1328		}
	1187	const UINT16 *source = &m_c169_roz_control[which * 8];
	1188	UINT16 attrs = source[1];
	1189
	1190	// if enabled
	1191	if ((attrs & 0x8000) == 0)
	1192	{
	1193	// second ROZ layer is configured to use per-scanline registers
	1194	if (which == special && mode == 0x8000)
	1195	{
	1196	for (int line = 0; line < 224; line++)
	1197	c169_roz_draw_scanline(bitmap, line, which, pri, cliprect);
1329	1198	}
1330	1199	else
1331	1200	{
1332		struct RozParam rozInfo;
1333		UnpackRozParam( pSource, &rozInfo );
1334		if( rozInfo.priority == pri )
1335		{
1336		DrawRozHelper( bitmap, mRozTilemap[which], cliprect, &rozInfo );
1337		} /* roz_pri==pri */
	1201	roz_parameters params;
	1202	c169_roz_unpack_params(source, params);
	1203	if (params.priority == pri)
	1204	c169_roz_draw_helper(bitmap, *m_c169_roz_tilemap[which], cliprect, params);
1338	1205	}
1339		} /* enable */
1340		} /* which */
1341		} /* namco_roz_draw */
1342
1343		READ16_HANDLER( namco_rozcontrol16_r )
1344		{
1345		return rozcontrol16[offset];
1346		} /* namco_rozcontrol16_r */
1347
1348		WRITE16_HANDLER( namco_rozcontrol16_w )
1349		{
1350		COMBINE_DATA( &rozcontrol16[offset] );
1351		} /* namco_rozcontrol16_w */
1352
1353		#ifdef UNUSED_FUNCTION
1354		READ16_HANDLER( namco_rozbank16_r )
1355		{
1356		return rozbank16[offset];
1357		} /* namco_rozbank16_r */
1358
1359		WRITE16_HANDLER( namco_rozbank16_w )
1360		{
1361		UINT16 old_data = rozbank16[offset];
1362		COMBINE_DATA( &rozbank16[offset] );
1363		if( rozbank16[offset]!=old_data )
1364		{
1365		int i;
1366		for( i=0; i<ROZ_TILEMAP_COUNT; i++ )
1367		{
1368		mRozTilemap[i]->mark_all_dirty();
1369	1206	}
1370		}
1371		} /* namco_rozbank16_w */
1372		#endif
	1207	}
	1208	}
1373	1209
1374		static void
1375		writerozvideo( int offset, UINT16 data )
	1210	READ16_MEMBER( namcos2_shared_state::c169_roz_control_r )
1376	1211	{
1377		int i;
1378		rozvideoram16[offset] = data;
1379		for( i=0; i<ROZ_TILEMAP_COUNT; i++ )
1380		{
1381		mRozTilemap[i]->mark_tile_dirty( offset );
1382		}
1383		} /* writerozvideo */
	1212	return m_c169_roz_control[offset];
	1213	}
1384	1214
1385		READ16_HANDLER( namco_rozvideoram16_r )
	1215	WRITE16_MEMBER( namcos2_shared_state::c169_roz_control_w )
1386	1216	{
1387		return rozvideoram16[offset];
1388		} /* namco_rozvideoram16_r */
	1217	COMBINE_DATA(&m_c169_roz_control[offset]);
	1218	}
1389	1219
1390		WRITE16_HANDLER( namco_rozvideoram16_w )
	1220	READ16_MEMBER( namcos2_shared_state::c169_roz_bank_r )
1391	1221	{
1392		UINT16 v = rozvideoram16[offset];
1393		COMBINE_DATA( &v );
1394		writerozvideo( offset, v );
1395		} /* namco_rozvideoram16_w */
	1222	return m_c169_roz_bank[offset];
	1223	}
1396	1224
1397		READ32_HANDLER( namco_rozcontrol32_r )
	1225	WRITE16_MEMBER( namcos2_shared_state::c169_roz_bank_w )
1398	1226	{
1399		offset *= 2;
1400		return (rozcontrol16[offset]<<16)|rozcontrol16[offset+1];
1401		} /* namco_rozcontrol32_r */
	1227	UINT16 old_data = m_c169_roz_bank[offset];
	1228	COMBINE_DATA(&m_c169_roz_bank[offset]);
	1229	if (m_c169_roz_bank[offset] != old_data)
	1230	for (int i = 0; i < ROZ_TILEMAP_COUNT; i++)
	1231	m_c169_roz_tilemap[i]->mark_all_dirty();
	1232	}
1402	1233
1403		WRITE32_HANDLER( namco_rozcontrol32_w )
	1234	READ16_MEMBER( namcos2_shared_state::c169_roz_videoram_r )
1404	1235	{
1405		UINT32 v;
1406		offset *=2;
1407		v = (rozcontrol16[offset]<<16)|rozcontrol16[offset+1];
1408		COMBINE_DATA(&v);
1409		rozcontrol16[offset] = v>>16;
1410		rozcontrol16[offset+1] = v&0xffff;
1411		} /* namco_rozcontrol32_w */
	1236	return m_c169_roz_videoram[offset];
	1237	}
1412	1238
1413		READ32_HANDLER( namco_rozcontrol32_le_r )
	1239	WRITE16_MEMBER( namcos2_shared_state::c169_roz_videoram_w )
1414	1240	{
1415		offset *= 2;
1416		return (rozcontrol16[offset]<<16)|rozcontrol16[offset+1];
1417		} /* namco_rozcontrol32_le_r */
	1241	COMBINE_DATA(&m_c169_roz_videoram[offset]);
	1242	for (int i = 0; i < ROZ_TILEMAP_COUNT; i++)
	1243	m_c169_roz_tilemap[i]->mark_tile_dirty(offset);
	1244	}
1418	1245
1419		WRITE32_HANDLER( namco_rozcontrol32_le_w )
1420		{
1421		UINT32 v;
1422		offset *=2;
1423		v = (rozcontrol16[offset+1]<<16)|rozcontrol16[offset];
1424		COMBINE_DATA(&v);
1425		rozcontrol16[offset+1] = v>>16;
1426		rozcontrol16[offset] = v&0xffff;
1427		} /* namco_rozcontrol32_le_w */
1428
1429		READ32_HANDLER( namco_rozbank32_r )
1430		{
1431		offset *= 2;
1432		return (rozbank16[offset]<<16)|rozbank16[offset+1];
1433		} /* namco_rozbank32_r */
1434
1435		WRITE32_HANDLER( namco_rozbank32_w )
1436		{
1437		UINT32 v;
1438		offset *=2;
1439		v = (rozbank16[offset]<<16)|rozbank16[offset+1];
1440		COMBINE_DATA(&v);
1441		rozbank16[offset] = v>>16;
1442		rozbank16[offset+1] = v&0xffff;
1443		} /* namco_rozbank32_w */
1444
1445		READ32_HANDLER( namco_rozvideoram32_r )
1446		{
1447		offset *= 2;
1448		return (rozvideoram16[offset]<<16)|rozvideoram16[offset+1];
1449		} /* namco_rozvideoram32_r */
1450
1451		WRITE32_HANDLER( namco_rozvideoram32_w )
1452		{
1453		UINT32 v;
1454		offset *= 2;
1455		v = (rozvideoram16[offset]<<16)|rozvideoram16[offset+1];
1456		COMBINE_DATA( &v );
1457		writerozvideo(offset,v>>16);
1458		writerozvideo(offset+1,v&0xffff);
1459		} /* namco_rozvideoram32_w */
1460
1461		READ32_HANDLER( namco_rozvideoram32_le_r )
1462		{
1463		offset *= 2;
1464		return (rozvideoram16[offset+1]<<16)|rozvideoram16[offset];
1465		} /* namco_rozvideoram32_le_r */
1466
1467		WRITE32_HANDLER( namco_rozvideoram32_le_w )
1468		{
1469		UINT32 v;
1470		offset *= 2;
1471		v = (rozvideoram16[offset+1]<<16)|rozvideoram16[offset];
1472		COMBINE_DATA( &v );
1473		writerozvideo(offset+1,v>>16);
1474		writerozvideo(offset,v&0xffff);
1475		} /* namco_rozvideoram32_le_w */
1476
1477	1246	/**************************************************************************************************************/
1478	1247	/*
1479	1248	Land Line Buffer

trunk/src/mame/drivers/namcofl.c

r17652	r17653
156	156	*/
157	157
158	158	#include "emu.h"
159		#include "includes/namcos2.h"
160	159	#include "includes/namcoic.h"
161	160	#include "cpu/i960/i960.h"
162	161	#include "cpu/m37710/m37710.h"
r17652	r17653
236	235	AM_RANGE(0x30400000, 0x3040ffff) AM_RAM_WRITE(namcofl_paletteram_w) AM_SHARE("paletteram")
237	236	AM_RANGE(0x30800000, 0x3080ffff) AM_READWRITE_LEGACY(namco_tilemapvideoram32_le_r, namco_tilemapvideoram32_le_w )
238	237	AM_RANGE(0x30a00000, 0x30a0003f) AM_READWRITE_LEGACY(namco_tilemapcontrol32_le_r, namco_tilemapcontrol32_le_w )
239		AM_RANGE(0x30c00000, 0x30c1ffff) AM_READWRITE_LEGACY(namco_rozvideoram32_le_r,namco_rozvideoram32_le_w)
240		AM_RANGE(0x30d00000, 0x30d0001f) AM_READWRITE_LEGACY(namco_rozcontrol32_le_r,namco_rozcontrol32_le_w)
241		AM_RANGE(0x30e00000, 0x30e1ffff) AM_READWRITE_LEGACY(namco_obj32_le_r, namco_obj32_le_w)
	238	AM_RANGE(0x30c00000, 0x30c1ffff) AM_READWRITE16(c169_roz_videoram_r,c169_roz_videoram_w,0xffffffff) AM_SHARE("rozvideoram")
	239	AM_RANGE(0x30d00000, 0x30d0001f) AM_READWRITE16(c169_roz_control_r,c169_roz_control_w,0xffffffff)
	240	AM_RANGE(0x30e00000, 0x30e1ffff) AM_READWRITE16(c355_obj_ram_r,c355_obj_ram_w,0xffffffff) AM_SHARE("objram")
242	241	AM_RANGE(0x30f00000, 0x30f0000f) AM_RAM /* NebulaM2 code says this is int enable at 0000, int request at 0004, but doesn't do much about it */
243	242	AM_RANGE(0x40000000, 0x4000005f) AM_READWRITE(namcofl_sysreg_r, namcofl_sysreg_w )
244	243	AM_RANGE(0xfffffffc, 0xffffffff) AM_READ(fl_unk1_r )
r17652	r17653
818	817	DRIVER_INIT_MEMBER(namcofl_state,speedrcr)
819	818	{
820	819	namcofl_common_init(machine());
821		namcos2_gametype = NAMCOFL_SPEED_RACER;
	820	m_gametype = NAMCOFL_SPEED_RACER;
822	821	}
823	822
824	823	DRIVER_INIT_MEMBER(namcofl_state,finalapr)
825	824	{
826	825	namcofl_common_init(machine());
827		namcos2_gametype = NAMCOFL_FINAL_LAP_R;
	826	m_gametype = NAMCOFL_FINAL_LAP_R;
828	827	}
829	828
830	829	GAME ( 1995, speedrcr,         0, namcofl, speedrcr, namcofl_state, speedrcr, ROT0, "Namco", "Speed Racer", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_SOUND )

trunk/src/mame/drivers/namcos2.c

r17652	r17653
538	538	{
539	539	m_dpram[offset] = data&0xff;
540	540
541		if( namcos2_gametype==NAMCOS2_GOLLY_GHOST )
	541	if( m_gametype==NAMCOS2_GOLLY_GHOST )
542	542	{
543	543	switch( offset )
544	544	{
r17652	r17653
601	601	/*************************************************************/
602	602
603	603	static ADDRESS_MAP_START( common_default_am, AS_PROGRAM, 16, namcos2_state )
604		AM_RANGE(0xc00000, 0xc03fff) AM_READWRITE(spriteram_word_r, spriteram_word_w) AM_SHARE("spriteram")
605		AM_RANGE(0xc40000, 0xc40001) AM_READWRITE_LEGACY(namcos2_gfx_ctrl_r,namcos2_gfx_ctrl_w)
606		AM_RANGE(0xc80000, 0xc9ffff) AM_READWRITE(rozram_word_r,rozram_word_w) AM_SHARE("rozram")
607		AM_RANGE(0xcc0000, 0xcc000f) AM_READWRITE(roz_ctrl_word_r, roz_ctrl_word_w)
	604	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_SHARE("spriteram")
	605	AM_RANGE(0xc40000, 0xc40001) AM_READWRITE(gfx_ctrl_r, gfx_ctrl_w)
	606	AM_RANGE(0xc80000, 0xc9ffff) AM_RAM_WRITE(rozram_word_w) AM_SHARE("rozram")
	607	AM_RANGE(0xcc0000, 0xcc000f) AM_RAM AM_SHARE("rozctrl")
608	608	AM_RANGE(0xd00000, 0xd0000f) AM_READWRITE_LEGACY(namcos2_68k_key_r,namcos2_68k_key_w)
609	609	AM_IMPORT_FROM( namcos2_68k_default_cpu_board_am )
610	610	ADDRESS_MAP_END
r17652	r17653
629	629
630	630	static ADDRESS_MAP_START( common_finallap_am, AS_PROGRAM, 16, namcos2_state )
631	631	AM_RANGE(0x300000, 0x33ffff) AM_READ_LEGACY(namcos2_flap_prot_r)
632		AM_RANGE(0x800000, 0x80ffff) AM_READWRITE(spriteram_word_r, spriteram_word_w) AM_SHARE("spriteram")
633		AM_RANGE(0x840000, 0x840001) AM_READ_LEGACY(namcos2_gfx_ctrl_r) AM_WRITE_LEGACY(namcos2_gfx_ctrl_w)
	632	AM_RANGE(0x800000, 0x80ffff) AM_RAM AM_SHARE("spriteram")
	633	AM_RANGE(0x840000, 0x840001) AM_READWRITE(gfx_ctrl_r, gfx_ctrl_w)
634	634	AM_RANGE(0x880000, 0x89ffff) AM_READ_LEGACY(namco_road16_r) AM_WRITE_LEGACY(namco_road16_w)
635	635	AM_RANGE(0x8c0000, 0x8c0001) AM_WRITENOP
636	636	AM_IMPORT_FROM( namcos2_68k_default_cpu_board_am )
r17652	r17653
654	654	/*************************************************************/
655	655
656	656	static ADDRESS_MAP_START( common_sgunner_am, AS_PROGRAM, 16, namcos2_state )
657		AM_RANGE(0x800000, 0x8141ff) AM_READWRITE_LEGACY(namco_obj16_r,namco_obj16_w)
	657	AM_RANGE(0x800000, 0x8141ff) AM_READWRITE(c355_obj_ram_r,c355_obj_ram_w) AM_SHARE("objram")
658	658	AM_RANGE(0x818000, 0x818001) AM_WRITENOP
659	659	AM_RANGE(0xa00000, 0xa0000f) AM_READWRITE_LEGACY(namcos2_68k_key_r,namcos2_68k_key_w)
660	660	AM_IMPORT_FROM( namcos2_68k_default_cpu_board_am )
r17652	r17653
678	678	/*************************************************************/
679	679
680	680	static ADDRESS_MAP_START( common_metlhawk_am, AS_PROGRAM, 16, namcos2_state )
681		AM_RANGE(0xc00000, 0xc03fff) AM_READWRITE(spriteram_word_r, spriteram_word_w) AM_SHARE("spriteram") \
682		AM_RANGE(0xc40000, 0xc4ffff) AM_READWRITE_LEGACY(namco_rozvideoram16_r,namco_rozvideoram16_w) \
683		AM_RANGE(0xd00000, 0xd0001f) AM_READWRITE_LEGACY(namco_rozcontrol16_r,namco_rozcontrol16_w) \
684		AM_RANGE(0xe00000, 0xe00001) AM_READWRITE_LEGACY(namcos2_gfx_ctrl_r,namcos2_gfx_ctrl_w) /* ??? */ \
	681	AM_RANGE(0xc00000, 0xc03fff) AM_RAM AM_SHARE("spriteram") \
	682	AM_RANGE(0xc40000, 0xc4ffff) AM_READWRITE(c169_roz_videoram_r,c169_roz_videoram_w) AM_SHARE("rozvideoram") \
	683	AM_RANGE(0xd00000, 0xd0001f) AM_READWRITE(c169_roz_control_r,c169_roz_control_w) \
	684	AM_RANGE(0xe00000, 0xe00001) AM_READWRITE(gfx_ctrl_r, gfx_ctrl_w) /* ??? */ \
685	685	AM_IMPORT_FROM( namcos2_68k_default_cpu_board_am )
686	686	ADDRESS_MAP_END
687	687
r17652	r17653
703	703	/*************************************************************/
704	704
705	705	static ADDRESS_MAP_START( common_luckywld_am, AS_PROGRAM, 16, namcos2_state )
706		AM_RANGE(0x800000, 0x8141ff) AM_READWRITE_LEGACY(namco_obj16_r,namco_obj16_w)
	706	AM_RANGE(0x800000, 0x8141ff) AM_READWRITE(c355_obj_ram_r,c355_obj_ram_w) AM_SHARE("objram")
707	707	AM_RANGE(0x818000, 0x818001) AM_NOP /* enable? */
708	708	AM_RANGE(0x81a000, 0x81a001) AM_WRITENOP /* enable? */
709	709	AM_RANGE(0x840000, 0x840001) AM_READNOP
710		AM_RANGE(0x900000, 0x900007) AM_READWRITE_LEGACY(namco_spritepos16_r,namco_spritepos16_w)
	710	AM_RANGE(0x900000, 0x900007) AM_READWRITE(c355_obj_position_r,c355_obj_position_w)
711	711	AM_RANGE(0xa00000, 0xa1ffff) AM_READWRITE_LEGACY(namco_road16_r,namco_road16_w)
712		AM_RANGE(0xc00000, 0xc0ffff) AM_READWRITE_LEGACY(namco_rozvideoram16_r,namco_rozvideoram16_w)
713		AM_RANGE(0xd00000, 0xd0001f) AM_READWRITE_LEGACY(namco_rozcontrol16_r,namco_rozcontrol16_w)
	712	AM_RANGE(0xc00000, 0xc0ffff) AM_READWRITE(c169_roz_videoram_r,c169_roz_videoram_w) AM_SHARE("rozvideoram")
	713	AM_RANGE(0xd00000, 0xd0001f) AM_READWRITE(c169_roz_control_r,c169_roz_control_w)
714	714	AM_RANGE(0xf00000, 0xf00007) AM_READWRITE_LEGACY(namcos2_68k_key_r,namcos2_68k_key_w)
715	715	AM_IMPORT_FROM( namcos2_68k_default_cpu_board_am )
716	716	ADDRESS_MAP_END
r17652	r17653
5004	5004
5005	5005	DRIVER_INIT_MEMBER(namcos2_state,assault)
5006	5006	{
5007		namcos2_gametype=NAMCOS2_ASSAULT;
	5007	m_gametype=NAMCOS2_ASSAULT;
5008	5008	}
5009	5009
5010	5010	DRIVER_INIT_MEMBER(namcos2_state,assaultj)
5011	5011	{
5012		namcos2_gametype=NAMCOS2_ASSAULT_JP;
	5012	m_gametype=NAMCOS2_ASSAULT_JP;
5013	5013	}
5014	5014
5015	5015	DRIVER_INIT_MEMBER(namcos2_state,assaultp)
5016	5016	{
5017		namcos2_gametype=NAMCOS2_ASSAULT_PLUS;
	5017	m_gametype=NAMCOS2_ASSAULT_PLUS;
5018	5018	}
5019	5019
5020	5020	DRIVER_INIT_MEMBER(namcos2_state,assaultp_hack)
r17652	r17653
5033	5033
5034	5034	DRIVER_INIT_MEMBER(namcos2_state,burnforc)
5035	5035	{
5036		namcos2_gametype=NAMCOS2_BURNING_FORCE;
	5036	m_gametype=NAMCOS2_BURNING_FORCE;
5037	5037	}
5038	5038
5039	5039	DRIVER_INIT_MEMBER(namcos2_state,cosmogng)
5040	5040	{
5041		namcos2_gametype=NAMCOS2_COSMO_GANG;
	5041	m_gametype=NAMCOS2_COSMO_GANG;
5042	5042	}
5043	5043
5044	5044	DRIVER_INIT_MEMBER(namcos2_state,dsaber)
5045	5045	{
5046		namcos2_gametype=NAMCOS2_DRAGON_SABER;
	5046	m_gametype=NAMCOS2_DRAGON_SABER;
5047	5047	}
5048	5048
5049	5049	DRIVER_INIT_MEMBER(namcos2_state,dsaberj)
5050	5050	{
5051		namcos2_gametype=NAMCOS2_DRAGON_SABER;
	5051	m_gametype=NAMCOS2_DRAGON_SABER;
5052	5052	}
5053	5053
5054	5054	DRIVER_INIT_MEMBER(namcos2_state,dirtfoxj)
5055	5055	{
5056		namcos2_gametype=NAMCOS2_DIRT_FOX_JP;
	5056	m_gametype=NAMCOS2_DIRT_FOX_JP;
5057	5057	}
5058	5058
5059	5059	DRIVER_INIT_MEMBER(namcos2_state,finallap)
5060	5060	{
5061		namcos2_gametype=NAMCOS2_FINAL_LAP;
	5061	m_gametype=NAMCOS2_FINAL_LAP;
5062	5062	}
5063	5063
5064	5064	DRIVER_INIT_MEMBER(namcos2_state,finalap2)
5065	5065	{
5066		namcos2_gametype=NAMCOS2_FINAL_LAP_2;
	5066	m_gametype=NAMCOS2_FINAL_LAP_2;
5067	5067	}
5068	5068
5069	5069	DRIVER_INIT_MEMBER(namcos2_state,finalap3)
5070	5070	{
5071		namcos2_gametype=NAMCOS2_FINAL_LAP_3;
	5071	m_gametype=NAMCOS2_FINAL_LAP_3;
5072	5072	}
5073	5073
5074	5074	DRIVER_INIT_MEMBER(namcos2_state,finehour)
5075	5075	{
5076		namcos2_gametype=NAMCOS2_FINEST_HOUR;
	5076	m_gametype=NAMCOS2_FINEST_HOUR;
5077	5077	}
5078	5078
5079	5079	DRIVER_INIT_MEMBER(namcos2_state,fourtrax)
5080	5080	{
5081		namcos2_gametype=NAMCOS2_FOUR_TRAX;
	5081	m_gametype=NAMCOS2_FOUR_TRAX;
5082	5082	}
5083	5083
5084	5084	DRIVER_INIT_MEMBER(namcos2_state,kyukaidk)
5085	5085	{
5086		namcos2_gametype=NAMCOS2_KYUUKAI_DOUCHUUKI;
	5086	m_gametype=NAMCOS2_KYUUKAI_DOUCHUUKI;
5087	5087	}
5088	5088
5089	5089	DRIVER_INIT_MEMBER(namcos2_state,marvlanj)
5090	5090	{
5091		namcos2_gametype=NAMCOS2_MARVEL_LAND;
	5091	m_gametype=NAMCOS2_MARVEL_LAND;
5092	5092	}
5093	5093
5094	5094	DRIVER_INIT_MEMBER(namcos2_state,marvland)
5095	5095	{
5096		namcos2_gametype=NAMCOS2_MARVEL_LAND;
	5096	m_gametype=NAMCOS2_MARVEL_LAND;
5097	5097	}
5098	5098
5099	5099	DRIVER_INIT_MEMBER(namcos2_state,metlhawk)
r17652	r17653
5151	5151	} /* next k */
5152	5152	} /* next j */
5153	5153	} /* next i */
5154		namcos2_gametype=NAMCOS2_METAL_HAWK;
	5154	m_gametype=NAMCOS2_METAL_HAWK;
5155	5155	} /* metlhawk */
5156	5156
5157	5157	DRIVER_INIT_MEMBER(namcos2_state,mirninja)
5158	5158	{
5159		namcos2_gametype=NAMCOS2_MIRAI_NINJA;
	5159	m_gametype=NAMCOS2_MIRAI_NINJA;
5160	5160	}
5161	5161
5162	5162	DRIVER_INIT_MEMBER(namcos2_state,ordyne)
5163	5163	{
5164		namcos2_gametype=NAMCOS2_ORDYNE;
	5164	m_gametype=NAMCOS2_ORDYNE;
5165	5165	}
5166	5166
5167	5167	DRIVER_INIT_MEMBER(namcos2_state,phelios)
5168	5168	{
5169		namcos2_gametype=NAMCOS2_PHELIOS;
	5169	m_gametype=NAMCOS2_PHELIOS;
5170	5170	}
5171	5171
5172	5172	DRIVER_INIT_MEMBER(namcos2_state,rthun2)
5173	5173	{
5174		namcos2_gametype=NAMCOS2_ROLLING_THUNDER_2;
	5174	m_gametype=NAMCOS2_ROLLING_THUNDER_2;
5175	5175	}
5176	5176
5177	5177	DRIVER_INIT_MEMBER(namcos2_state,rthun2j)
5178	5178	{
5179		namcos2_gametype=NAMCOS2_ROLLING_THUNDER_2;
	5179	m_gametype=NAMCOS2_ROLLING_THUNDER_2;
5180	5180	}
5181	5181
5182	5182	DRIVER_INIT_MEMBER(namcos2_state,sgunner2)
5183	5183	{
5184		namcos2_gametype=NAMCOS2_STEEL_GUNNER_2;
	5184	m_gametype=NAMCOS2_STEEL_GUNNER_2;
5185	5185	}
5186	5186
5187	5187	DRIVER_INIT_MEMBER(namcos2_state,sws)
5188	5188	{
5189		namcos2_gametype=NAMCOS2_SUPER_WSTADIUM;
	5189	m_gametype=NAMCOS2_SUPER_WSTADIUM;
5190	5190	}
5191	5191
5192	5192	DRIVER_INIT_MEMBER(namcos2_state,sws92)
5193	5193	{
5194		namcos2_gametype=NAMCOS2_SUPER_WSTADIUM_92;
	5194	m_gametype=NAMCOS2_SUPER_WSTADIUM_92;
5195	5195	}
5196	5196
5197	5197	DRIVER_INIT_MEMBER(namcos2_state,sws92g)
5198	5198	{
5199		namcos2_gametype=NAMCOS2_SUPER_WSTADIUM_92T;
	5199	m_gametype=NAMCOS2_SUPER_WSTADIUM_92T;
5200	5200	}
5201	5201
5202	5202	DRIVER_INIT_MEMBER(namcos2_state,sws93)
5203	5203	{
5204		namcos2_gametype=NAMCOS2_SUPER_WSTADIUM_93;
	5204	m_gametype=NAMCOS2_SUPER_WSTADIUM_93;
5205	5205	}
5206	5206
5207	5207	DRIVER_INIT_MEMBER(namcos2_state,suzuka8h)
5208	5208	{
5209		namcos2_gametype=NAMCOS2_SUZUKA_8_HOURS;
	5209	m_gametype=NAMCOS2_SUZUKA_8_HOURS;
5210	5210	}
5211	5211
5212	5212	DRIVER_INIT_MEMBER(namcos2_state,suzuk8h2)
5213	5213	{
5214		namcos2_gametype=NAMCOS2_SUZUKA_8_HOURS_2;
	5214	m_gametype=NAMCOS2_SUZUKA_8_HOURS_2;
5215	5215	}
5216	5216
5217	5217	DRIVER_INIT_MEMBER(namcos2_state,valkyrie)
5218	5218	{
5219		namcos2_gametype=NAMCOS2_VALKYRIE;
	5219	m_gametype=NAMCOS2_VALKYRIE;
5220	5220	}
5221	5221
5222	5222	DRIVER_INIT_MEMBER(namcos2_state,gollygho)
5223	5223	{
5224		namcos2_gametype=NAMCOS2_GOLLY_GHOST;
	5224	m_gametype=NAMCOS2_GOLLY_GHOST;
5225	5225	}
5226	5226
5227	5227	DRIVER_INIT_MEMBER(namcos2_state,bubbletr)
5228	5228	{
5229		namcos2_gametype=NAMCOS2_BUBBLE_TROUBLE;
	5229	m_gametype=NAMCOS2_BUBBLE_TROUBLE;
5230	5230	}
5231	5231
5232	5232
r17652	r17653
5249	5249	if( code&0x80 ) out |= 0x01;
5250	5250	pData[i] = out;
5251	5251	}
5252		namcos2_gametype=NAMCOS2_LUCKY_AND_WILD;
	5252	m_gametype=NAMCOS2_LUCKY_AND_WILD;
5253	5253	}
5254	5254
5255	5255	/* Based on the dumped BIOS versions it looks like Namco changed the BIOS rom */

trunk/src/emu/tilemap.h

r17652	r17653
638	638
639	639	// function definition for a get info callback
640	640	#define TILE_GET_INFO(_name)         void _name(running_machine &machine, tile_data &tileinfo, tilemap_memory_index tile_index, void *param)
	641	#define TILE_GET_INFO_MEMBER(_name)      void _name(tile_data &tileinfo, tilemap_memory_index tile_index, void *param)
641	642	#define TILE_GET_INFO_DEVICE(_name)      void _name(device_t *device, tile_data &tileinfo, tilemap_memory_index tile_index, void *param)
642	643
643	644	// function definition for a logical-to-memory mapper
644	645	#define TILEMAP_MAPPER(_name)         tilemap_memory_index _name(running_machine &machine, UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows)
	646	#define TILEMAP_MAPPER_MEMBER(_name)   tilemap_memory_index _name(UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows)
645	647
646	648	// useful macro inside of a TILE_GET_INFO callback to set tile information
647	649	#define SET_TILE_INFO(GFX,CODE,COLOR,FLAGS)         tileinfo.set(machine, GFX, CODE, COLOR, FLAGS)
	650	#define SET_TILE_INFO_MEMBER(GFX,CODE,COLOR,FLAGS)  tileinfo.set(machine(), GFX, CODE, COLOR, FLAGS)
648	651	#define SET_TILE_INFO_DEVICE(GFX,CODE,COLOR,FLAGS)  tileinfo.set(device->machine(), GFX, CODE, COLOR, FLAGS)
649	652
650	653	// Macros for setting tile attributes in the TILE_GET_INFO callback:

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team