Previous

199869 Revisions

Next

r21028 Wednesday 13th February, 2013 at 13:43:43 UTC by Miodrag Milanović
Modernization of drivers part 23 (no whatsnew)

[src/mame/drivers]

cham24.c clayshoo.c dacholer.c discoboy.c dominob.c dreamwld.c drtomy.c ettrivia.c famibox.c galaxi.c gamecstl.c gpworld.c jollyjgr.c littlerb.c midqslvr.c mirax.c mjsister.c mlanding.c neoprint.c nexus3d.c nyny.c onetwo.c panicr.c savquest.c segald.c sliver.c srmp6.c ssfindo.c taitowlf.c thayers.c voyager.c xtom3d.c

trunk/src/mame/drivers/jollyjgr.c

r21027	r21028
142	142	UINT32 screen_update_jollyjgr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
143	143	UINT32 screen_update_fspider(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
144	144	INTERRUPT_GEN_MEMBER(jollyjgr_interrupt);
	145	void draw_bitmap( bitmap_ind16 &bitmap );
145	146	};
146	147
147	148
r21027	r21028
456	457	m_bg_tilemap->set_scroll_cols(32);
457	458	}
458	459
459		static void draw_bitmap( running_machine &machine, bitmap_ind16 &bitmap )
	460	void jollyjgr_state::draw_bitmap( bitmap_ind16 &bitmap )
460	461	{
461		jollyjgr_state *state = machine.driver_data<jollyjgr_state>();
462	462	int x, y, count;
463	463	int i, bit0, bit1, bit2;
464	464	int color;
r21027	r21028
470	470	{
471	471	for(i = 0; i < 8; i++)
472	472	{
473		bit0 = (state->m_bitmap[count] >> i) & 1;
474		bit1 = (state->m_bitmap[count + 0x2000] >> i) & 1;
475		bit2 = (state->m_bitmap[count + 0x4000] >> i) & 1;
	473	bit0 = (m_bitmap[count] >> i) & 1;
	474	bit1 = (m_bitmap[count + 0x2000] >> i) & 1;
	475	bit2 = (m_bitmap[count + 0x4000] >> i) & 1;
476	476	color = bit0 | (bit1 << 1) | (bit2 << 2);
477	477
478	478	if(color)
479	479	{
480		if(state->m_flip_x && state->m_flip_y)
	480	if(m_flip_x && m_flip_y)
481	481	bitmap.pix16(y, x * 8 + i) = color + 32;
482		else if(state->m_flip_x && !state->m_flip_y)
	482	else if(m_flip_x && !m_flip_y)
483	483	bitmap.pix16(255 - y, x * 8 + i) = color + 32;
484		else if(!state->m_flip_x && state->m_flip_y)
	484	else if(!m_flip_x && m_flip_y)
485	485	bitmap.pix16(y, 255 - x * 8 - i) = color + 32;
486	486	else
487	487	bitmap.pix16(255 - y, 255 - x * 8 - i) = color + 32;
r21027	r21028
503	503	if(m_pri) //used in Frog & Spiders level 3
504	504	{
505	505	if(!(m_bitmap_disable))
506		draw_bitmap(machine(), bitmap);
	506	draw_bitmap(bitmap);
507	507
508	508	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
509	509	}
r21027	r21028
512	512	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
513	513
514	514	if(!(m_bitmap_disable))
515		draw_bitmap(machine(), bitmap);
	515	draw_bitmap(bitmap);
516	516	}
517	517
518	518	/* Sprites are the same as in Galaxian */

trunk/src/mame/drivers/gamecstl.c

r21027	r21028
121	121	virtual void video_start();
122	122	UINT32 screen_update_gamecstl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
123	123	IRQ_CALLBACK_MEMBER(irq_callback);
	124	void draw_char(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int ch, int att, int x, int y);
	125	void intel82439tx_init();
124	126	};
125	127
126	128
r21027	r21028
139	141	palette_set_color(machine(), i, cga_palette[i]);
140	142	}
141	143
142		static void draw_char(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int ch, int att, int x, int y)
	144	void gamecstl_state::draw_char(bitmap_ind16 &bitmap, const rectangle &cliprect, gfx_element *gfx, int ch, int att, int x, int y)
143	145	{
144	146	int i,j;
145	147	const UINT8 *dp;
r21027	r21028
232	234	state->m_mxtc_config_reg[reg] = data;
233	235	}
234	236
235		static void intel82439tx_init(running_machine &machine)
	237	void gamecstl_state::intel82439tx_init()
236	238	{
237		gamecstl_state *state = machine.driver_data<gamecstl_state>();
238		state->m_mxtc_config_reg[0x60] = 0x02;
239		state->m_mxtc_config_reg[0x61] = 0x02;
240		state->m_mxtc_config_reg[0x62] = 0x02;
241		state->m_mxtc_config_reg[0x63] = 0x02;
242		state->m_mxtc_config_reg[0x64] = 0x02;
243		state->m_mxtc_config_reg[0x65] = 0x02;
	239	m_mxtc_config_reg[0x60] = 0x02;
	240	m_mxtc_config_reg[0x61] = 0x02;
	241	m_mxtc_config_reg[0x62] = 0x02;
	242	m_mxtc_config_reg[0x63] = 0x02;
	243	m_mxtc_config_reg[0x64] = 0x02;
	244	m_mxtc_config_reg[0x65] = 0x02;
244	245	}
245	246
246	247	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21027	r21028
759	760
760	761	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, gamecstl_set_keyb_int);
761	762
762		intel82439tx_init(machine());
	763	intel82439tx_init();
763	764
764	765	kbdc8042_init(machine(), &at8042);
765	766	}

trunk/src/mame/drivers/famibox.c

r21027	r21028
112	112	UINT32 screen_update_famibox(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
113	113	TIMER_CALLBACK_MEMBER(famicombox_attract_timer_callback);
114	114	TIMER_CALLBACK_MEMBER(famicombox_gameplay_timer_callback);
	115	void set_mirroring(famibox_state *state, int mirroring);
	116	void famicombox_bankswitch(UINT8 bank);
	117	void famicombox_reset();
115	118	};
116	119
117	120	/******************************************************
r21027	r21028
121	124	*******************************************************/
122	125
123	126	#if 0
124		static void set_mirroring(famibox_state *state, int mirroring)
	127	void famibox_state::set_mirroring(famibox_state *state, int mirroring)
125	128	{
126	129	switch(mirroring)
127	130	{
128	131	case PPU_MIRROR_LOW:
129		state->m_nt_page[0] = state->m_nt_page[1] = state->m_nt_page[2] = state->m_nt_page[3] = state->m_nt_ram;
	132	m_nt_page[0] = m_nt_page[1] = m_nt_page[2] = m_nt_page[3] = m_nt_ram;
130	133	break;
131	134	case PPU_MIRROR_HIGH:
132		state->m_nt_page[0] = state->m_nt_page[1] = state->m_nt_page[2] = state->m_nt_page[3] = state->m_nt_ram + 0x400;
	135	m_nt_page[0] = m_nt_page[1] = m_nt_page[2] = m_nt_page[3] = m_nt_ram + 0x400;
133	136	break;
134	137	case PPU_MIRROR_HORZ:
135		state->m_nt_page[0] = state->m_nt_ram;
136		state->m_nt_page[1] = state->m_nt_ram;
137		state->m_nt_page[2] = state->m_nt_ram + 0x400;
138		state->m_nt_page[3] = state->m_nt_ram + 0x400;
	138	m_nt_page[0] = m_nt_ram;
	139	m_nt_page[1] = m_nt_ram;
	140	m_nt_page[2] = m_nt_ram + 0x400;
	141	m_nt_page[3] = m_nt_ram + 0x400;
139	142	break;
140	143	case PPU_MIRROR_VERT:
141		state->m_nt_page[0] = state->m_nt_ram;
142		state->m_nt_page[1] = state->m_nt_ram + 0x400;
143		state->m_nt_page[2] = state->m_nt_ram;
144		state->m_nt_page[3] = state->m_nt_ram + 0x400;
	144	m_nt_page[0] = m_nt_ram;
	145	m_nt_page[1] = m_nt_ram + 0x400;
	146	m_nt_page[2] = m_nt_ram;
	147	m_nt_page[3] = m_nt_ram + 0x400;
145	148	break;
146	149	case PPU_MIRROR_NONE:
147	150	default:
148		state->m_nt_page[0] = state->m_nt_ram;
149		state->m_nt_page[1] = state->m_nt_ram + 0x400;
150		state->m_nt_page[2] = state->m_nt_ram + 0x800;
151		state->m_nt_page[3] = state->m_nt_ram + 0xc00;
	151	m_nt_page[0] = m_nt_ram;
	152	m_nt_page[1] = m_nt_ram + 0x400;
	153	m_nt_page[2] = m_nt_ram + 0x800;
	154	m_nt_page[3] = m_nt_ram + 0xc00;
152	155	break;
153	156	}
154	157	}
r21027	r21028
234	237	System
235	238
236	239	*******************************************************/
237		static void famicombox_bankswitch(running_machine &machine, UINT8 bank)
	240	void famibox_state::famicombox_bankswitch(UINT8 bank)
238	241	{
239	242	struct
240	243	{
r21027	r21028
263	266	{ 0x00, "menu",         0, 0x4000, 0x8000 },
264	267	};
265	268
266		//  famibox_state *state = machine.driver_data<famibox_state>();
267	269
268	270	for (int i = 0; i < sizeof(famicombox_banks)/sizeof(famicombox_banks[0]); i++ )
269	271	{
270	272	if ( bank == famicombox_banks[i].bank ||
271	273	famicombox_banks[i].bank == 0 )
272	274	{
273		machine.root_device().membank("cpubank1")->set_base(machine.root_device().memregion(famicombox_banks[i].memory_region)->base() + famicombox_banks[i].bank1_offset);
274		machine.root_device().membank("cpubank2")->set_base(machine.root_device().memregion(famicombox_banks[i].memory_region)->base() + famicombox_banks[i].bank2_offset);
275		machine.root_device().membank("ppubank1")->set_base(machine.root_device().memregion(famicombox_banks[i].memory_region)->base() + famicombox_banks[i].ppubank_offset);
	275	machine().root_device().membank("cpubank1")->set_base(machine().root_device().memregion(famicombox_banks[i].memory_region)->base() + famicombox_banks[i].bank1_offset);
	276	machine().root_device().membank("cpubank2")->set_base(machine().root_device().memregion(famicombox_banks[i].memory_region)->base() + famicombox_banks[i].bank2_offset);
	277	machine().root_device().membank("ppubank1")->set_base(machine().root_device().memregion(famicombox_banks[i].memory_region)->base() + famicombox_banks[i].ppubank_offset);
276	278	break;
277	279	}
278	280	}
279	281	}
280	282
281		static void famicombox_reset(running_machine &machine)
	283	void famibox_state::famicombox_reset()
282	284	{
283		famicombox_bankswitch(machine, 0);
284		machine.device("maincpu")->reset();
	285	famicombox_bankswitch(0);
	286	machine().device("maincpu")->reset();
285	287	}
286	288
287	289	TIMER_CALLBACK_MEMBER(famibox_state::famicombox_attract_timer_callback)
r21027	r21028
290	292	if ( BIT(m_exception_mask,1) )
291	293	{
292	294	m_exception_cause &= ~0x02;
293		famicombox_reset(machine());
	295	famicombox_reset();
294	296	}
295	297	}
296	298
r21027	r21028
305	307	if ( BIT(m_exception_mask,4) )
306	308	{
307	309	m_exception_cause &= ~0x10;
308		famicombox_reset(machine());
	310	famicombox_reset();
309	311	}
310	312	}
311	313	}
r21027	r21028
371	373	break;
372	374	case 4:
373	375	logerror("%s: bankswitch %x\n", machine().describe_context(), data );
374		famicombox_bankswitch(machine(), data & 0x3f);
	376	famicombox_bankswitch(data & 0x3f);
375	377	break;
376	378	default:
377	379	logerror("%s: Unhandled famibox_system_w(%x,%02x)\n", machine().describe_context(), offset, data );
r21027	r21028
410	412	if ( BIT(m_exception_mask, 3) )
411	413	{
412	414	m_exception_cause &= ~0x08;
413		famicombox_reset(machine());
	415	famicombox_reset();
414	416	}
415	417	}
416	418
r21027	r21028
427	429	if ( BIT(m_exception_mask,4) && (m_coins == 1) )
428	430	{
429	431	m_exception_cause &= ~0x10;
430		famicombox_reset(machine());
	432	famicombox_reset();
431	433	}
432	434	}
433	435	}
r21027	r21028
549	551
550	552	void famibox_state::machine_reset()
551	553	{
552		famicombox_bankswitch(machine(), 0);
	554	famicombox_bankswitch(0);
553	555	}
554	556
555	557	void famibox_state::machine_start()
r21027	r21028
563	565	machine().device("ppu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x2000, 0x3eff, read8_delegate(FUNC(famibox_state::famibox_nt_r), this), write8_delegate(FUNC(famibox_state::famibox_nt_w), this));
564	566	machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x1fff, "ppubank1");
565	567
566		famicombox_bankswitch(machine(), 0);
	568	famicombox_bankswitch(0);
567	569
568	570
569	571	m_attract_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(famibox_state::famicombox_attract_timer_callback),this));

trunk/src/mame/drivers/discoboy.c

r21027	r21028
87	87	virtual void machine_reset();
88	88	virtual void video_start();
89	89	UINT32 screen_update_discoboy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	90	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	91	void discoboy_setrombank( UINT8 data );
90	92	};
91	93
92	94
r21027	r21028
95	97	{
96	98	}
97	99
98		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	100	void discoboy_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
99	101	{
100		discoboy_state *state = machine.driver_data<discoboy_state>();
101	102	int flipscreen = 0;
102	103	int offs, sx, sy;
103	104
104	105	for (offs = 0x1000 - 0x40; offs >= 0; offs -= 0x20)
105	106	{
106		int code = state->m_ram_4[offs];
107		int attr = state->m_ram_4[offs + 1];
	107	int code = m_ram_4[offs];
	108	int attr = m_ram_4[offs + 1];
108	109	int color = attr & 0x0f;
109		sx = state->m_ram_4[offs + 3] + ((attr & 0x10) << 4);
110		sy = ((state->m_ram_4[offs + 2] + 8) & 0xff) - 8;
	110	sx = m_ram_4[offs + 3] + ((attr & 0x10) << 4);
	111	sy = ((m_ram_4[offs + 2] + 8) & 0xff) - 8;
111	112	code += (attr & 0xe0) << 3;
112	113
113	114	if (code >= 0x400)
114	115	{
115		if ((state->m_gfxbank & 0x30) == 0x00)
	116	if ((m_gfxbank & 0x30) == 0x00)
116	117	{
117	118	code = 0x400 + (code & 0x3ff);
118	119	}
119		else if ((state->m_gfxbank & 0x30) == 0x10)
	120	else if ((m_gfxbank & 0x30) == 0x10)
120	121	{
121	122	code = 0x400 + (code & 0x3ff) + 0x400;
122	123	}
123		else if ((state->m_gfxbank & 0x30) == 0x20)
	124	else if ((m_gfxbank & 0x30) == 0x20)
124	125	{
125	126	code = 0x400 + (code & 0x3ff) + 0x800;
126	127	}
127		else if ((state->m_gfxbank & 0x30) == 0x30)
	128	else if ((m_gfxbank & 0x30) == 0x30)
128	129	{
129	130	code = 0x400 + (code & 0x3ff) + 0xc00;
130	131	}
131	132	else
132	133	{
133		code = machine.rand();
	134	code = machine().rand();
134	135	}
135	136	}
136	137
137		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	138	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
138	139	code,
139	140	color,
140	141	flipscreen,0,
r21027	r21028
196	197	}
197	198	}
198	199
199		draw_sprites(machine(), bitmap, cliprect);
	200	draw_sprites(bitmap, cliprect);
200	201
201	202	return 0;
202	203	}
203	204
204	205	#ifdef UNUSED_FUNCTION
205		void discoboy_setrombank( running_machine &machine, UINT8 data )
	206	void discoboy_state::discoboy_setrombank( UINT8 data )
206	207	{
207		UINT8 *ROM = machine.root_device().memregion("maincpu")->base();
	208	UINT8 *ROM = machine().root_device().memregion("maincpu")->base();
208	209	data &= 0x2f;
209	210	space.machine().root_device().membank("bank1")->set_base(&ROM[0x6000 + (data * 0x1000)] );
210	211	}

trunk/src/mame/drivers/littlerb.c

r21027	r21028
85	85	#include "video/ramdac.h"
86	86	#include "sound/dac.h"
87	87
88		static void littlerb_draw_sprites(running_machine &machine);
89
90	88	class littlerb_state : public driver_device
91	89	{
92	90	public:
r21027	r21028
173	171
174	172	}
175	173
176		littlerb_draw_sprites(space.machine());
	174	littlerb_draw_sprites();
177	175
178	176
179	177	m_listoffset = 0;
r21027	r21028
203	201	virtual void video_start();
204	202	UINT32 screen_update_littlerb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
205	203	TIMER_DEVICE_CALLBACK_MEMBER(littlerb_scanline);
	204	void littlerb_recalc_regs();
	205	UINT16 littlerb_data_read(UINT16 mem_mask);
	206	void littlerb_data_write(UINT16 data, UINT16 mem_mask);
	207	void littlerb_recalc_address();
	208	UINT8 sound_data_shift();
	209	void draw_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect, int xsize,int ysize, UINT32 fulloffs, int xpos, int ypos );
	210	void littlerb_draw_sprites();
206	211	};
207	212
208	213
r21027	r21028
291	296	/* end VDP device to give us our own memory map */
292	297
293	298
294		static void littlerb_recalc_regs(running_machine &machine)
	299	void littlerb_state::littlerb_recalc_regs()
295	300	{
296		littlerb_state *state = machine.driver_data<littlerb_state>();
297		state->m_vdp_address_low = state->m_write_address&0xffff;
298		state->m_vdp_address_high = (state->m_write_address>>16)&0xffff;
	301	m_vdp_address_low = m_write_address&0xffff;
	302	m_vdp_address_high = (m_write_address>>16)&0xffff;
299	303	}
300	304
301	305
302		static UINT16 littlerb_data_read(running_machine &machine, UINT16 mem_mask)
	306	UINT16 littlerb_state::littlerb_data_read(UINT16 mem_mask)
303	307	{
304		littlerb_state *state = machine.driver_data<littlerb_state>();
305		UINT32 addr = state->m_write_address >> 3; // almost surely raw addresses are actually shifted by 3
306		address_space &vdp_space = machine.device<littlerb_vdp_device>("littlerbvdp")->space();
	308	UINT32 addr = m_write_address >> 3; // almost surely raw addresses are actually shifted by 3
	309	address_space &vdp_space = machine().device<littlerb_vdp_device>("littlerbvdp")->space();
307	310
308	311	return vdp_space.read_word(addr, mem_mask);
309	312	}
310	313
311		static void littlerb_data_write(running_machine &machine, UINT16 data, UINT16 mem_mask)
	314	void littlerb_state::littlerb_data_write(UINT16 data, UINT16 mem_mask)
312	315	{
313		littlerb_state *state = machine.driver_data<littlerb_state>();
314		UINT32 addr = state->m_write_address >> 3; // almost surely raw addresses are actually shifted by 3
315		address_space &vdp_space = machine.device<littlerb_vdp_device>("littlerbvdp")->space();
316		int mode = state->m_vdp_writemode;
	316	UINT32 addr = m_write_address >> 3; // almost surely raw addresses are actually shifted by 3
	317	address_space &vdp_space = machine().device<littlerb_vdp_device>("littlerbvdp")->space();
	318	int mode = m_vdp_writemode;
317	319
318	320
319		logerror("mode %04x, data %04x, mem_mask %04x (address %08x)\n", mode,  data, mem_mask, state->m_write_address >> 3);
	321	logerror("mode %04x, data %04x, mem_mask %04x (address %08x)\n", mode,  data, mem_mask, m_write_address >> 3);
320	322
321	323	if ((mode!=0x3800) && (mode !=0x2000) && (mode != 0xe000) && (mode != 0xf800))
322	324	{
r21027	r21028
327	329
328	330	// 2000 is used for palette writes which appears to be a RAMDAC, no auto-inc.
329	331	//  1ff80806 is our 'spritelist'
330		if (mode!=0x2000 && mode != 0xe000 && addr != 0x1ff80806) state->m_write_address+=0x10;
331		littlerb_recalc_regs(machine);
	332	if (mode!=0x2000 && mode != 0xe000 && addr != 0x1ff80806) m_write_address+=0x10;
	333	littlerb_recalc_regs();
332	334	}
333	335
334	336
r21027	r21028
339	341
340	342
341	343
342		static void littlerb_recalc_address(running_machine &machine)
	344	void littlerb_state::littlerb_recalc_address()
343	345	{
344		littlerb_state *state = machine.driver_data<littlerb_state>();
345		state->m_write_address = state->m_vdp_address_low | state->m_vdp_address_high<<16;
	346	m_write_address = m_vdp_address_low | m_vdp_address_high<<16;
346	347	}
347	348
348	349	READ16_MEMBER(littlerb_state::littlerb_vdp_r)
r21027	r21028
354	355	{
355	356	case 0: res = m_vdp_address_low; break;
356	357	case 1: res = m_vdp_address_high; break;
357		case 2: res = littlerb_data_read(machine(), mem_mask); break;
	358	case 2: res = littlerb_data_read(mem_mask); break;
358	359	case 3: res = m_vdp_writemode; break;
359	360	}
360	361
r21027	r21028
405	406	{
406	407	case 0:
407	408	COMBINE_DATA(&m_vdp_address_low);
408		littlerb_recalc_address(machine());
	409	littlerb_recalc_address();
409	410	break;
410	411
411	412	case 1:
412	413	COMBINE_DATA(&m_vdp_address_high);
413		littlerb_recalc_address(machine());
	414	littlerb_recalc_address();
414	415	break;
415	416
416	417
417	418	case 2:
418		littlerb_data_write(machine(), data, mem_mask);
	419	littlerb_data_write(data, mem_mask);
419	420	break;
420	421
421	422	case 3:
r21027	r21028
429	430	}
430	431
431	432	/* could be slightly different (timing wise, directly related to the irqs), but certainly they smoked some bad pot for this messy way ... */
432		static UINT8 sound_data_shift(running_machine &machine)
	433	UINT8 littlerb_state::sound_data_shift()
433	434	{
434		return ((machine.primary_screen->frame_number() % 16) == 0) ? 8 : 0;
	435	return ((machine().primary_screen->frame_number() % 16) == 0) ? 8 : 0;
435	436	}
436	437
437	438	/* l is SFX, r is BGM (they doesn't seem to share the same data ROM) */
438	439	WRITE16_MEMBER(littlerb_state::littlerb_l_sound_w)
439	440	{
440		m_sound_index_l = (data >> sound_data_shift(machine())) & 0xff;
	441	m_sound_index_l = (data >> sound_data_shift()) & 0xff;
441	442	m_sound_pointer_l = 0;
442	443	//popmessage("%04x %04x",m_sound_index_l,m_sound_index_r);
443	444	}
444	445
445	446	WRITE16_MEMBER(littlerb_state::littlerb_r_sound_w)
446	447	{
447		m_sound_index_r = (data >> sound_data_shift(machine())) & 0xff;
	448	m_sound_index_r = (data >> sound_data_shift()) & 0xff;
448	449	m_sound_pointer_r = 0;
449	450	//popmessage("%04x %04x",m_sound_index_l,m_sound_index_r);
450	451	}
r21027	r21028
606	607
607	608
608	609
609		static void draw_sprite(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int xsize,int ysize, UINT32 fulloffs, int xpos, int ypos )
	610	void littlerb_state::draw_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect, int xsize,int ysize, UINT32 fulloffs, int xpos, int ypos )
610	611	{
611	612	int x,y;
612	613	fulloffs >>= 3;
613		address_space &vdp_space = machine.device<littlerb_vdp_device>("littlerbvdp")->space();
	614	address_space &vdp_space = machine().device<littlerb_vdp_device>("littlerbvdp")->space();
614	615
615	616	for (y=0;y<ysize;y++)
616	617	{
r21027	r21028
643	644	}
644	645	}
645	646
646		static void littlerb_draw_sprites(running_machine &machine)
	647	void littlerb_state::littlerb_draw_sprites()
647	648	{
648		littlerb_state *state = machine.driver_data<littlerb_state>();
649	649	int x,y,offs;
650	650	int xsize,ysize;
651		UINT16* spriteregion = state->m_spritelist;
	651	UINT16* spriteregion = m_spritelist;
652	652	//littlerb_printf("frame\n");
653	653
654	654	int layer = 0;
655	655	int yoffset = 0;
656	656
657		littlerb_printf("m_listoffset %04x\n", state->m_listoffset );
	657	littlerb_printf("m_listoffset %04x\n", m_listoffset );
658	658
659	659	littlerb_printf("%04x %04x %04x %04x\n", spriteregion[0], spriteregion[1], spriteregion[2], spriteregion[3]);
660	660
r21027	r21028
663	663	int minx = 0 , maxx = 0x14f;
664	664	int miny = 0 , maxy = 0x11f;
665	665
666		for (offs=0;offs<(state->m_listoffset);)
	666	for (offs=0;offs<(m_listoffset);)
667	667	{
668	668	UINT32 read_dword = ((spriteregion[offs+1])<<16)+ (spriteregion[offs+0]);
669	669
r21027	r21028
694	694	if (spriteregion[offs+4]==0x6000)
695	695	{
696	696	if (spriteregion[offs+3] & 0x1000)
697		state->m_temp_bitmap_sprites_back->fill(0, state->m_temp_bitmap_sprites_back->cliprect());
	697	m_temp_bitmap_sprites_back->fill(0, m_temp_bitmap_sprites_back->cliprect());
698	698	}
699	699	else
700	700	{
701		if (spriteregion[offs+1] != 0xffd6) state->m_temp_bitmap_sprites->fill(0, state->m_temp_bitmap_sprites->cliprect());
	701	if (spriteregion[offs+1] != 0xffd6) m_temp_bitmap_sprites->fill(0, m_temp_bitmap_sprites->cliprect());
702	702	}
703	703
704	704
r21027	r21028
781	781	// used between levels, and on boss death to clip sprite at the ground for sinking effect
782	782
783	783
784		if (clip.min_x > state->m_temp_bitmap_sprites->cliprect().max_x)
785		clip.min_x =  state->m_temp_bitmap_sprites->cliprect().max_x;
	784	if (clip.min_x > m_temp_bitmap_sprites->cliprect().max_x)
	785	clip.min_x =  m_temp_bitmap_sprites->cliprect().max_x;
786	786
787		if (clip.min_x < state->m_temp_bitmap_sprites->cliprect().min_x)
788		clip.min_x =  state->m_temp_bitmap_sprites->cliprect().min_x;
	787	if (clip.min_x < m_temp_bitmap_sprites->cliprect().min_x)
	788	clip.min_x =  m_temp_bitmap_sprites->cliprect().min_x;
789	789
790		if (clip.max_x > state->m_temp_bitmap_sprites->cliprect().max_x)
791		clip.max_x =  state->m_temp_bitmap_sprites->cliprect().max_x;
	790	if (clip.max_x > m_temp_bitmap_sprites->cliprect().max_x)
	791	clip.max_x =  m_temp_bitmap_sprites->cliprect().max_x;
792	792
793		if (clip.max_x < state->m_temp_bitmap_sprites->cliprect().min_x)
794		clip.max_x =  state->m_temp_bitmap_sprites->cliprect().min_x;
	793	if (clip.max_x < m_temp_bitmap_sprites->cliprect().min_x)
	794	clip.max_x =  m_temp_bitmap_sprites->cliprect().min_x;
795	795
796	796
797		if (clip.min_y > state->m_temp_bitmap_sprites->cliprect().max_y)
798		clip.min_y =  state->m_temp_bitmap_sprites->cliprect().max_y;
	797	if (clip.min_y > m_temp_bitmap_sprites->cliprect().max_y)
	798	clip.min_y =  m_temp_bitmap_sprites->cliprect().max_y;
799	799
800		if (clip.min_y < state->m_temp_bitmap_sprites->cliprect().min_y)
801		clip.min_y =  state->m_temp_bitmap_sprites->cliprect().min_y;
	800	if (clip.min_y < m_temp_bitmap_sprites->cliprect().min_y)
	801	clip.min_y =  m_temp_bitmap_sprites->cliprect().min_y;
802	802
803		if (clip.max_y > state->m_temp_bitmap_sprites->cliprect().max_y)
804		clip.max_y =  state->m_temp_bitmap_sprites->cliprect().max_y;
	803	if (clip.max_y > m_temp_bitmap_sprites->cliprect().max_y)
	804	clip.max_y =  m_temp_bitmap_sprites->cliprect().max_y;
805	805
806		if (clip.max_y < state->m_temp_bitmap_sprites->cliprect().min_y)
807		clip.max_y =  state->m_temp_bitmap_sprites->cliprect().min_y;
	806	if (clip.max_y < m_temp_bitmap_sprites->cliprect().min_y)
	807	clip.max_y =  m_temp_bitmap_sprites->cliprect().min_y;
808	808
809	809
810	810	littlerb_alt_printf("%04x %04x %04x %04x %04x %04x\n", spriteregion[offs+0], spriteregion[offs+1], spriteregion[offs+2], spriteregion[offs+3], spriteregion[offs+4], spriteregion[offs+5]);
811	811
812		if (layer==0) draw_sprite(machine, *state->m_temp_bitmap_sprites, clip,xsize,ysize,fullcode,x,y);
813		else draw_sprite(machine, *state->m_temp_bitmap_sprites_back, clip,xsize,ysize,fullcode,x,y);
	812	if (layer==0) draw_sprite(*m_temp_bitmap_sprites, clip,xsize,ysize,fullcode,x,y);
	813	else draw_sprite(*m_temp_bitmap_sprites_back, clip,xsize,ysize,fullcode,x,y);
814	814
815	815
816	816	offs += 6;

trunk/src/mame/drivers/mjsister.c

r21027	r21028
63	63	UINT32 screen_update_mjsister(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
64	64	TIMER_CALLBACK_MEMBER(dac_callback);
65	65	void mjsister_redraw();
	66	void mjsister_plot0( int offset, UINT8 data );
	67	void mjsister_plot1( int offset, UINT8 data );
66	68	};
67	69
68	70
r21027	r21028
81	83	save_item(NAME(m_videoram1));
82	84	}
83	85
84		static void mjsister_plot0( running_machine &machine, int offset, UINT8 data )
	86	void mjsister_state::mjsister_plot0( int offset, UINT8 data )
85	87	{
86		mjsister_state *state = machine.driver_data<mjsister_state>();
87	88	int x, y, c1, c2;
88	89
89	90	x = offset & 0x7f;
90	91	y = offset / 0x80;
91	92
92		c1 = (data & 0x0f)        + state->m_colorbank * 0x20;
93		c2 = ((data & 0xf0) >> 4) + state->m_colorbank * 0x20;
	93	c1 = (data & 0x0f)        + m_colorbank * 0x20;
	94	c2 = ((data & 0xf0) >> 4) + m_colorbank * 0x20;
94	95
95		state->m_tmpbitmap0->pix16(y, x * 2 + 0) = c1;
96		state->m_tmpbitmap0->pix16(y, x * 2 + 1) = c2;
	96	m_tmpbitmap0->pix16(y, x * 2 + 0) = c1;
	97	m_tmpbitmap0->pix16(y, x * 2 + 1) = c2;
97	98	}
98	99
99		static void mjsister_plot1( running_machine &machine, int offset, UINT8 data )
	100	void mjsister_state::mjsister_plot1( int offset, UINT8 data )
100	101	{
101		mjsister_state *state = machine.driver_data<mjsister_state>();
102	102	int x, y, c1, c2;
103	103
104	104	x = offset & 0x7f;
r21027	r21028
108	108	c2 = (data & 0xf0) >> 4;
109	109
110	110	if (c1)
111		c1 += state->m_colorbank * 0x20 + 0x10;
	111	c1 += m_colorbank * 0x20 + 0x10;
112	112	if (c2)
113		c2 += state->m_colorbank * 0x20 + 0x10;
	113	c2 += m_colorbank * 0x20 + 0x10;
114	114
115		state->m_tmpbitmap1->pix16(y, x * 2 + 0) = c1;
116		state->m_tmpbitmap1->pix16(y, x * 2 + 1) = c2;
	115	m_tmpbitmap1->pix16(y, x * 2 + 0) = c1;
	116	m_tmpbitmap1->pix16(y, x * 2 + 1) = c2;
117	117	}
118	118
119	119	WRITE8_MEMBER(mjsister_state::mjsister_videoram_w)
r21027	r21028
121	121	if (m_vrambank)
122	122	{
123	123	m_videoram1[offset] = data;
124		mjsister_plot1(machine(), offset, data);
	124	mjsister_plot1(offset, data);
125	125	}
126	126	else
127	127	{
128	128	m_videoram0[offset] = data;
129		mjsister_plot0(machine(), offset, data);
	129	mjsister_plot0(offset, data);
130	130	}
131	131	}
132	132
r21027	r21028
141	141
142	142	for (offs = 0; offs < 0x8000; offs++)
143	143	{
144		mjsister_plot0(machine(), offs, m_videoram0[offs]);
145		mjsister_plot1(machine(), offs, m_videoram1[offs]);
	144	mjsister_plot0(offs, m_videoram0[offs]);
	145	mjsister_plot1(offs, m_videoram1[offs]);
146	146	}
147	147	m_screen_redraw = 0;
148	148	}

trunk/src/mame/drivers/onetwo.c

r21027	r21028
76	76	virtual void machine_start();
77	77	virtual void video_start();
78	78	UINT32 screen_update_onetwo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	79	void set_color(int offset);
79	80	};
80	81
81	82
r21027	r21028
137	138	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
138	139	}
139	140
140		static void set_color(running_machine &machine, int offset)
	141	void onetwo_state::set_color(int offset)
141	142	{
142		onetwo_state *state = machine.driver_data<onetwo_state>();
143	143	int r, g, b;
144	144
145		r = state->m_paletteram[offset] & 0x1f;
146		g = state->m_paletteram2[offset] & 0x1f;
147		b = ((state->m_paletteram[offset] & 0x60) >> 2) | ((state->m_paletteram2[offset] & 0xe0) >> 5);
148		palette_set_color_rgb(machine, offset, pal5bit(r), pal5bit(g), pal5bit(b));
	145	r = m_paletteram[offset] & 0x1f;
	146	g = m_paletteram2[offset] & 0x1f;
	147	b = ((m_paletteram[offset] & 0x60) >> 2) | ((m_paletteram2[offset] & 0xe0) >> 5);
	148	palette_set_color_rgb(machine(), offset, pal5bit(r), pal5bit(g), pal5bit(b));
149	149	}
150	150
151	151	WRITE8_MEMBER(onetwo_state::palette1_w)
152	152	{
153	153	m_paletteram[offset] = data;
154		set_color(machine(), offset);
	154	set_color(offset);
155	155	}
156	156
157	157	WRITE8_MEMBER(onetwo_state::palette2_w)
158	158	{
159	159	m_paletteram2[offset] = data;
160		set_color(machine(), offset);
	160	set_color(offset);
161	161	}
162	162
163	163	/*************************************

trunk/src/mame/drivers/thayers.c

r21027	r21028
84	84	virtual void machine_reset();
85	85	TIMER_CALLBACK_MEMBER(intrq_tick);
86	86	TIMER_CALLBACK_MEMBER(ssi263_phoneme_tick);
	87	void check_interrupt();
87	88	};
88	89
89	90
r21027	r21028
95	96
96	97	/* Interrupts */
97	98
98		static void check_interrupt(running_machine &machine)
	99	void thayers_state::check_interrupt()
99	100	{
100		thayers_state *state = machine.driver_data<thayers_state>();
101		if (!state->m_timer_int || !state->m_data_rdy_int || !state->m_ssi_data_request)
	101	if (!m_timer_int || !m_data_rdy_int || !m_ssi_data_request)
102	102	{
103		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);
	103	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);
104	104	}
105	105	else
106	106	{
107		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
	107	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
108	108	}
109	109	}
110	110
r21027	r21028
146	146	{
147	147	m_timer_int = 1;
148	148
149		check_interrupt(machine());
	149	check_interrupt();
150	150	}
151	151
152	152	WRITE8_MEMBER(thayers_state::data_rdy_int_ack_w)
153	153	{
154	154	m_data_rdy_int = 1;
155	155
156		check_interrupt(machine());
	156	check_interrupt();
157	157	}
158	158
159	159	WRITE8_MEMBER(thayers_state::cop_d_w)
r21027	r21028
179	179	m_data_rdy_int = 0;
180	180	}
181	181
182		check_interrupt(machine());
	182	check_interrupt();
183	183	}
184	184
185	185	/* COP Communication */
r21027	r21028
475	475	TIMER_CALLBACK_MEMBER(thayers_state::ssi263_phoneme_tick)
476	476	{
477	477	m_ssi_data_request = 0;
478		check_interrupt(machine());
	478	check_interrupt();
479	479	}
480	480
481	481	WRITE8_MEMBER(thayers_state::ssi263_register_w)
r21027	r21028
493	493	ssi263.p = data & 0x3f;
494	494
495	495	m_ssi_data_request = 1;
496		check_interrupt(machine());
	496	check_interrupt();
497	497
498	498	switch (ssi263.mode)
499	499	{

trunk/src/mame/drivers/dominob.c

r21027	r21028
86	86	DECLARE_READ8_MEMBER(dominob_unk_port02_r);
87	87	virtual void video_start();
88	88	UINT32 screen_update_dominob(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	89	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
89	90	};
90	91
91	92	void dominob_state::video_start()
r21027	r21028
93	94	machine().gfx[0]->set_granularity(8);
94	95	}
95	96
96		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	97	void dominob_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
97	98	{
98		dominob_state *state = machine.driver_data<dominob_state>();
99	99	int offs;
100	100
101		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	101	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
102	102	{
103	103	int sx, sy, code;
104	104
105		sx = state->m_spriteram[offs];
106		sy = 248 - state->m_spriteram[offs + 1];
107		if (state->flip_screen_x()) sx = 248 - sx;
108		if (state->flip_screen_y()) sy = 248 - sy;
	105	sx = m_spriteram[offs];
	106	sy = 248 - m_spriteram[offs + 1];
	107	if (flip_screen_x()) sx = 248 - sx;
	108	if (flip_screen_y()) sy = 248 - sy;
109	109
110		code = state->m_spriteram[offs + 3] + ((state->m_spriteram[offs + 2] & 0x03) << 8)  ;
	110	code = m_spriteram[offs + 3] + ((m_spriteram[offs + 2] & 0x03) << 8)  ;
111	111
112		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	112	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
113	113	2 * code,
114		((state->m_spriteram[offs + 2] & 0xf8) >> 3)  ,
115		state->flip_screen_x(),state->flip_screen_y(),
116		sx,sy + (state->flip_screen_y() ? 8 : -8),0);
117		drawgfx_transpen(bitmap,cliprect,machine.gfx[0],
	114	((m_spriteram[offs + 2] & 0xf8) >> 3)  ,
	115	flip_screen_x(),flip_screen_y(),
	116	sx,sy + (flip_screen_y() ? 8 : -8),0);
	117	drawgfx_transpen(bitmap,cliprect,machine().gfx[0],
118	118	2 * code + 1,
119		((state->m_spriteram[offs + 2] & 0xf8) >> 3)  ,
120		state->flip_screen_x(),state->flip_screen_y(),
	119	((m_spriteram[offs + 2] & 0xf8) >> 3)  ,
	120	flip_screen_x(),flip_screen_y(),
121	121	sx,sy,0);
122	122	}
123	123	}
r21027	r21028
158	158	}
159	159	}
160	160
161		draw_sprites(machine(), bitmap, cliprect);
	161	draw_sprites(bitmap, cliprect);
162	162
163	163	return 0;
164	164	}

trunk/src/mame/drivers/galaxi.c

r21027	r21028
95	95	virtual void machine_reset();
96	96	virtual void video_start();
97	97	UINT32 screen_update_galaxi(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	98	void show_out(  );
98	99	};
99	100
100	101
r21027	r21028
213	214	Memory Maps
214	215	***************************************************************************/
215	216
216		static void show_out( running_machine &machine )
	217	void galaxi_state::show_out(  )
217	218	{
218		//  galaxi_state *state = machine.driver_data<galaxi_state>();
219		//  popmessage("%04x %04x %04x", state->m_out[0], state->m_out[1], state->m_out[2]);
	219	//  popmessage("%04x %04x %04x", m_out[0], m_out[1], m_out[2]);
220	220	}
221	221
222	222	WRITE16_MEMBER(galaxi_state::galaxi_500000_w)
223	223	{
224	224	COMBINE_DATA(&m_out[0]);
225		show_out(machine());
	225	show_out();
226	226	}
227	227
228	228	WRITE16_MEMBER(galaxi_state::galaxi_500002_w)
229	229	{
230	230	COMBINE_DATA(&m_out[1]);
231		show_out(machine());
	231	show_out();
232	232	}
233	233
234	234	WRITE16_MEMBER(galaxi_state::galaxi_500004_w)
r21027	r21028
263	263	}
264	264
265	265	COMBINE_DATA(&m_out[2]);
266		show_out(machine());
	266	show_out();
267	267	}
268	268
269	269	CUSTOM_INPUT_MEMBER(galaxi_state::ticket_r)

trunk/src/mame/drivers/mirax.c

r21027	r21028
131	131	virtual void palette_init();
132	132	UINT32 screen_update_mirax(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
133	133	INTERRUPT_GEN_MEMBER(mirax_vblank_irq);
	134	void draw_tilemap(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 draw_flag);
	135	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
134	136	};
135	137
136	138
r21027	r21028
163	165	}
164	166
165	167
166		static void draw_tilemap(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 draw_flag)
	168	void mirax_state::draw_tilemap(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 draw_flag)
167	169	{
168		mirax_state *state = machine.driver_data<mirax_state>();
169		gfx_element *gfx = machine.gfx[0];
	170	gfx_element *gfx = machine().gfx[0];
170	171	int y,x;
171	172	int res_x,res_y,wrapy;
172	173
r21027	r21028
174	175	{
175	176	for (x=0;x<32;x++)
176	177	{
177		int tile = state->m_videoram[32*y+x];
178		int color = (state->m_colorram[x*2]<<8) | (state->m_colorram[(x*2)+1]);
	178	int tile = m_videoram[32*y+x];
	179	int color = (m_colorram[x*2]<<8) | (m_colorram[(x*2)+1]);
179	180	int x_scroll = (color & 0xff00)>>8;
180	181	tile |= ((color & 0xe0)<<3);
181	182
182		res_x = (state->m_flipscreen_x) ? 248-x*8 : x*8;
183		res_y = (state->m_flipscreen_y) ? 248-y*8+x_scroll : y*8-x_scroll;
184		wrapy = (state->m_flipscreen_y) ? -256 : 256;
	183	res_x = (m_flipscreen_x) ? 248-x*8 : x*8;
	184	res_y = (m_flipscreen_y) ? 248-y*8+x_scroll : y*8-x_scroll;
	185	wrapy = (m_flipscreen_y) ? -256 : 256;
185	186
186	187	if((x <= 1 || x >= 30) ^ draw_flag)
187	188	{
188		drawgfx_opaque(bitmap,cliprect,gfx,tile,color & 7,(state->m_flipscreen_x),(state->m_flipscreen_y),res_x,res_y);
	189	drawgfx_opaque(bitmap,cliprect,gfx,tile,color & 7,(m_flipscreen_x),(m_flipscreen_y),res_x,res_y);
189	190	/* wrap-around */
190		drawgfx_opaque(bitmap,cliprect,gfx,tile,color & 7,(state->m_flipscreen_x),(state->m_flipscreen_y),res_x,res_y+wrapy);
	191	drawgfx_opaque(bitmap,cliprect,gfx,tile,color & 7,(m_flipscreen_x),(m_flipscreen_y),res_x,res_y+wrapy);
191	192	}
192	193	}
193	194	}
194	195	}
195	196
196		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	197	void mirax_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
197	198	{
198		mirax_state *state = machine.driver_data<mirax_state>();
199		UINT8 *spriteram = state->m_spriteram;
	199	UINT8 *spriteram = m_spriteram;
200	200	int count;
201	201
202	202	for(count=0;count<0x200;count+=4)
r21027	r21028
208	208
209	209	spr_offs = (spriteram[count+1] & 0x3f);
210	210	color = spriteram[count+2] & 0x7;
211		fx = (state->m_flipscreen_x) ^ ((spriteram[count+1] & 0x40) >> 6); //<- guess
212		fy = (state->m_flipscreen_y) ^ ((spriteram[count+1] & 0x80) >> 7);
	211	fx = (m_flipscreen_x) ^ ((spriteram[count+1] & 0x40) >> 6); //<- guess
	212	fy = (m_flipscreen_y) ^ ((spriteram[count+1] & 0x80) >> 7);
213	213
214	214	spr_offs += (spriteram[count+2] & 0xe0)<<1;
215	215	spr_offs += (spriteram[count+2] & 0x10)<<5;
216	216
217		y = (state->m_flipscreen_y) ? spriteram[count] : 0x100 - spriteram[count] - 16;
218		x = (state->m_flipscreen_x) ? 240 - spriteram[count+3] : spriteram[count+3];
	217	y = (m_flipscreen_y) ? spriteram[count] : 0x100 - spriteram[count] - 16;
	218	x = (m_flipscreen_x) ? 240 - spriteram[count+3] : spriteram[count+3];
219	219
220		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],spr_offs,color,fx,fy,x,y,0);
	220	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],spr_offs,color,fx,fy,x,y,0);
221	221	}
222	222	}
223	223
224	224	UINT32 mirax_state::screen_update_mirax(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
225	225	{
226		draw_tilemap(machine(),bitmap,cliprect,1);
227		draw_sprites(machine(),bitmap,cliprect);
228		draw_tilemap(machine(),bitmap,cliprect,0);
	226	draw_tilemap(bitmap,cliprect,1);
	227	draw_sprites(bitmap,cliprect);
	228	draw_tilemap(bitmap,cliprect,0);
229	229	return 0;
230	230	}
231	231

trunk/src/mame/drivers/ssfindo.c

r21027	r21028
258	258	required_device<cpu_device> m_maincpu;
259	259	required_memory_region m_region_user2;
260	260	required_ioport m_io_ps7500;
261		};
262	261
	262	typedef void (ssfindo_state::*ssfindo_speedup_func)(address_space &space);
	263	ssfindo_speedup_func ssfindo_speedup;
263	264
264		static void PS7500_startTimer0(running_machine &machine);
265		static void PS7500_startTimer1(running_machine &machine);
	265	void PS7500_startTimer0();
	266	void PS7500_startTimer1();
	267	void PS7500_reset();
	268	void ssfindo_speedups(address_space& space);
	269	void ppcar_speedups(address_space& space);
	270	};
266	271
267	272
268	273	UINT32 ssfindo_state::screen_update_ssfindo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r21027	r21028
309	314	}
310	315	}
311	316
312		static void PS7500_startTimer0(running_machine &machine)
	317	void ssfindo_state::PS7500_startTimer0()
313	318	{
314		ssfindo_state *state = machine.driver_data<ssfindo_state>();
315		int val=((state->m_PS7500_IO[T0low]&0xff)|((state->m_PS7500_IO[T0high]&0xff)<<8))>>1;
	319	int val=((m_PS7500_IO[T0low]&0xff)|((m_PS7500_IO[T0high]&0xff)<<8))>>1;
316	320
317	321	if(val==0)
318		state->m_PS7500timer0->adjust(attotime::never);
	322	m_PS7500timer0->adjust(attotime::never);
319	323	else
320		state->m_PS7500timer0->adjust(attotime::from_usec(val ), 0, attotime::from_usec(val ));
	324	m_PS7500timer0->adjust(attotime::from_usec(val ), 0, attotime::from_usec(val ));
321	325	}
322	326
323	327	TIMER_CALLBACK_MEMBER(ssfindo_state::PS7500_Timer1_callback)
r21027	r21028
329	333	}
330	334	}
331	335
332		static void PS7500_startTimer1(running_machine &machine)
	336	void ssfindo_state::PS7500_startTimer1()
333	337	{
334		ssfindo_state *state = machine.driver_data<ssfindo_state>();
335		int val=((state->m_PS7500_IO[T1low]&0xff)|((state->m_PS7500_IO[T1high]&0xff)<<8))>>1;
	338	int val=((m_PS7500_IO[T1low]&0xff)|((m_PS7500_IO[T1high]&0xff)<<8))>>1;
336	339	if(val==0)
337		state->m_PS7500timer1->adjust(attotime::never);
	340	m_PS7500timer1->adjust(attotime::never);
338	341	else
339		state->m_PS7500timer1->adjust(attotime::from_usec(val ), 0, attotime::from_usec(val ));
	342	m_PS7500timer1->adjust(attotime::from_usec(val ), 0, attotime::from_usec(val ));
340	343	}
341	344
342	345	INTERRUPT_GEN_MEMBER(ssfindo_state::ssfindo_interrupt)
r21027	r21028
348	351	}
349	352	}
350	353
351		static void PS7500_reset(running_machine &machine)
	354	void ssfindo_state::PS7500_reset()
352	355	{
353		ssfindo_state *state = machine.driver_data<ssfindo_state>();
354		state->m_PS7500_IO[IOCR]            =   0x3f;
355		state->m_PS7500_IO[VIDCR]       =   0;
	356	m_PS7500_IO[IOCR]            =   0x3f;
	357	m_PS7500_IO[VIDCR]       =   0;
356	358
357		state->m_PS7500timer0->adjust( attotime::never);
358		state->m_PS7500timer1->adjust( attotime::never);
	359	m_PS7500timer0->adjust( attotime::never);
	360	m_PS7500timer1->adjust( attotime::never);
359	361	}
360	362
361		typedef void (*ssfindo_speedup_func)(address_space &space);
362		ssfindo_speedup_func ssfindo_speedup;
363	363
364		static void ssfindo_speedups(address_space& space)
	364	void ssfindo_state::ssfindo_speedups(address_space& space)
365	365	{
366	366	if (space.device().safe_pc()==0x2d6c8) // ssfindo
367	367	space.device().execute().spin_until_time(attotime::from_usec(20));
r21027	r21028
369	369	space.device().execute().spin_until_time(attotime::from_usec(20));
370	370	}
371	371
372		static void ppcar_speedups(address_space& space)
	372	void ssfindo_state::ppcar_speedups(address_space& space)
373	373	{
374	374	if (space.device().safe_pc()==0x000bc8) // ppcar
375	375	space.device().execute().spin_until_time(attotime::from_usec(20));
r21027	r21028
402	402	return (m_PS7500_IO[IRQSTA] & m_PS7500_IO[IRQMSKA]) | 0x80;
403	403
404	404	case IOCR: //TODO: nINT1, OD[n] p.81
405		if (ssfindo_speedup) ssfindo_speedup(space);
	405	if (ssfindo_speedup) (this->*ssfindo_speedup)(space);
406	406
407	407	if( m_iocr_hack)
408	408	{
r21027	r21028
462	462	break;
463	463
464	464	case T1GO:
465		PS7500_startTimer1(machine());
	465	PS7500_startTimer1();
466	466	break;
467	467
468	468	case T0GO:
469		PS7500_startTimer0(machine());
	469	PS7500_startTimer0();
470	470	break;
471	471
472	472	case VIDEND:
r21027	r21028
621	621
622	622	void ssfindo_state::machine_reset()
623	623	{
624		PS7500_reset(machine());
	624	PS7500_reset();
625	625	}
626	626
627	627	static INPUT_PORTS_START( ssfindo )
r21027	r21028
874	874	{
875	875	DRIVER_INIT_CALL(common);
876	876	m_flashType=0;
877		ssfindo_speedup = ssfindo_speedups;
	877	ssfindo_speedup = &ssfindo_state::ssfindo_speedups;
878	878	m_iocr_hack=0;
879	879	}
880	880
r21027	r21028
882	882	{
883	883	DRIVER_INIT_CALL(common);
884	884	m_flashType=1;
885		ssfindo_speedup = ppcar_speedups;
	885	ssfindo_speedup = &ssfindo_state::ppcar_speedups;
886	886	m_iocr_hack=0;
887	887	}
888	888

trunk/src/mame/drivers/gpworld.c

r21027	r21028
74	74	UINT32 screen_update_gpworld(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
75	75	INTERRUPT_GEN_MEMBER(vblank_callback_gpworld);
76	76	TIMER_CALLBACK_MEMBER(irq_stop);
	77	void gpworld_draw_tiles(bitmap_rgb32 &bitmap,const rectangle &cliprect);
	78	inline void draw_pixel(bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip);
	79	void gpworld_draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect);
77	80	};
78	81
79	82
r21027	r21028
85	88
86	89
87	90	/* VIDEO GOODS */
88		static void gpworld_draw_tiles(running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect)
	91	void gpworld_state::gpworld_draw_tiles(bitmap_rgb32 &bitmap,const rectangle &cliprect)
89	92	{
90		gpworld_state *state = machine.driver_data<gpworld_state>();
91	93	UINT8 characterX, characterY;
92	94
93	95	/* Temporarily set to 64 wide to accommodate two screens */
r21027	r21028
97	99	{
98	100	int current_screen_character = (characterY*64) + characterX;
99	101
100		drawgfx_transpen(bitmap, cliprect, machine.gfx[0], state->m_tile_ram[current_screen_character],
	102	drawgfx_transpen(bitmap, cliprect, machine().gfx[0], m_tile_ram[current_screen_character],
101	103	characterY, 0, 0, characterX*8, characterY*8, 0);
102	104	}
103	105	}
104	106	}
105	107
106		INLINE void draw_pixel(running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
	108	void gpworld_state::draw_pixel(bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
107	109	{
108	110	if (flip)
109	111	{
r21027	r21028
112	114	}
113	115
114	116	if (cliprect.contains(x, y))
115		bitmap.pix32(y, x) = machine.pens[color];
	117	bitmap.pix32(y, x) = machine().pens[color];
116	118	}
117	119
118		static void gpworld_draw_sprites(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	120	void gpworld_state::gpworld_draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect)
119	121	{
120		gpworld_state *state = machine.driver_data<gpworld_state>();
121	122	const int SPR_Y_TOP     = 0;
122	123	const int SPR_Y_BOTTOM  = 1;
123	124	const int SPR_X_LO      = 2;
r21027	r21028
126	127	const int SPR_SKIP_HI   = 5;
127	128	const int SPR_GFXOFS_LO = 6;
128	129	const int SPR_GFXOFS_HI = 7;
129		int flip = state->flip_screen();
	130	int flip = flip_screen();
130	131
131	132	int i;
132	133
133		UINT8 *GFX = state->memregion("gfx2")->base();
	134	UINT8 *GFX = memregion("gfx2")->base();
134	135
135	136	/* Heisted from Daphne which heisted it from MAME */
136	137	for (i = 0; i < 0x800; i += 8)
137	138	{
138		UINT8 *spr_reg = state->m_sprite_ram + i;
	139	UINT8 *spr_reg = m_sprite_ram + i;
139	140
140	141	if (spr_reg[SPR_Y_BOTTOM] && spr_reg[SPR_X_LO] != 0xff)
141	142	{
r21027	r21028
203	204	}
204	205
205	206	/* Daphne says "don't draw the pixel if it's black". */
206		draw_pixel(machine, bitmap,cliprect,x+0,y,palette_get_color(machine, pixel1 + (sprite_color*0x10 + 0x200)),flip);
207		draw_pixel(machine, bitmap,cliprect,x+1,y,palette_get_color(machine, pixel2 + (sprite_color*0x10 + 0x200)),flip);
208		draw_pixel(machine, bitmap,cliprect,x+2,y,palette_get_color(machine, pixel3 + (sprite_color*0x10 + 0x200)),flip);
209		draw_pixel(machine, bitmap,cliprect,x+3,y,palette_get_color(machine, pixel4 + (sprite_color*0x10 + 0x200)),flip);
	207	draw_pixel(bitmap,cliprect,x+0,y,palette_get_color(machine(), pixel1 + (sprite_color*0x10 + 0x200)),flip);
	208	draw_pixel(bitmap,cliprect,x+1,y,palette_get_color(machine(), pixel2 + (sprite_color*0x10 + 0x200)),flip);
	209	draw_pixel(bitmap,cliprect,x+2,y,palette_get_color(machine(), pixel3 + (sprite_color*0x10 + 0x200)),flip);
	210	draw_pixel(bitmap,cliprect,x+3,y,palette_get_color(machine(), pixel4 + (sprite_color*0x10 + 0x200)),flip);
210	211
211	212	x += 4;
212	213
r21027	r21028
230	231	{
231	232	bitmap.fill(0, cliprect);
232	233
233		gpworld_draw_tiles(machine(), bitmap, cliprect);
234		gpworld_draw_sprites(machine(), bitmap, cliprect);
	234	gpworld_draw_tiles(bitmap, cliprect);
	235	gpworld_draw_sprites(bitmap, cliprect);
235	236
236	237	return 0;
237	238	}

trunk/src/mame/drivers/segald.c

r21027	r21028
59	59	DECLARE_DRIVER_INIT(astron);
60	60	virtual void machine_start();
61	61	UINT32 screen_update_astron(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	62	void astron_draw_characters(bitmap_rgb32 &bitmap,const rectangle &cliprect);
	63	void astron_draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect);
62	64	};
63	65
64	66	/* VIDEO GOODS */
65		static void astron_draw_characters(running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect)
	67	void segald_state::astron_draw_characters(bitmap_rgb32 &bitmap,const rectangle &cliprect)
66	68	{
67		segald_state *state = machine.driver_data<segald_state>();
68	69	UINT8 characterX, characterY;
69	70
70	71	for (characterX = 0; characterX < 32; characterX++)
r21027	r21028
72	73	for (characterY = 0; characterY < 32; characterY++)
73	74	{
74	75	int current_screen_character = (characterY*32) + characterX;
75		drawgfx_transpen(bitmap, cliprect, machine.gfx[0], state->m_fix_ram[current_screen_character],
	76	drawgfx_transpen(bitmap, cliprect, machine().gfx[0], m_fix_ram[current_screen_character],
76	77	1, 0, 0, characterX*8, characterY*8, 0);
77	78	}
78	79	}
79	80	}
80	81
81		static void astron_draw_sprites(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	82	void segald_state::astron_draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect)
82	83	{
83	84	/* Heisted from Daphne */
84	85	const UINT8 SPR_Y_TOP     = 0;
r21027	r21028
90	91	/*  const UINT8 SPR_GFXOFS_LO = 6;*/
91	92	/*  const UINT8 SPR_GFXOFS_HI = 7;*/
92	93
93		segald_state *state = machine.driver_data<segald_state>();
94	94	int sx,sy;
95	95	int spr_number;
96	96	int spr_base;
r21027	r21028
98	98	for (spr_number = 0; spr_number < 32; spr_number++)
99	99	{
100	100	spr_base = 0x10 * spr_number;
101		sy = state->m_obj_ram[spr_base + SPR_Y_TOP];
102		sx = state->m_obj_ram[spr_base + SPR_X_LO];
	101	sy = m_obj_ram[spr_base + SPR_Y_TOP];
	102	sx = m_obj_ram[spr_base + SPR_X_LO];
103	103
104	104	if (sx != 0 || sy != 0)
105	105	logerror("Hey!  A sprite's not at 0,0 : %d %d", sx, sy);
r21027	r21028
111	111	{
112	112	bitmap.fill(0, cliprect);
113	113
114		astron_draw_characters(machine(), bitmap, cliprect);
115		astron_draw_sprites(machine(), bitmap, cliprect);
	114	astron_draw_characters(bitmap, cliprect);
	115	astron_draw_sprites(bitmap, cliprect);
116	116
117	117	return 0;
118	118	}

trunk/src/mame/drivers/srmp6.c

r21027	r21028
106	106	DECLARE_DRIVER_INIT(INIT);
107	107	virtual void video_start();
108	108	UINT32 screen_update_srmp6(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	109	void update_palette();
	110	UINT32 process(UINT8 b,UINT32 dst_offset);
109	111	};
110	112
111	113	#define VERBOSE 0
r21027	r21028
122	124	8*64
123	125	};
124	126
125		static void update_palette(running_machine &machine)
	127	void srmp6_state::update_palette()
126	128	{
127		srmp6_state *state = machine.driver_data<srmp6_state>();
128	129	INT8 r, g ,b;
129		int brg = state->m_brightness - 0x60;
	130	int brg = m_brightness - 0x60;
130	131	int i;
131	132
132	133	for(i = 0; i < 0x800; i++)
133	134	{
134		r = state->m_generic_paletteram_16[i] >>  0 & 0x1F;
135		g = state->m_generic_paletteram_16[i] >>  5 & 0x1F;
136		b = state->m_generic_paletteram_16[i] >> 10 & 0x1F;
	135	r = m_generic_paletteram_16[i] >>  0 & 0x1F;
	136	g = m_generic_paletteram_16[i] >>  5 & 0x1F;
	137	b = m_generic_paletteram_16[i] >> 10 & 0x1F;
137	138
138	139	if(brg < 0) {
139	140	r += (r * brg) >> 5;
r21027	r21028
151	152	b += ((0x1F - b) * brg) >> 5;
152	153	if(b > 0x1F) b = 0x1F;
153	154	}
154		palette_set_color(machine, i, MAKE_RGB(r << 3, g << 3, b << 3));
	155	palette_set_color(machine(), i, MAKE_RGB(r << 3, g << 3, b << 3));
155	156	}
156	157	}
157	158
r21027	r21028
339	340	data = (!data)?0x60:(data == 0x5e)?0x60:data;
340	341	if (m_brightness != data) {
341	342	m_brightness = data;
342		update_palette(machine());
	343	update_palette();
343	344	}
344	345	break;
345	346
r21027	r21028
368	369
369	370
370	371	/* DMA RLE stuff - the same as CPS3 */
371		static UINT32 process(running_machine &machine,UINT8 b,UINT32 dst_offset)
	372	UINT32 srmp6_state::process(UINT8 b,UINT32 dst_offset)
372	373	{
373		srmp6_state *state = machine.driver_data<srmp6_state>();
374	374	int l=0;
375	375
376		UINT8 *tram=(UINT8*)state->m_tileram;
	376	UINT8 *tram=(UINT8*)m_tileram;
377	377
378		if (state->m_lastb == state->m_lastb2)  //rle
	378	if (m_lastb == m_lastb2)  //rle
379	379	{
380	380	int i;
381	381	int rle=(b+1)&0xff;
382	382
383	383	for(i=0;i<rle;++i)
384	384	{
385		tram[dst_offset + state->m_destl] = state->m_lastb;
386		machine.gfx[0]->mark_dirty((dst_offset + state->m_destl)/0x40);
	385	tram[dst_offset + m_destl] = m_lastb;
	386	machine().gfx[0]->mark_dirty((dst_offset + m_destl)/0x40);
387	387
388	388	dst_offset++;
389	389	++l;
390	390	}
391		state->m_lastb2 = 0xffff;
	391	m_lastb2 = 0xffff;
392	392
393	393	return l;
394	394	}
395	395	else
396	396	{
397		state->m_lastb2 = state->m_lastb;
398		state->m_lastb = b;
399		tram[dst_offset + state->m_destl] = b;
400		machine.gfx[0]->mark_dirty((dst_offset + state->m_destl)/0x40);
	397	m_lastb2 = m_lastb;
	398	m_lastb = b;
	399	tram[dst_offset + m_destl] = b;
	400	machine().gfx[0]->mark_dirty((dst_offset + m_destl)/0x40);
401	401
402	402	return 1;
403	403	}
r21027	r21028
453	453	{
454	454	UINT8 real_byte;
455	455	real_byte = rom[srctab+p*2];
456		tempidx+=process(machine(),real_byte,tempidx);
	456	tempidx+=process(real_byte,tempidx);
457	457	real_byte = rom[srctab+p*2+1];//px[DMA_XOR((current_table_address+p*2+1))];
458		tempidx+=process(machine(),real_byte,tempidx);
	458	tempidx+=process(real_byte,tempidx);
459	459	}
460	460	else
461	461	{
462		tempidx+=process(machine(),p,tempidx);
	462	tempidx+=process(p,tempidx);
463	463	}
464	464
465	465	ctrl<<=1;

trunk/src/mame/drivers/cham24.c

r21027	r21028
89	89	virtual void video_start();
90	90	virtual void palette_init();
91	91	UINT32 screen_update_cham24(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	92	void cham24_set_mirroring( int mirroring );
92	93	};
93	94
94	95
95	96
96		static void cham24_set_mirroring( running_machine &machine, int mirroring )
	97	void cham24_state::cham24_set_mirroring( int mirroring )
97	98	{
98		cham24_state *state = machine.driver_data<cham24_state>();
99	99	switch(mirroring)
100	100	{
101	101	case PPU_MIRROR_LOW:
102		state->m_nt_page[0] = state->m_nt_page[1] = state->m_nt_page[2] = state->m_nt_page[3] = state->m_nt_ram;
	102	m_nt_page[0] = m_nt_page[1] = m_nt_page[2] = m_nt_page[3] = m_nt_ram;
103	103	break;
104	104	case PPU_MIRROR_HIGH:
105		state->m_nt_page[0] = state->m_nt_page[1] = state->m_nt_page[2] = state->m_nt_page[3] = state->m_nt_ram + 0x400;
	105	m_nt_page[0] = m_nt_page[1] = m_nt_page[2] = m_nt_page[3] = m_nt_ram + 0x400;
106	106	break;
107	107	case PPU_MIRROR_HORZ:
108		state->m_nt_page[0] = state->m_nt_ram;
109		state->m_nt_page[1] = state->m_nt_ram;
110		state->m_nt_page[2] = state->m_nt_ram + 0x400;
111		state->m_nt_page[3] = state->m_nt_ram + 0x400;
	108	m_nt_page[0] = m_nt_ram;
	109	m_nt_page[1] = m_nt_ram;
	110	m_nt_page[2] = m_nt_ram + 0x400;
	111	m_nt_page[3] = m_nt_ram + 0x400;
112	112	break;
113	113	case PPU_MIRROR_VERT:
114		state->m_nt_page[0] = state->m_nt_ram;
115		state->m_nt_page[1] = state->m_nt_ram + 0x400;
116		state->m_nt_page[2] = state->m_nt_ram;
117		state->m_nt_page[3] = state->m_nt_ram + 0x400;
	114	m_nt_page[0] = m_nt_ram;
	115	m_nt_page[1] = m_nt_ram + 0x400;
	116	m_nt_page[2] = m_nt_ram;
	117	m_nt_page[3] = m_nt_ram + 0x400;
118	118	break;
119	119	case PPU_MIRROR_NONE:
120	120	default:
121		state->m_nt_page[0] = state->m_nt_ram;
122		state->m_nt_page[1] = state->m_nt_ram + 0x400;
123		state->m_nt_page[2] = state->m_nt_ram + 0x800;
124		state->m_nt_page[3] = state->m_nt_ram + 0xc00;
	121	m_nt_page[0] = m_nt_ram;
	122	m_nt_page[1] = m_nt_ram + 0x400;
	123	m_nt_page[2] = m_nt_ram + 0x800;
	124	m_nt_page[3] = m_nt_ram + 0xc00;
125	125	break;
126	126	}
127	127	}
r21027	r21028
210	210	membank("bank1")->set_base(machine().root_device().memregion("gfx1")->base() + (0x2000 * gfx_bank));
211	211
212	212	// set gfx mirroring
213		cham24_set_mirroring(machine(), gfx_mirroring != 0 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
	213	cham24_set_mirroring(gfx_mirroring != 0 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
214	214
215	215	// switch PRG bank
216	216	if (prg_bank_page_size == 0)

trunk/src/mame/drivers/savquest.c

r21027	r21028
103	103	virtual void machine_start();
104	104	virtual void machine_reset();
105	105	IRQ_CALLBACK_MEMBER(irq_callback);
	106	void intel82439tx_init();
106	107	};
107	108
108	109	// Intel 82439TX System Controller (MXTC)
r21027	r21028
185	186	state->m_mxtc_config_reg[reg] = data;
186	187	}
187	188
188		static void intel82439tx_init(running_machine &machine)
	189	void savquest_state::intel82439tx_init()
189	190	{
190		savquest_state *state = machine.driver_data<savquest_state>();
191		state->m_mxtc_config_reg[0x60] = 0x02;
192		state->m_mxtc_config_reg[0x61] = 0x02;
193		state->m_mxtc_config_reg[0x62] = 0x02;
194		state->m_mxtc_config_reg[0x63] = 0x02;
195		state->m_mxtc_config_reg[0x64] = 0x02;
196		state->m_mxtc_config_reg[0x65] = 0x02;
	191	m_mxtc_config_reg[0x60] = 0x02;
	192	m_mxtc_config_reg[0x61] = 0x02;
	193	m_mxtc_config_reg[0x62] = 0x02;
	194	m_mxtc_config_reg[0x63] = 0x02;
	195	m_mxtc_config_reg[0x64] = 0x02;
	196	m_mxtc_config_reg[0x65] = 0x02;
197	197	}
198	198
199	199	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21027	r21028
623	623	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, savquest_set_keyb_int);
624	624
625	625	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(savquest_state::irq_callback),this));
626		intel82439tx_init(machine());
	626	intel82439tx_init();
627	627
628	628	kbdc8042_init(machine(), &at8042);
629	629	}

trunk/src/mame/drivers/nexus3d.c

r21027	r21028
51	51	virtual void machine_reset();
52	52	virtual void video_start();
53	53	UINT32 screen_update_nexus3d(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	54	void nexus3d_flash_reset();
54	55	};
55	56
56	57
r21027	r21028
61	62	// Flash handling is very similar (but not 100% identical) to the stuff used in cavesh3 (command structure seems very slightly different, probably due to larger size)
62	63	// this is just a skeleton implementation
63	64
64		void nexus3d_flash_reset(running_machine& machine)
	65	void nexus3d_state::nexus3d_flash_reset()
65	66	{
66		nexus3d_state *state = machine.driver_data<nexus3d_state>();
67		state->m_last_flash_cmd = 0x00;
68		state->m_flash_addr_seq = 0;
69		state->m_flash_addr = 0;
	67	m_last_flash_cmd = 0x00;
	68	m_flash_addr_seq = 0;
	69	m_flash_addr = 0;
70	70
71		state->m_flash_page_addr = 0;
	71	m_flash_page_addr = 0;
72	72	}
73	73
74	74	READ8_MEMBER(nexus3d_state::n3d_flash_r)
r21027	r21028
189	189
190	190	void nexus3d_state::machine_reset()
191	191	{
192		nexus3d_flash_reset(machine());
	192	nexus3d_flash_reset();
193	193	}
194	194
195	195	static MACHINE_CONFIG_START( nexus3d, nexus3d_state )

trunk/src/mame/drivers/midqslvr.c

r21027	r21028
99	99	virtual void machine_start();
100	100	virtual void machine_reset();
101	101	IRQ_CALLBACK_MEMBER(irq_callback);
	102	void intel82439tx_init();
102	103	};
103	104
104	105
r21027	r21028
197	198	state->m_mxtc_config_reg[reg] = data;
198	199	}
199	200
200		static void intel82439tx_init(running_machine &machine)
	201	void midqslvr_state::intel82439tx_init()
201	202	{
202		midqslvr_state *state = machine.driver_data<midqslvr_state>();
203		state->m_mxtc_config_reg[0x60] = 0x02;
204		state->m_mxtc_config_reg[0x61] = 0x02;
205		state->m_mxtc_config_reg[0x62] = 0x02;
206		state->m_mxtc_config_reg[0x63] = 0x02;
207		state->m_mxtc_config_reg[0x64] = 0x02;
208		state->m_mxtc_config_reg[0x65] = 0x02;
	203	m_mxtc_config_reg[0x60] = 0x02;
	204	m_mxtc_config_reg[0x61] = 0x02;
	205	m_mxtc_config_reg[0x62] = 0x02;
	206	m_mxtc_config_reg[0x63] = 0x02;
	207	m_mxtc_config_reg[0x64] = 0x02;
	208	m_mxtc_config_reg[0x65] = 0x02;
209	209	}
210	210
211	211	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21027	r21028
662	662	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, midqslvr_set_keyb_int);
663	663
664	664	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(midqslvr_state::irq_callback),this));
665		intel82439tx_init(machine());
	665	intel82439tx_init();
666	666
667	667	kbdc8042_init(machine(), &at8042);
668	668	}

trunk/src/mame/drivers/xtom3d.c

r21027	r21028
116	116	virtual void machine_start();
117	117	virtual void machine_reset();
118	118	IRQ_CALLBACK_MEMBER(irq_callback);
	119	void intel82439tx_init();
119	120	};
120	121
121	122	// Intel 82439TX System Controller (MXTC)
r21027	r21028
210	211	state->m_mxtc_config_reg[reg] = data;
211	212	}
212	213
213		static void intel82439tx_init(running_machine &machine)
	214	void xtom3d_state::intel82439tx_init()
214	215	{
215		xtom3d_state *state = machine.driver_data<xtom3d_state>();
216		state->m_mxtc_config_reg[0x60] = 0x02;
217		state->m_mxtc_config_reg[0x61] = 0x02;
218		state->m_mxtc_config_reg[0x62] = 0x02;
219		state->m_mxtc_config_reg[0x63] = 0x02;
220		state->m_mxtc_config_reg[0x64] = 0x02;
221		state->m_mxtc_config_reg[0x65] = 0x02;
	216	m_mxtc_config_reg[0x60] = 0x02;
	217	m_mxtc_config_reg[0x61] = 0x02;
	218	m_mxtc_config_reg[0x62] = 0x02;
	219	m_mxtc_config_reg[0x63] = 0x02;
	220	m_mxtc_config_reg[0x64] = 0x02;
	221	m_mxtc_config_reg[0x65] = 0x02;
222	222	}
223	223
224	224	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21027	r21028
654	654	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, xtom3d_set_keyb_int);
655	655
656	656	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(xtom3d_state::irq_callback),this));
657		intel82439tx_init(machine());
	657	intel82439tx_init();
658	658
659	659	kbdc8042_init(machine(), &at8042);
660	660	}

trunk/src/mame/drivers/nyny.c

r21027	r21028
131	131	virtual void machine_reset();
132	132	INTERRUPT_GEN_MEMBER(update_pia_1);
133	133	DECLARE_WRITE8_MEMBER(ic48_1_74123_output_changed);
	134	inline void shift_star_generator(  );
134	135	};
135	136
136	137
r21027	r21028
371	372	}
372	373
373	374
374		INLINE void shift_star_generator( running_machine &machine )
	375	void nyny_state::shift_star_generator(  )
375	376	{
376		nyny_state *state = machine.driver_data<nyny_state>();
377		state->m_star_shift_reg = (state->m_star_shift_reg << 1) | (((~state->m_star_shift_reg >> 15) & 0x01) ^ ((state->m_star_shift_reg >> 2) & 0x01));
	377	m_star_shift_reg = (m_star_shift_reg << 1) | (((~m_star_shift_reg >> 15) & 0x01) ^ ((m_star_shift_reg >> 2) & 0x01));
378	378	}
379	379
380	380
r21027	r21028
408	408	}
409	409
410	410	if (delay_counter == 0)
411		shift_star_generator(device->machine());
	411	state->shift_star_generator();
412	412	else
413	413	delay_counter = delay_counter - 1;
414	414	}

trunk/src/mame/drivers/drtomy.c

r21027	r21028
41	41	virtual void machine_reset();
42	42	virtual void video_start();
43	43	UINT32 screen_update_drtomy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	44	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
44	45	};
45	46
46	47
r21027	r21028
78	79	3  | xxxxxxxx xxxxxx-- | sprite code
79	80	*/
80	81
81		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	82	void drtomy_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
82	83	{
83		drtomy_state *state = machine.driver_data<drtomy_state>();
84	84	int i, x, y, ex, ey;
85		gfx_element *gfx = machine.gfx[0];
	85	gfx_element *gfx = machine().gfx[0];
86	86
87	87	static const int x_offset[2] = {0x0, 0x2};
88	88	static const int y_offset[2] = {0x0, 0x1};
89	89
90	90	for (i = 3; i < 0x1000 / 2; i += 4)
91	91	{
92		int sx = state->m_spriteram[i + 2] & 0x01ff;
93		int sy = (240 - (state->m_spriteram[i] & 0x00ff)) & 0x00ff;
94		int number = state->m_spriteram[i + 3];
95		int color = (state->m_spriteram[i + 2] & 0x1e00) >> 9;
96		int attr = (state->m_spriteram[i] & 0xfe00) >> 9;
	92	int sx = m_spriteram[i + 2] & 0x01ff;
	93	int sy = (240 - (m_spriteram[i] & 0x00ff)) & 0x00ff;
	94	int number = m_spriteram[i + 3];
	95	int color = (m_spriteram[i + 2] & 0x1e00) >> 9;
	96	int attr = (m_spriteram[i] & 0xfe00) >> 9;
97	97
98	98	int xflip = attr & 0x20;
99	99	int yflip = attr & 0x40;
r21027	r21028
134	134	{
135	135	m_tilemap_bg->draw(bitmap, cliprect, 0, 0);
136	136	m_tilemap_fg->draw(bitmap, cliprect, 0, 0);
137		draw_sprites(machine(), bitmap, cliprect);
	137	draw_sprites(bitmap, cliprect);
138	138	return 0;
139	139	}
140	140

trunk/src/mame/drivers/dacholer.c

r21027	r21028
91	91	virtual void palette_init();
92	92	UINT32 screen_update_dacholer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
93	93	INTERRUPT_GEN_MEMBER(sound_irq);
	94	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
94	95	};
95	96
96	97	TILE_GET_INFO_MEMBER(dacholer_state::get_bg_tile_info)
r21027	r21028
121	122	m_scroll_y = data;
122	123	}
123	124
124		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	125	void dacholer_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
125	126	{
126		dacholer_state *state = machine.driver_data<dacholer_state>();
127	127	int offs, code, attr, sx, sy, flipx, flipy;
128	128
129		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	129	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
130	130	{
131		code = state->m_spriteram[offs + 1];
132		attr = state->m_spriteram[offs + 2];
	131	code = m_spriteram[offs + 1];
	132	attr = m_spriteram[offs + 2];
133	133
134	134	flipx = attr & 0x10;
135	135	flipy = attr & 0x20;
136	136
137		sx = (state->m_spriteram[offs + 3] - 128) + 256 * (attr & 0x01);
138		sy = 255 - state->m_spriteram[offs];
	137	sx = (m_spriteram[offs + 3] - 128) + 256 * (attr & 0x01);
	138	sy = 255 - m_spriteram[offs];
139	139
140		if (state->flip_screen())
	140	if (flip_screen())
141	141	{
142	142	sx = 240 - sx;
143	143	sy = 240 - sy;
r21027	r21028
145	145	flipy = !flipy;
146	146	}
147	147
148		drawgfx_transpen(bitmap, cliprect, machine.gfx[2],
	148	drawgfx_transpen(bitmap, cliprect, machine().gfx[2],
149	149	code,
150	150	0,
151	151	flipx,flipy,
r21027	r21028
167	167	}
168	168
169	169	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
170		draw_sprites(machine(), bitmap, cliprect);
	170	draw_sprites(bitmap, cliprect);
171	171	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
172	172	return 0;
173	173	}

trunk/src/mame/drivers/sliver.c

r21027	r21028
114	114	DECLARE_WRITE8_MEMBER(oki_setbank);
115	115	virtual void video_start();
116	116	UINT32 screen_update_sliver(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	117	void plot_pixel_rgb(int x, int y, UINT32 r, UINT32 g, UINT32 b);
	118	void plot_pixel_pal(int x, int y, int addr);
	119	void blit_gfx();
	120	void render_jpeg();
117	121	};
118	122
119		static void plot_pixel_rgb(sliver_state *state, int x, int y, UINT32 r, UINT32 g, UINT32 b)
	123	void sliver_state::plot_pixel_rgb(int x, int y, UINT32 r, UINT32 g, UINT32 b)
120	124	{
121	125	//  printf("plot %d %d %d\n", r,g,b);
122	126
123	127	if (y < 0 || x < 0 || x > 383 || y > 255)
124	128	return;
125	129
126		state->m_bitmap_bg.pix32(y, x) = r | (g<<8) | (b<<16);
	130	m_bitmap_bg.pix32(y, x) = r | (g<<8) | (b<<16);
127	131	}
128	132
129		static void plot_pixel_pal(running_machine &machine, int x, int y, int addr)
	133	void sliver_state::plot_pixel_pal(int x, int y, int addr)
130	134	{
131		sliver_state *state = machine.driver_data<sliver_state>();
132	135	UINT32 r,g,b;
133	136
134	137	if (y < 0 || x < 0 || x > 383 || y > 255)
135	138	return;
136	139
137		b=(state->m_colorram[addr] << 2) | (state->m_colorram[addr] & 0x3);
138		g=(state->m_colorram[addr+0x100] << 2) | (state->m_colorram[addr+0x100] & 3);
139		r=(state->m_colorram[addr+0x200] << 2) | (state->m_colorram[addr+0x200] & 3);
	140	b=(m_colorram[addr] << 2) | (m_colorram[addr] & 0x3);
	141	g=(m_colorram[addr+0x100] << 2) | (m_colorram[addr+0x100] & 3);
	142	r=(m_colorram[addr+0x200] << 2) | (m_colorram[addr+0x200] & 3);
140	143
141		state->m_bitmap_fg.pix32(y, x) = r | (g<<8) | (b<<16);
	144	m_bitmap_fg.pix32(y, x) = r | (g<<8) | (b<<16);
142	145	}
143	146
144	147	WRITE16_MEMBER(sliver_state::fifo_data_w)
r21027	r21028
162	165	}
163	166	}
164	167
165		static void blit_gfx(running_machine &machine)
	168	void sliver_state::blit_gfx()
166	169	{
167		sliver_state *state = machine.driver_data<sliver_state>();
168	170	int tmpptr=0;
169		const UINT8 *rom = state->memregion("user1")->base();
	171	const UINT8 *rom = memregion("user1")->base();
170	172
171		while (tmpptr < state->m_fptr)
	173	while (tmpptr < m_fptr)
172	174	{
173	175	int x,y,romdata;
174	176	int w,h;
175		int romoffs=state->m_fifo[tmpptr+0]+(state->m_fifo[tmpptr+1] << 8)+(state->m_fifo[tmpptr+2] << 16);
	177	int romoffs=m_fifo[tmpptr+0]+(m_fifo[tmpptr+1] << 8)+(m_fifo[tmpptr+2] << 16);
176	178
177		w=state->m_fifo[tmpptr+3]+1;
178		h=state->m_fifo[tmpptr+4]+1;
	179	w=m_fifo[tmpptr+3]+1;
	180	h=m_fifo[tmpptr+4]+1;
179	181
180		if (state->m_fifo[tmpptr+7] == 0)
	182	if (m_fifo[tmpptr+7] == 0)
181	183	{
182	184	for (y=0; y < h; y++)
183	185	{
r21027	r21028
186	188	romdata = rom[romoffs&0x1fffff];
187	189	if (romdata)
188	190	{
189		plot_pixel_pal(machine, state->m_fifo[tmpptr+5]+state->m_fifo[tmpptr+3]-x, state->m_fifo[tmpptr+6]+state->m_fifo[tmpptr+4]-y, romdata);
	191	plot_pixel_pal(m_fifo[tmpptr+5]+m_fifo[tmpptr+3]-x, m_fifo[tmpptr+6]+m_fifo[tmpptr+4]-y, romdata);
190	192	}
191	193	romoffs++;
192	194	}
r21027	r21028
205	207
206	208	WRITE16_MEMBER(sliver_state::fifo_flush_w)
207	209	{
208		blit_gfx(machine());
	210	blit_gfx();
209	211	}
210	212
211	213
r21027	r21028
214	216	COMBINE_DATA(&m_jpeg1);
215	217	}
216	218
217		static void render_jpeg(running_machine &machine)
	219	void sliver_state::render_jpeg()
218	220	{
219		sliver_state *state = machine.driver_data<sliver_state>();
220	221	int x;
221		int addr = (int)state->m_jpeg2 + (((int)state->m_jpeg1) << 16);
	222	int addr = (int)m_jpeg2 + (((int)m_jpeg1) << 16);
222	223
223		state->m_bitmap_bg.fill(0);
	224	m_bitmap_bg.fill(0);
224	225	if (addr < 0)
225	226	{
226	227	return;
r21027	r21028
237	238	cinfo.err = jpeg_std_error(&jerr);
238	239	jpeg_create_decompress(&cinfo);
239	240
240		jpeg_mem_src(&cinfo, machine.root_device().memregion("user2")->base()+addr, machine.root_device().memregion("user2")->bytes()-addr);
	241	jpeg_mem_src(&cinfo, machine().root_device().memregion("user2")->base()+addr, machine().root_device().memregion("user2")->bytes()-addr);
241	242
242	243	jpeg_read_header(&cinfo, TRUE);
243	244	jpeg_start_decompress(&cinfo);
r21027	r21028
256	257	UINT8 b = buffer[0][(x*3)];
257	258	UINT8 g = buffer[0][(x*3)+1];
258	259	UINT8 r = buffer[0][(x*3)+2];
259		plot_pixel_rgb(state, x - x_offset + state->m_jpeg_x, y - y_offset - state->m_jpeg_y, r, g, b);
	260	plot_pixel_rgb(x - x_offset + m_jpeg_x, y - y_offset - m_jpeg_y, r, g, b);
260	261
261	262	}
262	263
r21027	r21028
274	275	{
275	276	COMBINE_DATA(&m_jpeg2);
276	277
277		render_jpeg(machine());
	278	render_jpeg();
278	279
279	280	}
280	281
r21027	r21028
297	298	{
298	299	m_jpeg_x = tmpx;
299	300	m_jpeg_y = tmpy;
300		render_jpeg(machine());
	301	render_jpeg();
301	302	}
302	303	}
303	304	else

trunk/src/mame/drivers/mlanding.c

r21027	r21028
79	79	virtual void video_start();
80	80	UINT32 screen_update_mlanding(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
81	81	TIMER_CALLBACK_MEMBER(dma_complete);
	82	int start_dma();
82	83	};
83	84
84	85
r21027	r21028
113	114	}
114	115
115	116	/* Return the number of pixels processed for timing purposes? */
116		static int start_dma(running_machine &machine)
	117	int mlanding_state::start_dma()
117	118	{
118		mlanding_state *state = machine.driver_data<mlanding_state>();
119	119	/* Traverse the DMA RAM list */
120	120	int offs;
121	121
r21027	r21028
130	130
131	131	int j, k;
132	132
133		UINT16 attr = state->m_dma_ram[offs];
	133	UINT16 attr = m_dma_ram[offs];
134	134
135	135	if (attr == 0)
136	136	continue;
137	137
138		x = state->m_dma_ram[offs + 1];
139		y = state->m_dma_ram[offs + 2];
140		colour = state->m_dma_ram[offs + 3];
	138	x = m_dma_ram[offs + 1];
	139	y = m_dma_ram[offs + 2];
	140	colour = m_dma_ram[offs + 3];
141	141
142	142	dx = x >> 11;
143	143	dy = y >> 11;
r21027	r21028
172	172	// Draw the 8x8 chunk
173	173	for (y1 = 0; y1 < 8; ++y1)
174	174	{
175		UINT16 *src = &state->m_ml_tileram[(code * 2 * 8) + y1*2];
176		UINT16 *dst = &state->m_g_ram[(y + k*8+y1)*512/2 + (j*8+x)/2];
	175	UINT16 *src = &m_ml_tileram[(code * 2 * 8) + y1*2];
	176	UINT16 *dst = &m_g_ram[(y + k*8+y1)*512/2 + (j*8+x)/2];
177	177
178	178	UINT8 p2 = *src & 0xff;
179	179	UINT8 p1 = *src++ >> 8;
r21027	r21028
220	220	for(y1 = 0; y1 < dy*8; y1++)
221	221	{
222	222	int x1;
223		UINT16 *dst = &state->m_g_ram[((y + y1) * 512/2) + x/2];
	223	UINT16 *dst = &m_g_ram[((y + y1) * 512/2) + x/2];
224	224
225	225	for(x1 = 0; x1 < dx*8; x1+=2)
226	226	{
r21027	r21028
324	324	int pixels;
325	325
326	326	// Return the number of pixels drawn?
327		pixels = start_dma(machine());
	327	pixels = start_dma();
328	328
329	329	if (pixels)
330	330	{

trunk/src/mame/drivers/neoprint.c

r21027	r21028
57	57	DECLARE_MACHINE_RESET(nprsp);
58	58	UINT32 screen_update_neoprint(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
59	59	UINT32 screen_update_nprsp(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	60	void draw_layer(bitmap_ind16 &bitmap,const rectangle &cliprect,int layer,int data_shift);
	61	void audio_cpu_assert_nmi();
60	62	};
61	63
62	64
r21027	r21028
73	75	---- ---- --?? ??xx [6] map register
74	76	*/
75	77
76		static void draw_layer(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,int layer,int data_shift)
	78	void neoprint_state::draw_layer(bitmap_ind16 &bitmap,const rectangle &cliprect,int layer,int data_shift)
77	79	{
78		neoprint_state *state = machine.driver_data<neoprint_state>();
79	80	int i, y, x;
80		gfx_element *gfx = machine.gfx[0];
	81	gfx_element *gfx = machine().gfx[0];
81	82	INT16 scrollx, scrolly;
82	83
83		i = (state->m_npvidregs[((layer*8)+0x06)/2] & 7) * 0x1000/4;
84		scrollx = ((state->m_npvidregs[((layer*8)+0x00)/2] - (0xd8 + layer*4)) & 0x03ff);
85		scrolly = ((state->m_npvidregs[((layer*8)+0x02)/2] - 0xffeb) & 0x03ff);
	84	i = (m_npvidregs[((layer*8)+0x06)/2] & 7) * 0x1000/4;
	85	scrollx = ((m_npvidregs[((layer*8)+0x00)/2] - (0xd8 + layer*4)) & 0x03ff);
	86	scrolly = ((m_npvidregs[((layer*8)+0x02)/2] - 0xffeb) & 0x03ff);
86	87
87	88	scrollx/=2;
88	89	scrolly/=2;
r21027	r21028
91	92	{
92	93	for (x=0;x<32;x++)
93	94	{
94		UINT16 dat = state->m_npvidram[i*2] >> data_shift; // a video register?
	95	UINT16 dat = m_npvidram[i*2] >> data_shift; // a video register?
95	96	UINT16 color;
96		if(state->m_npvidram[i*2+1] & 0x0020) // TODO: 8bpp switch?
97		color = ((state->m_npvidram[i*2+1] & 0x8000) << 1) | 0x200 | ((state->m_npvidram[i*2+1] & 0xff00) >> 7);
	97	if(m_npvidram[i*2+1] & 0x0020) // TODO: 8bpp switch?
	98	color = ((m_npvidram[i*2+1] & 0x8000) << 1) | 0x200 | ((m_npvidram[i*2+1] & 0xff00) >> 7);
98	99	else
99		color = ((state->m_npvidram[i*2+1] & 0xff00) >> 8) | ((state->m_npvidram[i*2+1] & 0x0010) << 4);
100		UINT8 fx = (state->m_npvidram[i*2+1] & 0x0040);
101		UINT8 fy = (state->m_npvidram[i*2+1] & 0x0080);
	100	color = ((m_npvidram[i*2+1] & 0xff00) >> 8) | ((m_npvidram[i*2+1] & 0x0010) << 4);
	101	UINT8 fx = (m_npvidram[i*2+1] & 0x0040);
	102	UINT8 fy = (m_npvidram[i*2+1] & 0x0080);
102	103
103	104	drawgfx_transpen(bitmap,cliprect,gfx,dat,color,fx,fy,x*16+scrollx,y*16-scrolly,0);
104	105	drawgfx_transpen(bitmap,cliprect,gfx,dat,color,fx,fy,x*16+scrollx-512,y*16-scrolly,0);
r21027	r21028
115	116	{
116	117	bitmap.fill(0, cliprect);
117	118
118		draw_layer(machine(),bitmap,cliprect,1,2);
119		draw_layer(machine(),bitmap,cliprect,0,2);
	119	draw_layer(bitmap,cliprect,1,2);
	120	draw_layer(bitmap,cliprect,0,2);
120	121
121	122	return 0;
122	123	}
r21027	r21028
125	126	{
126	127	bitmap.fill(0, cliprect);
127	128
128		draw_layer(machine(),bitmap,cliprect,1,0);
129		draw_layer(machine(),bitmap,cliprect,2,0);
130		draw_layer(machine(),bitmap,cliprect,0,0);
	129	draw_layer(bitmap,cliprect,1,0);
	130	draw_layer(bitmap,cliprect,2,0);
	131	draw_layer(bitmap,cliprect,0,0);
131	132
132	133	return 0;
133	134	}
r21027	r21028
165	166	return (m_audio_result << 8) | 0x00;
166	167	}
167	168
168		static void audio_cpu_assert_nmi(running_machine &machine)
	169	void neoprint_state::audio_cpu_assert_nmi()
169	170	{
170		machine.device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	171	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
171	172	}
172	173
173	174
r21027	r21028
183	184	{
184	185	soundlatch_byte_w(space, 0, data >> 8);
185	186
186		audio_cpu_assert_nmi(machine());
	187	audio_cpu_assert_nmi();
187	188
188	189	/* boost the interleave to let the audio CPU read the command */
189	190	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(50));

trunk/src/mame/drivers/voyager.c

r21027	r21028
70	70	virtual void machine_start();
71	71	virtual void machine_reset();
72	72	IRQ_CALLBACK_MEMBER(irq_callback);
	73	void intel82439tx_init();
73	74	};
74	75
75	76
r21027	r21028
263	264	state->m_mxtc_config_reg[reg] = data;
264	265	}
265	266
266		static void intel82439tx_init(running_machine &machine)
	267	void voyager_state::intel82439tx_init()
267	268	{
268		voyager_state *state = machine.driver_data<voyager_state>();
269		state->m_mxtc_config_reg[0x60] = 0x02;
270		state->m_mxtc_config_reg[0x61] = 0x02;
271		state->m_mxtc_config_reg[0x62] = 0x02;
272		state->m_mxtc_config_reg[0x63] = 0x02;
273		state->m_mxtc_config_reg[0x64] = 0x02;
274		state->m_mxtc_config_reg[0x65] = 0x02;
	269	m_mxtc_config_reg[0x60] = 0x02;
	270	m_mxtc_config_reg[0x61] = 0x02;
	271	m_mxtc_config_reg[0x62] = 0x02;
	272	m_mxtc_config_reg[0x63] = 0x02;
	273	m_mxtc_config_reg[0x64] = 0x02;
	274	m_mxtc_config_reg[0x65] = 0x02;
275	275	}
276	276
277	277	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21027	r21028
788	788
789	789	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, voyager_set_keyb_int);
790	790
791		intel82439tx_init(machine());
	791	intel82439tx_init();
792	792
793	793	kbdc8042_init(machine(), &at8042);
794	794	}

trunk/src/mame/drivers/clayshoo.c

r21027	r21028
42	42	virtual void machine_reset();
43	43	UINT32 screen_update_clayshoo(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
44	44	TIMER_CALLBACK_MEMBER(reset_analog_bit);
	45	UINT8 difficulty_input_port_r( int bit );
	46	void create_analog_timers(  );
45	47	};
46	48
47	49
r21027	r21028
57	59	}
58	60
59	61
60		static UINT8 difficulty_input_port_r( running_machine &machine, int bit )
	62	UINT8 clayshoo_state::difficulty_input_port_r( int bit )
61	63	{
62	64	UINT8 ret = 0;
63	65
64	66	/* read fake port and remap the buttons to 2 bits */
65		UINT8   raw = machine.root_device().ioport("FAKE")->read();
	67	UINT8   raw = machine().root_device().ioport("FAKE")->read();
66	68
67	69	if (raw & (1 << (bit + 1)))
68	70	ret = 0x03;     /* expert */
r21027	r21028
83	85	{
84	86	case 0x01:  ret = ioport("IN0")->read(); break;
85	87	case 0x02:  ret = ioport("IN1")->read(); break;
86		case 0x04:  ret = (ioport("IN2")->read() & 0xf0) | difficulty_input_port_r(machine(), 0) |
87		(difficulty_input_port_r(machine(), 3) << 2); break;
	88	case 0x04:  ret = (ioport("IN2")->read() & 0xf0) | difficulty_input_port_r(0) |
	89	(difficulty_input_port_r(3) << 2); break;
88	90	case 0x08:  ret = ioport("IN3")->read(); break;
89	91	case 0x10:
90	92	case 0x20:  break;  /* these two are not really used */
r21027	r21028
134	136	}
135	137
136	138
137		static void create_analog_timers( running_machine &machine )
	139	void clayshoo_state::create_analog_timers(  )
138	140	{
139		clayshoo_state *state = machine.driver_data<clayshoo_state>();
140		state->m_analog_timer_1 = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(clayshoo_state::reset_analog_bit),state));
141		state->m_analog_timer_2 = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(clayshoo_state::reset_analog_bit),state));
	141	m_analog_timer_1 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(clayshoo_state::reset_analog_bit),this));
	142	m_analog_timer_2 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(clayshoo_state::reset_analog_bit),this));
142	143	}
143	144
144	145
r21027	r21028
171	172
172	173	void clayshoo_state::machine_start()
173	174	{
174		create_analog_timers(machine());
	175	create_analog_timers();
175	176
176	177	/* register for state saving */
177	178	save_item(NAME(m_input_port_select));

trunk/src/mame/drivers/dreamwld.c

r21027	r21028
165	165	virtual void video_start();
166	166	UINT32 screen_update_dreamwld(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
167	167	void screen_eof_dreamwld(screen_device &screen, bool state);
	168	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
168	169	};
169	170
170	171
171	172
172		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	173	void dreamwld_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
173	174	{
174		dreamwld_state *state = machine.driver_data<dreamwld_state>();
175		gfx_element *gfx = machine.gfx[0];
176		UINT32 *source = state->m_spritebuf1;
177		UINT32 *finish = state->m_spritebuf1 + 0x1000 / 4;
178		UINT16 *redirect = (UINT16 *)state->memregion("spritelut")->base();
	175	gfx_element *gfx = machine().gfx[0];
	176	UINT32 *source = m_spritebuf1;
	177	UINT32 *finish = m_spritebuf1 + 0x1000 / 4;
	178	UINT16 *redirect = (UINT16 *)memregion("spritelut")->base();
179	179
180	180	while (source < finish)
181	181	{
r21027	r21028
394	394	tmptilemap0->draw(bitmap, cliprect, 0, 0);
395	395	tmptilemap1->draw(bitmap, cliprect, 0, 0);
396	396
397		draw_sprites(machine(), bitmap, cliprect);
	397	draw_sprites(bitmap, cliprect);
398	398
399	399	return 0;
400	400	}

trunk/src/mame/drivers/panicr.c

r21027	r21028
100	100	virtual void palette_init();
101	101	UINT32 screen_update_panicr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
102	102	TIMER_DEVICE_CALLBACK_MEMBER(panicr_scanline);
	103	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect );
103	104	};
104	105
105	106
r21027	r21028
224	225	colortable_configure_tilemap_groups(machine().colortable, m_txttilemap, machine().gfx[0], 0);
225	226	}
226	227
227		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect )
	228	void panicr_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect )
228	229	{
229		panicr_state *state = machine.driver_data<panicr_state>();
230		UINT8 *spriteram = state->m_spriteram;
	230	UINT8 *spriteram = m_spriteram;
231	231	int offs,flipx,flipy,x,y,color,sprite;
232	232
233	233	for (offs = 0; offs<0x1000; offs+=16)
r21027	r21028
239	239	if (spriteram[offs+1] & 0x40) x -= 0x100;
240	240
241	241	color = spriteram[offs+1] & 0x0f;
242		sprite = spriteram[offs+0] | (*state->m_spritebank << 8);
	242	sprite = spriteram[offs+0] | (*m_spritebank << 8);
243	243
244		drawgfx_transmask(bitmap,cliprect,machine.gfx[3],
	244	drawgfx_transmask(bitmap,cliprect,machine().gfx[3],
245	245	sprite,
246	246	color,flipx,flipy,x,y,
247		colortable_get_transpen_mask(machine.colortable, machine.gfx[3], color, 0));
	247	colortable_get_transpen_mask(machine().colortable, machine().gfx[3], color, 0));
248	248	}
249	249	}
250	250
r21027	r21028
254	254	m_txttilemap->mark_all_dirty();
255	255	m_bgtilemap->set_scrollx(0, m_scrollx);
256	256	m_bgtilemap->draw(bitmap, cliprect, 0,0);
257		draw_sprites(machine(),bitmap,cliprect);
	257	draw_sprites(bitmap,cliprect);
258	258	m_txttilemap->draw(bitmap, cliprect, 0,0);
259	259
260	260	return 0;

trunk/src/mame/drivers/ettrivia.c

r21027	r21028
62	62	virtual void palette_init();
63	63	UINT32 screen_update_ettrivia(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
64	64	INTERRUPT_GEN_MEMBER(ettrivia_interrupt);
	65	inline void get_tile_info(tile_data &tileinfo, int tile_index, UINT8 *vidram, int gfx_code);
65	66	};
66	67
67	68
r21027	r21028
196	197	GFXDECODE_ENTRY( "gfx2", 0, charlayout, 32*4, 32 )
197	198	GFXDECODE_END
198	199
199		INLINE void get_tile_info(running_machine &machine, tile_data &tileinfo, int tile_index, UINT8 *vidram, int gfx_code)
	200	void ettrivia_state::get_tile_info(tile_data &tileinfo, int tile_index, UINT8 *vidram, int gfx_code)
200	201	{
201		ettrivia_state *state = machine.driver_data<ettrivia_state>();
202	202	int code = vidram[tile_index];
203		int color = (code >> 5) + 8 * state->m_palreg;
	203	int color = (code >> 5) + 8 * m_palreg;
204	204
205		code += state->m_gfx_bank * 0x100;
	205	code += m_gfx_bank * 0x100;
206	206
207		SET_TILE_INFO(gfx_code,code,color,0);
	207	SET_TILE_INFO_MEMBER(gfx_code,code,color,0);
208	208	}
209	209
210	210	TILE_GET_INFO_MEMBER(ettrivia_state::get_tile_info_bg)
211	211	{
212		get_tile_info(machine(), tileinfo, tile_index, m_bg_videoram, 0);
	212	get_tile_info(tileinfo, tile_index, m_bg_videoram, 0);
213	213	}
214	214
215	215	TILE_GET_INFO_MEMBER(ettrivia_state::get_tile_info_fg)
216	216	{
217		get_tile_info(machine(), tileinfo, tile_index, m_fg_videoram, 1);
	217	get_tile_info(tileinfo, tile_index, m_fg_videoram, 1);
218	218	}
219	219
220	220	void ettrivia_state::palette_init()

trunk/src/mame/drivers/taitowlf.c

r21027	r21028
98	98	virtual void palette_init();
99	99	UINT32 screen_update_taitowlf(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
100	100	IRQ_CALLBACK_MEMBER(irq_callback);
	101	void intel82439tx_init();
101	102	};
102	103
103	104	#if !ENABLE_VGA
r21027	r21028
174	175	state->m_mxtc_config_reg[reg] = data;
175	176	}
176	177
177		static void intel82439tx_init(running_machine &machine)
	178	void taitowlf_state::intel82439tx_init()
178	179	{
179		taitowlf_state *state = machine.driver_data<taitowlf_state>();
180		state->m_mxtc_config_reg[0x60] = 0x02;
181		state->m_mxtc_config_reg[0x61] = 0x02;
182		state->m_mxtc_config_reg[0x62] = 0x02;
183		state->m_mxtc_config_reg[0x63] = 0x02;
184		state->m_mxtc_config_reg[0x64] = 0x02;
185		state->m_mxtc_config_reg[0x65] = 0x02;
	180	m_mxtc_config_reg[0x60] = 0x02;
	181	m_mxtc_config_reg[0x61] = 0x02;
	182	m_mxtc_config_reg[0x62] = 0x02;
	183	m_mxtc_config_reg[0x63] = 0x02;
	184	m_mxtc_config_reg[0x64] = 0x02;
	185	m_mxtc_config_reg[0x65] = 0x02;
186	186	}
187	187
188	188	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21027	r21028
703	703
704	704	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, taitowlf_set_keyb_int);
705	705
706		intel82439tx_init(machine());
	706	intel82439tx_init();
707	707
708	708	kbdc8042_init(machine(), &at8042);
709	709	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team