MAME SVN History

199869 Revisions

r20829 Friday 8th February, 2013 at 13:12:13 UTC by Miodrag Milanović
Modernization of drivers part 8 (no whatsnew)

[src/mame/drivers]	itech32.c itech8.c
[src/mame/includes]	ikki.h irobot.h ironhors.h itech32.h itech8.h
[src/mame/machine]	irobot.c
[src/mame/video]	ikki.c irobot.c ironhors.c itech32.c itech8.c

trunk/src/mame/drivers/itech8.c
r20828	r20829
569	569	*
570	570	*************************************/
571	571
572		void itech8_update_interrupts(~~running_machine &machine,~~ int periodic, int tms34061, int blitter)
	572	void itech8_state::itech8_update_interrupts(int periodic, int tms34061, int blitter)
573	573	{
574		itech8_state *state = machine.driver_data<itech8_state>();
575		device_type main_cpu_type = machine.device("maincpu")->type();
	574	device_type main_cpu_type = machine().device("maincpu")->type();
576	575
577	576	/* update the states */
578		if (periodic != -1) state->m_periodic_int = periodic;
579		if (tms34061 != -1) state->m_tms34061_int = tms34061;
580		if (blitter != -1) state->m_blitter_int = blitter;
	577	if (periodic != -1) m_periodic_int = periodic;
	578	if (tms34061 != -1) m_tms34061_int = tms34061;
	579	if (blitter != -1) m_blitter_int = blitter;
581	580
582	581	/* handle the 6809 case */
583	582	if (main_cpu_type == M6809 \|\| main_cpu_type == HD6309)
584	583	{
585	584	/* just modify lines that have changed */
586		if (periodic != -1) machine.device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, periodic ? ASSERT_LINE : CLEAR_LINE);
587		if (tms34061 != -1) machine.device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, tms34061 ? ASSERT_LINE : CLEAR_LINE);
588		if (blitter != -1) machine.device("maincpu")->execute().set_input_line(M6809_FIRQ_LINE, blitter ? ASSERT_LINE : CLEAR_LINE);
	585	if (periodic != -1) machine().device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, periodic ? ASSERT_LINE : CLEAR_LINE);
	586	if (tms34061 != -1) machine().device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, tms34061 ? ASSERT_LINE : CLEAR_LINE);
	587	if (blitter != -1) machine().device("maincpu")->execute().set_input_line(M6809_FIRQ_LINE, blitter ? ASSERT_LINE : CLEAR_LINE);
589	588	}
590	589
591	590	/* handle the 68000 case */
592	591	else
593	592	{
594		machine.device("maincpu")->execute().set_input_line(2, state->m_blitter_int ? ASSERT_LINE : CLEAR_LINE);
595		machine.device("maincpu")->execute().set_input_line(3, state->m_periodic_int ? ASSERT_LINE : CLEAR_LINE);
	593	machine().device("maincpu")->execute().set_input_line(2, m_blitter_int ? ASSERT_LINE : CLEAR_LINE);
	594	machine().device("maincpu")->execute().set_input_line(3, m_periodic_int ? ASSERT_LINE : CLEAR_LINE);
596	595	}
597	596	}
598	597
r20828	r20829
606	605
607	606	TIMER_CALLBACK_MEMBER(itech8_state::irq_off)
608	607	{
609		itech8_update_interrupts(~~machine(),~~ 0, -1, -1);
	608	itech8_update_interrupts(0, -1, -1);
610	609	}
611	610
612	611
613	612	INTERRUPT_GEN_MEMBER(itech8_state::generate_nmi)
614	613	{
615	614	/* signal the NMI */
616		itech8_update_interrupts(~~machine(),~~ 1, -1, -1);
	615	itech8_update_interrupts(1, -1, -1);
617	616	machine().scheduler().timer_set(attotime::from_usec(1), timer_expired_delegate(FUNC(itech8_state::irq_off),this));
618	617
619	618	if (FULL_LOGGING) logerror("------------ VBLANK (%d) --------------\n", machine().primary_screen->vpos());

trunk/src/mame/drivers/itech32.c
r20828	r20829
374	374	*
375	375	*************************************/
376	376
377		~~INLINE~~ in~~t determ~~ine_i~~rq_s~~t~~ate(~~itech32_state *state, int vint, int xint, int qint)
	377	inline int itech32_state::determine_irq_state(int vint, int xint, int qint)
378	378	{
379	379	int level = 0;
380	380
381	381
382	382	/* determine which level is active */
383		if (state->m_vint_state) level = 1;
384		if (state->m_xint_state) level = 2;
385		if (state->m_qint_state) level = 3;
	383	if (m_vint_state) level = 1;
	384	if (m_xint_state) level = 2;
	385	if (m_qint_state) level = 3;
386	386
387	387	/* Driver's Edge shifts the interrupts a bit */
388		if (~~state->~~m_is_drivedge && level) level += 2;
	388	if (m_is_drivedge && level) level += 2;
389	389
390	390	return level;
391	391	}
392	392
393	393
394		void itech32_update_interrupts(~~running_machine &machine,~~ int vint, int xint, int qint)
	394	void itech32_state::itech32_update_interrupts(int vint, int xint, int qint)
395	395	{
396		itech32_state *state = machine.driver_data<itech32_state>();
397	396	/* update the states */
398		if (vint != -1) state->m_vint_state = vint;
399		if (xint != -1) state->m_xint_state = xint;
400		if (qint != -1) state->m_qint_state = qint;
	397	if (vint != -1) m_vint_state = vint;
	398	if (xint != -1) m_xint_state = xint;
	399	if (qint != -1) m_qint_state = qint;
401	400
402		if (~~state->~~m_is_drivedge)
	401	if (m_is_drivedge)
403	402	{
404		machine.device("maincpu")->execute().set_input_line(3, state->m_vint_state ? ASSERT_LINE : CLEAR_LINE);
405		machine.device("maincpu")->execute().set_input_line(4, state->m_xint_state ? ASSERT_LINE : CLEAR_LINE);
406		machine.device("maincpu")->execute().set_input_line(5, state->m_qint_state ? ASSERT_LINE : CLEAR_LINE);
	403	machine().device("maincpu")->execute().set_input_line(3, m_vint_state ? ASSERT_LINE : CLEAR_LINE);
	404	machine().device("maincpu")->execute().set_input_line(4, m_xint_state ? ASSERT_LINE : CLEAR_LINE);
	405	machine().device("maincpu")->execute().set_input_line(5, m_qint_state ? ASSERT_LINE : CLEAR_LINE);
407	406	}
408	407	else
409	408	{
410		machine.device("maincpu")->execute().set_input_line(1, state->m_vint_state ? ASSERT_LINE : CLEAR_LINE);
411		machine.device("maincpu")->execute().set_input_line(2, state->m_xint_state ? ASSERT_LINE : CLEAR_LINE);
412		machine.device("maincpu")->execute().set_input_line(3, state->m_qint_state ? ASSERT_LINE : CLEAR_LINE);
	409	machine().device("maincpu")->execute().set_input_line(1, m_vint_state ? ASSERT_LINE : CLEAR_LINE);
	410	machine().device("maincpu")->execute().set_input_line(2, m_xint_state ? ASSERT_LINE : CLEAR_LINE);
	411	machine().device("maincpu")->execute().set_input_line(3, m_qint_state ? ASSERT_LINE : CLEAR_LINE);
413	412	}
414	413	}
415	414
r20828	r20829
417	416	INTERRUPT_GEN_MEMBER(itech32_state::generate_int1)
418	417	{
419	418	/* signal the NMI */
420		itech32_update_interrupts(~~machine(),~~ 1, -1, -1);
	419	itech32_update_interrupts(1, -1, -1);
421	420	if (FULL_LOGGING) logerror("------------ VBLANK (%d) --------------\n", machine().primary_screen->vpos());
422	421	}
423	422
424	423
425	424	WRITE16_MEMBER(itech32_state::int1_ack_w)
426	425	{
427		itech32_update_interrupts(~~machine(),~~ 0, -1, -1);
	426	itech32_update_interrupts(0, -1, -1);
428	427	}
429	428
430	429
r20828	r20829
873	872
874	873	void itech32_state::nvram_init(nvram_device &nvram, void *base, size_t length)
875	874	{
876		itech32_state *state = machine().driver_data<itech32_state>();
877	875	// if nvram is the main RAM, don't overwrite exception vectors
878		int start = (base == ~~state->~~m_main_ram) ? 0x80 : 0x00;
	876	int start = (base == m_main_ram) ? 0x80 : 0x00;
879	877	for (int i = start; i < length; i++)
880	878	((UINT8 *)base)[i] = machine().rand();
881	879
882	880	// due to accessing uninitialized RAM, we need this hack
883		if (state->m_is_drivedge)
884		((UINT32 *)state->m_main_ram.target())[0x2ce4/4] = 0x0000001e;
	881	if (m_is_drivedge)
	882	((UINT32 *)m_main_ram.target())[0x2ce4/4] = 0x0000001e;
885	883	}
886	884
887	885
r20828	r20829
4111	4109	*
4112	4110	*************************************/
4113	4111
4114		~~static~~ void init_program_rom(~~running_machine &machine~~)
	4112	void itech32_state::init_program_rom()
4115	4113	{
4116		itech32_state *state = machine.driver_data<itech32_state>();
4117		if (state->m_main_ram == NULL)
4118		state->m_main_ram.set_target(state->m_nvram, state->m_nvram.bytes());
4119		memcpy(state->m_main_ram, state->m_main_rom, 0x80);
	4114	if (m_main_ram == NULL)
	4115	m_main_ram.set_target(m_nvram, m_nvram.bytes());
	4116	memcpy(m_main_ram, m_main_rom, 0x80);
4120	4117	}
4121	4118
4122	4119
4123	4120	DRIVER_INIT_MEMBER(itech32_state,timekill)
4124	4121	{
4125		init_program_rom(~~machine()~~);
	4122	init_program_rom();
4126	4123	m_vram_height = 512;
4127	4124	m_planes = 2;
4128	4125	m_is_drivedge = 0;
r20828	r20829
4131	4128
4132	4129	DRIVER_INIT_MEMBER(itech32_state,hardyard)
4133	4130	{
4134		init_program_rom(~~machine()~~);
	4131	init_program_rom();
4135	4132	m_vram_height = 1024;
4136	4133	m_planes = 1;
4137	4134	m_is_drivedge = 0;
r20828	r20829
4140	4137
4141	4138	DRIVER_INIT_MEMBER(itech32_state,bloodstm)
4142	4139	{
4143		init_program_rom(~~machine()~~);
	4140	init_program_rom();
4144	4141	m_vram_height = 1024;
4145	4142	m_planes = 1;
4146	4143	m_is_drivedge = 0;
r20828	r20829
4149	4146
4150	4147	DRIVER_INIT_MEMBER(itech32_state,drivedge)
4151	4148	{
4152		init_program_rom(~~machine()~~);
	4149	init_program_rom();
4153	4150	m_vram_height = 1024;
4154	4151	m_planes = 1;
4155	4152	m_is_drivedge = 1;
r20828	r20829
4167	4164	ROM P/N 1079 Rev 1 (contains graphic roms, 4MHz OSC + ITBWL-1 security PIC chip)
4168	4165	Sound P/N 1060 Rev 0 (see Hot Memory PCB layout above)
4169	4166	*/
4170		init_program_rom(~~machine()~~);
	4167	init_program_rom();
4171	4168	m_vram_height = 1024;
4172	4169	m_planes = 1;
4173	4170
r20828	r20829
4187	4184	ROM P/N 1079 Rev 1 (contains graphic roms, 4MHz OSC + ITBWL-1 security PIC chip)
4188	4185	Sound P/N 1060 Rev 0 (see Hot Memory PCB layout above)
4189	4186	*/
4190		init_program_rom(~~machine()~~);
	4187	init_program_rom();
4191	4188	m_vram_height = 1024;
4192	4189	m_planes = 1;
4193	4190
r20828	r20829
4200	4197	}
4201	4198
4202	4199
4203		~~static~~ void init_sftm_common(~~running_machine &machine,~~ int prot_addr)
	4200	void itech32_state::init_sftm_common(int prot_addr)
4204	4201	{
4205		itech32_state *state = machine.driver_data<itech32_state>();
4206		init_program_rom(machine);
4207		state->m_vram_height = 1024;
4208		state->m_planes = 1;
4209		state->m_is_drivedge = 0;
	4202	init_program_rom();
	4203	m_vram_height = 1024;
	4204	m_planes = 1;
	4205	m_is_drivedge = 0;
4210	4206
4211		~~state->~~m_itech020_prot_address = prot_addr;
	4207	m_itech020_prot_address = prot_addr;
4212	4208
4213		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x300000, 0x300003, write32_delegate(FUNC(itech32_state::itech020_color2_w),state));
4214		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x380000, 0x380003, write32_delegate(FUNC(itech32_state::itech020_color1_w),state));
	4209	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x300000, 0x300003, write32_delegate(FUNC(itech32_state::itech020_color2_w),this));
	4210	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x380000, 0x380003, write32_delegate(FUNC(itech32_state::itech020_color1_w),this));
4215	4211	}
4216	4212
4217	4213
4218	4214	DRIVER_INIT_MEMBER(itech32_state,sftm)
4219	4215	{
4220		init_sftm_common(~~machine(),~~ 0x7a6a);
	4216	init_sftm_common(0x7a6a);
4221	4217	}
4222	4218
4223	4219
4224	4220	DRIVER_INIT_MEMBER(itech32_state,sftm110)
4225	4221	{
4226		init_sftm_common(~~machine(),~~ 0x7a66);
	4222	init_sftm_common(0x7a66);
4227	4223	}
4228	4224
4229	4225
4230		~~static~~ void init_shuffle_bowl_common(~~running_machine &machine,~~ int prot_addr)
	4226	void itech32_state::init_shuffle_bowl_common(int prot_addr)
4231	4227	{
4232		itech32_state *state = machine.driver_data<itech32_state>();
4233	4228	/*
4234	4229	The newest versions of World Class Bowling are on the same exact
4235	4230	platform as Shuffle Shot. So We'll use the same general INIT
4236	4231	routine for these two programs. IE: PCB P/N 1083 Rev 2
4237	4232	*/
4238		init_program_rom(machine);
4239		state->m_vram_height = 1024;
4240		state->m_planes = 1;
4241		state->m_is_drivedge = 0;
	4233	init_program_rom();
	4234	m_vram_height = 1024;
	4235	m_planes = 1;
	4236	m_is_drivedge = 0;
4242	4237
4243		~~state->~~m_itech020_prot_address = prot_addr;
	4238	m_itech020_prot_address = prot_addr;
4244	4239
4245		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x300000, 0x300003, write32_delegate(FUNC(itech32_state::itech020_color2_w),state));
4246		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x380000, 0x380003, write32_delegate(FUNC(itech32_state::itech020_color1_w),state));
4247		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x180800, 0x180803, read32_delegate(FUNC(itech32_state::trackball32_4bit_p1_r),state));
4248		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x181000, 0x181003, read32_delegate(FUNC(itech32_state::trackball32_4bit_p2_r),state));
	4240	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x300000, 0x300003, write32_delegate(FUNC(itech32_state::itech020_color2_w),this));
	4241	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x380000, 0x380003, write32_delegate(FUNC(itech32_state::itech020_color1_w),this));
	4242	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x180800, 0x180803, read32_delegate(FUNC(itech32_state::trackball32_4bit_p1_r),this));
	4243	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x181000, 0x181003, read32_delegate(FUNC(itech32_state::trackball32_4bit_p2_r),this));
4249	4244	}
4250	4245
4251	4246
4252	4247	DRIVER_INIT_MEMBER(itech32_state,shufshot)
4253	4248	{
4254		init_shuffle_bowl_common(~~machine(),~~ 0x111a);
	4249	init_shuffle_bowl_common(0x111a);
4255	4250	}
4256	4251
4257	4252
4258	4253	DRIVER_INIT_MEMBER(itech32_state,wcbowln)
4259	4254	{
4260	4255	/* The security PROM is NOT interchangeable between the Deluxe and "normal" versions. */
4261		init_shuffle_bowl_common(~~machine(),~~ 0x1116);
	4256	init_shuffle_bowl_common(0x1116);
4262	4257	}
4263	4258
4264		~~static~~ void install_timekeeper(~~running_machine &machine~~)
	4259	void itech32_state::install_timekeeper()
4265	4260	{
4266		device_t *device = machine.device("m48t02");
4267		machine.device("maincpu")->memory().space(AS_PROGRAM).install_legacy_readwrite_handler(*device, 0x681000, 0x6817ff, FUNC(timekeeper_r), FUNC(timekeeper_w), 0xffffffff);
	4261	device_t *device = machine().device("m48t02");
	4262	machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_readwrite_handler(*device, 0x681000, 0x6817ff, FUNC(timekeeper_r), FUNC(timekeeper_w), 0xffffffff);
4268	4263	}
4269	4264
4270	4265	DRIVER_INIT_MEMBER(itech32_state,wcbowlt)
4271	4266	{
4272	4267	/* Tournament Version, Same protection memory address as WCB Deluxe, but uses the standard WCB pic ITBWL-3 */
4273		init_shuffle_bowl_common(~~machine(),~~ 0x111a);
	4268	init_shuffle_bowl_common(0x111a);
4274	4269
4275		install_timekeeper(~~machine()~~);
	4270	install_timekeeper();
4276	4271	}
4277	4272
4278		~~static~~ void init_gt_common(~~running_machine &machine~~)
	4273	void itech32_state::init_gt_common()
4279	4274	{
4280		itech32_state *state = machine.driver_data<itech32_state>();
4281		init_program_rom(machine);
4282		state->m_vram_height = 1024;
4283		state->m_planes = 2;
4284		state->m_is_drivedge = 0;
	4275	init_program_rom();
	4276	m_vram_height = 1024;
	4277	m_planes = 2;
	4278	m_is_drivedge = 0;
4285	4279
4286		~~state->~~m_itech020_prot_address = 0x112f;
	4280	m_itech020_prot_address = 0x112f;
4287	4281	}
4288	4282
4289	4283
r20828	r20829
4297	4291	through GTClassic. This is _NOT_ a factory modification
4298	4292	*/
4299	4293	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x200000, 0x200003, read32_delegate(FUNC(itech32_state::trackball32_8bit_r),this));
4300		init_gt_common(~~machine()~~);
	4294	init_gt_common();
4301	4295	}
4302	4296
4303	4297
r20828	r20829
4311	4305	*/
4312	4306	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x180800, 0x180803, read32_delegate(FUNC(itech32_state::trackball32_4bit_p1_r),this));
4313	4307	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x181000, 0x181003, read32_delegate(FUNC(itech32_state::trackball32_4bit_p2_r),this));
4314		init_gt_common(~~machine()~~);
	4308	init_gt_common();
4315	4309	}
4316	4310
4317	4311
r20828	r20829
4322	4316	*/
4323	4317	DRIVER_INIT_CALL(aama);
4324	4318
4325		install_timekeeper(~~machine()~~);
	4319	install_timekeeper();
4326	4320	}
4327	4321
4328	4322
r20828	r20829
4335	4329	Trackball info is read through 200202 (actually 200203).
4336	4330	*/
4337	4331	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x200200, 0x200203, read32_delegate(FUNC(itech32_state::trackball32_4bit_p1_r),this));
4338		init_gt_common(~~machine()~~);
	4332	init_gt_common();
4339	4333	}
4340	4334
4341	4335
r20828	r20829
4349	4343	Player 2 trackball read through 200002
4350	4344	*/
4351	4345	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x200000, 0x200003, read32_delegate(FUNC(itech32_state::trackball32_4bit_combined_r),this));
4352		init_gt_common(~~machine()~~);
	4346	init_gt_common();
4353	4347	}
4354	4348
4355	4349

trunk/src/mame/machine/irobot.c
r20828	r20829
27	27	"%s, scanline: %d\n", (m).describe_context(), (m).primary_screen->vpos())
28	28
29	29
30		static void irmb_run(running_machine &machine);
31
32
33		/***********************************************************************/
34
35
36
37	30	READ8_MEMBER(irobot_state::irobot_sharedmem_r)
38	31	{
39	32	if (m_outx == 3)
r20828	r20829
76	69	m_combase_mb = m_comRAM[(data >> 7) ^ 1];
77	70	m_bufsel = data & 0x02;
78	71	if (((data & 0x01) == 0x01) && (m_vg_clear == 0))
79		irobot_poly_clear(~~machine()~~);
	72	irobot_poly_clear();
80	73
81	74	m_vg_clear = data & 0x01;
82	75
83	76	if ((data & 0x04) && !(m_statwr & 0x04))
84	77	{
85		irobot_run_video(~~machine()~~);
	78	irobot_run_video();
86	79	#if IR_TIMING
87	80	if (m_irvg_running == 0)
88	81	logerror("vg start ");
r20828	r20829
94	87	m_irvg_running=1;
95	88	}
96	89	if ((data & 0x10) && !(m_statwr & 0x10))
97		irmb_run(~~machine()~~);
	90	irmb_run();
98	91	m_statwr = data;
99	92	}
100	93
r20828	r20829
287	280	#endif
288	281
289	282
290		~~static~~ UINT32 ir~~mb_din(ir~~obot_state state, const irmb_ops curop)
	283	UINT32 irobot_state::irmb_din(const irmb_ops *curop)
291	284	{
292	285	UINT32 d = 0;
293	286
294	287	if (!(curop->flags & FL_MBMEMDEC) && (curop->flags & FL_MBRW))
295	288	{
296		UINT32 ad = curop->diradd \| (~~state->~~m_irmb_latch & curop->latchmask);
	289	UINT32 ad = curop->diradd \| (m_irmb_latch & curop->latchmask);
297	290
298		if (curop->diren \|\| (state->m_irmb_latch & 0x6000) == 0)
299		d = ((UINT16 )state->m_mbRAM)[ad & 0xfff]; / MB RAM read */
300		else if (state->m_irmb_latch & 0x4000)
301		d = ((UINT16 )state->m_mbROM)[ad + 0x2000]; / MB ROM read, CEMATH = 1 */
	291	if (curop->diren \|\| (m_irmb_latch & 0x6000) == 0)
	292	d = ((UINT16 )m_mbRAM)[ad & 0xfff]; / MB RAM read */
	293	else if (m_irmb_latch & 0x4000)
	294	d = ((UINT16 )m_mbROM)[ad + 0x2000]; / MB ROM read, CEMATH = 1 */
302	295	else
303		d = ((UINT16 )~~state->~~m_mbROM)[ad & 0x1fff]; / MB ROM read, CEMATH = 0 */
	296	d = ((UINT16 )m_mbROM)[ad & 0x1fff]; / MB ROM read, CEMATH = 0 */
304	297	}
305	298	return d;
306	299	}
307	300
308	301
309		~~static~~ void ir~~mb_d~~o~~ut(iro~~bot_state st~~ate,~~ const irmb_ops curop, UINT32 d)
	302	void irobot_state::irmb_dout(const irmb_ops *curop, UINT32 d)
310	303	{
311	304	/* Write to video com ram */
312	305	if (curop->ramsel == 3)
313		((UINT16 *)~~state->~~m_combase_mb)[~~state->~~m_irmb_latch & 0x7ff] = d;
	306	((UINT16 *)m_combase_mb)[m_irmb_latch & 0x7ff] = d;
314	307
315	308	/* Write to mathox ram */
316	309	if (!(curop->flags & FL_MBMEMDEC))
317	310	{
318		UINT32 ad = curop->diradd \| (~~state->~~m_irmb_latch & curop->latchmask);
	311	UINT32 ad = curop->diradd \| (m_irmb_latch & curop->latchmask);
319	312
320		if (curop->diren \|\| (state->m_irmb_latch & 0x6000) == 0)
321		((UINT16 )state->m_mbRAM)[ad & 0xfff] = d; / MB RAM write */
	313	if (curop->diren \|\| (m_irmb_latch & 0x6000) == 0)
	314	((UINT16 )m_mbRAM)[ad & 0xfff] = d; / MB RAM write */
322	315	}
323	316	}
324	317
325	318
326	319	/* Convert microcode roms to a more usable form */
327		~~static~~ void load_oproms(~~running_machine &machine~~)
	320	void irobot_state::load_oproms()
328	321	{
329		irobot_state *state = machine.driver_data<irobot_state>();
330		UINT8 *MB = state->memregion("proms")->base() + 0x20;
	322	UINT8 *MB = memregion("proms")->base() + 0x20;
331	323	int i;
332	324
333	325	/* allocate RAM */
334		~~state->~~m_mbops = auto_alloc_array(machine, irmb_ops, 1024);
	326	m_mbops = auto_alloc_array(machine(), irmb_ops, 1024);
335	327
336	328	for (i = 0; i < 1024; i++)
337	329	{
338	330	int nxtadd, func, ramsel, diradd, latchmask, dirmask, time;
339	331
340		state->m_mbops[i].areg = &state->m_irmb_regs[MB[0x0000 + i] & 0x0F];
341		state->m_mbops[i].breg = &state->m_irmb_regs[MB[0x0400 + i] & 0x0F];
	332	m_mbops[i].areg = &m_irmb_regs[MB[0x0000 + i] & 0x0F];
	333	m_mbops[i].breg = &m_irmb_regs[MB[0x0400 + i] & 0x0F];
342	334	func = (MB[0x0800 + i] & 0x0F) << 5;
343	335	func \|= ((MB[0x0C00 +i] & 0x0F) << 1);
344	336	func \|= (MB[0x1000 + i] & 0x08) >> 3;
345	337	time = MB[0x1000 + i] & 0x03;
346		~~state->~~m_mbops[i].flags = (MB[0x1000 + i] & 0x04) >> 2;
	338	m_mbops[i].flags = (MB[0x1000 + i] & 0x04) >> 2;
347	339	nxtadd = (MB[0x1400 + i] & 0x0C) >> 2;
348	340	diradd = MB[0x1400 + i] & 0x03;
349	341	nxtadd \|= ((MB[0x1800 + i] & 0x0F) << 6);
350	342	nxtadd \|= ((MB[0x1C00 + i] & 0x0F) << 2);
351	343	diradd \|= (MB[0x2000 + i] & 0x0F) << 2;
352	344	func \|= (MB[0x2400 + i] & 0x0E) << 9;
353		state->m_mbops[i].flags \|= (MB[0x2400 + i] & 0x01) << 1;
354		state->m_mbops[i].flags \|= (MB[0x2800 + i] & 0x0F) << 2;
355		state->m_mbops[i].flags \|= ((MB[0x2C00 + i] & 0x01) << 6);
356		state->m_mbops[i].flags \|= (MB[0x2C00 + i] & 0x08) << 4;
	345	m_mbops[i].flags \|= (MB[0x2400 + i] & 0x01) << 1;
	346	m_mbops[i].flags \|= (MB[0x2800 + i] & 0x0F) << 2;
	347	m_mbops[i].flags \|= ((MB[0x2C00 + i] & 0x01) << 6);
	348	m_mbops[i].flags \|= (MB[0x2C00 + i] & 0x08) << 4;
357	349	ramsel = (MB[0x2C00 + i] & 0x06) >> 1;
358	350	diradd \|= (MB[0x3000 + i] & 0x03) << 6;
359	351
360		if (~~state->~~m_mbops[i].flags & FL_shift) func \|= 0x200;
	352	if (m_mbops[i].flags & FL_shift) func \|= 0x200;
361	353
362		state->m_mbops[i].func = func;
363		state->m_mbops[i].nxtop = &state->m_mbops[nxtadd];
	354	m_mbops[i].func = func;
	355	m_mbops[i].nxtop = &m_mbops[nxtadd];
364	356
365	357	/* determine the number of 12MHz cycles for this operation */
366	358	if (time == 3)
367		~~state->~~m_mbops[i].cycles = 2;
	359	m_mbops[i].cycles = 2;
368	360	else
369		~~state->~~m_mbops[i].cycles = 3 + time;
	361	m_mbops[i].cycles = 3 + time;
370	362
371	363	/* precompute the hardcoded address bits and the mask to be used on the latch value */
372	364	if (ramsel == 0)
r20828	r20829
384	376	else
385	377	dirmask \|= 0x0003;
386	378
387		state->m_mbops[i].ramsel = ramsel;
388		state->m_mbops[i].diradd = diradd & dirmask;
389		state->m_mbops[i].latchmask = latchmask;
390		state->m_mbops[i].diren = (ramsel == 0);
	379	m_mbops[i].ramsel = ramsel;
	380	m_mbops[i].diradd = diradd & dirmask;
	381	m_mbops[i].latchmask = latchmask;
	382	m_mbops[i].diren = (ramsel == 0);
391	383
392	384	#if DISASSEMBLE_MB_ROM
393		disassemble_instruction(&~~state->~~m_mbops[i]);
	385	disassemble_instruction(&m_mbops[i]);
394	386	#endif
395	387	}
396	388	}
r20828	r20829
406	398	m_irmb_regs[i] = 0;
407	399	}
408	400	m_irmb_latch=0;
409		load_oproms(~~machine()~~);
	401	load_oproms();
410	402	}
411	403
412	404	TIMER_DEVICE_CALLBACK_MEMBER(irobot_state::irobot_irmb_done_callback)
r20828	r20829
525	517	#define JUMP3 if (!nflag) curop = curop->nxtop; else curop++;
526	518	#define JUMP4 if (nflag) curop = curop->nxtop; else curop++;
527	519	#define JUMP5 curop = curop->nxtop;
528		#define JUMP6 state->m_irmb_stack[SP] = curop + 1; SP = (SP + 1) & 15; curop = curop->nxtop;
529		#define JUMP7 SP = (SP - 1) & 15; curop = state->m_irmb_stack[SP];
	520	#define JUMP6 m_irmb_stack[SP] = curop + 1; SP = (SP + 1) & 15; curop = curop->nxtop;
	521	#define JUMP7 SP = (SP - 1) & 15; curop = m_irmb_stack[SP];
530	522
531	523
532	524	/* Run mathbox */
533		~~static~~ void irmb_run(~~running_machine &machine~~)
	525	void irobot_state::irmb_run()
534	526	{
535		irobot_state *state = machine.driver_data<irobot_state>();
536		const irmb_ops *prevop = &state->m_mbops[0];
537		const irmb_ops *curop = &state->m_mbops[0];
	527	const irmb_ops *prevop = &m_mbops[0];
	528	const irmb_ops *curop = &m_mbops[0];
538	529
539	530	UINT32 Q = 0;
540	531	UINT32 Y = 0;
r20828	r20829
579	570	case 0x02: ADD(0, Q); break;
580	571	case 0x03: ADD(0, *curop->breg); break;
581	572	case 0x04: ADD(0, *curop->areg); break;
582		case 0x05: tmp = irmb_din(state, curop); ADD(tmp, *curop->areg); break;
583		case 0x06: tmp = irmb_din(state, curop); ADD(tmp, Q); break;
584		case 0x07: tmp = irmb_din(state, curop); ADD(tmp, 0); break;
	573	case 0x05: tmp = irmb_din(curop); ADD(tmp, *curop->areg); break;
	574	case 0x06: tmp = irmb_din(curop); ADD(tmp, Q); break;
	575	case 0x07: tmp = irmb_din(curop); ADD(tmp, 0); break;
585	576	case 0x08: SUBR(*curop->areg, Q); break;
586	577	case 0x09: SUBR(curop->areg, curop->breg); break;
587	578	case 0x0a: SUBR(0, Q); break;
588	579	case 0x0b: SUBR(0, *curop->breg); break;
589	580	case 0x0c: SUBR(0, *curop->areg); break;
590		case 0x0d: tmp = irmb_din(state, curop); SUBR(tmp, *curop->areg); break;
591		case 0x0e: tmp = irmb_din(state, curop); SUBR(tmp, Q); break;
592		case 0x0f: tmp = irmb_din(state, curop); SUBR(tmp, 0); break;
	581	case 0x0d: tmp = irmb_din(curop); SUBR(tmp, *curop->areg); break;
	582	case 0x0e: tmp = irmb_din(curop); SUBR(tmp, Q); break;
	583	case 0x0f: tmp = irmb_din(curop); SUBR(tmp, 0); break;
593	584	case 0x10: SUB(*curop->areg, Q); break;
594	585	case 0x11: SUB(curop->areg, curop->breg); break;
595	586	case 0x12: SUB(0, Q); break;
596	587	case 0x13: SUB(0, *curop->breg); break;
597	588	case 0x14: SUB(0, *curop->areg); break;
598		case 0x15: tmp = irmb_din(state, curop); SUB(tmp, *curop->areg); break;
599		case 0x16: tmp = irmb_din(state, curop); SUB(tmp, Q); break;
600		case 0x17: tmp = irmb_din(state, curop); SUB(tmp, 0); break;
	589	case 0x15: tmp = irmb_din(curop); SUB(tmp, *curop->areg); break;
	590	case 0x16: tmp = irmb_din(curop); SUB(tmp, Q); break;
	591	case 0x17: tmp = irmb_din(curop); SUB(tmp, 0); break;
601	592	case 0x18: OR(*curop->areg, Q); break;
602	593	case 0x19: OR(curop->areg, curop->breg); break;
603	594	case 0x1a: OR(0, Q); break;
604	595	case 0x1b: OR(0, *curop->breg); break;
605	596	case 0x1c: OR(0, *curop->areg); break;
606		case 0x1d: OR(irmb_din(state, curop), *curop->areg); break;
607		case 0x1e: OR(irmb_din(state, curop), Q); break;
608		case 0x1f: OR(irmb_din(state, curop), 0); break;
	597	case 0x1d: OR(irmb_din(curop), *curop->areg); break;
	598	case 0x1e: OR(irmb_din(curop), Q); break;
	599	case 0x1f: OR(irmb_din(curop), 0); break;
609	600	case 0x20: AND(*curop->areg, Q); break;
610	601	case 0x21: AND(curop->areg, curop->breg); break;
611	602	case 0x22: AND(0, Q); break;
612	603	case 0x23: AND(0, *curop->breg); break;
613	604	case 0x24: AND(0, *curop->areg); break;
614		case 0x25: AND(irmb_din(state, curop), *curop->areg); break;
615		case 0x26: AND(irmb_din(state, curop), Q); break;
616		case 0x27: AND(irmb_din(state, curop), 0); break;
	605	case 0x25: AND(irmb_din(curop), *curop->areg); break;
	606	case 0x26: AND(irmb_din(curop), Q); break;
	607	case 0x27: AND(irmb_din(curop), 0); break;
617	608	case 0x28: IAND(*curop->areg, Q); break;
618	609	case 0x29: IAND(curop->areg, curop->breg); break;
619	610	case 0x2a: IAND(0, Q); break;
620	611	case 0x2b: IAND(0, *curop->breg); break;
621	612	case 0x2c: IAND(0, *curop->areg); break;
622		case 0x2d: IAND(irmb_din(state, curop), *curop->areg); break;
623		case 0x2e: IAND(irmb_din(state, curop), Q); break;
624		case 0x2f: IAND(irmb_din(state, curop), 0); break;
	613	case 0x2d: IAND(irmb_din(curop), *curop->areg); break;
	614	case 0x2e: IAND(irmb_din(curop), Q); break;
	615	case 0x2f: IAND(irmb_din(curop), 0); break;
625	616	case 0x30: XOR(*curop->areg, Q); break;
626	617	case 0x31: XOR(curop->areg, curop->breg); break;
627	618	case 0x32: XOR(0, Q); break;
628	619	case 0x33: XOR(0, *curop->breg); break;
629	620	case 0x34: XOR(0, *curop->areg); break;
630		case 0x35: XOR(irmb_din(state, curop), *curop->areg); break;
631		case 0x36: XOR(irmb_din(state, curop), Q); break;
632		case 0x37: XOR(irmb_din(state, curop), 0); break;
	621	case 0x35: XOR(irmb_din(curop), *curop->areg); break;
	622	case 0x36: XOR(irmb_din(curop), Q); break;
	623	case 0x37: XOR(irmb_din(curop), 0); break;
633	624	case 0x38: IXOR(*curop->areg, Q); break;
634	625	case 0x39: IXOR(curop->areg, curop->breg); break;
635	626	case 0x3a: IXOR(0, Q); break;
636	627	case 0x3b: IXOR(0, *curop->breg); break;
637	628	case 0x3c: IXOR(0, *curop->areg); break;
638		case 0x3d: IXOR(irmb_din(state, curop), *curop->areg); break;
639		case 0x3e: IXOR(irmb_din(state, curop), Q); break;
640		default: case 0x3f: IXOR(irmb_din(state, curop), 0); break;
	629	case 0x3d: IXOR(irmb_din(curop), *curop->areg); break;
	630	case 0x3e: IXOR(irmb_din(curop), Q); break;
	631	default: case 0x3f: IXOR(irmb_din(curop), 0); break;
641	632	}
642	633
643	634	/* Evaluate flags */
r20828	r20829
788	779
789	780	/* Do write */
790	781	if (!(prevop->flags & FL_MBRW))
791		irmb_dout(~~state,~~ prevop, Y);
	782	irmb_dout(prevop, Y);
792	783
793	784	/* ADDEN */
794	785	if (!(prevop->flags & FL_ADDEN))
795	786	{
796	787	if (prevop->flags & FL_MBRW)
797		~~state->~~m_irmb_latch = irmb_din(~~state,~~ prevop);
	788	m_irmb_latch = irmb_din(prevop);
798	789	else
799		~~state->~~m_irmb_latch = Y;
	790	m_irmb_latch = Y;
800	791	}
801	792	}
802	793	g_profiler.stop();
r20828	r20829
805	796
806	797
807	798	#if IR_TIMING
808		if (~~state->~~m_irmb_running == 0)
	799	if (m_irmb_running == 0)
809	800	{
810		~~state->~~m_irmb_timer->adjust(attotime::from_hz(12000000) * icount);
	801	m_irmb_timer->adjust(attotime::from_hz(12000000) * icount);
811	802	logerror("mb start ");
812		IR_CPU_STATE(machine);
	803	IR_CPU_STATE(machine());
813	804	}
814	805	else
815	806	{
816	807	logerror("mb start [busy!] ");
817		IR_CPU_STATE(machine);
818		state->m_irmb_timer->adjust(attotime::from_hz(200) * icount);
	808	IR_CPU_STATE(machine());
	809	m_irmb_timer->adjust(attotime::from_hz(200) * icount);
819	810	}
820	811	#else
821		machine.device("maincpu")->execute().set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
	812	machine().device("maincpu")->execute().set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
822	813	#endif
823		~~state->~~m_irmb_running=1;
	814	m_irmb_running=1;
824	815	}
825	816
826	817

trunk/src/mame/includes/itech32.h
r20828	r20829
163	163	INTERRUPT_GEN_MEMBER(generate_int1);
164	164	TIMER_CALLBACK_MEMBER(delayed_sound_data_w);
165	165	TIMER_CALLBACK_MEMBER(scanline_interrupt);
	166	inline offs_t compute_safe_address(int x, int y);
	167	inline void disable_clipping();
	168	inline void enable_clipping();
	169	void logblit(const char *tag);
	170	void update_interrupts(int fast);
	171	void draw_raw(UINT16 *base, UINT16 color);
	172	void draw_raw_drivedge(UINT16 base, UINT16 zbase, UINT16 color);
	173	inline void draw_rle_fast(UINT16 *base, UINT16 color);
	174	inline void draw_rle_fast_xflip(UINT16 *base, UINT16 color);
	175	inline void draw_rle_slow(UINT16 *base, UINT16 color);
	176	void draw_rle(UINT16 *base, UINT16 color);
	177	void shiftreg_clear(UINT16 base, UINT16 zbase);
	178	void handle_video_command();
	179	inline int determine_irq_state(int vint, int xint, int qint);
	180	void itech32_update_interrupts(int vint, int xint, int qint);
	181	void init_program_rom();
	182	void init_sftm_common(int prot_addr);
	183	void init_shuffle_bowl_common(int prot_addr);
	184	void install_timekeeper();
	185	void init_gt_common();
166	186	};
167	187
168		/----------- defined in drivers/itech32.c -----------/
169		void itech32_update_interrupts(running_machine &machine, int vint, int xint, int qint);

trunk/src/mame/includes/ikki.h
r20828	r20829
37	37	virtual void palette_init();
38	38	UINT32 screen_update_ikki(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
39	39	TIMER_DEVICE_CALLBACK_MEMBER(ikki_irq);
	40	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
40	41	};

trunk/src/mame/includes/irobot.h
r20828	r20829
83	83	TIMER_CALLBACK_MEMBER(scanline_callback);
84	84	TIMER_DEVICE_CALLBACK_MEMBER(irobot_irvg_done_callback);
85	85	TIMER_DEVICE_CALLBACK_MEMBER(irobot_irmb_done_callback);
	86	void _irobot_poly_clear(UINT8 *bitmap_base);
	87	void irobot_poly_clear();
	88	void draw_line(UINT8 *polybitmap, int x1, int y1, int x2, int y2, int col);
	89	void irobot_run_video();
	90	UINT32 irmb_din(const irmb_ops *curop);
	91	void irmb_dout(const irmb_ops *curop, UINT32 d);
	92	void load_oproms();
	93	void irmb_run();
86	94	};
87
88		/----------- defined in video/irobot.c -----------/
89		void irobot_poly_clear(running_machine &machine);
90		void irobot_run_video(running_machine &machine);

trunk/src/mame/includes/ironhors.h
r20828	r20829
52	52	UINT32 screen_update_farwest(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
53	53	TIMER_DEVICE_CALLBACK_MEMBER(ironhors_irq);
54	54	TIMER_DEVICE_CALLBACK_MEMBER(farwest_irq);
	55	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	56	void farwest_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
55	57	};

trunk/src/mame/includes/itech8.h
r20828	r20829
104	104	TIMER_CALLBACK_MEMBER(delayed_sound_data_w);
105	105	TIMER_CALLBACK_MEMBER(blitter_done);
106	106	TIMER_DEVICE_CALLBACK_MEMBER(grmatch_palette_update);
	107	inline UINT8 fetch_next_raw();
	108	inline void consume_raw(int count);
	109	inline UINT8 fetch_next_rle();
	110	inline void consume_rle(int count);
	111	void perform_blit(address_space &space);
	112	void itech8_update_interrupts(int periodic, int tms34061, int blitter);
107	113	};
108	114
109
110		/----------- defined in drivers/itech8.c -----------/
111
112		void itech8_update_interrupts(running_machine &machine, int periodic, int tms34061, int blitter);
113
114
115	115	/----------- defined in machine/slikshot.c -----------/
116	116
117	117	DECLARE_READ8_HANDLER( slikz80_port_r );

trunk/src/mame/video/ikki.c
r20828	r20829
61	61	}
62	62
63	63
64		~~static~~ void draw_sprites( ~~running_machine &machine,~~ bitmap_ind16 &bitmap, const rectangle &cliprect )
	64	void ikki_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
65	65	{
66		ikki_state *state = machine.driver_data<ikki_state>();
67		UINT8 *spriteram = state->m_spriteram;
	66	UINT8 *spriteram = m_spriteram;
68	67	int y;
69	68	offs_t offs;
70	69
71		~~state->~~m_sprite_bitmap.fill(~~state->~~m_punch_through_pen, cliprect);
	70	m_sprite_bitmap.fill(m_punch_through_pen, cliprect);
72	71
73		for (offs = 0; offs < ~~state->~~m_spriteram.bytes(); offs += 4)
	72	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
74	73	{
75	74	int code = (spriteram[offs + 2] & 0x80) \| (spriteram[offs + 1] >> 1);
76	75	int color = spriteram[offs + 2] & 0x3f;
r20828	r20829
78	77	int x = spriteram[offs + 3];
79	78	y = spriteram[offs + 0];
80	79
81		if (~~state->~~m_flipscreen)
	80	if (m_flipscreen)
82	81	x = 240 - x;
83	82	else
84	83	y = 224 - y;
r20828	r20829
92	91	if (y > 240)
93	92	y = y - 256;
94	93
95		drawgfx_transmask(~~state->~~m_sprite_bitmap,cliprect, machine.gfx[1],
	94	drawgfx_transmask(m_sprite_bitmap,cliprect, machine().gfx[1],
96	95	code, color,
97		~~state->~~m_flipscreen,~~state->~~m_flipscreen,
	96	m_flipscreen,m_flipscreen,
98	97	x,y,
99		colortable_get_transpen_mask(machine.colortable, machine.gfx[1], color, 0));
	98	colortable_get_transpen_mask(machine().colortable, machine().gfx[1], color, 0));
100	99	}
101	100
102	101	/* copy the sprite bitmap into the main bitmap, skipping the transparent pixels */
r20828	r20829
106	105
107	106	for (x = cliprect.min_x; x <= cliprect.max_x; x++)
108	107	{
109		UINT16 pen = ~~state->~~m_sprite_bitmap.pix16(y, x);
	108	UINT16 pen = m_sprite_bitmap.pix16(y, x);
110	109
111		if (colortable_entry_get_value(machine.colortable, pen) != 0x100)
	110	if (colortable_entry_get_value(machine().colortable, pen) != 0x100)
112	111	bitmap.pix16(y, x) = pen;
113	112	}
114	113	}
r20828	r20829
182	181	x,y);
183	182	}
184	183
185		draw_sprites(~~machine(),~~ bitmap, cliprect);
	184	draw_sprites(bitmap, cliprect);
186	185
187	186	/* mask sprites */
188	187

trunk/src/mame/video/itech32.c
r20828	r20829
131	131
132	132	#define ADJUSTED_HEIGHT(x) ((((x) >> 1) & 0x100) \| ((x) & 0xff))
133	133
134		~~INLINE~~ offs_t compute_safe_address(~~itech32_state *state,~~ int x, int y)
	134	inline offs_t itech32_state::compute_safe_address(int x, int y)
135	135	{
136		return ((y & ~~state->~~m_vram_ymask) * 512) + (x & ~~state->~~m_vram_xmask);
	136	return ((y & m_vram_ymask) * 512) + (x & m_vram_xmask);
137	137	}
138	138
139		~~INLINE~~ void disable_clipping(~~itech32_state *state~~)
	139	inline void itech32_state::disable_clipping()
140	140	{
141		state->m_clip_save = state->m_clip_rect;
142		state->m_clip_rect.set(0, 0xfff, 0, 0xfff);
143		state->m_scaled_clip_rect.set(0, 0xfff << 8, 0, 0xfff << 8);
	141	m_clip_save = m_clip_rect;
	142	m_clip_rect.set(0, 0xfff, 0, 0xfff);
	143	m_scaled_clip_rect.set(0, 0xfff << 8, 0, 0xfff << 8);
144	144	}
145	145
146		~~INLINE~~ void enable_clipping(~~itech32_state *state~~)
	146	inline void itech32_state::enable_clipping()
147	147	{
148		~~state->~~m_clip_rect = ~~state->~~m_clip_save;
	148	m_clip_rect = m_clip_save;
149	149
150		state->m_scaled_clip_rect.min_x = state->m_clip_rect.min_x << 8;
151		state->m_scaled_clip_rect.max_x = state->m_clip_rect.max_x << 8;
152		state->m_scaled_clip_rect.min_y = state->m_clip_rect.min_y << 8;
153		state->m_scaled_clip_rect.max_y = state->m_clip_rect.max_y << 8;
	150	m_scaled_clip_rect.min_x = m_clip_rect.min_x << 8;
	151	m_scaled_clip_rect.max_x = m_clip_rect.max_x << 8;
	152	m_scaled_clip_rect.min_y = m_clip_rect.min_y << 8;
	153	m_scaled_clip_rect.max_y = m_clip_rect.max_y << 8;
154	154	}
155	155
156	156
r20828	r20829
365	365	*
366	366	*************************************/
367	367
368		~~static~~ void logblit(~~running_machine &machine,~~ const char *tag)
	368	void itech32_state::logblit(const char *tag)
369	369	{
370		itech32_state *state = machine.driver_data<itech32_state>();
371		if (!machine.input().code_pressed(KEYCODE_L))
	370	if (!machine().input().code_pressed(KEYCODE_L))
372	371	return;
373		if (~~state->~~m_is_drivedge && ~~state->~~VIDEO_TRANSFER_FLAGS == 0x5490)
	372	if (m_is_drivedge && VIDEO_TRANSFER_FLAGS == 0x5490)
374	373	{
375	374	/* polygon drawing */
376	375	logerror("%s: e=%d%d f=%04x s=(%03x-%03x,%03x) w=%03x h=%03x b=%02x%04x c=%02x%02x ss=%04x,%04x ds=%04x,%04x ls=%04x%04x rs=%04x%04x u80=%04x", tag,
377		state->m_enable_latch[0], state->m_enable_latch[1],
378		state->VIDEO_TRANSFER_FLAGS,
379		state->VIDEO_TRANSFER_X, state->VIDEO_RIGHTCLIP, state->VIDEO_TRANSFER_Y, state->VIDEO_TRANSFER_WIDTH, state->VIDEO_TRANSFER_HEIGHT,
380		state->VIDEO_TRANSFER_ADDRHI, state->VIDEO_TRANSFER_ADDRLO,
381		state->m_color_latch[0] >> 8, state->m_color_latch[1] >> 8,
382		state->VIDEO_SRC_XSTEP, state->VIDEO_SRC_YSTEP,
383		state->VIDEO_DST_XSTEP, state->VIDEO_DST_YSTEP,
384		state->VIDEO_LEFTSTEPHI, state->VIDEO_LEFTSTEPLO, state->VIDEO_RIGHTSTEPHI, state->VIDEO_RIGHTSTEPLO,
385		state->VIDEO_STARTSTEP);
	376	m_enable_latch[0], m_enable_latch[1],
	377	VIDEO_TRANSFER_FLAGS,
	378	VIDEO_TRANSFER_X, VIDEO_RIGHTCLIP, VIDEO_TRANSFER_Y, VIDEO_TRANSFER_WIDTH, VIDEO_TRANSFER_HEIGHT,
	379	VIDEO_TRANSFER_ADDRHI, VIDEO_TRANSFER_ADDRLO,
	380	m_color_latch[0] >> 8, m_color_latch[1] >> 8,
	381	VIDEO_SRC_XSTEP, VIDEO_SRC_YSTEP,
	382	VIDEO_DST_XSTEP, VIDEO_DST_YSTEP,
	383	VIDEO_LEFTSTEPHI, VIDEO_LEFTSTEPLO, VIDEO_RIGHTSTEPHI, VIDEO_RIGHTSTEPLO,
	384	VIDEO_STARTSTEP);
386	385	}
387	386
388		else if (state->m_video[0x16/2] == 0x100 && state->m_video[0x18/2] == 0x100 &&
389		state->m_video[0x1a/2] == 0x000 && state->m_video[0x1c/2] == 0x100 &&
390		state->m_video[0x1e/2] == 0x000 && state->m_video[0x20/2] == 0x000)
	387	else if (m_video[0x16/2] == 0x100 && m_video[0x18/2] == 0x100 &&
	388	m_video[0x1a/2] == 0x000 && m_video[0x1c/2] == 0x100 &&
	389	m_video[0x1e/2] == 0x000 && m_video[0x20/2] == 0x000)
391	390	{
392	391	logerror("%s: e=%d%d f=%04x c=%02x%02x %02x%04x -> (%03x,%03x) %3dx%3dc=(%03x,%03x)-(%03x,%03x)", tag,
393		state->m_enable_latch[0], state->m_enable_latch[1],
394		state->VIDEO_TRANSFER_FLAGS,
395		state->m_color_latch[0] >> 8, state->m_color_latch[1] >> 8,
396		state->VIDEO_TRANSFER_ADDRHI, state->VIDEO_TRANSFER_ADDRLO,
397		state->VIDEO_TRANSFER_X, state->VIDEO_TRANSFER_Y,
398		state->VIDEO_TRANSFER_WIDTH, ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT),
399		state->VIDEO_LEFTCLIP, state->VIDEO_TOPCLIP, state->VIDEO_RIGHTCLIP, state->VIDEO_BOTTOMCLIP);
	392	m_enable_latch[0], m_enable_latch[1],
	393	VIDEO_TRANSFER_FLAGS,
	394	m_color_latch[0] >> 8, m_color_latch[1] >> 8,
	395	VIDEO_TRANSFER_ADDRHI, VIDEO_TRANSFER_ADDRLO,
	396	VIDEO_TRANSFER_X, VIDEO_TRANSFER_Y,
	397	VIDEO_TRANSFER_WIDTH, ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT),
	398	VIDEO_LEFTCLIP, VIDEO_TOPCLIP, VIDEO_RIGHTCLIP, VIDEO_BOTTOMCLIP);
400	399	}
401	400	else
402	401	{
403	402	logerror("%s: e=%d%d f=%04x c=%02x%02x %02x%04x -> (%03x,%03x) %3dx%3d c=(%03x,%03x)-(%03x,%03x) s=%04x %04x %04x %04x %04x %04x", tag,
404		state->m_enable_latch[0], state->m_enable_latch[1],
405		state->VIDEO_TRANSFER_FLAGS,
406		state->m_color_latch[0] >> 8, state->m_color_latch[1] >> 8,
407		state->VIDEO_TRANSFER_ADDRHI, state->VIDEO_TRANSFER_ADDRLO,
408		state->VIDEO_TRANSFER_X, state->VIDEO_TRANSFER_Y,
409		state->VIDEO_TRANSFER_WIDTH, ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT),
410		state->VIDEO_LEFTCLIP, state->VIDEO_TOPCLIP, state->VIDEO_RIGHTCLIP, state->VIDEO_BOTTOMCLIP,
411		state->m_video[0x16/2], state->m_video[0x18/2], state->m_video[0x1a/2],
412		state->m_video[0x1c/2], state->m_video[0x1e/2], state->m_video[0x20/2]);
	403	m_enable_latch[0], m_enable_latch[1],
	404	VIDEO_TRANSFER_FLAGS,
	405	m_color_latch[0] >> 8, m_color_latch[1] >> 8,
	406	VIDEO_TRANSFER_ADDRHI, VIDEO_TRANSFER_ADDRLO,
	407	VIDEO_TRANSFER_X, VIDEO_TRANSFER_Y,
	408	VIDEO_TRANSFER_WIDTH, ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT),
	409	VIDEO_LEFTCLIP, VIDEO_TOPCLIP, VIDEO_RIGHTCLIP, VIDEO_BOTTOMCLIP,
	410	m_video[0x16/2], m_video[0x18/2], m_video[0x1a/2],
	411	m_video[0x1c/2], m_video[0x1e/2], m_video[0x20/2]);
413	412	}
414		if (~~state->~~m_is_drivedge) logerror(" v0=%08x v1=%08x v2=%08x v3=%08x", ~~state->~~m_drivedge_zbuf_control[0], ~~state->~~m_drivedge_zbuf_control[1], ~~state->~~m_drivedge_zbuf_control[2], ~~state->~~m_drivedge_zbuf_control[3]);
	413	if (m_is_drivedge) logerror(" v0=%08x v1=%08x v2=%08x v3=%08x", m_drivedge_zbuf_control[0], m_drivedge_zbuf_control[1], m_drivedge_zbuf_control[2], m_drivedge_zbuf_control[3]);
415	414	logerror("\n");
416	415	}
417	416
r20828	r20829
423	422	*
424	423	*************************************/
425	424
426		~~static~~ void update_interrupts(~~running_machine &machine,~~ int fast)
	425	void itech32_state::update_interrupts(int fast)
427	426	{
428		itech32_state *state = machine.driver_data<itech32_state>();
429	427	int scanline_state = 0, blitter_state = 0;
430	428
431		if (~~state->~~VIDEO_INTSTATE & ~~state->~~VIDEO_INTENABLE & VIDEOINT_SCANLINE)
	429	if (VIDEO_INTSTATE & VIDEO_INTENABLE & VIDEOINT_SCANLINE)
432	430	scanline_state = 1;
433		if (~~state->~~VIDEO_INTSTATE & ~~state->~~VIDEO_INTENABLE & VIDEOINT_BLITTER)
	431	if (VIDEO_INTSTATE & VIDEO_INTENABLE & VIDEOINT_BLITTER)
434	432	blitter_state = 1;
435	433
436		itech32_update_interrupts(~~machine,~~ -1, blitter_state, scanline_state);
	434	itech32_update_interrupts(-1, blitter_state, scanline_state);
437	435	}
438	436
439	437
r20828	r20829
447	445	VIDEO_INTSTATE \|= VIDEOINT_SCANLINE;
448	446
449	447	/* update the interrupt state */
450		update_interrupts(~~machine(),~~ 0);
	448	update_interrupts(0);
451	449	}
452	450
453	451
r20828	r20829
458	456	*
459	457	*************************************/
460	458
461		~~static~~ void ~~draw_raw(~~itech32_state sta~~te,~~ UINT16 base, UINT16 color)
	459	void itech32_state::draw_raw(UINT16 *base, UINT16 color)
462	460	{
463		UINT8 *src = &state->m_grom_base[(state->m_grom_bank \| ((state->VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| state->VIDEO_TRANSFER_ADDRLO) % state->m_grom_size];
464		int transparent_pen = (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
465		int width = state->VIDEO_TRANSFER_WIDTH << 8;
466		int height = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT) << 8;
467		int xsrcstep = state->VIDEO_SRC_XSTEP;
468		int ysrcstep = state->VIDEO_SRC_YSTEP;
469		int sx, sy = (state->VIDEO_TRANSFER_Y & 0xfff) << 8;
470		int startx = (state->VIDEO_TRANSFER_X & 0xfff) << 8;
	461	UINT8 *src = &m_grom_base[(m_grom_bank \| ((VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| VIDEO_TRANSFER_ADDRLO) % m_grom_size];
	462	int transparent_pen = (VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
	463	int width = VIDEO_TRANSFER_WIDTH << 8;
	464	int height = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT) << 8;
	465	int xsrcstep = VIDEO_SRC_XSTEP;
	466	int ysrcstep = VIDEO_SRC_YSTEP;
	467	int sx, sy = (VIDEO_TRANSFER_Y & 0xfff) << 8;
	468	int startx = (VIDEO_TRANSFER_X & 0xfff) << 8;
471	469	int xdststep = 0x100;
472		int ydststep = ~~state->~~VIDEO_DST_YSTEP;
	470	int ydststep = VIDEO_DST_YSTEP;
473	471	int x, y;
474	472
475	473	/* adjust for (lack of) clipping */
476		if (!(state->VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
477		disable_clipping(state);
	474	if (!(VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
	475	disable_clipping();
478	476
479	477	/* adjust for scaling */
480		if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE)
481		xdststep = state->VIDEO_DST_XSTEP;
	478	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE)
	479	xdststep = VIDEO_DST_XSTEP;
482	480
483	481	/* adjust for flipping */
484		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
	482	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
485	483	xdststep = -xdststep;
486		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
	484	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
487	485	ydststep = -ydststep;
488	486
489	487	/* loop over Y in src pixels */
r20828	r20829
492	490	UINT8 rowsrc = &src[(y >> 8) (width >> 8)];
493	491
494	492	/* simpler case: VIDEO_YSTEP_PER_X is zero */
495		if (~~state->~~VIDEO_YSTEP_PER_X == 0)
	493	if (VIDEO_YSTEP_PER_X == 0)
496	494	{
497	495	/* clip in the Y direction */
498		if (sy >= ~~state->~~m_scaled_clip_rect.min_y && sy < ~~state->~~m_scaled_clip_rect.max_y)
	496	if (sy >= m_scaled_clip_rect.min_y && sy < m_scaled_clip_rect.max_y)
499	497	{
500	498	UINT32 dstoffs;
501	499
r20828	r20829
504	502	if (xdststep > 0)
505	503	{
506	504	/* skip left pixels */
507		for (x = 0; x < width && sx < ~~state->~~m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep) ;
	505	for (x = 0; x < width && sx < m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep) ;
508	506
509	507	/* compute the address */
510		dstoffs = compute_safe_address(s~~tate, s~~x >> 8, sy >> 8) - (sx >> 8);
	508	dstoffs = compute_safe_address(sx >> 8, sy >> 8) - (sx >> 8);
511	509
512	510	/* render middle pixels */
513		for ( ; x < width && sx < ~~state->~~m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
	511	for ( ; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
514	512	{
515	513	int pixel = rowsrc[x >> 8];
516	514	if (pixel != transparent_pen)
517		base[(dstoffs + (sx >> 8)) & ~~state->~~m_vram_mask] = pixel \| color;
	515	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
518	516	}
519	517	}
520	518	else
521	519	{
522	520	/* skip right pixels */
523		for (x = 0; x < width && sx >= ~~state->~~m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep) ;
	521	for (x = 0; x < width && sx >= m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep) ;
524	522
525	523	/* compute the address */
526		dstoffs = compute_safe_address(s~~tate, s~~x >> 8, sy >> 8) - (sx >> 8);
	524	dstoffs = compute_safe_address(sx >> 8, sy >> 8) - (sx >> 8);
527	525
528	526	/* render middle pixels */
529		for ( ; x < width && sx >= ~~state->~~m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
	527	for ( ; x < width && sx >= m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
530	528	{
531	529	int pixel = rowsrc[x >> 8];
532	530	if (pixel != transparent_pen)
533		base[(dstoffs + (sx >> 8)) & ~~state->~~m_vram_mask] = pixel \| color;
	531	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
534	532	}
535	533	}
536	534	}
r20828	r20829
539	537	/* slow case: VIDEO_YSTEP_PER_X is non-zero */
540	538	else
541	539	{
542		int ystep = (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_DYDXSIGN) ? -~~state->~~VIDEO_YSTEP_PER_X : ~~state->~~VIDEO_YSTEP_PER_X;
	540	int ystep = (VIDEO_TRANSFER_FLAGS & XFERFLAG_DYDXSIGN) ? -VIDEO_YSTEP_PER_X : VIDEO_YSTEP_PER_X;
543	541	int ty = sy;
544	542
545	543	/* render all pixels */
546	544	sx = startx;
547		for (x = 0; x < width && sx < state->m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
548		if (state->m_scaled_clip_rect.contains(sx, ty))
	545	for (x = 0; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
	546	if (m_scaled_clip_rect.contains(sx, ty))
549	547	{
550	548	int pixel = rowsrc[x >> 8];
551	549	if (pixel != transparent_pen)
552		base[compute_safe_address(s~~tate, s~~x >> 8, ty >> 8)] = pixel \| color;
	550	base[compute_safe_address(sx >> 8, ty >> 8)] = pixel \| color;
553	551	}
554	552	}
555	553
556	554	/* apply skew */
557		if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DXDYSIGN)
558		startx += state->VIDEO_XSTEP_PER_Y;
	555	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_DXDYSIGN)
	556	startx += VIDEO_XSTEP_PER_Y;
559	557	else
560		startx -= ~~state->~~VIDEO_XSTEP_PER_Y;
	558	startx -= VIDEO_XSTEP_PER_Y;
561	559	}
562	560
563	561	/* restore cliprects */
564		if (!(state->VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
565		enable_clipping(state);
	562	if (!(VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
	563	enable_clipping();
566	564	}
567	565
568	566
569		~~static~~ void draw_raw_drivedge(~~itech32_state state,~~ UINT16 base, UINT16 *zbase, UINT16 color)
	567	void itech32_state::draw_raw_drivedge(UINT16 base, UINT16 zbase, UINT16 color)
570	568	{
571		UINT8 *src = &state->m_grom_base[(state->m_grom_bank \| ((state->VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| state->VIDEO_TRANSFER_ADDRLO) % state->m_grom_size];
572		int transparent_pen = (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
573		int width = state->VIDEO_TRANSFER_WIDTH << 8;
574		int height = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT) << 8;
575		int xsrcstep = state->VIDEO_SRC_XSTEP;
576		int ysrcstep = state->VIDEO_SRC_YSTEP;
577		int sx, sy = ((state->VIDEO_TRANSFER_Y & 0xfff) << 8) + 0x80;
578		int startx = ((state->VIDEO_TRANSFER_X & 0xfff) << 8) + 0x80;
	569	UINT8 *src = &m_grom_base[(m_grom_bank \| ((VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| VIDEO_TRANSFER_ADDRLO) % m_grom_size];
	570	int transparent_pen = (VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
	571	int width = VIDEO_TRANSFER_WIDTH << 8;
	572	int height = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT) << 8;
	573	int xsrcstep = VIDEO_SRC_XSTEP;
	574	int ysrcstep = VIDEO_SRC_YSTEP;
	575	int sx, sy = ((VIDEO_TRANSFER_Y & 0xfff) << 8) + 0x80;
	576	int startx = ((VIDEO_TRANSFER_X & 0xfff) << 8) + 0x80;
579	577	int xdststep = 0x100;
580		int ydststep = state->VIDEO_DST_YSTEP;
581		INT32 z0 = state->m_drivedge_zbuf_control[2] & 0x7ff00;
582		INT32 zmatch = (state->m_drivedge_zbuf_control[2] & 0x1f) << 11;
	578	int ydststep = VIDEO_DST_YSTEP;
	579	INT32 z0 = m_drivedge_zbuf_control[2] & 0x7ff00;
	580	INT32 zmatch = (m_drivedge_zbuf_control[2] & 0x1f) << 11;
583	581	INT32 srcdelta = 0;
584	582	int x, y;
585	583
586	584	/* adjust for (lack of) clipping */
587		if (!(state->VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
588		disable_clipping(state);
	585	if (!(VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
	586	disable_clipping();
589	587
590	588	/* adjust for scaling */
591		if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE)
592		xdststep = state->VIDEO_DST_XSTEP;
	589	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE)
	590	xdststep = VIDEO_DST_XSTEP;
593	591
594	592	/* adjust for flipping */
595		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
	593	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
596	594	xdststep = -xdststep;
597		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
	595	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
598	596	ydststep = -ydststep;
599	597
600	598	/* loop over Y in src pixels */
r20828	r20829
603	601	UINT8 *rowsrc = src + (srcdelta >> 8);
604	602
605	603	/* in the polygon case, we don't factor in the Y */
606		if (~~state->~~VIDEO_TRANSFER_FLAGS != 0x5490)
	604	if (VIDEO_TRANSFER_FLAGS != 0x5490)
607	605	rowsrc += (y >> 8) * (width >> 8);
608	606	else
609	607	width = 1000 << 8;
610	608
611	609	/* simpler case: VIDEO_YSTEP_PER_X is zero */
612		if (~~state->~~VIDEO_YSTEP_PER_X == 0)
	610	if (VIDEO_YSTEP_PER_X == 0)
613	611	{
614	612	/* clip in the Y direction */
615		if (sy >= ~~state->~~m_scaled_clip_rect.min_y && sy < ~~state->~~m_scaled_clip_rect.max_y)
	613	if (sy >= m_scaled_clip_rect.min_y && sy < m_scaled_clip_rect.max_y)
616	614	{
617	615	UINT32 dstoffs, zbufoffs;
618	616	INT32 z = z0;
r20828	r20829
622	620	if (xdststep > 0)
623	621	{
624	622	/* skip left pixels */
625		for (x = 0; x < width && sx < state->m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
626		z += (INT32)state->m_drivedge_zbuf_control[0];
	623	for (x = 0; x < width && sx < m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
	624	z += (INT32)m_drivedge_zbuf_control[0];
627	625
628	626	/* compute the address */
629		dstoffs = compute_safe_address(state, sx >> 8, sy >> 8) - (sx >> 8);
630		zbufoffs = compute_safe_address(state, sx >> 8, sy >> 8) - (sx >> 8);
	627	dstoffs = compute_safe_address(sx >> 8, sy >> 8) - (sx >> 8);
	628	zbufoffs = compute_safe_address(sx >> 8, sy >> 8) - (sx >> 8);
631	629
632	630	/* render middle pixels */
633		if (~~state->~~m_drivedge_zbuf_control[3] & 0x8000)
	631	if (m_drivedge_zbuf_control[3] & 0x8000)
634	632	{
635		for ( ; x < width && sx < ~~state->~~m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
	633	for ( ; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
636	634	{
637	635	int pixel = rowsrc[x >> 8];
638	636	if (pixel != transparent_pen)
639	637	{
640		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = pixel \| color;
641		zbase[(zbufoffs + (sx >> 8)) & state->m_vram_mask] = (z >> 8) \| zmatch;
	638	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
	639	zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] = (z >> 8) \| zmatch;
642	640	}
643		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	641	z += (INT32)m_drivedge_zbuf_control[0];
644	642	}
645	643	}
646		else if (~~state->~~m_drivedge_zbuf_control[3] & 0x4000)
	644	else if (m_drivedge_zbuf_control[3] & 0x4000)
647	645	{
648		for ( ; x < width && sx < ~~state->~~m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
	646	for ( ; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
649	647	{
650	648	int pixel = rowsrc[x >> 8];
651		if (pixel != transparent_pen && zmatch == (zbase[(zbufoffs + (sx >> 8)) & state->m_vram_mask] & (0x1f << 11)))
652		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = pixel \| color;
653		z += (INT32)state->m_drivedge_zbuf_control[0];
	649	if (pixel != transparent_pen && zmatch == (zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] & (0x1f << 11)))
	650	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
	651	z += (INT32)m_drivedge_zbuf_control[0];
654	652	}
655	653	}
656	654	else
657	655	{
658		for ( ; x < width && sx < ~~state->~~m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
	656	for ( ; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
659	657	{
660	658	int pixel = rowsrc[x >> 8];
661		if (pixel != transparent_pen && ((z >> 8) <= (zbase[(zbufoffs + (sx >> 8)) & ~~state->~~m_vram_mask] & 0x7ff)))
	659	if (pixel != transparent_pen && ((z >> 8) <= (zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] & 0x7ff)))
662	660	{
663		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = pixel \| color;
664		zbase[(zbufoffs + (sx >> 8)) & state->m_vram_mask] = (z >> 8) \| zmatch;
	661	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
	662	zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] = (z >> 8) \| zmatch;
665	663	}
666		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	664	z += (INT32)m_drivedge_zbuf_control[0];
667	665	}
668	666	}
669	667	}
670	668	else
671	669	{
672	670	/* skip right pixels */
673		for (x = 0; x < width && sx >= state->m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
674		z += (INT32)state->m_drivedge_zbuf_control[0];
	671	for (x = 0; x < width && sx >= m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep)
	672	z += (INT32)m_drivedge_zbuf_control[0];
675	673
676	674	/* compute the address */
677		dstoffs = compute_safe_address(state, sx >> 8, sy >> 8) - (sx >> 8);
678		zbufoffs = compute_safe_address(state, sx >> 8, sy >> 8) - (sx >> 8);
	675	dstoffs = compute_safe_address(sx >> 8, sy >> 8) - (sx >> 8);
	676	zbufoffs = compute_safe_address(sx >> 8, sy >> 8) - (sx >> 8);
679	677
680	678	/* render middle pixels */
681		if (~~state->~~m_drivedge_zbuf_control[3] & 0x8000)
	679	if (m_drivedge_zbuf_control[3] & 0x8000)
682	680	{
683		for ( ; x < width && sx >= ~~state->~~m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
	681	for ( ; x < width && sx >= m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
684	682	{
685	683	int pixel = rowsrc[x >> 8];
686	684	if (pixel != transparent_pen)
687	685	{
688		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = pixel \| color;
689		zbase[(zbufoffs + (sx >> 8)) & state->m_vram_mask] = (z >> 8) \| zmatch;
	686	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
	687	zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] = (z >> 8) \| zmatch;
690	688	}
691		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	689	z += (INT32)m_drivedge_zbuf_control[0];
692	690	}
693	691	}
694		else if (~~state->~~m_drivedge_zbuf_control[3] & 0x4000)
	692	else if (m_drivedge_zbuf_control[3] & 0x4000)
695	693	{
696		for ( ; x < width && sx >= ~~state->~~m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
	694	for ( ; x < width && sx >= m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
697	695	{
698	696	int pixel = rowsrc[x >> 8];
699		if (pixel != transparent_pen && zmatch == (zbase[(zbufoffs + (sx >> 8)) & state->m_vram_mask] & (0x1f << 11)))
700		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = pixel \| color;
701		z += (INT32)state->m_drivedge_zbuf_control[0];
	697	if (pixel != transparent_pen && zmatch == (zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] & (0x1f << 11)))
	698	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
	699	z += (INT32)m_drivedge_zbuf_control[0];
702	700	}
703	701	}
704	702	else
705	703	{
706		for ( ; x < width && sx >= ~~state->~~m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
	704	for ( ; x < width && sx >= m_scaled_clip_rect.min_x; x += xsrcstep, sx += xdststep)
707	705	{
708	706	int pixel = rowsrc[x >> 8];
709		if (pixel != transparent_pen && ((z >> 8) <= (zbase[(zbufoffs + (sx >> 8)) & ~~state->~~m_vram_mask] & 0x7ff)))
	707	if (pixel != transparent_pen && ((z >> 8) <= (zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] & 0x7ff)))
710	708	{
711		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = pixel \| color;
712		zbase[(zbufoffs + (sx >> 8)) & state->m_vram_mask] = (z >> 8) \| zmatch;
	709	base[(dstoffs + (sx >> 8)) & m_vram_mask] = pixel \| color;
	710	zbase[(zbufoffs + (sx >> 8)) & m_vram_mask] = (z >> 8) \| zmatch;
713	711	}
714		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	712	z += (INT32)m_drivedge_zbuf_control[0];
715	713	}
716	714	}
717	715	}
r20828	r20829
721	719	/* slow case: VIDEO_YSTEP_PER_X is non-zero */
722	720	else
723	721	{
724		int ystep = (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_DYDXSIGN) ? -~~state->~~VIDEO_YSTEP_PER_X : ~~state->~~VIDEO_YSTEP_PER_X;
	722	int ystep = (VIDEO_TRANSFER_FLAGS & XFERFLAG_DYDXSIGN) ? -VIDEO_YSTEP_PER_X : VIDEO_YSTEP_PER_X;
725	723	int ty = sy;
726	724	INT32 z = z0;
727	725
728	726	/* render all pixels */
729	727	sx = startx;
730		if (~~state->~~m_drivedge_zbuf_control[3] & 0x8000)
	728	if (m_drivedge_zbuf_control[3] & 0x8000)
731	729	{
732		for (x = 0; x < width && sx < state->m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
733		if (state->m_scaled_clip_rect.contains(sx, ty))
	730	for (x = 0; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
	731	if (m_scaled_clip_rect.contains(sx, ty))
734	732	{
735	733	int pixel = rowsrc[x >> 8];
736	734	if (pixel != transparent_pen)
737	735	{
738		base[compute_safe_address(state, sx >> 8, ty >> 8)] = pixel \| color;
739		zbase[compute_safe_address(state, sx >> 8, ty >> 8)] = (z >> 8) \| zmatch;
	736	base[compute_safe_address(sx >> 8, ty >> 8)] = pixel \| color;
	737	zbase[compute_safe_address(sx >> 8, ty >> 8)] = (z >> 8) \| zmatch;
740	738	}
741		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	739	z += (INT32)m_drivedge_zbuf_control[0];
742	740	}
743	741	}
744		else if (~~state->~~m_drivedge_zbuf_control[3] & 0x4000)
	742	else if (m_drivedge_zbuf_control[3] & 0x4000)
745	743	{
746		for (x = 0; x < width && sx < state->m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
747		if (state->m_scaled_clip_rect.contains(sx, ty))
	744	for (x = 0; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
	745	if (m_scaled_clip_rect.contains(sx, ty))
748	746	{
749	747	int pixel = rowsrc[x >> 8];
750		UINT16 *zbuf = &zbase[compute_safe_address(s~~tate, s~~x >> 8, ty >> 8)];
	748	UINT16 *zbuf = &zbase[compute_safe_address(sx >> 8, ty >> 8)];
751	749	if (pixel != transparent_pen && zmatch == (*zbuf & (0x1f << 11)))
752	750	{
753		base[compute_safe_address(s~~tate, s~~x >> 8, ty >> 8)] = pixel \| color;
	751	base[compute_safe_address(sx >> 8, ty >> 8)] = pixel \| color;
754	752	*zbuf = (z >> 8) \| zmatch;
755	753	}
756		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	754	z += (INT32)m_drivedge_zbuf_control[0];
757	755	}
758	756	}
759	757	else
760	758	{
761		for (x = 0; x < width && sx < state->m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
762		if (state->m_scaled_clip_rect.contains(sx, ty))
	759	for (x = 0; x < width && sx < m_scaled_clip_rect.max_x; x += xsrcstep, sx += xdststep, ty += ystep)
	760	if (m_scaled_clip_rect.contains(sx, ty))
763	761	{
764	762	int pixel = rowsrc[x >> 8];
765		UINT16 *zbuf = &zbase[compute_safe_address(s~~tate, s~~x >> 8, ty >> 8)];
	763	UINT16 *zbuf = &zbase[compute_safe_address(sx >> 8, ty >> 8)];
766	764	if (pixel != transparent_pen && ((z >> 8) <= (*zbuf & 0x7ff)))
767	765	{
768		base[compute_safe_address(s~~tate, s~~x >> 8, ty >> 8)] = pixel \| color;
	766	base[compute_safe_address(sx >> 8, ty >> 8)] = pixel \| color;
769	767	*zbuf = (z >> 8) \| zmatch;
770	768	}
771		z += (INT32)~~state->~~m_drivedge_zbuf_control[0];
	769	z += (INT32)m_drivedge_zbuf_control[0];
772	770	}
773	771	}
774	772	}
775	773
776	774	/* apply skew */
777		if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DXDYSIGN)
778		startx += state->VIDEO_XSTEP_PER_Y;
	775	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_DXDYSIGN)
	776	startx += VIDEO_XSTEP_PER_Y;
779	777	else
780		startx -= ~~state->~~VIDEO_XSTEP_PER_Y;
	778	startx -= VIDEO_XSTEP_PER_Y;
781	779
782	780	/* update the per-scanline parameters */
783		if (~~state->~~VIDEO_TRANSFER_FLAGS == 0x5490)
	781	if (VIDEO_TRANSFER_FLAGS == 0x5490)
784	782	{
785		startx += (INT32)((state->VIDEO_LEFTSTEPHI << 16) \| state->VIDEO_LEFTSTEPLO);
786		state->m_scaled_clip_rect.max_x += (INT32)((state->VIDEO_RIGHTSTEPHI << 16) \| state->VIDEO_RIGHTSTEPLO);
787		srcdelta += (INT16)state->VIDEO_STARTSTEP;
	783	startx += (INT32)((VIDEO_LEFTSTEPHI << 16) \| VIDEO_LEFTSTEPLO);
	784	m_scaled_clip_rect.max_x += (INT32)((VIDEO_RIGHTSTEPHI << 16) \| VIDEO_RIGHTSTEPLO);
	785	srcdelta += (INT16)VIDEO_STARTSTEP;
788	786	}
789		z0 += (INT32)~~state->~~m_drivedge_zbuf_control[1];
	787	z0 += (INT32)m_drivedge_zbuf_control[1];
790	788	}
791	789
792	790	/* restore cliprects */
793		if (!(state->VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
794		enable_clipping(state);
	791	if (!(VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
	792	enable_clipping();
795	793
796	794	/* reflect the final values into registers */
797		state->VIDEO_TRANSFER_X = (state->VIDEO_TRANSFER_X & ~0xfff) \| (startx >> 8);
798		state->VIDEO_RIGHTCLIP = (state->VIDEO_RIGHTCLIP & ~0xfff) \| (state->m_scaled_clip_rect.max_x >> 8);
799		state->VIDEO_TRANSFER_Y = (state->VIDEO_TRANSFER_Y & ~0xfff) \| ((state->VIDEO_TRANSFER_Y + (y >> 8)) & 0xfff);
800		state->VIDEO_TRANSFER_ADDRLO += srcdelta >> 8;
	795	VIDEO_TRANSFER_X = (VIDEO_TRANSFER_X & ~0xfff) \| (startx >> 8);
	796	VIDEO_RIGHTCLIP = (VIDEO_RIGHTCLIP & ~0xfff) \| (m_scaled_clip_rect.max_x >> 8);
	797	VIDEO_TRANSFER_Y = (VIDEO_TRANSFER_Y & ~0xfff) \| ((VIDEO_TRANSFER_Y + (y >> 8)) & 0xfff);
	798	VIDEO_TRANSFER_ADDRLO += srcdelta >> 8;
801	799
802		~~state->~~m_drivedge_zbuf_control[2] = (~~state->~~m_drivedge_zbuf_control[2] & ~0x7ff00) \| (z0 & 0x7ff00);
	800	m_drivedge_zbuf_control[2] = (m_drivedge_zbuf_control[2] & ~0x7ff00) \| (z0 & 0x7ff00);
803	801	}
804	802
805	803
r20828	r20829
848	846	*
849	847	*************************************/
850	848
851		~~INLINE~~ void ~~draw_rle_fast(~~itech32_state state, UINT16 base, UINT16 color)
	849	inline void itech32_state::draw_rle_fast(UINT16 *base, UINT16 color)
852	850	{
853		UINT8 *src = &state->m_grom_base[(state->m_grom_bank \| ((state->VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| state->VIDEO_TRANSFER_ADDRLO) % state->m_grom_size];
854		int transparent_pen = (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
855		int width = state->VIDEO_TRANSFER_WIDTH;
856		int height = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT);
857		int sx = state->VIDEO_TRANSFER_X & 0xfff;
858		int sy = (state->VIDEO_TRANSFER_Y & 0xfff) << 8;
	851	UINT8 *src = &m_grom_base[(m_grom_bank \| ((VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| VIDEO_TRANSFER_ADDRLO) % m_grom_size];
	852	int transparent_pen = (VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
	853	int width = VIDEO_TRANSFER_WIDTH;
	854	int height = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT);
	855	int sx = VIDEO_TRANSFER_X & 0xfff;
	856	int sy = (VIDEO_TRANSFER_Y & 0xfff) << 8;
859	857	int xleft, y, count = 0, val = 0, innercount;
860		int ydststep = ~~state->~~VIDEO_DST_YSTEP;
	858	int ydststep = VIDEO_DST_YSTEP;
861	859	int lclip, rclip;
862	860
863	861	/* determine clipping */
864		lclip = ~~state->~~m_clip_rect.min_x - sx;
	862	lclip = m_clip_rect.min_x - sx;
865	863	if (lclip < 0) lclip = 0;
866		rclip = sx + width - ~~state->~~m_clip_rect.max_x;
	864	rclip = sx + width - m_clip_rect.max_x;
867	865	if (rclip < 0) rclip = 0;
868	866	width -= lclip + rclip;
869	867	sx += lclip;
870	868
871	869	/* adjust for flipping */
872		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
	870	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
873	871	ydststep = -ydststep;
874	872
875	873	/* loop over Y in src pixels */
r20828	r20829
878	876	UINT32 dstoffs;
879	877
880	878	/* clip in the Y direction */
881		if (sy < ~~state->~~m_scaled_clip_rect.min_y \|\| sy >= ~~state->~~m_scaled_clip_rect.max_y)
	879	if (sy < m_scaled_clip_rect.min_y \|\| sy >= m_scaled_clip_rect.max_y)
882	880	{
883	881	SKIP_RLE(width + lclip + rclip, xleft, count, innercount, src);
884	882	continue;
885	883	}
886	884
887	885	/* compute the address */
888		dstoffs = compute_safe_address(s~~tate, s~~x, sy >> 8);
	886	dstoffs = compute_safe_address(sx, sy >> 8);
889	887
890	888	/* left clip */
891	889	SKIP_RLE(lclip, xleft, count, innercount, src);
r20828	r20829
902	900	{
903	901	int pixel = *src++;
904	902	if (pixel != transparent_pen)
905		base[dstoffs & ~~state->~~m_vram_mask] = color \| pixel;
	903	base[dstoffs & m_vram_mask] = color \| pixel;
906	904	dstoffs++;
907	905	}
908	906
r20828	r20829
911	909	{
912	910	val \|= color;
913	911	while (innercount--)
914		base[dstoffs++ & ~~state->~~m_vram_mask] = val;
	912	base[dstoffs++ & m_vram_mask] = val;
915	913	}
916	914
917	915	/* run of transparent repeats */
r20828	r20829
925	923	}
926	924
927	925
928		~~INLINE~~ void draw_rle_fast_xflip(~~itech32_state state,~~ UINT16 base, UINT16 color)
	926	inline void itech32_state::draw_rle_fast_xflip(UINT16 *base, UINT16 color)
929	927	{
930		UINT8 *src = &state->m_grom_base[(state->m_grom_bank \| ((state->VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| state->VIDEO_TRANSFER_ADDRLO) % state->m_grom_size];
931		int transparent_pen = (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
932		int width = state->VIDEO_TRANSFER_WIDTH;
933		int height = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT);
934		int sx = state->VIDEO_TRANSFER_X & 0xfff;
935		int sy = (state->VIDEO_TRANSFER_Y & 0xfff) << 8;
	928	UINT8 *src = &m_grom_base[(m_grom_bank \| ((VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| VIDEO_TRANSFER_ADDRLO) % m_grom_size];
	929	int transparent_pen = (VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
	930	int width = VIDEO_TRANSFER_WIDTH;
	931	int height = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT);
	932	int sx = VIDEO_TRANSFER_X & 0xfff;
	933	int sy = (VIDEO_TRANSFER_Y & 0xfff) << 8;
936	934	int xleft, y, count = 0, val = 0, innercount;
937		int ydststep = ~~state->~~VIDEO_DST_YSTEP;
	935	int ydststep = VIDEO_DST_YSTEP;
938	936	int lclip, rclip;
939	937
940	938	/* determine clipping */
941		lclip = sx - ~~state->~~m_clip_rect.max_x;
	939	lclip = sx - m_clip_rect.max_x;
942	940	if (lclip < 0) lclip = 0;
943		rclip = ~~state->~~m_clip_rect.min_x - (sx - width);
	941	rclip = m_clip_rect.min_x - (sx - width);
944	942	if (rclip < 0) rclip = 0;
945	943	width -= lclip + rclip;
946	944	sx -= lclip;
947	945
948	946	/* adjust for flipping */
949		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
	947	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
950	948	ydststep = -ydststep;
951	949
952	950	/* loop over Y in src pixels */
r20828	r20829
955	953	UINT32 dstoffs;
956	954
957	955	/* clip in the Y direction */
958		if (sy < ~~state->~~m_scaled_clip_rect.min_y \|\| sy >= ~~state->~~m_scaled_clip_rect.max_y)
	956	if (sy < m_scaled_clip_rect.min_y \|\| sy >= m_scaled_clip_rect.max_y)
959	957	{
960	958	SKIP_RLE(width + lclip + rclip, xleft, count, innercount, src);
961	959	continue;
962	960	}
963	961
964	962	/* compute the address */
965		dstoffs = compute_safe_address(s~~tate, s~~x, sy >> 8);
	963	dstoffs = compute_safe_address(sx, sy >> 8);
966	964
967	965	/* left clip */
968	966	SKIP_RLE(lclip, xleft, count, innercount, src);
r20828	r20829
979	977	{
980	978	int pixel = *src++;
981	979	if (pixel != transparent_pen)
982		base[dstoffs & ~~state->~~m_vram_mask] = color \| pixel;
	980	base[dstoffs & m_vram_mask] = color \| pixel;
983	981	dstoffs--;
984	982	}
985	983
r20828	r20829
988	986	{
989	987	val \|= color;
990	988	while (innercount--)
991		base[dstoffs-- & ~~state->~~m_vram_mask] = val;
	989	base[dstoffs-- & m_vram_mask] = val;
992	990	}
993	991
994	992	/* run of transparent repeats */
r20828	r20829
1009	1007	*
1010	1008	*************************************/
1011	1009
1012		~~INLINE~~ void ~~draw_rle_slow(~~itech32_state state, UINT16 base, UINT16 color)
	1010	inline void itech32_state::draw_rle_slow(UINT16 *base, UINT16 color)
1013	1011	{
1014		UINT8 *src = &state->m_grom_base[(state->m_grom_bank \| ((state->VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| state->VIDEO_TRANSFER_ADDRLO) % state->m_grom_size];
1015		int transparent_pen = (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
1016		int width = state->VIDEO_TRANSFER_WIDTH;
1017		int height = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT);
1018		int sx, sy = (state->VIDEO_TRANSFER_Y & 0xfff) << 8;
	1012	UINT8 *src = &m_grom_base[(m_grom_bank \| ((VIDEO_TRANSFER_ADDRHI & 0xff) << 16) \| VIDEO_TRANSFER_ADDRLO) % m_grom_size];
	1013	int transparent_pen = (VIDEO_TRANSFER_FLAGS & XFERFLAG_TRANSPARENT) ? 0xff : -1;
	1014	int width = VIDEO_TRANSFER_WIDTH;
	1015	int height = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT);
	1016	int sx, sy = (VIDEO_TRANSFER_Y & 0xfff) << 8;
1019	1017	int xleft, y, count = 0, val = 0, innercount;
1020	1018	int xdststep = 0x100;
1021		int ydststep = state->VIDEO_DST_YSTEP;
1022		int startx = (state->VIDEO_TRANSFER_X & 0xfff) << 8;
	1019	int ydststep = VIDEO_DST_YSTEP;
	1020	int startx = (VIDEO_TRANSFER_X & 0xfff) << 8;
1023	1021
1024	1022	/* adjust for scaling */
1025		if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE)
1026		xdststep = state->VIDEO_DST_XSTEP;
	1023	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE)
	1024	xdststep = VIDEO_DST_XSTEP;
1027	1025
1028	1026	/* adjust for flipping */
1029		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
	1027	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
1030	1028	xdststep = -xdststep;
1031		if (~~state->~~VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
	1029	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP)
1032	1030	ydststep = -ydststep;
1033	1031
1034	1032	/* loop over Y in src pixels */
r20828	r20829
1037	1035	UINT32 dstoffs;
1038	1036
1039	1037	/* clip in the Y direction */
1040		if (sy < ~~state->~~m_scaled_clip_rect.min_y \|\| sy >= ~~state->~~m_scaled_clip_rect.max_y)
	1038	if (sy < m_scaled_clip_rect.min_y \|\| sy >= m_scaled_clip_rect.max_y)
1041	1039	{
1042	1040	SKIP_RLE(width, xleft, count, innercount, src);
1043	1041	continue;
r20828	r20829
1045	1043
1046	1044	/* compute the address */
1047	1045	sx = startx;
1048		dstoffs = compute_safe_address(~~state, state->~~m_clip_rect.min_x, sy >> 8) - ~~state->~~m_clip_rect.min_x;
	1046	dstoffs = compute_safe_address(m_clip_rect.min_x, sy >> 8) - m_clip_rect.min_x;
1049	1047
1050	1048	/* loop until gone */
1051	1049	for (xleft = width; xleft > 0; )
r20828	r20829
1059	1057	{
1060	1058	int pixel = *src++;
1061	1059	if (pixel != transparent_pen)
1062		if (sx >= state->m_scaled_clip_rect.min_x && sx < state->m_scaled_clip_rect.max_x)
1063		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = color \| pixel;
	1060	if (sx >= m_scaled_clip_rect.min_x && sx < m_scaled_clip_rect.max_x)
	1061	base[(dstoffs + (sx >> 8)) & m_vram_mask] = color \| pixel;
1064	1062	}
1065	1063
1066	1064	/* run of non-transparent repeats */
r20828	r20829
1068	1066	{
1069	1067	val \|= color;
1070	1068	for ( ; innercount--; sx += xdststep)
1071		if (sx >= state->m_scaled_clip_rect.min_x && sx < state->m_scaled_clip_rect.max_x)
1072		base[(dstoffs + (sx >> 8)) & state->m_vram_mask] = val;
	1069	if (sx >= m_scaled_clip_rect.min_x && sx < m_scaled_clip_rect.max_x)
	1070	base[(dstoffs + (sx >> 8)) & m_vram_mask] = val;
1073	1071	}
1074	1072
1075	1073	/* run of transparent repeats */
r20828	r20829
1078	1076	}
1079	1077
1080	1078	/* apply skew */
1081		if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DXDYSIGN)
1082		startx += state->VIDEO_XSTEP_PER_Y;
	1079	if (VIDEO_TRANSFER_FLAGS & XFERFLAG_DXDYSIGN)
	1080	startx += VIDEO_XSTEP_PER_Y;
1083	1081	else
1084		startx -= ~~state->~~VIDEO_XSTEP_PER_Y;
	1082	startx -= VIDEO_XSTEP_PER_Y;
1085	1083	}
1086	1084	}
1087	1085
1088	1086
1089	1087
1090		~~static~~ void ~~draw_rle(~~itech32_state state, UINT16 base, UINT16 color)
	1088	void itech32_state::draw_rle(UINT16 *base, UINT16 color)
1091	1089	{
1092	1090	/* adjust for (lack of) clipping */
1093		if (!(state->VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
1094		disable_clipping(state);
	1091	if (!(VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
	1092	disable_clipping();
1095	1093
1096	1094	/* if we have an X scale, draw it slow */
1097		if (((state->VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE) && state->VIDEO_DST_XSTEP != 0x100) \|\| state->VIDEO_XSTEP_PER_Y)
1098		draw_rle_slow(state, base, color);
	1095	if (((VIDEO_TRANSFER_FLAGS & XFERFLAG_DSTXSCALE) && VIDEO_DST_XSTEP != 0x100) \|\| VIDEO_XSTEP_PER_Y)
	1096	draw_rle_slow(base, color);
1099	1097
1100	1098	/* else draw it fast */
1101		else if (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
1102		draw_rle_fast_xflip(state, base, color);
	1099	else if (VIDEO_TRANSFER_FLAGS & XFERFLAG_XFLIP)
	1100	draw_rle_fast_xflip(base, color);
1103	1101	else
1104		draw_rle_fast(~~state,~~ base, color);
	1102	draw_rle_fast(base, color);
1105	1103
1106	1104	/* restore cliprects */
1107		if (!(state->VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
1108		enable_clipping(state);
	1105	if (!(VIDEO_TRANSFER_FLAGS & XFERFLAG_CLIP))
	1106	enable_clipping();
1109	1107	}
1110	1108
1111	1109
r20828	r20829
1116	1114	*
1117	1115	*************************************/
1118	1116
1119		~~static~~ void shiftreg_c~~lear(itec~~h32_state state, UINT16 base, UINT16 *zbase)
	1117	void itech32_state::shiftreg_clear(UINT16 base, UINT16 zbase)
1120	1118	{
1121		int ydir = (state->VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP) ? -1 : 1;
1122		int height = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT);
1123		int sx = state->VIDEO_TRANSFER_X & 0xfff;
1124		int sy = state->VIDEO_TRANSFER_Y & 0xfff;
	1119	int ydir = (VIDEO_TRANSFER_FLAGS & XFERFLAG_YFLIP) ? -1 : 1;
	1120	int height = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT);
	1121	int sx = VIDEO_TRANSFER_X & 0xfff;
	1122	int sy = VIDEO_TRANSFER_Y & 0xfff;
1125	1123	UINT16 *src;
1126	1124	int y;
1127	1125
1128	1126	/* first line is the source */
1129		src = &base[compute_safe_address(s~~tate, s~~x, sy)];
	1127	src = &base[compute_safe_address(sx, sy)];
1130	1128	sy += ydir;
1131	1129
1132	1130	/* loop over height */
1133	1131	for (y = 1; y < height; y++)
1134	1132	{
1135		memcpy(&base[compute_safe_address(s~~tate, s~~x, sy)], src, 512*2);
	1133	memcpy(&base[compute_safe_address(sx, sy)], src, 512*2);
1136	1134	if (zbase)
1137	1135	{
1138		UINT16 zval = ((state->m_drivedge_zbuf_control[2] >> 8) & 0x7ff) \| ((state->m_drivedge_zbuf_control[2] & 0x1f) << 11);
1139		UINT16 *dst = &zbase[compute_safe_address(state, sx, sy)];
	1136	UINT16 zval = ((m_drivedge_zbuf_control[2] >> 8) & 0x7ff) \| ((m_drivedge_zbuf_control[2] & 0x1f) << 11);
	1137	UINT16 *dst = &zbase[compute_safe_address(sx, sy)];
1140	1138	int x;
1141	1139	for (x = 0; x < 512; x++)
1142	1140	*dst++ = zval;
r20828	r20829
1153	1151	*
1154	1152	*************************************/
1155	1153
1156		~~static~~ void handle_video_command(~~running_machine &machine~~)
	1154	void itech32_state::handle_video_command()
1157	1155	{
1158		itech32_state *state = machine.driver_data<itech32_state>();
1159	1156	/* only 6 known commands */
1160		switch (~~state->~~VIDEO_COMMAND)
	1157	switch (VIDEO_COMMAND)
1161	1158	{
1162	1159	/* command 1: blit raw data */
1163	1160	case 1:
1164	1161	g_profiler.start(PROFILER_USER1);
1165		if (BLIT_LOGGING) logblit(~~machine,~~ "Blit Raw");
	1162	if (BLIT_LOGGING) logblit("Blit Raw");
1166	1163
1167		if (~~state->~~m_is_drivedge)
	1164	if (m_is_drivedge)
1168	1165	{
1169		if (~~state->~~m_enable_latch[0]) draw_raw_drivedge(~~state, state->~~m_videoplane[0], ~~state->~~m_videoplane[1], ~~state->~~m_color_latch[0]);
	1166	if (m_enable_latch[0]) draw_raw_drivedge(m_videoplane[0], m_videoplane[1], m_color_latch[0]);
1170	1167	}
1171	1168	else
1172	1169	{
1173		if (state->m_enable_latch[0]) draw_raw(state, state->m_videoplane[0], state->m_color_latch[0]);
1174		if (state->m_enable_latch[1]) draw_raw(state, state->m_videoplane[1], state->m_color_latch[1]);
	1170	if (m_enable_latch[0]) draw_raw(m_videoplane[0], m_color_latch[0]);
	1171	if (m_enable_latch[1]) draw_raw(m_videoplane[1], m_color_latch[1]);
1175	1172	}
1176	1173
1177	1174	g_profiler.stop();
r20828	r20829
1180	1177	/* command 2: blit RLE-compressed data */
1181	1178	case 2:
1182	1179	g_profiler.start(PROFILER_USER2);
1183		if (BLIT_LOGGING) logblit(~~machine,~~ "Blit RLE");
	1180	if (BLIT_LOGGING) logblit("Blit RLE");
1184	1181
1185		if (state->m_enable_latch[0]) draw_rle(state, state->m_videoplane[0], state->m_color_latch[0]);
1186		if (state->m_enable_latch[1]) draw_rle(state, state->m_videoplane[1], state->m_color_latch[1]);
	1182	if (m_enable_latch[0]) draw_rle(m_videoplane[0], m_color_latch[0]);
	1183	if (m_enable_latch[1]) draw_rle(m_videoplane[1], m_color_latch[1]);
1187	1184
1188	1185	g_profiler.stop();
1189	1186	break;
1190	1187
1191	1188	/* command 3: set up raw data transfer */
1192	1189	case 3:
1193		if (BLIT_LOGGING) logblit(machine, "Raw Xfer");
1194		state->m_xfer_xcount = state->VIDEO_TRANSFER_WIDTH;
1195		state->m_xfer_ycount = ADJUSTED_HEIGHT(state->VIDEO_TRANSFER_HEIGHT);
1196		state->m_xfer_xcur = state->VIDEO_TRANSFER_X & 0xfff;
1197		state->m_xfer_ycur = state->VIDEO_TRANSFER_Y & 0xfff;
	1190	if (BLIT_LOGGING) logblit("Raw Xfer");
	1191	m_xfer_xcount = VIDEO_TRANSFER_WIDTH;
	1192	m_xfer_ycount = ADJUSTED_HEIGHT(VIDEO_TRANSFER_HEIGHT);
	1193	m_xfer_xcur = VIDEO_TRANSFER_X & 0xfff;
	1194	m_xfer_ycur = VIDEO_TRANSFER_Y & 0xfff;
1198	1195	break;
1199	1196
1200	1197	/* command 4: flush? */
r20828	r20829
1208	1205	/* command 6: perform shift register copy */
1209	1206	case 6:
1210	1207	g_profiler.start(PROFILER_USER3);
1211		if (BLIT_LOGGING) logblit(~~machine,~~ "ShiftReg");
	1208	if (BLIT_LOGGING) logblit("ShiftReg");
1212	1209
1213		if (~~state->~~m_is_drivedge)
	1210	if (m_is_drivedge)
1214	1211	{
1215		if (~~state->~~m_enable_latch[0]) shiftreg_clear(~~state, state->~~m_videoplane[0], ~~state->~~m_videoplane[1]);
	1212	if (m_enable_latch[0]) shiftreg_clear(m_videoplane[0], m_videoplane[1]);
1216	1213	}
1217	1214	else
1218	1215	{
1219		if (state->m_enable_latch[0]) shiftreg_clear(state, state->m_videoplane[0], NULL);
1220		if (state->m_enable_latch[1]) shiftreg_clear(state, state->m_videoplane[1], NULL);
	1216	if (m_enable_latch[0]) shiftreg_clear(m_videoplane[0], NULL);
	1217	if (m_enable_latch[1]) shiftreg_clear(m_videoplane[1], NULL);
1221	1218	}
1222	1219
1223	1220	g_profiler.stop();
1224	1221	break;
1225	1222
1226	1223	default:
1227		if (BLIT_LOGGING) logerror("Unknown blit command %d\n", ~~state->~~VIDEO_COMMAND);
	1224	if (BLIT_LOGGING) logerror("Unknown blit command %d\n", VIDEO_COMMAND);
1228	1225	break;
1229	1226	}
1230	1227
1231	1228	/* tell the processor we're done */
1232		state->VIDEO_INTSTATE \|= VIDEOINT_BLITTER;
1233		update_interrupts(machine, 1);
	1229	VIDEO_INTSTATE \|= VIDEOINT_BLITTER;
	1230	update_interrupts(1);
1234	1231	}
1235	1232
1236	1233
r20828	r20829
1252	1249	{
1253	1250	case 0x02/2: /* VIDEO_INTACK */
1254	1251	VIDEO_INTSTATE = old & ~data;
1255		update_interrupts(~~machine(),~~ 1);
	1252	update_interrupts(1);
1256	1253	break;
1257	1254
1258	1255	case 0x04/2: /* VIDEO_TRANSFER */
1259	1256	if (VIDEO_COMMAND == 3 && m_xfer_ycount)
1260	1257	{
1261		itech32_state *state = machine().driver_data<itech32_state>();
1262		offs_t addr = compute_safe_address(state, m_xfer_xcur, m_xfer_ycur);
	1258	offs_t addr = compute_safe_address(m_xfer_xcur, m_xfer_ycur);
1263	1259	if (m_enable_latch[0])
1264	1260	{
1265	1261	VIDEO_TRANSFER = m_videoplane[0][addr];
r20828	r20829
1278	1274	break;
1279	1275
1280	1276	case 0x08/2: /* VIDEO_COMMAND */
1281		handle_video_command(~~machine()~~);
	1277	handle_video_command();
1282	1278	break;
1283	1279
1284	1280	case 0x0a/2: /* VIDEO_INTENABLE */
1285		update_interrupts(~~machine(),~~ 1);
	1281	update_interrupts(1);
1286	1282	break;
1287	1283
1288	1284	case 0x24/2: /* VIDEO_LEFTCLIP */
r20828	r20829
1415	1411	/* loop over height */
1416	1412	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
1417	1413	{
1418		UINT16 *src1 = &m_videoplane[0][compute_safe_address(~~this,~~ VIDEO_DISPLAY_XORIGIN1, VIDEO_DISPLAY_YORIGIN1 + y)];
	1414	UINT16 *src1 = &m_videoplane[0][compute_safe_address(VIDEO_DISPLAY_XORIGIN1, VIDEO_DISPLAY_YORIGIN1 + y)];
1419	1415
1420	1416	/* handle multi-plane case */
1421	1417	if (m_planes > 1)
1422	1418	{
1423		UINT16 *src2 = &m_videoplane[1][compute_safe_address(~~this,~~ VIDEO_DISPLAY_XORIGIN2 + VIDEO_DISPLAY_XSCROLL2, VIDEO_DISPLAY_YORIGIN2 + VIDEO_DISPLAY_YSCROLL2 + y)];
	1419	UINT16 *src2 = &m_videoplane[1][compute_safe_address(VIDEO_DISPLAY_XORIGIN2 + VIDEO_DISPLAY_XSCROLL2, VIDEO_DISPLAY_YORIGIN2 + VIDEO_DISPLAY_YSCROLL2 + y)];
1424	1420	UINT16 scanline[384];
1425	1421	int x;
1426	1422

trunk/src/mame/video/itech8.c
r20828	r20829
138	138	*
139	139	*************************************/
140	140
141		static void generate_interrupt(running_machine &machine, int state)
	141	static void generate_interrupt(running_machine &machine, int state_num)
142	142	{
143		itech8_update_interrupts(machine, -1, state, -1);
	143	itech8_state *state = machine.driver_data<itech8_state>();
	144	state->itech8_update_interrupts(-1, state_num, -1);
144	145
145		if (FULL_LOGGING && state) logerror("------------ DISPLAY INT (%d) --------------\n", machine.primary_screen->vpos());
	146	if (FULL_LOGGING && state_num) logerror("------------ DISPLAY INT (%d) --------------\n", machine.primary_screen->vpos());
146	147	}
147	148
148	149
r20828	r20829
215	216	*
216	217	*************************************/
217	218
218		~~INLINE~~ UINT8 fetch_next_raw(~~itech8_state *state~~)
	219	inline UINT8 itech8_state::fetch_next_raw()
219	220	{
220		return ~~state->~~m_grom_base[~~state->~~m_fetch_offset++ % ~~state->~~m_grom_size];
	221	return m_grom_base[m_fetch_offset++ % m_grom_size];
221	222	}
222	223
223	224
224		~~INLINE~~ void ~~consume_raw(~~itech8_state *s~~tat~~e, int count)
	225	inline void itech8_state::consume_raw(int count)
225	226	{
226		~~state->~~m_fetch_offset += count;
	227	m_fetch_offset += count;
227	228	}
228	229
229	230
230		~~INLINE~~ UINT8 ~~fetch_next_rle(~~itech8_state *state)
	231	inline UINT8 itech8_state::fetch_next_rle()
231	232	{
232		if (~~state->~~m_fetch_rle_count == 0)
	233	if (m_fetch_rle_count == 0)
233	234	{
234		state->m_fetch_rle_count = state->m_grom_base[state->m_fetch_offset++ % state->m_grom_size];
235		state->m_fetch_rle_literal = state->m_fetch_rle_count & 0x80;
236		state->m_fetch_rle_count &= 0x7f;
	235	m_fetch_rle_count = m_grom_base[m_fetch_offset++ % m_grom_size];
	236	m_fetch_rle_literal = m_fetch_rle_count & 0x80;
	237	m_fetch_rle_count &= 0x7f;
237	238
238		if (!state->m_fetch_rle_literal)
239		state->m_fetch_rle_value = state->m_grom_base[state->m_fetch_offset++ % state->m_grom_size];
	239	if (!m_fetch_rle_literal)
	240	m_fetch_rle_value = m_grom_base[m_fetch_offset++ % m_grom_size];
240	241	}
241	242
242		state->m_fetch_rle_count--;
243		if (state->m_fetch_rle_literal)
244		state->m_fetch_rle_value = state->m_grom_base[state->m_fetch_offset++ % state->m_grom_size];
	243	m_fetch_rle_count--;
	244	if (m_fetch_rle_literal)
	245	m_fetch_rle_value = m_grom_base[m_fetch_offset++ % m_grom_size];
245	246
246		return ~~state->~~m_fetch_rle_value;
	247	return m_fetch_rle_value;
247	248	}
248	249
249	250
250		~~INLINE~~ void ~~consume_rle(~~itech8_state *s~~tat~~e, int count)
	251	inline void itech8_state::consume_rle(int count)
251	252	{
252	253	while (count)
253	254	{
254	255	int num_to_consume;
255	256
256		if (~~state->~~m_fetch_rle_count == 0)
	257	if (m_fetch_rle_count == 0)
257	258	{
258		state->m_fetch_rle_count = state->m_grom_base[state->m_fetch_offset++ % state->m_grom_size];
259		state->m_fetch_rle_literal = state->m_fetch_rle_count & 0x80;
260		state->m_fetch_rle_count &= 0x7f;
	259	m_fetch_rle_count = m_grom_base[m_fetch_offset++ % m_grom_size];
	260	m_fetch_rle_literal = m_fetch_rle_count & 0x80;
	261	m_fetch_rle_count &= 0x7f;
261	262
262		if (!state->m_fetch_rle_literal)
263		state->m_fetch_rle_value = state->m_grom_base[state->m_fetch_offset++ % state->m_grom_size];
	263	if (!m_fetch_rle_literal)
	264	m_fetch_rle_value = m_grom_base[m_fetch_offset++ % m_grom_size];
264	265	}
265	266
266		num_to_consume = (count < ~~state->~~m_fetch_rle_count) ? count : ~~state->~~m_fetch_rle_count;
	267	num_to_consume = (count < m_fetch_rle_count) ? count : m_fetch_rle_count;
267	268	count -= num_to_consume;
268	269
269		state->m_fetch_rle_count -= num_to_consume;
270		if (state->m_fetch_rle_literal)
271		state->m_fetch_offset += num_to_consume;
	270	m_fetch_rle_count -= num_to_consume;
	271	if (m_fetch_rle_literal)
	272	m_fetch_offset += num_to_consume;
272	273	}
273	274	}
274	275
r20828	r20829
280	281	*
281	282	*************************************/
282	283
283		~~static~~ void perform_blit(address_space &space)
	284	void itech8_state::perform_blit(address_space &space)
284	285	{
285		itech8_state *state = space.machine().driver_data<itech8_state>();
286		struct tms34061_display &tms_state = state->m_tms_state;
287		UINT8 *blitter_data = state->m_blitter_data;
288		offs_t addr = state->m_tms_state.regs[TMS34061_XYADDRESS] \| ((tms_state.regs[TMS34061_XYOFFSET] & 0x300) << 8);
	286	struct tms34061_display &tms_state = m_tms_state;
	287	UINT8 *blitter_data = m_blitter_data;
	288	offs_t addr = m_tms_state.regs[TMS34061_XYADDRESS] \| ((tms_state.regs[TMS34061_XYOFFSET] & 0x300) << 8);
289	289	UINT8 shift = (BLITTER_FLAGS & BLITFLAG_SHIFT) ? 4 : 0;
290	290	int transparent = (BLITTER_FLAGS & BLITFLAG_TRANSPARENT);
291	291	int ydir = (BLITTER_FLAGS & BLITFLAG_YFLIP) ? -1 : 1;
r20828	r20829
304	304	if (FULL_LOGGING)
305	305	logerror("Blit: scan=%d src=%06x @ (%05x) for %dx%d ... flags=%02x\n",
306	306	space.machine().primary_screen->vpos(),
307		(~~state->~~m_grom_bank << 16) \| (BLITTER_ADDRHI << 8) \| BLITTER_ADDRLO,
	307	(m_grom_bank << 16) \| (BLITTER_ADDRHI << 8) \| BLITTER_ADDRLO,
308	308	tms_state.regs[TMS34061_XYADDRESS] \| ((tms_state.regs[TMS34061_XYOFFSET] & 0x300) << 8),
309	309	BLITTER_WIDTH, BLITTER_HEIGHT, BLITTER_FLAGS);
310	310
311	311	/* initialize the fetcher */
312		state->m_fetch_offset = (state->m_grom_bank << 16) \| (BLITTER_ADDRHI << 8) \| BLITTER_ADDRLO;
313		state->m_fetch_rle_count = 0;
	312	m_fetch_offset = (m_grom_bank << 16) \| (BLITTER_ADDRHI << 8) \| BLITTER_ADDRLO;
	313	m_fetch_rle_count = 0;
314	314
315	315	/* RLE starts with a couple of extra 0's */
316	316	if (rle)
317		~~state->~~m_fetch_offset += 2;
	317	m_fetch_offset += 2;
318	318
319	319	/* select 4-bit versus 8-bit transparency */
320	320	if (BLITTER_OUTPUT & 0x40)
r20828	r20829
346	346	/* skip src and dest */
347	347	addr += xdir * (width + skip[0] + skip[1]);
348	348	if (rle)
349		consume_rle(~~state,~~ width + skip[0] + skip[1]);
	349	consume_rle(width + skip[0] + skip[1]);
350	350	else
351		consume_raw(~~state,~~ width + skip[0] + skip[1]);
	351	consume_raw(width + skip[0] + skip[1]);
352	352
353	353	/* back up one and reverse directions */
354	354	addr -= xdir;
r20828	r20829
363	363	/* skip left */
364	364	addr += xdir * skip[y & 1];
365	365	if (rle)
366		consume_rle(s~~tate, s~~kip[y & 1]);
	366	consume_rle(skip[y & 1]);
367	367	else
368		consume_raw(s~~tate, s~~kip[y & 1]);
	368	consume_raw(skip[y & 1]);
369	369
370	370	/* loop over width */
371	371	for (x = 0; x < width; x++)
372	372	{
373		UINT8 pix = rle ? fetch_next_rle(~~state~~) : fetch_next_raw(~~state~~);
	373	UINT8 pix = rle ? fetch_next_rle() : fetch_next_raw();
374	374
375	375	/* swap pixels for X flip in 4bpp mode */
376	376	if (xflip && transmaskhi != 0xff)
r20828	r20829
399	399	/* skip right */
400	400	addr += xdir * skip[~y & 1];
401	401	if (rle)
402		consume_rle(s~~tate, s~~kip[~y & 1]);
	402	consume_rle(skip[~y & 1]);
403	403	else
404		consume_raw(s~~tate, s~~kip[~y & 1]);
	404	consume_raw(skip[~y & 1]);
405	405
406	406	/* back up one and reverse directions */
407	407	addr -= xdir;
r20828	r20829
423	423	{
424	424	/* turn off blitting and generate an interrupt */
425	425	m_blit_in_progress = 0;
426		itech8_update_interrupts(~~machine(),~~ -1, -1, 1);
	426	itech8_update_interrupts(-1, -1, 1);
427	427
428	428	if (FULL_LOGGING) logerror("------------ BLIT DONE (%d) --------------\n", machine().primary_screen->vpos());
429	429	}
r20828	r20829
450	450	/* a read from offset 3 clears the interrupt and returns the status */
451	451	if (offset == 3)
452	452	{
453		itech8_update_interrupts(~~machine(),~~ -1, -1, 0);
	453	itech8_update_interrupts(-1, -1, 0);
454	454	if (m_blit_in_progress)
455	455	result \|= 0x80;
456	456	else

trunk/src/mame/video/ironhors.c
r20828	r20829
150	150	m_bg_tilemap->set_scroll_rows(32);
151	151	}
152	152
153		~~static~~ void draw_sprites( ~~running_machine &machine,~~ bitmap_ind16 &bitmap, const rectangle &cliprect )
	153	void ironhors_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
154	154	{
155		ironhors_state *state = machine.driver_data<ironhors_state>();
156	155	int offs;
157	156	UINT8 *sr;
158	157
159		if (state->m_spriterambank != 0)
160		sr = state->m_spriteram;
	158	if (m_spriterambank != 0)
	159	sr = m_spriteram;
161	160	else
162		sr = ~~state->~~m_spriteram2;
	161	sr = m_spriteram2;
163	162
164		for (offs = 0; offs < ~~state->~~m_spriteram.bytes(); offs += 5)
	163	for (offs = 0; offs < m_spriteram.bytes(); offs += 5)
165	164	{
166	165	int sx = sr[offs + 3];
167	166	int sy = sr[offs + 2];
168	167	int flipx = sr[offs + 4] & 0x20;
169	168	int flipy = sr[offs + 4] & 0x40;
170	169	int code = (sr[offs] << 2) + ((sr[offs + 1] & 0x03) << 10) + ((sr[offs + 1] & 0x0c) >> 2);
171		int color = ((sr[offs + 1] & 0xf0) >> 4) + 16 * state->m_palettebank;
172		// int mod = state->flip_screen() ? -8 : 8;
	170	int color = ((sr[offs + 1] & 0xf0) >> 4) + 16 * m_palettebank;
	171	// int mod = flip_screen() ? -8 : 8;
173	172
174		if (~~state->~~flip_screen())
	173	if (flip_screen())
175	174	{
176	175	sx = 240 - sx;
177	176	sy = 240 - sy;
r20828	r20829
182	181	switch (sr[offs + 4] & 0x0c)
183	182	{
184	183	case 0x00: /* 16x16 */
185		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	184	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
186	185	code/4,
187	186	color,
188	187	flipx,flipy,
r20828	r20829
191	190
192	191	case 0x04: /* 16x8 */
193	192	{
194		if (~~state->~~flip_screen()) sy += 8; // this fixes the train wheels' position
	193	if (flip_screen()) sy += 8; // this fixes the train wheels' position
195	194
196		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	195	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
197	196	code & ~1,
198	197	color,
199	198	flipx,flipy,
200	199	flipx?sx+8:sx,sy,0);
201		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	200	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
202	201	code \| 1,
203	202	color,
204	203	flipx,flipy,
r20828	r20829
208	207
209	208	case 0x08: /* 8x16 */
210	209	{
211		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	210	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
212	211	code & ~2,
213	212	color,
214	213	flipx,flipy,
215	214	sx,flipy?sy+8:sy,0);
216		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	215	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
217	216	code \| 2,
218	217	color,
219	218	flipx,flipy,
r20828	r20829
223	222
224	223	case 0x0c: /* 8x8 */
225	224	{
226		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	225	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
227	226	code,
228	227	color,
229	228	flipx,flipy,
r20828	r20829
242	241	m_bg_tilemap->set_scrollx(row, m_scroll[row]);
243	242
244	243	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
245		draw_sprites(~~machine(),~~ bitmap, cliprect);
	244	draw_sprites(bitmap, cliprect);
246	245	return 0;
247	246	}
248	247
r20828	r20829
263	262	m_bg_tilemap->set_scroll_rows(32);
264	263	}
265	264
266		~~static~~ void farwest_draw_sprites( ~~running_machine &machine,~~ bitmap_ind16 &bitmap, const rectangle &cliprect )
	265	void ironhors_state::farwest_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
267	266	{
268		ironhors_state *state = machine.driver_data<ironhors_state>();
269	267	int offs;
270		UINT8 *sr = state->m_spriteram2;
271		UINT8 *sr2 = state->m_spriteram;
	268	UINT8 *sr = m_spriteram2;
	269	UINT8 *sr2 = m_spriteram;
272	270
273		for (offs = 0; offs < ~~state->~~m_spriteram.bytes(); offs += 4)
	271	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
274	272	{
275	273	int sx = sr[offs + 2];
276	274	int sy = sr[offs + 1];
277	275	int flipx = sr[offs + 3] & 0x20;
278	276	int flipy = sr[offs + 3] & 0x40;
279	277	int code = (sr[offs] << 2) + ((sr2[offs] & 0x03) << 10) + ((sr2[offs] & 0x0c) >> 2);
280		int color = ((sr2[offs] & 0xf0) >> 4) + 16 * ~~state->~~m_palettebank;
	278	int color = ((sr2[offs] & 0xf0) >> 4) + 16 * m_palettebank;
281	279
282	280	// int mod = flip_screen() ? -8 : 8;
283	281
r20828	r20829
292	290	switch (sr[offs + 3] & 0x0c)
293	291	{
294	292	case 0x00: /* 16x16 */
295		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	293	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
296	294	code/4,
297	295	color,
298	296	flipx,flipy,
r20828	r20829
301	299
302	300	case 0x04: /* 16x8 */
303	301	{
304		if (~~state->~~flip_screen()) sy += 8; // this fixes the train wheels' position
	302	if (flip_screen()) sy += 8; // this fixes the train wheels' position
305	303
306		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	304	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
307	305	code & ~1,
308	306	color,
309	307	flipx,flipy,
310	308	flipx?sx+8:sx,sy,0);
311		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	309	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
312	310	code \| 1,
313	311	color,
314	312	flipx,flipy,
r20828	r20829
318	316
319	317	case 0x08: /* 8x16 */
320	318	{
321		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	319	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
322	320	code & ~2,
323	321	color,
324	322	flipx,flipy,
325	323	sx,flipy?sy+8:sy,0);
326		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	324	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
327	325	code \| 2,
328	326	color,
329	327	flipx,flipy,
r20828	r20829
333	331
334	332	case 0x0c: /* 8x8 */
335	333	{
336		drawgfx_transpen(bitmap,cliprect,machine.gfx[2],
	334	drawgfx_transpen(bitmap,cliprect,machine().gfx[2],
337	335	code,
338	336	color,
339	337	flipx,flipy,
r20828	r20829
352	350	m_bg_tilemap->set_scrollx(row, m_scroll[row]);
353	351
354	352	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
355		farwest_draw_sprites(~~machine(),~~ bitmap, cliprect);
	353	farwest_draw_sprites(bitmap, cliprect);
356	354	return 0;
357	355	}

trunk/src/mame/video/irobot.c
r20828	r20829
76	76	}
77	77
78	78
79		~~static~~ void _irobot_poly_clear(~~running_machine &machine,~~ UINT8 *bitmap_base)
	79	void irobot_state::_irobot_poly_clear(UINT8 *bitmap_base)
80	80	{
81		memset(bitmap_base, 0, BITMAP_WIDTH * machine.primary_screen->height());
	81	memset(bitmap_base, 0, BITMAP_WIDTH * machine().primary_screen->height());
82	82	}
83	83
84		void irobot_poly_clear(~~running_machine &machine~~)
	84	void irobot_state::irobot_poly_clear()
85	85	{
86		irobot_state *state = machine.driver_data<irobot_state>();
87		UINT8 *bitmap_base = state->m_bufsel ? state->m_polybitmap2 : state->m_polybitmap1;
88		_irobot_poly_clear(machine, bitmap_base);
	86	UINT8 *bitmap_base = m_bufsel ? m_polybitmap2 : m_polybitmap1;
	87	_irobot_poly_clear(bitmap_base);
89	88	}
90	89
91	90
r20828	r20829
102	101	m_polybitmap2 = auto_alloc_array(machine(), UINT8, BITMAP_WIDTH * height);
103	102
104	103	/* clear the bitmaps so we start with valid palette look-up values for drawing */
105		_irobot_poly_clear(machine(), m_polybitmap1);
106		_irobot_poly_clear(machine(), m_polybitmap2);
	104	_irobot_poly_clear(m_polybitmap1);
	105	_irobot_poly_clear(m_polybitmap2);
107	106
108	107	/* Set clipping */
109	108	m_ir_xmin = m_ir_ymin = 0;
r20828	r20829
162	161	modified from a routine written by Andrew Caldwell
163	162	*/
164	163
165		~~static~~ void draw_line(~~running_machine &machine,~~ UINT8 *polybitmap, int x1, int y1, int x2, int y2, int col)
	164	void irobot_state::draw_line(UINT8 *polybitmap, int x1, int y1, int x2, int y2, int col)
166	165	{
167		irobot_state *state = machine.driver_data<irobot_state>();
168	166	int dx,dy,sx,sy,cx,cy;
169	167
170	168	dx = abs(x1-x2);
r20828	r20829
178	176	{
179	177	for (;;)
180	178	{
181		if (x1 >= ~~state->~~m_ir_xmin && x1 < ~~state->~~m_ir_xmax && y1 >= ~~state->~~m_ir_ymin && y1 < ~~state->~~m_ir_ymax)
	179	if (x1 >= m_ir_xmin && x1 < m_ir_xmax && y1 >= m_ir_ymin && y1 < m_ir_ymax)
182	180	draw_pixel (x1, y1, col);
183	181	if (x1 == x2) break;
184	182	x1 += sx;
r20828	r20829
194	192	{
195	193	for (;;)
196	194	{
197		if (x1 >= ~~state->~~m_ir_xmin && x1 < ~~state->~~m_ir_xmax && y1 >= ~~state->~~m_ir_ymin && y1 < ~~state->~~m_ir_ymax)
	195	if (x1 >= m_ir_xmin && x1 < m_ir_xmax && y1 >= m_ir_ymin && y1 < m_ir_ymax)
198	196	draw_pixel (x1, y1, col);
199	197	if (y1 == y2) break;
200	198	y1 += sy;
r20828	r20829
211	209
212	210	#define ROUND_TO_PIXEL(x) ((x >> 7) - 128)
213	211
214		void irobot_run_video(~~running_machine &machine~~)
	212	void irobot_state::irobot_run_video()
215	213	{
216		irobot_state *state = machine.driver_data<irobot_state>();
217	214	UINT8 *polybitmap;
218		UINT16 combase16 = (UINT16 )~~state->~~m_combase;
	215	UINT16 combase16 = (UINT16 )m_combase;
219	216	int sx,sy,ex,ey,sx2,ey2;
220	217	int color;
221	218	UINT32 d1;
r20828	r20829
223	220	int shp;
224	221	INT32 word1,word2;
225	222
226		logerror("Starting Polygon Generator, Clear=%d\n",~~state->~~m_vg_clear);
	223	logerror("Starting Polygon Generator, Clear=%d\n",m_vg_clear);
227	224
228		if (state->m_bufsel)
229		polybitmap = state->m_polybitmap2;
	225	if (m_bufsel)
	226	polybitmap = m_polybitmap2;
230	227	else
231		polybitmap = ~~state->~~m_polybitmap1;
	228	polybitmap = m_polybitmap1;
232	229
233	230	lpnt=0;
234	231	while (lpnt < 0x7ff)
r20828	r20829
249	246	color = sy & 0x3f;
250	247	sx = ROUND_TO_PIXEL(sx);
251	248	sy = ROUND_TO_PIXEL(sy);
252		if (sx >= ~~state->~~m_ir_xmin && sx < ~~state->~~m_ir_xmax && sy >= ~~state->~~m_ir_ymin && sy < ~~state->~~m_ir_ymax)
	249	if (sx >= m_ir_xmin && sx < m_ir_xmax && sy >= m_ir_ymin && sy < m_ir_ymax)
253	250	draw_pixel(sx,sy,color);
254	251	spnt+=2;
255	252	}//while object
r20828	r20829
269	266	sx = combase16[spnt+3];
270	267	word1 = (INT16)combase16[spnt+2];
271	268	ex = sx + word1 * (ey - sy + 1);
272		draw_line(~~machine,~~ polybitmap, ROUND_TO_PIXEL(sx),sy,ROUND_TO_PIXEL(ex),ey,color);
	269	draw_line(polybitmap, ROUND_TO_PIXEL(sx),sy,ROUND_TO_PIXEL(ex),ey,color);
273	270	spnt+=4;
274	271	}//while object
275	272	}//if line
r20828	r20829
303	300
304	301	while(1)
305	302	{
306		if (sy >= ~~state->~~m_ir_ymin && sy < ~~state->~~m_ir_ymax)
	303	if (sy >= m_ir_ymin && sy < m_ir_ymax)
307	304	{
308	305	int x1 = ROUND_TO_PIXEL(sx);
309	306	int x2 = ROUND_TO_PIXEL(sx2);
310	307	int temp;
311	308
312	309	if (x1 > x2) temp = x1, x1 = x2, x2 = temp;
313		if (x1 < state->m_ir_xmin) x1 = state->m_ir_xmin;
314		if (x2 >= state->m_ir_xmax) x2 = state->m_ir_xmax - 1;
	310	if (x1 < m_ir_xmin) x1 = m_ir_xmin;
	311	if (x2 >= m_ir_xmax) x2 = m_ir_xmax - 1;
315	312	if (x1 < x2)
316	313	fill_hline(x1 + 1, x2, sy, color);
317	314	}

199869 Revisions