Previous

199869 Revisions

Next

r20827 Friday 8th February, 2013 at 12:49:41 UTC by Miodrag Milanović
Modernization of drivers part 7 (no whatsnew)

[src/mame/drivers]	hitme.c hyprduel.c
[src/mame/includes]	hcastle.h hexion.h higemaru.h himesiki.h hitme.h hnayayoi.h holeland.h homedata.h homerun.h hyhoo.h hyperspt.h hyprduel.h
[src/mame/video]	hcastle.c hexion.c higemaru.c himesiki.c hnayayoi.c holeland.c homedata.c homerun.c hyhoo.c hyperspt.c hyprduel.c

trunk/src/mame/drivers/hitme.c

r20826	r20827
126	126	*
127	127	*************************************/
128	128
129		static UINT8 read_port_and_t0( running_machine &machine, int port )
	129	UINT8 hitme_state::read_port_and_t0( int port )
130	130	{
131		hitme_state *state = machine.driver_data<hitme_state>();
132	131	static const char *const portnames[] = { "IN0", "IN1", "IN2", "IN3" };
133	132
134		UINT8 val = machine.root_device().ioport(portnames[port])->read();
135		if (machine.time() > state->m_timeout_time)
	133	UINT8 val = machine().root_device().ioport(portnames[port])->read();
	134	if (machine().time() > m_timeout_time)
136	135	val ^= 0x80;
137	136	return val;
138	137	}
139	138
140	139
141		static UINT8 read_port_and_t0_and_hblank( running_machine &machine, int port )
	140	UINT8 hitme_state::read_port_and_t0_and_hblank( int port )
142	141	{
143		UINT8 val = read_port_and_t0(machine, port);
144		if (machine.primary_screen->hpos() < (machine.primary_screen->width() * 9 / 10))
	142	UINT8 val = read_port_and_t0(port);
	143	if (machine().primary_screen->hpos() < (machine().primary_screen->width() * 9 / 10))
145	144	val ^= 0x04;
146	145	return val;
147	146	}
r20826	r20827
149	148
150	149	READ8_MEMBER(hitme_state::hitme_port_0_r)
151	150	{
152		return read_port_and_t0_and_hblank(machine(), 0);
	151	return read_port_and_t0_and_hblank(0);
153	152	}
154	153
155	154
156	155	READ8_MEMBER(hitme_state::hitme_port_1_r)
157	156	{
158		return read_port_and_t0(machine(), 1);
	157	return read_port_and_t0(1);
159	158	}
160	159
161	160
162	161	READ8_MEMBER(hitme_state::hitme_port_2_r)
163	162	{
164		return read_port_and_t0_and_hblank(machine(), 2);
	163	return read_port_and_t0_and_hblank(2);
165	164	}
166	165
167	166
168	167	READ8_MEMBER(hitme_state::hitme_port_3_r)
169	168	{
170		return read_port_and_t0(machine(), 3);
	169	return read_port_and_t0(3);
171	170	}
172	171
173	172

trunk/src/mame/drivers/hyprduel.c

r20826	r20827
45	45	Interrupts
46	46	***************************************************************************/
47	47
48		static void update_irq_state( running_machine &machine )
	48	void hyprduel_state::update_irq_state(  )
49	49	{
50		hyprduel_state *state = machine.driver_data<hyprduel_state>();
51		int irq = state->m_requested_int & ~*state->m_irq_enable;
	50	int irq = m_requested_int & ~*m_irq_enable;
52	51
53		state->m_maincpu->set_input_line(3, (irq & state->m_int_num) ? ASSERT_LINE : CLEAR_LINE);
	52	m_maincpu->set_input_line(3, (irq & m_int_num) ? ASSERT_LINE : CLEAR_LINE);
54	53	}
55	54
56	55	TIMER_CALLBACK_MEMBER(hyprduel_state::vblank_end_callback)
r20826	r20827
73	72	else
74	73	m_requested_int |= 0x12;        /* hsync */
75	74
76		update_irq_state(machine());
	75	update_irq_state();
77	76	}
78	77
79	78	READ16_MEMBER(hyprduel_state::hyprduel_irq_cause_r)
r20826	r20827
90	89	else
91	90	m_requested_int &= ~(data & *m_irq_enable);
92	91
93		update_irq_state(machine());
	92	update_irq_state();
94	93	}
95	94	}
96	95
r20826	r20827
255	254	TIMER_CALLBACK_MEMBER(hyprduel_state::hyprduel_blit_done)
256	255	{
257	256	m_requested_int |= 1 << m_blitter_bit;
258		update_irq_state(machine());
	257	update_irq_state();
259	258	}
260	259
261		INLINE int blt_read( const UINT8 *ROM, const int offs )
	260	inline int hyprduel_state::blt_read( const UINT8 *ROM, const int offs )
262	261	{
263	262	return ROM[offs];
264	263	}

trunk/src/mame/includes/hyprduel.h

r20826	r20827
95	95	TIMER_CALLBACK_MEMBER(hyprduel_blit_done);
96	96	TIMER_DEVICE_CALLBACK_MEMBER(hyprduel_interrupt);
97	97	void hyprduel_postload();
	98	inline void get_tile_info( tile_data &tileinfo, int tile_index, int layer, UINT16 *vram);
	99	inline void get_tile_info_8bit( tile_data &tileinfo, int tile_index, int layer, UINT16 *vram );
	100	inline void get_tile_info_16x16_8bit( tile_data &tileinfo, int tile_index, int layer, UINT16 *vram );
	101	inline void hyprduel_vram_w( offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram );
	102	void alloc_empty_tiles(  );
	103	void expand_gfx1(hyprduel_state &state);
	104	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	105	void draw_layers( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl );
	106	void dirty_tiles( int layer, UINT16 *vram );
	107	void update_irq_state(  );
	108	inline int blt_read( const UINT8 *ROM, const int offs );
98	109	};

trunk/src/mame/includes/hyperspt.h

r20826	r20827
44	44	DECLARE_VIDEO_START(roadf);
45	45	UINT32 screen_update_hyperspt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
46	46	INTERRUPT_GEN_MEMBER(vblank_irq);
	47	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
47	48	};

trunk/src/mame/includes/hnayayoi.h

r20826	r20827
37	37	virtual void video_start();
38	38	DECLARE_VIDEO_START(untoucha);
39	39	UINT32 screen_update_hnayayoi(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	40	void common_vh_start( int num_pixmaps );
	41	void copy_pixel( int x, int y, int pen );
	42	void draw_layer_interleaved( bitmap_ind16 &bitmap, const rectangle &cliprect, int left_pixmap, int right_pixmap, int palbase, int transp );
40	43	};

trunk/src/mame/includes/himesiki.h

r20826	r20827
34	34	virtual void machine_reset();
35	35	virtual void video_start();
36	36	UINT32 screen_update_himesiki(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	37	void himesiki_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
37	38	};

trunk/src/mame/includes/homerun.h

r20826	r20827
54	54	virtual void video_start();
55	55	UINT32 screen_update_homerun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
56	56	DECLARE_WRITE8_MEMBER(homerun_banking_w);
	57	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
57	58	};

trunk/src/mame/includes/hyhoo.h

r20826	r20827
25	25	virtual void video_start();
26	26	UINT32 screen_update_hyhoo(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
27	27	TIMER_CALLBACK_MEMBER(blitter_timer_callback);
	28	void hyhoo_gfxdraw();
28	29	};

trunk/src/mame/includes/holeland.h

r20826	r20827
33	33	DECLARE_VIDEO_START(crzrally);
34	34	UINT32 screen_update_holeland(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
35	35	UINT32 screen_update_crzrally(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	36	void holeland_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	37	void crzrally_draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect );
36	38	};

trunk/src/mame/includes/higemaru.h

r20826	r20827
28	28	virtual void palette_init();
29	29	UINT32 screen_update_higemaru(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
30	30	TIMER_DEVICE_CALLBACK_MEMBER(higemaru_scanline);
	31	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
31	32	};

trunk/src/mame/includes/hcastle.h

r20826	r20827
56	56	virtual void video_start();
57	57	virtual void palette_init();
58	58	UINT32 screen_update_hcastle(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	59	void set_pens();
	60	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *sbank, int bank );
59	61	};

trunk/src/mame/includes/hitme.h

r20826	r20827
41	41	DECLARE_VIDEO_START(barricad);
42	42	UINT32 screen_update_hitme(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
43	43	UINT32 screen_update_barricad(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	44	UINT8 read_port_and_t0( int port );
	45	UINT8 read_port_and_t0_and_hblank( int port );
44	46	};
45	47
46	48

trunk/src/mame/includes/homedata.h

r20826	r20827
127	127	void screen_eof_homedata(screen_device &screen, bool state);
128	128	INTERRUPT_GEN_MEMBER(homedata_irq);
129	129	INTERRUPT_GEN_MEMBER(upd7807_irq);
	130	void mrokumei_handleblit( address_space &space, int rom_base );
	131	void reikaids_handleblit( address_space &space, int rom_base );
	132	void pteacher_handleblit( address_space &space, int rom_base );
	133	inline void mrokumei_info0( tile_data &tileinfo, int tile_index, int page, int gfxbank );
	134	inline void mrokumei_info1( tile_data &tileinfo, int tile_index, int page, int gfxbank );
	135	inline void reikaids_info( tile_data &tileinfo, int tile_index, int page, int layer, int gfxbank );
	136	inline void pteacher_info( tile_data &tileinfo, int tile_index, int page, int layer, int gfxbank );
	137	inline void lemnangl_info( tile_data &tileinfo, int tile_index, int page, int layer, int gfxset, int gfxbank );
	138	inline void mirderby_info0( tile_data &tileinfo, int tile_index, int page, int gfxbank );
	139	inline void mirderby_info1( tile_data &tileinfo, int tile_index, int page, int gfxbank );
130	140	};

trunk/src/mame/includes/hexion.h

r20826	r20827
24	24	virtual void video_start();
25	25	UINT32 screen_update_hexion(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
26	26	TIMER_DEVICE_CALLBACK_MEMBER(hexion_scanline);
	27	inline void get_tile_info(tile_data &tileinfo,int tile_index,UINT8 *ram);
27	28	};

trunk/src/mame/video/homerun.c

r20826	r20827
108	108	}
109	109
110	110
111		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	111	void homerun_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
112	112	{
113		homerun_state *state = machine.driver_data<homerun_state>();
114		UINT8 *spriteram = state->m_spriteram;
	113	UINT8 *spriteram = m_spriteram;
115	114	int offs;
116	115
117		for (offs = state->m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
	116	for (offs = m_spriteram.bytes() - 4; offs >= 0; offs -= 4)
118	117	{
119	118	int sx = spriteram[offs + 3];
120	119	int sy = spriteram[offs + 0] - 15;
121		int code = (spriteram[offs + 1]) | ((spriteram[offs + 2] & 0x8) << 5) | ((state->m_gfx_ctrl & 3) << 9);
	120	int code = (spriteram[offs + 1]) | ((spriteram[offs + 2] & 0x8) << 5) | ((m_gfx_ctrl & 3) << 9);
122	121	int color = (spriteram[offs + 2] & 0x07) | 8;
123	122	int flipx = (spriteram[offs + 2] & 0x40) >> 6;
124	123	int flipy = (spriteram[offs + 2] & 0x80) >> 7;
125	124
126		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	125	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
127	126	code,
128	127	color,
129	128	flipx,flipy,
130	129	sx,sy,0);
131	130
132	131	// wraparound
133		drawgfx_transpen(bitmap, cliprect, machine.gfx[1],
	132	drawgfx_transpen(bitmap, cliprect, machine().gfx[1],
134	133	code,
135	134	color,
136	135	flipx,flipy,
r20826	r20827
144	143	m_tilemap->set_scrollx(0, m_scrollx);
145	144
146	145	m_tilemap->draw(bitmap, cliprect, 0, 0);
147		draw_sprites(machine(), bitmap, cliprect);
	146	draw_sprites(bitmap, cliprect);
148	147
149	148	return 0;
150	149	}

trunk/src/mame/video/hyprduel.c

r20826	r20827
103	103
104	104
105	105	/* 8x8x4 tiles only */
106		INLINE void get_tile_info( running_machine &machine, tile_data &tileinfo, int tile_index, int layer, UINT16 *vram)
	106	inline void hyprduel_state::get_tile_info( tile_data &tileinfo, int tile_index, int layer, UINT16 *vram)
107	107	{
108		hyprduel_state *state = machine.driver_data<hyprduel_state>();
109	108	UINT16 code;
110	109	int table_index;
111	110	UINT32 tile;
112	111
113	112	/* The actual tile index depends on the window */
114		tile_index = ((tile_index / WIN_NX + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX +
115		((tile_index % WIN_NX + state->m_window[layer * 2 + 1] / 8) % BIG_NX);
	113	tile_index = ((tile_index / WIN_NX + m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX +
	114	((tile_index % WIN_NX + m_window[layer * 2 + 1] / 8) % BIG_NX);
116	115
117	116	/* Fetch the code */
118	117	code = vram[tile_index];
119	118
120	119	/* Use it as an index into the tiles set table */
121	120	table_index = ((code & 0x1ff0) >> 4 ) * 2;
122		tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1];
	121	tile = (m_tiletable[table_index + 0] << 16) + m_tiletable[table_index + 1];
123	122
124	123	if (code & 0x8000) /* Special: draw a tile of a single color (i.e. not from the gfx ROMs) */
125	124	{
126	125	int _code = code & 0x000f;
127		tileinfo.pen_data = state->m_empty_tiles + _code * 16 * 16;
	126	tileinfo.pen_data = m_empty_tiles + _code * 16 * 16;
128	127	tileinfo.palette_base = ((code & 0x0ff0)) + 0x1000;
129	128	tileinfo.flags = 0;
130	129	tileinfo.group = 0;
r20826	r20827
132	131	else
133	132	{
134	133	tileinfo.group = 0;
135		SET_TILE_INFO(
	134	SET_TILE_INFO_MEMBER(
136	135	0,
137	136	(tile & 0xfffff) + (code & 0xf),
138	137	(((tile & 0x0ff00000) >> 20)) + 0x100,
r20826	r20827
142	141
143	142	/* 8x8x4 or 8x8x8 tiles. It's the tile's color that decides: if its low 4
144	143	bits are high ($f,$1f,$2f etc) the tile is 8bpp, otherwise it's 4bpp */
145		INLINE void get_tile_info_8bit( running_machine &machine, tile_data &tileinfo, int tile_index, int layer, UINT16 *vram )
	144	inline void hyprduel_state::get_tile_info_8bit( tile_data &tileinfo, int tile_index, int layer, UINT16 *vram )
146	145	{
147		hyprduel_state *state = machine.driver_data<hyprduel_state>();
148	146	UINT16 code;
149	147	int table_index;
150	148	UINT32 tile;
151	149
152	150	/* The actual tile index depends on the window */
153		tile_index = ((tile_index / WIN_NX + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX +
154		((tile_index % WIN_NX + state->m_window[layer * 2 + 1] / 8) % BIG_NX);
	151	tile_index = ((tile_index / WIN_NX + m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX +
	152	((tile_index % WIN_NX + m_window[layer * 2 + 1] / 8) % BIG_NX);
155	153
156	154	/* Fetch the code */
157	155	code = vram[tile_index];
158	156
159	157	/* Use it as an index into the tiles set table */
160	158	table_index = ((code & 0x1ff0) >> 4) * 2;
161		tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1];
	159	tile = (m_tiletable[table_index + 0] << 16) + m_tiletable[table_index + 1];
162	160
163	161	if (code & 0x8000) /* Special: draw a tile of a single color (i.e. not from the gfx ROMs) */
164	162	{
165	163	int _code = code & 0x000f;
166		tileinfo.pen_data = state->m_empty_tiles + _code * 16 * 16;
	164	tileinfo.pen_data = m_empty_tiles + _code * 16 * 16;
167	165	tileinfo.palette_base = ((code & 0x0ff0)) + 0x1000;
168	166	tileinfo.flags = 0;
169	167	tileinfo.group = 0;
r20826	r20827
171	169	else if ((tile & 0x00f00000) == 0x00f00000) /* draw tile as 8bpp */
172	170	{
173	171	tileinfo.group = 1;
174		SET_TILE_INFO(
	172	SET_TILE_INFO_MEMBER(
175	173	1,
176	174	(tile & 0xfffff) + 2*(code & 0xf),
177	175	((tile & 0x0f000000) >> 24) + 0x10,
r20826	r20827
180	178	else
181	179	{
182	180	tileinfo.group = 0;
183		SET_TILE_INFO(
	181	SET_TILE_INFO_MEMBER(
184	182	0,
185	183	(tile & 0xfffff) + (code & 0xf),
186	184	(((tile & 0x0ff00000) >> 20)) + 0x100,
r20826	r20827
190	188
191	189	/* 16x16x4 or 16x16x8 tiles. It's the tile's color that decides: if its low 4
192	190	bits are high ($f,$1f,$2f etc) the tile is 8bpp, otherwise it's 4bpp */
193		INLINE void get_tile_info_16x16_8bit( running_machine &machine, tile_data &tileinfo, int tile_index, int layer, UINT16 *vram )
	191	inline void hyprduel_state::get_tile_info_16x16_8bit( tile_data &tileinfo, int tile_index, int layer, UINT16 *vram )
194	192	{
195		hyprduel_state *state = machine.driver_data<hyprduel_state>();
196	193	UINT16 code;
197	194	int table_index;
198	195	UINT32 tile;
199	196
200	197	/* The actual tile index depends on the window */
201		tile_index = ((tile_index / WIN_NX + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX +
202		((tile_index % WIN_NX + state->m_window[layer * 2 + 1] / 8) % BIG_NX);
	198	tile_index = ((tile_index / WIN_NX + m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX +
	199	((tile_index % WIN_NX + m_window[layer * 2 + 1] / 8) % BIG_NX);
203	200
204	201	/* Fetch the code */
205	202	code = vram[tile_index];
206	203
207	204	/* Use it as an index into the tiles set table */
208	205	table_index = ((code & 0x1ff0) >> 4) * 2;
209		tile = (state->m_tiletable[table_index + 0] << 16) + state->m_tiletable[table_index + 1];
	206	tile = (m_tiletable[table_index + 0] << 16) + m_tiletable[table_index + 1];
210	207
211	208	if (code & 0x8000) /* Special: draw a tile of a single color (i.e. not from the gfx ROMs) */
212	209	{
213	210	int _code = code & 0x000f;
214		tileinfo.pen_data = state->m_empty_tiles + _code * 16 * 16;
	211	tileinfo.pen_data = m_empty_tiles + _code * 16 * 16;
215	212	tileinfo.palette_base = ((code & 0x0ff0)) + 0x1000;
216	213	tileinfo.flags = 0;
217	214	tileinfo.group = 0;
r20826	r20827
219	216	else if ((tile & 0x00f00000) == 0x00f00000) /* draw tile as 8bpp */
220	217	{
221	218	tileinfo.group = 1;
222		SET_TILE_INFO(
	219	SET_TILE_INFO_MEMBER(
223	220	3,
224	221	(tile & 0xfffff) + 8*(code & 0xf),
225	222	((tile & 0x0f000000) >> 24) + 0x10,
r20826	r20827
228	225	else
229	226	{
230	227	tileinfo.group = 0;
231		SET_TILE_INFO(
	228	SET_TILE_INFO_MEMBER(
232	229	2,
233	230	(tile & 0xfffff) + 4*(code & 0xf),
234	231	(((tile & 0x0ff00000) >> 20)) + 0x100,
r20826	r20827
237	234	}
238	235	}
239	236
240		INLINE void hyprduel_vram_w( running_machine &machine, offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram )
	237	inline void hyprduel_state::hyprduel_vram_w( offs_t offset, UINT16 data, UINT16 mem_mask, int layer, UINT16 *vram )
241	238	{
242		hyprduel_state *state = machine.driver_data<hyprduel_state>();
243	239	COMBINE_DATA(&vram[offset]);
244	240	{
245	241	/* Account for the window */
246		int col = (offset % BIG_NX) - ((state->m_window[layer * 2 + 1] / 8) % BIG_NX);
247		int row = (offset / BIG_NX) - ((state->m_window[layer * 2 + 0] / 8) % BIG_NY);
	242	int col = (offset % BIG_NX) - ((m_window[layer * 2 + 1] / 8) % BIG_NX);
	243	int row = (offset / BIG_NX) - ((m_window[layer * 2 + 0] / 8) % BIG_NY);
248	244	if (col < -(BIG_NX-WIN_NX))
249	245	col += (BIG_NX-WIN_NX) + WIN_NX;
250	246	if (row < -(BIG_NY-WIN_NY))
251	247	row += (BIG_NY-WIN_NY) + WIN_NY;
252	248	if ((col >= 0) && (col < WIN_NX) && (row >= 0) && (row < WIN_NY))
253		state->m_bg_tilemap[layer]->mark_tile_dirty(row * WIN_NX + col);
	249	m_bg_tilemap[layer]->mark_tile_dirty(row * WIN_NX + col);
254	250	}
255	251	}
256	252
r20826	r20827
258	254
259	255	TILE_GET_INFO_MEMBER(hyprduel_state::get_tile_info_0_8bit)
260	256	{
261		get_tile_info_8bit(machine(), tileinfo, tile_index, 0, m_vram_0);
	257	get_tile_info_8bit(tileinfo, tile_index, 0, m_vram_0);
262	258	}
263	259
264	260	TILE_GET_INFO_MEMBER(hyprduel_state::get_tile_info_1_8bit)
265	261	{
266		get_tile_info_8bit(machine(), tileinfo, tile_index, 1, m_vram_1);
	262	get_tile_info_8bit(tileinfo, tile_index, 1, m_vram_1);
267	263	}
268	264
269	265	TILE_GET_INFO_MEMBER(hyprduel_state::get_tile_info_2_8bit)
270	266	{
271		get_tile_info_8bit(machine(), tileinfo, tile_index, 2, m_vram_2);
	267	get_tile_info_8bit(tileinfo, tile_index, 2, m_vram_2);
272	268	}
273	269
274	270	WRITE16_MEMBER(hyprduel_state::hyprduel_vram_0_w)
275	271	{
276		hyprduel_vram_w(machine(), offset, data, mem_mask, 0, m_vram_0);
	272	hyprduel_vram_w(offset, data, mem_mask, 0, m_vram_0);
277	273	}
278	274
279	275	WRITE16_MEMBER(hyprduel_state::hyprduel_vram_1_w)
280	276	{
281		hyprduel_vram_w(machine(), offset, data, mem_mask, 1, m_vram_1);
	277	hyprduel_vram_w(offset, data, mem_mask, 1, m_vram_1);
282	278	}
283	279
284	280	WRITE16_MEMBER(hyprduel_state::hyprduel_vram_2_w)
285	281	{
286		hyprduel_vram_w(machine(), offset, data, mem_mask, 2, m_vram_2);
	282	hyprduel_vram_w(offset, data, mem_mask, 2, m_vram_2);
287	283	}
288	284
289	285
r20826	r20827
311	307	the tile's sizes to be known at startup - which we don't!
312	308	*/
313	309
314		static void alloc_empty_tiles( running_machine &machine )
	310	void hyprduel_state::alloc_empty_tiles(  )
315	311	{
316		hyprduel_state *state = machine.driver_data<hyprduel_state>();
317	312	int code,i;
318	313
319		state->m_empty_tiles = auto_alloc_array(machine, UINT8, 16*16*16);
320		state->save_pointer(NAME(state->m_empty_tiles), 16*16*16);
	314	m_empty_tiles = auto_alloc_array(machine(), UINT8, 16*16*16);
	315	save_pointer(NAME(m_empty_tiles), 16*16*16);
321	316
322	317	for (code = 0; code < 0x10; code++)
323	318	for (i = 0; i < 16 * 16; i++)
324		state->m_empty_tiles[16 * 16 * code + i] = code;
	319	m_empty_tiles[16 * 16 * code + i] = code;
325	320	}
326	321
327	322
r20826	r20827
342	337	}
343	338
344	339
345		static void expand_gfx1(hyprduel_state &state)
	340	void hyprduel_state::expand_gfx1(hyprduel_state &state)
346	341	{
347	342	UINT8 *base_gfx = state.machine().root_device().memregion("gfx1")->base();
348	343	UINT32 length = 2 * state.machine().root_device().memregion("gfx1")->bytes();
r20826	r20827
358	353	VIDEO_START_MEMBER(hyprduel_state,common_14220)
359	354	{
360	355	expand_gfx1(*this);
361		alloc_empty_tiles(machine());
	356	alloc_empty_tiles();
362	357	m_tiletable_old = auto_alloc_array(machine(), UINT16, m_tiletable.bytes() / 2);
363	358	m_dirtyindex = auto_alloc_array(machine(), UINT8, m_tiletable.bytes() / 4);
364	359
r20826	r20827
459	454
460	455	/* Draw sprites */
461	456
462		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	457	void hyprduel_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
463	458	{
464		hyprduel_state *state = machine.driver_data<hyprduel_state>();
465		UINT8 *base_gfx4 = state->m_expanded_gfx1;
466		UINT8 *base_gfx8 = state->memregion("gfx1")->base();
467		UINT32 gfx_size = state->memregion("gfx1")->bytes();
	459	UINT8 *base_gfx4 = m_expanded_gfx1;
	460	UINT8 *base_gfx8 = memregion("gfx1")->base();
	461	UINT32 gfx_size = memregion("gfx1")->bytes();
468	462
469		int max_x = machine.primary_screen->width();
470		int max_y = machine.primary_screen->height();
	463	int max_x = machine().primary_screen->width();
	464	int max_y = machine().primary_screen->height();
471	465
472		int max_sprites = state->m_spriteram.bytes() / 8;
473		int sprites = state->m_videoregs[0x00 / 2] % max_sprites;
	466	int max_sprites = m_spriteram.bytes() / 8;
	467	int sprites = m_videoregs[0x00 / 2] % max_sprites;
474	468
475		int color_start = ((state->m_videoregs[0x08 / 2] & 0xf) << 4) + 0x100;
	469	int color_start = ((m_videoregs[0x08 / 2] & 0xf) << 4) + 0x100;
476	470
477	471	int i, j, pri;
478	472	static const int primask[4] = { 0x0000, 0xff00, 0xff00|0xf0f0, 0xff00|0xf0f0|0xcccc };
r20826	r20827
485	479
486	480	for (i = 0; i < 0x20; i++)
487	481	{
488		if (!(state->m_videoregs[0x02 / 2] & 0x8000))
	482	if (!(m_videoregs[0x02 / 2] & 0x8000))
489	483	{
490		src = state->m_spriteram + (sprites - 1) * (8 / 2);
	484	src = m_spriteram + (sprites - 1) * (8 / 2);
491	485	inc = -(8 / 2);
492	486	} else {
493		src = state->m_spriteram;
	487	src = m_spriteram;
494	488	inc = (8 / 2);
495	489	}
496	490
r20826	r20827
520	514	continue;
521	515	}
522	516
523		pri = (state->m_videoregs[0x02 / 2] & 0x0300) >> 8;
	517	pri = (m_videoregs[0x02 / 2] & 0x0300) >> 8;
524	518
525		if (!(state->m_videoregs[0x02 / 2] & 0x8000))
	519	if (!(m_videoregs[0x02 / 2] & 0x8000))
526	520	{
527		if (curr_pri > (state->m_videoregs[0x02 / 2] & 0x1f))
528		pri = (state->m_videoregs[0x02 / 2] & 0x0c00) >> 10;
	521	if (curr_pri > (m_videoregs[0x02 / 2] & 0x1f))
	522	pri = (m_videoregs[0x02 / 2] & 0x0c00) >> 10;
529	523	}
530	524
531	525	y = src[1];
r20826	r20827
538	532
539	533	zoom = zoomtable[(y & 0xfc00) >> 10] << (16 - 8);
540	534
541		x = (x & 0x07ff) - state->m_sprite_xoffs;
542		y = (y & 0x03ff) - state->m_sprite_yoffs;
	535	x = (x & 0x07ff) - m_sprite_xoffs;
	536	y = (y & 0x03ff) - m_sprite_yoffs;
543	537
544	538	width = (((attr >> 11) & 0x7) + 1) * 8;
545	539	height = (((attr >>  8) & 0x7) + 1) * 8;
546	540
547	541	UINT32 gfxstart = (8 * 8 * 4 / 8) * (((attr & 0x000f) << 16) + code);
548	542
549		if (state->flip_screen())
	543	if (flip_screen())
550	544	{
551	545	flipx = !flipx;     x = max_x - x - width;
552	546	flipy = !flipy;     y = max_y - y - height;
r20826	r20827
558	552	if ((gfxstart + width * height - 1) >= gfx_size)
559	553	continue;
560	554
561		gfx_element gfx(machine, base_gfx8 + gfxstart, width, height, width, 0, 256);
	555	gfx_element gfx(machine(), base_gfx8 + gfxstart, width, height, width, 0, 256);
562	556
563	557	pdrawgfxzoom_transpen(bitmap,cliprect, &gfx,
564	558	0,
r20826	r20827
566	560	flipx, flipy,
567	561	x, y,
568	562	zoom, zoom,
569		machine.priority_bitmap,primask[pri], 255);
	563	machine().priority_bitmap,primask[pri], 255);
570	564	}
571	565	else
572	566	{
r20826	r20827
574	568	if ((gfxstart + width / 2 * height - 1) >= gfx_size)
575	569	continue;
576	570
577		gfx_element gfx(machine, base_gfx4 + 2 * gfxstart, width, height, width, 0, 16);
	571	gfx_element gfx(machine(), base_gfx4 + 2 * gfxstart, width, height, width, 0, 16);
578	572
579	573	pdrawgfxzoom_transpen(bitmap,cliprect, &gfx,
580	574	0,
r20826	r20827
582	576	flipx, flipy,
583	577	x, y,
584	578	zoom, zoom,
585		machine.priority_bitmap,primask[pri], 15);
	579	machine().priority_bitmap,primask[pri], 15);
586	580	}
587	581	#if 0
588	582	{   /* Display priority + zoom on each sprite */
r20826	r20827
630	624	}
631	625
632	626
633		static void draw_layers( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl )
	627	void hyprduel_state::draw_layers( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri, int layers_ctrl )
634	628	{
635		hyprduel_state *state = machine.driver_data<hyprduel_state>();
636		UINT16 layers_pri = state->m_videoregs[0x10/2];
	629	UINT16 layers_pri = m_videoregs[0x10/2];
637	630	int layer;
638	631
639	632	/* Draw all the layers with priority == pri */
r20826	r20827
642	635	if ( pri == ((layers_pri >> (layer*2)) & 3) )
643	636	{
644	637	if (layers_ctrl & (1 << layer)) // for debug
645		state->m_bg_tilemap[layer]->draw(bitmap, cliprect, 0, 1 << (3 - pri));
	638	m_bg_tilemap[layer]->draw(bitmap, cliprect, 0, 1 << (3 - pri));
646	639	}
647	640	}
648	641	}
649	642
650	643	/* Dirty tilemaps when the tiles set changes */
651		static void dirty_tiles( running_machine &machine, int layer, UINT16 *vram )
	644	void hyprduel_state::dirty_tiles( int layer, UINT16 *vram )
652	645	{
653		hyprduel_state *state = machine.driver_data<hyprduel_state>();
654	646	int col, row;
655	647
656	648	for (row = 0; row < WIN_NY; row++)
657	649	{
658	650	for (col = 0; col < WIN_NX; col++)
659	651	{
660		int offset = (col + state->m_window[layer * 2 + 1] / 8) % BIG_NX + ((row + state->m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX;
	652	int offset = (col + m_window[layer * 2 + 1] / 8) % BIG_NX + ((row + m_window[layer * 2 + 0] / 8) % BIG_NY) * BIG_NX;
661	653	UINT16 code = vram[offset];
662	654
663		if (!(code & 0x8000) && state->m_dirtyindex[(code & 0x1ff0) >> 4])
664		state->m_bg_tilemap[layer]->mark_tile_dirty(row * WIN_NX + col);
	655	if (!(code & 0x8000) && m_dirtyindex[(code & 0x1ff0) >> 4])
	656	m_bg_tilemap[layer]->mark_tile_dirty(row * WIN_NX + col);
665	657	}
666	658	}
667	659	}
r20826	r20827
691	683
692	684	if (dirty)
693	685	{
694		dirty_tiles(machine(), 0, m_vram_0);
695		dirty_tiles(machine(), 1, m_vram_1);
696		dirty_tiles(machine(), 2, m_vram_2);
	686	dirty_tiles(0, m_vram_0);
	687	dirty_tiles(1, m_vram_1);
	688	dirty_tiles(2, m_vram_2);
697	689	}
698	690	}
699	691
r20826	r20827
740	732	#endif
741	733
742	734	for (pri = 3; pri >= 0; pri--)
743		draw_layers(machine(), bitmap, cliprect, pri, layers_ctrl);
	735	draw_layers(bitmap, cliprect, pri, layers_ctrl);
744	736
745	737	if (layers_ctrl & 0x08)
746		draw_sprites(machine(), bitmap, cliprect);
	738	draw_sprites(bitmap, cliprect);
747	739
748	740	return 0;
749	741	}

trunk/src/mame/video/hcastle.c

r20826	r20827
42	42	}
43	43
44	44
45		static void set_pens(running_machine &machine)
	45	void hcastle_state::set_pens()
46	46	{
47		hcastle_state *state = machine.driver_data<hcastle_state>();
48	47	int i;
49	48
50	49	for (i = 0x00; i < 0x100; i += 2)
51	50	{
52		UINT16 data = state->m_paletteram[i | 1] | (state->m_paletteram[i] << 8);
	51	UINT16 data = m_paletteram[i | 1] | (m_paletteram[i] << 8);
53	52
54	53	rgb_t color = MAKE_RGB(pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
55	54
56		colortable_palette_set_color(machine.colortable, i >> 1, color);
	55	colortable_palette_set_color(machine().colortable, i >> 1, color);
57	56	}
58	57	}
59	58
r20826	r20827
199	198
200	199	/*****************************************************************************/
201	200
202		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *sbank, int bank )
	201	void hcastle_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *sbank, int bank )
203	202	{
204		hcastle_state *state = machine.driver_data<hcastle_state>();
205		device_t *k007121 = bank ? state->m_k007121_2 : state->m_k007121_1;
206		address_space &space = machine.driver_data()->generic_space();
	203	device_t *k007121 = bank ? m_k007121_2 : m_k007121_1;
	204	address_space &space = machine().driver_data()->generic_space();
207	205	int base_color = (k007121_ctrlram_r(k007121, space, 6) & 0x30) * 2;
208		int bank_base = (bank == 0) ? 0x4000 * (state->m_gfx_bank & 1) : 0;
	206	int bank_base = (bank == 0) ? 0x4000 * (m_gfx_bank & 1) : 0;
209	207
210		k007121_sprites_draw(k007121, bitmap, cliprect, machine.gfx[bank], machine.colortable, sbank, base_color, 0, bank_base, (UINT32)-1);
	208	k007121_sprites_draw(k007121, bitmap, cliprect, machine().gfx[bank], machine().colortable, sbank, base_color, 0, bank_base, (UINT32)-1);
211	209	}
212	210
213	211	/*****************************************************************************/
r20826	r20827
225	223	UINT8 ctrl_2_2 = k007121_ctrlram_r(m_k007121_2, space, 2);
226	224	UINT8 ctrl_2_3 = k007121_ctrlram_r(m_k007121_2, space, 3);
227	225
228		set_pens(machine());
	226	set_pens();
229	227
230	228	m_pf1_bankbase = 0x0000;
231	229	m_pf2_bankbase = 0x4000 * ((m_gfx_bank & 2) >> 1);
r20826	r20827
254	252	if ((m_gfx_bank & 0x04) == 0)
255	253	{
256	254	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
257		draw_sprites(machine(), bitmap, cliprect, m_spriteram->buffer(), 0);
258		draw_sprites(machine(), bitmap, cliprect, m_spriteram2->buffer(), 1);
	255	draw_sprites(bitmap, cliprect, m_spriteram->buffer(), 0);
	256	draw_sprites(bitmap, cliprect, m_spriteram2->buffer(), 1);
259	257	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
260	258	}
261	259	else
262	260	{
263	261	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
264	262	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
265		draw_sprites(machine(), bitmap, cliprect, m_spriteram->buffer(), 0);
266		draw_sprites(machine(), bitmap, cliprect, m_spriteram2->buffer(), 1);
	263	draw_sprites(bitmap, cliprect, m_spriteram->buffer(), 0);
	264	draw_sprites(bitmap, cliprect, m_spriteram2->buffer(), 1);
267	265	}
268	266	return 0;
269	267	}

trunk/src/mame/video/hyperspt.c

r20826	r20827
126	126	m_bg_tilemap->set_scroll_rows(32);
127	127	}
128	128
129		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	129	void hyperspt_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
130	130	{
131		hyperspt_state *state = machine.driver_data<hyperspt_state>();
132		UINT8 *spriteram = state->m_spriteram;
	131	UINT8 *spriteram = m_spriteram;
133	132	int offs;
134	133
135		for (offs = state->m_spriteram.bytes() - 4;offs >= 0;offs -= 4)
	134	for (offs = m_spriteram.bytes() - 4;offs >= 0;offs -= 4)
136	135	{
137	136	int sx = spriteram[offs + 3];
138	137	int sy = 240 - spriteram[offs + 1];
r20826	r20827
141	140	int flipx = ~spriteram[offs] & 0x40;
142	141	int flipy = spriteram[offs] & 0x80;
143	142
144		if (state->flip_screen())
	143	if (flip_screen())
145	144	{
146	145	sy = 240 - sy;
147	146	flipy = !flipy;
148	147	}
149	148
150		/* Note that this adjustment must be done AFTER handling state->flip_screen(), thus */
	149	/* Note that this adjustment must be done AFTER handling flip_screen(), thus */
151	150	/* proving that this is a hardware related "feature" */
152	151
153	152	sy += 1;
154	153
155	154	drawgfx_transmask(bitmap,cliprect,
156		machine.gfx[0],
	155	machine().gfx[0],
157	156	code, color,
158	157	flipx, flipy,
159	158	sx, sy,
160		colortable_get_transpen_mask(machine.colortable, machine.gfx[0], color, 0));
	159	colortable_get_transpen_mask(machine().colortable, machine().gfx[0], color, 0));
161	160
162	161	/* redraw with wraparound */
163	162
164	163	drawgfx_transmask(bitmap,cliprect,
165		machine.gfx[0],
	164	machine().gfx[0],
166	165	code, color,
167	166	flipx, flipy,
168	167	sx - 256, sy,
169		colortable_get_transpen_mask(machine.colortable, machine.gfx[0], color, 0));
	168	colortable_get_transpen_mask(machine().colortable, machine().gfx[0], color, 0));
170	169	}
171	170	}
172	171
r20826	r20827
182	181	}
183	182
184	183	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
185		draw_sprites(machine(), bitmap, cliprect);
	184	draw_sprites(bitmap, cliprect);
186	185	return 0;
187	186	}
188	187

trunk/src/mame/video/hnayayoi.c

r20826	r20827
12	12	#include "emu.h"
13	13	#include "includes/hnayayoi.h"
14	14
15		static void common_vh_start( running_machine &machine, int num_pixmaps )
	15	void hnayayoi_state::common_vh_start( int num_pixmaps )
16	16	{
17		hnayayoi_state *state = machine.driver_data<hnayayoi_state>();
18	17	int i;
19	18
20		state->m_total_pixmaps = num_pixmaps;
	19	m_total_pixmaps = num_pixmaps;
21	20
22	21	for (i = 0; i < 8; i++)
23	22	{
24		if (i < state->m_total_pixmaps)
	23	if (i < m_total_pixmaps)
25	24	{
26		state->m_pixmap[i] = auto_alloc_array(machine, UINT8, 256 * 256);
	25	m_pixmap[i] = auto_alloc_array(machine(), UINT8, 256 * 256);
27	26	}
28	27	else
29		state->m_pixmap[i] = NULL;
	28	m_pixmap[i] = NULL;
30	29	}
31	30	}
32	31
33	32	void hnayayoi_state::video_start()
34	33	{
35		common_vh_start(machine(), 4);  /* 4 bitmaps -> 2 layers */
	34	common_vh_start(4);  /* 4 bitmaps -> 2 layers */
36	35
37	36	save_pointer(NAME(m_pixmap[0]), 256 * 256);
38	37	save_pointer(NAME(m_pixmap[1]), 256 * 256);
r20826	r20827
42	41
43	42	VIDEO_START_MEMBER(hnayayoi_state,untoucha)
44	43	{
45		common_vh_start(machine(), 8);  /* 8 bitmaps -> 4 layers */
	44	common_vh_start(8);  /* 8 bitmaps -> 4 layers */
46	45
47	46	save_pointer(NAME(m_pixmap[0]), 256 * 256);
48	47	save_pointer(NAME(m_pixmap[1]), 256 * 256);
r20826	r20827
111	110	}
112	111	}
113	112
114		static void copy_pixel( running_machine &machine, int x, int y, int pen )
	113	void hnayayoi_state::copy_pixel( int x, int y, int pen )
115	114	{
116		hnayayoi_state *state = machine.driver_data<hnayayoi_state>();
117	115	if (x >= 0 && x <= 255 && y >= 0 && y <= 255)
118	116	{
119	117	int i;
120	118
121	119	for (i = 0; i < 8; i++)
122	120	{
123		if ((~state->m_blit_layer & (1 << i)) && (state->m_pixmap[i]))
124		state->m_pixmap[i][256 * y + x] = pen;
	121	if ((~m_blit_layer & (1 << i)) && (m_pixmap[i]))
	122	m_pixmap[i][256 * y + x] = pen;
125	123	}
126	124	}
127	125	}
r20826	r20827
190	188	case 0x2:
191	189	case 0x1:
192	190	while (cmd--)
193		copy_pixel(machine(), x++, y, pen);
	191	copy_pixel(x++, y, pen);
194	192	break;
195	193
196	194	case 0x0:
r20826	r20827
221	219	}
222	220
223	221
224		static void draw_layer_interleaved( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int left_pixmap, int right_pixmap, int palbase, int transp )
	222	void hnayayoi_state::draw_layer_interleaved( bitmap_ind16 &bitmap, const rectangle &cliprect, int left_pixmap, int right_pixmap, int palbase, int transp )
225	223	{
226		hnayayoi_state *state = machine.driver_data<hnayayoi_state>();
227	224	int county, countx, pen;
228		UINT8 *src1 = state->m_pixmap[left_pixmap];
229		UINT8 *src2 = state->m_pixmap[right_pixmap];
	225	UINT8 *src1 = m_pixmap[left_pixmap];
	226	UINT8 *src2 = m_pixmap[right_pixmap];
230	227	UINT16 *dstbase = &bitmap.pix16(0);
231	228
232	229	palbase *= 16;
r20826	r20827
266	263
267	264	if (m_total_pixmaps == 4)
268	265	{
269		draw_layer_interleaved(machine(), bitmap, cliprect, 3, 2, col1, 0);
270		draw_layer_interleaved(machine(), bitmap, cliprect, 1, 0, col0, 1);
	266	draw_layer_interleaved(bitmap, cliprect, 3, 2, col1, 0);
	267	draw_layer_interleaved(bitmap, cliprect, 1, 0, col0, 1);
271	268	}
272	269	else    /* total_pixmaps == 8 */
273	270	{
274		draw_layer_interleaved(machine(), bitmap, cliprect, 7, 6, col3, 0);
275		draw_layer_interleaved(machine(), bitmap, cliprect, 5, 4, col2, 1);
276		draw_layer_interleaved(machine(), bitmap, cliprect, 3, 2, col1, 1);
277		draw_layer_interleaved(machine(), bitmap, cliprect, 1, 0, col0, 1);
	271	draw_layer_interleaved(bitmap, cliprect, 7, 6, col3, 0);
	272	draw_layer_interleaved(bitmap, cliprect, 5, 4, col2, 1);
	273	draw_layer_interleaved(bitmap, cliprect, 3, 2, col1, 1);
	274	draw_layer_interleaved(bitmap, cliprect, 1, 0, col0, 1);
278	275	}
279	276	return 0;
280	277	}

trunk/src/mame/video/himesiki.c

r20826	r20827
45	45	logerror("p08_w %02x\n",data);
46	46	}
47	47
48		static void himesiki_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	48	void himesiki_state::himesiki_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
49	49	{
50		himesiki_state *state = machine.driver_data<himesiki_state>();
51		UINT8 *spriteram = state->m_spriteram;
	50	UINT8 *spriteram = m_spriteram;
52	51	int offs;
53	52
54	53	for (offs = 0x100; offs < 0x160; offs += 4)
r20826	r20827
65	64	if (x > 0x1e0)
66	65	x -= 0x200;
67	66
68		if (state->m_flipscreen)
	67	if (m_flipscreen)
69	68	{
70	69	y = (y + 33) & 0xff;
71	70	x = 224 - x;
r20826	r20827
79	78	y -= 0x100;
80	79	}
81	80
82		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, col, fx, fy, x, y, 15);
	81	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, col, fx, fy, x, y, 15);
83	82	}
84	83
85	84	for (offs = 0; offs < 0x100; offs += 4)
r20826	r20827
95	94	if (x > 0x1e0)
96	95	x -= 0x200;
97	96
98		if (state->m_flipscreen)
	97	if (m_flipscreen)
99	98	{
100	99	y += 49;
101	100	x = 240 - x;
r20826	r20827
108	107	if (y > 0xf0)
109	108	y -= 0x100;
110	109
111		drawgfx_transpen(bitmap, cliprect, machine.gfx[2], code, col, f, f, x, y, 15);
	110	drawgfx_transpen(bitmap, cliprect, machine().gfx[2], code, col, f, f, x, y, 15);
112	111	}
113	112	}
114	113
r20826	r20827
118	117	m_bg_tilemap->set_scrolldx(x, x);
119	118
120	119	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
121		himesiki_draw_sprites(machine(), bitmap, cliprect);
	120	himesiki_draw_sprites(bitmap, cliprect);
122	121
123	122	return 0;
124	123	}

trunk/src/mame/video/holeland.c

r20826	r20827
101	101	}
102	102
103	103
104		static void holeland_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	104	void holeland_state::holeland_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
105	105	{
106		holeland_state *state = machine.driver_data<holeland_state>();
107		UINT8 *spriteram = state->m_spriteram;
	106	UINT8 *spriteram = m_spriteram;
108	107	int offs, code, sx, sy, color, flipx, flipy;
109	108
110	109	/* Weird, sprites entries don't start on DWORD boundary */
111		for (offs = 3; offs < state->m_spriteram.bytes() - 1; offs += 4)
	110	for (offs = 3; offs < m_spriteram.bytes() - 1; offs += 4)
112	111	{
113	112	sy = 236 - spriteram[offs];
114	113	sx = spriteram[offs + 2];
115	114
116	115	/* Bit 7 unknown */
117	116	code = spriteram[offs + 1] & 0x7f;
118		color = state->m_palette_offset + (spriteram[offs + 3] >> 4);
	117	color = m_palette_offset + (spriteram[offs + 3] >> 4);
119	118
120	119	/* Bit 0, 1 unknown */
121	120	flipx = spriteram[offs + 3] & 0x04;
122	121	flipy = spriteram[offs + 3] & 0x08;
123	122
124		if (state->flip_screen_x())
	123	if (flip_screen_x())
125	124	{
126	125	flipx = !flipx;
127	126	sx = 240 - sx;
128	127	}
129	128
130		if (state->flip_screen_y())
	129	if (flip_screen_y())
131	130	{
132	131	flipy = !flipy;
133	132	sy = 240 - sy;
134	133	}
135	134
136		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	135	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
137	136	code,
138	137	color,
139	138	flipx,flipy,
r20826	r20827
141	140	}
142	141	}
143	142
144		static void crzrally_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect )
	143	void holeland_state::crzrally_draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect )
145	144	{
146		holeland_state *state = machine.driver_data<holeland_state>();
147		UINT8 *spriteram = state->m_spriteram;
	145	UINT8 *spriteram = m_spriteram;
148	146	int offs, code, sx, sy, color, flipx, flipy;
149	147
150	148	/* Weird, sprites entries don't start on DWORD boundary */
151		for (offs = 3; offs < state->m_spriteram.bytes() - 1; offs += 4)
	149	for (offs = 3; offs < m_spriteram.bytes() - 1; offs += 4)
152	150	{
153	151	sy = 236 - spriteram[offs];
154	152	sx = spriteram[offs + 2];
r20826	r20827
160	158	flipx = spriteram[offs + 3] & 0x04;
161	159	flipy = spriteram[offs + 3] & 0x08;
162	160
163		if (state->flip_screen_x())
	161	if (flip_screen_x())
164	162	{
165	163	flipx = !flipx;
166	164	sx = 240 - sx;
167	165	}
168	166
169		if (state->flip_screen_y())
	167	if (flip_screen_y())
170	168	{
171	169	flipy = !flipy;
172	170	sy = 240 - sy;
173	171	}
174	172
175		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	173	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
176	174	code,
177	175	color,
178	176	flipx,flipy,
r20826	r20827
184	182	{
185	183	/*m_bg_tilemap->mark_all_dirty(); */
186	184	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER1, 0);
187		holeland_draw_sprites(machine(), bitmap, cliprect);
	185	holeland_draw_sprites(bitmap, cliprect);
188	186	m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_LAYER0, 0);
189	187	return 0;
190	188	}
r20826	r20827
192	190	UINT32 holeland_state::screen_update_crzrally(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
193	191	{
194	192	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
195		crzrally_draw_sprites(machine(), bitmap, cliprect);
	193	crzrally_draw_sprites(bitmap, cliprect);
196	194	return 0;
197	195	}

trunk/src/mame/video/higemaru.c

r20826	r20827
102	102	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(higemaru_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
103	103	}
104	104
105		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	105	void higemaru_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
106	106	{
107		higemaru_state *state = machine.driver_data<higemaru_state>();
108		UINT8 *spriteram = state->m_spriteram;
	107	UINT8 *spriteram = m_spriteram;
109	108	int offs;
110	109
111		for (offs = state->m_spriteram.bytes() - 16; offs >= 0; offs -= 16)
	110	for (offs = m_spriteram.bytes() - 16; offs >= 0; offs -= 16)
112	111	{
113	112	int code,col,sx,sy,flipx,flipy;
114	113
r20826	r20827
118	117	sy = spriteram[offs + 8];
119	118	flipx = spriteram[offs + 4] & 0x10;
120	119	flipy = spriteram[offs + 4] & 0x20;
121		if (state->flip_screen())
	120	if (flip_screen())
122	121	{
123	122	sx = 240 - sx;
124	123	sy = 240 - sy;
r20826	r20827
126	125	flipy = !flipy;
127	126	}
128	127
129		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	128	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
130	129	code,
131	130	col,
132	131	flipx,flipy,
133	132	sx,sy,15);
134	133
135	134	/* draw again with wraparound */
136		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	135	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
137	136	code,
138	137	col,
139	138	flipx,flipy,
r20826	r20827
144	143	UINT32 higemaru_state::screen_update_higemaru(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
145	144	{
146	145	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
147		draw_sprites(machine(), bitmap, cliprect);
	146	draw_sprites(bitmap, cliprect);
148	147	return 0;
149	148	}

trunk/src/mame/video/hexion.c

r20826	r20827
10	10
11	11	***************************************************************************/
12	12
13		INLINE void get_tile_info(running_machine &machine,tile_data &tileinfo,int tile_index,UINT8 *ram)
	13	inline void hexion_state::get_tile_info(tile_data &tileinfo,int tile_index,UINT8 *ram)
14	14	{
15	15	tile_index *= 4;
16		SET_TILE_INFO(
	16	SET_TILE_INFO_MEMBER(
17	17	0,
18	18	ram[tile_index] + ((ram[tile_index+1] & 0x3f) << 8),
19	19	ram[tile_index+2] & 0x0f,
r20826	r20827
22	22
23	23	TILE_GET_INFO_MEMBER(hexion_state::get_tile_info0)
24	24	{
25		get_tile_info(machine(),tileinfo,tile_index,m_vram[0]);
	25	get_tile_info(tileinfo,tile_index,m_vram[0]);
26	26	}
27	27
28	28	TILE_GET_INFO_MEMBER(hexion_state::get_tile_info1)
29	29	{
30		get_tile_info(machine(),tileinfo,tile_index,m_vram[1]);
	30	get_tile_info(tileinfo,tile_index,m_vram[1]);
31	31	}
32	32
33	33

trunk/src/mame/video/hyhoo.c

r20826	r20827
11	11	#include "includes/hyhoo.h"
12	12
13	13
14		static void hyhoo_gfxdraw(running_machine &machine);
15
16
17	14	WRITE8_MEMBER(hyhoo_state::hyhoo_blitter_w)
18	15	{
19	16	switch (offset)
r20826	r20827
27	24	case 0x04:  m_blitter_sizex = data; break;
28	25	case 0x05:  m_blitter_sizey = data;
29	26	/* writing here also starts the blit */
30		hyhoo_gfxdraw(machine());
	27	hyhoo_gfxdraw();
31	28	break;
32	29	case 0x06:  m_blitter_direction_x = (data >> 0) & 0x01;
33	30	m_blitter_direction_y = (data >> 1) & 0x01;
r20826	r20827
61	58	nb1413m3_busyflag = 1;
62	59	}
63	60
64		static void hyhoo_gfxdraw(running_machine &machine)
	61	void hyhoo_state::hyhoo_gfxdraw()
65	62	{
66		hyhoo_state *state = machine.driver_data<hyhoo_state>();
67		UINT8 *GFX = state->memregion("gfx1")->base();
	63	UINT8 *GFX = memregion("gfx1")->base();
68	64
69	65	int x, y;
70	66	int dx1, dx2, dy;
r20826	r20827
79	75
80	76	nb1413m3_busyctr = 0;
81	77
82		state->m_gfxrom |= ((nb1413m3_sndrombank1 & 0x02) << 3);
	78	m_gfxrom |= ((nb1413m3_sndrombank1 & 0x02) << 3);
83	79
84		startx = state->m_blitter_destx + state->m_blitter_sizex;
85		starty = state->m_blitter_desty + state->m_blitter_sizey;
	80	startx = m_blitter_destx + m_blitter_sizex;
	81	starty = m_blitter_desty + m_blitter_sizey;
86	82
87		if (state->m_blitter_direction_x)
	83	if (m_blitter_direction_x)
88	84	{
89		sizex = state->m_blitter_sizex ^ 0xff;
	85	sizex = m_blitter_sizex ^ 0xff;
90	86	skipx = 1;
91	87	}
92	88	else
93	89	{
94		sizex = state->m_blitter_sizex;
	90	sizex = m_blitter_sizex;
95	91	skipx = -1;
96	92	}
97	93
98		if (state->m_blitter_direction_y)
	94	if (m_blitter_direction_y)
99	95	{
100		sizey = state->m_blitter_sizey ^ 0xff;
	96	sizey = m_blitter_sizey ^ 0xff;
101	97	skipy = 1;
102	98	}
103	99	else
104	100	{
105		sizey = state->m_blitter_sizey;
	101	sizey = m_blitter_sizey;
106	102	skipy = -1;
107	103	}
108	104
109		gfxlen = machine.root_device().memregion("gfx1")->bytes();
110		gfxaddr = (state->m_gfxrom << 17) + (state->m_blitter_src_addr << 1);
	105	gfxlen = machine().root_device().memregion("gfx1")->bytes();
	106	gfxaddr = (m_gfxrom << 17) + (m_blitter_src_addr << 1);
111	107
112	108	for (y = starty, ctry = sizey; ctry >= 0; y += skipy, ctry--)
113	109	{
r20826	r20827
127	123	dx2 = (2 * x + 1) & 0x1ff;
128	124	dy = y & 0xff;
129	125
130		if (state->m_highcolorflag & 0x04)
	126	if (m_highcolorflag & 0x04)
131	127	{
132	128	// direct mode
133	129
134	130	if (color != 0xff)
135	131	{
136		if (state->m_highcolorflag & 0x20)
	132	if (m_highcolorflag & 0x20)
137	133	{
138	134	/* least significant bits */
139	135
r20826	r20827
146	142
147	143	pen = MAKE_RGB(pal6bit(r), pal5bit(g), pal5bit(b));
148	144
149		state->m_tmpbitmap.pix32(dy, dx1) = state->m_tmpbitmap.pix32(dy, dx1) | pen;
150		state->m_tmpbitmap.pix32(dy, dx2) = state->m_tmpbitmap.pix32(dy, dx2) | pen;
	145	m_tmpbitmap.pix32(dy, dx1) = m_tmpbitmap.pix32(dy, dx1) | pen;
	146	m_tmpbitmap.pix32(dy, dx2) = m_tmpbitmap.pix32(dy, dx2) | pen;
151	147	}
152	148	else
153	149	{
r20826	r20827
162	158
163	159	pen = MAKE_RGB(pal6bit(r << 3), pal5bit(g << 2), pal5bit(b << 3));
164	160
165		state->m_tmpbitmap.pix32(dy, dx1) = pen;
166		state->m_tmpbitmap.pix32(dy, dx2) = pen;
	161	m_tmpbitmap.pix32(dy, dx1) = pen;
	162	m_tmpbitmap.pix32(dy, dx2) = pen;
167	163	}
168	164	}
169	165	}
r20826	r20827
171	167	{
172	168	// lookup table mode
173	169
174		if (state->m_blitter_direction_x)
	170	if (m_blitter_direction_x)
175	171	{
176	172	// flip
177	173	color1 = (color & 0x0f) >> 0;
r20826	r20827
184	180	color2 = (color & 0x0f) >> 0;
185	181	}
186	182
187		if (state->m_clut[color1])
	183	if (m_clut[color1])
188	184	{
189	185	// src xxxxxxxx_bbgggrrr
190	186	// dst bbxxxggg_xxrrrxxx
191	187
192		r = ((~state->m_clut[color1] & 0x07) >> 0) & 0x07;
193		g = ((~state->m_clut[color1] & 0x38) >> 3) & 0x07;
194		b = ((~state->m_clut[color1] & 0xc0) >> 6) & 0x03;
	188	r = ((~m_clut[color1] & 0x07) >> 0) & 0x07;
	189	g = ((~m_clut[color1] & 0x38) >> 3) & 0x07;
	190	b = ((~m_clut[color1] & 0xc0) >> 6) & 0x03;
195	191
196	192	pen = MAKE_RGB(pal6bit(r << 3), pal5bit(g << 2), pal5bit(b << 3));
197	193
198		state->m_tmpbitmap.pix32(dy, dx1) = pen;
	194	m_tmpbitmap.pix32(dy, dx1) = pen;
199	195	}
200	196
201		if (state->m_clut[color2])
	197	if (m_clut[color2])
202	198	{
203	199	// src xxxxxxxx_bbgggrrr
204	200	// dst bbxxxggg_xxrrrxxx
205	201
206		r = ((~state->m_clut[color2] & 0x07) >> 0) & 0x07;
207		g = ((~state->m_clut[color2] & 0x38) >> 3) & 0x07;
208		b = ((~state->m_clut[color2] & 0xc0) >> 6) & 0x03;
	202	r = ((~m_clut[color2] & 0x07) >> 0) & 0x07;
	203	g = ((~m_clut[color2] & 0x38) >> 3) & 0x07;
	204	b = ((~m_clut[color2] & 0xc0) >> 6) & 0x03;
209	205
210	206	pen = MAKE_RGB(pal6bit(r << 3), pal5bit(g << 2), pal5bit(b << 3));
211	207
212		state->m_tmpbitmap.pix32(dy, dx2) = pen;
	208	m_tmpbitmap.pix32(dy, dx2) = pen;
213	209	}
214	210	}
215	211
r20826	r20827
218	214	}
219	215
220	216	nb1413m3_busyflag = 0;
221		machine.scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(hyhoo_state::blitter_timer_callback),state));
	217	machine().scheduler().timer_set(attotime::from_hz(400000) * nb1413m3_busyctr, timer_expired_delegate(FUNC(hyhoo_state::blitter_timer_callback),this));
222	218	}
223	219
224	220

trunk/src/mame/video/homedata.c

r20826	r20827
32	32
33	33	***************************************************************************/
34	34
35		static void mrokumei_handleblit( address_space &space, int rom_base )
	35	void homedata_state::mrokumei_handleblit( address_space &space, int rom_base )
36	36	{
37		homedata_state *state = space.machine().driver_data<homedata_state>();
38	37	int i;
39	38	int dest_param;
40	39	int source_addr;
41	40	int dest_addr;
42	41	int base_addr;
43	42	int opcode, data, num_tiles;
44		UINT8 *pBlitData = state->memregion("user1")->base() + rom_base;
	43	UINT8 *pBlitData = memregion("user1")->base() + rom_base;
45	44
46		dest_param = state->m_blitter_param[(state->m_blitter_param_count - 4) & 3] * 256 +
47		state->m_blitter_param[(state->m_blitter_param_count - 3) & 3];
	45	dest_param = m_blitter_param[(m_blitter_param_count - 4) & 3] * 256 +
	46	m_blitter_param[(m_blitter_param_count - 3) & 3];
48	47
49		source_addr = state->m_blitter_param[(state->m_blitter_param_count - 2) & 3] * 256 +
50		state->m_blitter_param[(state->m_blitter_param_count - 1) & 3];
	48	source_addr = m_blitter_param[(m_blitter_param_count - 2) & 3] * 256 +
	49	m_blitter_param[(m_blitter_param_count - 1) & 3];
51	50
52	51	/*  xxx-.----.----.---- not used?
53	52	*  ---x.----.----.---- layer
r20826	r20827
58	57
59	58	//  logerror( "[blit bank %02x src %04x dst %04x]\n", blitter_bank, source_addr, dest_param);
60	59
61		if( state->m_visible_page == 0 )
	60	if( m_visible_page == 0 )
62	61	{
63	62	base_addr += 0x2000;
64	63	}
r20826	r20827
99	98	} /* i!=0 */
100	99
101	100	if (data)   /* 00 is a nop */
102		state->mrokumei_videoram_w(space, base_addr + dest_addr, data);
	101	mrokumei_videoram_w(space, base_addr + dest_addr, data);
103	102
104		if (state->m_vreg[1] & 0x80)    /* flip screen */
	103	if (m_vreg[1] & 0x80)    /* flip screen */
105	104	{
106	105	dest_addr -= 2;
107	106	if (dest_addr < 0)
r20826	r20827
116	115	} /* for(;;) */
117	116
118	117	finish:
119		state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
	118	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
120	119	}
121	120
122		static void reikaids_handleblit( address_space &space, int rom_base )
	121	void homedata_state::reikaids_handleblit( address_space &space, int rom_base )
123	122	{
124		homedata_state *state = space.machine().driver_data<homedata_state>();
125	123	int i;
126	124	UINT16 dest_param;
127	125	int flipx;
128	126	int source_addr, base_addr;
129	127	int dest_addr;
130		UINT8 *pBlitData = state->memregion("user1")->base() + rom_base;
	128	UINT8 *pBlitData = memregion("user1")->base() + rom_base;
131	129
132	130	int opcode, data, num_tiles;
133	131
134		dest_param = state->m_blitter_param[(state->m_blitter_param_count - 4) & 3] * 256 +
135		state->m_blitter_param[(state->m_blitter_param_count - 3) & 3];
	132	dest_param = m_blitter_param[(m_blitter_param_count - 4) & 3] * 256 +
	133	m_blitter_param[(m_blitter_param_count - 3) & 3];
136	134
137		source_addr = state->m_blitter_param[(state->m_blitter_param_count - 2) & 3] * 256 +
138		state->m_blitter_param[(state->m_blitter_param_count - 1) & 3];
	135	source_addr = m_blitter_param[(m_blitter_param_count - 2) & 3] * 256 +
	136	m_blitter_param[(m_blitter_param_count - 1) & 3];
139	137
140	138	/*  x---.----.----.---- flipx
141	139	*  -x--.----.----.---- select: attr/tile
r20826	r20827
147	145
148	146	//  logerror( "[blit %02x %04x %04x]\n",blitter_bank,source_addr,dest_param);
149	147
150		if (state->m_visible_page == 0)
	148	if (m_visible_page == 0)
151	149	base_addr += 0x2000 << 2;
152	150
153	151	for(;;)
r20826	r20827
202	200	addr ^= 0x007c;
203	201	}
204	202
205		state->reikaids_videoram_w(space, addr, dat);
	203	reikaids_videoram_w(space, addr, dat);
206	204	}
207	205	}
208	206
209		if (state->m_vreg[1] & 0x80)    /* flip screen */
	207	if (m_vreg[1] & 0x80)    /* flip screen */
210	208	dest_addr-=4;
211	209	else
212	210	dest_addr+=4;
r20826	r20827
214	212	}
215	213
216	214	finish:
217		state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
	215	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
218	216	}
219	217
220		static void pteacher_handleblit( address_space &space, int rom_base )
	218	void homedata_state::pteacher_handleblit( address_space &space, int rom_base )
221	219	{
222		homedata_state *state = space.machine().driver_data<homedata_state>();
223	220	int i;
224	221	int dest_param;
225	222	int source_addr;
226	223	int dest_addr, base_addr;
227	224	int opcode, data, num_tiles;
228		UINT8 *pBlitData = state->memregion("user1")->base() + rom_base;
	225	UINT8 *pBlitData = memregion("user1")->base() + rom_base;
229	226
230		dest_param = state->m_blitter_param[(state->m_blitter_param_count - 4) & 3] * 256 +
231		state->m_blitter_param[(state->m_blitter_param_count - 3) & 3];
	227	dest_param = m_blitter_param[(m_blitter_param_count - 4) & 3] * 256 +
	228	m_blitter_param[(m_blitter_param_count - 3) & 3];
232	229
233		source_addr = state->m_blitter_param[(state->m_blitter_param_count - 2) & 3] * 256 +
234		state->m_blitter_param[(state->m_blitter_param_count - 1) & 3];
	230	source_addr = m_blitter_param[(m_blitter_param_count - 2) & 3] * 256 +
	231	m_blitter_param[(m_blitter_param_count - 1) & 3];
235	232
236	233	/*  x---.----.----.---- not used?
237	234	*  -x--.----.----.---- layer   (0..1)
r20826	r20827
242	239
243	240	//  logerror( "[blit %02x %04x %04x]->%d\n",blitter_bank,source_addr,dest_param,homedata_visible_page);
244	241
245		if (state->m_visible_page == 0)
	242	if (m_visible_page == 0)
246	243	{
247	244	base_addr += 0x2000 << 2;
248	245	}
r20826	r20827
289	286	if ((addr & 0x2080) == 0)
290	287	{
291	288	addr = ((addr & 0xc000) >> 2) | ((addr & 0x1f00) >> 1) | (addr & 0x7f);
292		state->mrokumei_videoram_w(space, addr, data);
	289	mrokumei_videoram_w(space, addr, data);
293	290	}
294	291	}
295	292
296		if (state->m_vreg[1] & 0x80)    /* flip screen */
	293	if (m_vreg[1] & 0x80)    /* flip screen */
297	294	dest_addr -= 2;
298	295	else
299	296	dest_addr += 2;
r20826	r20827
301	298	} /* for(;;) */
302	299
303	300	finish:
304		state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
	301	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
305	302	}
306	303
307	304
r20826	r20827
404	401
405	402	***************************************************************************/
406	403
407		INLINE void mrokumei_info0( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int gfxbank )
	404	inline void homedata_state::mrokumei_info0( tile_data &tileinfo, int tile_index, int page, int gfxbank )
408	405	{
409		homedata_state *state = machine.driver_data<homedata_state>();
410	406	int addr  = tile_index * 2 + 0x2000 * page;
411		int attr  = state->m_videoram[addr];
412		int code  = state->m_videoram[addr + 1] + ((attr & 0x03) << 8) + (gfxbank << 10);
	407	int attr  = m_videoram[addr];
	408	int code  = m_videoram[addr + 1] + ((attr & 0x03) << 8) + (gfxbank << 10);
413	409	int color = (attr >> 2) + (gfxbank << 6);
414	410
415		SET_TILE_INFO( 0, code, color, state->m_flipscreen );
	411	SET_TILE_INFO_MEMBER( 0, code, color, m_flipscreen );
416	412	}
417		INLINE void mrokumei_info1( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int gfxbank )
	413	inline void homedata_state::mrokumei_info1( tile_data &tileinfo, int tile_index, int page, int gfxbank )
418	414	{
419		homedata_state *state = machine.driver_data<homedata_state>();
420	415	int addr  = tile_index * 2 + 0x1000 + 0x2000 * page;
421		int attr  = state->m_videoram[addr];
422		int code  = state->m_videoram[addr + 1] + ((attr & 0x07) << 8) + (gfxbank << 11);
	416	int attr  = m_videoram[addr];
	417	int code  = m_videoram[addr + 1] + ((attr & 0x07) << 8) + (gfxbank << 11);
423	418	int color = (attr >> 3) + ((gfxbank & 3) << 6);
424	419
425		SET_TILE_INFO( 1, code, color, state->m_flipscreen );
	420	SET_TILE_INFO_MEMBER( 1, code, color, m_flipscreen );
426	421	}
427	422
428	423	TILE_GET_INFO_MEMBER(homedata_state::mrokumei_get_info0_0)
429	424	{
430		mrokumei_info0( machine(), tileinfo, tile_index, 0,  m_blitter_bank & 0x03 );
	425	mrokumei_info0(tileinfo, tile_index, 0,  m_blitter_bank & 0x03 );
431	426	}
432	427
433	428	TILE_GET_INFO_MEMBER(homedata_state::mrokumei_get_info1_0)
434	429	{
435		mrokumei_info0( machine(), tileinfo, tile_index, 1,  m_blitter_bank & 0x03 );
	430	mrokumei_info0(tileinfo, tile_index, 1,  m_blitter_bank & 0x03 );
436	431	}
437	432
438	433	TILE_GET_INFO_MEMBER(homedata_state::mrokumei_get_info0_1)
439	434	{
440		mrokumei_info1( machine(), tileinfo, tile_index, 0, (m_blitter_bank & 0x38) >> 3 );
	435	mrokumei_info1(tileinfo, tile_index, 0, (m_blitter_bank & 0x38) >> 3 );
441	436	}
442	437
443	438	TILE_GET_INFO_MEMBER(homedata_state::mrokumei_get_info1_1)
444	439	{
445		mrokumei_info1( machine(), tileinfo, tile_index, 1, (m_blitter_bank & 0x38) >> 3 );
	440	mrokumei_info1(tileinfo, tile_index, 1, (m_blitter_bank & 0x38) >> 3 );
446	441	}
447	442
448	443
449		INLINE void reikaids_info( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int layer, int gfxbank )
	444	inline void homedata_state::reikaids_info( tile_data &tileinfo, int tile_index, int page, int layer, int gfxbank )
450	445	{
451		homedata_state *state = machine.driver_data<homedata_state>();
452	446	int addr  = tile_index * 4 + layer + 0x2000 * page;
453		int attr  = state->m_videoram[addr];
454		int code  = state->m_videoram[addr + 0x1000] + ((attr & 0x03) << 8) + (gfxbank << 10);
	447	int attr  = m_videoram[addr];
	448	int code  = m_videoram[addr + 0x1000] + ((attr & 0x03) << 8) + (gfxbank << 10);
455	449	int color = (attr & 0x7c) >> 2;
456		int flags = state->m_flipscreen;
	450	int flags = m_flipscreen;
457	451
458	452	if (attr & 0x80) flags ^= TILE_FLIPX;
459	453
460		SET_TILE_INFO( layer, code, color, flags );
	454	SET_TILE_INFO_MEMBER( layer, code, color, flags );
461	455	}
462	456
463	457	/* reikaids_gfx_bank[0]:
r20826	r20827
470	464	*/
471	465	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info0_0)
472	466	{
473		reikaids_info(machine(), tileinfo, tile_index, 0, 0,  (m_gfx_bank[1] >> 3));
	467	reikaids_info(tileinfo, tile_index, 0, 0,  (m_gfx_bank[1] >> 3));
474	468	}
475	469
476	470	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info1_0)
477	471	{
478		reikaids_info(machine(), tileinfo, tile_index, 1, 0,  (m_gfx_bank[1] >> 3));
	472	reikaids_info(tileinfo, tile_index, 1, 0,  (m_gfx_bank[1] >> 3));
479	473	}
480	474
481	475	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info0_1)
482	476	{
483		reikaids_info(machine(), tileinfo, tile_index, 0, 1, ((m_gfx_bank[0] & 0x78) >> 3));
	477	reikaids_info(tileinfo, tile_index, 0, 1, ((m_gfx_bank[0] & 0x78) >> 3));
484	478	}
485	479
486	480	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info1_1)
487	481	{
488		reikaids_info(machine(), tileinfo, tile_index, 1, 1, ((m_gfx_bank[0] & 0x78) >> 3));
	482	reikaids_info(tileinfo, tile_index, 1, 1, ((m_gfx_bank[0] & 0x78) >> 3));
489	483	}
490	484
491	485	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info0_2)
492	486	{
493		reikaids_info(machine(), tileinfo, tile_index, 0, 2,  (m_gfx_bank[1] & 0x7));
	487	reikaids_info(tileinfo, tile_index, 0, 2,  (m_gfx_bank[1] & 0x7));
494	488	}
495	489
496	490	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info1_2)
497	491	{
498		reikaids_info(machine(), tileinfo, tile_index, 1, 2,  (m_gfx_bank[1] & 0x7));
	492	reikaids_info(tileinfo, tile_index, 1, 2,  (m_gfx_bank[1] & 0x7));
499	493	}
500	494
501	495	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info0_3)
502	496	{
503		reikaids_info(machine(), tileinfo, tile_index, 0, 3,  (m_gfx_bank[0] & 0x7));
	497	reikaids_info(tileinfo, tile_index, 0, 3,  (m_gfx_bank[0] & 0x7));
504	498	}
505	499
506	500	TILE_GET_INFO_MEMBER(homedata_state::reikaids_get_info1_3)
507	501	{
508		reikaids_info(machine(), tileinfo, tile_index, 1, 3,  (m_gfx_bank[0] & 0x7));
	502	reikaids_info(tileinfo, tile_index, 1, 3,  (m_gfx_bank[0] & 0x7));
509	503	}
510	504
511	505
512		INLINE void pteacher_info( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int layer, int gfxbank )
	506	inline void homedata_state::pteacher_info( tile_data &tileinfo, int tile_index, int page, int layer, int gfxbank )
513	507	{
514		homedata_state *state = machine.driver_data<homedata_state>();
515	508	int addr  = tile_index * 2 + 0x1000 * layer + 0x2000 * page;
516		int attr  = state->m_videoram[addr];
517		int code  = state->m_videoram[addr + 1] + ((attr & 0x07) << 8) + (gfxbank << 11);
	509	int attr  = m_videoram[addr];
	510	int code  = m_videoram[addr + 1] + ((attr & 0x07) << 8) + (gfxbank << 11);
518	511	int color = (attr >> 3) + ((gfxbank & 1) << 5);
519	512
520		SET_TILE_INFO(layer, code, color, state->m_flipscreen);
	513	SET_TILE_INFO_MEMBER(layer, code, color, m_flipscreen);
521	514	}
522	515
523	516	TILE_GET_INFO_MEMBER(homedata_state::pteacher_get_info0_0)
524	517	{
525		pteacher_info(machine(), tileinfo, tile_index, 0, 0, m_gfx_bank[0] & 0x0f);
	518	pteacher_info(tileinfo, tile_index, 0, 0, m_gfx_bank[0] & 0x0f);
526	519	}
527	520
528	521	TILE_GET_INFO_MEMBER(homedata_state::pteacher_get_info1_0)
529	522	{
530		pteacher_info(machine(), tileinfo, tile_index, 1, 0, m_gfx_bank[0] & 0x0f);
	523	pteacher_info(tileinfo, tile_index, 1, 0, m_gfx_bank[0] & 0x0f);
531	524	}
532	525
533	526	TILE_GET_INFO_MEMBER(homedata_state::pteacher_get_info0_1)
534	527	{
535		pteacher_info(machine(), tileinfo, tile_index, 0, 1, m_gfx_bank[0] >> 4);
	528	pteacher_info(tileinfo, tile_index, 0, 1, m_gfx_bank[0] >> 4);
536	529	}
537	530
538	531	TILE_GET_INFO_MEMBER(homedata_state::pteacher_get_info1_1)
539	532	{
540		pteacher_info(machine(), tileinfo, tile_index, 1, 1, m_gfx_bank[0] >> 4);
	533	pteacher_info(tileinfo, tile_index, 1, 1, m_gfx_bank[0] >> 4);
541	534	}
542	535
543	536
544		INLINE void lemnangl_info( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int layer, int gfxset, int gfxbank )
	537	inline void homedata_state::lemnangl_info( tile_data &tileinfo, int tile_index, int page, int layer, int gfxset, int gfxbank )
545	538	{
546		homedata_state *state = machine.driver_data<homedata_state>();
547	539	int addr  = tile_index * 2 + 0x1000 * layer + 0x2000 * page;
548		int attr  = state->m_videoram[addr];
549		int code  = state->m_videoram[addr + 1] + ((attr & 0x07) << 8) + (gfxbank << 11);
	540	int attr  = m_videoram[addr];
	541	int code  = m_videoram[addr + 1] + ((attr & 0x07) << 8) + (gfxbank << 11);
550	542	int color = 16 * (attr >> 3) + gfxbank;
551	543
552		SET_TILE_INFO(2 * layer + gfxset, code, color, state->m_flipscreen);
	544	SET_TILE_INFO_MEMBER(2 * layer + gfxset, code, color, m_flipscreen);
553	545	}
554	546
555	547	TILE_GET_INFO_MEMBER(homedata_state::lemnangl_get_info0_0)
556	548	{
557		lemnangl_info( machine(), tileinfo, tile_index, 0, 0,  m_blitter_bank & 1, m_gfx_bank[0] & 0x0f );
	549	lemnangl_info(tileinfo, tile_index, 0, 0,  m_blitter_bank & 1, m_gfx_bank[0] & 0x0f );
558	550	}
559	551
560	552	TILE_GET_INFO_MEMBER(homedata_state::lemnangl_get_info1_0)
561	553	{
562		lemnangl_info( machine(), tileinfo, tile_index, 1, 0,  m_blitter_bank & 1, m_gfx_bank[0] & 0x0f );
	554	lemnangl_info(tileinfo, tile_index, 1, 0,  m_blitter_bank & 1, m_gfx_bank[0] & 0x0f );
563	555	}
564	556
565	557
566	558	TILE_GET_INFO_MEMBER(homedata_state::lemnangl_get_info0_1)
567	559	{
568		lemnangl_info( machine(), tileinfo, tile_index, 0, 1, (m_blitter_bank & 2) >> 1, m_gfx_bank[0] >> 4 );
	560	lemnangl_info(tileinfo, tile_index, 0, 1, (m_blitter_bank & 2) >> 1, m_gfx_bank[0] >> 4 );
569	561	}
570	562
571	563	TILE_GET_INFO_MEMBER(homedata_state::lemnangl_get_info1_1)
572	564	{
573		lemnangl_info( machine(), tileinfo, tile_index, 1, 1, (m_blitter_bank & 2) >> 1, m_gfx_bank[0] >> 4 );
	565	lemnangl_info(tileinfo, tile_index, 1, 1, (m_blitter_bank & 2) >> 1, m_gfx_bank[0] >> 4 );
574	566	}
575	567
576	568
577		INLINE void mirderby_info0( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int gfxbank )
	569	inline void homedata_state::mirderby_info0( tile_data &tileinfo, int tile_index, int page, int gfxbank )
578	570	{
579		homedata_state *state = machine.driver_data<homedata_state>();
580	571	int addr  = tile_index * 2 + 0x2000 * page;
581		int attr  = state->m_videoram[addr];
582		int code  = state->m_videoram[addr + 1] + ((attr & 0x03) << 8) + 0x400;// + (gfxbank << 10);
	572	int attr  = m_videoram[addr];
	573	int code  = m_videoram[addr + 1] + ((attr & 0x03) << 8) + 0x400;// + (gfxbank << 10);
583	574	int color = (attr >> 2) + (gfxbank << 6);
584	575
585		SET_TILE_INFO( 0, code, color, state->m_flipscreen );
	576	SET_TILE_INFO_MEMBER( 0, code, color, m_flipscreen );
586	577	}
587		INLINE void mirderby_info1( running_machine &machine, tile_data &tileinfo, int tile_index, int page, int gfxbank )
	578	inline void homedata_state::mirderby_info1( tile_data &tileinfo, int tile_index, int page, int gfxbank )
588	579	{
589		homedata_state *state = machine.driver_data<homedata_state>();
590	580	int addr  = tile_index * 2 + 0x1000 + 0x2000 * page;
591		int attr  = state->m_videoram[addr];
592		int code  = state->m_videoram[addr + 1] + ((attr & 0x07) << 8) + 0x400;//(gfxbank << 11);
	581	int attr  = m_videoram[addr];
	582	int code  = m_videoram[addr + 1] + ((attr & 0x07) << 8) + 0x400;//(gfxbank << 11);
593	583	int color = (attr >> 3) + ((gfxbank & 3) << 6);
594	584
595		SET_TILE_INFO( 1, code, color, state->m_flipscreen );
	585	SET_TILE_INFO_MEMBER( 1, code, color, m_flipscreen );
596	586	}
597	587
598	588	TILE_GET_INFO_MEMBER(homedata_state::mirderby_get_info0_0)
599	589	{
600		mirderby_info0( machine(), tileinfo, tile_index, 0, 0);// m_blitter_bank & 0x03 );
	590	mirderby_info0(tileinfo, tile_index, 0, 0);// m_blitter_bank & 0x03 );
601	591	}
602	592
603	593	TILE_GET_INFO_MEMBER(homedata_state::mirderby_get_info1_0)
604	594	{
605		mirderby_info0( machine(), tileinfo, tile_index, 1, 0);// m_blitter_bank & 0x03 );
	595	mirderby_info0(tileinfo, tile_index, 1, 0);// m_blitter_bank & 0x03 );
606	596	}
607	597
608	598	TILE_GET_INFO_MEMBER(homedata_state::mirderby_get_info0_1)
609	599	{
610		mirderby_info1( machine(), tileinfo, tile_index, 0, 0);//(m_blitter_bank & 0x38) >> 3 );
	600	mirderby_info1(tileinfo, tile_index, 0, 0);//(m_blitter_bank & 0x38) >> 3 );
611	601	}
612	602
613	603	TILE_GET_INFO_MEMBER(homedata_state::mirderby_get_info1_1)
614	604	{
615		mirderby_info1( machine(), tileinfo, tile_index, 1, 0);//(m_blitter_bank & 0x38) >> 3 );
	605	mirderby_info1(tileinfo, tile_index, 1, 0);//(m_blitter_bank & 0x38) >> 3 );
616	606	}
617	607
618	608

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team