Previous

199869 Revisions

Next

r20972 Tuesday 12th February, 2013 at 09:06:25 UTC by Miodrag Milanović
Modernization of drivers part 13 (no whatsnew)

[src/mame/audio]	n8080.c
[src/mame/drivers]	nbmj9195.c neogeo.c ninjakd2.c ninjaw.c niyanpai.c nmk16.c nova2001.c
[src/mame/includes]	n8080.h nbmj8688.h nbmj8891.h nbmj8900.h nbmj8991.h nbmj9195.h nemesis.h neogeo.h ninjakd2.h ninjaw.h nitedrvr.h niyanpai.h nmk16.h nova2001.h nycaptor.h
[src/mame/machine]	nitedrvr.c
[src/mame/video]	n8080.c nbmj8688.c nbmj8891.c nbmj8900.c nbmj8991.c nbmj9195.c nemesis.c neogeo.c ninjakd2.c ninjaw.c nitedrvr.c niyanpai.c nmk16.c nova2001.c nycaptor.c
[src/mess/drivers]	ng_aes.c

trunk/src/mame/drivers/ninjaw.c

r20971	r20972
325	325
326	326	extern const char layout_darius[];
327	327
328		static void parse_control( running_machine &machine )   /* assumes Z80 sandwiched between 68Ks */
	328	void ninjaw_state::parse_control(  )   /* assumes Z80 sandwiched between 68Ks */
329	329	{
330	330	/* bit 0 enables cpu B */
331	331	/* however this fails when recovering from a save state
332	332	if cpu B is disabled !! */
333		ninjaw_state *state = machine.driver_data<ninjaw_state>();
334		state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
	333	m_subcpu->set_input_line(INPUT_LINE_RESET, (m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
335	334
336	335	}
337	336
r20971	r20972
341	340	data = data >> 8;
342	341	m_cpua_ctrl = data;
343	342
344		parse_control(machine());
	343	parse_control();
345	344
346	345	logerror("CPU #0 PC %06x: write %04x to cpu control\n", space.device().safe_pc(), data);
347	346	}
r20971	r20972
351	350	SOUND
352	351	*****************************************/
353	352
354		static void reset_sound_region( running_machine &machine )
	353	void ninjaw_state::reset_sound_region(  )
355	354	{
356		ninjaw_state *state = machine.driver_data<ninjaw_state>();
357		state->membank("bank10")->set_entry(state->m_banknum);
	355	membank("bank10")->set_entry(m_banknum);
358	356	}
359	357
360	358	WRITE8_MEMBER(ninjaw_state::sound_bankswitch_w)
361	359	{
362	360	m_banknum = data & 7;
363		reset_sound_region(machine());
	361	reset_sound_region();
364	362	}
365	363
366	364	WRITE16_MEMBER(ninjaw_state::ninjaw_sound_w)
r20971	r20972
791	789
792	790	void ninjaw_state::ninjaw_postload()
793	791	{
794		parse_control(machine());
795		reset_sound_region(machine());
	792	parse_control();
	793	reset_sound_region();
796	794	}
797	795
798	796	void ninjaw_state::machine_start()

trunk/src/mame/drivers/niyanpai.c

r20971	r20972
48	48	#include "includes/niyanpai.h"
49	49
50	50
51		static void niyanpai_soundbank_w(running_machine &machine, int data)
	51	void niyanpai_state::niyanpai_soundbank_w(int data)
52	52	{
53		UINT8 *SNDROM = machine.root_device().memregion("audiocpu")->base();
	53	UINT8 *SNDROM = machine().root_device().memregion("audiocpu")->base();
54	54
55		machine.root_device().membank("bank1")->set_base(&SNDROM[0x08000 + (0x8000 * (data & 0x03))]);
	55	machine().root_device().membank("bank1")->set_base(&SNDROM[0x08000 + (0x8000 * (data & 0x03))]);
56	56	}
57	57
58	58	READ8_MEMBER(niyanpai_state::niyanpai_sound_r)
r20971	r20972
109	109	switch (offset)
110	110	{
111	111	case 0:         /* PA_0 */
112		niyanpai_soundbank_w(machine(), data & 0x03);
	112	niyanpai_soundbank_w(data & 0x03);
113	113	break;
114	114	case 1:         /* PB_0 */
115	115	machine().device<dac_device>("dac1")->write_unsigned8(data);
r20971	r20972
264	264	SNDROM[0x0213] = 0x00;          // DI -> NOP
265	265
266	266	// initialize sound rom bank
267		niyanpai_soundbank_w(machine(), 0);
	267	niyanpai_soundbank_w(0);
268	268
269	269	// initialize out coin flag (musobana)
270	270	m_musobana_outcoin_flag = 1;

trunk/src/mame/drivers/neogeo.c

r20971	r20972
173	173	NEOGEO_BANK_AUDIO_CPU_CART_BANK0, NEOGEO_BANK_AUDIO_CPU_CART_BANK1, NEOGEO_BANK_AUDIO_CPU_CART_BANK2, NEOGEO_BANK_AUDIO_CPU_CART_BANK3
174	174	};
175	175
176
177	176	/*************************************
178	177	*
179		*  Forward declerations
180		*
181		*************************************/
182
183		static void set_output_latch(running_machine &machine, UINT8 data);
184		static void set_output_data(running_machine &machine, UINT8 data);
185
186
187		/*************************************
188		*
189	178	*  Main CPU interrupt generation
190	179	*
191	180	*************************************/
r20971	r20972
335	324	}
336	325
337	326
338		static void audio_cpu_assert_nmi(running_machine &machine)
	327	void neogeo_state::audio_cpu_assert_nmi()
339	328	{
340		neogeo_state *state = machine.driver_data<neogeo_state>();
341		state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	329	m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
342	330	}
343	331
344	332	WRITE8_MEMBER(neogeo_state::audio_cpu_clear_nmi_w)
r20971	r20972
354	342	*
355	343	*************************************/
356	344
357		static void select_controller( running_machine &machine, UINT8 data )
	345	void neogeo_state::select_controller( UINT8 data )
358	346	{
359		neogeo_state *state = machine.driver_data<neogeo_state>();
360		state->m_controller_select = data;
	347	m_controller_select = data;
361	348	}
362	349
363	350
r20971	r20972
403	390	{
404	391	switch (offset)
405	392	{
406		case 0x00: select_controller(machine(), data & 0x00ff); break;
407		case 0x18: if (m_is_mvs) set_output_latch(machine(), data & 0x00ff); break;
408		case 0x20: if (m_is_mvs) set_output_data(machine(), data & 0x00ff); break;
	393	case 0x00: select_controller(data & 0x00ff); break;
	394	case 0x18: if (m_is_mvs) set_output_latch(data & 0x00ff); break;
	395	case 0x20: if (m_is_mvs) set_output_data(data & 0x00ff); break;
409	396	case 0x28: upd4990a_control_16_w(m_upd4990a, space, 0, data, mem_mask); break;
410	397	//  case 0x30: break; // coin counters
411	398	//  case 0x31: break; // coin counters
r20971	r20972
467	454	*
468	455	*************************************/
469	456
470		static void set_save_ram_unlock( running_machine &machine, UINT8 data )
	457	void neogeo_state::set_save_ram_unlock( UINT8 data )
471	458	{
472		neogeo_state *state = machine.driver_data<neogeo_state>();
473		state->m_save_ram_unlocked = data;
	459	m_save_ram_unlocked = data;
474	460	}
475	461
476	462
r20971	r20972
556	542	{
557	543	soundlatch_byte_w(space, 0, data >> 8);
558	544
559		audio_cpu_assert_nmi(machine());
	545	audio_cpu_assert_nmi();
560	546
561	547	/* boost the interleave to let the audio CPU read the command */
562	548	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(50));
r20971	r20972
838	824	switch (offset & 0x07)
839	825	{
840	826	default:
841		case 0x00: neogeo_set_screen_dark(machine(), bit); break;
	827	case 0x00: neogeo_set_screen_dark(bit); break;
842	828	case 0x01:
843	829	if (m_is_cartsys)
844	830	{
r20971	r20972
859	845	}
860	846	if (m_has_audio_banking) set_audio_cpu_rom_source(bit); /* this is a guess */
861	847	break;
862		case 0x05: neogeo_set_fixed_layer_source(machine(), bit); break;
863		case 0x06: if (m_is_mvs) set_save_ram_unlock(machine(), bit); break;
864		case 0x07: neogeo_set_palette_bank(machine(), bit); break;
	848	case 0x05: neogeo_set_fixed_layer_source(bit); break;
	849	case 0x06: if (m_is_mvs) set_save_ram_unlock(bit); break;
	850	case 0x07: neogeo_set_palette_bank(bit); break;
865	851
866	852	case 0x02: /* unknown - HC32 middle pin 1 */
867	853	case 0x03: /* unknown - uPD4990 pin ? */
r20971	r20972
926	912	*
927	913	*************************************/
928	914
929		static void set_outputs( running_machine &machine )
	915	void neogeo_state::set_outputs(  )
930	916	{
931		neogeo_state *state = machine.driver_data<neogeo_state>();
932	917	static const UINT8 led_map[0x10] =
933	918	{ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x58,0x4c,0x62,0x69,0x78,0x00 };
934	919
935	920	/* EL */
936		output_set_digit_value(0, led_map[state->m_el_value]);
	921	output_set_digit_value(0, led_map[m_el_value]);
937	922
938	923	/* LED1 */
939		output_set_digit_value(1, led_map[state->m_led1_value >> 4]);
940		output_set_digit_value(2, led_map[state->m_led1_value & 0x0f]);
	924	output_set_digit_value(1, led_map[m_led1_value >> 4]);
	925	output_set_digit_value(2, led_map[m_led1_value & 0x0f]);
941	926
942	927	/* LED2 */
943		output_set_digit_value(3, led_map[state->m_led2_value >> 4]);
944		output_set_digit_value(4, led_map[state->m_led2_value & 0x0f]);
	928	output_set_digit_value(3, led_map[m_led2_value >> 4]);
	929	output_set_digit_value(4, led_map[m_led2_value & 0x0f]);
945	930	}
946	931
947	932
948		static void set_output_latch( running_machine &machine, UINT8 data )
	933	void neogeo_state::set_output_latch( UINT8 data )
949	934	{
950		neogeo_state *state = machine.driver_data<neogeo_state>();
951
952	935	/* looks like the LEDs are set on the
953	936	falling edge */
954		UINT8 falling_bits = state->m_output_latch & ~data;
	937	UINT8 falling_bits = m_output_latch & ~data;
955	938
956	939	if (falling_bits & 0x08)
957		state->m_el_value = 16 - (state->m_output_data & 0x0f);
	940	m_el_value = 16 - (m_output_data & 0x0f);
958	941
959	942	if (falling_bits & 0x10)
960		state->m_led1_value = ~state->m_output_data;
	943	m_led1_value = ~m_output_data;
961	944
962	945	if (falling_bits & 0x20)
963		state->m_led2_value = ~state->m_output_data;
	946	m_led2_value = ~m_output_data;
964	947
965	948	if (falling_bits & 0xc7)
966		logerror("%s  Unmaped LED write.  Data: %x\n", machine.describe_context(), falling_bits);
	949	logerror("%s  Unmaped LED write.  Data: %x\n", machine().describe_context(), falling_bits);
967	950
968		state->m_output_latch = data;
	951	m_output_latch = data;
969	952
970		set_outputs(machine);
	953	set_outputs();
971	954	}
972	955
973	956
974		static void set_output_data( running_machine &machine, UINT8 data )
	957	void neogeo_state::set_output_data( UINT8 data )
975	958	{
976		neogeo_state *state = machine.driver_data<neogeo_state>();
977		state->m_output_data = data;
	959	m_output_data = data;
978	960	}
979	961
980	962
r20971	r20972
991	973	_set_main_cpu_vector_table_source();
992	974	set_audio_cpu_banking();
993	975	_set_audio_cpu_rom_source();
994		if (m_is_mvs) set_outputs(machine());
	976	if (m_is_mvs) set_outputs();
995	977	}
996	978
997	979

trunk/src/mame/drivers/nbmj9195.c

r20971	r20972
52	52	soundlatch_clear_byte_w(space, 0, 0);
53	53	}
54	54
55		static void nbmj9195_outcoin_flag_w(address_space &space, int data)
	55	void nbmj9195_state::nbmj9195_outcoin_flag_w(int data)
56	56	{
57		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
58	57	// bit0: coin in counter
59	58	// bit1: coin out counter
60	59	// bit2: hopper
61	60	// bit3: coin lockout
62	61
63		if (data & 0x04) state->m_outcoin_flag ^= 1;
64		else state->m_outcoin_flag = 1;
	62	if (data & 0x04) m_outcoin_flag ^= 1;
	63	else m_outcoin_flag = 1;
65	64	}
66	65
67	66	WRITE8_MEMBER(nbmj9195_state::nbmj9195_inputportsel_w)
r20971	r20972
69	68	m_inputport = (data ^ 0xff);
70	69	}
71	70
72		static int nbmj9195_dipsw_r(running_machine &machine)
	71	int nbmj9195_state::nbmj9195_dipsw_r()
73	72	{
74		nbmj9195_state *state = machine.driver_data<nbmj9195_state>();
75		return (((state->ioport("DSWA")->read() & 0xff) | ((state->ioport("DSWB")->read() & 0xff) << 8)) >> state->m_dipswbitsel) & 0x01;
	73	return (((ioport("DSWA")->read() & 0xff) | ((ioport("DSWB")->read() & 0xff) << 8)) >> m_dipswbitsel) & 0x01;
76	74	}
77	75
78		static void nbmj9195_dipswbitsel_w(address_space &space, int data)
	76	void nbmj9195_state::nbmj9195_dipswbitsel_w(int data)
79	77	{
80		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
81	78	switch (data & 0xc0)
82	79	{
83	80	case 0x00:
84		state->m_dipswbitsel = 0;
	81	m_dipswbitsel = 0;
85	82	break;
86	83	case 0x40:
87	84	break;
88	85	case 0x80:
89	86	break;
90	87	case 0xc0:
91		state->m_dipswbitsel = ((state->m_dipswbitsel + 1) & 0x0f);
	88	m_dipswbitsel = ((m_dipswbitsel + 1) & 0x0f);
92	89	break;
93	90	default:
94	91	break;
95	92	}
96	93	}
97	94
98		static void mscoutm_inputportsel_w(address_space &space, int data)
	95	void nbmj9195_state::mscoutm_inputportsel_w( int data)
99	96	{
100		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
101		state->m_mscoutm_inputport = (data ^ 0xff);
	97	m_mscoutm_inputport = (data ^ 0xff);
102	98	}
103	99
104	100	READ8_MEMBER(nbmj9195_state::mscoutm_dipsw_0_r)
r20971	r20972
241	237	portdata = ioport("KEY3")->read();
242	238	break;
243	239	case 0x10:
244		portdata = ((ioport("KEY4")->read() & 0x7f) | (nbmj9195_dipsw_r(machine()) << 7));
	240	portdata = ((ioport("KEY4")->read() & 0x7f) | (nbmj9195_dipsw_r() << 7));
245	241	break;
246	242	default:
247	243	portdata = (ioport("KEY0")->read() & ioport("KEY1")->read() & ioport("KEY2")->read() & ioport("KEY3")->read() & (ioport("KEY4")->read() & 0x7f));
r20971	r20972
314	310	switch (offset)
315	311	{
316	312	case 0:         /* PA_0 */
317		mscoutm_inputportsel_w(space, data);    // NB22090
	313	mscoutm_inputportsel_w(data);    // NB22090
318	314	break;
319	315	case 1:         /* PB_0 */
320	316	break;
321	317	case 2:         /* PC_0 */
322	318	break;
323	319	case 3:         /* PD_0 */
324		nbmj9195_clutsel_w(space, data);
	320	nbmj9195_clutsel_w(data);
325	321	break;
326	322	case 4:         /* PE_0 */
327		nbmj9195_gfxflag2_w(space, data);       // NB22090
	323	nbmj9195_gfxflag2_w(data);       // NB22090
328	324	break;
329	325
330	326	case 5:         /* PA_1 */
r20971	r20972
356	352	case 1:         /* PB_0 */
357	353	break;
358	354	case 2:         /* PC_0 */
359		nbmj9195_dipswbitsel_w(space, data);
	355	nbmj9195_dipswbitsel_w(data);
360	356	break;
361	357	case 3:         /* PD_0 */
362		nbmj9195_clutsel_w(space, data);
	358	nbmj9195_clutsel_w(data);
363	359	break;
364	360	case 4:         /* PE_0 */
365		nbmj9195_outcoin_flag_w(space, data);
	361	nbmj9195_outcoin_flag_w(data);
366	362	break;
367	363
368	364	case 5:         /* PA_1 */

trunk/src/mame/drivers/nova2001.c

r20971	r20972
977	977
978	978	******************************************************************************/
979	979
980		static void lineswap_gfx_roms(running_machine &machine, const char *region, const int bit)
	980	void nova2001_state::lineswap_gfx_roms(const char *region, const int bit)
981	981	{
982		const int length = machine.root_device().memregion(region)->bytes();
	982	const int length = machine().root_device().memregion(region)->bytes();
983	983
984		UINT8* const src = machine.root_device().memregion(region)->base();
	984	UINT8* const src = machine().root_device().memregion(region)->base();
985	985
986		UINT8* const temp = auto_alloc_array(machine, UINT8, length);
	986	UINT8* const temp = auto_alloc_array(machine(), UINT8, length);
987	987
988	988	const int mask = (1 << (bit + 1)) - 1;
989	989
r20971	r20972
998	998
999	999	memcpy(src, temp, length);
1000	1000
1001		auto_free(machine, temp);
	1001	auto_free(machine(), temp);
1002	1002	}
1003	1003
1004	1004
r20971	r20972
1011	1011
1012	1012	DRIVER_INIT_MEMBER(nova2001_state,pkunwar)
1013	1013	{
1014		lineswap_gfx_roms(machine(), "gfx1", 13);
	1014	lineswap_gfx_roms("gfx1", 13);
1015	1015	}
1016	1016
1017	1017	DRIVER_INIT_MEMBER(nova2001_state,raiders5)
1018	1018	{
1019		lineswap_gfx_roms(machine(), "gfx1", 13);
1020		lineswap_gfx_roms(machine(), "gfx2", 13);
	1019	lineswap_gfx_roms("gfx1", 13);
	1020	lineswap_gfx_roms("gfx2", 13);
1021	1021	}
1022	1022
1023	1023

trunk/src/mame/drivers/nmk16.c

r20971	r20972
727	727	}
728	728
729	729	/*coin setting MCU simulation*/
730		static void mcu_run(running_machine &machine, UINT8 dsw_setting)
	730	void nmk16_state::mcu_run(UINT8 dsw_setting)
731	731	{
732		nmk16_state *state = machine.driver_data<nmk16_state>();
733	732	UINT16 coin_input;
734	733	UINT8 dsw[2];
735	734	UINT8 i;
736	735
737	736	/*Accept the start button but needs some m68k processing first,otherwise you can't start a play with 1 credit inserted*/
738		if(state->m_start_helper & 1 && state->m_mainram[0x9000/2] & 0x0200) /*start 1 */
	737	if(m_start_helper & 1 && m_mainram[0x9000/2] & 0x0200) /*start 1 */
739	738	{
740		state->m_mainram[0xef00/2]--;
741		state->m_start_helper = state->m_start_helper & 2;
	739	m_mainram[0xef00/2]--;
	740	m_start_helper = m_start_helper & 2;
742	741	}
743		if(state->m_start_helper & 2 && state->m_mainram[0x9000/2] & 0x0100) /*start 2*/
	742	if(m_start_helper & 2 && m_mainram[0x9000/2] & 0x0100) /*start 2*/
744	743	{
745		state->m_mainram[0xef00/2]--;
746		state->m_start_helper = state->m_start_helper & 1;
	744	m_mainram[0xef00/2]--;
	745	m_start_helper = m_start_helper & 1;
747	746	}
748	747
749	748	/*needed because of the uncompatibility of the dsw settings.*/
750	749	if(dsw_setting) // Thunder Dragon
751	750	{
752		dsw[0] = (machine.root_device().ioport("DSW2")->read() & 0x7);
753		dsw[1] = (machine.root_device().ioport("DSW2")->read() & 0x38) >> 3;
	751	dsw[0] = (machine().root_device().ioport("DSW2")->read() & 0x7);
	752	dsw[1] = (machine().root_device().ioport("DSW2")->read() & 0x38) >> 3;
754	753	for(i=0;i<2;i++)
755	754	{
756	755	switch(dsw[i] & 7)
757	756	{
758		case 0: state->m_mainram[0x9000/2]|=0x4000; break; //free play
759		case 1: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 4; break;
760		case 2: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 3; break;
761		case 3: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 2; break;
762		case 4: state->m_coin_count_frac[i] = 4; state->m_coin_count[i] = 1; break;
763		case 5: state->m_coin_count_frac[i] = 3; state->m_coin_count[i] = 1; break;
764		case 6: state->m_coin_count_frac[i] = 2; state->m_coin_count[i] = 1; break;
765		case 7: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 1; break;
	757	case 0: m_mainram[0x9000/2]|=0x4000; break; //free play
	758	case 1: m_coin_count_frac[i] = 1; m_coin_count[i] = 4; break;
	759	case 2: m_coin_count_frac[i] = 1; m_coin_count[i] = 3; break;
	760	case 3: m_coin_count_frac[i] = 1; m_coin_count[i] = 2; break;
	761	case 4: m_coin_count_frac[i] = 4; m_coin_count[i] = 1; break;
	762	case 5: m_coin_count_frac[i] = 3; m_coin_count[i] = 1; break;
	763	case 6: m_coin_count_frac[i] = 2; m_coin_count[i] = 1; break;
	764	case 7: m_coin_count_frac[i] = 1; m_coin_count[i] = 1; break;
766	765	}
767	766	}
768	767	}
769	768	else // Hacha Mecha Fighter
770	769	{
771		dsw[0] = (machine.root_device().ioport("DSW1")->read() & 0x0700) >> 8;
772		dsw[1] = (machine.root_device().ioport("DSW1")->read() & 0x3800) >> 11;
	770	dsw[0] = (machine().root_device().ioport("DSW1")->read() & 0x0700) >> 8;
	771	dsw[1] = (machine().root_device().ioport("DSW1")->read() & 0x3800) >> 11;
773	772	for(i=0;i<2;i++)
774	773	{
775	774	switch(dsw[i] & 7)
776	775	{
777		case 0: state->m_mainram[0x9000/2]|=0x4000; break; //free play
778		case 1: state->m_coin_count_frac[i] = 4; state->m_coin_count[i] = 1; break;
779		case 2: state->m_coin_count_frac[i] = 3; state->m_coin_count[i] = 1; break;
780		case 3: state->m_coin_count_frac[i] = 2; state->m_coin_count[i] = 1; break;
781		case 4: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 4; break;
782		case 5: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 3; break;
783		case 6: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 2; break;
784		case 7: state->m_coin_count_frac[i] = 1; state->m_coin_count[i] = 1; break;
	776	case 0: m_mainram[0x9000/2]|=0x4000; break; //free play
	777	case 1: m_coin_count_frac[i] = 4; m_coin_count[i] = 1; break;
	778	case 2: m_coin_count_frac[i] = 3; m_coin_count[i] = 1; break;
	779	case 3: m_coin_count_frac[i] = 2; m_coin_count[i] = 1; break;
	780	case 4: m_coin_count_frac[i] = 1; m_coin_count[i] = 4; break;
	781	case 5: m_coin_count_frac[i] = 1; m_coin_count[i] = 3; break;
	782	case 6: m_coin_count_frac[i] = 1; m_coin_count[i] = 2; break;
	783	case 7: m_coin_count_frac[i] = 1; m_coin_count[i] = 1; break;
785	784	}
786	785	}
787	786	}
788	787
789	788	/*read the coin port*/
790		coin_input = (~(machine.root_device().ioport("IN0")->read()));
	789	coin_input = (~(machine().root_device().ioport("IN0")->read()));
791	790
792	791	if(coin_input & 0x01)//coin 1
793	792	{
794		if((state->m_input_pressed & 0x01) == 0)
	793	if((m_input_pressed & 0x01) == 0)
795	794	{
796		if(state->m_coin_count_frac[0] != 1)
	795	if(m_coin_count_frac[0] != 1)
797	796	{
798		state->m_mainram[0xef02/2]+=state->m_coin_count[0];
799		if(state->m_coin_count_frac[0] == state->m_mainram[0xef02/2])
	797	m_mainram[0xef02/2]+=m_coin_count[0];
	798	if(m_coin_count_frac[0] == m_mainram[0xef02/2])
800	799	{
801		state->m_mainram[0xef00/2]+=state->m_coin_count[0];
802		state->m_mainram[0xef02/2] = 0;
	800	m_mainram[0xef00/2]+=m_coin_count[0];
	801	m_mainram[0xef02/2] = 0;
803	802	}
804	803	}
805	804	else
806		state->m_mainram[0xef00/2]+=state->m_coin_count[0];
	805	m_mainram[0xef00/2]+=m_coin_count[0];
807	806	}
808		state->m_input_pressed = (state->m_input_pressed & 0xfe) | 1;
	807	m_input_pressed = (m_input_pressed & 0xfe) | 1;
809	808	}
810	809	else
811		state->m_input_pressed = (state->m_input_pressed & 0xfe);
	810	m_input_pressed = (m_input_pressed & 0xfe);
812	811
813	812	if(coin_input & 0x02)//coin 2
814	813	{
815		if((state->m_input_pressed & 0x02) == 0)
	814	if((m_input_pressed & 0x02) == 0)
816	815	{
817		if(state->m_coin_count_frac[1] != 1)
	816	if(m_coin_count_frac[1] != 1)
818	817	{
819		state->m_mainram[0xef02/2]+=state->m_coin_count[1];
820		if(state->m_coin_count_frac[1] == state->m_mainram[0xef02/2])
	818	m_mainram[0xef02/2]+=m_coin_count[1];
	819	if(m_coin_count_frac[1] == m_mainram[0xef02/2])
821	820	{
822		state->m_mainram[0xef00/2]+=state->m_coin_count[1];
823		state->m_mainram[0xef02/2] = 0;
	821	m_mainram[0xef00/2]+=m_coin_count[1];
	822	m_mainram[0xef02/2] = 0;
824	823	}
825	824	}
826	825	else
827		state->m_mainram[0xef00/2]+=state->m_coin_count[1];
	826	m_mainram[0xef00/2]+=m_coin_count[1];
828	827	}
829		state->m_input_pressed = (state->m_input_pressed & 0xfd) | 2;
	828	m_input_pressed = (m_input_pressed & 0xfd) | 2;
830	829	}
831	830	else
832		state->m_input_pressed = (state->m_input_pressed & 0xfd);
	831	m_input_pressed = (m_input_pressed & 0xfd);
833	832
834	833	if(coin_input & 0x04)//service 1
835	834	{
836		if((state->m_input_pressed & 0x04) == 0)
837		state->m_mainram[0xef00/2]++;
838		state->m_input_pressed = (state->m_input_pressed & 0xfb) | 4;
	835	if((m_input_pressed & 0x04) == 0)
	836	m_mainram[0xef00/2]++;
	837	m_input_pressed = (m_input_pressed & 0xfb) | 4;
839	838	}
840	839	else
841		state->m_input_pressed = (state->m_input_pressed & 0xfb);
	840	m_input_pressed = (m_input_pressed & 0xfb);
842	841
843	842	/*The 0x9000 ram address is the status */
844		if(state->m_mainram[0xef00/2] > 0 && state->m_mainram[0x9000/2] & 0x8000) //enable start button
	843	if(m_mainram[0xef00/2] > 0 && m_mainram[0x9000/2] & 0x8000) //enable start button
845	844	{
846	845	if(coin_input & 0x08)//start 1
847	846	{
848		if((state->m_input_pressed & 0x08) == 0 && (!(state->m_mainram[0x9000/2] & 0x0200))) //start 1
849		state->m_start_helper = 1;
	847	if((m_input_pressed & 0x08) == 0 && (!(m_mainram[0x9000/2] & 0x0200))) //start 1
	848	m_start_helper = 1;
850	849
851		state->m_input_pressed = (state->m_input_pressed & 0xf7) | 8;
	850	m_input_pressed = (m_input_pressed & 0xf7) | 8;
852	851	}
853	852	else
854		state->m_input_pressed = (state->m_input_pressed & 0xf7);
	853	m_input_pressed = (m_input_pressed & 0xf7);
855	854
856	855	if(coin_input & 0x10)//start 2
857	856	{
858	857	/*Decrease two coins to let two players play with one start 2 button and two credits inserted at the insert coin screen.*/
859		if((state->m_input_pressed & 0x10) == 0 && (!(state->m_mainram[0x9000/2] & 0x0100))) // start 2
860		state->m_start_helper = (state->m_mainram[0x9000/2] == 0x8000) ? (3) : (2);
	858	if((m_input_pressed & 0x10) == 0 && (!(m_mainram[0x9000/2] & 0x0100))) // start 2
	859	m_start_helper = (m_mainram[0x9000/2] == 0x8000) ? (3) : (2);
861	860
862		state->m_input_pressed = (state->m_input_pressed & 0xef) | 0x10;
	861	m_input_pressed = (m_input_pressed & 0xef) | 0x10;
863	862	}
864	863	else
865		state->m_input_pressed = (state->m_input_pressed & 0xef);
	864	m_input_pressed = (m_input_pressed & 0xef);
866	865	}
867	866	}
868	867
869	868	TIMER_DEVICE_CALLBACK_MEMBER(nmk16_state::tdragon_mcu_sim)
870	869	{
871		mcu_run(machine(),1);
	870	mcu_run(1);
872	871	}
873	872
874	873	TIMER_DEVICE_CALLBACK_MEMBER(nmk16_state::hachamf_mcu_sim)
875	874	{
876		mcu_run(machine(),0);
	875	mcu_run(0);
877	876	}
878	877
879	878	static ADDRESS_MAP_START( tdragon_map, AS_PROGRAM, 16, nmk16_state )
r20971	r20972
4343	4342	MACHINE_CONFIG_END
4344	4343
4345	4344
4346		static UINT8 decode_byte(UINT8 src, const UINT8 *bitp)
	4345	UINT8 nmk16_state::decode_byte(UINT8 src, const UINT8 *bitp)
4347	4346	{
4348	4347	UINT8 ret, i;
4349	4348
r20971	r20972
4354	4353	return ret;
4355	4354	}
4356	4355
4357		static UINT32 bjtwin_address_map_bg0(UINT32 addr)
	4356	UINT32 nmk16_state::bjtwin_address_map_bg0(UINT32 addr)
4358	4357	{
4359	4358	return ((addr&0x00004)>> 2) | ((addr&0x00800)>> 10) | ((addr&0x40000)>>16);
4360	4359	}
4361	4360
4362	4361
4363		static UINT16 decode_word(UINT16 src, const UINT8 *bitp)
	4362	UINT16 nmk16_state::decode_word(UINT16 src, const UINT8 *bitp)
4364	4363	{
4365	4364	UINT16 ret, i;
4366	4365
r20971	r20972
4372	4371	}
4373	4372
4374	4373
4375		static UINT32 bjtwin_address_map_sprites(UINT32 addr)
	4374	UINT32 nmk16_state::bjtwin_address_map_sprites(UINT32 addr)
4376	4375	{
4377	4376	return ((addr&0x00010)>> 4) | ((addr&0x20000)>>16) | ((addr&0x100000)>>18);
4378	4377	}
4379	4378
4380	4379
4381		static void decode_gfx(running_machine &machine)
	4380	void nmk16_state::decode_gfx()
4382	4381	{
4383	4382	/* GFX are scrambled.  We decode them here.  (BIG Thanks to Antiriad for descrambling info) */
4384	4383	UINT8 *rom;
r20971	r20972
4411	4410
4412	4411
4413	4412	/* background */
4414		rom = machine.root_device().memregion("gfx2")->base();
4415		len = machine.root_device().memregion("gfx2")->bytes();
	4413	rom = machine().root_device().memregion("gfx2")->base();
	4414	len = machine().root_device().memregion("gfx2")->bytes();
4416	4415	for (A = 0;A < len;A++)
4417	4416	{
4418	4417	rom[A] = decode_byte( rom[A], decode_data_bg[bjtwin_address_map_bg0(A)]);
4419	4418	}
4420	4419
4421	4420	/* sprites */
4422		rom = machine.root_device().memregion("gfx3")->base();
4423		len = machine.root_device().memregion("gfx3")->bytes();
	4421	rom = machine().root_device().memregion("gfx3")->base();
	4422	len = machine().root_device().memregion("gfx3")->bytes();
4424	4423	for (A = 0;A < len;A += 2)
4425	4424	{
4426	4425	UINT16 tmp = decode_word( rom[A+1]*256 + rom[A], decode_data_sprite[bjtwin_address_map_sprites(A)]);
r20971	r20972
4429	4428	}
4430	4429	}
4431	4430
4432		static void decode_tdragonb(running_machine &machine)
	4431	void nmk16_state::decode_tdragonb()
4433	4432	{
4434	4433	/* Descrambling Info Again Taken from Raine, Huge Thanks to Antiriad and the Raine Team for
4435	4434	going Open Source, best of luck in future development. */
r20971	r20972
4449	4448	{0x7,0x6,0x5,0x3,0x4,0x2,0x1,0x0},
4450	4449	};
4451	4450
4452		rom = machine.root_device().memregion("maincpu")->base();
4453		len = machine.root_device().memregion("maincpu")->bytes();
	4451	rom = machine().root_device().memregion("maincpu")->base();
	4452	len = machine().root_device().memregion("maincpu")->bytes();
4454	4453	for (A = 0;A < len;A += 2)
4455	4454	{
4456	4455	int h = A+NATIVE_ENDIAN_VALUE_LE_BE(1,0), l = A+NATIVE_ENDIAN_VALUE_LE_BE(0,1);
r20971	r20972
4459	4458	rom[l] = tmp & 0xff;
4460	4459	}
4461	4460
4462		rom = machine.root_device().memregion("gfx2")->base();
4463		len = machine.root_device().memregion("gfx2")->bytes();
	4461	rom = machine().root_device().memregion("gfx2")->base();
	4462	len = machine().root_device().memregion("gfx2")->bytes();
4464	4463	for (A = 0;A < len;A++)
4465	4464	{
4466	4465	rom[A] = decode_byte( rom[A], decode_data_tdragonbgfx[0]);
4467	4466	}
4468	4467
4469		rom = machine.root_device().memregion("gfx3")->base();
4470		len = machine.root_device().memregion("gfx3")->bytes();
	4468	rom = machine().root_device().memregion("gfx3")->base();
	4469	len = machine().root_device().memregion("gfx3")->bytes();
4471	4470	for (A = 0;A < len;A++)
4472	4471	{
4473	4472	rom[A] = decode_byte( rom[A], decode_data_tdragonbgfx[0]);
4474	4473	}
4475	4474	}
4476	4475
4477		static void decode_ssmissin(running_machine &machine)
	4476	void nmk16_state::decode_ssmissin()
4478	4477	{
4479	4478	/* Like Thunder Dragon Bootleg without the Program Rom Swapping */
4480	4479	UINT8 *rom;
r20971	r20972
4486	4485	{0x7,0x6,0x5,0x3,0x4,0x2,0x1,0x0},
4487	4486	};
4488	4487
4489		rom = machine.root_device().memregion("gfx2")->base();
4490		len = machine.root_device().memregion("gfx2")->bytes();
	4488	rom = machine().root_device().memregion("gfx2")->base();
	4489	len = machine().root_device().memregion("gfx2")->bytes();
4491	4490	for (A = 0;A < len;A++)
4492	4491	{
4493	4492	rom[A] = decode_byte( rom[A], decode_data_tdragonbgfx[0]);
4494	4493	}
4495	4494
4496		rom = machine.root_device().memregion("gfx3")->base();
4497		len = machine.root_device().memregion("gfx3")->bytes();
	4495	rom = machine().root_device().memregion("gfx3")->base();
	4496	len = machine().root_device().memregion("gfx3")->bytes();
4498	4497	for (A = 0;A < len;A++)
4499	4498	{
4500	4499	rom[A] = decode_byte( rom[A], decode_data_tdragonbgfx[0]);
r20971	r20972
4504	4503
4505	4504	DRIVER_INIT_MEMBER(nmk16_state,nmk)
4506	4505	{
4507		decode_gfx(machine());
	4506	decode_gfx();
4508	4507	}
4509	4508
4510	4509	DRIVER_INIT_MEMBER(nmk16_state,hachamf)
r20971	r20972
4520	4519
4521	4520	DRIVER_INIT_MEMBER(nmk16_state,tdragonb)
4522	4521	{
4523		decode_tdragonb(machine());
	4522	decode_tdragonb();
4524	4523	}
4525	4524
4526	4525	DRIVER_INIT_MEMBER(nmk16_state,tdragon)
r20971	r20972
4537	4536
4538	4537	DRIVER_INIT_MEMBER(nmk16_state,ssmissin)
4539	4538	{
4540		decode_ssmissin(machine());
	4539	decode_ssmissin();
4541	4540	}
4542	4541
4543	4542	DRIVER_INIT_MEMBER(nmk16_state,bjtwin)

trunk/src/mame/drivers/ninjakd2.c

r20971	r20972
1416	1416
1417	1417	******************************************************************************/
1418	1418
1419		static void lineswap_gfx_roms(running_machine &machine, const char *region, const int bit)
	1419	void ninjakd2_state::lineswap_gfx_roms(const char *region, const int bit)
1420	1420	{
1421		const int length = machine.root_device().memregion(region)->bytes();
1422		UINT8* const src = machine.root_device().memregion(region)->base();
1423		UINT8* const temp = auto_alloc_array(machine, UINT8, length);
	1421	const int length = machine().root_device().memregion(region)->bytes();
	1422	UINT8* const src = machine().root_device().memregion(region)->base();
	1423	UINT8* const temp = auto_alloc_array(machine(), UINT8, length);
1424	1424	const int mask = (1 << (bit + 1)) - 1;
1425	1425
1426	1426	for (int sa = 0; sa < length; sa++)
r20971	r20972
1430	1430	}
1431	1431
1432	1432	memcpy(src, temp, length);
1433		auto_free(machine, temp);
	1433	auto_free(machine(), temp);
1434	1434	}
1435	1435
1436		static void gfx_unscramble(running_machine &machine)
	1436	void ninjakd2_state::gfx_unscramble()
1437	1437	{
1438		lineswap_gfx_roms(machine, "gfx1", 13);     // fg tiles
1439		lineswap_gfx_roms(machine, "gfx2", 14);     // sprites
1440		lineswap_gfx_roms(machine, "gfx3", 14);     // bg tiles
	1438	lineswap_gfx_roms("gfx1", 13);     // fg tiles
	1439	lineswap_gfx_roms("gfx2", 14);     // sprites
	1440	lineswap_gfx_roms("gfx3", 14);     // bg tiles
1441	1441	}
1442	1442
1443	1443
r20971	r20972
1445	1445	{
1446	1446	mc8123_decrypt_rom(machine(), "soundcpu", "user1", NULL, 0);
1447	1447
1448		gfx_unscramble(machine());
	1448	gfx_unscramble();
1449	1449	}
1450	1450
1451	1451	DRIVER_INIT_MEMBER(ninjakd2_state,bootleg)
r20971	r20972
1453	1453	address_space &space = machine().device("soundcpu")->memory().space(AS_PROGRAM);
1454	1454	space.set_decrypted_region(0x0000, 0x7fff, machine().root_device().memregion("soundcpu")->base() + 0x10000);
1455	1455
1456		gfx_unscramble(machine());
	1456	gfx_unscramble();
1457	1457	}
1458	1458
1459	1459	DRIVER_INIT_MEMBER(ninjakd2_state,mnight)
1460	1460	{
1461		gfx_unscramble(machine());
	1461	gfx_unscramble();
1462	1462	}
1463	1463
1464	1464	/*****************************************************************************/

trunk/src/mame/audio/n8080.c

r20971	r20972
275	275	{
276	276	if (data & ~state->m_prev_snd_data & 0x10)
277	277	{
278		spacefev_start_red_cannon(machine);
	278	state->spacefev_start_red_cannon();
279	279	}
280	280
281	281	state->m_spacefev_red_screen = data & 0x08;

trunk/src/mame/machine/nitedrvr.c

r20971	r20972
18	18	change in-between can affect the direction you move.
19	19	***************************************************************************/
20	20
21		static int nitedrvr_steering( running_machine &machine )
	21	int nitedrvr_state::nitedrvr_steering( )
22	22	{
23		nitedrvr_state *state = machine.driver_data<nitedrvr_state>();
24		int this_val = state->ioport("STEER")->read();
25		int delta = this_val - state->m_last_steering_val;
	23	int this_val = ioport("STEER")->read();
	24	int delta = this_val - m_last_steering_val;
26	25
27		state->m_last_steering_val = this_val;
	26	m_last_steering_val = this_val;
28	27
29	28	if (delta > 128)
30	29	delta -= 256;
r20971	r20972
32	31	delta += 256;
33	32
34	33	/* Divide by four to make our steering less sensitive */
35		state->m_steering_buf += (delta / 4);
	34	m_steering_buf += (delta / 4);
36	35
37		if (state->m_steering_buf > 0)
	36	if (m_steering_buf > 0)
38	37	{
39		state->m_steering_buf--;
40		state->m_steering_val = 0xc0;
	38	m_steering_buf--;
	39	m_steering_val = 0xc0;
41	40	}
42		else if (state->m_steering_buf < 0)
	41	else if (m_steering_buf < 0)
43	42	{
44		state->m_steering_buf++;
45		state->m_steering_val = 0x80;
	43	m_steering_buf++;
	44	m_steering_val = 0x80;
46	45	}
47	46	else
48	47	{
49		state->m_steering_val = 0x00;
	48	m_steering_val = 0x00;
50	49	}
51	50
52		return state->m_steering_val;
	51	return m_steering_val;
53	52	}
54	53
55	54	/***************************************************************************
r20971	r20972
121	120	else
122	121	return 0x70;
123	122	case 0x03:                      /* Remap our steering */
124		return (ioport("DSW2")->read() | nitedrvr_steering(machine()));
	123	return (ioport("DSW2")->read() | nitedrvr_steering());
125	124	default:
126	125	return 0xff;
127	126	}

trunk/src/mame/includes/ninjakd2.h

r20971	r20972
97	97	UINT32 screen_update_omegaf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
98	98	void screen_eof_ninjakd2(screen_device &screen, bool state);
99	99	INTERRUPT_GEN_MEMBER(ninjakd2_interrupt);
	100	void robokid_get_bg_tile_info( tile_data& tileinfo, tilemap_memory_index const tile_index, int const gfxnum, const UINT8* const videoram);
	101	void bg_ctrl(int offset, int data, tilemap_t* tilemap);
	102	void draw_sprites( bitmap_ind16 &bitmap);
	103	void erase_sprites( bitmap_ind16 &bitmap);
	104	void update_sprites();
	105	void lineswap_gfx_roms(const char *region, const int bit);
	106	void gfx_unscramble();
100	107	};

trunk/src/mame/includes/nbmj8891.h

r20971	r20972
75	75	DECLARE_VIDEO_START(nbmj8891_1layer);
76	76	UINT32 screen_update_nbmj8891(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
77	77	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	78	void nbmj8891_vramflip(int vram);
	79	void update_pixel0(int x, int y);
	80	void update_pixel1(int x, int y);
	81	void nbmj8891_gfxdraw();
78	82	};

trunk/src/mame/includes/nbmj8688.h

r20971	r20972
91	91	UINT32 screen_update_mbmj8688_lcd0(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
92	92	UINT32 screen_update_mbmj8688_lcd1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
93	93	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	94	void update_pixel(int x, int y);
	95	void writeram_low(int x, int y, int color);
	96	void writeram_high(int x, int y, int color);
	97	void mbmj8688_gfxdraw(int gfxtype);
	98	void common_video_start();
	99	void nbmj8688_HD61830B_instr_w(address_space &space,int offset,int data,int chip);
	100	void nbmj8688_HD61830B_data_w(address_space &space,int offset,int data,int chip);
94	101	};

trunk/src/mame/includes/neogeo.h

r20971	r20972
291	291	void _set_main_cpu_vector_table_source();
292	292	void optimize_sprite_data();
293	293	void draw_fixed_layer( bitmap_rgb32 &bitmap, int scanline );
	294	void set_videoram_offset( UINT16 data );
	295	UINT16 get_videoram_data(  );
	296	void set_videoram_data( UINT16 data);
	297	void set_videoram_modulo( UINT16 data);
	298	UINT16 get_videoram_modulo(  );
	299	void compute_rgb_weights(  );
	300	pen_t get_pen( UINT16 data );
	301	void neogeo_set_palette_bank( UINT8 data );
	302	void neogeo_set_screen_dark( UINT8 data );
	303	void set_auto_animation_speed( UINT8 data);
	304	void set_auto_animation_disabled( UINT8 data);
	305	UINT8 neogeo_get_auto_animation_counter(  );
	306	void create_auto_animation_timer(  );
	307	void start_auto_animation_timer(  );
	308	void neogeo_set_fixed_layer_source( UINT8 data );
	309	inline int rows_to_height(int rows);
	310	inline int sprite_on_scanline(int scanline, int y, int rows);
	311	void draw_sprites( bitmap_rgb32 &bitmap, int scanline );
	312	void parse_sprites( int scanline );
	313	void create_sprite_line_timer(  );
	314	void start_sprite_line_timer(  );
	315	UINT16 get_video_control(  );
	316	void audio_cpu_assert_nmi();
	317	void select_controller( UINT8 data );
	318	void set_save_ram_unlock( UINT8 data );
	319	void set_outputs(  );
	320	void set_output_latch( UINT8 data );
	321	void set_output_data( UINT8 data );
294	322	};
295	323
296	324
r20971	r20972
383	411	void samsho5b_vx_decrypt(running_machine &machine);
384	412	void matrimbl_decrypt(running_machine &machine);
385	413
386		/*----------- defined in video/neogeo.c -----------*/
387
388		void neogeo_set_palette_bank(running_machine &machine, UINT8 data);
389		void neogeo_set_screen_dark(running_machine &machine, UINT8 data);
390
391		void neogeo_set_fixed_layer_source(running_machine &machine, UINT8 data);
392
393		UINT8 neogeo_get_auto_animation_counter(running_machine &machine);

trunk/src/mame/includes/nbmj8991.h

r20971	r20972
54	54	UINT32 screen_update_nbmj8991_type1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
55	55	UINT32 screen_update_nbmj8991_type2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
56	56	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	57	void nbmj8991_vramflip();
	58	void update_pixel(int x, int y);
	59	void nbmj8991_gfxdraw();
57	60	};

trunk/src/mame/includes/nbmj8900.h

r20971	r20972
46	46	virtual void video_start();
47	47	UINT32 screen_update_nbmj8900(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
48	48	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	49	void nbmj8900_vramflip(int vram);
	50	void update_pixel0(int x, int y);
	51	void update_pixel1(int x, int y);
	52	void nbmj8900_gfxdraw();
49	53	};

trunk/src/mame/includes/n8080.h

r20971	r20972
86	86	TIMER_DEVICE_CALLBACK_MEMBER(rst2_tick);
87	87	TIMER_DEVICE_CALLBACK_MEMBER(spacefev_vco_voltage_timer);
88	88	TIMER_DEVICE_CALLBACK_MEMBER(helifire_dac_volume_timer);
	89	void spacefev_start_red_cannon(  );
	90	void helifire_next_line(  );
89	91	};
90	92
91		/*----------- defined in video/n8080.c -----------*/
92		void spacefev_start_red_cannon(running_machine &machine);
93
94	93	/*----------- defined in audio/n8080.c -----------*/
95	94
96	95	MACHINE_CONFIG_EXTERN( spacefev_sound );

trunk/src/mame/includes/ninjaw.h

r20971	r20972
49	49	UINT32 screen_update_ninjaw_middle(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
50	50	UINT32 screen_update_ninjaw_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
51	51	void ninjaw_postload();
	52	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int primask, int x_offs, int y_offs );
	53	void parse_control(  )   /* assumes Z80 sandwiched between 68Ks */;
	54	void reset_sound_region(  );
	55	UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int xoffs, device_t *tc0100scn);
52	56	};

trunk/src/mame/includes/nemesis.h

r20971	r20972
90	90	TIMER_DEVICE_CALLBACK_MEMBER(konamigt_interrupt);
91	91	TIMER_DEVICE_CALLBACK_MEMBER(gx400_interrupt);
92	92	void nemesis_postload();
	93	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
93	94	};

trunk/src/mame/includes/nitedrvr.h

r20971	r20972
59	59	virtual void video_start();
60	60	UINT32 screen_update_nitedrvr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
61	61	TIMER_DEVICE_CALLBACK_MEMBER(nitedrvr_crash_toggle_callback);
	62	void draw_box( bitmap_ind16 &bitmap, int bx, int by, int ex, int ey );
	63	void draw_roadway( bitmap_ind16 &bitmap );
	64	int nitedrvr_steering(  );
62	65	};
63	66
64	67	/*----------- defined in audio/nitedrvr.c -----------*/

trunk/src/mame/includes/nycaptor.h

r20971	r20972
105	105	DECLARE_MACHINE_RESET(ta7630);
106	106	UINT32 screen_update_nycaptor(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
107	107	TIMER_CALLBACK_MEMBER(nmi_callback);
	108	int nycaptor_spot(  );
	109	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri );
	110	void nycaptor_setmask(  );
108	111	};

trunk/src/mame/includes/nbmj9195.h

r20971	r20972
113	113	UINT32 screen_update_nbmj9195(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
114	114	INTERRUPT_GEN_MEMBER(ctc0_trg1);
115	115	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	116	int nbmj9195_blitter_r(int offset, int vram);
	117	void nbmj9195_blitter_w(int offset, int data, int vram);
	118	void nbmj9195_clutsel_w(int data);
	119	void nbmj9195_clut_w(int offset, int data, int vram);
	120	void nbmj9195_gfxflag2_w(int data);
	121	void nbmj9195_vramflip(int vram);
	122	void update_pixel(int vram, int x, int y);
	123	void nbmj9195_gfxdraw(int vram);
	124	void nbmj9195_outcoin_flag_w(int data);
	125	int nbmj9195_dipsw_r();
	126	void nbmj9195_dipswbitsel_w(int data);
	127	void mscoutm_inputportsel_w(int data);
116	128	};
117
118		/*----------- defined in video/nbmj9195.c -----------*/
119		void nbmj9195_clutsel_w(address_space &space, int data);
120		void nbmj9195_gfxflag2_w(address_space &space, int data);

trunk/src/mame/includes/niyanpai.h

r20971	r20972
82	82	UINT32 screen_update_niyanpai(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
83	83	INTERRUPT_GEN_MEMBER(niyanpai_interrupt);
84	84	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	85	int niyanpai_blitter_r(int vram, int offset);
	86	void niyanpai_blitter_w(int vram, int offset, int data);
	87	void niyanpai_clutsel_w(int vram, int data);
	88	void niyanpai_clut_w(int vram, int offset, int data);
	89	void niyanpai_vramflip(int vram);
	90	void update_pixel(int vram, int x, int y);
	91	void niyanpai_gfxdraw(int vram);
	92	void niyanpai_soundbank_w(int data);
85	93	};

trunk/src/mame/includes/nmk16.h

r20971	r20972
147	147	TIMER_DEVICE_CALLBACK_MEMBER(hachamf_mcu_sim);
148	148	TIMER_DEVICE_CALLBACK_MEMBER(nmk16_scanline);
149	149	TIMER_DEVICE_CALLBACK_MEMBER(manybloc_scanline);
	150	void nmk16_video_init();
	151	inline void nmk16_draw_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, UINT16 *spr);
	152	inline void nmk16_draw_sprite_flipsupported(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, UINT16 *spr);
	153	void nmk16_draw_sprites_swap(bitmap_ind16 &bitmap, const rectangle &cliprect, int *bittbl);
	154	void nmk16_draw_sprites_swap_flipsupported(bitmap_ind16 &bitmap, const rectangle &cliprect, int *bittbl);
	155	void nmk16_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority);
	156	void nmk16_draw_sprites_flipsupported(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority);
	157	int nmk16_bg_spr_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	158	int nmk16_bg_fg_spr_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	159	int nmk16_bg_spr_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	160	int nmk16_bg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	161	int nmk16_bioshipbg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	162	int nmk16_bg_sprswap_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8]);
	163	int nmk16_bg_sprswapflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8]);
	164	int nmk16_complexbg_sprswap_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8]);
	165	void video_update(bitmap_ind16 &bitmap, const rectangle &cliprect,int dsw_flipscreen,int xoffset, int yoffset,int attr_mask);
	166	void redhawki_video_update(bitmap_ind16 &bitmap, const rectangle &cliprect );
	167	void mcu_run(UINT8 dsw_setting);
	168	UINT8 decode_byte(UINT8 src, const UINT8 *bitp);
	169	UINT32 bjtwin_address_map_bg0(UINT32 addr);
	170	UINT16 decode_word(UINT16 src, const UINT8 *bitp);
	171	UINT32 bjtwin_address_map_sprites(UINT32 addr);
	172	void decode_gfx();
	173	void decode_tdragonb();
	174	void decode_ssmissin();
150	175	};

trunk/src/mame/includes/nova2001.h

r20971	r20972
44	44	UINT32 screen_update_ninjakun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
45	45	UINT32 screen_update_pkunwar(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
46	46	UINT32 screen_update_raiders5(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	47	void nova2001_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
	48	void pkunwar_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect );
	49	void lineswap_gfx_roms(const char *region, const int bit);
47	50	};

trunk/src/mame/video/ninjaw.c

r20971	r20972
14	14	SPRITE DRAW ROUTINE
15	15	************************************************************/
16	16
17		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int primask, int x_offs, int y_offs )
	17	void ninjaw_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int primask, int x_offs, int y_offs )
18	18	{
19		ninjaw_state *state = machine.driver_data<ninjaw_state>();
20		UINT16 *spriteram = state->m_spriteram;
	19	UINT16 *spriteram = m_spriteram;
21	20	int offs, data, tilenum, color, flipx, flipy;
22	21	int x, y, priority, curx, cury;
23	22	int code;
r20971	r20972
26	25	int unknown = 0;
27	26	#endif
28	27
29		for (offs = (state->m_spriteram.bytes() / 2) - 4; offs >= 0; offs -= 4)
	28	for (offs = (m_spriteram.bytes() / 2) - 4; offs >= 0; offs -= 4)
30	29	{
31	30	data = spriteram[offs + 2];
32	31	tilenum = data & 0x7fff;
r20971	r20972
78	77	cury = y;
79	78	code = tilenum;
80	79
81		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	80	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
82	81	code, color,
83	82	flipx, flipy,
84	83	curx, cury, 0);
r20971	r20972
95	94	SCREEN REFRESH
96	95	**************************************************************/
97	96
98		static UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int xoffs, device_t *tc0100scn)
	97	UINT32 ninjaw_state::update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int xoffs, device_t *tc0100scn)
99	98	{
100	99	UINT8 layer[3], nodraw;
101	100
r20971	r20972
114	113	bitmap.fill(get_black_pen(screen.machine()), cliprect);
115	114
116	115	/* Sprites can be under/over the layer below text layer */
117		draw_sprites(screen.machine(), bitmap, cliprect, 1, xoffs, 8); // draw sprites with priority 1 which are under the mid layer
	116	draw_sprites(bitmap, cliprect, 1, xoffs, 8); // draw sprites with priority 1 which are under the mid layer
118	117
119	118	// draw middle layer
120	119	tc0100scn_tilemap_draw(tc0100scn, bitmap, cliprect, layer[1], 0, 0);
121	120
122		draw_sprites(screen.machine(),bitmap,cliprect,0,xoffs,8); // draw sprites with priority 0 which are over the mid layer
	121	draw_sprites(bitmap,cliprect,0,xoffs,8); // draw sprites with priority 0 which are over the mid layer
123	122
124	123	// draw top(text) layer
125	124	tc0100scn_tilemap_draw(tc0100scn, bitmap, cliprect, layer[2], 0, 0);

trunk/src/mame/video/nova2001.c

r20971	r20972
254	254	*
255	255	*************************************/
256	256
257		static void nova2001_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	257	void nova2001_state::nova2001_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
258	258	{
259		nova2001_state *state = machine.driver_data<nova2001_state>();
260		UINT8 *spriteram = state->m_spriteram;
261		gfx_element *gfx = machine.gfx[0];
	259	UINT8 *spriteram = m_spriteram;
	260	gfx_element *gfx = machine().gfx[0];
262	261	int offs;
263	262
264	263	for (offs = 0; offs < 0x800; offs += 32)
r20971	r20972
276	275	continue;
277	276	}
278	277
279		if (state->flip_screen())
	278	if (flip_screen())
280	279	{
281	280	sx = 240 - sx;
282	281	sy = 240 - sy;
r20971	r20972
292	291	}
293	292	}
294	293
295		static void pkunwar_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	294	void nova2001_state::pkunwar_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect )
296	295	{
297		nova2001_state *state = machine.driver_data<nova2001_state>();
298		UINT8 *spriteram = state->m_spriteram;
299		gfx_element *gfx = machine.gfx[0];
	296	UINT8 *spriteram = m_spriteram;
	297	gfx_element *gfx = machine().gfx[0];
300	298	int offs;
301	299
302	300	for (offs = 0; offs < 0x800; offs += 32)
r20971	r20972
314	312	continue;
315	313	}
316	314
317		if (state->flip_screen())
	315	if (flip_screen())
318	316	{
319	317	sx = 240 - sx;
320	318	sy = 240 - sy;
r20971	r20972
343	341	{
344	342	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
345	343
346		nova2001_draw_sprites(machine(), bitmap, cliprect);
	344	nova2001_draw_sprites(bitmap, cliprect);
347	345
348	346	// according to the schematics, fg category 0 should be drawn behind sprites,
349	347	// but it doesn't look right that way
r20971	r20972
357	355	{
358	356	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE | TILEMAP_DRAW_ALL_CATEGORIES, 0);
359	357
360		pkunwar_draw_sprites(machine(), bitmap, cliprect);
	358	pkunwar_draw_sprites(bitmap, cliprect);
361	359
362	360	m_bg_tilemap->draw(bitmap, cliprect, 1, 0);
363	361
r20971	r20972
370	368
371	369	m_fg_tilemap->draw(bitmap, cliprect, 1, 0);
372	370
373		nova2001_draw_sprites(machine(), bitmap, cliprect);
	371	nova2001_draw_sprites(bitmap, cliprect);
374	372
375	373	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
376	374
r20971	r20972
381	379	{
382	380	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
383	381
384		pkunwar_draw_sprites(machine(), bitmap, cliprect);
	382	pkunwar_draw_sprites(bitmap, cliprect);
385	383
386	384	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
387	385

trunk/src/mame/video/n8080.c

r20971	r20972
44	44	}
45	45
46	46
47		void spacefev_start_red_cannon( running_machine &machine )
	47	void n8080_state::spacefev_start_red_cannon(  )
48	48	{
49		n8080_state *state = machine.driver_data<n8080_state>();
50
51		state->m_spacefev_red_cannon = 1;
52		state->m_cannon_timer->adjust(attotime::from_usec(550 * 68 * 10));
	49	m_spacefev_red_cannon = 1;
	50	m_cannon_timer->adjust(attotime::from_usec(550 * 68 * 10));
53	51	}
54	52
55	53
r20971	r20972
60	58	}
61	59
62	60
63		static void helifire_next_line( running_machine &machine )
	61	void n8080_state::helifire_next_line(  )
64	62	{
65		n8080_state *state = machine.driver_data<n8080_state>();
	63	m_helifire_mv++;
66	64
67		state->m_helifire_mv++;
68
69		if (state->m_helifire_sc % 4 == 2)
	65	if (m_helifire_sc % 4 == 2)
70	66	{
71		state->m_helifire_mv %= 256;
	67	m_helifire_mv %= 256;
72	68	}
73	69	else
74	70	{
75		if (state->flip_screen())
76		state->m_helifire_mv %= 255;
	71	if (flip_screen())
	72	m_helifire_mv %= 255;
77	73	else
78		state->m_helifire_mv %= 257;
	74	m_helifire_mv %= 257;
79	75	}
80	76
81		if (state->m_helifire_mv == 128)
	77	if (m_helifire_mv == 128)
82	78	{
83		state->m_helifire_sc++;
	79	m_helifire_sc++;
84	80	}
85	81	}
86	82
r20971	r20972
331	327
332	328	/* next line */
333	329
334		helifire_next_line(machine());
	330	helifire_next_line();
335	331	}
336	332
337	333	m_helifire_mv = saved_mv;
r20971	r20972
376	372
377	373	for (i = 0; i < 256; i++)
378	374	{
379		helifire_next_line(machine());
	375	helifire_next_line();
380	376	}
381	377	}
382	378	}

trunk/src/mame/video/ninjakd2.c

r20971	r20972
73	73	return (col & 0x0f) | ((row & 0x1f) << 4) | ((col & 0x70) << 5);
74	74	}
75	75
76		static void robokid_get_bg_tile_info(running_machine& machine, tile_data& tileinfo, tilemap_memory_index const tile_index, int const gfxnum, const UINT8* const videoram)
	76	void ninjakd2_state::robokid_get_bg_tile_info( tile_data& tileinfo, tilemap_memory_index const tile_index, int const gfxnum, const UINT8* const videoram)
77	77	{
78	78	int const lo = videoram[(tile_index << 1)];
79	79	int const hi = videoram[(tile_index << 1) | 1];
80	80	int const tile = ((hi & 0x10) << 7) | ((hi & 0x20) << 5) | ((hi & 0xc0) << 2) | lo;
81	81	int const color = hi & 0x0f;
82	82
83		SET_TILE_INFO(
	83	SET_TILE_INFO_MEMBER(
84	84	gfxnum,
85	85	tile,
86	86	color,
r20971	r20972
89	89
90	90	TILE_GET_INFO_MEMBER(ninjakd2_state::robokid_get_bg0_tile_info)
91	91	{
92		robokid_get_bg_tile_info(machine(), tileinfo, tile_index, 2, m_robokid_bg0_videoram);
	92	robokid_get_bg_tile_info(tileinfo, tile_index, 2, m_robokid_bg0_videoram);
93	93	}
94	94
95	95	TILE_GET_INFO_MEMBER(ninjakd2_state::robokid_get_bg1_tile_info)
96	96	{
97		robokid_get_bg_tile_info(machine(), tileinfo, tile_index, 3, m_robokid_bg1_videoram);
	97	robokid_get_bg_tile_info(tileinfo, tile_index, 3, m_robokid_bg1_videoram);
98	98	}
99	99
100	100	TILE_GET_INFO_MEMBER(ninjakd2_state::robokid_get_bg2_tile_info)
101	101	{
102		robokid_get_bg_tile_info(machine(), tileinfo, tile_index, 4, m_robokid_bg2_videoram);
	102	robokid_get_bg_tile_info(tileinfo, tile_index, 4, m_robokid_bg2_videoram);
103	103	}
104	104
105	105
r20971	r20972
283	283	}
284	284
285	285
286		static void bg_ctrl(int offset, int data, tilemap_t* tilemap)
	286	void ninjakd2_state::bg_ctrl(int offset, int data, tilemap_t* tilemap)
287	287	{
288	288	int scrollx = tilemap->scrollx(0);
289	289	int scrolly = tilemap->scrolly(0);
r20971	r20972
335	335	*
336	336	*************************************/
337	337
338		static void draw_sprites(running_machine& machine, bitmap_ind16 &bitmap)
	338	void ninjakd2_state::draw_sprites( bitmap_ind16 &bitmap)
339	339	{
340		ninjakd2_state *state = machine.driver_data<ninjakd2_state>();
341		gfx_element* const gfx = machine.gfx[1];
342		int const big_xshift = state->m_robokid_sprites ? 1 : 0;
343		int const big_yshift = state->m_robokid_sprites ? 0 : 1;
	340	gfx_element* const gfx = machine().gfx[1];
	341	int const big_xshift = m_robokid_sprites ? 1 : 0;
	342	int const big_yshift = m_robokid_sprites ? 0 : 1;
344	343
345		UINT8* sprptr = &state->m_spriteram[11];
	344	UINT8* sprptr = &m_spriteram[11];
346	345	int sprites_drawn = 0;
347	346
348	347	/* The sprite generator draws exactly 96 16x16 sprites per frame. When big
r20971	r20972
368	367	// Ninja Kid II doesn't use the 'big' feature so it might not be available on the board
369	368	int const big = (sprptr[2] & 0x04) >> 2;
370	369
371		if (state->flip_screen())
	370	if (flip_screen())
372	371	{
373	372	sx = 240 - 16*big - sx;
374	373	sy = 240 - 16*big - sy;
r20971	r20972
428	427	// This is very hackish.
429	428	// (Is there a possibility that software can't select it but hardware can?)
430	429
431		static void erase_sprites(running_machine& machine, bitmap_ind16 &bitmap)
	430	void ninjakd2_state::erase_sprites( bitmap_ind16 &bitmap)
432	431	{
433		ninjakd2_state *state = machine.driver_data<ninjakd2_state>();
434
435	432	// if sprite overdraw is disabled, clear the sprite framebuffer
436		if (!state->m_next_sprite_overdraw_enabled)
	433	if (!m_next_sprite_overdraw_enabled)
437	434	{
438		state->m_sprites_bitmap.fill(0xf);
	435	m_sprites_bitmap.fill(0xf);
439	436	}
440	437	else
441	438	{
442		for (int y = 0; y < state->m_sprites_bitmap.height(); ++y)
	439	for (int y = 0; y < m_sprites_bitmap.height(); ++y)
443	440	{
444		for (int x = 0; x < state->m_sprites_bitmap.width(); ++x)
	441	for (int x = 0; x < m_sprites_bitmap.width(); ++x)
445	442	{
446		UINT16* const ptr = &state->m_sprites_bitmap.pix16(y, x);
447		if ( (*state->m_stencil_compare_function)(*ptr) ) *ptr = 0xf;
	443	UINT16* const ptr = &m_sprites_bitmap.pix16(y, x);
	444	if ( (*m_stencil_compare_function)(*ptr) ) *ptr = 0xf;
448	445	}
449	446	}
450	447	}
451	448	}
452	449
453	450
454		static void update_sprites(running_machine& machine)
	451	void ninjakd2_state::update_sprites()
455	452	{
456		ninjakd2_state *state = machine.driver_data<ninjakd2_state>();
457
458	453	////// Before modified, this was written.
459	454	// we want to erase the sprites with the old setting and draw them with the
460	455	// new one. Not doing this causes a glitch in Ninja Kid II when taking the top
461	456	// exit from stage 3.
462	457	////// The glitch is correct behavior.
463		erase_sprites(machine, state->m_sprites_bitmap);
464		draw_sprites(machine, state->m_sprites_bitmap);
	458	erase_sprites(m_sprites_bitmap);
	459	draw_sprites(m_sprites_bitmap);
465	460	}
466	461
467	462
r20971	r20972
469	464	{
470	465	// updating sprites here instead than in screen_eof avoids a palette glitch
471	466	// at the end of the "rainbow sky" screens.
472		update_sprites(machine());
	467	update_sprites();
473	468	m_sprites_updated = 1;
474	469
475	470	bitmap.fill(0, cliprect);
r20971	r20972
483	478
484	479	UINT32 ninjakd2_state::screen_update_robokid(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
485	480	{
486		update_sprites(machine());
	481	update_sprites();
487	482	m_sprites_updated = 1;
488	483
489	484	bitmap.fill(0, cliprect);
r20971	r20972
499	494
500	495	UINT32 ninjakd2_state::screen_update_omegaf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
501	496	{
502		update_sprites(machine());
	497	update_sprites();
503	498	m_sprites_updated = 1;
504	499
505	500	bitmap.fill(0, cliprect);
r20971	r20972
520	515	if (state)
521	516	{
522	517	if (!m_sprites_updated)
523		update_sprites(machine());
	518	update_sprites();
524	519
525	520	m_sprites_updated = 0;
526	521	}

trunk/src/mame/video/nbmj8891.c

r20971	r20972
11	11	#include "includes/nbmj8891.h"
12	12
13	13
14		static void nbmj8891_vramflip(running_machine &machine, int vram);
15		static void nbmj8891_gfxdraw(running_machine &machine);
16
17
18	14	/******************************************************************************
19	15
20	16
r20971	r20972
115	111	case 0x04:  m_blitter_sizex = data; break;
116	112	case 0x05:  m_blitter_sizey = data;
117	113	/* writing here also starts the blit */
118		nbmj8891_gfxdraw(machine());
	114	nbmj8891_gfxdraw();
119	115	break;
120	116	case 0x06:  m_blitter_direction_x = (data & 0x01) ? 1 : 0;
121	117	m_blitter_direction_y = (data & 0x02) ? 1 : 0;
122	118	m_flipscreen = (data & 0x04) ? 1 : 0;
123	119	m_dispflag = (data & 0x08) ? 0 : 1;
124		if (m_gfxdraw_mode) nbmj8891_vramflip(machine(), 1);
125		nbmj8891_vramflip(machine(), 0);
	120	if (m_gfxdraw_mode) nbmj8891_vramflip(1);
	121	nbmj8891_vramflip(0);
126	122	break;
127	123	case 0x07:  break;
128	124	}
r20971	r20972
143	139
144	140	WRITE8_MEMBER(nbmj8891_state::nbmj8891_taiwanmb_gfxdraw_w)
145	141	{
146		//  nbmj8891_gfxdraw(machine());
	142	//  nbmj8891_gfxdraw();
147	143	}
148	144
149	145	WRITE8_MEMBER(nbmj8891_state::nbmj8891_taiwanmb_gfxflag_w)
150	146	{
151	147	m_flipscreen = (data & 0x04) ? 1 : 0;
152	148
153		nbmj8891_vramflip(machine(), 0);
	149	nbmj8891_vramflip(0);
154	150	}
155	151
156	152	WRITE8_MEMBER(nbmj8891_state::nbmj8891_taiwanmb_mcu_w)
r20971	r20972
226	222	m_blitter_sizey ^= 0x00;
227	223	}
228	224
229		nbmj8891_gfxdraw(machine());
	225	nbmj8891_gfxdraw();
230	226	}
231	227
232	228	//  m_blitter_direction_x = 0;                // for debug
r20971	r20972
267	263
268	264
269	265	******************************************************************************/
270		void nbmj8891_vramflip(running_machine &machine, int vram)
	266	void nbmj8891_state::nbmj8891_vramflip(int vram)
271	267	{
272		nbmj8891_state *state = machine.driver_data<nbmj8891_state>();
273	268	int x, y;
274	269	UINT8 color1, color2;
275	270	UINT8 *vidram;
276	271
277		int width = machine.primary_screen->width();
278		int height = machine.primary_screen->height();
	272	int width = machine().primary_screen->width();
	273	int height = machine().primary_screen->height();
279	274
280		if (state->m_flipscreen == state->m_flipscreen_old) return;
	275	if (m_flipscreen == m_flipscreen_old) return;
281	276
282		vidram = vram ? state->m_videoram1 : state->m_videoram0;
	277	vidram = vram ? m_videoram1 : m_videoram0;
283	278
284	279	for (y = 0; y < (height / 2); y++)
285	280	{
r20971	r20972
292	287	}
293	288	}
294	289
295		state->m_flipscreen_old = state->m_flipscreen;
296		state->m_screen_refresh = 1;
	290	m_flipscreen_old = m_flipscreen;
	291	m_screen_refresh = 1;
297	292	}
298	293
299	294
300		static void update_pixel0(running_machine &machine, int x, int y)
	295	void nbmj8891_state::update_pixel0(int x, int y)
301	296	{
302		nbmj8891_state *state = machine.driver_data<nbmj8891_state>();
303		UINT8 color = state->m_videoram0[(y * machine.primary_screen->width()) + x];
304		state->m_tmpbitmap0.pix16(y, x) = color;
	297	UINT8 color = m_videoram0[(y * machine().primary_screen->width()) + x];
	298	m_tmpbitmap0.pix16(y, x) = color;
305	299	}
306	300
307		static void update_pixel1(running_machine &machine, int x, int y)
	301	void nbmj8891_state::update_pixel1(int x, int y)
308	302	{
309		nbmj8891_state *state = machine.driver_data<nbmj8891_state>();
310		UINT8 color = state->m_videoram1[(y * machine.primary_screen->width()) + x];
311		state->m_tmpbitmap1.pix16(y, x) = (color == 0x7f) ? 0xff : color;
	303	UINT8 color = m_videoram1[(y * machine().primary_screen->width()) + x];
	304	m_tmpbitmap1.pix16(y, x) = (color == 0x7f) ? 0xff : color;
312	305	}
313	306
314	307	TIMER_CALLBACK_MEMBER(nbmj8891_state::blitter_timer_callback)
r20971	r20972
316	309	nb1413m3_busyflag = 1;
317	310	}
318	311
319		static void nbmj8891_gfxdraw(running_machine &machine)
	312	void nbmj8891_state::nbmj8891_gfxdraw()
320	313	{
321		nbmj8891_state *state = machine.driver_data<nbmj8891_state>();
322		UINT8 *GFX = state->memregion("gfx1")->base();
323		int width = machine.primary_screen->width();
	314	UINT8 *GFX = memregion("gfx1")->base();
	315	int width = machine().primary_screen->width();
324	316
325	317	int x, y;
326	318	int dx1, dx2, dy1, dy2;
r20971	r20972
333	325
334	326	nb1413m3_busyctr = 0;
335	327
336		startx = state->m_blitter_destx + state->m_blitter_sizex;
337		starty = state->m_blitter_desty + state->m_blitter_sizey;
	328	startx = m_blitter_destx + m_blitter_sizex;
	329	starty = m_blitter_desty + m_blitter_sizey;
338	330
339		if (state->m_blitter_direction_x)
	331	if (m_blitter_direction_x)
340	332	{
341		sizex = state->m_blitter_sizex ^ 0xff;
	333	sizex = m_blitter_sizex ^ 0xff;
342	334	skipx = 1;
343	335	}
344	336	else
345	337	{
346		sizex = state->m_blitter_sizex;
	338	sizex = m_blitter_sizex;
347	339	skipx = -1;
348	340	}
349	341
350		if (state->m_blitter_direction_y)
	342	if (m_blitter_direction_y)
351	343	{
352		sizey = state->m_blitter_sizey ^ 0xff;
	344	sizey = m_blitter_sizey ^ 0xff;
353	345	skipy = 1;
354	346	}
355	347	else
356	348	{
357		sizey = state->m_blitter_sizey;
	349	sizey = m_blitter_sizey;
358	350	skipy = -1;
359	351	}
360	352
361		gfxlen = machine.root_device().memregion("gfx1")->bytes();
362		gfxaddr = (state->m_gfxrom << 17) + (state->m_blitter_src_addr << 1);
	353	gfxlen = machine().root_device().memregion("gfx1")->bytes();
	354	gfxaddr = (m_gfxrom << 17) + (m_blitter_src_addr << 1);
363	355
364	356	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
365	357	{
r20971	r20972
378	370	// for hanamomo font type
379	371	if (nb1413m3_type == NB1413M3_HANAMOMO)
380	372	{
381		if ((state->ioport("FONTTYPE")->read()) == 0x00)
	373	if ((ioport("FONTTYPE")->read()) == 0x00)
382	374	{
383	375	if ((gfxaddr >= 0x20000) && (gfxaddr < 0x28000))
384	376	{
r20971	r20972
390	382	dx1 = (2 * x + 0) & 0x1ff;
391	383	dx2 = (2 * x + 1) & 0x1ff;
392	384
393		if (state->m_gfxdraw_mode)
	385	if (m_gfxdraw_mode)
394	386	{
395	387	// 2 layer type
396	388	dy1 = y & 0xff;
397		dy2 = (y + state->m_scrolly) & 0xff;
	389	dy2 = (y + m_scrolly) & 0xff;
398	390	}
399	391	else
400	392	{
401	393	// 1 layer type
402		dy1 = (y + state->m_scrolly) & 0xff;
	394	dy1 = (y + m_scrolly) & 0xff;
403	395	dy2 = 0;
404	396	}
405	397
406		if (!state->m_flipscreen)
	398	if (!m_flipscreen)
407	399	{
408	400	dx1 ^= 0x1ff;
409	401	dx2 ^= 0x1ff;
r20971	r20972
411	403	dy2 ^= 0xff;
412	404	}
413	405
414		if (state->m_blitter_direction_x)
	406	if (m_blitter_direction_x)
415	407	{
416	408	// flip
417	409	color1 = (color & 0x0f) >> 0;
r20971	r20972
424	416	color2 = (color & 0x0f) >> 0;
425	417	}
426	418
427		color1 = state->m_clut[((state->m_clutsel & 0x7f) << 4) + color1];
428		color2 = state->m_clut[((state->m_clutsel & 0x7f) << 4) + color2];
	419	color1 = m_clut[((m_clutsel & 0x7f) << 4) + color1];
	420	color2 = m_clut[((m_clutsel & 0x7f) << 4) + color2];
429	421
430		if ((!state->m_gfxdraw_mode) || (state->m_vram & 0x01))
	422	if ((!m_gfxdraw_mode) || (m_vram & 0x01))
431	423	{
432	424	// layer 1
433	425	if (color1 != 0xff)
434	426	{
435		state->m_videoram0[(dy1 * width) + dx1] = color1;
436		update_pixel0(machine, dx1, dy1);
	427	m_videoram0[(dy1 * width) + dx1] = color1;
	428	update_pixel0(dx1, dy1);
437	429	}
438	430	if (color2 != 0xff)
439	431	{
440		state->m_videoram0[(dy1 * width) + dx2] = color2;
441		update_pixel0(machine, dx2, dy1);
	432	m_videoram0[(dy1 * width) + dx2] = color2;
	433	update_pixel0(dx2, dy1);
442	434	}
443	435	}
444		if (state->m_gfxdraw_mode && (state->m_vram & 0x02))
	436	if (m_gfxdraw_mode && (m_vram & 0x02))
445	437	{
446	438	// layer 2
447		if (state->m_vram & 0x08)
	439	if (m_vram & 0x08)
448	440	{
449	441	// transparent enable
450	442	if (color1 != 0xff)
451	443	{
452		state->m_videoram1[(dy2 * width) + dx1] = color1;
453		update_pixel1(machine, dx1, dy2);
	444	m_videoram1[(dy2 * width) + dx1] = color1;
	445	update_pixel1(dx1, dy2);
454	446	}
455	447	if (color2 != 0xff)
456	448	{
457		state->m_videoram1[(dy2 * width) + dx2] = color2;
458		update_pixel1(machine, dx2, dy2);
	449	m_videoram1[(dy2 * width) + dx2] = color2;
	450	update_pixel1(dx2, dy2);
459	451	}
460	452	}
461	453	else
462	454	{
463	455	// transparent disable
464		state->m_videoram1[(dy2 * width) + dx1] = color1;
465		update_pixel1(machine, dx1, dy2);
466		state->m_videoram1[(dy2 * width) + dx2] = color2;
467		update_pixel1(machine, dx2, dy2);
	456	m_videoram1[(dy2 * width) + dx1] = color1;
	457	update_pixel1(dx1, dy2);
	458	m_videoram1[(dy2 * width) + dx2] = color2;
	459	update_pixel1(dx2, dy2);
468	460	}
469	461	}
470	462
r20971	r20972
473	465	}
474	466
475	467	nb1413m3_busyflag = 0;
476		machine.scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8891_state::blitter_timer_callback),state));
	468	machine().scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8891_state::blitter_timer_callback),this));
477	469	}
478	470
479	471	/******************************************************************************
r20971	r20972
530	522	m_screen_refresh = 0;
531	523	for (y = 0; y < height; y++)
532	524	for (x = 0; x < width; x++)
533		update_pixel0(machine(), x, y);
	525	update_pixel0(x, y);
534	526
535	527	if (m_gfxdraw_mode)
536	528	for (y = 0; y < height; y++)
537	529	for (x = 0; x < width; x++)
538		update_pixel1(machine(), x, y);
	530	update_pixel1(x, y);
539	531	}
540	532
541	533	if (m_dispflag)

trunk/src/mame/video/nbmj8688.c

r20971	r20972
11	11	#include "includes/nbmj8688.h"
12	12
13	13
14		static void mbmj8688_gfxdraw(running_machine &machine, int gfxtype);
15
16
17	14	/* the blitter can copy data both in "direct" mode, where every byte of the source
18	15	data is copied verbatim to video RAM *twice* (thus doubling the pixel width),
19	16	and in "lookup" mode, where the source byte is taken 4 bits at a time and indexed
r20971	r20972
123	120	case 0x04:  m_blitter_sizex = data; break;
124	121	case 0x05:  m_blitter_sizey = data;
125	122	/* writing here also starts the blit */
126		mbmj8688_gfxdraw(machine(), m_mjsikaku_gfxmode);
	123	mbmj8688_gfxdraw(m_mjsikaku_gfxmode);
127	124	break;
128	125	case 0x06:  m_blitter_direction_x = (data & 0x01) ? 1 : 0;
129	126	m_blitter_direction_y = (data & 0x02) ? 1 : 0;
r20971	r20972
246	243	}
247	244
248	245
249		static void update_pixel(nbmj8688_state *state, int x, int y)
	246	void nbmj8688_state::update_pixel(int x, int y)
250	247	{
251		int color = state->m_mjsikaku_videoram[(y * 512) + x];
252		state->m_mjsikaku_tmpbitmap->pix16(y, x) = color;
	248	int color = m_mjsikaku_videoram[(y * 512) + x];
	249	m_mjsikaku_tmpbitmap->pix16(y, x) = color;
253	250	}
254	251
255		static void writeram_low(nbmj8688_state *state, int x, int y, int color)
	252	void nbmj8688_state::writeram_low(int x, int y, int color)
256	253	{
257		state->m_mjsikaku_videoram[(y * 512) + x] &= 0xff00;
258		state->m_mjsikaku_videoram[(y * 512) + x] |= color;
259		update_pixel(state, x, y);
	254	m_mjsikaku_videoram[(y * 512) + x] &= 0xff00;
	255	m_mjsikaku_videoram[(y * 512) + x] |= color;
	256	update_pixel(x, y);
260	257	}
261	258
262		static void writeram_high(nbmj8688_state *state, int x, int y, int color)
	259	void nbmj8688_state::writeram_high(int x, int y, int color)
263	260	{
264		state->m_mjsikaku_videoram[(y * 512) + x] &= 0x00ff;
265		state->m_mjsikaku_videoram[(y * 512) + x] |= color << 8;
266		update_pixel(state, x, y);
	261	m_mjsikaku_videoram[(y * 512) + x] &= 0x00ff;
	262	m_mjsikaku_videoram[(y * 512) + x] |= color << 8;
	263	update_pixel(x, y);
267	264	}
268	265
269	266	TIMER_CALLBACK_MEMBER(nbmj8688_state::blitter_timer_callback)
r20971	r20972
271	268	nb1413m3_busyflag = 1;
272	269	}
273	270
274		static void mbmj8688_gfxdraw(running_machine &machine, int gfxtype)
	271	void nbmj8688_state::mbmj8688_gfxdraw(int gfxtype)
275	272	{
276		nbmj8688_state *state = machine.driver_data<nbmj8688_state>();
277		UINT8 *GFX = state->memregion("gfx1")->base();
	273	UINT8 *GFX = memregion("gfx1")->base();
278	274
279	275	int x, y;
280	276	int dx1, dx2, dy;
r20971	r20972
287	283
288	284	if (gfxtype == GFXTYPE_PURE_12BIT)
289	285	{
290		if (state->m_mjsikaku_gfxflag2 & 0x20) return;
	286	if (m_mjsikaku_gfxflag2 & 0x20) return;
291	287	}
292	288
293	289	nb1413m3_busyctr = 0;
294	290
295		startx = state->m_blitter_destx + state->m_blitter_sizex;
296		starty = state->m_blitter_desty + state->m_blitter_sizey;
	291	startx = m_blitter_destx + m_blitter_sizex;
	292	starty = m_blitter_desty + m_blitter_sizey;
297	293
298		if (state->m_blitter_direction_x)
	294	if (m_blitter_direction_x)
299	295	{
300		sizex = state->m_blitter_sizex ^ 0xff;
	296	sizex = m_blitter_sizex ^ 0xff;
301	297	skipx = 1;
302	298	}
303	299	else
304	300	{
305		sizex = state->m_blitter_sizex;
	301	sizex = m_blitter_sizex;
306	302	skipx = -1;
307	303	}
308	304
309		if (state->m_blitter_direction_y)
	305	if (m_blitter_direction_y)
310	306	{
311		sizey = state->m_blitter_sizey ^ 0xff;
	307	sizey = m_blitter_sizey ^ 0xff;
312	308	skipy = 1;
313	309	}
314	310	else
315	311	{
316		sizey = state->m_blitter_sizey;
	312	sizey = m_blitter_sizey;
317	313	skipy = -1;
318	314	}
319	315
320		gfxlen = machine.root_device().memregion("gfx1")->bytes();
321		gfxaddr = (state->m_mjsikaku_gfxrom << 17) + (state->m_blitter_src_addr << 1);
	316	gfxlen = machine().root_device().memregion("gfx1")->bytes();
	317	gfxaddr = (m_mjsikaku_gfxrom << 17) + (m_blitter_src_addr << 1);
322	318
323	319	//popmessage("ADDR:%08X DX:%03d DY:%03d SX:%03d SY:%03d", gfxaddr, startx, starty, sizex, sizey);
324	320	//logerror("ADDR:%08X DX:%03d DY:%03d SX:%03d SY:%03d\n", gfxaddr, startx, starty, sizex, sizey);
325		//if (state->m_blitter_direction_x|state->m_blitter_direction_y) popmessage("ADDR:%08X FX:%01d FY:%01d", gfxaddr, state->m_blitter_direction_x, state->m_blitter_direction_y);
	321	//if (m_blitter_direction_x|m_blitter_direction_y) popmessage("ADDR:%08X FX:%01d FY:%01d", gfxaddr, m_blitter_direction_x, m_blitter_direction_y);
326	322
327	323	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
328	324	{
r20971	r20972
340	336
341	337	dx1 = (2 * x + 0) & 0x1ff;
342	338	dx2 = (2 * x + 1) & 0x1ff;
343		dy = (y + state->m_mjsikaku_scrolly) & 0xff;
	339	dy = (y + m_mjsikaku_scrolly) & 0xff;
344	340
345		if (state->m_mjsikaku_flipscreen)
	341	if (m_mjsikaku_flipscreen)
346	342	{
347	343	dx1 ^= 0x1ff;
348	344	dx2 ^= 0x1ff;
r20971	r20972
351	347
352	348	if (gfxtype == GFXTYPE_HYBRID_16BIT)
353	349	{
354		if (state->m_mjsikaku_gfxflag3 & 0x40)
	350	if (m_mjsikaku_gfxflag3 & 0x40)
355	351	{
356	352	// direct mode
357	353
358		if (state->m_mjsikaku_gfxflag3 & 0x80)
	354	if (m_mjsikaku_gfxflag3 & 0x80)
359	355	{
360	356	/* least significant bits */
361	357	if (color != 0xff)
362	358	{
363		writeram_low(state, dx1, dy, color);
364		writeram_low(state, dx2, dy, color);
	359	writeram_low(dx1, dy, color);
	360	writeram_low(dx2, dy, color);
365	361	}
366	362	}
367	363	else
r20971	r20972
369	365	/* most significant bits */
370	366	if (color != 0xff)
371	367	{
372		writeram_high(state, dx1, dy, color);
373		writeram_high(state, dx2, dy, color);
	368	writeram_high(dx1, dy, color);
	369	writeram_high(dx2, dy, color);
374	370	}
375	371	}
376	372	}
r20971	r20972
380	376	// lookup table mode
381	377
382	378	// unknown flag (seiha, seiham)
383		//  if (state->m_mjsikaku_gfxflag3 & 0x80) return;
	379	//  if (m_mjsikaku_gfxflag3 & 0x80) return;
384	380
385	381	// unknown (seiha, seiham, iemoto, ojousan)
386		if (!(state->m_mjsikaku_gfxflag2 & 0x20)) return;
	382	if (!(m_mjsikaku_gfxflag2 & 0x20)) return;
387	383
388		if (state->m_blitter_direction_x)
	384	if (m_blitter_direction_x)
389	385	{
390	386	// flip
391	387	color1 = (color & 0x0f) >> 0;
r20971	r20972
398	394	color2 = (color & 0x0f) >> 0;
399	395	}
400	396
401		color1 = (state->m_clut[color1] << 8) | ((state->m_clut[color1 | 0x10] & 0x0f) << 4);
402		color2 = (state->m_clut[color2] << 8) | ((state->m_clut[color2 | 0x10] & 0x0f) << 4);
	397	color1 = (m_clut[color1] << 8) | ((m_clut[color1 | 0x10] & 0x0f) << 4);
	398	color2 = (m_clut[color2] << 8) | ((m_clut[color2 | 0x10] & 0x0f) << 4);
403	399
404	400	if (color1 != 0xfff0)
405	401	{
406	402	/* extend color from 12-bit to 16-bit */
407	403	color1 = (color1 & 0xffc0) | ((color1 & 0x20) >> 1) | ((color1 & 0x10) >> 2);
408		state->m_mjsikaku_videoram[(dy * 512) + dx1] = color1;
409		update_pixel(state, dx1, dy);
	404	m_mjsikaku_videoram[(dy * 512) + dx1] = color1;
	405	update_pixel(dx1, dy);
410	406	}
411	407
412	408	if (color2 != 0xfff0)
413	409	{
414	410	/* extend color from 12-bit to 16-bit */
415	411	color2 = (color2 & 0xffc0) | ((color2 & 0x20) >> 1) | ((color2 & 0x10) >> 2);
416		state->m_mjsikaku_videoram[(dy * 512) + dx2] = color2;
417		update_pixel(state, dx2, dy);
	412	m_mjsikaku_videoram[(dy * 512) + dx2] = color2;
	413	update_pixel(dx2, dy);
418	414	}
419	415	}
420	416	}
r20971	r20972
422	418	{
423	419	/* 12-bit palette with 4-to-12 bit lookup table */
424	420
425		if (state->m_blitter_direction_x)
	421	if (m_blitter_direction_x)
426	422	{
427	423	// flip
428	424	color1 = (color & 0x0f) >> 0;
r20971	r20972
435	431	color2 = (color & 0x0f) >> 0;
436	432	}
437	433
438		color1 = state->m_clut[color1] | ((state->m_clut[color1 | 0x10] & 0x0f) << 8);
439		color2 = state->m_clut[color2] | ((state->m_clut[color2 | 0x10] & 0x0f) << 8);
	434	color1 = m_clut[color1] | ((m_clut[color1 | 0x10] & 0x0f) << 8);
	435	color2 = m_clut[color2] | ((m_clut[color2 | 0x10] & 0x0f) << 8);
440	436
441	437	if (color1 != 0x0fff)
442	438	{
443		state->m_mjsikaku_videoram[(dy * 512) + dx1] = color1;
444		update_pixel(state, dx1, dy);
	439	m_mjsikaku_videoram[(dy * 512) + dx1] = color1;
	440	update_pixel(dx1, dy);
445	441	}
446	442	if (color2 != 0x0fff)
447	443	{
448		state->m_mjsikaku_videoram[(dy * 512) + dx2] = color2;
449		update_pixel(state, dx2, dy);
	444	m_mjsikaku_videoram[(dy * 512) + dx2] = color2;
	445	update_pixel(dx2, dy);
450	446	}
451	447	}
452	448	else
453	449	{
454		if (gfxtype == GFXTYPE_HYBRID_12BIT && (state->m_mjsikaku_gfxflag2 & 0x20))
	450	if (gfxtype == GFXTYPE_HYBRID_12BIT && (m_mjsikaku_gfxflag2 & 0x20))
455	451	{
456	452	/* 4096 colors mode, wedged in on top of normal mode
457	453	Here we affect only the 4 least significant bits, the others are
458	454	changed as usual.
459	455	*/
460	456
461		if (state->m_mjsikaku_gfxflag2 & 0x10)
	457	if (m_mjsikaku_gfxflag2 & 0x10)
462	458	{
463	459	// 4096 colors low mode (2nd draw upper)
464		color = state->m_clut[((color & 0xf0) >> 4)];
	460	color = m_clut[((color & 0xf0) >> 4)];
465	461	}
466	462	else
467	463	{
468	464	// 4096 colors low mode (1st draw lower)
469		color = state->m_clut[((color & 0x0f) >> 0)];
	465	color = m_clut[((color & 0x0f) >> 0)];
470	466	}
471	467
472	468	if (color != 0xff)
473	469	{
474	470	color &= 0x0f;
475		writeram_high(state, dx1, dy, color);
476		writeram_high(state, dx2, dy, color);
	471	writeram_high(dx1, dy, color);
	472	writeram_high(dx2, dy, color);
477	473	}
478	474	}
479	475	else
480	476	{
481		if (state->m_mjsikaku_gfxflag2 & 0x04)
	477	if (m_mjsikaku_gfxflag2 & 0x04)
482	478	{
483	479	// direct mode
484	480
r20971	r20972
488	484	{
489	485	// lookup table mode
490	486
491		if (state->m_blitter_direction_x)
	487	if (m_blitter_direction_x)
492	488	{
493	489	// flip
494	490	color1 = (color & 0x0f) >> 0;
r20971	r20972
501	497	color2 = (color & 0x0f) >> 0;
502	498	}
503	499
504		color1 = state->m_clut[color1];
505		color2 = state->m_clut[color2];
	500	color1 = m_clut[color1];
	501	color2 = m_clut[color2];
506	502	}
507	503
508		if (gfxtype == GFXTYPE_PURE_16BIT && !(state->m_mjsikaku_gfxflag2 & 0x20))
	504	if (gfxtype == GFXTYPE_PURE_16BIT && !(m_mjsikaku_gfxflag2 & 0x20))
509	505	{
510	506	/* 16-bit palette most significant bits */
511		if (color1 != 0xff) writeram_high(state, dx1, dy, color1);
512		if (color2 != 0xff) writeram_high(state, dx2, dy, color2);
	507	if (color1 != 0xff) writeram_high(dx1, dy, color1);
	508	if (color2 != 0xff) writeram_high(dx2, dy, color2);
513	509	}
514	510	else
515	511	{
516	512	/* 8-bit palette or 16-bit palette least significant bits */
517		if (color1 != 0xff) writeram_low(state, dx1, dy, color1);
518		if (color2 != 0xff) writeram_low(state, dx2, dy, color2);
	513	if (color1 != 0xff) writeram_low(dx1, dy, color1);
	514	if (color2 != 0xff) writeram_low(dx2, dy, color2);
519	515	}
520	516	}
521	517	}
r20971	r20972
527	523	nb1413m3_busyflag = 0;
528	524
529	525	if (gfxtype == GFXTYPE_8BIT)
530		machine.scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8688_state::blitter_timer_callback),state));
	526	machine().scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8688_state::blitter_timer_callback),this));
531	527	else
532		machine.scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8688_state::blitter_timer_callback),state));
	528	machine().scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8688_state::blitter_timer_callback),this));
533	529	}
534	530
535	531
r20971	r20972
538	534
539	535	******************************************************************************/
540	536
541		static void common_video_start(running_machine &machine)
	537	void nbmj8688_state::common_video_start()
542	538	{
543		nbmj8688_state *state = machine.driver_data<nbmj8688_state>();
544		state->m_mjsikaku_tmpbitmap = auto_bitmap_ind16_alloc(machine, 512, 256);
545		state->m_mjsikaku_videoram = auto_alloc_array_clear(machine, UINT16, 512 * 256);
546		state->m_clut = auto_alloc_array(machine, UINT8, 0x20);
	539	m_mjsikaku_tmpbitmap = auto_bitmap_ind16_alloc(machine(), 512, 256);
	540	m_mjsikaku_videoram = auto_alloc_array_clear(machine(), UINT16, 512 * 256);
	541	m_clut = auto_alloc_array(machine(), UINT8, 0x20);
547	542
548		state->m_mjsikaku_scrolly = 0;  // reset because crystalg/crystal2 don't write to this register
	543	m_mjsikaku_scrolly = 0;  // reset because crystalg/crystal2 don't write to this register
549	544	}
550	545
551	546	VIDEO_START_MEMBER(nbmj8688_state,mbmj8688_8bit)
552	547	{
553	548	m_mjsikaku_gfxmode = GFXTYPE_8BIT;
554		common_video_start(machine());
	549	common_video_start();
555	550	}
556	551
557	552	VIDEO_START_MEMBER(nbmj8688_state,mbmj8688_hybrid_12bit)
558	553	{
559	554	m_mjsikaku_gfxmode = GFXTYPE_HYBRID_12BIT;
560		common_video_start(machine());
	555	common_video_start();
561	556	}
562	557
563	558	VIDEO_START_MEMBER(nbmj8688_state,mbmj8688_pure_12bit)
564	559	{
565	560	m_mjsikaku_gfxmode = GFXTYPE_PURE_12BIT;
566		common_video_start(machine());
	561	common_video_start();
567	562	}
568	563
569	564	VIDEO_START_MEMBER(nbmj8688_state,mbmj8688_hybrid_16bit)
570	565	{
571	566	m_mjsikaku_gfxmode = GFXTYPE_HYBRID_16BIT;
572		common_video_start(machine());
	567	common_video_start();
573	568	}
574	569
575	570	VIDEO_START_MEMBER(nbmj8688_state,mbmj8688_pure_16bit)
576	571	{
577	572	m_mjsikaku_gfxmode = GFXTYPE_PURE_16BIT;
578		common_video_start(machine());
	573	common_video_start();
579	574	}
580	575
581	576	VIDEO_START_MEMBER(nbmj8688_state,mbmj8688_pure_16bit_LCD)
r20971	r20972
585	580	m_HD61830B_ram[0] = auto_alloc_array(machine(), UINT8, 0x10000);
586	581	m_HD61830B_ram[1] = auto_alloc_array(machine(), UINT8, 0x10000);
587	582
588		common_video_start(machine());
	583	common_video_start();
589	584	}
590	585
591	586
r20971	r20972
596	591
597	592	******************************************************************************/
598	593
599		static void nbmj8688_HD61830B_instr_w(address_space &space,int offset,int data,int chip)
	594	void nbmj8688_state::nbmj8688_HD61830B_instr_w(address_space &space,int offset,int data,int chip)
600	595	{
601		nbmj8688_state *state = space.machine().driver_data<nbmj8688_state>();
602		state->m_HD61830B_instr[chip] = data;
	596	m_HD61830B_instr[chip] = data;
603	597	}
604	598
605		static void nbmj8688_HD61830B_data_w(address_space &space,int offset,int data,int chip)
	599	void nbmj8688_state::nbmj8688_HD61830B_data_w(address_space &space,int offset,int data,int chip)
606	600	{
607		nbmj8688_state *state = space.machine().driver_data<nbmj8688_state>();
608		switch (state->m_HD61830B_instr[chip])
	601	switch (m_HD61830B_instr[chip])
609	602	{
610	603	case 0x0a:  // set cursor address (low order)
611		state->m_HD61830B_addr[chip] = (state->m_HD61830B_addr[chip] & 0xff00) | data;
	604	m_HD61830B_addr[chip] = (m_HD61830B_addr[chip] & 0xff00) | data;
612	605	break;
613	606	case 0x0b:  // set cursor address (high order)
614		state->m_HD61830B_addr[chip] = (state->m_HD61830B_addr[chip] & 0x00ff) | (data << 8);
	607	m_HD61830B_addr[chip] = (m_HD61830B_addr[chip] & 0x00ff) | (data << 8);
615	608	break;
616	609	case 0x0c:  // write display data
617		state->m_HD61830B_ram[chip][state->m_HD61830B_addr[chip]++] = data;
	610	m_HD61830B_ram[chip][m_HD61830B_addr[chip]++] = data;
618	611	break;
619	612	default:
620		logerror("HD61830B unsupported instruction %02x %02x\n",state->m_HD61830B_instr[chip],data);
	613	logerror("HD61830B unsupported instruction %02x %02x\n",m_HD61830B_instr[chip],data);
621	614	break;
622	615	}
623	616	}
r20971	r20972
678	671	{
679	672	for (x = 0; x < 512; x++)
680	673	{
681		update_pixel(this, x, y);
	674	update_pixel(x, y);
682	675	}
683	676	}
684	677	}

trunk/src/mame/video/nbmj8991.c

r20971	r20972
10	10	#include "includes/nb1413m3.h"
11	11	#include "includes/nbmj8991.h"
12	12
13
14		static void nbmj8991_vramflip(running_machine &machine);
15		static void nbmj8991_gfxdraw(running_machine &machine);
16		static void update_pixel(running_machine &machine, int x, int y);
17
18
19	13	/******************************************************************************
20	14
21	15
r20971	r20972
89	83	case 0x04:  m_blitter_sizex = data; break;
90	84	case 0x05:  m_blitter_sizey = data;
91	85	/* writing here also starts the blit */
92		nbmj8991_gfxdraw(machine());
	86	nbmj8991_gfxdraw();
93	87	break;
94	88	case 0x06:  m_blitter_direction_x = (data & 0x01) ? 1 : 0;
95	89	m_blitter_direction_y = (data & 0x02) ? 1 : 0;
96	90	m_flipscreen = (data & 0x04) ? 0 : 1;
97	91	m_dispflag = (data & 0x10) ? 0 : 1;
98		nbmj8991_vramflip(machine());
	92	nbmj8991_vramflip();
99	93	break;
100	94	case 0x07:  break;
101	95	case 0x10:  m_blitter_destx = (m_blitter_destx & 0xff00) | data; break;
r20971	r20972
134	128
135	129
136	130	******************************************************************************/
137		static void nbmj8991_vramflip(running_machine &machine)
	131	void nbmj8991_state::nbmj8991_vramflip()
138	132	{
139		nbmj8991_state *state = machine.driver_data<nbmj8991_state>();
140	133	int x, y;
141	134	UINT8 color1, color2;
142		int width = machine.primary_screen->width();
143		int height = machine.primary_screen->height();
	135	int width = machine().primary_screen->width();
	136	int height = machine().primary_screen->height();
144	137
145		if (state->m_flipscreen == state->m_flipscreen_old) return;
	138	if (m_flipscreen == m_flipscreen_old) return;
146	139
147	140	for (y = 0; y < height / 2; y++)
148	141	{
149	142	for (x = 0; x < width / 2; x++)
150	143	{
151	144	// rotate 180 degrees (   0,   0) - ( 511, 511)
152		color1 = state->m_videoram[(y * width) + x];
153		color2 = state->m_videoram[(((height - 1) - y) * width) + (((width / 2) - 1) - x)];
154		state->m_videoram[(y * width) + x] = color2;
155		state->m_videoram[(((height - 1) - y) * width) + (((width / 2) - 1) - x)] = color1;
	145	color1 = m_videoram[(y * width) + x];
	146	color2 = m_videoram[(((height - 1) - y) * width) + (((width / 2) - 1) - x)];
	147	m_videoram[(y * width) + x] = color2;
	148	m_videoram[(((height - 1) - y) * width) + (((width / 2) - 1) - x)] = color1;
156	149	// rotate 180 degrees ( 512,   0) - (1023, 511)
157		color1 = state->m_videoram[(y * width) + (x + (width / 2))];
158		color2 = state->m_videoram[(((height - 1) - y) * width) + ((((width / 2) - 1) - x) + (width / 2))];
159		state->m_videoram[(y * width) + (x + (width / 2))] = color2;
160		state->m_videoram[(((height - 1) - y) * width) + ((((width / 2) - 1) - x) + (width / 2))] = color1;
	150	color1 = m_videoram[(y * width) + (x + (width / 2))];
	151	color2 = m_videoram[(((height - 1) - y) * width) + ((((width / 2) - 1) - x) + (width / 2))];
	152	m_videoram[(y * width) + (x + (width / 2))] = color2;
	153	m_videoram[(((height - 1) - y) * width) + ((((width / 2) - 1) - x) + (width / 2))] = color1;
161	154	}
162	155	}
163	156
164		state->m_flipscreen_old = state->m_flipscreen;
165		state->m_screen_refresh = 1;
	157	m_flipscreen_old = m_flipscreen;
	158	m_screen_refresh = 1;
166	159	}
167	160
168		static void update_pixel(running_machine &machine, int x, int y)
	161	void nbmj8991_state::update_pixel(int x, int y)
169	162	{
170		nbmj8991_state *state = machine.driver_data<nbmj8991_state>();
171		UINT8 color = state->m_videoram[(y * machine.primary_screen->width()) + x];
172		state->m_tmpbitmap.pix16(y, x) = color;
	163	UINT8 color = m_videoram[(y * machine().primary_screen->width()) + x];
	164	m_tmpbitmap.pix16(y, x) = color;
173	165	}
174	166
175	167	TIMER_CALLBACK_MEMBER(nbmj8991_state::blitter_timer_callback)
r20971	r20972
177	169	nb1413m3_busyflag = 1;
178	170	}
179	171
180		static void nbmj8991_gfxdraw(running_machine &machine)
	172	void nbmj8991_state::nbmj8991_gfxdraw()
181	173	{
182		nbmj8991_state *state = machine.driver_data<nbmj8991_state>();
183		UINT8 *GFX = state->memregion("gfx1")->base();
184		int width = machine.primary_screen->width();
	174	UINT8 *GFX = memregion("gfx1")->base();
	175	int width = machine().primary_screen->width();
185	176
186	177	int x, y;
187	178	int dx1, dx2, dy;
r20971	r20972
194	185
195	186	nb1413m3_busyctr = 0;
196	187
197		if (state->m_blitter_direction_x)
	188	if (m_blitter_direction_x)
198	189	{
199		startx = state->m_blitter_destx;
200		sizex = state->m_blitter_sizex ^ 0xff;
	190	startx = m_blitter_destx;
	191	sizex = m_blitter_sizex ^ 0xff;
201	192	skipx = 1;
202	193	}
203	194	else
204	195	{
205		startx = state->m_blitter_destx + state->m_blitter_sizex;
206		sizex = state->m_blitter_sizex;
	196	startx = m_blitter_destx + m_blitter_sizex;
	197	sizex = m_blitter_sizex;
207	198	skipx = -1;
208	199	}
209	200
210		if (state->m_blitter_direction_y)
	201	if (m_blitter_direction_y)
211	202	{
212		starty = state->m_blitter_desty;
213		sizey = state->m_blitter_sizey ^ 0xff;
	203	starty = m_blitter_desty;
	204	sizey = m_blitter_sizey ^ 0xff;
214	205	skipy = 1;
215	206	}
216	207	else
217	208	{
218		starty = state->m_blitter_desty + state->m_blitter_sizey;
219		sizey = state->m_blitter_sizey;
	209	starty = m_blitter_desty + m_blitter_sizey;
	210	sizey = m_blitter_sizey;
220	211	skipy = -1;
221	212	}
222	213
223		gfxlen = machine.root_device().memregion("gfx1")->bytes();
224		gfxaddr = (state->m_gfxrom << 17) + (state->m_blitter_src_addr << 1);
	214	gfxlen = machine().root_device().memregion("gfx1")->bytes();
	215	gfxaddr = (m_gfxrom << 17) + (m_blitter_src_addr << 1);
225	216
226	217	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
227	218	{
r20971	r20972
241	232	dx2 = (2 * x + 1) & 0x3ff;
242	233	dy = y & 0x1ff;
243	234
244		if (!state->m_flipscreen)
	235	if (!m_flipscreen)
245	236	{
246	237	dx1 ^= 0x1ff;
247	238	dx2 ^= 0x1ff;
248	239	dy ^= 0x1ff;
249	240	}
250	241
251		if (state->m_blitter_direction_x)
	242	if (m_blitter_direction_x)
252	243	{
253	244	// flip
254	245	color1 = (color & 0x0f) >> 0;
r20971	r20972
261	252	color2 = (color & 0x0f) >> 0;
262	253	}
263	254
264		color1 = state->m_clut[((state->m_clutsel & 0x7f) * 0x10) + color1];
265		color2 = state->m_clut[((state->m_clutsel & 0x7f) * 0x10) + color2];
	255	color1 = m_clut[((m_clutsel & 0x7f) * 0x10) + color1];
	256	color2 = m_clut[((m_clutsel & 0x7f) * 0x10) + color2];
266	257
267	258	if (color1 != 0xff)
268	259	{
269		state->m_videoram[(dy * width) + dx1] = color1;
270		update_pixel(machine, dx1, dy);
	260	m_videoram[(dy * width) + dx1] = color1;
	261	update_pixel(dx1, dy);
271	262	}
272	263	if (color2 != 0xff)
273	264	{
274		state->m_videoram[(dy * width) + dx2] = color2;
275		update_pixel(machine, dx2, dy);
	265	m_videoram[(dy * width) + dx2] = color2;
	266	update_pixel(dx2, dy);
276	267	}
277	268
278	269	nb1413m3_busyctr++;
r20971	r20972
280	271	}
281	272
282	273	nb1413m3_busyflag = 0;
283		machine.scheduler().timer_set(attotime::from_nsec(1650) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8991_state::blitter_timer_callback),state));
	274	machine().scheduler().timer_set(attotime::from_nsec(1650) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8991_state::blitter_timer_callback),this));
284	275	}
285	276
286	277	/******************************************************************************
r20971	r20972
311	302
312	303	for (y = 0; y < height; y++)
313	304	for (x = 0; x < width; x++)
314		update_pixel(machine(), x, y);
	305	update_pixel(x, y);
315	306	}
316	307
317	308	if (m_dispflag)
r20971	r20972
350	341
351	342	for (y = 0; y < height; y++)
352	343	for (x = 0; x < width; x++)
353		update_pixel(machine(), x, y);
	344	update_pixel(x, y);
354	345	}
355	346
356	347	if (nb1413m3_inputport & 0x20)

trunk/src/mame/video/nbmj8900.c

r20971	r20972
11	11	#include "includes/nbmj8900.h"
12	12
13	13
14		static void nbmj8900_vramflip(running_machine &machine, int vram);
15		static void nbmj8900_gfxdraw(running_machine &machine);
16
17
18	14	/******************************************************************************
19	15
20	16
r20971	r20972
117	113	case 0x04:  m_blitter_sizex = data; break;
118	114	case 0x05:  m_blitter_sizey = data;
119	115	/* writing here also starts the blit */
120		nbmj8900_gfxdraw(machine());
	116	nbmj8900_gfxdraw();
121	117	break;
122	118	case 0x06:  m_blitter_direction_x = (data & 0x01) ? 1 : 0;
123	119	m_blitter_direction_y = (data & 0x02) ? 1 : 0;
124	120	m_flipscreen = (data & 0x04) ? 1 : 0;
125	121	m_dispflag = (data & 0x08) ? 0 : 1;
126		if (m_gfxdraw_mode) nbmj8900_vramflip(machine(), 1);
127		nbmj8900_vramflip(machine(), 0);
	122	if (m_gfxdraw_mode) nbmj8900_vramflip(1);
	123	nbmj8900_vramflip(0);
128	124	break;
129	125	case 0x07:  break;
130	126	}
r20971	r20972
160	156
161	157
162	158	******************************************************************************/
163		void nbmj8900_vramflip(running_machine &machine, int vram)
	159	void nbmj8900_state::nbmj8900_vramflip(int vram)
164	160	{
165		nbmj8900_state *state = machine.driver_data<nbmj8900_state>();
166	161	int x, y;
167	162	unsigned char color1, color2;
168	163	unsigned char *vidram;
169		int width = machine.primary_screen->width();
170		int height = machine.primary_screen->height();
	164	int width = machine().primary_screen->width();
	165	int height = machine().primary_screen->height();
171	166
172		if (state->m_flipscreen == state->m_flipscreen_old) return;
	167	if (m_flipscreen == m_flipscreen_old) return;
173	168
174		vidram = vram ? state->m_videoram1 : state->m_videoram0;
	169	vidram = vram ? m_videoram1 : m_videoram0;
175	170
176	171	for (y = 0; y < (height / 2); y++)
177	172	{
r20971	r20972
184	179	}
185	180	}
186	181
187		state->m_flipscreen_old = state->m_flipscreen;
188		state->m_screen_refresh = 1;
	182	m_flipscreen_old = m_flipscreen;
	183	m_screen_refresh = 1;
189	184	}
190	185
191	186
192		static void update_pixel0(running_machine &machine, int x, int y)
	187	void nbmj8900_state::update_pixel0(int x, int y)
193	188	{
194		nbmj8900_state *state = machine.driver_data<nbmj8900_state>();
195		UINT8 color = state->m_videoram0[(y * state->m_screen_width) + x];
196		state->m_tmpbitmap0.pix16(y, x) = machine.pens[color];
	189	UINT8 color = m_videoram0[(y * m_screen_width) + x];
	190	m_tmpbitmap0.pix16(y, x) = machine().pens[color];
197	191	}
198	192
199		static void update_pixel1(running_machine &machine, int x, int y)
	193	void nbmj8900_state::update_pixel1(int x, int y)
200	194	{
201		nbmj8900_state *state = machine.driver_data<nbmj8900_state>();
202		UINT8 color = state->m_videoram1[(y * state->m_screen_width) + x];
203		state->m_tmpbitmap1.pix16(y, x) = machine.pens[color];
	195	UINT8 color = m_videoram1[(y * m_screen_width) + x];
	196	m_tmpbitmap1.pix16(y, x) = machine().pens[color];
204	197	}
205	198
206	199	TIMER_CALLBACK_MEMBER(nbmj8900_state::blitter_timer_callback)
r20971	r20972
208	201	nb1413m3_busyflag = 1;
209	202	}
210	203
211		static void nbmj8900_gfxdraw(running_machine &machine)
	204	void nbmj8900_state::nbmj8900_gfxdraw()
212	205	{
213		nbmj8900_state *state = machine.driver_data<nbmj8900_state>();
214		unsigned char *GFX = state->memregion("gfx")->base();
	206	unsigned char *GFX = memregion("gfx")->base();
215	207
216	208	int x, y;
217	209	int dx1, dx2, dy1, dy2;
r20971	r20972
224	216
225	217	nb1413m3_busyctr = 0;
226	218
227		startx = state->m_blitter_destx + state->m_blitter_sizex;
228		starty = state->m_blitter_desty + state->m_blitter_sizey;
	219	startx = m_blitter_destx + m_blitter_sizex;
	220	starty = m_blitter_desty + m_blitter_sizey;
229	221
230		if (state->m_blitter_direction_x)
	222	if (m_blitter_direction_x)
231	223	{
232		sizex = state->m_blitter_sizex ^ 0xff;
	224	sizex = m_blitter_sizex ^ 0xff;
233	225	skipx = 1;
234	226	}
235	227	else
236	228	{
237		sizex = state->m_blitter_sizex;
	229	sizex = m_blitter_sizex;
238	230	skipx = -1;
239	231	}
240	232
241		if (state->m_blitter_direction_y)
	233	if (m_blitter_direction_y)
242	234	{
243		sizey = state->m_blitter_sizey ^ 0xff;
	235	sizey = m_blitter_sizey ^ 0xff;
244	236	skipy = 1;
245	237	}
246	238	else
247	239	{
248		sizey = state->m_blitter_sizey;
	240	sizey = m_blitter_sizey;
249	241	skipy = -1;
250	242	}
251	243
252		gfxaddr = (state->m_gfxrom << 17) + (state->m_blitter_src_addr << 1);
	244	gfxaddr = (m_gfxrom << 17) + (m_blitter_src_addr << 1);
253	245
254	246	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
255	247	{
256	248	for (x = startx, ctrx = sizex; ctrx >= 0; x += skipx, ctrx--)
257	249	{
258		if ((gfxaddr > (machine.root_device().memregion("gfx")->bytes() - 1)))
	250	if ((gfxaddr > (machine().root_device().memregion("gfx")->bytes() - 1)))
259	251	{
260	252	#ifdef MAME_DEBUG
261	253	popmessage("GFXROM ADDRESS OVER!!");
262	254	#endif
263		gfxaddr &= (machine.root_device().memregion("gfx")->bytes() - 1);
	255	gfxaddr &= (machine().root_device().memregion("gfx")->bytes() - 1);
264	256	}
265	257
266	258	color = GFX[gfxaddr++];
r20971	r20972
274	266	dx1 = (2 * x + 0) & 0x1ff;
275	267	dx2 = (2 * x + 1) & 0x1ff;
276	268
277		if (state->m_gfxdraw_mode)
	269	if (m_gfxdraw_mode)
278	270	{
279	271	// 2 layer type
280	272	dy1 = y & 0xff;
281		dy2 = (y + state->m_scrolly) & 0xff;
	273	dy2 = (y + m_scrolly) & 0xff;
282	274	}
283	275	else
284	276	{
285	277	// 1 layer type
286		dy1 = (y + state->m_scrolly) & 0xff;
	278	dy1 = (y + m_scrolly) & 0xff;
287	279	dy2 = 0;
288	280	}
289	281
290		if (!state->m_flipscreen)
	282	if (!m_flipscreen)
291	283	{
292	284	dx1 ^= 0x1ff;
293	285	dx2 ^= 0x1ff;
r20971	r20972
295	287	dy2 ^= 0xff;
296	288	}
297	289
298		if (state->m_blitter_direction_x)
	290	if (m_blitter_direction_x)
299	291	{
300	292	// flip
301	293	color1 = (color & 0x0f) >> 0;
r20971	r20972
308	300	color2 = (color & 0x0f) >> 0;
309	301	}
310	302
311		color1 = state->m_clut[((state->m_clutsel & 0x7f) << 4) + color1];
312		color2 = state->m_clut[((state->m_clutsel & 0x7f) << 4) + color2];
	303	color1 = m_clut[((m_clutsel & 0x7f) << 4) + color1];
	304	color2 = m_clut[((m_clutsel & 0x7f) << 4) + color2];
313	305
314		if ((!state->m_gfxdraw_mode) || (state->m_vram & 0x01))
	306	if ((!m_gfxdraw_mode) || (m_vram & 0x01))
315	307	{
316	308	// layer 1
317	309	if (color1 != 0xff)
318	310	{
319		state->m_videoram0[(dy1 * state->m_screen_width) + dx1] = color1;
320		update_pixel0(machine, dx1, dy1);
	311	m_videoram0[(dy1 * m_screen_width) + dx1] = color1;
	312	update_pixel0(dx1, dy1);
321	313	}
322	314	if (color2 != 0xff)
323	315	{
324		state->m_videoram0[(dy1 * state->m_screen_width) + dx2] = color2;
325		update_pixel0(machine, dx2, dy1);
	316	m_videoram0[(dy1 * m_screen_width) + dx2] = color2;
	317	update_pixel0(dx2, dy1);
326	318	}
327	319	}
328		if (state->m_gfxdraw_mode && (state->m_vram & 0x02))
	320	if (m_gfxdraw_mode && (m_vram & 0x02))
329	321	{
330	322	// layer 2
331		if (state->m_vram & 0x08)
	323	if (m_vram & 0x08)
332	324	{
333	325	// transparent enable
334	326	if (color1 != 0xff)
335	327	{
336		state->m_videoram1[(dy2 * state->m_screen_width) + dx1] = color1;
337		update_pixel1(machine, dx1, dy2);
	328	m_videoram1[(dy2 * m_screen_width) + dx1] = color1;
	329	update_pixel1(dx1, dy2);
338	330	}
339	331	if (color2 != 0xff)
340	332	{
341		state->m_videoram1[(dy2 * state->m_screen_width) + dx2] = color2;
342		update_pixel1(machine, dx2, dy2);
	333	m_videoram1[(dy2 * m_screen_width) + dx2] = color2;
	334	update_pixel1(dx2, dy2);
343	335	}
344	336	}
345	337	else
346	338	{
347	339	// transparent disable
348		state->m_videoram1[(dy2 * state->m_screen_width) + dx1] = color1;
349		update_pixel1(machine, dx1, dy2);
350		state->m_videoram1[(dy2 * state->m_screen_width) + dx2] = color2;
351		update_pixel1(machine, dx2, dy2);
	340	m_videoram1[(dy2 * m_screen_width) + dx1] = color1;
	341	update_pixel1(dx1, dy2);
	342	m_videoram1[(dy2 * m_screen_width) + dx2] = color2;
	343	update_pixel1(dx2, dy2);
352	344	}
353	345	}
354	346
r20971	r20972
357	349	}
358	350
359	351	nb1413m3_busyflag = 0;
360		machine.scheduler().timer_set(attotime::from_nsec(2500) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8900_state::blitter_timer_callback),state));
	352	machine().scheduler().timer_set(attotime::from_nsec(2500) * nb1413m3_busyctr, timer_expired_delegate(FUNC(nbmj8900_state::blitter_timer_callback),this));
361	353	}
362	354
363	355	/******************************************************************************
r20971	r20972
396	388	{
397	389	for (x = 0; x < m_screen_width; x++)
398	390	{
399		update_pixel0(machine(), x, y);
	391	update_pixel0(x, y);
400	392	}
401	393	}
402	394	if (m_gfxdraw_mode)
r20971	r20972
405	397	{
406	398	for (x = 0; x < m_screen_width; x++)
407	399	{
408		update_pixel1(machine(), x, y);
	400	update_pixel1(x, y);
409	401	}
410	402	}
411	403	}

trunk/src/mame/video/nmk16.c

r20971	r20972
108	108
109	109	***************************************************************************/
110	110
111		static void nmk16_video_init(running_machine &machine)
	111	void nmk16_state::nmk16_video_init()
112	112	{
113		nmk16_state *state = machine.driver_data<nmk16_state>();
114		state->m_spriteram_old = auto_alloc_array_clear(machine, UINT16, 0x1000/2);
115		state->m_spriteram_old2 = auto_alloc_array_clear(machine, UINT16, 0x1000/2);
	113	m_spriteram_old = auto_alloc_array_clear(machine(), UINT16, 0x1000/2);
	114	m_spriteram_old2 = auto_alloc_array_clear(machine(), UINT16, 0x1000/2);
116	115
117		state->m_videoshift = 0;        /* 256x224 screen, no shift */
118		state->m_background_bitmap = NULL;
119		state->m_simple_scroll = 1;
	116	m_videoshift = 0;        /* 256x224 screen, no shift */
	117	m_background_bitmap = NULL;
	118	m_simple_scroll = 1;
120	119	}
121	120
122	121
r20971	r20972
128	127	m_bg_tilemap0->set_transparent_pen(15);
129	128	m_tx_tilemap->set_transparent_pen(15);
130	129
131		nmk16_video_init(machine());
	130	nmk16_video_init();
132	131	m_background_bitmap = auto_bitmap_ind16_alloc(machine(),8192,512);
133	132	m_bioship_background_bank=0;
134	133	m_redraw_bitmap = 1;
r20971	r20972
144	143	m_fg_tilemap->set_transparent_pen(15);
145	144	m_tx_tilemap->set_transparent_pen(15);
146	145
147		nmk16_video_init(machine());
	146	nmk16_video_init();
148	147	}
149	148
150	149	VIDEO_START_MEMBER(nmk16_state,macross)
r20971	r20972
154	153
155	154	m_tx_tilemap->set_transparent_pen(15);
156	155
157		nmk16_video_init(machine());
	156	nmk16_video_init();
158	157	}
159	158
160	159	VIDEO_START_MEMBER(nmk16_state,gunnail)
r20971	r20972
165	164	m_tx_tilemap->set_transparent_pen(15);
166	165	m_bg_tilemap0->set_scroll_rows(512);
167	166
168		nmk16_video_init(machine());
	167	nmk16_video_init();
169	168	m_videoshift = 64;  /* 384x224 screen, leftmost 64 pixels have to be retrieved */
170	169	/* from the other side of the tilemap (!) */
171	170	m_simple_scroll = 0;
r20971	r20972
182	181
183	182	m_tx_tilemap->set_transparent_pen(15);
184	183
185		nmk16_video_init(machine());
	184	nmk16_video_init();
186	185	m_videoshift = 64;  /* 384x224 screen, leftmost 64 pixels have to be retrieved */
187	186	/* from the other side of the tilemap (!) */
188	187	}
r20971	r20972
197	196	{
198	197	m_bg_tilemap0 = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(nmk16_state::bjtwin_get_bg_tile_info),this),TILEMAP_SCAN_COLS,8,8,64,32);
199	198
200		nmk16_video_init(machine());
	199	nmk16_video_init();
201	200	m_videoshift = 64;  /* 384x224 screen, leftmost 64 pixels have to be retrieved */
202	201	/* from the other side of the tilemap (!) */
203	202	}
r20971	r20972
389	388
390	389	// manybloc uses extra flip bits on the sprites, but these break other games
391	390
392		static inline void nmk16_draw_sprite(nmk16_state *state, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, UINT16 *spr)
	391	inline void nmk16_state::nmk16_draw_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, UINT16 *spr)
393	392	{
394	393	if ((spr[0] & 0x0001))
395	394	{
396		int sx    = (spr[4] & 0x1FF) + state->m_videoshift;
	395	int sx    = (spr[4] & 0x1FF) + m_videoshift;
397	396	int sy    =  spr[6] & 0x1FF;
398	397	int code  =  spr[3];
399	398	int color =  spr[7];
r20971	r20972
406	405	if(pri != priority)
407	406	return;
408	407
409		if (state->flip_screen())
	408	if (flip_screen())
410	409	{
411	410	sx = 368 - sx;
412	411	sy = 240 - sy;
r20971	r20972
420	419	xx = w;
421	420	do
422	421	{
423		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	422	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
424	423	code,
425	424	color,
426		state->flip_screen(), state->flip_screen(),
	425	flip_screen(), flip_screen(),
427	426	((x + 16) & 0x1FF) - 16,sy & 0x1FF,15);
428	427	code++;
429	428	x += delta;
r20971	r20972
434	433	}
435	434	}
436	435
437		static inline void nmk16_draw_sprite_flipsupported(nmk16_state *state, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, UINT16 *spr)
	436	inline void nmk16_state::nmk16_draw_sprite_flipsupported(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority, UINT16 *spr)
438	437	{
439	438	if ((spr[0] & 0x0001))
440	439	{
441		int sx    = (spr[4] & 0x1FF) + state->m_videoshift;
	440	int sx    = (spr[4] & 0x1FF) + m_videoshift;
442	441	int sy    =  spr[6] & 0x1FF;
443	442	int code  =  spr[3];
444	443	int color =  spr[7];
r20971	r20972
454	453	if(pri != priority)
455	454	return;
456	455
457		flipx ^= state->flip_screen();
458		flipy ^= state->flip_screen();
	456	flipx ^= flip_screen();
	457	flipy ^= flip_screen();
459	458
460		if (state->flip_screen())
	459	if (flip_screen())
461	460	{
462	461	sx = 368 - sx;
463	462	sy = 240 - sy;
r20971	r20972
472	471	xx = w;
473	472	do
474	473	{
475		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	474	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
476	475	code,
477	476	color,
478	477	flipx, flipy,
r20971	r20972
485	484	}
486	485	}
487	486
488		static void nmk16_draw_sprites_swap(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int *bittbl)
	487	void nmk16_state::nmk16_draw_sprites_swap(bitmap_ind16 &bitmap, const rectangle &cliprect, int *bittbl)
489	488	{
490		nmk16_state *state = machine.driver_data<nmk16_state>();
491	489	int i, prio;
492	490
493	491	// Priority level (4 levels, 0x100 sprites)
r20971	r20972
497	495	for ( i = 0; i < 0x100; i++ )
498	496	{
499	497	int spr = BITSWAP8(i, bittbl[0], bittbl[1], bittbl[2], bittbl[3], bittbl[4], bittbl[5], bittbl[6], bittbl[7]);
500		nmk16_draw_sprite(state, machine, bitmap, cliprect, prio, state->m_spriteram_old2 + (spr * 8));
	498	nmk16_draw_sprite(bitmap, cliprect, prio, m_spriteram_old2 + (spr * 8));
501	499	}
502	500	}
503	501	}
504	502
505		static void nmk16_draw_sprites_swap_flipsupported(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int *bittbl)
	503	void nmk16_state::nmk16_draw_sprites_swap_flipsupported(bitmap_ind16 &bitmap, const rectangle &cliprect, int *bittbl)
506	504	{
507		nmk16_state *state = machine.driver_data<nmk16_state>();
508	505	int i, prio;
509	506
510	507	// Priority level (4 levels, 0x100 sprites)
r20971	r20972
514	511	for ( i = 0; i < 0x100; i++ )
515	512	{
516	513	int spr = BITSWAP8(i, bittbl[0], bittbl[1], bittbl[2], bittbl[3], bittbl[4], bittbl[5], bittbl[6], bittbl[7]);
517		nmk16_draw_sprite_flipsupported(state, machine, bitmap, cliprect, prio, state->m_spriteram_old2 + (spr * 16/2));
	514	nmk16_draw_sprite_flipsupported(bitmap, cliprect, prio, m_spriteram_old2 + (spr * 16/2));
518	515	}
519	516	}
520	517	}
521	518
522		static void nmk16_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
	519	void nmk16_state::nmk16_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
523	520	{
524		nmk16_state *state = machine.driver_data<nmk16_state>();
525	521	int offs;
526	522
527	523	for (offs = 0;offs < 0x1000/2;offs += 8)
528	524	{
529		nmk16_draw_sprite(state, machine, bitmap, cliprect, priority, state->m_spriteram_old2 + offs);
	525	nmk16_draw_sprite(bitmap, cliprect, priority, m_spriteram_old2 + offs);
530	526	}
531	527	}
532	528
533		static void nmk16_draw_sprites_flipsupported(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
	529	void nmk16_state::nmk16_draw_sprites_flipsupported(bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
534	530	{
535		nmk16_state *state = machine.driver_data<nmk16_state>();
536	531	int offs;
537	532
538	533	for (offs = 0;offs < 0x1000/2;offs += 8)
539	534	{
540		if (state->m_spriteram_old2[offs] & 0x0001)
	535	if (m_spriteram_old2[offs] & 0x0001)
541	536	{
542		nmk16_draw_sprite_flipsupported(state, machine, bitmap, cliprect, priority, state->m_spriteram_old2 + offs);
	537	nmk16_draw_sprite_flipsupported(bitmap, cliprect, priority, m_spriteram_old2 + offs);
543	538	}
544	539	}
545	540	}
r20971	r20972
552	547
553	548	***************************************************************************/
554	549
555		int nmk16_bg_spr_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
	550	int nmk16_state::nmk16_bg_spr_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
556	551	{
557		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
558		state->m_bg_tilemap0->set_scrollx(0,-state->m_videoshift);
	552	m_bg_tilemap0->set_scrollx(0,-m_videoshift);
559	553
560		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	554	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
561	555
562		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,3);
563		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,2);
564		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,1);
565		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,0);
	556	nmk16_draw_sprites(bitmap,cliprect,3);
	557	nmk16_draw_sprites(bitmap,cliprect,2);
	558	nmk16_draw_sprites(bitmap,cliprect,1);
	559	nmk16_draw_sprites(bitmap,cliprect,0);
566	560	return 0;
567	561	}
568	562
569		int nmk16_bg_fg_spr_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
	563	int nmk16_state::nmk16_bg_fg_spr_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
570	564	{
571		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
572		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	565	m_tx_tilemap->set_scrollx(0,-m_videoshift);
573	566
574		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
575		state->m_fg_tilemap->draw(bitmap, cliprect, 0,0);
	567	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	568	m_fg_tilemap->draw(bitmap, cliprect, 0,0);
576	569
577		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,3);
578		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,2);
579		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,1);
580		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,0);
	570	nmk16_draw_sprites(bitmap,cliprect,3);
	571	nmk16_draw_sprites(bitmap,cliprect,2);
	572	nmk16_draw_sprites(bitmap,cliprect,1);
	573	nmk16_draw_sprites(bitmap,cliprect,0);
581	574
582		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	575	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
583	576	return 0;
584	577	}
585	578
586		int nmk16_bg_spr_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
	579	int nmk16_state::nmk16_bg_spr_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
587	580	{
588		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
589		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	581	m_tx_tilemap->set_scrollx(0,-m_videoshift);
590	582
591		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	583	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
592	584
593		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,3);
594		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,2);
595		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,1);
596		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,0);
	585	nmk16_draw_sprites(bitmap,cliprect,3);
	586	nmk16_draw_sprites(bitmap,cliprect,2);
	587	nmk16_draw_sprites(bitmap,cliprect,1);
	588	nmk16_draw_sprites(bitmap,cliprect,0);
597	589
598		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	590	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
599	591	return 0;
600	592	}
601	593
602		int nmk16_bg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
	594	int nmk16_state::nmk16_bg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
603	595	{
604		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
605		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	596	m_tx_tilemap->set_scrollx(0,-m_videoshift);
606	597
607		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	598	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
608	599
609		nmk16_draw_sprites_flipsupported(screen.machine(), bitmap,cliprect,3);
610		nmk16_draw_sprites_flipsupported(screen.machine(), bitmap,cliprect,2);
611		nmk16_draw_sprites_flipsupported(screen.machine(), bitmap,cliprect,1);
612		nmk16_draw_sprites_flipsupported(screen.machine(), bitmap,cliprect,0);
	600	nmk16_draw_sprites_flipsupported(bitmap,cliprect,3);
	601	nmk16_draw_sprites_flipsupported(bitmap,cliprect,2);
	602	nmk16_draw_sprites_flipsupported(bitmap,cliprect,1);
	603	nmk16_draw_sprites_flipsupported(bitmap,cliprect,0);
613	604
614		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	605	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
615	606	return 0;
616	607	}
617	608
618		int nmk16_bioshipbg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
	609	int nmk16_state::nmk16_bioshipbg_sprflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
619	610	{
620		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
621		UINT16 *tilerom = (UINT16 *)state->memregion("gfx5")->base();
622		int scrollx=-(state->m_bioship_scroll[1] + state->m_bioship_scroll[0]*256);
623		int scrolly=-(state->m_bioship_scroll[3] + state->m_bioship_scroll[2]*256);
	611	UINT16 *tilerom = (UINT16 *)memregion("gfx5")->base();
	612	int scrollx=-(m_bioship_scroll[1] + m_bioship_scroll[0]*256);
	613	int scrolly=-(m_bioship_scroll[3] + m_bioship_scroll[2]*256);
624	614
625		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	615	m_tx_tilemap->set_scrollx(0,-m_videoshift);
626	616
627		if (state->m_redraw_bitmap)
	617	if (m_redraw_bitmap)
628	618	{
629		int bank = state->m_bioship_background_bank * 0x2000;
	619	int bank = m_bioship_background_bank * 0x2000;
630	620	int sx=0, sy=0, offs;
631		state->m_redraw_bitmap=0;
	621	m_redraw_bitmap=0;
632	622
633	623	/* Draw background from tile rom */
634	624	for (offs = 0;offs <0x1000;offs++) {
r20971	r20972
636	626	int numtile = data&0xfff;
637	627	int color = (data&0xf000)>>12;
638	628
639		drawgfx_opaque(*state->m_background_bitmap,state->m_background_bitmap->cliprect(),screen.machine().gfx[3],
	629	drawgfx_opaque(*m_background_bitmap,m_background_bitmap->cliprect(),screen.machine().gfx[3],
640	630	numtile,
641	631	color,
642	632	0,0,   /* no flip */
r20971	r20972
645	635	data = tilerom[offs+0x1000+bank];
646	636	numtile = data&0xfff;
647	637	color = (data&0xf000)>>12;
648		drawgfx_opaque(*state->m_background_bitmap,state->m_background_bitmap->cliprect(),screen.machine().gfx[3],
	638	drawgfx_opaque(*m_background_bitmap,m_background_bitmap->cliprect(),screen.machine().gfx[3],
649	639	numtile,
650	640	color,
651	641	0,0,   /* no flip */
r20971	r20972
656	646	}
657	647	}
658	648
659		copyscrollbitmap(bitmap,*state->m_background_bitmap,1,&scrollx,1,&scrolly,cliprect);
660		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	649	copyscrollbitmap(bitmap,*m_background_bitmap,1,&scrollx,1,&scrolly,cliprect);
	650	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
661	651
662		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,3);
663		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,2);
664		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,1);
665		nmk16_draw_sprites(screen.machine(), bitmap,cliprect,0);
	652	nmk16_draw_sprites(bitmap,cliprect,3);
	653	nmk16_draw_sprites(bitmap,cliprect,2);
	654	nmk16_draw_sprites(bitmap,cliprect,1);
	655	nmk16_draw_sprites(bitmap,cliprect,0);
666	656
667		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	657	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
668	658	return 0;
669	659	}
670	660
671		int nmk16_bg_sprswap_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8])
	661	int nmk16_state::nmk16_bg_sprswap_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8])
672	662	{
673		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
674		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	663	m_tx_tilemap->set_scrollx(0,-m_videoshift);
675	664
676		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	665	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
677	666
678		nmk16_draw_sprites_swap(screen.machine(), bitmap,cliprect, bittbl);
	667	nmk16_draw_sprites_swap(bitmap,cliprect, bittbl);
679	668
680		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	669	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
681	670	return 0;
682	671	}
683	672
684		int nmk16_bg_sprswapflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8])
	673	int nmk16_state::nmk16_bg_sprswapflip_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8])
685	674	{
686		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
687		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	675	m_tx_tilemap->set_scrollx(0,-m_videoshift);
688	676
689		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	677	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
690	678
691		nmk16_draw_sprites_swap_flipsupported(screen.machine(), bitmap,cliprect, bittbl);
	679	nmk16_draw_sprites_swap_flipsupported(bitmap,cliprect, bittbl);
692	680
693		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	681	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
694	682	return 0;
695	683	}
696	684
697		int nmk16_complexbg_sprswap_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8])
	685	int nmk16_state::nmk16_complexbg_sprswap_tx_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int bittbl[8])
698	686	{
699		nmk16_state *state = screen.machine().driver_data<nmk16_state>();
700		state->m_tx_tilemap->set_scrollx(0,-state->m_videoshift);
	687	m_tx_tilemap->set_scrollx(0,-m_videoshift);
701	688
702	689	// the hardware supports per-scanline X *and* Y scroll which isn't
703	690	// supported by tilemaps so we have to draw the tilemap one line at a time
704		if (!state->m_simple_scroll)
	691	if (!m_simple_scroll)
705	692	{
706	693	int i=16;
707	694	int y1;
r20971	r20972
709	696	y1 = cliprect.min_y;
710	697	while (y1 <= cliprect.max_y)
711	698	{
712		int const yscroll = state->m_gunnail_scrollramy[0] + state->m_gunnail_scrollramy[y1];
	699	int const yscroll = m_gunnail_scrollramy[0] + m_gunnail_scrollramy[y1];
713	700	int tilemap_bank_select;
714		tilemap_t* bg_tilemap = state->m_bg_tilemap0;
	701	tilemap_t* bg_tilemap = m_bg_tilemap0;
715	702
716	703	bgclip.min_y = y1;
717	704	bgclip.max_y = y1;
718	705
719	706
720		tilemap_bank_select = (state->m_gunnail_scrollram[0]&0x3000)>>12;
	707	tilemap_bank_select = (m_gunnail_scrollram[0]&0x3000)>>12;
721	708	switch (tilemap_bank_select)
722	709	{
723		case 0: if (state->m_bg_tilemap0) bg_tilemap = state->m_bg_tilemap0; break;
724		case 1: if (state->m_bg_tilemap1) bg_tilemap = state->m_bg_tilemap1; break;
725		case 2: if (state->m_bg_tilemap2) bg_tilemap = state->m_bg_tilemap2; break;
726		case 3: if (state->m_bg_tilemap3) bg_tilemap = state->m_bg_tilemap3; break;
	710	case 0: if (m_bg_tilemap0) bg_tilemap = m_bg_tilemap0; break;
	711	case 1: if (m_bg_tilemap1) bg_tilemap = m_bg_tilemap1; break;
	712	case 2: if (m_bg_tilemap2) bg_tilemap = m_bg_tilemap2; break;
	713	case 3: if (m_bg_tilemap3) bg_tilemap = m_bg_tilemap3; break;
727	714	}
728	715
729	716	bg_tilemap->set_scroll_rows(512);
730	717
731	718	bg_tilemap->set_scrolly(0, yscroll);
732		bg_tilemap->set_scrollx((i + yscroll) & 0x1ff, state->m_gunnail_scrollram[0] + state->m_gunnail_scrollram[i] - state->m_videoshift);
	719	bg_tilemap->set_scrollx((i + yscroll) & 0x1ff, m_gunnail_scrollram[0] + m_gunnail_scrollram[i] - m_videoshift);
733	720
734	721	bg_tilemap->draw(bitmap, bgclip, 0,0);
735	722
r20971	r20972
739	726	}
740	727	else
741	728	{
742		UINT16 yscroll = ((state->m_gunnail_scrollram[2]&0xff)<<8) | ((state->m_gunnail_scrollram[3]&0xff)<<0);
743		UINT16 xscroll = ((state->m_gunnail_scrollram[0]&0xff)<<8) | ((state->m_gunnail_scrollram[1]&0xff)<<0);
	729	UINT16 yscroll = ((m_gunnail_scrollram[2]&0xff)<<8) | ((m_gunnail_scrollram[3]&0xff)<<0);
	730	UINT16 xscroll = ((m_gunnail_scrollram[0]&0xff)<<8) | ((m_gunnail_scrollram[1]&0xff)<<0);
744	731	int tilemap_bank_select;
745		tilemap_t* bg_tilemap = state->m_bg_tilemap0;
	732	tilemap_t* bg_tilemap = m_bg_tilemap0;
746	733
747	734	//popmessage( "scroll %04x, %04x", yscroll,xscroll);
748	735
749	736	tilemap_bank_select = (xscroll&0x3000)>>12;
750	737	switch (tilemap_bank_select)
751	738	{
752		case 0: if (state->m_bg_tilemap0) bg_tilemap = state->m_bg_tilemap0; break;
753		case 1: if (state->m_bg_tilemap1) bg_tilemap = state->m_bg_tilemap1; break;
754		case 2: if (state->m_bg_tilemap2) bg_tilemap = state->m_bg_tilemap2; break;
755		case 3: if (state->m_bg_tilemap3) bg_tilemap = state->m_bg_tilemap3; break;
	739	case 0: if (m_bg_tilemap0) bg_tilemap = m_bg_tilemap0; break;
	740	case 1: if (m_bg_tilemap1) bg_tilemap = m_bg_tilemap1; break;
	741	case 2: if (m_bg_tilemap2) bg_tilemap = m_bg_tilemap2; break;
	742	case 3: if (m_bg_tilemap3) bg_tilemap = m_bg_tilemap3; break;
756	743	}
757	744
758	745	bg_tilemap->set_scroll_rows(1);
759	746
760	747	bg_tilemap->set_scrolly(0, yscroll);
761		bg_tilemap->set_scrollx(0, xscroll - state->m_videoshift);
	748	bg_tilemap->set_scrollx(0, xscroll - m_videoshift);
762	749
763	750	bg_tilemap->draw(bitmap, cliprect, 0,0);
764	751	}
765	752
766		nmk16_draw_sprites_swap(screen.machine(), bitmap,cliprect, bittbl);
	753	nmk16_draw_sprites_swap(bitmap,cliprect, bittbl);
767	754
768		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	755	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
769	756	return 0;
770	757	}
771	758
r20971	r20972
934	921
935	922	***************************************************************************/
936	923
937		static void video_update(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect,
	924	void nmk16_state::video_update(bitmap_ind16 &bitmap, const rectangle &cliprect,
938	925	int dsw_flipscreen,         // 1 = Horizontal and vertical screen flip are hardwired to 2 dip switches
939	926	int xoffset, int yoffset,   // bg_tilemap0 offsets
940	927	int attr_mask               // "sprite active" mask
941	928	)
942	929	{
943		nmk16_state *state = machine.driver_data<nmk16_state>();
944
945
946
947	930	if (dsw_flipscreen)
948	931	{
949		state->flip_screen_x_set(~state->ioport("DSW1")->read() & 0x0100);
950		state->flip_screen_y_set(~state->ioport("DSW1")->read() & 0x0200);
	932	flip_screen_x_set(~ioport("DSW1")->read() & 0x0100);
	933	flip_screen_y_set(~ioport("DSW1")->read() & 0x0200);
951	934	}
952	935
953	936
954		state->m_bg_tilemap0->set_scrollx(0, state->m_afega_scroll_0[1] + xoffset);
955		state->m_bg_tilemap0->set_scrolly(0, state->m_afega_scroll_0[0] + yoffset);
	937	m_bg_tilemap0->set_scrollx(0, m_afega_scroll_0[1] + xoffset);
	938	m_bg_tilemap0->set_scrolly(0, m_afega_scroll_0[0] + yoffset);
956	939
957		state->m_tx_tilemap->set_scrollx(0, state->m_afega_scroll_1[1]);
958		state->m_tx_tilemap->set_scrolly(0, state->m_afega_scroll_1[0]);
	940	m_tx_tilemap->set_scrollx(0, m_afega_scroll_1[1]);
	941	m_tx_tilemap->set_scrolly(0, m_afega_scroll_1[0]);
959	942
960	943
961		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
	944	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
962	945
963		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,3);
964		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,2);
965		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,1);
966		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,0);
	946	nmk16_draw_sprites_flipsupported(bitmap,cliprect,3);
	947	nmk16_draw_sprites_flipsupported(bitmap,cliprect,2);
	948	nmk16_draw_sprites_flipsupported(bitmap,cliprect,1);
	949	nmk16_draw_sprites_flipsupported(bitmap,cliprect,0);
967	950
968		state->m_tx_tilemap->draw(bitmap, cliprect, 0,0);
	951	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
969	952	}
970	953
971		static void redhawki_video_update(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	954	void nmk16_state::redhawki_video_update(bitmap_ind16 &bitmap, const rectangle &cliprect )
972	955	{
973		nmk16_state *state = machine.driver_data<nmk16_state>();
974	956
	957	m_bg_tilemap0->set_scrollx(0, m_afega_scroll_1[0]&0xff);
	958	m_bg_tilemap0->set_scrolly(0, m_afega_scroll_1[1]&0xff);
975	959
976		state->m_bg_tilemap0->set_scrollx(0, state->m_afega_scroll_1[0]&0xff);
977		state->m_bg_tilemap0->set_scrolly(0, state->m_afega_scroll_1[1]&0xff);
	960	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
978	961
979		state->m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
980
981		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,3);
982		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,2);
983		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,1);
984		nmk16_draw_sprites_flipsupported(machine, bitmap,cliprect,0);
	962	nmk16_draw_sprites_flipsupported(bitmap,cliprect,3);
	963	nmk16_draw_sprites_flipsupported(bitmap,cliprect,2);
	964	nmk16_draw_sprites_flipsupported(bitmap,cliprect,1);
	965	nmk16_draw_sprites_flipsupported(bitmap,cliprect,0);
985	966	}
986	967
987		UINT32 nmk16_state::screen_update_afega(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){    video_update(machine(),bitmap,cliprect, 1, -0x100,+0x000, 0x0001);  return 0; }
988		UINT32 nmk16_state::screen_update_bubl2000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ video_update(machine(),bitmap,cliprect, 0, -0x100,+0x000, 0x0001);  return 0; } // no flipscreen support, I really would confirmation from the schematics
989		UINT32 nmk16_state::screen_update_redhawkb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ video_update(machine(),bitmap,cliprect, 0, +0x000,+0x100, 0x0001);  return 0; }
990		UINT32 nmk16_state::screen_update_redhawki(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ redhawki_video_update(machine(),bitmap,cliprect); return 0;} // strange scroll regs
	968	UINT32 nmk16_state::screen_update_afega(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)   { video_update(bitmap,cliprect, 1, -0x100,+0x000, 0x0001);  return 0; }
	969	UINT32 nmk16_state::screen_update_bubl2000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ video_update(bitmap,cliprect, 0, -0x100,+0x000, 0x0001);  return 0; } // no flipscreen support, I really would confirmation from the schematics
	970	UINT32 nmk16_state::screen_update_redhawkb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ video_update(bitmap,cliprect, 0, +0x000,+0x100, 0x0001);  return 0; }
	971	UINT32 nmk16_state::screen_update_redhawki(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ redhawki_video_update(bitmap,cliprect); return 0;} // strange scroll regs
991	972
992	973	UINT32 nmk16_state::screen_update_firehawk(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
993	974	{
r20971	r20972
996	977
997	978	m_bg_tilemap0->draw(bitmap, cliprect, 0,0);
998	979
999		nmk16_draw_sprites_flipsupported(machine(), bitmap,cliprect,3);
1000		nmk16_draw_sprites_flipsupported(machine(), bitmap,cliprect,2);
1001		nmk16_draw_sprites_flipsupported(machine(), bitmap,cliprect,1);
1002		nmk16_draw_sprites_flipsupported(machine(), bitmap,cliprect,0);
	980	nmk16_draw_sprites_flipsupported(bitmap,cliprect,3);
	981	nmk16_draw_sprites_flipsupported(bitmap,cliprect,2);
	982	nmk16_draw_sprites_flipsupported(bitmap,cliprect,1);
	983	nmk16_draw_sprites_flipsupported(bitmap,cliprect,0);
1003	984
1004	985	m_tx_tilemap->draw(bitmap, cliprect, 0,0);
1005	986	return 0;

trunk/src/mame/video/nitedrvr.c

r20971	r20972
35	35	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(nitedrvr_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
36	36	}
37	37
38		static void draw_box( bitmap_ind16 &bitmap, int bx, int by, int ex, int ey )
	38	void nitedrvr_state::draw_box( bitmap_ind16 &bitmap, int bx, int by, int ex, int ey )
39	39	{
40	40	int x, y;
41	41
r20971	r20972
49	49	return;
50	50	}
51	51
52		static void draw_roadway( running_machine &machine, bitmap_ind16 &bitmap )
	52	void nitedrvr_state::draw_roadway( bitmap_ind16 &bitmap )
53	53	{
54		nitedrvr_state *state = machine.driver_data<nitedrvr_state>();
55	54	int roadway;
56	55
57	56	for (roadway = 0; roadway < 16; roadway++)
58	57	{
59	58	int bx, by, ex, ey;
60	59
61		bx = state->m_hvc[roadway];
62		by = state->m_hvc[roadway + 16];
63		ex = bx + ((state->m_hvc[roadway + 32] & 0xf0) >> 4);
64		ey = by + (16 - (state->m_hvc[roadway + 32] & 0x0f));
	60	bx = m_hvc[roadway];
	61	by = m_hvc[roadway + 16];
	62	ex = bx + ((m_hvc[roadway + 32] & 0xf0) >> 4);
	63	ey = by + (16 - (m_hvc[roadway + 32] & 0x0f));
65	64
66	65	draw_box(bitmap, bx, by, ex, ey);
67	66	}
r20971	r20972
70	69	UINT32 nitedrvr_state::screen_update_nitedrvr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
71	70	{
72	71	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
73		draw_roadway(machine(), bitmap);
	72	draw_roadway(bitmap);
74	73	return 0;
75	74	}

trunk/src/mame/video/nycaptor.c

r20971	r20972
15	15	spot number isn't set to 0 in main menu ; lives - yes
16	16	sprites in main menu req priority 'type' 0
17	17	*/
18		static int nycaptor_spot( running_machine &machine )
	18	int nycaptor_state::nycaptor_spot(  )
19	19	{
20		nycaptor_state *state = machine.driver_data<nycaptor_state>();
21
22		if (state->m_gametype == 0 || state->m_gametype == 2)
23		return state->m_sharedram[0x299] ? state->m_sharedram[0x298] : 0;
	20	if (m_gametype == 0 || m_gametype == 2)
	21	return m_sharedram[0x299] ? m_sharedram[0x298] : 0;
24	22	else
25	23	return 0;
26	24
r20971	r20972
44	42
45	43	tileinfo.group = 0;
46	44
47		if ((!nycaptor_spot(machine())) && (pal == 6))
	45	if ((!nycaptor_spot()) && (pal == 6))
48	46	tileinfo.group = 1;
49	47
50		if (((nycaptor_spot(machine()) == 3) && (pal == 8)) || ((nycaptor_spot(machine()) == 1) && (pal == 0xc)))
	48	if (((nycaptor_spot() == 3) && (pal == 8)) || ((nycaptor_spot() == 1) && (pal == 0xc)))
51	49	tileinfo.group = 2;
52	50
53		if ((nycaptor_spot(machine()) == 1) && (tileinfo.category == 2))
	51	if ((nycaptor_spot() == 1) && (tileinfo.category == 2))
54	52	tileinfo.group = 3;
55	53
56	54	#if NYCAPTOR_DEBUG
57	55	if (m_mask & (1 << tileinfo.category))
58	56	{
59		if (nycaptor_spot(machine()))
	57	if (nycaptor_spot())
60	58	pal = 0xe;
61	59	else
62	60	pal = 4;
r20971	r20972
151	149	m_bg_tilemap->set_scrolly(offset, data);
152	150	}
153	151
154		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
	152	void nycaptor_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
155	153	{
156		nycaptor_state *state = machine.driver_data<nycaptor_state>();
157	154	int i;
158	155
159	156	for (i = 0; i < 0x20; i++)
160	157	{
161		int pr = state->m_spriteram[0x9f - i];
	158	int pr = m_spriteram[0x9f - i];
162	159	int offs = (pr & 0x1f) * 4;
163	160	int code, sx, sy, flipx, flipy, pal, priori;
164	161
165		code = state->m_spriteram[offs + 2] + ((state->m_spriteram[offs + 1] & 0x10) << 4);//1 bit wolny = 0x20
166		pal  = state->m_spriteram[offs + 1] & 0x0f;
167		sx   = state->m_spriteram[offs + 3];
168		sy   = 240 - state->m_spriteram[offs + 0];
	162	code = m_spriteram[offs + 2] + ((m_spriteram[offs + 1] & 0x10) << 4);//1 bit wolny = 0x20
	163	pal  = m_spriteram[offs + 1] & 0x0f;
	164	sx   = m_spriteram[offs + 3];
	165	sy   = 240 - m_spriteram[offs + 0];
169	166	priori = (pr & 0xe0) >> 5;
170	167
171	168	if (priori == pri)
172	169	{
173	170	#if NYCAPTOR_DEBUG
174		if (state->m_mask & (1 << (pri + 4))) pal = 0xd;
	171	if (m_mask & (1 << (pri + 4))) pal = 0xd;
175	172	#endif
176		flipx = BIT(state->m_spriteram[offs + 1], 6);
177		flipy = BIT(state->m_spriteram[offs + 1], 7);
	173	flipx = BIT(m_spriteram[offs + 1], 6);
	174	flipy = BIT(m_spriteram[offs + 1], 7);
178	175
179		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	176	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
180	177	code,
181	178	pal,
182	179	flipx,flipy,
183	180	sx,sy,15);
184	181
185		if (state->m_spriteram[offs + 3] > 240)
	182	if (m_spriteram[offs + 3] > 240)
186	183	{
187		sx = (state->m_spriteram[offs + 3] - 256);
188		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	184	sx = (m_spriteram[offs + 3] - 256);
	185	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
189	186	code,
190	187	pal,
191	188	flipx,flipy,
r20971	r20972
210	207
211	208	#define mKEY_MASK(x,y) if (machine.input().code_pressed_once(x)) { state->m_mask |= y; state->m_bg_tilemap->mark_all_dirty(); }
212	209
213		static void nycaptor_setmask( running_machine &machine )
	210	void nycaptor_state::nycaptor_setmask(  )
214	211	{
215		nycaptor_state *state = machine.driver_data<nycaptor_state>();
216
217	212	mKEY_MASK(KEYCODE_Q, 1); /* bg */
218	213	mKEY_MASK(KEYCODE_W, 2);
219	214	mKEY_MASK(KEYCODE_E, 4);
r20971	r20972
228	223	mKEY_MASK(KEYCODE_J, 0x400);
229	224	mKEY_MASK(KEYCODE_K, 0x800);
230	225
231		if (machine.input().code_pressed_once(KEYCODE_Z)){state->m_mask = 0; state->m_bg_tilemap->mark_all_dirty();} /* disable */
232		if (machine.input().code_pressed_once(KEYCODE_X)){state->m_mask |= 0x1000; state->m_bg_tilemap->mark_all_dirty();} /* no layers */
	226	if (machine().input().code_pressed_once(KEYCODE_Z)){m_mask = 0; m_bg_tilemap->mark_all_dirty();} /* disable */
	227	if (machine().input().code_pressed_once(KEYCODE_X)){m_mask |= 0x1000; m_bg_tilemap->mark_all_dirty();} /* no layers */
233	228	}
234	229	#endif
235	230
r20971	r20972
258	253	}
259	254	else
260	255	#endif
261		switch (nycaptor_spot(machine()) & 3)
	256	switch (nycaptor_spot() & 3)
262	257	{
263	258	case 0:
264	259	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 3, 0);
265		draw_sprites(machine(), bitmap, cliprect, 6);
	260	draw_sprites(bitmap, cliprect, 6);
266	261	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 3, 0);
267	262	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 2, 0);
268	263	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 2, 0);
269	264	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 1, 0);
270		draw_sprites(machine(), bitmap, cliprect, 3);
	265	draw_sprites(bitmap, cliprect, 3);
271	266	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 1, 0);
272		draw_sprites(machine(), bitmap, cliprect, 0);
273		draw_sprites(machine(), bitmap, cliprect, 2);
	267	draw_sprites(bitmap, cliprect, 0);
	268	draw_sprites(bitmap, cliprect, 2);
274	269	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 0, 0);
275		draw_sprites(machine(), bitmap, cliprect, 1);
	270	draw_sprites(bitmap, cliprect, 1);
276	271	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0, 0);
277	272	break;
278	273
279	274	case 1:
280	275	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 3, 0);
281		draw_sprites(machine(), bitmap, cliprect, 3);
	276	draw_sprites(bitmap, cliprect, 3);
282	277	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 3, 0);
283		draw_sprites(machine(), bitmap, cliprect, 2);
	278	draw_sprites(bitmap, cliprect, 2);
284	279	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 2, 0);
285	280	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 1, 0);
286		draw_sprites(machine(), bitmap, cliprect, 1);
	281	draw_sprites(bitmap, cliprect, 1);
287	282	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 1, 0);
288	283	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 2, 0);
289		draw_sprites(machine(), bitmap, cliprect, 0);
	284	draw_sprites(bitmap, cliprect, 0);
290	285	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 0, 0);
291	286	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0, 0);
292	287	break;
r20971	r20972
295	290	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 3, 0);
296	291	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 3, 0);
297	292	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 1, 0);
298		draw_sprites(machine(), bitmap, cliprect, 1);
	293	draw_sprites(bitmap, cliprect, 1);
299	294	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 1, 0);
300	295	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 2, 0);
301	296	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 2, 0);
302		draw_sprites(machine(), bitmap, cliprect, 0);
	297	draw_sprites(bitmap, cliprect, 0);
303	298	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 0, 0);
304	299	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0, 0);
305	300	break;
306	301
307	302	case 3:
308	303	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 1, 0);
309		draw_sprites(machine(), bitmap, cliprect, 1);
	304	draw_sprites(bitmap, cliprect, 1);
310	305	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 1, 0);
311		draw_sprites(machine(), bitmap, cliprect, 0);
	306	draw_sprites(bitmap, cliprect, 0);
312	307	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1 | 0, 0);
313	308	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0 | 0, 0);
314	309	break;

trunk/src/mame/video/nbmj9195.c

r20971	r20972
10	10	#include "emu.h"
11	11	#include "includes/nbmj9195.h"
12	12
13
14		static void nbmj9195_vramflip(running_machine &machine, int vram);
15		static void nbmj9195_gfxdraw(running_machine &machine, int vram);
16
17
18	13	/******************************************************************************
19	14
20	15
r20971	r20972
68	63
69	64
70	65	******************************************************************************/
71		static int nbmj9195_blitter_r(address_space &space, int offset, int vram)
	66	int nbmj9195_state::nbmj9195_blitter_r(int offset, int vram)
72	67	{
73		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
74	68	int ret;
75		UINT8 *GFXROM = state->memregion("gfx1")->base();
	69	UINT8 *GFXROM = memregion("gfx1")->base();
76	70
77	71	switch (offset)
78	72	{
79		case 0x00:  ret = 0xfe | ((state->m_nb19010_busyflag & 0x01) ^ 0x01); break;    // NB19010 Busy Flag
80		case 0x01:  ret = GFXROM[state->m_blitter_src_addr[vram]]; break;           // NB19010 GFX-ROM Read
	73	case 0x00:  ret = 0xfe | ((m_nb19010_busyflag & 0x01) ^ 0x01); break;    // NB19010 Busy Flag
	74	case 0x01:  ret = GFXROM[m_blitter_src_addr[vram]]; break;           // NB19010 GFX-ROM Read
81	75	default:    ret = 0xff; break;
82	76	}
83	77
84	78	return ret;
85	79	}
86	80
87		static void nbmj9195_blitter_w(address_space &space, int offset, int data, int vram)
	81	void nbmj9195_state::nbmj9195_blitter_w(int offset, int data, int vram)
88	82	{
89		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
90	83	int new_line;
91	84
92	85	switch (offset)
93	86	{
94		case 0x00:  state->m_blitter_direction_x[vram] = (data & 0x01) ? 1 : 0;
95		state->m_blitter_direction_y[vram] = (data & 0x02) ? 1 : 0;
96		state->m_clutmode[vram] = (data & 0x04) ? 1 : 0;
	87	case 0x00:  m_blitter_direction_x[vram] = (data & 0x01) ? 1 : 0;
	88	m_blitter_direction_y[vram] = (data & 0x02) ? 1 : 0;
	89	m_clutmode[vram] = (data & 0x04) ? 1 : 0;
97	90	//  if (data & 0x08) popmessage("Unknown GFX Flag!! (0x08)");
98		state->m_transparency[vram] = (data & 0x10) ? 1 : 0;
	91	m_transparency[vram] = (data & 0x10) ? 1 : 0;
99	92	//  if (data & 0x20) popmessage("Unknown GFX Flag!! (0x20)");
100		state->m_flipscreen[vram] = (data & 0x40) ? 0 : 1;
101		state->m_dispflag[vram] = (data & 0x80) ? 1 : 0;
102		nbmj9195_vramflip(space.machine(), vram);
	93	m_flipscreen[vram] = (data & 0x40) ? 0 : 1;
	94	m_dispflag[vram] = (data & 0x80) ? 1 : 0;
	95	nbmj9195_vramflip(vram);
103	96	break;
104		case 0x01:  state->m_scrollx[vram] = (state->m_scrollx[vram] & 0x0100) | data; break;
105		case 0x02:  state->m_scrollx[vram] = (state->m_scrollx[vram] & 0x00ff) | ((data << 8) & 0x0100);
106		new_line = space.machine().primary_screen->vpos();
107		if (state->m_flipscreen[vram])
	97	case 0x01:  m_scrollx[vram] = (m_scrollx[vram] & 0x0100) | data; break;
	98	case 0x02:  m_scrollx[vram] = (m_scrollx[vram] & 0x00ff) | ((data << 8) & 0x0100);
	99	new_line = machine().primary_screen->vpos();
	100	if (m_flipscreen[vram])
108	101	{
109		for ( ; state->m_scanline[vram] < new_line; state->m_scanline[vram]++)
110		state->m_scrollx_raster[vram][state->m_scanline[vram]] = (((-state->m_scrollx[vram]) - 0x4e)  & 0x1ff) << 1;
	102	for ( ; m_scanline[vram] < new_line; m_scanline[vram]++)
	103	m_scrollx_raster[vram][m_scanline[vram]] = (((-m_scrollx[vram]) - 0x4e)  & 0x1ff) << 1;
111	104	}
112	105	else
113	106	{
114		for ( ; state->m_scanline[vram] < new_line; state->m_scanline[vram]++)
115		state->m_scrollx_raster[vram][(state->m_scanline[vram] ^ 0x1ff)] = (((-state->m_scrollx[vram]) - 0x4e)  & 0x1ff) << 1;
	107	for ( ; m_scanline[vram] < new_line; m_scanline[vram]++)
	108	m_scrollx_raster[vram][(m_scanline[vram] ^ 0x1ff)] = (((-m_scrollx[vram]) - 0x4e)  & 0x1ff) << 1;
116	109	}
117	110	break;
118		case 0x03:  state->m_scrolly[vram] = (state->m_scrolly[vram] & 0x0100) | data; break;
119		case 0x04:  state->m_scrolly[vram] = (state->m_scrolly[vram] & 0x00ff) | ((data << 8) & 0x0100); break;
120		case 0x05:  state->m_blitter_src_addr[vram] = (state->m_blitter_src_addr[vram] & 0xffff00) | data; break;
121		case 0x06:  state->m_blitter_src_addr[vram] = (state->m_blitter_src_addr[vram] & 0xff00ff) | (data << 8); break;
122		case 0x07:  state->m_blitter_src_addr[vram] = (state->m_blitter_src_addr[vram] & 0x00ffff) | (data << 16); break;
123		case 0x08:  state->m_blitter_sizex[vram] = data; break;
124		case 0x09:  state->m_blitter_sizey[vram] = data; break;
125		case 0x0a:  state->m_blitter_destx[vram] = (state->m_blitter_destx[vram]  & 0xff00) | data; break;
126		case 0x0b:  state->m_blitter_destx[vram] = (state->m_blitter_destx[vram]  & 0x00ff) | (data << 8); break;
127		case 0x0c:  state->m_blitter_desty[vram] = (state->m_blitter_desty[vram]  & 0xff00) | data; break;
128		case 0x0d:  state->m_blitter_desty[vram] = (state->m_blitter_desty[vram]  & 0x00ff) | (data << 8);
129		nbmj9195_gfxdraw(space.machine(), vram);
	111	case 0x03:  m_scrolly[vram] = (m_scrolly[vram] & 0x0100) | data; break;
	112	case 0x04:  m_scrolly[vram] = (m_scrolly[vram] & 0x00ff) | ((data << 8) & 0x0100); break;
	113	case 0x05:  m_blitter_src_addr[vram] = (m_blitter_src_addr[vram] & 0xffff00) | data; break;
	114	case 0x06:  m_blitter_src_addr[vram] = (m_blitter_src_addr[vram] & 0xff00ff) | (data << 8); break;
	115	case 0x07:  m_blitter_src_addr[vram] = (m_blitter_src_addr[vram] & 0x00ffff) | (data << 16); break;
	116	case 0x08:  m_blitter_sizex[vram] = data; break;
	117	case 0x09:  m_blitter_sizey[vram] = data; break;
	118	case 0x0a:  m_blitter_destx[vram] = (m_blitter_destx[vram]  & 0xff00) | data; break;
	119	case 0x0b:  m_blitter_destx[vram] = (m_blitter_destx[vram]  & 0x00ff) | (data << 8); break;
	120	case 0x0c:  m_blitter_desty[vram] = (m_blitter_desty[vram]  & 0xff00) | data; break;
	121	case 0x0d:  m_blitter_desty[vram] = (m_blitter_desty[vram]  & 0x00ff) | (data << 8);
	122	nbmj9195_gfxdraw(vram);
130	123	break;
131	124	default:    break;
132	125	}
133	126	}
134	127
135		void nbmj9195_clutsel_w(address_space &space, int data)
	128	void nbmj9195_state::nbmj9195_clutsel_w(int data)
136	129	{
137		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
138		state->m_clutsel = data;
	130	m_clutsel = data;
139	131	}
140	132
141		static void nbmj9195_clut_w(address_space &space, int offset, int data, int vram)
	133	void nbmj9195_state::nbmj9195_clut_w(int offset, int data, int vram)
142	134	{
143		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
144		state->m_clut[vram][((state->m_clutsel & 0xff) * 0x10) + (offset & 0x0f)] = data;
	135	m_clut[vram][((m_clutsel & 0xff) * 0x10) + (offset & 0x0f)] = data;
145	136	}
146	137
147		void nbmj9195_gfxflag2_w(address_space &space, int data)
	138	void nbmj9195_state::nbmj9195_gfxflag2_w(int data)
148	139	{
149		nbmj9195_state *state = space.machine().driver_data<nbmj9195_state>();
150		state->m_gfxflag2 = data;
	140	m_gfxflag2 = data;
151	141	}
152	142
153	143	/******************************************************************************
154	144
155	145
156	146	******************************************************************************/
157		static void nbmj9195_vramflip(running_machine &machine, int vram)
	147	void nbmj9195_state::nbmj9195_vramflip(int vram)
158	148	{
159		nbmj9195_state *state = machine.driver_data<nbmj9195_state>();
160	149	int x, y;
161	150	UINT16 color1, color2;
162		int width = machine.primary_screen->width();
163		int height = machine.primary_screen->height();
	151	int width = machine().primary_screen->width();
	152	int height = machine().primary_screen->height();
164	153
165		if (state->m_flipscreen[vram] == state->m_flipscreen_old[vram]) return;
	154	if (m_flipscreen[vram] == m_flipscreen_old[vram]) return;
166	155
167	156	for (y = 0; y < (height / 2); y++)
168	157	{
169	158	for (x = 0; x < width; x++)
170	159	{
171		color1 = state->m_videoram[vram][(y * width) + x];
172		color2 = state->m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
173		state->m_videoram[vram][(y * width) + x] = color2;
174		state->m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
	160	color1 = m_videoram[vram][(y * width) + x];
	161	color2 = m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
	162	m_videoram[vram][(y * width) + x] = color2;
	163	m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
175	164	}
176	165	}
177	166
178		if (state->m_gfxdraw_mode == 2)
	167	if (m_gfxdraw_mode == 2)
179	168	{
180	169	for (y = 0; y < (height / 2); y++)
181	170	{
182	171	for (x = 0; x < width; x++)
183	172	{
184		color1 = state->m_videoworkram[vram][(y * width) + x];
185		color2 = state->m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
186		state->m_videoworkram[vram][(y * width) + x] = color2;
187		state->m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
	173	color1 = m_videoworkram[vram][(y * width) + x];
	174	color2 = m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
	175	m_videoworkram[vram][(y * width) + x] = color2;
	176	m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
188	177	}
189	178	}
190	179	}
191	180
192		state->m_flipscreen_old[vram] = state->m_flipscreen[vram];
193		state->m_screen_refresh = 1;
	181	m_flipscreen_old[vram] = m_flipscreen[vram];
	182	m_screen_refresh = 1;
194	183	}
195	184
196		static void update_pixel(running_machine &machine, int vram, int x, int y)
	185	void nbmj9195_state::update_pixel(int vram, int x, int y)
197	186	{
198		nbmj9195_state *state = machine.driver_data<nbmj9195_state>();
199		UINT16 color = state->m_videoram[vram][(y * machine.primary_screen->width()) + x];
200		state->m_tmpbitmap[vram].pix16(y, x) = color;
	187	UINT16 color = m_videoram[vram][(y * machine().primary_screen->width()) + x];
	188	m_tmpbitmap[vram].pix16(y, x) = color;
201	189	}
202	190
203	191	TIMER_CALLBACK_MEMBER(nbmj9195_state::blitter_timer_callback)
r20971	r20972
205	193	m_nb19010_busyflag = 1;
206	194	}
207	195
208		static void nbmj9195_gfxdraw(running_machine &machine, int vram)
	196	void nbmj9195_state::nbmj9195_gfxdraw(int vram)
209	197	{
210		nbmj9195_state *state = machine.driver_data<nbmj9195_state>();
211		UINT8 *GFX = state->memregion("gfx1")->base();
212		int width = machine.primary_screen->width();
	198	UINT8 *GFX = memregion("gfx1")->base();
	199	int width = machine().primary_screen->width();
213	200
214	201	int x, y;
215	202	int dx1, dx2, dy;
r20971	r20972
220	207	UINT16 color, color1, color2;
221	208	int gfxaddr, gfxlen;
222	209
223		state->m_nb19010_busyctr = 0;
	210	m_nb19010_busyctr = 0;
224	211
225		if ((state->m_gfxdraw_mode == 2) && (state->m_clutmode[vram]))
	212	if ((m_gfxdraw_mode == 2) && (m_clutmode[vram]))
226	213	{
227	214	// NB22090 clut256 mode
228		state->m_blitter_sizex[vram] = GFX[((state->m_blitter_src_addr[vram] + 0) & 0x00ffffff)];
229		state->m_blitter_sizey[vram] = GFX[((state->m_blitter_src_addr[vram] + 1) & 0x00ffffff)];
	215	m_blitter_sizex[vram] = GFX[((m_blitter_src_addr[vram] + 0) & 0x00ffffff)];
	216	m_blitter_sizey[vram] = GFX[((m_blitter_src_addr[vram] + 1) & 0x00ffffff)];
230	217	}
231	218
232		if (state->m_blitter_direction_x[vram])
	219	if (m_blitter_direction_x[vram])
233	220	{
234		startx = state->m_blitter_destx[vram];
235		sizex = state->m_blitter_sizex[vram];
	221	startx = m_blitter_destx[vram];
	222	sizex = m_blitter_sizex[vram];
236	223	skipx = 1;
237	224	}
238	225	else
239	226	{
240		startx = state->m_blitter_destx[vram] + state->m_blitter_sizex[vram];
241		sizex = state->m_blitter_sizex[vram];
	227	startx = m_blitter_destx[vram] + m_blitter_sizex[vram];
	228	sizex = m_blitter_sizex[vram];
242	229	skipx = -1;
243	230	}
244	231
245		if (state->m_blitter_direction_y[vram])
	232	if (m_blitter_direction_y[vram])
246	233	{
247		starty = state->m_blitter_desty[vram];
248		sizey = state->m_blitter_sizey[vram];
	234	starty = m_blitter_desty[vram];
	235	sizey = m_blitter_sizey[vram];
249	236	skipy = 1;
250	237	}
251	238	else
252	239	{
253		starty = state->m_blitter_desty[vram] + state->m_blitter_sizey[vram];
254		sizey = state->m_blitter_sizey[vram];
	240	starty = m_blitter_desty[vram] + m_blitter_sizey[vram];
	241	sizey = m_blitter_sizey[vram];
255	242	skipy = -1;
256	243	}
257	244
258		gfxlen = machine.root_device().memregion("gfx1")->bytes();
259		gfxaddr = ((state->m_blitter_src_addr[vram] + 2) & 0x00ffffff);
	245	gfxlen = machine().root_device().memregion("gfx1")->bytes();
	246	gfxaddr = ((m_blitter_src_addr[vram] + 2) & 0x00ffffff);
260	247
261	248	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
262	249	{
r20971	r20972
277	264	dx2 = (2 * x + 1) & 0x3ff;
278	265	dy = y & 0x1ff;
279	266
280		if (!state->m_flipscreen[vram])
	267	if (!m_flipscreen[vram])
281	268	{
282	269	dx1 ^= 0x3ff;
283	270	dx2 ^= 0x3ff;
284	271	dy ^= 0x1ff;
285	272	}
286	273
287		if (state->m_blitter_direction_x[vram])
	274	if (m_blitter_direction_x[vram])
288	275	{
289	276	// flip
290	277	color1 = (color & 0x0f) >> 0;
r20971	r20972
297	284	color2 = (color & 0x0f) >> 0;
298	285	}
299	286
300		if ((state->m_gfxdraw_mode == 2) && (state->m_clutmode[vram]))
	287	if ((m_gfxdraw_mode == 2) && (m_clutmode[vram]))
301	288	{
302	289	// clut256 mode
303	290
304		if (state->m_gfxflag2 & 0xc0)
	291	if (m_gfxflag2 & 0xc0)
305	292	{
306	293	// clut256 mode 1st(low)
307		state->m_videoworkram[vram][(dy * width) + dx1] &= 0x00f0;
308		state->m_videoworkram[vram][(dy * width) + dx1] |= color1 & 0x0f;
309		state->m_videoworkram[vram][(dy * width) + dx2] &= 0x00f0;
310		state->m_videoworkram[vram][(dy * width) + dx2] |= color2 & 0x0f;
	294	m_videoworkram[vram][(dy * width) + dx1] &= 0x00f0;
	295	m_videoworkram[vram][(dy * width) + dx1] |= color1 & 0x0f;
	296	m_videoworkram[vram][(dy * width) + dx2] &= 0x00f0;
	297	m_videoworkram[vram][(dy * width) + dx2] |= color2 & 0x0f;
311	298
312	299	continue;
313	300	}
314	301	else
315	302	{
316	303	// clut256 mode 2nd(high)
317		state->m_videoworkram[vram][(dy * width) + dx1] &= 0x000f;
318		state->m_videoworkram[vram][(dy * width) + dx1] |= (color1 & 0x0f) << 4;
319		state->m_videoworkram[vram][(dy * width) + dx2] &= 0x000f;
320		state->m_videoworkram[vram][(dy * width) + dx2] |= (color2 & 0x0f) << 4;
	304	m_videoworkram[vram][(dy * width) + dx1] &= 0x000f;
	305	m_videoworkram[vram][(dy * width) + dx1] |= (color1 & 0x0f) << 4;
	306	m_videoworkram[vram][(dy * width) + dx2] &= 0x000f;
	307	m_videoworkram[vram][(dy * width) + dx2] |= (color2 & 0x0f) << 4;
321	308
322		state->m_videoworkram[vram][(dy * width) + dx1] += state->m_clut[vram][(state->m_clutsel * 0x10)];
323		state->m_videoworkram[vram][(dy * width) + dx2] += state->m_clut[vram][(state->m_clutsel * 0x10)];
	309	m_videoworkram[vram][(dy * width) + dx1] += m_clut[vram][(m_clutsel * 0x10)];
	310	m_videoworkram[vram][(dy * width) + dx2] += m_clut[vram][(m_clutsel * 0x10)];
324	311	}
325	312
326		color1 = state->m_videoworkram[vram][(dy * width) + dx1];
327		color2 = state->m_videoworkram[vram][(dy * width) + dx2];
	313	color1 = m_videoworkram[vram][(dy * width) + dx1];
	314	color2 = m_videoworkram[vram][(dy * width) + dx2];
328	315	}
329	316	else
330	317	{
331	318	// clut16 mode
332		color1 = state->m_clut[vram][(state->m_clutsel * 0x10) + color1];
333		color2 = state->m_clut[vram][(state->m_clutsel * 0x10) + color2];
	319	color1 = m_clut[vram][(m_clutsel * 0x10) + color1];
	320	color2 = m_clut[vram][(m_clutsel * 0x10) + color2];
334	321	}
335	322
336		if (state->m_gfxdraw_mode == 2)
	323	if (m_gfxdraw_mode == 2)
337	324	{
338	325	color1 |= (0x0100 * vram);
339	326	color2 |= (0x0100 * vram);
340	327	}
341	328
342		if (((color1 & 0x00ff) != 0x00ff) || (!state->m_transparency[vram]))
	329	if (((color1 & 0x00ff) != 0x00ff) || (!m_transparency[vram]))
343	330	{
344		state->m_videoram[vram][(dy * width) + dx1] = color1;
345		update_pixel(machine, vram, dx1, dy);
	331	m_videoram[vram][(dy * width) + dx1] = color1;
	332	update_pixel(vram, dx1, dy);
346	333	}
347		if (((color2 & 0x00ff) != 0x00ff) || (!state->m_transparency[vram]))
	334	if (((color2 & 0x00ff) != 0x00ff) || (!m_transparency[vram]))
348	335	{
349		state->m_videoram[vram][(dy * width) + dx2] = color2;
350		update_pixel(machine, vram, dx2, dy);
	336	m_videoram[vram][(dy * width) + dx2] = color2;
	337	update_pixel(vram, dx2, dy);
351	338	}
352	339
353		state->m_nb19010_busyctr++;
	340	m_nb19010_busyctr++;
354	341	}
355	342	}
356	343
357		if ((state->m_gfxdraw_mode == 2) && (state->m_clutmode[vram]))
	344	if ((m_gfxdraw_mode == 2) && (m_clutmode[vram]))
358	345	{
359	346	// NB22090 clut256 mode
360		state->m_blitter_src_addr[vram] = gfxaddr;
	347	m_blitter_src_addr[vram] = gfxaddr;
361	348	}
362	349
363		state->m_nb19010_busyflag = 0;
	350	m_nb19010_busyflag = 0;
364	351
365	352	/* 1650ns per count */
366		machine.scheduler().timer_set(attotime::from_nsec(state->m_nb19010_busyctr * 1650), timer_expired_delegate(FUNC(nbmj9195_state::blitter_timer_callback),state));
	353	machine().scheduler().timer_set(attotime::from_nsec(m_nb19010_busyctr * 1650), timer_expired_delegate(FUNC(nbmj9195_state::blitter_timer_callback),this));
367	354	}
368	355
369	356	/******************************************************************************
370	357
371	358
372	359	******************************************************************************/
373		WRITE8_MEMBER(nbmj9195_state::nbmj9195_blitter_0_w){ nbmj9195_blitter_w(space, offset, data, 0); }
374		WRITE8_MEMBER(nbmj9195_state::nbmj9195_blitter_1_w){ nbmj9195_blitter_w(space, offset, data, 1); }
	360	WRITE8_MEMBER(nbmj9195_state::nbmj9195_blitter_0_w){ nbmj9195_blitter_w(offset, data, 0); }
	361	WRITE8_MEMBER(nbmj9195_state::nbmj9195_blitter_1_w){ nbmj9195_blitter_w(offset, data, 1); }
375	362
376		READ8_MEMBER(nbmj9195_state::nbmj9195_blitter_0_r){ return nbmj9195_blitter_r(space, offset, 0); }
377		READ8_MEMBER(nbmj9195_state::nbmj9195_blitter_1_r){ return nbmj9195_blitter_r(space, offset, 1); }
	363	READ8_MEMBER(nbmj9195_state::nbmj9195_blitter_0_r){ return nbmj9195_blitter_r(offset, 0); }
	364	READ8_MEMBER(nbmj9195_state::nbmj9195_blitter_1_r){ return nbmj9195_blitter_r(offset, 1); }
378	365
379		WRITE8_MEMBER(nbmj9195_state::nbmj9195_clut_0_w){ nbmj9195_clut_w(space, offset, data, 0); }
380		WRITE8_MEMBER(nbmj9195_state::nbmj9195_clut_1_w){ nbmj9195_clut_w(space, offset, data, 1); }
	366	WRITE8_MEMBER(nbmj9195_state::nbmj9195_clut_0_w){ nbmj9195_clut_w(offset, data, 0); }
	367	WRITE8_MEMBER(nbmj9195_state::nbmj9195_clut_1_w){ nbmj9195_clut_w(offset, data, 1); }
381	368
382	369	/******************************************************************************
383	370
r20971	r20972
453	440	for (y = 0; y < height; y++)
454	441	for (x = 0; x < width; x++)
455	442	{
456		update_pixel(machine(), 0, x, y);
	443	update_pixel(0, x, y);
457	444
458	445	if (m_gfxdraw_mode)
459		update_pixel(machine(), 1, x, y);
	446	update_pixel(1, x, y);
460	447	}
461	448	}
462	449

trunk/src/mame/video/niyanpai.c

r20971	r20972
9	9	#include "emu.h"
10	10	#include "includes/niyanpai.h"
11	11
12
13		static void niyanpai_vramflip(running_machine &machine, int vram);
14		static void niyanpai_gfxdraw(running_machine &machine, int vram);
15
16
17	12	/******************************************************************************
18	13
19	14
r20971	r20972
62	57
63	58
64	59	******************************************************************************/
65		static int niyanpai_blitter_r(running_machine &machine, int vram, int offset)
	60	int niyanpai_state::niyanpai_blitter_r(int vram, int offset)
66	61	{
67		niyanpai_state *state = machine.driver_data<niyanpai_state>();
68	62	int ret;
69		UINT8 *GFXROM = state->memregion("gfx1")->base();
	63	UINT8 *GFXROM = memregion("gfx1")->base();
70	64
71	65	switch (offset)
72	66	{
73		case 0x00:  ret = 0xfe | ((state->m_nb19010_busyflag & 0x01) ^ 0x01); break;    // NB19010 Busy Flag
74		case 0x01:  ret = GFXROM[state->m_blitter_src_addr[vram]]; break;           // NB19010 GFX-ROM Read
	67	case 0x00:  ret = 0xfe | ((m_nb19010_busyflag & 0x01) ^ 0x01); break;    // NB19010 Busy Flag
	68	case 0x01:  ret = GFXROM[m_blitter_src_addr[vram]]; break;           // NB19010 GFX-ROM Read
75	69	default:    ret = 0xff; break;
76	70	}
77	71
78	72	return ret;
79	73	}
80	74
81		static void niyanpai_blitter_w(running_machine &machine, int vram, int offset, int data)
	75	void niyanpai_state::niyanpai_blitter_w(int vram, int offset, int data)
82	76	{
83		niyanpai_state *state = machine.driver_data<niyanpai_state>();
84	77	switch (offset)
85	78	{
86		case 0x00:  state->m_blitter_direction_x[vram] = (data & 0x01) ? 1 : 0;
87		state->m_blitter_direction_y[vram] = (data & 0x02) ? 1 : 0;
88		state->m_clutmode[vram] = (data & 0x04) ? 1 : 0;
	79	case 0x00:  m_blitter_direction_x[vram] = (data & 0x01) ? 1 : 0;
	80	m_blitter_direction_y[vram] = (data & 0x02) ? 1 : 0;
	81	m_clutmode[vram] = (data & 0x04) ? 1 : 0;
89	82	//  if (data & 0x08) popmessage("Unknown GFX Flag!! (0x08)");
90		state->m_transparency[vram] = (data & 0x10) ? 1 : 0;
	83	m_transparency[vram] = (data & 0x10) ? 1 : 0;
91	84	//  if (data & 0x20) popmessage("Unknown GFX Flag!! (0x20)");
92		state->m_flipscreen[vram] = (data & 0x40) ? 0 : 1;
93		state->m_dispflag[vram] = (data & 0x80) ? 1 : 0;
94		niyanpai_vramflip(machine, vram);
	85	m_flipscreen[vram] = (data & 0x40) ? 0 : 1;
	86	m_dispflag[vram] = (data & 0x80) ? 1 : 0;
	87	niyanpai_vramflip(vram);
95	88	break;
96		case 0x01:  state->m_scrollx[vram] = (state->m_scrollx[vram] & 0x0100) | data; break;
97		case 0x02:  state->m_scrollx[vram] = (state->m_scrollx[vram] & 0x00ff) | ((data << 8) & 0x0100); break;
98		case 0x03:  state->m_scrolly[vram] = (state->m_scrolly[vram] & 0x0100) | data; break;
99		case 0x04:  state->m_scrolly[vram] = (state->m_scrolly[vram] & 0x00ff) | ((data << 8) & 0x0100); break;
100		case 0x05:  state->m_blitter_src_addr[vram] = (state->m_blitter_src_addr[vram] & 0xffff00) | data; break;
101		case 0x06:  state->m_blitter_src_addr[vram] = (state->m_blitter_src_addr[vram] & 0xff00ff) | (data << 8); break;
102		case 0x07:  state->m_blitter_src_addr[vram] = (state->m_blitter_src_addr[vram] & 0x00ffff) | (data << 16); break;
103		case 0x08:  state->m_blitter_sizex[vram] = data; break;
104		case 0x09:  state->m_blitter_sizey[vram] = data; break;
105		case 0x0a:  state->m_blitter_destx[vram] = (state->m_blitter_destx[vram]  & 0xff00) | data; break;
106		case 0x0b:  state->m_blitter_destx[vram] = (state->m_blitter_destx[vram]  & 0x00ff) | (data << 8); break;
107		case 0x0c:  state->m_blitter_desty[vram] = (state->m_blitter_desty[vram]  & 0xff00) | data; break;
108		case 0x0d:  state->m_blitter_desty[vram] = (state->m_blitter_desty[vram]  & 0x00ff) | (data << 8);
109		niyanpai_gfxdraw(machine, vram);
	89	case 0x01:  m_scrollx[vram] = (m_scrollx[vram] & 0x0100) | data; break;
	90	case 0x02:  m_scrollx[vram] = (m_scrollx[vram] & 0x00ff) | ((data << 8) & 0x0100); break;
	91	case 0x03:  m_scrolly[vram] = (m_scrolly[vram] & 0x0100) | data; break;
	92	case 0x04:  m_scrolly[vram] = (m_scrolly[vram] & 0x00ff) | ((data << 8) & 0x0100); break;
	93	case 0x05:  m_blitter_src_addr[vram] = (m_blitter_src_addr[vram] & 0xffff00) | data; break;
	94	case 0x06:  m_blitter_src_addr[vram] = (m_blitter_src_addr[vram] & 0xff00ff) | (data << 8); break;
	95	case 0x07:  m_blitter_src_addr[vram] = (m_blitter_src_addr[vram] & 0x00ffff) | (data << 16); break;
	96	case 0x08:  m_blitter_sizex[vram] = data; break;
	97	case 0x09:  m_blitter_sizey[vram] = data; break;
	98	case 0x0a:  m_blitter_destx[vram] = (m_blitter_destx[vram]  & 0xff00) | data; break;
	99	case 0x0b:  m_blitter_destx[vram] = (m_blitter_destx[vram]  & 0x00ff) | (data << 8); break;
	100	case 0x0c:  m_blitter_desty[vram] = (m_blitter_desty[vram]  & 0xff00) | data; break;
	101	case 0x0d:  m_blitter_desty[vram] = (m_blitter_desty[vram]  & 0x00ff) | (data << 8);
	102	niyanpai_gfxdraw(vram);
110	103	break;
111	104	default:    break;
112	105	}
113	106	}
114	107
115		static void niyanpai_clutsel_w(running_machine &machine, int vram, int data)
	108	void niyanpai_state::niyanpai_clutsel_w(int vram, int data)
116	109	{
117		niyanpai_state *state = machine.driver_data<niyanpai_state>();
118		state->m_clutsel[vram] = data;
	110	m_clutsel[vram] = data;
119	111	}
120	112
121		static void niyanpai_clut_w(running_machine &machine, int vram, int offset, int data)
	113	void niyanpai_state::niyanpai_clut_w(int vram, int offset, int data)
122	114	{
123		niyanpai_state *state = machine.driver_data<niyanpai_state>();
124		state->m_clut[vram][((state->m_clutsel[vram] & 0xff) * 0x10) + (offset & 0x0f)] = data;
	115	m_clut[vram][((m_clutsel[vram] & 0xff) * 0x10) + (offset & 0x0f)] = data;
125	116	}
126	117
127	118	/******************************************************************************
128	119
129	120
130	121	******************************************************************************/
131		static void niyanpai_vramflip(running_machine &machine, int vram)
	122	void niyanpai_state::niyanpai_vramflip(int vram)
132	123	{
133		niyanpai_state *state = machine.driver_data<niyanpai_state>();
134	124	int x, y;
135	125	UINT16 color1, color2;
136		int width = machine.primary_screen->width();
137		int height = machine.primary_screen->height();
	126	int width = machine().primary_screen->width();
	127	int height = machine().primary_screen->height();
138	128
139		if (state->m_flipscreen[vram] == state->m_flipscreen_old[vram]) return;
	129	if (m_flipscreen[vram] == m_flipscreen_old[vram]) return;
140	130
141	131	for (y = 0; y < (height / 2); y++)
142	132	{
143	133	for (x = 0; x < width; x++)
144	134	{
145		color1 = state->m_videoram[vram][(y * width) + x];
146		color2 = state->m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
147		state->m_videoram[vram][(y * width) + x] = color2;
148		state->m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
	135	color1 = m_videoram[vram][(y * width) + x];
	136	color2 = m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
	137	m_videoram[vram][(y * width) + x] = color2;
	138	m_videoram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
149	139	}
150	140	}
151	141
r20971	r20972
153	143	{
154	144	for (x = 0; x < width; x++)
155	145	{
156		color1 = state->m_videoworkram[vram][(y * width) + x];
157		color2 = state->m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
158		state->m_videoworkram[vram][(y * width) + x] = color2;
159		state->m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
	146	color1 = m_videoworkram[vram][(y * width) + x];
	147	color2 = m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)];
	148	m_videoworkram[vram][(y * width) + x] = color2;
	149	m_videoworkram[vram][((y ^ 0x1ff) * width) + (x ^ 0x3ff)] = color1;
160	150	}
161	151	}
162	152
163		state->m_flipscreen_old[vram] = state->m_flipscreen[vram];
164		state->m_screen_refresh = 1;
	153	m_flipscreen_old[vram] = m_flipscreen[vram];
	154	m_screen_refresh = 1;
165	155	}
166	156
167		static void update_pixel(running_machine &machine, int vram, int x, int y)
	157	void niyanpai_state::update_pixel(int vram, int x, int y)
168	158	{
169		niyanpai_state *state = machine.driver_data<niyanpai_state>();
170		UINT16 color = state->m_videoram[vram][(y * machine.primary_screen->width()) + x];
171		state->m_tmpbitmap[vram].pix16(y, x) = color;
	159	UINT16 color = m_videoram[vram][(y * machine().primary_screen->width()) + x];
	160	m_tmpbitmap[vram].pix16(y, x) = color;
172	161	}
173	162
174	163	TIMER_CALLBACK_MEMBER(niyanpai_state::blitter_timer_callback)
r20971	r20972
176	165	m_nb19010_busyflag = 1;
177	166	}
178	167
179		static void niyanpai_gfxdraw(running_machine &machine, int vram)
	168	void niyanpai_state::niyanpai_gfxdraw(int vram)
180	169	{
181		niyanpai_state *state = machine.driver_data<niyanpai_state>();
182		UINT8 *GFX = state->memregion("gfx1")->base();
183		int width = machine.primary_screen->width();
	170	UINT8 *GFX = memregion("gfx1")->base();
	171	int width = machine().primary_screen->width();
184	172
185	173	int x, y;
186	174	int dx1, dx2, dy;
r20971	r20972
191	179	UINT16 color, color1, color2;
192	180	int gfxaddr, gfxlen;
193	181
194		state->m_nb19010_busyctr = 0;
	182	m_nb19010_busyctr = 0;
195	183
196		if (state->m_clutmode[vram])
	184	if (m_clutmode[vram])
197	185	{
198	186	// NB22090 clut256 mode
199		state->m_blitter_sizex[vram] = GFX[((state->m_blitter_src_addr[vram] + 0) & 0x00ffffff)];
200		state->m_blitter_sizey[vram] = GFX[((state->m_blitter_src_addr[vram] + 1) & 0x00ffffff)];
	187	m_blitter_sizex[vram] = GFX[((m_blitter_src_addr[vram] + 0) & 0x00ffffff)];
	188	m_blitter_sizey[vram] = GFX[((m_blitter_src_addr[vram] + 1) & 0x00ffffff)];
201	189	}
202	190
203		if (state->m_blitter_direction_x[vram])
	191	if (m_blitter_direction_x[vram])
204	192	{
205		startx = state->m_blitter_destx[vram];
206		sizex = state->m_blitter_sizex[vram];
	193	startx = m_blitter_destx[vram];
	194	sizex = m_blitter_sizex[vram];
207	195	skipx = 1;
208	196	}
209	197	else
210	198	{
211		startx = state->m_blitter_destx[vram] + state->m_blitter_sizex[vram];
212		sizex = state->m_blitter_sizex[vram];
	199	startx = m_blitter_destx[vram] + m_blitter_sizex[vram];
	200	sizex = m_blitter_sizex[vram];
213	201	skipx = -1;
214	202	}
215	203
216		if (state->m_blitter_direction_y[vram])
	204	if (m_blitter_direction_y[vram])
217	205	{
218		starty = state->m_blitter_desty[vram];
219		sizey = state->m_blitter_sizey[vram];
	206	starty = m_blitter_desty[vram];
	207	sizey = m_blitter_sizey[vram];
220	208	skipy = 1;
221	209	}
222	210	else
223	211	{
224		starty = state->m_blitter_desty[vram] + state->m_blitter_sizey[vram];
225		sizey = state->m_blitter_sizey[vram];
	212	starty = m_blitter_desty[vram] + m_blitter_sizey[vram];
	213	sizey = m_blitter_sizey[vram];
226	214	skipy = -1;
227	215	}
228	216
229		gfxlen = machine.root_device().memregion("gfx1")->bytes();
230		gfxaddr = ((state->m_blitter_src_addr[vram] + 2) & 0x00ffffff);
	217	gfxlen = machine().root_device().memregion("gfx1")->bytes();
	218	gfxaddr = ((m_blitter_src_addr[vram] + 2) & 0x00ffffff);
231	219
232	220	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
233	221	{
r20971	r20972
248	236	dx2 = (2 * x + 1) & 0x3ff;
249	237	dy = y & 0x1ff;
250	238
251		if (!state->m_flipscreen[vram])
	239	if (!m_flipscreen[vram])
252	240	{
253	241	dx1 ^= 0x3ff;
254	242	dx2 ^= 0x3ff;
255	243	dy ^= 0x1ff;
256	244	}
257	245
258		if (state->m_blitter_direction_x[vram])
	246	if (m_blitter_direction_x[vram])
259	247	{
260	248	// flip
261	249	color1 = (color & 0x0f) >> 0;
r20971	r20972
268	256	color2 = (color & 0x0f) >> 0;
269	257	}
270	258
271		if (state->m_clutmode[vram])
	259	if (m_clutmode[vram])
272	260	{
273	261	// clut256 mode
274	262
275		if (state->m_clutsel[vram] & 0x80)
	263	if (m_clutsel[vram] & 0x80)
276	264	{
277	265	// clut256 mode 1st(low)
278		state->m_videoworkram[vram][(dy * width) + dx1] &= 0x00f0;
279		state->m_videoworkram[vram][(dy * width) + dx1] |= color1 & 0x0f;
280		state->m_videoworkram[vram][(dy * width) + dx2] &= 0x00f0;
281		state->m_videoworkram[vram][(dy * width) + dx2] |= color2 & 0x0f;
	266	m_videoworkram[vram][(dy * width) + dx1] &= 0x00f0;
	267	m_videoworkram[vram][(dy * width) + dx1] |= color1 & 0x0f;
	268	m_videoworkram[vram][(dy * width) + dx2] &= 0x00f0;
	269	m_videoworkram[vram][(dy * width) + dx2] |= color2 & 0x0f;
282	270
283	271	continue;
284	272	}
285	273	else
286	274	{
287	275	// clut256 mode 2nd(high)
288		state->m_videoworkram[vram][(dy * width) + dx1] &= 0x000f;
289		state->m_videoworkram[vram][(dy * width) + dx1] |= (color1 & 0x0f) << 4;
290		state->m_videoworkram[vram][(dy * width) + dx2] &= 0x000f;
291		state->m_videoworkram[vram][(dy * width) + dx2] |= (color2 & 0x0f) << 4;
	276	m_videoworkram[vram][(dy * width) + dx1] &= 0x000f;
	277	m_videoworkram[vram][(dy * width) + dx1] |= (color1 & 0x0f) << 4;
	278	m_videoworkram[vram][(dy * width) + dx2] &= 0x000f;
	279	m_videoworkram[vram][(dy * width) + dx2] |= (color2 & 0x0f) << 4;
292	280
293		//          state->m_videoworkram[vram][(dy * width) + dx1] += state->m_clut[vram][(state->m_clutsel[vram] * 0x10)];
294		//          state->m_videoworkram[vram][(dy * width) + dx2] += state->m_clut[vram][(state->m_clutsel[vram] * 0x10)];
	281	//          m_videoworkram[vram][(dy * width) + dx1] += m_clut[vram][(m_clutsel[vram] * 0x10)];
	282	//          m_videoworkram[vram][(dy * width) + dx2] += m_clut[vram][(m_clutsel[vram] * 0x10)];
295	283	}
296	284
297		color1 = state->m_videoworkram[vram][(dy * width) + dx1];
298		color2 = state->m_videoworkram[vram][(dy * width) + dx2];
	285	color1 = m_videoworkram[vram][(dy * width) + dx1];
	286	color2 = m_videoworkram[vram][(dy * width) + dx2];
299	287	}
300	288	else
301	289	{
302	290	// clut16 mode
303		color1 = state->m_clut[vram][(state->m_clutsel[vram] * 0x10) + color1];
304		color2 = state->m_clut[vram][(state->m_clutsel[vram] * 0x10) + color2];
	291	color1 = m_clut[vram][(m_clutsel[vram] * 0x10) + color1];
	292	color2 = m_clut[vram][(m_clutsel[vram] * 0x10) + color2];
305	293	}
306	294
307	295	color1 |= (0x0100 * vram);
308	296	color2 |= (0x0100 * vram);
309	297
310		if (((color1 & 0x00ff) != 0x00ff) || (!state->m_transparency[vram]))
	298	if (((color1 & 0x00ff) != 0x00ff) || (!m_transparency[vram]))
311	299	{
312		state->m_videoram[vram][(dy * width) + dx1] = color1;
313		update_pixel(machine, vram, dx1, dy);
	300	m_videoram[vram][(dy * width) + dx1] = color1;
	301	update_pixel(vram, dx1, dy);
314	302	}
315		if (((color2 & 0x00ff) != 0x00ff) || (!state->m_transparency[vram]))
	303	if (((color2 & 0x00ff) != 0x00ff) || (!m_transparency[vram]))
316	304	{
317		state->m_videoram[vram][(dy * width) + dx2] = color2;
318		update_pixel(machine, vram, dx2, dy);
	305	m_videoram[vram][(dy * width) + dx2] = color2;
	306	update_pixel(vram, dx2, dy);
319	307	}
320	308
321		state->m_nb19010_busyctr++;
	309	m_nb19010_busyctr++;
322	310	}
323	311	}
324	312
325		if (state->m_clutmode[vram])
	313	if (m_clutmode[vram])
326	314	{
327	315	// NB22090 clut256 mode
328		state->m_blitter_src_addr[vram] = gfxaddr;
	316	m_blitter_src_addr[vram] = gfxaddr;
329	317	}
330	318
331		state->m_nb19010_busyflag = 0;
332		machine.scheduler().timer_set(attotime::from_nsec(1000 * state->m_nb19010_busyctr), timer_expired_delegate(FUNC(niyanpai_state::blitter_timer_callback),state));
	319	m_nb19010_busyflag = 0;
	320	machine().scheduler().timer_set(attotime::from_nsec(1000 * m_nb19010_busyctr), timer_expired_delegate(FUNC(niyanpai_state::blitter_timer_callback),this));
333	321	}
334	322
335	323	/******************************************************************************
336	324
337	325
338	326	******************************************************************************/
339		WRITE16_MEMBER(niyanpai_state::niyanpai_blitter_0_w){ niyanpai_blitter_w(machine(), 0, offset, data); }
340		WRITE16_MEMBER(niyanpai_state::niyanpai_blitter_1_w){ niyanpai_blitter_w(machine(), 1, offset, data); }
341		WRITE16_MEMBER(niyanpai_state::niyanpai_blitter_2_w){ niyanpai_blitter_w(machine(), 2, offset, data); }
	327	WRITE16_MEMBER(niyanpai_state::niyanpai_blitter_0_w){ niyanpai_blitter_w(0, offset, data); }
	328	WRITE16_MEMBER(niyanpai_state::niyanpai_blitter_1_w){ niyanpai_blitter_w(1, offset, data); }
	329	WRITE16_MEMBER(niyanpai_state::niyanpai_blitter_2_w){ niyanpai_blitter_w(2, offset, data); }
342	330
343		READ16_MEMBER(niyanpai_state::niyanpai_blitter_0_r){ return niyanpai_blitter_r(machine(), 0, offset); }
344		READ16_MEMBER(niyanpai_state::niyanpai_blitter_1_r){ return niyanpai_blitter_r(machine(), 1, offset); }
345		READ16_MEMBER(niyanpai_state::niyanpai_blitter_2_r){ return niyanpai_blitter_r(machine(), 2, offset); }
	331	READ16_MEMBER(niyanpai_state::niyanpai_blitter_0_r){ return niyanpai_blitter_r(0, offset); }
	332	READ16_MEMBER(niyanpai_state::niyanpai_blitter_1_r){ return niyanpai_blitter_r(1, offset); }
	333	READ16_MEMBER(niyanpai_state::niyanpai_blitter_2_r){ return niyanpai_blitter_r(2, offset); }
346	334
347		WRITE16_MEMBER(niyanpai_state::niyanpai_clut_0_w){ niyanpai_clut_w(machine(), 0, offset, data); }
348		WRITE16_MEMBER(niyanpai_state::niyanpai_clut_1_w){ niyanpai_clut_w(machine(), 1, offset, data); }
349		WRITE16_MEMBER(niyanpai_state::niyanpai_clut_2_w){ niyanpai_clut_w(machine(), 2, offset, data); }
	335	WRITE16_MEMBER(niyanpai_state::niyanpai_clut_0_w){ niyanpai_clut_w(0, offset, data); }
	336	WRITE16_MEMBER(niyanpai_state::niyanpai_clut_1_w){ niyanpai_clut_w(1, offset, data); }
	337	WRITE16_MEMBER(niyanpai_state::niyanpai_clut_2_w){ niyanpai_clut_w(2, offset, data); }
350	338
351		WRITE16_MEMBER(niyanpai_state::niyanpai_clutsel_0_w){ niyanpai_clutsel_w(machine(), 0, data); }
352		WRITE16_MEMBER(niyanpai_state::niyanpai_clutsel_1_w){ niyanpai_clutsel_w(machine(), 1, data); }
353		WRITE16_MEMBER(niyanpai_state::niyanpai_clutsel_2_w){ niyanpai_clutsel_w(machine(), 2, data); }
	339	WRITE16_MEMBER(niyanpai_state::niyanpai_clutsel_0_w){ niyanpai_clutsel_w(0, data); }
	340	WRITE16_MEMBER(niyanpai_state::niyanpai_clutsel_1_w){ niyanpai_clutsel_w(1, data); }
	341	WRITE16_MEMBER(niyanpai_state::niyanpai_clutsel_2_w){ niyanpai_clutsel_w(2, data); }
354	342
355	343	/******************************************************************************
356	344
r20971	r20972
397	385	for (y = 0; y < height; y++)
398	386	for (x = 0; x < width; x++)
399	387	{
400		update_pixel(machine(), 0, x, y);
401		update_pixel(machine(), 1, x, y);
402		update_pixel(machine(), 2, x, y);
	388	update_pixel(0, x, y);
	389	update_pixel(1, x, y);
	390	update_pixel(2, x, y);
403	391	}
404	392	}
405	393

trunk/src/mame/video/neogeo.c

r20971	r20972
18	18	*
19	19	*************************************/
20	20
21		static void set_videoram_offset( running_machine &machine, UINT16 data )
	21	void neogeo_state::set_videoram_offset( UINT16 data )
22	22	{
23		neogeo_state *state = machine.driver_data<neogeo_state>();
24		state->m_videoram_offset = data;
	23	m_videoram_offset = data;
25	24
26	25	/* the read happens right away */
27		state->m_videoram_read_buffer = state->m_videoram[state->m_videoram_offset];
	26	m_videoram_read_buffer = m_videoram[m_videoram_offset];
28	27	}
29	28
30	29
31		static UINT16 get_videoram_data( running_machine &machine )
	30	UINT16 neogeo_state::get_videoram_data(  )
32	31	{
33		neogeo_state *state = machine.driver_data<neogeo_state>();
34		return state->m_videoram_read_buffer;
	32	return m_videoram_read_buffer;
35	33	}
36	34
37	35
38		static void set_videoram_data( running_machine &machine, UINT16 data)
	36	void neogeo_state::set_videoram_data( UINT16 data)
39	37	{
40		neogeo_state *state = machine.driver_data<neogeo_state>();
41		state->m_videoram[state->m_videoram_offset] = data;
	38	m_videoram[m_videoram_offset] = data;
42	39
43	40	/* auto increment/decrement the current offset - A15 is NOT effected */
44		state->m_videoram_offset = (state->m_videoram_offset & 0x8000) | ((state->m_videoram_offset + state->m_videoram_modulo) & 0x7fff);
	41	m_videoram_offset = (m_videoram_offset & 0x8000) | ((m_videoram_offset + m_videoram_modulo) & 0x7fff);
45	42
46	43	/* read next value right away */
47		state->m_videoram_read_buffer = state->m_videoram[state->m_videoram_offset];
	44	m_videoram_read_buffer = m_videoram[m_videoram_offset];
48	45	}
49	46
50	47
51		static void set_videoram_modulo( running_machine &machine, UINT16 data)
	48	void neogeo_state::set_videoram_modulo( UINT16 data)
52	49	{
53		neogeo_state *state = machine.driver_data<neogeo_state>();
54		state->m_videoram_modulo = data;
	50	m_videoram_modulo = data;
55	51	}
56	52
57	53
58		static UINT16 get_videoram_modulo( running_machine &machine )
	54	UINT16 neogeo_state::get_videoram_modulo(  )
59	55	{
60		neogeo_state *state = machine.driver_data<neogeo_state>();
61		return state->m_videoram_modulo;
	56	return m_videoram_modulo;
62	57	}
63	58
64	59
r20971	r20972
69	64	*
70	65	*************************************/
71	66
72		static void compute_rgb_weights( running_machine &machine )
	67	void neogeo_state::compute_rgb_weights(  )
73	68	{
74		neogeo_state *state = machine.driver_data<neogeo_state>();
75	69	static const int resistances[] = { 220, 470, 1000, 2200, 3900 };
76	70
77	71	/* compute four sets of weights - with or without the pulldowns -
78	72	ensuring that we use the same scaler for all */
79	73
80	74	double scaler = compute_resistor_weights(0, 0xff, -1,
81		5, resistances, state->m_rgb_weights_normal, 0, 0,
	75	5, resistances, m_rgb_weights_normal, 0, 0,
82	76	0, 0, 0, 0, 0,
83	77	0, 0, 0, 0, 0);
84	78
85	79	compute_resistor_weights(0, 0xff, scaler,
86		5, resistances, state->m_rgb_weights_normal_bit15, 8200, 0,
	80	5, resistances, m_rgb_weights_normal_bit15, 8200, 0,
87	81	0, 0, 0, 0, 0,
88	82	0, 0, 0, 0, 0);
89	83
90	84	compute_resistor_weights(0, 0xff, scaler,
91		5, resistances, state->m_rgb_weights_dark, 150, 0,
	85	5, resistances, m_rgb_weights_dark, 150, 0,
92	86	0, 0, 0, 0, 0,
93	87	0, 0, 0, 0, 0);
94	88
95	89	compute_resistor_weights(0, 0xff, scaler,
96		5, resistances, state->m_rgb_weights_dark_bit15, 1 / ((1.0 / 8200) + (1.0 / 150)), 0,
	90	5, resistances, m_rgb_weights_dark_bit15, 1 / ((1.0 / 8200) + (1.0 / 150)), 0,
97	91	0, 0, 0, 0, 0,
98	92	0, 0, 0, 0, 0);
99	93	}
100	94
101	95
102		static pen_t get_pen( running_machine &machine, UINT16 data )
	96	pen_t neogeo_state::get_pen( UINT16 data )
103	97	{
104		neogeo_state *state = machine.driver_data<neogeo_state>();
105	98	double *weights;
106	99	UINT8 r, g, b;
107	100
108		if (state->m_screen_dark)
	101	if (m_screen_dark)
109	102	{
110	103	if (data & 0x8000)
111		weights = state->m_rgb_weights_dark_bit15;
	104	weights = m_rgb_weights_dark_bit15;
112	105	else
113		weights = state->m_rgb_weights_dark;
	106	weights = m_rgb_weights_dark;
114	107	}
115	108	else
116	109	{
117	110	if (data & 0x8000)
118		weights = state->m_rgb_weights_normal_bit15;
	111	weights = m_rgb_weights_normal_bit15;
119	112	else
120		weights = state->m_rgb_weights_normal;
	113	weights = m_rgb_weights_normal;
121	114	}
122	115
123	116	r = combine_5_weights(weights,
r20971	r20972
150	143	int i;
151	144
152	145	for (i = 0; i < NUM_PENS; i++)
153		m_pens[i] = get_pen(machine(), m_palettes[m_palette_bank][i]);
	146	m_pens[i] = get_pen(m_palettes[m_palette_bank][i]);
154	147	}
155	148
156	149
157		void neogeo_set_palette_bank( running_machine &machine, UINT8 data )
	150	void neogeo_state::neogeo_set_palette_bank( UINT8 data )
158	151	{
159		neogeo_state *state = machine.driver_data<neogeo_state>();
160		if (data != state->m_palette_bank)
	152	if (data != m_palette_bank)
161	153	{
162		state->m_palette_bank = data;
	154	m_palette_bank = data;
163	155
164		state->regenerate_pens();
	156	regenerate_pens();
165	157	}
166	158	}
167	159
168	160
169		void neogeo_set_screen_dark( running_machine &machine, UINT8 data )
	161	void neogeo_state::neogeo_set_screen_dark( UINT8 data )
170	162	{
171		neogeo_state *state = machine.driver_data<neogeo_state>();
172		if (data != state->m_screen_dark)
	163	if (data != m_screen_dark)
173	164	{
174		state->m_screen_dark = data;
	165	m_screen_dark = data;
175	166
176		state->regenerate_pens();
	167	regenerate_pens();
177	168	}
178	169	}
179	170
r20971	r20972
190	181
191	182	COMBINE_DATA(addr);
192	183
193		m_pens[offset] = get_pen(machine(), *addr);
	184	m_pens[offset] = get_pen(*addr);
194	185	}
195	186
196	187
r20971	r20972
201	192	*
202	193	*************************************/
203	194
204		static void set_auto_animation_speed( running_machine &machine, UINT8 data)
	195	void neogeo_state::set_auto_animation_speed( UINT8 data)
205	196	{
206		neogeo_state *state = machine.driver_data<neogeo_state>();
207		state->m_auto_animation_speed = data;
	197	m_auto_animation_speed = data;
208	198	}
209	199
210	200
211		static void set_auto_animation_disabled( running_machine &machine, UINT8 data)
	201	void neogeo_state::set_auto_animation_disabled( UINT8 data)
212	202	{
213		neogeo_state *state = machine.driver_data<neogeo_state>();
214		state->m_auto_animation_disabled = data;
	203	m_auto_animation_disabled = data;
215	204	}
216	205
217	206
218		UINT8 neogeo_get_auto_animation_counter( running_machine &machine )
	207	UINT8 neogeo_state::neogeo_get_auto_animation_counter(  )
219	208	{
220		neogeo_state *state = machine.driver_data<neogeo_state>();
221		return state->m_auto_animation_counter;
	209	return m_auto_animation_counter;
222	210	}
223	211
224	212
r20971	r20972
236	224	}
237	225
238	226
239		static void create_auto_animation_timer( running_machine &machine )
	227	void neogeo_state::create_auto_animation_timer(  )
240	228	{
241		neogeo_state *state = machine.driver_data<neogeo_state>();
242		state->m_auto_animation_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::auto_animation_timer_callback),state));
	229	m_auto_animation_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::auto_animation_timer_callback),this));
243	230	}
244	231
245	232
246		static void start_auto_animation_timer( running_machine &machine )
	233	void neogeo_state::start_auto_animation_timer(  )
247	234	{
248		neogeo_state *state = machine.driver_data<neogeo_state>();
249		state->m_auto_animation_timer->adjust(machine.primary_screen->time_until_pos(NEOGEO_VSSTART));
	235	m_auto_animation_timer->adjust(machine().primary_screen->time_until_pos(NEOGEO_VSSTART));
250	236	}
251	237
252	238
r20971	r20972
257	243	*
258	244	*************************************/
259	245
260		void neogeo_set_fixed_layer_source( running_machine &machine, UINT8 data )
	246	void neogeo_state::neogeo_set_fixed_layer_source( UINT8 data )
261	247	{
262		neogeo_state *state = machine.driver_data<neogeo_state>();
263		state->m_fixed_layer_source = data;
	248	m_fixed_layer_source = data;
264	249	}
265	250
266	251
r20971	r20972
376	361	};
377	362
378	363
379		INLINE int rows_to_height(int rows)
	364	inline int neogeo_state::rows_to_height(int rows)
380	365	{
381	366	if ((rows == 0) || (rows > 0x20))
382	367	rows = 0x20;
r20971	r20972
385	370	}
386	371
387	372
388		INLINE int sprite_on_scanline(int scanline, int y, int rows)
	373	inline int neogeo_state::sprite_on_scanline(int scanline, int y, int rows)
389	374	{
390	375	/* check if the current scanline falls inside this sprite,
391	376	two possible scenerios, wrap around or not */
r20971	r20972
396	381	}
397	382
398	383
399		static void draw_sprites( running_machine &machine, bitmap_rgb32 &bitmap, int scanline )
	384	void neogeo_state::draw_sprites( bitmap_rgb32 &bitmap, int scanline )
400	385	{
401		neogeo_state *state = machine.driver_data<neogeo_state>();
402	386	int sprite_index;
403	387	int max_sprite_index;
404	388
r20971	r20972
411	395
412	396	/* select the active list */
413	397	if (scanline & 0x01)
414		sprite_list = &state->m_videoram[0x8680];
	398	sprite_list = &m_videoram[0x8680];
415	399	else
416		sprite_list = &state->m_videoram[0x8600];
	400	sprite_list = &m_videoram[0x8600];
417	401
418	402	/* optimization -- find last non-zero entry and only draw that many +1
419	403	sprite.  This is not 100% correct as the hardware will keep drawing
r20971	r20972
431	415	for (sprite_index = 0; sprite_index <= max_sprite_index; sprite_index++)
432	416	{
433	417	UINT16 sprite_number = sprite_list[sprite_index] & 0x01ff;
434		UINT16 y_control = state->m_videoram[0x8200 | sprite_number];
435		UINT16 zoom_control = state->m_videoram[0x8000 | sprite_number];
	418	UINT16 y_control = m_videoram[0x8200 | sprite_number];
	419	UINT16 zoom_control = m_videoram[0x8000 | sprite_number];
436	420
437	421	/* if chained, go to next X coordinate and get new X zoom */
438	422	if (y_control & 0x40)
r20971	r20972
444	428	else
445	429	{
446	430	y = 0x200 - (y_control >> 7);
447		x = state->m_videoram[0x8400 | sprite_number] >> 7;
	431	x = m_videoram[0x8400 | sprite_number] >> 7;
448	432	zoom_y = zoom_control & 0xff;
449	433	zoom_x = (zoom_control >> 8) & 0x0f;
450	434	rows = y_control & 0x3f;
r20971	r20972
487	471	}
488	472	}
489	473
490		sprite_y_and_tile = state->m_region_zoomy[(zoom_y << 8) | zoom_line];
	474	sprite_y_and_tile = m_region_zoomy[(zoom_y << 8) | zoom_line];
491	475	sprite_y = sprite_y_and_tile & 0x0f;
492	476	tile = sprite_y_and_tile >> 4;
493	477
r20971	r20972
498	482	}
499	483
500	484	attr_and_code_offs = (sprite_number << 6) | (tile << 1);
501		attr = state->m_videoram[attr_and_code_offs + 1];
502		code = ((attr << 12) & 0x70000) | state->m_videoram[attr_and_code_offs];
	485	attr = m_videoram[attr_and_code_offs + 1];
	486	code = ((attr << 12) & 0x70000) | m_videoram[attr_and_code_offs];
503	487
504	488	/* substitute auto animation bits */
505		if (!state->m_auto_animation_disabled)
	489	if (!m_auto_animation_disabled)
506	490	{
507	491	if (attr & 0x0008)
508		code = (code & ~0x07) | (state->m_auto_animation_counter & 0x07);
	492	code = (code & ~0x07) | (m_auto_animation_counter & 0x07);
509	493	else if (attr & 0x0004)
510		code = (code & ~0x03) | (state->m_auto_animation_counter & 0x03);
	494	code = (code & ~0x03) | (m_auto_animation_counter & 0x03);
511	495	}
512	496
513	497	/* vertical flip? */
r20971	r20972
517	501	zoom_x_table = zoom_x_tables[zoom_x];
518	502
519	503	/* compute offset in gfx ROM and mask it to the number of bits available */
520		gfx = &state->m_sprite_gfx[((code << 8) | (sprite_y << 4)) & state->m_sprite_gfx_address_mask];
	504	gfx = &m_sprite_gfx[((code << 8) | (sprite_y << 4)) & m_sprite_gfx_address_mask];
521	505
522		line_pens = &state->m_pens[attr >> 8 << 4];
	506	line_pens = &m_pens[attr >> 8 << 4];
523	507
524	508	/* horizontal flip? */
525	509	if (attr & 0x0001)
r20971	r20972
585	569	}
586	570
587	571
588		static void parse_sprites( running_machine &machine, int scanline )
	572	void neogeo_state::parse_sprites( int scanline )
589	573	{
590		neogeo_state *state = machine.driver_data<neogeo_state>();
591	574	UINT16 sprite_number;
592	575	int y = 0;
593	576	int rows = 0;
r20971	r20972
597	580
598	581	/* select the active list */
599	582	if (scanline & 0x01)
600		sprite_list = &state->m_videoram[0x8680];
	583	sprite_list = &m_videoram[0x8680];
601	584	else
602		sprite_list = &state->m_videoram[0x8600];
	585	sprite_list = &m_videoram[0x8600];
603	586
604	587	/* scan all sprites */
605	588	for (sprite_number = 0; sprite_number < MAX_SPRITES_PER_SCREEN; sprite_number++)
606	589	{
607		UINT16 y_control = state->m_videoram[0x8200 | sprite_number];
	590	UINT16 y_control = m_videoram[0x8200 | sprite_number];
608	591
609	592	/* if not chained, get Y position and height, otherwise use previous values */
610	593	if (~y_control & 0x40)
r20971	r20972
646	629	if (scanline != 0)
647	630	machine().primary_screen->update_partial(scanline - 1);
648	631
649		parse_sprites(machine(), scanline);
	632	parse_sprites(scanline);
650	633
651	634	/* let's come back at the beginning of the next line */
652	635	scanline = (scanline + 1) % NEOGEO_VTOTAL;
r20971	r20972
655	638	}
656	639
657	640
658		static void create_sprite_line_timer( running_machine &machine )
	641	void neogeo_state::create_sprite_line_timer(  )
659	642	{
660		neogeo_state *state = machine.driver_data<neogeo_state>();
661		state->m_sprite_line_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::sprite_line_timer_callback),state));
	643	m_sprite_line_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::sprite_line_timer_callback),this));
662	644	}
663	645
664	646
665		static void start_sprite_line_timer( running_machine &machine )
	647	void neogeo_state::start_sprite_line_timer(  )
666	648	{
667		neogeo_state *state = machine.driver_data<neogeo_state>();
668		state->m_sprite_line_timer->adjust(machine.primary_screen->time_until_pos(0));
	649	m_sprite_line_timer->adjust(machine().primary_screen->time_until_pos(0));
669	650	}
670	651
671	652
r20971	r20972
733	714	*
734	715	*************************************/
735	716
736		static UINT16 get_video_control( running_machine &machine )
	717	UINT16 neogeo_state::get_video_control(  )
737	718	{
738	719	UINT16 ret;
739	720	UINT16 v_counter;
r20971	r20972
760	741	*/
761	742
762	743	/* the vertical counter chain goes from 0xf8 - 0x1ff */
763		v_counter = machine.primary_screen->vpos() + 0x100;
	744	v_counter = machine().primary_screen->vpos() + 0x100;
764	745
765	746	if (v_counter >= 0x200)
766	747	v_counter = v_counter - NEOGEO_VTOTAL;
767	748
768		ret = (v_counter << 7) | (neogeo_get_auto_animation_counter(machine) & 0x0007);
	749	ret = (v_counter << 7) | (neogeo_get_auto_animation_counter() & 0x0007);
769	750
770		if (VERBOSE) logerror("%s: video_control read (%04x)\n", machine.describe_context(), ret);
	751	if (VERBOSE) logerror("%s: video_control read (%04x)\n", machine().describe_context(), ret);
771	752
772	753	return ret;
773	754	}
r20971	r20972
778	759	/* this does much more than this, but I'm not sure exactly what */
779	760	if (VERBOSE) logerror("%s: video control write %04x\n", machine().describe_context(), data);
780	761
781		set_auto_animation_speed(machine(), data >> 8);
782		set_auto_animation_disabled(machine(), data & 0x0008);
	762	set_auto_animation_speed(data >> 8);
	763	set_auto_animation_disabled(data & 0x0008);
783	764
784	765	neogeo_set_display_position_interrupt_control(data & 0x00f0);
785	766	}
r20971	r20972
798	779	{
799	780	default:
800	781	case 0x00:
801		case 0x01: ret = get_videoram_data(machine()); break;
802		case 0x02: ret = get_videoram_modulo(machine()); break;
803		case 0x03: ret = get_video_control(machine()); break;
	782	case 0x01: ret = get_videoram_data(); break;
	783	case 0x02: ret = get_videoram_modulo(); break;
	784	case 0x03: ret = get_video_control(); break;
804	785	}
805	786	}
806	787
r20971	r20972
819	800
820	801	switch (offset)
821	802	{
822		case 0x00: set_videoram_offset(machine(), data); break;
823		case 0x01: set_videoram_data(machine(), data); break;
824		case 0x02: set_videoram_modulo(machine(), data); break;
	803	case 0x00: set_videoram_offset(data); break;
	804	case 0x01: set_videoram_data(data); break;
	805	case 0x02: set_videoram_modulo(data); break;
825	806	case 0x03: set_video_control(data); break;
826	807	case 0x04: neogeo_set_display_counter_msb(data); break;
827	808	case 0x05: neogeo_set_display_counter_lsb(data); break;
r20971	r20972
853	834	memset(m_pens, 0x00, NUM_PENS * sizeof(pen_t));
854	835	memset(m_videoram, 0x00, 0x20000);
855	836
856		compute_rgb_weights(machine());
857		create_sprite_line_timer(machine());
858		create_auto_animation_timer(machine());
	837	compute_rgb_weights();
	838	create_sprite_line_timer();
	839	create_auto_animation_timer();
859	840	optimize_sprite_data();
860	841
861	842	/* initialize values that are not modified on a reset */
r20971	r20972
897	878
898	879	void neogeo_state::video_reset()
899	880	{
900		start_sprite_line_timer(machine());
901		start_auto_animation_timer(machine());
	881	start_sprite_line_timer();
	882	start_auto_animation_timer();
902	883	optimize_sprite_data();
903	884	}
904	885
r20971	r20972
915	896	/* fill with background color first */
916	897	bitmap.fill(m_pens[0x0fff], cliprect);
917	898
918		if (m_has_sprite_bus) draw_sprites(machine(), bitmap, cliprect.min_y);
	899	if (m_has_sprite_bus) draw_sprites(bitmap, cliprect.min_y);
919	900
920	901	if (m_has_text_bus) draw_fixed_layer(bitmap, cliprect.min_y);
921	902

trunk/src/mame/video/nemesis.c

r20971	r20972
311	311	}
312	312
313	313
314		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	314	void nemesis_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
315	315	{
316	316	/*
317	317	*  16 bytes per sprite, in memory from 56000-56fff
r20971	r20972
328	328	*  byte    E : not used.
329	329	*/
330	330
331		nemesis_state *state = machine.driver_data<nemesis_state>();
332		UINT16 *spriteram = state->m_spriteram;
	331	UINT16 *spriteram = m_spriteram;
333	332	int address;    /* start of sprite in spriteram */
334	333	int sx; /* sprite X-pos */
335	334	int sy; /* sprite Y-pos */
r20971	r20972
345	344
346	345	for (priority = 256 - 1; priority >= 0; priority--)
347	346	{
348		for (address = state->m_spriteram_words - 8; address >= 0; address -= 8)
	347	for (address = m_spriteram_words - 8; address >= 0; address -= 8)
349	348	{
350	349	if((spriteram[address] & 0xff) != priority)
351	350	continue;
r20971	r20972
379	378	if (zoom)
380	379	{
381	380	zoom = ((1 << 16) * 0x80 / zoom) + 0x02ab;
382		if (state->m_flipscreen)
	381	if (m_flipscreen)
383	382	{
384	383	sx = 256 - ((zoom * w) >> 16) - sx;
385	384	sy = 256 - ((zoom * h) >> 16) - sy;
r20971	r20972
387	386	flipy = !flipy;
388	387	}
389	388
390		pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[char_type],
	389	pdrawgfxzoom_transpen(bitmap,cliprect,machine().gfx[char_type],
391	390	code,
392	391	color,
393	392	flipx,flipy,
394	393	sx,sy,
395	394	zoom,zoom,
396		machine.priority_bitmap,0xffcc,0 );
	395	machine().priority_bitmap,0xffcc,0 );
397	396	}
398	397	}
399	398	}
r20971	r20972
452	451	}
453	452	}
454	453
455		draw_sprites(machine(),bitmap,cliprect);
	454	draw_sprites(bitmap,cliprect);
456	455
457	456	return 0;
458	457	}

trunk/src/mess/drivers/ng_aes.c

r20971	r20972
1156	1156	m_recurse = 0;
1157	1157
1158	1158	/* AES apparently always uses the cartridge's fixed bank mode */
1159		neogeo_set_fixed_layer_source(machine(),1);
	1159	neogeo_set_fixed_layer_source(1);
1160	1160
1161	1161	NeoSpriteRAM = memregion("sprites")->base();
1162	1162	YM2610ADPCMAROM = memregion("ymsnd")->base();

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team