Previous

199869 Revisions

Next

r33961 Friday 19th December, 2014 at 17:53:11 UTC by Osso
Added missing save state support to segaic16_video_device. Fixes quartet2 save state problem (nw) Some almost exclusively cosmetic changes to the device, while at it (nw)

[src/mame/drivers]	segahang.c segaorun.c segas16a.c segas16b.c segas18.c segaxbd.c segaybd.c
[src/mame/includes]	segaorun.h segas16b.h segas18.h
[src/mame/video]	segahang.c segaic16.c segaic16.h segaorun.c segas16a.c segas16b.c segas18.c segaxbd.c segaybd.c

trunk/src/mame/drivers/segahang.c

r242472	r242473
59	59	//
60	60
61	61	// bit 7: screen flip
62		m_segaic16vid->segaic16_tilemap_set_flip(0, data & 0x80);
	62	m_segaic16vid->tilemap_set_flip(0, data & 0x80);
63	63	m_sprites->set_flip(data & 0x80);
64	64
65	65	// bit 6: shadow/highlight control
66	66	m_shadow = ~data & 0x40;
67	67
68	68	// bit 4: enable display
69		m_segaic16vid->segaic16_set_display_enable(data & 0x10);
	69	m_segaic16vid->set_display_enable(data & 0x10);
70	70
71	71	// bits 2 & 3: control the lamps
72	72	set_led_status(machine(), 1, data & 0x08);
r242472	r242473
102	102	m_soundcpu->set_input_line(INPUT_LINE_NMI, (data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
103	103
104	104	// bits 1 & 2: tilemap origin
105		m_segaic16vid->segaic16_tilemap_set_colscroll(0, ~data & 0x04);
106		m_segaic16vid->segaic16_tilemap_set_rowscroll(0, ~data & 0x02);
	105	m_segaic16vid->tilemap_set_colscroll(0, ~data & 0x04);
	106	m_segaic16vid->tilemap_set_rowscroll(0, ~data & 0x02);
107	107
108	108	// bit 0: sound mute
109	109	machine().sound().system_enable(data & 0x01);
r242472	r242473
350	350	void segahang_state::machine_reset()
351	351	{
352	352	// reset misc components
353		m_segaic16vid->segaic16_tilemap_reset(*m_screen);
	353	m_segaic16vid->tilemap_reset(*m_screen);
354	354
355	355	// queue up a timer to either boost interleave or disable the MCU
356	356	synchronize(TID_INIT_I8751);
r242472	r242473
413	413	ADDRESS_MAP_UNMAP_HIGH
414	414	AM_RANGE(0x000000, 0x03ffff) AM_ROM
415	415	AM_RANGE(0x20c000, 0x20ffff) AM_RAM AM_SHARE("workram")
416		AM_RANGE(0x400000, 0x403fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_tileram_0_r, segaic16_tileram_0_w) AM_SHARE("textram")
417		AM_RANGE(0x410000, 0x410fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_textram_0_r, segaic16_textram_0_w) AM_SHARE("tileram")
	416	AM_RANGE(0x400000, 0x403fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, tileram_r, tileram_w) AM_SHARE("tileram")
	417	AM_RANGE(0x410000, 0x410fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, textram_r, textram_w) AM_SHARE("textram")
418	418	AM_RANGE(0x600000, 0x6007ff) AM_RAM AM_SHARE("sprites")
419	419	AM_RANGE(0xa00000, 0xa00fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
420	420	AM_RANGE(0xc00000, 0xc3ffff) AM_ROM AM_REGION("subcpu", 0)
r242472	r242473
427	427	ADDRESS_MAP_UNMAP_HIGH
428	428	AM_RANGE(0x000000, 0x03ffff) AM_ROM
429	429	AM_RANGE(0x040000, 0x043fff) AM_RAM AM_SHARE("workram")
430		AM_RANGE(0x100000, 0x107fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_tileram_0_r, segaic16_tileram_0_w) AM_SHARE("textram")
431		AM_RANGE(0x108000, 0x108fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_textram_0_r, segaic16_textram_0_w) AM_SHARE("tileram")
	430	AM_RANGE(0x100000, 0x107fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, tileram_r, tileram_w) AM_SHARE("tileram")
	431	AM_RANGE(0x108000, 0x108fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, textram_r, textram_w) AM_SHARE("textram")
432	432	AM_RANGE(0x110000, 0x110fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
433	433	AM_RANGE(0x124000, 0x127fff) AM_RAM AM_SHARE("subram")
434	434	AM_RANGE(0x130000, 0x130fff) AM_RAM AM_SHARE("sprites")
r242472	r242473
1746	1746	DRIVER_INIT_MEMBER(segahang_state,generic)
1747	1747	{
1748	1748	// point globals to allocated memory regions
1749		m_segaic16vid->segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
1750		m_segaic16vid->segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
1751	1749	m_segaic16road->segaic16_roadram_0 = reinterpret_cast<UINT16 *>(memshare("roadram")->ptr());
1752	1750
1753	1751	// save states

trunk/src/mame/drivers/segaorun.c

r242472	r242473
349	349	//  D1: (CONT) - affects sprite hardware
350	350	//  D0: Sound section reset (1= normal operation, 0= reset)
351	351
352		m_segaic16vid->segaic16_set_display_enable(data & 0x20);
	352	m_segaic16vid->set_display_enable(data & 0x20);
353	353	m_adc_select = (data >> 2) & 7;
354	354	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
355	355	}
r242472	r242473
459	459	break;
460	460
461	461	case 1:
462		mapper.map_as_ram(0x00000, 0x10000, 0xfe0000, "tileram", write16_delegate(FUNC(segaorun_state::sega_tileram_0_w), this));
463		mapper.map_as_ram(0x10000, 0x01000, 0xfef000, "textram", write16_delegate(FUNC(segaorun_state::sega_textram_0_w), this));
	462	mapper.map_as_ram(0x00000, 0x10000, 0xfe0000, "tileram", write16_delegate(FUNC(segaorun_state::tileram_w), this));
	463	mapper.map_as_ram(0x10000, 0x01000, 0xfef000, "textram", write16_delegate(FUNC(segaorun_state::textram_w), this));
464	464	break;
465	465
466	466	case 0:
r242472	r242473
568	568	// reset misc components
569	569	if (m_custom_map != NULL)
570	570	m_mapper->configure_explicit(m_custom_map);
571		m_segaic16vid->segaic16_tilemap_reset(*m_screen);
	571	m_segaic16vid->tilemap_reset(*m_screen);
572	572
573	573	// hook the RESET line, which resets CPU #1
574	574	m_maincpu->set_reset_callback(write_line_delegate(FUNC(segaorun_state::m68k_reset_callback),this));
r242472	r242473
814	814	//  D2: Start lamp
815	815	//  other bits: ?
816	816	m_adc_select = data >> 6 & 3;
817		m_segaic16vid->segaic16_set_display_enable(data >> 5 & 1);
	817	m_segaic16vid->set_display_enable(data >> 5 & 1);
818	818	output_set_value("Vibration_motor", data >> 3 & 1);
819	819	output_set_value("Start_lamp", data >> 2 & 1);
820	820	}
r242472	r242473
2369	2369	m_nvram->set_base(m_workram, m_workram.bytes());
2370	2370
2371	2371	// point globals to allocated memory regions
2372		m_segaic16vid->segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
2373		m_segaic16vid->segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
2374	2372	m_segaic16road->segaic16_roadram_0 = reinterpret_cast<UINT16 *>(memshare("roadram")->ptr());
2375	2373
2376	2374	// save state

trunk/src/mame/drivers/segas16a.c

r242472	r242473
187	187	m_video_control = data;
188	188
189	189	// bit 7: screen flip
190		m_segaic16vid->segaic16_tilemap_set_flip(0, data & 0x80);
	190	m_segaic16vid->tilemap_set_flip(0, data & 0x80);
191	191	m_sprites->set_flip(data & 0x80);
192	192
193	193	// bit 6: set 8751 interrupt line
r242472	r242473
195	195	m_mcu->set_input_line(MCS51_INT1_LINE, (data & 0x40) ? CLEAR_LINE : ASSERT_LINE);
196	196
197	197	// bit 4: enable display
198		m_segaic16vid->segaic16_set_display_enable(data & 0x10);
	198	m_segaic16vid->set_display_enable(data & 0x10);
199	199
200	200	// bits 0 & 1: update coin counters
201	201	coin_counter_w(machine(), 1, data & 0x02);
r242472	r242473
224	224	//       1= sound is enabled
225	225	//
226	226	m_soundcpu->set_input_line(INPUT_LINE_NMI, (data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
227		m_segaic16vid->segaic16_tilemap_set_colscroll(0, ~data & 0x04);
228		m_segaic16vid->segaic16_tilemap_set_rowscroll(0, ~data & 0x02);
	227	m_segaic16vid->tilemap_set_colscroll(0, ~data & 0x04);
	228	m_segaic16vid->tilemap_set_rowscroll(0, ~data & 0x02);
229	229	}
230	230
231	231
r242472	r242473
455	455
456	456	// enable/disable the display
457	457	if (data & 0x40)
458		m_segaic16vid->segaic16_set_display_enable(1);
	458	m_segaic16vid->set_display_enable(1);
459	459
460	460	// apply an extra boost if the main CPU is just waking up
461	461	if ((m_mcu_control ^ data) & 0x40)
r242472	r242473
715	715
716	716	// X scroll values
717	717	address_space &space = m_maincpu->space(AS_PROGRAM);
718		m_segaic16vid->segaic16_textram_0_w(space, 0xff8/2, m_workram[0x0d14/2], 0xffff);
719		m_segaic16vid->segaic16_textram_0_w(space, 0xffa/2, m_workram[0x0d18/2], 0xffff);
	718	m_segaic16vid->textram_w(space, 0xff8/2, m_workram[0x0d14/2], 0xffff);
	719	m_segaic16vid->textram_w(space, 0xffa/2, m_workram[0x0d18/2], 0xffff);
720	720
721	721	// page values
722		m_segaic16vid->segaic16_textram_0_w(space, 0xe9e/2, m_workram[0x0d1c/2], 0xffff);
723		m_segaic16vid->segaic16_textram_0_w(space, 0xe9c/2, m_workram[0x0d1e/2], 0xffff);
	722	m_segaic16vid->textram_w(space, 0xe9e/2, m_workram[0x0d1c/2], 0xffff);
	723	m_segaic16vid->textram_w(space, 0xe9c/2, m_workram[0x0d1e/2], 0xffff);
724	724	}
725	725
726	726
r242472	r242473
952	952	static ADDRESS_MAP_START( system16a_map, AS_PROGRAM, 16, segas16a_state )
953	953	ADDRESS_MAP_UNMAP_HIGH
954	954	AM_RANGE(0x000000, 0x03ffff) AM_MIRROR(0x380000) AM_ROM
955		AM_RANGE(0x400000, 0x407fff) AM_MIRROR(0xb88000) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_tileram_0_r, segaic16_tileram_0_w) AM_SHARE("textram")
956		AM_RANGE(0x410000, 0x410fff) AM_MIRROR(0xb8f000) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_textram_0_r, segaic16_textram_0_w) AM_SHARE("tileram")
	955	AM_RANGE(0x400000, 0x407fff) AM_MIRROR(0xb88000) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, tileram_r, tileram_w) AM_SHARE("tileram")
	956	AM_RANGE(0x410000, 0x410fff) AM_MIRROR(0xb8f000) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, textram_r, textram_w) AM_SHARE("textram")
957	957	AM_RANGE(0x440000, 0x4407ff) AM_MIRROR(0x3bf800) AM_RAM AM_SHARE("sprites")
958	958	AM_RANGE(0x840000, 0x840fff) AM_MIRROR(0x3bf000) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
959	959	AM_RANGE(0xc40000, 0xc43fff) AM_MIRROR(0x39c000) AM_READWRITE(misc_io_r, misc_io_w)
r242472	r242473
3454	3454	m_custom_io_r = read16_delegate(FUNC(segas16a_state::standard_io_r), this);
3455	3455	m_custom_io_w = write16_delegate(FUNC(segas16a_state::standard_io_w), this);
3456	3456
3457		// point globals to allocated memory regions
3458		m_segaic16vid->segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
3459		m_segaic16vid->segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
3460
3461	3457	// save state
3462	3458	save_item(NAME(m_video_control));
3463	3459	save_item(NAME(m_mcu_control));

trunk/src/mame/drivers/segas16b.c

r242472	r242473
912	912	break;
913	913
914	914	case 5: // 64k of tileram + 4k of textram
915		mapper.map_as_ram(0x00000, 0x10000, 0xfe0000, "tileram", write16_delegate(FUNC(segas16b_state::sega_tileram_0_w), this));
916		mapper.map_as_ram(0x10000, 0x01000, 0xfef000, "textram", write16_delegate(FUNC(segas16b_state::sega_textram_0_w), this));
	915	mapper.map_as_ram(0x00000, 0x10000, 0xfe0000, "tileram", write16_delegate(FUNC(segas16b_state::tileram_w), this));
	916	mapper.map_as_ram(0x10000, 0x01000, 0xfef000, "textram", write16_delegate(FUNC(segas16b_state::textram_w), this));
917	917	break;
918	918
919	919	case 4: // 2k of spriteram
r242472	r242473
1003	1003	WRITE16_MEMBER( segas16b_state::rom_5704_bank_w )
1004	1004	{
1005	1005	if (ACCESSING_BITS_0_7)
1006		m_segaic16vid->segaic16_tilemap_set_bank(0, offset & 1, data & 7);
	1006	m_segaic16vid->tilemap_set_bank(0, offset & 1, data & 7);
1007	1007	}
1008	1008
1009	1009
r242472	r242473
1051	1051
1052	1052	case 0x2000/2:
1053	1053	if (ACCESSING_BITS_0_7)
1054		m_segaic16vid->segaic16_tilemap_set_bank(0, offset & 1, data & 7);
	1054	m_segaic16vid->tilemap_set_bank(0, offset & 1, data & 7);
1055	1055	break;
1056	1056	}
1057	1057	}
r242472	r242473
1124	1124	//  D1 : (Output to coin counter 2?)
1125	1125	//  D0 : Output to coin counter 1
1126	1126	//
1127		m_segaic16vid->segaic16_tilemap_set_flip(0, data & 0x40);
	1127	m_segaic16vid->tilemap_set_flip(0, data & 0x40);
1128	1128	m_sprites->set_flip(data & 0x40);
1129	1129	if (!m_disable_screen_blanking)
1130		m_segaic16vid->segaic16_set_display_enable(data & 0x20);
	1130	m_segaic16vid->set_display_enable(data & 0x20);
1131	1131	set_led_status(machine(), 1, data & 0x08);
1132	1132	set_led_status(machine(), 0, data & 0x04);
1133	1133	coin_counter_w(machine(), 1, data & 0x02);
r242472	r242473
1288	1288	synchronize(TID_INIT_I8751);
1289	1289
1290	1290	// reset tilemap state
1291		m_segaic16vid->segaic16_tilemap_reset(*m_screen);
	1291	m_segaic16vid->tilemap_reset(*m_screen);
1292	1292
1293	1293	// configure sprite banks
1294	1294	static const UINT8 default_banklist[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
r242472	r242473
6625	6625	m_custom_io_r = read16_delegate(FUNC(segas16b_state::standard_io_r), this);
6626	6626	m_custom_io_w = write16_delegate(FUNC(segas16b_state::standard_io_w), this);
6627	6627
6628		// point globals to allocated memory regions
6629		m_segaic16vid->segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
6630		m_segaic16vid->segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
6631
6632	6628	// save state
6633	6629	save_item(NAME(m_atomicp_sound_count));
6634	6630	save_item(NAME(m_hwc_input_value));
r242472	r242473
6654	6650	// configure special behaviors for the Korean boards
6655	6651	m_disable_screen_blanking = true;
6656	6652	m_atomicp_sound_divisor = 1;
6657		m_segaic16vid->segaic16_display_enable = 1;
	6653	m_segaic16vid->m_display_enable = 1;
6658	6654
6659	6655	// allocate a sound timer
6660	6656	emu_timer *timer = timer_alloc(TID_ATOMICP_SOUND_IRQ);
r242472	r242473
7221	7217	AM_RANGE(0x000000, 0x0fffff) AM_ROMBANK(ISGSM_MAIN_BANK) AM_REGION("bios", 0) // this area is ALWAYS read-only, even when the game is banked in
7222	7218	AM_RANGE(0x200000, 0x23ffff) AM_RAM // used during startup for decompression
7223	7219	AM_RANGE(0x3f0000, 0x3fffff) AM_WRITE(rom_5704_bank_w)
7224		AM_RANGE(0x400000, 0x40ffff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_tileram_0_r, segaic16_tileram_0_w) AM_SHARE("textram")
7225		AM_RANGE(0x410000, 0x410fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_textram_0_r, segaic16_textram_0_w) AM_SHARE("tileram")
	7220	AM_RANGE(0x400000, 0x40ffff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, tileram_r, tileram_w) AM_SHARE("tileram")
	7221	AM_RANGE(0x410000, 0x410fff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, textram_r, textram_w) AM_SHARE("textram")
7226	7222	AM_RANGE(0x440000, 0x4407ff) AM_RAM AM_SHARE("sprites")
7227	7223	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
7228	7224	AM_RANGE(0xc40000, 0xc43fff) AM_READWRITE(standard_io_r, standard_io_w)
r242472	r242473
7358	7354
7359	7355	void isgsm_state::machine_reset()
7360	7356	{
7361		m_segaic16vid->segaic16_tilemap_reset(*m_screen);
	7357	m_segaic16vid->tilemap_reset(*m_screen);
7362	7358
7363	7359	// configure sprite banks
7364	7360	for (int i = 0; i < 16; i++)

trunk/src/mame/drivers/segas18.c

r242472	r242473
57	57	break;
58	58
59	59	case 5:
60		mapper.map_as_ram(0x00000, 0x10000, 0xfe0000, "tileram", write16_delegate(FUNC(segas18_state::sega_tileram_0_w), this));
61		mapper.map_as_ram(0x10000, 0x01000, 0xfef000, "textram", write16_delegate(FUNC(segas18_state::sega_textram_0_w), this));
	60	mapper.map_as_ram(0x00000, 0x10000, 0xfe0000, "tileram", write16_delegate(FUNC(segas18_state::tileram_w), this));
	61	mapper.map_as_ram(0x10000, 0x01000, 0xfef000, "textram", write16_delegate(FUNC(segas18_state::textram_w), this));
62	62	break;
63	63
64	64	case 4:
r242472	r242473
141	141	// configure the NVRAM to point to our workram
142	142	m_nvram->set_base(m_workram, m_workram.bytes());
143	143
144		// point globals to allocated memory regions
145		m_segaic16vid->segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
146		m_segaic16vid->segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
147
148	144	// configure VDP
149	145	m_vdp->set_use_cram(1);
150	146	m_vdp->set_vdp_pal(FALSE);
r242472	r242473
181	177
182	178	void segas18_state::machine_reset()
183	179	{
184		m_segaic16vid->segaic16_tilemap_reset(*m_screen);
	180	m_segaic16vid->tilemap_reset(*m_screen);
185	181
186	182	m_vdp->device_reset_old();
187	183
r242472	r242473
202	198	{
203	199	// miscellaneous output
204	200	set_grayscale(~data & 0x40);
205		m_segaic16vid->segaic16_tilemap_set_flip(0, data & 0x20);
	201	m_segaic16vid->tilemap_set_flip(0, data & 0x20);
206	202	m_sprites->set_flip(data & 0x20);
207	203	// These are correct according to cgfm's docs, but mwalker and ddcrew both
208	204	// enable the lockout and never turn it off
r242472	r242473
284	280	{
285	281	for (int i = 0; i < 4; i++)
286	282	{
287		m_segaic16vid->segaic16_tilemap_set_bank(0, 0 + i, (data & 0xf) * 4 + i);
288		m_segaic16vid->segaic16_tilemap_set_bank(0, 4 + i, ((data >> 4) & 0xf) * 4 + i);
	283	m_segaic16vid->tilemap_set_bank(0, 0 + i, (data & 0xf) * 4 + i);
	284	m_segaic16vid->tilemap_set_bank(0, 4 + i, ((data >> 4) & 0xf) * 4 + i);
289	285	}
290	286	}
291	287	}
r242472	r242473
305	301	int maxbanks = m_gfxdecode->gfx(0)->elements() / 1024;
306	302	if (data >= maxbanks)
307	303	data %= maxbanks;
308		m_segaic16vid->segaic16_tilemap_set_bank(0, offset, data);
	304	m_segaic16vid->tilemap_set_bank(0, offset, data);
309	305	}
310	306
311	307	// sprite banking
r242472	r242473
335	331	if (data & 0x80) data += 0x20;
336	332	data &= 0x3f;
337	333
338		m_segaic16vid->segaic16_tilemap_set_bank(0, offset, data);
	334	m_segaic16vid->tilemap_set_bank(0, offset, data);
339	335	}
340	336
341	337	// sprite banking
r242472	r242473
1217	1213	MCFG_315_5296_IN_PORTF_CB(IOPORT("COINAGE"))
1218	1214	MCFG_315_5296_IN_PORTG_CB(IOPORT("DSW"))
1219	1215	MCFG_315_5296_OUT_PORTH_CB(WRITE8(segas18_state, rom_5874_bank_w))
1220		MCFG_315_5296_OUT_CNT1_CB(DEVWRITELINE("segaic16vid", segaic16_video_device, segaic16_set_display_enable))
	1216	MCFG_315_5296_OUT_CNT1_CB(DEVWRITELINE("segaic16vid", segaic16_video_device, set_display_enable))
1221	1217	MCFG_315_5296_OUT_CNT2_CB(WRITELINE(segas18_state, set_vdp_enable))
1222	1218
1223	1219	MCFG_DEVICE_ADD("gen_vdp", SEGA315_5313, 0)

trunk/src/mame/drivers/segaxbd.c

r242472	r242473
449	449	if (((oldval ^ data) & 0x40) && !(data & 0x40))
450	450	machine().watchdog_reset();
451	451
452		m_segaic16vid->segaic16_set_display_enable(data & 0x20);
	452	m_segaic16vid->set_display_enable(data & 0x20);
453	453
454	454	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
455	455	if (m_soundcpu2 != NULL)
r242472	r242473
640	640
641	641	void segaxbd_state::machine_reset()
642	642	{
643		m_segaic16vid->segaic16_tilemap_reset(*m_screen);
	643	m_segaic16vid->tilemap_reset(*m_screen);
644	644
645	645	// hook the RESET line, which resets CPU #1
646	646	m_maincpu->set_reset_callback(write_line_delegate(FUNC(segaxbd_state::m68k_reset_callback),this));
r242472	r242473
876	876	AM_RANGE(0x000000, 0x07ffff) AM_ROM
877	877	AM_RANGE(0x080000, 0x083fff) AM_MIRROR(0x01c000) AM_RAM AM_SHARE("backup1")
878	878	AM_RANGE(0x0a0000, 0x0a3fff) AM_MIRROR(0x01c000) AM_RAM AM_SHARE("backup2")
879		AM_RANGE(0x0c0000, 0x0cffff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_tileram_0_r, segaic16_tileram_0_w) AM_SHARE("textram")
880		AM_RANGE(0x0d0000, 0x0d0fff) AM_MIRROR(0x00f000) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, segaic16_textram_0_r, segaic16_textram_0_w) AM_SHARE("tileram")
	879	AM_RANGE(0x0c0000, 0x0cffff) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, tileram_r, tileram_w) AM_SHARE("tileram")
	880	AM_RANGE(0x0d0000, 0x0d0fff) AM_MIRROR(0x00f000) AM_DEVREADWRITE("segaic16vid", segaic16_video_device, textram_r, textram_w) AM_SHARE("textram")
881	881	AM_RANGE(0x0e0000, 0x0e0007) AM_MIRROR(0x003ff8) AM_DEVREADWRITE("multiplier_main", sega_315_5248_multiplier_device, read, write)
882	882	AM_RANGE(0x0e4000, 0x0e401f) AM_MIRROR(0x003fe0) AM_DEVREADWRITE("divider_main", sega_315_5249_divider_device, read, write)
883	883	AM_RANGE(0x0e8000, 0x0e801f) AM_MIRROR(0x003fe0) AM_DEVREADWRITE("cmptimer_main", sega_315_5250_compare_timer_device, read, write)
r242472	r242473
3209	3209	m_iochip_custom_io_w[0][3] = iowrite_delegate(FUNC(segaxbd_state::generic_iochip0_lamps_w), this);
3210	3210
3211	3211	// point globals to allocated memory regions
3212		m_segaic16vid->segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
3213		m_segaic16vid->segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
3214	3212	m_segaic16road->segaic16_roadram_0 = reinterpret_cast<UINT16 *>(memshare("roadram")->ptr());
3215	3213
3216	3214	// save state

trunk/src/mame/drivers/segaybd.c

r242472	r242473
207	207	//  D2 = YRES
208	208	//  D1-D0 = ADC0-1
209	209	//
210		m_segaic16vid->segaic16_set_display_enable(data & 0x80);
	210	m_segaic16vid->set_display_enable(data & 0x80);
211	211	if (((old ^ data) & 0x20) && !(data & 0x20))
212	212	machine().watchdog_reset();
213	213	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
r242472	r242473
741	741	AM_RANGE(0x180000, 0x1807ff) AM_MIRROR(0x007800) AM_RAM AM_SHARE("rotateram")
742	742	AM_RANGE(0x188000, 0x188fff) AM_MIRROR(0x007000) AM_RAM AM_SHARE("bsprites")
743	743	AM_RANGE(0x190000, 0x193fff) AM_MIRROR(0x004000) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
744		AM_RANGE(0x198000, 0x19ffff) AM_DEVREAD("segaic16vid", segaic16_video_device, segaic16_rotate_control_0_r)
	744	AM_RANGE(0x198000, 0x19ffff) AM_DEVREAD("segaic16vid", segaic16_video_device, rotate_control_r)
745	745	AM_RANGE(0x1f0000, 0x1fffff) AM_RAM
746	746	ADDRESS_MAP_END
747	747
r242472	r242473
2529	2529	// allocate a scanline timer
2530	2530	m_scanline_timer = timer_alloc(TID_IRQ2_GEN);
2531	2531
2532		// point globals to allocated memory regions
2533		m_segaic16vid->segaic16_rotateram_0 = reinterpret_cast<UINT16 *>(memshare("rotateram")->ptr());
2534
2535	2532	// save state
2536	2533	save_item(NAME(m_pdrift_bank));
2537	2534	save_item(NAME(m_analog_data));

trunk/src/mame/includes/segaorun.h

r242472	r242473
80	80	UINT32 screen_update_outrun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
81	81	UINT32 screen_update_shangon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
82	82
83		DECLARE_WRITE16_MEMBER( sega_tileram_0_w ) { m_segaic16vid->segaic16_tileram_0_w(space,offset,data,mem_mask); };
84		DECLARE_WRITE16_MEMBER( sega_textram_0_w ) { m_segaic16vid->segaic16_textram_0_w(space,offset,data,mem_mask); };
	83	DECLARE_WRITE16_MEMBER( tileram_w ) { m_segaic16vid->tileram_w(space,offset,data,mem_mask); };
	84	DECLARE_WRITE16_MEMBER( textram_w ) { m_segaic16vid->textram_w(space,offset,data,mem_mask); };
85	85	DECLARE_READ16_MEMBER( sega_road_control_0_r ) { return m_segaic16road->segaic16_road_control_0_r(space,offset,mem_mask); };
86	86	DECLARE_WRITE16_MEMBER( sega_road_control_0_w ) { m_segaic16road->segaic16_road_control_0_w(space,offset,data,mem_mask); };
87	87

trunk/src/mame/includes/segas16b.h

r242472	r242473
114	114	// video updates
115	115	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
116	116
117		DECLARE_WRITE16_MEMBER( sega_tileram_0_w ) { m_segaic16vid->segaic16_tileram_0_w(space,offset,data,mem_mask); };
118		DECLARE_WRITE16_MEMBER( sega_textram_0_w ) { m_segaic16vid->segaic16_textram_0_w(space,offset,data,mem_mask); };
	117	DECLARE_WRITE16_MEMBER( tileram_w ) { m_segaic16vid->tileram_w(space,offset,data,mem_mask); };
	118	DECLARE_WRITE16_MEMBER( textram_w ) { m_segaic16vid->textram_w(space,offset,data,mem_mask); };
119	119
120	120	protected:
121	121	// internal types

trunk/src/mame/includes/segas18.h

r242472	r242473
91	91
92	92	DECLARE_READ16_MEMBER( genesis_vdp_r ) { return m_vdp->vdp_r(space, offset, mem_mask); }
93	93	DECLARE_WRITE16_MEMBER( genesis_vdp_w ) { m_vdp->vdp_w(space, offset, data, mem_mask); }
94		DECLARE_WRITE16_MEMBER( sega_tileram_0_w ) { m_segaic16vid->segaic16_tileram_0_w(space, offset, data, mem_mask); }
95		DECLARE_WRITE16_MEMBER( sega_textram_0_w ) { m_segaic16vid->segaic16_textram_0_w(space, offset, data, mem_mask); }
	94	DECLARE_WRITE16_MEMBER( tileram_w ) { m_segaic16vid->tileram_w(space, offset, data, mem_mask); }
	95	DECLARE_WRITE16_MEMBER( textram_w ) { m_segaic16vid->textram_w(space, offset, data, mem_mask); }
96	96
97	97	DECLARE_WRITE_LINE_MEMBER(set_grayscale);
98	98	DECLARE_WRITE_LINE_MEMBER(set_vdp_enable);

trunk/src/mame/video/segahang.c

r242472	r242473
18	18	void segahang_state::video_start()
19	19	{
20	20	// initialize the tile/text layers
21		m_segaic16vid->segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_HANGON, 0x000, 0, 2);
	21	m_segaic16vid->tilemap_init( 0, SEGAIC16_TILEMAP_HANGON, 0x000, 0, 2);
22	22
23	23	// initialize the road
24	24	m_segaic16road->segaic16_road_init(machine(), 0, m_sharrier_video ? SEGAIC16_ROAD_SHARRIER : SEGAIC16_ROAD_HANGON, 0x038, 0x7c0, 0x7c0, 0);
r242472	r242473
32	32	UINT32 segahang_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
33	33	{
34	34	// if no drawing is happening, fill with black and get out
35		if (!m_segaic16vid->segaic16_display_enable)
	35	if (!m_segaic16vid->m_display_enable)
36	36	{
37	37	bitmap.fill(m_palette->black_pen(), cliprect);
38	38	return 0;
r242472	r242473
48	48	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_BACKGROUND);
49	49
50	50	// draw background
51		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
52		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	51	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	52	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
53	53
54	54	// draw foreground
55		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
56		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	55	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	56	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
57	57
58	58	// draw the high priority road
59	59	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND);
r242472	r242473
61	61	// text layer
62	62	// note that we inflate the priority of the text layer to prevent sprites
63	63	// from drawing over the high scores
64		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08);
65		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	64	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08);
	65	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
66	66
67	67	// mix in sprites
68	68	bitmap_ind16 &sprites = m_sprites->bitmap();

trunk/src/mame/video/segaic16.c

r242472	r242473
336	336	and clipping capabilities, and advanced hot-spot positioning.  The
337	337	mixer chip adds totally dynamic priorities, alpha-blending of the
338	338	tilemaps, per-component color control, and some other funnies we
339		have not been able to decypher.
	339	have not been able to decipher.
340	340
341	341	ST-V (also know as Titan or the Saturn console):
342	342	The ultimate 2D system.  Even more advanced tilemaps, with 6-dof
343	343	roz support, alpha up to the wazoo and other niceties, known as
344		the vdp2.  Ths sprite engine, vdp1, allows for any 4-point
345		streching of the sprites, actually giving polygonal 3D
	344	the vdp2.  The sprite engine, vdp1, allows for any 4-point
	345	stretching of the sprites, actually giving polygonal 3D
346	346	capabilities.  Interestingly, the mixer capabilities took a hit,
347	347	with no real per-sprite mixer priority, which could be considered
348	348	annoying for a 2D system.  It still allowed some beauties like
r242472	r242473
374	374	segaic16_video_device::segaic16_video_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
375	375	: device_t(mconfig, SEGAIC16VID, "Sega 16-bit Video", tag, owner, clock, "segaic16_video", __FILE__),
376	376	device_video_interface(mconfig, *this),
	377	m_display_enable(0),
	378	m_tileram(*this, ":tileram"),
	379	m_textram(*this, ":textram"),
	380	m_rotateram(*this, ":rotateram"),
377	381	m_gfxdecode(*this)
378	382	{
	383	memset(m_rotate, 0, sizeof(m_rotate));
	384	memset(m_bg_tilemap, 0, sizeof(m_bg_tilemap));
379	385	}
380	386
381	387	//-------------------------------------------------
r242472	r242473
389	395	}
390	396
391	397
392		void segaic16_video_device::device_config_complete()
393		{
394		}
395
396	398	void segaic16_video_device::device_start()
397	399	{
	400	save_item(NAME(m_display_enable));
398	401	}
399	402
400	403	void segaic16_video_device::device_reset()
r242472	r242473
402	405	}
403	406
404	407
405
406
407
408
409
410
411
412
413	408	/*************************************
414	409	*
415	410	*  Misc functions
416	411	*
417	412	*************************************/
418	413
419		void segaic16_video_device::segaic16_set_display_enable(int enable)
	414	void segaic16_video_device::set_display_enable(int enable)
420	415	{
421	416	enable = (enable != 0);
422		if (segaic16_display_enable != enable)
	417	if (m_display_enable != enable)
423	418	{
424	419	m_screen->update_partial(m_screen->vpos());
425		segaic16_display_enable = enable;
	420	m_display_enable = enable;
426	421	}
427	422	}
428	423
r242472	r242473
435	430	*
436	431	*************************************/
437	432
438		void segaic16_draw_virtual_tilemap(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT16 pages, UINT16 xscroll, UINT16 yscroll, UINT32 flags, UINT32 priority)
	433	void draw_virtual_tilemap(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT16 pages, UINT16 xscroll, UINT16 yscroll, UINT32 flags, UINT32 priority)
439	434	{
440	435	int leftmin = -1, leftmax = -1, rightmin = -1, rightmax = -1;
441	436	int topmin = -1, topmax = -1, bottommin = -1, bottommax = -1;
r242472	r242473
637	632	*
638	633	*******************************************************************************************/
639	634
640		TILE_GET_INFO_MEMBER( segaic16_video_device::segaic16_tilemap_16a_tile_info )
	635	TILE_GET_INFO_MEMBER( segaic16_video_device::tilemap_16a_tile_info )
641	636	{
642	637	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)tilemap.user_data();
643	638	UINT16 data = info->rambase[tile_index];
r242472	r242473
649	644	}
650	645
651	646
652		TILE_GET_INFO_MEMBER( segaic16_video_device::segaic16_tilemap_16a_text_info )
	647	TILE_GET_INFO_MEMBER( segaic16_video_device::tilemap_16a_text_info )
653	648	{
654	649	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)tilemap.user_data();
655	650	UINT16 data = info->rambase[tile_index];
r242472	r242473
661	656	}
662	657
663	658
664		void segaic16_tilemap_16a_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority)
	659	void tilemap_16a_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority)
665	660	{
666	661	UINT16 *textram = info->textram;
667	662
r242472	r242473
712	707	/* draw the chunk */
713	708	effxscroll = (0xc8 - effxscroll + info->xoffs) & 0x3ff;
714	709	effyscroll = effyscroll & 0x1ff;
715		segaic16_draw_virtual_tilemap(screen, info, bitmap, rowcolclip, pages, effxscroll, effyscroll, flags, priority);
	710	draw_virtual_tilemap(screen, info, bitmap, rowcolclip, pages, effxscroll, effyscroll, flags, priority);
716	711	}
717	712	}
718	713	}
r242472	r242473
741	736	/* draw the chunk */
742	737	effxscroll = (0xc8 - effxscroll + info->xoffs) & 0x3ff;
743	738	effyscroll = effyscroll & 0x1ff;
744		segaic16_draw_virtual_tilemap(screen, info, bitmap, colclip, pages, effxscroll, effyscroll, flags, priority);
	739	draw_virtual_tilemap(screen, info, bitmap, colclip, pages, effxscroll, effyscroll, flags, priority);
745	740	}
746	741	}
747	742	else if (info->rowscroll)
r242472	r242473
770	765	/* draw the chunk */
771	766	effxscroll = (0xc8 - effxscroll + info->xoffs) & 0x3ff;
772	767	effyscroll = effyscroll & 0x1ff;
773		segaic16_draw_virtual_tilemap(screen, info, bitmap, rowclip, pages, effxscroll, effyscroll, flags, priority);
	768	draw_virtual_tilemap(screen, info, bitmap, rowclip, pages, effxscroll, effyscroll, flags, priority);
774	769	}
775	770	}
776	771	else
r242472	r242473
780	775	xscroll += 17;
781	776	xscroll = (0xc8 - xscroll + info->xoffs) & 0x3ff;
782	777	yscroll = yscroll & 0x1ff;
783		segaic16_draw_virtual_tilemap(screen, info, bitmap, cliprect, pages, xscroll, yscroll, flags, priority);
	778	draw_virtual_tilemap(screen, info, bitmap, cliprect, pages, xscroll, yscroll, flags, priority);
784	779	}
785	780	}
786	781
r242472	r242473
849	844	*
850	845	*******************************************************************************************/
851	846
852		TILE_GET_INFO_MEMBER( segaic16_video_device::segaic16_tilemap_16b_tile_info )
	847	TILE_GET_INFO_MEMBER( segaic16_video_device::tilemap_16b_tile_info )
853	848	{
854	849	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)tilemap.user_data();
855	850	UINT16 data = info->rambase[tile_index];
r242472	r242473
863	858	}
864	859
865	860
866		TILE_GET_INFO_MEMBER( segaic16_video_device::segaic16_tilemap_16b_text_info )
	861	TILE_GET_INFO_MEMBER( segaic16_video_device::tilemap_16b_text_info )
867	862	{
868	863	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)tilemap.user_data();
869	864	UINT16 data = info->rambase[tile_index];
r242472	r242473
876	871	}
877	872
878	873
879		TILE_GET_INFO_MEMBER( segaic16_video_device::segaic16_tilemap_16b_alt_tile_info )
	874	TILE_GET_INFO_MEMBER( segaic16_video_device::tilemap_16b_alt_tile_info )
880	875	{
881	876	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)tilemap.user_data();
882	877	UINT16 data = info->rambase[tile_index];
r242472	r242473
890	885	}
891	886
892	887
893		TILE_GET_INFO_MEMBER( segaic16_video_device::segaic16_tilemap_16b_alt_text_info )
	888	TILE_GET_INFO_MEMBER( segaic16_video_device::tilemap_16b_alt_text_info )
894	889	{
895	890	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)tilemap.user_data();
896	891	UINT16 data = info->rambase[tile_index];
r242472	r242473
903	898	}
904	899
905	900
906		void segaic16_tilemap_16b_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority)
	901	void tilemap_16b_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority)
907	902	{
908	903	UINT16 *textram = info->textram;
909	904	UINT16 xscroll, yscroll, pages;
r242472	r242473
955	950	/* draw the chunk */
956	951	effxscroll = (0xc0 - effxscroll + info->xoffs) & 0x3ff;
957	952	effyscroll = effyscroll & 0x1ff;
958		segaic16_draw_virtual_tilemap(screen, info, bitmap, rowcolclip, effpages, effxscroll, effyscroll, flags, priority);
	953	draw_virtual_tilemap(screen, info, bitmap, rowcolclip, effpages, effxscroll, effyscroll, flags, priority);
959	954	}
960	955	}
961	956	}
r242472	r242473
991	986	/* draw the chunk */
992	987	effxscroll = (0xc0 - effxscroll + info->xoffs) & 0x3ff;
993	988	effyscroll = effyscroll & 0x1ff;
994		segaic16_draw_virtual_tilemap(screen, info, bitmap, rowclip, effpages, effxscroll, effyscroll, flags, priority);
	989	draw_virtual_tilemap(screen, info, bitmap, rowclip, effpages, effxscroll, effyscroll, flags, priority);
995	990	}
996	991	}
997	992	}
998	993
999	994
1000		TIMER_CALLBACK_MEMBER( segaic16_video_device::segaic16_tilemap_16b_latch_values )
	995	TIMER_CALLBACK_MEMBER( segaic16_video_device::tilemap_16b_latch_values )
1001	996	{
1002		struct tilemap_info *info = &bg_tilemap[param];
	997	struct tilemap_info *info = &m_bg_tilemap[param];
1003	998	UINT16 *textram = info->textram;
1004	999	int i;
1005	1000
r242472	r242473
1016	1011	}
1017	1012
1018	1013
1019		void segaic16_tilemap_16b_reset(screen_device &screen, struct tilemap_info *info)
	1014	void tilemap_16b_reset(screen_device &screen, struct tilemap_info *info)
1020	1015	{
1021	1016	/* set a timer to latch values on scanline 261 */
1022	1017	info->latch_timer->adjust(screen.time_until_pos(261), info->index);
r242472	r242473
1030	1025	*
1031	1026	*************************************/
1032	1027
1033		void segaic16_video_device::segaic16_tilemap_init(running_machine &machine, int which, int type, int colorbase, int xoffs, int numbanks)
	1028	void segaic16_video_device::tilemap_init(int which, int type, int colorbase, int xoffs, int numbanks)
1034	1029	{
1035		struct tilemap_info *info = &bg_tilemap[which];
	1030	struct tilemap_info *info = &m_bg_tilemap[which];
1036	1031	tilemap_get_info_delegate get_text_info;
1037	1032	tilemap_get_info_delegate get_tile_info;
1038	1033	int pagenum;
r242472	r242473
1051	1046	switch (which)
1052	1047	{
1053	1048	case 0:
1054		info->textram = segaic16_textram_0;
1055		info->tileram = segaic16_tileram_0;
	1049	info->textram = m_textram;
	1050	info->tileram = m_tileram;
1056	1051	break;
1057	1052
1058	1053	default:
1059		fatalerror("Invalid tilemap index specified in segaic16_tilemap_init\n");
	1054	fatalerror("Invalid tilemap index specified in tilemap_init\n");
1060	1055	}
1061	1056
1062	1057	/* determine the parameters of the tilemaps */
1063	1058	switch (type)
1064	1059	{
1065	1060	case SEGAIC16_TILEMAP_HANGON:
1066		get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16a_text_info),this);
1067		get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16a_tile_info),this);
	1061	get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16a_text_info),this);
	1062	get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16a_tile_info),this);
1068	1063	info->numpages = 4;
1069		info->draw_layer = segaic16_tilemap_16a_draw_layer;
	1064	info->draw_layer = tilemap_16a_draw_layer;
1070	1065	info->reset = NULL;
1071	1066	info->latch_timer = NULL;
1072	1067	break;
1073	1068
1074	1069	case SEGAIC16_TILEMAP_16A:
1075		get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16a_text_info),this);
1076		get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16a_tile_info),this);
	1070	get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16a_text_info),this);
	1071	get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16a_tile_info),this);
1077	1072	info->numpages = 8;
1078		info->draw_layer = segaic16_tilemap_16a_draw_layer;
	1073	info->draw_layer = tilemap_16a_draw_layer;
1079	1074	info->reset = NULL;
1080	1075	info->latch_timer = NULL;
1081	1076	break;
1082	1077
1083	1078	case SEGAIC16_TILEMAP_16B:
1084		get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16b_text_info),this);
1085		get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16b_tile_info),this);
	1079	get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16b_text_info),this);
	1080	get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16b_tile_info),this);
1086	1081	info->numpages = 16;
1087		info->draw_layer = segaic16_tilemap_16b_draw_layer;
1088		info->reset = segaic16_tilemap_16b_reset;
1089		info->latch_timer = machine.scheduler().timer_alloc( timer_expired_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16b_latch_values),this) );
	1082	info->draw_layer = tilemap_16b_draw_layer;
	1083	info->reset = tilemap_16b_reset;
	1084	info->latch_timer = machine().scheduler().timer_alloc( timer_expired_delegate(FUNC(segaic16_video_device::tilemap_16b_latch_values),this) );
1090	1085	break;
1091	1086
1092	1087	case SEGAIC16_TILEMAP_16B_ALT:
1093		get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16b_alt_text_info),this);
1094		get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16b_alt_tile_info),this);
	1088	get_text_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16b_alt_text_info),this);
	1089	get_tile_info = tilemap_get_info_delegate(FUNC(segaic16_video_device::tilemap_16b_alt_tile_info),this);
1095	1090	info->numpages = 16;
1096		info->draw_layer = segaic16_tilemap_16b_draw_layer;
1097		info->reset = segaic16_tilemap_16b_reset;
1098		info->latch_timer = machine.scheduler().timer_alloc( timer_expired_delegate(FUNC(segaic16_video_device::segaic16_tilemap_16b_latch_values),this) );
	1091	info->draw_layer = tilemap_16b_draw_layer;
	1092	info->reset = tilemap_16b_reset;
	1093	info->latch_timer = machine().scheduler().timer_alloc( timer_expired_delegate(FUNC(segaic16_video_device::tilemap_16b_latch_values),this) );
1099	1094	break;
1100	1095
1101	1096	default:
1102		fatalerror("Invalid tilemap type specified in segaic16_tilemap_init\n");
	1097	fatalerror("Invalid tilemap type specified in tilemap_init\n");
1103	1098	}
1104	1099
1105	1100	/* create the tilemap for the text layer */
1106		info->textmap = &machine.tilemap().create(m_gfxdecode, get_text_info, TILEMAP_SCAN_ROWS,  8,8, 64,28);
	1101	info->textmap = &machine().tilemap().create(m_gfxdecode, get_text_info, TILEMAP_SCAN_ROWS,  8,8, 64,28);
1107	1102
1108	1103	/* configure it */
1109	1104	info->textmap_info.rambase = info->textram;
r242472	r242473
1119	1114	for (pagenum = 0; pagenum < info->numpages; pagenum++)
1120	1115	{
1121	1116	/* each page is 64x32 */
1122		info->tilemaps[pagenum] = &machine.tilemap().create(m_gfxdecode, get_tile_info, TILEMAP_SCAN_ROWS,  8,8, 64,32);
	1117	info->tilemaps[pagenum] = &machine().tilemap().create(m_gfxdecode, get_tile_info, TILEMAP_SCAN_ROWS,  8,8, 64,32);
1123	1118
1124	1119	/* configure the tilemap */
1125	1120	info->tmap_info[pagenum].rambase = info->tileram + pagenum * 64*32;
r242472	r242473
1131	1126	info->tilemaps[pagenum]->set_scrolldx(0, 22);
1132	1127	info->tilemaps[pagenum]->set_scrolldy(0, 38);
1133	1128	}
	1129
	1130	save_item(NAME(info->flip), which);
	1131	save_item(NAME(info->rowscroll), which);
	1132	save_item(NAME(info->colscroll), which);
	1133	save_item(NAME(info->bank), which);
	1134	save_item(NAME(info->latched_xscroll), which);
	1135	save_item(NAME(info->latched_yscroll), which);
	1136	save_item(NAME(info->latched_pageselect), which);
1134	1137	}
1135	1138
1136	1139
r242472	r242473
1141	1144	*
1142	1145	*************************************/
1143	1146
1144		void segaic16_video_device::segaic16_tilemap_draw(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int map, int priority, int priority_mark)
	1147	void segaic16_video_device::tilemap_draw(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int map, int priority, int priority_mark)
1145	1148	{
1146		struct tilemap_info *info = &bg_tilemap[which];
	1149	struct tilemap_info *info = &m_bg_tilemap[which];
1147	1150
1148	1151	/* text layer is a special common case */
1149	1152	if (map == SEGAIC16_TILEMAP_TEXT)
r242472	r242473
1162	1165	*
1163	1166	*************************************/
1164	1167
1165		void segaic16_video_device::segaic16_tilemap_reset(screen_device &screen)
	1168	void segaic16_video_device::tilemap_reset(screen_device &screen)
1166	1169	{
1167		struct tilemap_info *info = &bg_tilemap[0];
	1170	struct tilemap_info *info = &m_bg_tilemap[0];
1168	1171
1169	1172	if (info->reset)
1170	1173	(*info->reset)(screen, info);
r242472	r242473
1178	1181	*
1179	1182	*************************************/
1180	1183
1181		void segaic16_video_device::segaic16_tilemap_set_bank(int which, int banknum, int offset)
	1184	void segaic16_video_device::tilemap_set_bank(int which, int banknum, int offset)
1182	1185	{
1183		struct tilemap_info *info = &bg_tilemap[which];
	1186	struct tilemap_info *info = &m_bg_tilemap[which];
1184	1187
1185	1188	if (info->bank[banknum] != offset)
1186	1189	{
r242472	r242473
1198	1201	*
1199	1202	*************************************/
1200	1203
1201		void segaic16_video_device::segaic16_tilemap_set_flip(int which, int flip)
	1204	void segaic16_video_device::tilemap_set_flip(int which, int flip)
1202	1205	{
1203		struct tilemap_info *info = &bg_tilemap[which];
	1206	struct tilemap_info *info = &m_bg_tilemap[which];
1204	1207	int pagenum;
1205	1208
1206	1209	flip = (flip != 0);
r242472	r242473
1222	1225	*
1223	1226	*************************************/
1224	1227
1225		void segaic16_video_device::segaic16_tilemap_set_rowscroll(int which, int enable)
	1228	void segaic16_video_device::tilemap_set_rowscroll(int which, int enable)
1226	1229	{
1227		struct tilemap_info *info = &bg_tilemap[which];
	1230	struct tilemap_info *info = &m_bg_tilemap[which];
1228	1231
1229	1232	enable = (enable != 0);
1230	1233	if (info->rowscroll != enable)
r242472	r242473
1242	1245	*
1243	1246	*************************************/
1244	1247
1245		void segaic16_video_device::segaic16_tilemap_set_colscroll(int which, int enable)
	1248	void segaic16_video_device::tilemap_set_colscroll(int which, int enable)
1246	1249	{
1247		struct tilemap_info *info = &bg_tilemap[which];
	1250	struct tilemap_info *info = &m_bg_tilemap[which];
1248	1251
1249	1252	enable = (enable != 0);
1250	1253	if (info->colscroll != enable)
r242472	r242473
1262	1265	*
1263	1266	*************************************/
1264	1267
1265		READ16_MEMBER( segaic16_video_device::segaic16_tileram_0_r )
	1268	READ16_MEMBER( segaic16_video_device::tileram_r )
1266	1269	{
1267		return segaic16_tileram_0[offset];
	1270	return m_tileram[offset];
1268	1271	}
1269	1272
1270	1273
1271		WRITE16_MEMBER( segaic16_video_device::segaic16_tileram_0_w )
	1274	WRITE16_MEMBER( segaic16_video_device::tileram_w )
1272	1275	{
1273		COMBINE_DATA(&segaic16_tileram_0[offset]);
1274		bg_tilemap[0].tilemaps[offset / (64*32)]->mark_tile_dirty(offset % (64*32));
	1276	COMBINE_DATA(&m_tileram[offset]);
	1277	m_bg_tilemap[0].tilemaps[offset / (64*32)]->mark_tile_dirty(offset % (64*32));
1275	1278	}
1276	1279
1277	1280
1278		READ16_MEMBER( segaic16_video_device::segaic16_textram_0_r )
	1281	READ16_MEMBER( segaic16_video_device::textram_r )
1279	1282	{
1280		return segaic16_textram_0[offset];
	1283	return m_textram[offset];
1281	1284	}
1282	1285
1283	1286
1284		WRITE16_MEMBER( segaic16_video_device::segaic16_textram_0_w )
	1287	WRITE16_MEMBER( segaic16_video_device::textram_w )
1285	1288	{
1286	1289	/* certain ranges need immediate updates */
1287	1290	if (offset >= 0xe80/2)
1288	1291	m_screen->update_partial(m_screen->vpos());
1289	1292
1290		COMBINE_DATA(&segaic16_textram_0[offset]);
1291		bg_tilemap[0].textmap->mark_tile_dirty(offset);
	1293	COMBINE_DATA(&m_textram[offset]);
	1294	m_bg_tilemap[0].textmap->mark_tile_dirty(offset);
1292	1295	}
1293	1296
1294	1297
r242472	r242473
1303	1306	*
1304	1307	*************************************/
1305	1308
1306		void segaic16_video_device::segaic16_rotate_init(running_machine &machine, int which, int type, int colorbase)
	1309	void segaic16_video_device::rotate_init(int which, int type, int colorbase)
1307	1310	{
1308		struct rotate_info *info = &segaic16_rotate[which];
	1311	struct rotate_info *info = &m_rotate[which];
1309	1312
1310	1313	/* reset the tilemap info */
1311	1314	memset(info, 0, sizeof(*info));
r242472	r242473
1317	1320	switch (which)
1318	1321	{
1319	1322	case 0:
1320		info->rotateram = segaic16_rotateram_0;
	1323	info->rotateram = m_rotateram;
1321	1324	break;
1322	1325
1323	1326	default:
1324		fatalerror("Invalid rotate index specified in segaic16_rotate_init\n");
	1327	fatalerror("Invalid rotate index specified in rotate_init\n");
1325	1328	}
1326	1329
1327	1330	/* determine the parameters of the rotate */
r242472	r242473
1332	1335	break;
1333	1336
1334	1337	default:
1335		fatalerror("Invalid rotate system specified in segaic16_rotate_init\n");
	1338	fatalerror("Invalid rotate system specified in rotate_init\n");
1336	1339	}
1337	1340
1338	1341	/* allocate a buffer for swapping */
1339		info->buffer = auto_alloc_array(machine, UINT16, info->ramsize/2);
	1342	info->buffer = auto_alloc_array(machine(), UINT16, info->ramsize/2);
1340	1343
1341		state_save_register_item(machine, "segaic16_rot", NULL, which, info->colorbase);
1342		state_save_register_item_pointer(machine, "segaic16_rot", NULL, which, ((UINT8 *) info->buffer), info->ramsize);
	1344	save_item(NAME(info->colorbase), which);
	1345	save_pointer(NAME((UINT8 *) info->buffer), info->ramsize, which);
1343	1346	}
1344	1347
1345	1348
r242472	r242473
1350	1353	*
1351	1354	*************************************/
1352	1355
1353		void segaic16_video_device::segaic16_rotate_draw(int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind8 &priority_bitmap, bitmap_ind16 &srcbitmap)
	1356	void segaic16_video_device::rotate_draw(int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind8 &priority_bitmap, bitmap_ind16 &srcbitmap)
1354	1357	{
1355		struct rotate_info *info = &segaic16_rotate[which];
	1358	struct rotate_info *info = &m_rotate[which];
1356	1359	INT32 currx = (info->buffer[0x3f0] << 16) | info->buffer[0x3f1];
1357	1360	INT32 curry = (info->buffer[0x3f2] << 16) | info->buffer[0x3f3];
1358	1361	INT32 dyy = (info->buffer[0x3f4] << 16) | info->buffer[0x3f5];
r242472	r242473
1413	1416	*
1414	1417	*************************************/
1415	1418
1416		READ16_MEMBER( segaic16_video_device::segaic16_rotate_control_0_r )
	1419	READ16_MEMBER( segaic16_video_device::rotate_control_r )
1417	1420	{
1418		struct rotate_info *info = &segaic16_rotate[0];
	1421	struct rotate_info *info = &m_rotate[0];
1419	1422
1420	1423	if (info->buffer)
1421	1424	{

trunk/src/mame/video/segaic16.h

r242472	r242473
99	99	// static configuration
100	100	static void static_set_gfxdecode_tag(device_t &device, const char *tag);
101	101
102		UINT8 segaic16_display_enable;
103		UINT16 *segaic16_tileram_0;
104		UINT16 *segaic16_textram_0;
105		UINT16 *segaic16_rotateram_0;
	102	UINT8 m_display_enable;
	103	optional_shared_ptr<UINT16> m_tileram;
	104	optional_shared_ptr<UINT16> m_textram;
	105	optional_shared_ptr<UINT16> m_rotateram;
106	106
107		void segaic16_tilemap_set_colscroll(int which, int enable);
108		void segaic16_tilemap_set_rowscroll(int which, int enable);
109		void segaic16_tilemap_set_flip(int which, int flip);
110		void segaic16_tilemap_set_bank(int which, int banknum, int offset);
111		void segaic16_tilemap_reset(screen_device &screen);
112		void segaic16_tilemap_draw(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int map, int priority, int priority_mark);
113		//  void segaic16_tilemap_16b_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority);
114		//  void segaic16_tilemap_16a_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority);
115		//  void segaic16_draw_virtual_tilemap(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT16 pages, UINT16 xscroll, UINT16 yscroll, UINT32 flags, UINT32 priority);
116		//  void segaic16_tilemap_16b_reset(screen_device &screen, struct tilemap_info *info);
	107	void tilemap_set_colscroll(int which, int enable);
	108	void tilemap_set_rowscroll(int which, int enable);
	109	void tilemap_set_flip(int which, int flip);
	110	void tilemap_set_bank(int which, int banknum, int offset);
	111	void tilemap_reset(screen_device &screen);
	112	void tilemap_draw(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int map, int priority, int priority_mark);
	113	//  void tilemap_16b_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority);
	114	//  void tilemap_16a_draw_layer(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, int which, int flags, int priority);
	115	//  void draw_virtual_tilemap(screen_device &screen, struct tilemap_info *info, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT16 pages, UINT16 xscroll, UINT16 yscroll, UINT32 flags, UINT32 priority);
	116	//  void tilemap_16b_reset(screen_device &screen, struct tilemap_info *info);
117	117
118		TIMER_CALLBACK_MEMBER( segaic16_tilemap_16b_latch_values );
	118	TIMER_CALLBACK_MEMBER( tilemap_16b_latch_values );
119	119
120		struct rotate_info segaic16_rotate[SEGAIC16_MAX_ROTATE];
121		struct tilemap_info bg_tilemap[SEGAIC16_MAX_TILEMAPS];
	120	struct rotate_info m_rotate[SEGAIC16_MAX_ROTATE];
	121	struct tilemap_info m_bg_tilemap[SEGAIC16_MAX_TILEMAPS];
122	122
123		void segaic16_set_display_enable(int enable);
124		void segaic16_tilemap_init(running_machine &machine, int which, int type, int colorbase, int xoffs, int numbanks);
125		void segaic16_rotate_init(running_machine &machine, int which, int type, int colorbase);
	123	void set_display_enable(int enable);
	124	void tilemap_init(int which, int type, int colorbase, int xoffs, int numbanks);
	125	void rotate_init(int which, int type, int colorbase);
126	126
127		DECLARE_READ16_MEMBER( segaic16_tileram_0_r );
128		DECLARE_READ16_MEMBER( segaic16_textram_0_r );
129		DECLARE_WRITE16_MEMBER( segaic16_tileram_0_w );
130		DECLARE_WRITE16_MEMBER( segaic16_textram_0_w );
	127	DECLARE_READ16_MEMBER( tileram_r );
	128	DECLARE_READ16_MEMBER( textram_r );
	129	DECLARE_WRITE16_MEMBER( tileram_w );
	130	DECLARE_WRITE16_MEMBER( textram_w );
131	131
132		void segaic16_rotate_draw(int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind8 &priority_bitmap, bitmap_ind16 &srcbitmap);
	132	void rotate_draw(int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind8 &priority_bitmap, bitmap_ind16 &srcbitmap);
133	133
134		DECLARE_READ16_MEMBER( segaic16_rotate_control_0_r );
	134	DECLARE_READ16_MEMBER( rotate_control_r );
135	135
136		TILE_GET_INFO_MEMBER( segaic16_tilemap_16b_tile_info );
137		TILE_GET_INFO_MEMBER( segaic16_tilemap_16b_text_info );
138		TILE_GET_INFO_MEMBER( segaic16_tilemap_16b_alt_tile_info );
139		TILE_GET_INFO_MEMBER( segaic16_tilemap_16b_alt_text_info );
	136	TILE_GET_INFO_MEMBER( tilemap_16b_tile_info );
	137	TILE_GET_INFO_MEMBER( tilemap_16b_text_info );
	138	TILE_GET_INFO_MEMBER( tilemap_16b_alt_tile_info );
	139	TILE_GET_INFO_MEMBER( tilemap_16b_alt_text_info );
140	140
141		TILE_GET_INFO_MEMBER( segaic16_tilemap_16a_tile_info );
142		TILE_GET_INFO_MEMBER( segaic16_tilemap_16a_text_info );
	141	TILE_GET_INFO_MEMBER( tilemap_16a_tile_info );
	142	TILE_GET_INFO_MEMBER( tilemap_16a_text_info );
143	143
144	144	protected:
145	145	// device-level overrides
146		virtual void device_config_complete();
147	146	virtual void device_start();
148	147	virtual void device_reset();
149	148

trunk/src/mame/video/segaorun.c

r242472	r242473
20	20	if (m_shangon_video)
21	21	{
22	22	// initialize the tile/text layers
23		m_segaic16vid->segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16B_ALT, 0x000, 0, 2);
	23	m_segaic16vid->tilemap_init(0, SEGAIC16_TILEMAP_16B_ALT, 0x000, 0, 2);
24	24
25	25	// initialize the road
26	26	m_segaic16road->segaic16_road_init(machine(), 0, SEGAIC16_ROAD_OUTRUN, 0x7f6, 0x7c0, 0x7c0, 0);
r242472	r242473
28	28	else
29	29	{
30	30	// initialize the tile/text layers
31		m_segaic16vid->segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16B, 0x000, 0, 2);
	31	m_segaic16vid->tilemap_init(0, SEGAIC16_TILEMAP_16B, 0x000, 0, 2);
32	32
33	33	// initialize the road
34	34	m_segaic16road->segaic16_road_init(machine(), 0, SEGAIC16_ROAD_OUTRUN, 0x400, 0x420, 0x780, 0);
r242472	r242473
53	53	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_BACKGROUND);
54	54
55	55	// draw background
56		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
57		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	56	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	57	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
58	58
59	59	// draw foreground
60		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
61		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	60	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	61	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
62	62
63	63	// draw the high priority road
64	64	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND);
r242472	r242473
66	66	// text layer
67	67	// note that we inflate the priority of the text layer to prevent sprites
68	68	// from drawing over the high scores
69		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08);
70		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	69	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08);
	70	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
71	71
72	72	// mix in sprites
73	73	bitmap_ind16 &sprites = m_sprites->bitmap();
r242472	r242473
106	106	UINT32 segaorun_state::screen_update_outrun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
107	107	{
108	108	// if no drawing is happening, fill with black and get out
109		if (!m_segaic16vid->segaic16_display_enable)
	109	if (!m_segaic16vid->m_display_enable)
110	110	{
111	111	bitmap.fill(m_palette->black_pen(), cliprect);
112	112	return 0;
r242472	r242473
122	122	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_BACKGROUND);
123	123
124	124	// draw background
125		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
126		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	125	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	126	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
127	127
128	128	// draw foreground
129		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
130		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	129	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	130	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
131	131
132	132	// draw the high priority road
133	133	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND);
134	134
135	135	// text layer
136		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
137		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	136	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
	137	m_segaic16vid->tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
138	138
139	139	// mix in sprites
140	140	bitmap_ind16 &sprites = m_sprites->bitmap();

trunk/src/mame/video/segas16a.c

r242472	r242473
18	18	void segas16a_state::video_start()
19	19	{
20	20	// initialize the tile/text layers
21		m_segaic16vid->segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16A, 0x000, 0, 1);
	21	m_segaic16vid->tilemap_init( 0, SEGAIC16_TILEMAP_16A, 0x000, 0, 1);
22	22	}
23	23
24	24
r242472	r242473
29	29	UINT32 segas16a_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
30	30	{
31	31	// if no drawing is happening, fill with black and get out
32		if (!m_segaic16vid->segaic16_display_enable)
	32	if (!m_segaic16vid->m_display_enable)
33	33	{
34	34	bitmap.fill(m_palette->black_pen(), cliprect);
35	35	return 0;
r242472	r242473
42	42	screen.priority().fill(0, cliprect);
43	43
44	44	// draw background opaquely first, not setting any priorities
45		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00);
46		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00);
	45	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00);
	46	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00);
47	47
48	48	// draw background again, just to set the priorities on non-transparent pixels
49	49	bitmap_ind16 dummy_bitmap;
50		m_segaic16vid->segaic16_tilemap_draw(screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
51		m_segaic16vid->segaic16_tilemap_draw(screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	50	m_segaic16vid->tilemap_draw( screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	51	m_segaic16vid->tilemap_draw( screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
52	52
53	53	// draw foreground
54		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
55		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	54	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	55	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
56	56
57	57	// text layer
58		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
59		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	58	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
	59	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
60	60
61	61	// mix in sprites
62	62	bitmap_ind16 &sprites = m_sprites->bitmap();

trunk/src/mame/video/segas16b.c

r242472	r242473
18	18	void segas16b_state::video_start()
19	19	{
20	20	// initialize the tile/text layers
21		m_segaic16vid->segaic16_tilemap_init(machine(), 0, m_tilemap_type, 0x000, 0, 2);
	21	m_segaic16vid->tilemap_init( 0, m_tilemap_type, 0x000, 0, 2);
22	22	}
23	23
24	24
r242472	r242473
29	29	UINT32 segas16b_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
30	30	{
31	31	// if no drawing is happening, fill with black and get out
32		if (!m_segaic16vid->segaic16_display_enable)
	32	if (!m_segaic16vid->m_display_enable)
33	33	{
34	34	bitmap.fill(m_palette->black_pen(), cliprect);
35	35	return 0;
r242472	r242473
42	42	screen.priority().fill(0, cliprect);
43	43
44	44	// draw background opaquely first, not setting any priorities
45		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00);
46		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00);
	45	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00);
	46	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00);
47	47
48	48	// draw background again, just to set the priorities on non-transparent pixels
49	49	bitmap_ind16 dummy_bitmap;
50		m_segaic16vid->segaic16_tilemap_draw(screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
51		m_segaic16vid->segaic16_tilemap_draw(screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	50	m_segaic16vid->tilemap_draw( screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	51	m_segaic16vid->tilemap_draw( screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
52	52
53	53	// draw foreground
54		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
55		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	54	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	55	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
56	56
57	57	// text layer
58		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
59		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	58	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
	59	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
60	60
61	61	// mix in sprites
62	62	bitmap_ind16 &sprites = m_sprites->bitmap();

trunk/src/mame/video/segas18.c

r242472	r242473
34	34	m_vdp_mixing = 0;
35	35
36	36	// initialize the tile/text layers
37		m_segaic16vid->segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16B, 0x000, 0, 8);
	37	m_segaic16vid->tilemap_init( 0, SEGAIC16_TILEMAP_16B, 0x000, 0, 8);
38	38
39	39	save_item(NAME(m_grayscale_enable));
40	40	save_item(NAME(m_vdp_enable));
r242472	r242473
187	187	#endif
188	188
189	189	// if no drawing is happening, fill with black and get out
190		if (!m_segaic16vid->segaic16_display_enable)
	190	if (!m_segaic16vid->m_display_enable)
191	191	{
192	192	bitmap.fill(m_palette->black_pen(), cliprect);
193	193	return 0;
r242472	r242473
200	200	screen.priority().fill(0, cliprect);
201	201
202	202	// draw background opaquely first, not setting any priorities
203		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00);
204		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00);
	203	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00);
	204	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00);
205	205	if (m_vdp_enable && vdplayer == 0) draw_vdp(screen, bitmap, cliprect, vdppri);
206	206
207	207	// draw background again to draw non-transparent pixels over the VDP and set the priority
208		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
209		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	208	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	209	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
210	210	if (m_vdp_enable && vdplayer == 1) draw_vdp(screen, bitmap, cliprect, vdppri);
211	211
212	212	// draw foreground
213		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
214		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	213	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	214	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
215	215	if (m_vdp_enable && vdplayer == 2) draw_vdp(screen, bitmap, cliprect, vdppri);
216	216
217	217	// text layer
218		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
219		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	218	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
	219	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
220	220	if (m_vdp_enable && vdplayer == 3) draw_vdp(screen, bitmap, cliprect, vdppri);
221	221
222	222	// mix in sprites

trunk/src/mame/video/segaxbd.c

r242472	r242473
17	17	void segaxbd_state::video_start()
18	18	{
19	19	// initialize the tile/text layers
20		m_segaic16vid->segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16B, 0x1c00, 0, 2);
	20	m_segaic16vid->tilemap_init( 0, SEGAIC16_TILEMAP_16B, 0x1c00, 0, 2);
21	21
22	22	// initialize the road
23	23	m_segaic16road->segaic16_road_init(machine(), 0, SEGAIC16_ROAD_XBOARD, 0x1700, 0x1720, 0x1780, -166);
r242472	r242473
32	32	UINT32 segaxbd_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
33	33	{
34	34	// if no drawing is happening, fill with black and get out
35		if (!m_segaic16vid->segaic16_display_enable)
	35	if (!m_segaic16vid->m_display_enable)
36	36	{
37	37	bitmap.fill(m_palette->black_pen(), cliprect);
38	38	return 0;
r242472	r242473
50	50	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND);
51	51
52	52	// draw background
53		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
54		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
	53	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01);
	54	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02);
55	55
56	56	// draw foreground
57		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
58		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
	57	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02);
	58	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04);
59	59
60	60	// draw the high priority road
61	61	if (m_road_priority == 1)
62	62	m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND);
63	63
64	64	// text layer
65		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
66		m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
	65	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
	66	m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
67	67
68	68	// mix in sprites
69	69	bitmap_ind16 &sprites = m_sprites->bitmap();

trunk/src/mame/video/segaybd.c

r242472	r242473
17	17	void segaybd_state::video_start()
18	18	{
19	19	// initialize the rotation layer
20		m_segaic16vid->segaic16_rotate_init(machine(), 0, SEGAIC16_ROTATE_YBOARD, 0x000);
21		m_ysprites->set_rotate_ptr(m_segaic16vid->segaic16_rotate);
	20	m_segaic16vid->rotate_init(0, SEGAIC16_ROTATE_YBOARD, 0x000);
	21	m_ysprites->set_rotate_ptr(m_segaic16vid->m_rotate);
22	22	}
23	23
24	24
r242472	r242473
30	30	UINT32 segaybd_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
31	31	{
32	32	// if no drawing is happening, fill with black and get out
33		if (!m_segaic16vid->segaic16_display_enable)
	33	if (!m_segaic16vid->m_display_enable)
34	34	{
35	35	bitmap.fill(m_palette->black_pen(), cliprect);
36	36	return 0;
r242472	r242473
43	43	m_bsprites->draw_async(cliprect);
44	44
45	45	// apply rotation
46		m_segaic16vid->segaic16_rotate_draw(0, bitmap, cliprect, screen.priority(), m_ysprites->bitmap());
	46	m_segaic16vid->rotate_draw(0, bitmap, cliprect, screen.priority(), m_ysprites->bitmap());
47	47
48	48	// mix in 16B sprites
49	49	bitmap_ind16 &sprites = m_bsprites->bitmap();

https://github.com/mamedev/mame/commit/23c3deba37675f0892a1a3aa3df45f31eaa80036

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team