MAME SVN History

199869 Revisions

r36169 Sunday 1st March, 2015 at 17:32:26 UTC by Couriersud
Merge branch 'master' of https://github.com/mamedev/mame.git

[hash]	pasogo.xml
[src/mame/drivers]	hng64.c mitchell.c suna8.c suprgolf.c suprslam.c tankbust.c thunderx.c tryout.c usgames.c vigilant.c
[src/mame/includes]	hng64.h tankbust.h thunderx.h tryout.h usgames.h vigilant.h
[src/mame/video]	hng64.c
[src/mess/audio]	gamate.c
[src/mess/drivers]	gamate.c hh_ucom4.c
[src/mess/includes]	gamate.h

trunk/hash/pasogo.xml
r244680	r244681
3	3	<softwarelist name="pasogo" description="Koei PasoGo cartridges">
4	4
5	5	<!--
6		Koei PasoGo (パソ碁) undumped games
	6	Koei PasoGo (パソ碁) possible undumped games
7	7
8		Taikyoku-kun I ~ 対局くん I [KS-1001]
9		Tanoshii Tsumego Dai-1-kan ~ 楽しい詰碁・第1巻 [KS-1002]
10		Tanoshii Tsumego Dai-2-kan ~ 楽しい詰碁・第2巻 [KS-1003]
11
	8	Unknown title [cart KS-1005]
	9	Unknown title [cart KS-1006]
	10	Unknown title [cart KS-1007]
	11	Unknown title [cart KS-1008]
	12
12	13	-->
13	14
14		<!-- Contians 8M SOP44 ROM, 62256 SOP32 RAM, Microchip 1081N (reset IC?watchdog?battery-power-switcher?) and 3V battery. -->
15		<software name="dgoban">
16		<description>Denshi Goban</description>
	15	<!-- KS-1001: Contains 8M SOP44 ROM, 62256 SOP32 RAM, Microchip 1081N (reset IC?watchdog?battery-power-switcher?) and 3V battery. -->
	16	<software name="taikyoku">
	17	<description>Taikyoku-kun I</description>
17	18	<year>1996</year>
18	19	<publisher>Koei</publisher>
19		<info name="serial" value="KS-1009"/>
20		<info name="alt_title" value="電子碁盤"/>
	20	<info name="serial" value="KS-1001"/>
	21	<info name="alt_title" value="対局くん I"/>
21	22	<part name="cart" interface="pasogo_cart">
22	23	<dataarea name="rom" width="16" endianness="little" size="1048576">
23		<rom name="ks-1010.ic4" size="1048576" crc="b6a3f97c" sha1="2de63b05ec93a4ba3ea55ba131c0706927a5bf39" offset="00000000" />
	24	<rom name="ks-1001.ic4" size="1048576" crc="b6a3f97c" sha1="2de63b05ec93a4ba3ea55ba131c0706927a5bf39" offset="00000000" />
24	25	</dataarea>
25	26	</part>
26	27	</software>
27	28
	29	<!-- KS-1002: Contains 4M SOP40 ROM only. -->
	30	<software name="tanostd1">
	31	<description>Tanoshii Tsumego Dai-1-kan</description>
	32	<year>1996</year>
	33	<publisher>Koei</publisher>
	34	<info name="serial" value="KS-1002"/>
	35	<info name="alt_title" value="楽しい詰碁・第1巻"/>
	36	<part name="cart" interface="pasogo_cart">
	37	<dataarea name="rom" width="16" endianness="little" size="524288">
	38	<rom name="ks-1002.ic4" size="524288" crc="32f9c38a" sha1="1be82afcdf5e2d1a0e873fda4161e663d7a53a85" offset="00000000" />
	39	</dataarea>
	40	</part>
	41	</software>
28	42
29		<!-- Contains 4M SOP40 ROM only. -->
	43	<!-- KS-1003: Contains 4M SOP40 ROM only. -->
	44	<software name="tanostd2">
	45	<description>Tanoshii Tsumego Dai-2-kan</description>
	46	<year>1996</year>
	47	<publisher>Koei</publisher>
	48	<info name="serial" value="KS-1003"/>
	49	<info name="alt_title" value="楽しい詰碁・第2巻"/>
	50	<part name="cart" interface="pasogo_cart">
	51	<dataarea name="rom" width="16" endianness="little" size="524288">
	52	<rom name="ks-1003.ic4" size="524288" crc="32f9c38a" sha1="1be82afcdf5e2d1a0e873fda4161e663d7a53a85" offset="00000000" />
	53	</dataarea>
	54	</part>
	55	</software>
	56
	57	<!-- KS-1004: Contains 4M SOP40 ROM only. -->
30	58	<software name="igmks1">
31	59	<description>Igo Meikyokushuu - Dai-1-kan</description>
32	60	<year>1996</year>
r244680	r244681
35	63	<info name="alt_title" value="囲碁名局集第1巻"/>
36	64	<part name="cart" interface="pasogo_cart">
37	65	<dataarea name="rom" width="16" endianness="little" size="524288">
38		<rom name="~~yrm0442m~~-184s" size="524288" crc="32f9c38a" sha1="1be82afcdf5e2d1a0e873fda4161e663d7a53a85" offset="00000000" />
	66	<rom name="ks-1004.ic4" size="524288" crc="32f9c38a" sha1="1be82afcdf5e2d1a0e873fda4161e663d7a53a85" offset="00000000" />
39	67	</dataarea>
40	68	</part>
41	69	</software>
42	70
43		<!-- Contains 4M SOP40 ROM only. -->
	71	<!-- KS-1009: Contains 8M SOP44 ROM, 62256 SOP32 RAM, Microchip 1081N (reset IC?watchdog?battery-power-switcher?) and 3V battery. -->
	72	<software name="dgoban">
	73	<description>Denshi Goban</description>
	74	<year>1996</year>
	75	<publisher>Koei</publisher>
	76	<info name="serial" value="KS-1009"/>
	77	<info name="alt_title" value="電子碁盤"/>
	78	<part name="cart" interface="pasogo_cart">
	79	<dataarea name="rom" width="16" endianness="little" size="1048576">
	80	<rom name="ks-1009.ic4" size="1048576" crc="b6a3f97c" sha1="2de63b05ec93a4ba3ea55ba131c0706927a5bf39" offset="00000000" />
	81	</dataarea>
	82	</part>
	83	</software>
	84
	85	<!-- KS-1010: Contains 4M SOP40 ROM only. -->
44	86	<software name="tnt1">
45	87	<description>Tsuyoku Naru Tesuji - Dai-1-kan</description>
46	88	<year>1996</year>
r244680	r244681
49	91	<info name="alt_title" value="強くなる手筋・第1巻"/>
50	92	<part name="cart" interface="pasogo_cart">
51	93	<dataarea name="rom" width="16" endianness="little" size="524288">
52		<rom name="ks-1009.ic4" size="524288" crc="3e70fca6" sha1="c46cdc9e01f2f5c66b2523e1d30355e51c839f27" offset="00000000" />
	94	<rom name="ks-1010.ic4" size="524288" crc="3e70fca6" sha1="c46cdc9e01f2f5c66b2523e1d30355e51c839f27" offset="00000000" />
53	95	</dataarea>
54	96	</part>
55	97	</software>

trunk/src/mame/drivers/hng64.c
r244680	r244681
867	867	}
868	868
869	869	// Send it off to the 3d subsystem.
870		hng64_command3d(~~machine(),~~ packet3d);
	870	hng64_command3d( packet3d);
871	871	}
872	872	#endif
873	873	}
r244680	r244681
892	892	{
893	893	// this handles 3d to fb upload
894	894	UINT16 packet3d[16];
	895	// printf("dl_upload_w %08x %08x\n", data, mem_mask);
895	896
	897
896	898	for(int packetStart=0;packetStart<0x200/4;packetStart+=8)
897	899	{
898	900	// Create a 3d packet
r244680	r244681
906	908	}
907	909
908	910	// Send it off to the 3d subsystem.
909		hng64_command3d(~~machine(),~~ packet3d);
	911	hng64_command3d( packet3d);
910	912	}
911	913
912	914	machine().scheduler().timer_set(m_maincpu->cycles_to_attotime(0x200*8), timer_expired_delegate(FUNC(hng64_state::hng64_3dfifo_processed),this));
r244680	r244681
915	917	/* Note: Samurai Shodown games never calls bit 1, so it can't be framebuffer clear. It also calls bit 3 at start-up, meaning unknown */
916	918	WRITE32_MEMBER(hng64_state::dl_control_w) // This handles framebuffers
917	919	{
	920	// printf("dl_control_w %08x %08x\n", data, mem_mask);
	921
918	922	//if(data & 2) // swap buffers
919	923	//{
920	924	// clear3d();
r244680	r244681
1173	1177	<ElSemi> 0xBF800000-0xBF808000 S-RAM
1174	1178	<ElSemi> 0x60000000-0x60001000 Comm dualport ram
1175	1179	*/
	1180
	1181	WRITE32_MEMBER(hng64_state::hng64_vregs_w)
	1182	{
	1183	// printf("hng64_vregs_w %02x, %08x %08x\n", offset * 4, data, mem_mask);
	1184	COMBINE_DATA(&m_videoregs[offset]);
	1185	}
	1186
1176	1187	static ADDRESS_MAP_START( hng_map, AS_PROGRAM, 32, hng64_state )
1177	1188
1178	1189	AM_RANGE(0x00000000, 0x00ffffff) AM_RAM AM_SHARE("mainram")
r244680	r244681
1196	1207	AM_RANGE(0x2000e400, 0x2000efff) AM_WRITE(hng64_sprite_clear_odd_w)
1197	1208	AM_RANGE(0x20010000, 0x20010013) AM_RAM AM_SHARE("spriteregs")
1198	1209	AM_RANGE(0x20100000, 0x2017ffff) AM_RAM_WRITE(hng64_videoram_w) AM_SHARE("videoram") // Tilemap
1199		AM_RANGE(0x20190000, 0x20190037) AM_RAM AM_SHARE("videoregs")
	1210	AM_RANGE(0x20190000, 0x20190037) AM_RAM_WRITE(hng64_vregs_w) AM_SHARE("videoregs")
1200	1211	AM_RANGE(0x20200000, 0x20203fff) AM_RAM_WRITE(hng64_pal_w) AM_SHARE("paletteram")
1201	1212	AM_RANGE(0x20208000, 0x2020805f) AM_READWRITE(tcram_r, tcram_w) AM_SHARE("tcram") // Transition Control
1202	1213	AM_RANGE(0x20300000, 0x203001ff) AM_RAM_WRITE(dl_w) AM_SHARE("dl") // 3d Display List
r244680	r244681
1730	1741	GFXDECODE_ENTRY( "textures", 0, hng64_texlayout, 0x0, 0x10 ) /* textures */
1731	1742	GFXDECODE_END
1732	1743
1733		static void hng64_reorder(~~running_machine &machine,~~ UINT8* gfxregion, size_t gfxregionsize)
	1744	static void hng64_reorder( UINT8* gfxregion, size_t gfxregionsize)
1734	1745	{
1735	1746	// by default 2 4bpp tiles are stored in each 8bpp tile, this makes decoding in MAME harder than it needs to be
1736	1747	// reorder them
r244680	r244681
1750	1761
1751	1762	DRIVER_INIT_MEMBER(hng64_state,hng64_reorder_gfx)
1752	1763	{
1753		hng64_reorder(m~~achine(), m~~emregion("scrtile")->base(), memregion("scrtile")->bytes());
	1764	hng64_reorder(memregion("scrtile")->base(), memregion("scrtile")->bytes());
1754	1765	}
1755	1766
1756	1767	#define HACK_REGION
1757	1768	#ifdef HACK_REGION
1758		~~static~~ void hng64_patch_bios_region(~~running_machine& machine,~~ int region)
	1769	void hng64_state::hng64_patch_bios_region(int region)
1759	1770	{
1760		UINT8 *rom = m~~achine.root_device().m~~emregion("user1")->base();
	1771	UINT8 *rom = memregion("user1")->base();
1761	1772
1762	1773	if ((rom[0x4000]==0xff) && (rom[0x4001] == 0xff))
1763	1774	{
r244680	r244681
1774	1785	// region hacking, english error messages are more useful to us, but no english bios is dumped...
1775	1786	#ifdef HACK_REGION
1776	1787	// versions according to fatal fury test mode
1777		// hng64_patch_bios_region(machine(), 0); // 'Others Ver' (invalid?)
1778		hng64_patch_bios_region(machine(), 1); // Japan
1779		// hng64_patch_bios_region(machine(), 2); // USA
1780		// hng64_patch_bios_region(machine(), 3); // Korea
1781		// hng64_patch_bios_region(machine(), 4); // 'Others'
	1788	// hng64_patch_bios_region( 0); // 'Others Ver' (invalid?)
	1789	hng64_patch_bios_region( 1); // Japan
	1790	// hng64_patch_bios_region( 2); // USA
	1791	// hng64_patch_bios_region( 3); // Korea
	1792	// hng64_patch_bios_region( 4); // 'Others'
1782	1793	#endif
1783	1794
1784	1795	/* 1 meg of virtual address space for the com cpu */
r244680	r244681
1902	1913
1903	1914	m_comm_rom = memregion("user2")->base();
1904	1915	m_comm_ram = auto_alloc_array(machine(),UINT8,0x10000);
	1916
	1917
	1918	for (int i = 0; i < 0x38 / 4; i++)
	1919	{
	1920	m_videoregs[i] = 0xdeadbeef;
	1921	}
	1922
1905	1923	}
1906	1924
1907	1925

trunk/src/mame/drivers/mitchell.c
r244680	r244681
1587	1587	ROM_LOAD( "pang_03.bin", 0x10000, 0x20000, CRC(0c8477ae) SHA1(a31a8c00407dfc3017d56e29fac6114b73248030) ) /* Decrypted data */
1588	1588
1589	1589	ROM_REGION( 0x100000, "gfx1", ROMREGION_ERASEFF )
1590		ROM_LOAD( "bb9.bin", 0x000000, 0x20000, CRC(3a5883f5) SHA1(a8a33071e10f5992e80afdb782c334829f9ae27f) ) /* chars */
	1590	ROM_LOAD( "pang_9.bin", 0x000000, 0x20000, CRC(3a5883f5) SHA1(a8a33071e10f5992e80afdb782c334829f9ae27f) ) /* chars */
1591	1591	ROM_LOAD( "bb3.bin", 0x020000, 0x20000, CRC(79a8ed08) SHA1(c1e43889e29b80c7fe2c09b11eecde24450a1ff5) )
1592	1592	/* 40000-7ffff empty */
1593	1593	ROM_LOAD( "bb11.bin", 0x080000, 0x20000, CRC(166a16ae) SHA1(7f907c78b7ac8c99e3d79761a6ae689c77e3a1f5) )
r244680	r244681
1610	1610	ROM_CONTINUE(0x10000, 0x20000 ) /* Decrypted data */
1611	1611
1612	1612	ROM_REGION( 0x100000, "gfx1", ROMREGION_ERASEFF )
1613		ROM_LOAD( "bb9.bin", 0x000000, 0x20000, CRC(3a5883f5) SHA1(a8a33071e10f5992e80afdb782c334829f9ae27f) ) /* chars */
	1613	ROM_LOAD( "pang_9.bin", 0x000000, 0x20000, CRC(3a5883f5) SHA1(a8a33071e10f5992e80afdb782c334829f9ae27f) ) /* chars */
1614	1614	ROM_LOAD( "bb3.bin", 0x020000, 0x20000, CRC(79a8ed08) SHA1(c1e43889e29b80c7fe2c09b11eecde24450a1ff5) )
1615	1615	/* 40000-7ffff empty */
1616	1616	ROM_LOAD( "bb11.bin", 0x080000, 0x20000, CRC(166a16ae) SHA1(7f907c78b7ac8c99e3d79761a6ae689c77e3a1f5) )

trunk/src/mame/drivers/suna8.c
r244680	r244681
2538	2538
2539	2539	ROM_START( brickzn )
2540	2540	ROM_REGION( 0x50000 + 0x40000, "maincpu", 0 ) /* Main Z80 Code */
2541		ROM_LOAD( "P9.M7", 0x00000, 0x08000, CRC(bd7a3c01) SHA1(05fb2836f1c8d8818847ccb76e7b477f13a9929b) ) // V6.0 1992,3,16
2542		ROM_LOAD( "P8.K7", 0x10000, 0x20000, CRC(ec3e266d) SHA1(4441a5ae88e51353f6d1eb22c00becb0a7ecea6e) )
2543		ROM_LOAD( "P7.I7", 0x30000, 0x20000, CRC(4dd88631) SHA1(0dbcaf3420dad82c3ed94d231948fe69b044b786) )
	2541	ROM_LOAD( "p9.m7", 0x00000, 0x08000, CRC(bd7a3c01) SHA1(05fb2836f1c8d8818847ccb76e7b477f13a9929b) ) // V6.0 1992,3,16
	2542	ROM_LOAD( "p8.k7", 0x10000, 0x20000, CRC(ec3e266d) SHA1(4441a5ae88e51353f6d1eb22c00becb0a7ecea6e) )
	2543	ROM_LOAD( "p7.i7", 0x30000, 0x20000, CRC(4dd88631) SHA1(0dbcaf3420dad82c3ed94d231948fe69b044b786) )
2544	2544
2545	2545	ROM_REGION( 0x10000, "audiocpu", 0 ) /* Music Z80 Code */
2546		ROM_LOAD( "10.O8", 0x00000, 0x10000, CRC(4eba8178) SHA1(9a214a1acacdc124529bc9dde73a8e884fc70293) ) // BRICK MUSIC XILINX PROGRAM 3020 1991,11,14 MUSIC PROGRAM V 2,0 1990.12.14
	2546	ROM_LOAD( "10.o8", 0x00000, 0x10000, CRC(4eba8178) SHA1(9a214a1acacdc124529bc9dde73a8e884fc70293) ) // BRICK MUSIC XILINX PROGRAM 3020 1991,11,14 MUSIC PROGRAM V 2,0 1990.12.14
2547	2547
2548	2548	ROM_REGION( 0x10000, "pcm", 0 ) /* PCM Z80 Code */
2549		ROM_LOAD( "11.N10", 0x00000, 0x10000, CRC(6c54161a) SHA1(ea216d9f45b441acd56b9fed81a83e3bfe299fbd) )
	2549	ROM_LOAD( "11.n10", 0x00000, 0x10000, CRC(6c54161a) SHA1(ea216d9f45b441acd56b9fed81a83e3bfe299fbd) )
2550	2550
2551	2551	ROM_REGION( 0xc0000, "gfx1", ROMREGION_INVERT ) /* Sprites */
2552		ROM_LOAD( "P5.M5", 0x00000, 0x20000, CRC(ca59e2f7) SHA1(dbb9f2b316a44f760768f0430798e0c4e9e8f3ff) )
2553		ROM_LOAD( "P4.L5", 0x20000, 0x20000, CRC(cc8fb330) SHA1(fd263f65b81acbfc00fe339c461068ab160c04af) )
2554		ROM_LOAD( "P3.K5", 0x40000, 0x20000, CRC(2e4f194b) SHA1(86da1a582ea274f2af96d3e3e2ac72bcaf3638cb) )
2555		ROM_LOAD( "P2.I5", 0x60000, 0x20000, CRC(592d45ce) SHA1(8ce9236b7deba6cf00999680314ac04eff624a6d) )
2556		ROM_LOAD( "P1.H5", 0x80000, 0x20000, CRC(7a6bb583) SHA1(ff7018c07182fce0ff6954bbe3b08fa5105f6be0) )
2557		ROM_LOAD( "P6.H7", 0xa0000, 0x20000, CRC(bbf31081) SHA1(1fdbd0e0853082345225e18df340184a7a604b78) )
	2552	ROM_LOAD( "p5.m5", 0x00000, 0x20000, CRC(ca59e2f7) SHA1(dbb9f2b316a44f760768f0430798e0c4e9e8f3ff) )
	2553	ROM_LOAD( "p4.l5", 0x20000, 0x20000, CRC(cc8fb330) SHA1(fd263f65b81acbfc00fe339c461068ab160c04af) )
	2554	ROM_LOAD( "p3.k5", 0x40000, 0x20000, CRC(2e4f194b) SHA1(86da1a582ea274f2af96d3e3e2ac72bcaf3638cb) )
	2555	ROM_LOAD( "p2.i5", 0x60000, 0x20000, CRC(592d45ce) SHA1(8ce9236b7deba6cf00999680314ac04eff624a6d) )
	2556	ROM_LOAD( "p1.h5", 0x80000, 0x20000, CRC(7a6bb583) SHA1(ff7018c07182fce0ff6954bbe3b08fa5105f6be0) )
	2557	ROM_LOAD( "p6.h7", 0xa0000, 0x20000, CRC(bbf31081) SHA1(1fdbd0e0853082345225e18df340184a7a604b78) )
2558	2558	ROM_END
2559	2559
2560	2560
r244680	r244681
2603	2603
2604	2604	ROM_START( brickzn11 )
2605	2605	ROM_REGION( 0x50000 + 0x40000, "maincpu", 0 ) /* Main Z80 Code */
2606		ROM_LOAD( "9.bin", 0x00000, 0x08000, CRC(24f88cfd) SHA1(dfa7313ab6696042bab2e6cc8ff97b331d526c6b) )
	2606	ROM_LOAD( "9.bin", 0x00000, 0x08000, CRC(24f88cfd) SHA1(dfa7313ab6696042bab2e6cc8ff97b331d526c6b) ) // V1.1 1992,1,13
2607	2607	ROM_LOAD( "8.bin", 0x10000, 0x20000, CRC(e2c7f7ac) SHA1(43377daf6957829ef9bb7a81708c2f18f5d7ced6) )
2608	2608	ROM_LOAD( "7.bin", 0x30000, 0x20000, CRC(7af5b25c) SHA1(9e98e99bdc5be1602144c83f40b2ccf6b90a729a) )
2609	2609
r244680	r244681
2881	2881
2882	2882	GAME( 1991, hardhea2, 0, hardhea2, hardhea2, suna8_state, hardhea2, ROT0, "SunA", "Hard Head 2 (v2.0)", 0 )
2883	2883
2884		GAME( 1992, brickzn, 0, brickzn, brickzn, suna8_state, brickzn, ROT90, "SunA", "Brick Zone (v6.0, Joystick)", 0 )
2885		GAME( 1992, brickznv5, brickzn, brickzn, brickzn, suna8_state, brickznv5, ROT90, "SunA", "Brick Zone (v5.0, Joystick)", 0 )
2886		GAME( 1992, brickznv4, brickzn, brickzn, brickzn, suna8_state, brickznv4, ROT90, "SunA", "Brick Zone (v4.0, Spinner)", 0 )
	2884	// is meant to sound like this https://www.youtube.com/watch?v=yfU1C7A3iZI (recorded from v6.0, Joystick version)
	2885	GAME( 1992, brickzn, 0, brickzn, brickzn, suna8_state, brickzn, ROT90, "SunA", "Brick Zone (v6.0, Joystick)", GAME_IMPERFECT_SOUND )
	2886	GAME( 1992, brickznv5, brickzn, brickzn, brickzn, suna8_state, brickznv5, ROT90, "SunA", "Brick Zone (v5.0, Joystick)", GAME_IMPERFECT_SOUND )
	2887	GAME( 1992, brickznv4, brickzn, brickzn, brickzn, suna8_state, brickznv4, ROT90, "SunA", "Brick Zone (v4.0, Spinner)", GAME_IMPERFECT_SOUND )
2887	2888	GAME( 1992, brickzn11, brickzn, brickzn, brickzn, suna8_state, brickzn11, ROT90, "SunA", "Brick Zone (v1.1)", GAME_NOT_WORKING )

trunk/src/mame/drivers/suprgolf.c
r244680	r244681
72	72	DECLARE_WRITE8_MEMBER(suprgolf_writeB);
73	73	DECLARE_DRIVER_INIT(suprgolf);
74	74	TILE_GET_INFO_MEMBER(get_tile_info);
	75	virtual void machine_start();
75	76	virtual void machine_reset();
76	77	virtual void video_start();
77	78	UINT32 screen_update_suprgolf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
r244680	r244681
249	250	}
250	251	}
251	252
	253	void suprgolf_state::machine_start()
	254	{
	255	membank("bank1")->configure_entries(0, 16, memregion("user2")->base(), 0x4000);
	256	membank("bank2")->configure_entries(0, 64, memregion("user1")->base(), 0x4000);
	257	}
	258
252	259	WRITE8_MEMBER(suprgolf_state::suprgolf_pen_w)
253	260	{
254	261	m_vreg_pen = data;
r244680	r244681
266	273
267	274	WRITE8_MEMBER(suprgolf_state::rom_bank_select_w)
268	275	{
269		~~UINT8~~ *r~~egi~~on_base = ~~memregion("user1")->b~~a~~se()~~;
	276	m_rom_bank = data;
270	277
271		m_rom_bank = data;
	278	//popmessage("%08x %02x",((data & 0x3f) * 0x4000),data);
	279	//osd_printf_debug("ROM_BANK 0x8000 - %X @%X\n",data,space.device().safe_pcbase());
	280	membank("bank2")->set_entry(data & 0x3f);
272	281
273		//popmessage("%08x %02x",((data & 0x3f) * 0x4000),data);
274
275		// osd_printf_debug("ROM_BANK 0x8000 - %X @%X\n",data,space.device().safe_pcbase());
276		membank("bank2")->set_base(region_base + (data&0x3f ) * 0x4000);
277
278	282	m_msm_nmi_mask = data & 0x40;
279	283	flip_screen_set(data & 0x80);
280	284	}
281	285
282	286	WRITE8_MEMBER(suprgolf_state::rom2_bank_select_w)
283	287	{
284		UINT8 *region_base = memregion("user2")->base();
285		// osd_printf_debug("ROM_BANK 0x4000 - %X @%X\n",data,space.device().safe_pcbase());
286
287		membank("bank1")->set_base(region_base + (data&0x0f) * 0x4000);
288
	288	//osd_printf_debug("ROM_BANK 0x4000 - %X @%X\n",data,space.device().safe_pcbase());
	289	membank("bank1")->set_entry(data & 0x0f);
	290
289	291	if(data & 0xf0)
290	292	printf("Rom bank select 2 with data %02x activated\n",data);
291	293	}

trunk/src/mame/drivers/suprslam.c
r244680	r244681
115	115
116	116	WRITE8_MEMBER(suprslam_state::suprslam_sh_bankswitch_w)
117	117	{
118		UINT8 *RAM = memregion("audiocpu")->base();
119		int bankaddress;
120
121		bankaddress = 0x10000 + (data & 0x03) * 0x8000;
122		membank("bank1")->set_base(&RAM[bankaddress]);
	118	membank("bank1")->set_entry(data & 0x03);
123	119	}
124	120
125	121	/* MEMORY MAPS ***********************************************************/
r244680	r244681
288	284	save_item(NAME(m_screen_bank));
289	285	save_item(NAME(m_bg_bank));
290	286	save_item(NAME(m_pending_command));
	287
	288	membank("bank1")->configure_entries(0, 4, memregion("audiocpu")->base() + 0x10000, 0x8000);
291	289	}
292	290
293	291	void suprslam_state::machine_reset()

trunk/src/mame/drivers/tankbust.c
r244680	r244681
22	22	#include "includes/tankbust.h"
23	23
24	24
	25	void tankbust_state::machine_start()
	26	{
	27	membank("bank1")->configure_entries(0, 2, memregion("maincpu")->base() + 0x10000, 0x4000);
	28	membank("bank2")->configure_entries(0, 2, memregion("maincpu")->base() + 0x18000, 0x2000);
	29	}
	30
25	31	//port A of ay8910#0
26	32
27	33	TIMER_CALLBACK_MEMBER(tankbust_state::soundlatch_callback)
r244680	r244681
95	101
96	102	case 7: /* 0xe007 bankswitch */
97	103	/* bank 1 at 0x6000-9fff = from 0x10000 when bit0=0 else from 0x14000 */
	104	membank("bank1")->set_entry(data & 1);
	105
98	106	/* bank 2 at 0xa000-bfff = from 0x18000 when bit0=0 else from 0x1a000 */
99		membank("bank1")->set_base(memregion("maincpu")->base() + 0x10000 + ((data&1) * 0x4000) );
100		membank("bank2")->set_base(memregion("maincpu")->base() + 0x18000 + ((data&1) * 0x2000) ); /* verified (the game will reset after the "game over" otherwise) */
	107	membank("bank2")->set_entry(data & 1); /* verified (the game will reset after the "game over" otherwise) */
101	108	break;
102	109	}
103	110	}

trunk/src/mame/drivers/thunderx.c
r244680	r244681
312	312
313	313	WRITE8_MEMBER(thunderx_state::scontra_bankswitch_w)
314	314	{
315		UINT8 *RAM = memregion("maincpu")->base();
316		int offs;
	315	// logerror("%04x: bank switch %02x\n", space.device().safe_pc(), data & 0x0f);
	316	membank("bank1")->set_entry(data & 0x0f);
317	317
318		//logerror("%04x: bank switch %02x\n",space.device().safe_pc(),data);
319
320		/* bits 0-3 ROM bank */
321		offs = 0x10000 + (data & 0x0f)*0x2000;
322		membank("bank1")->set_base(&RAM[offs] );
323
324	318	/* bit 4 select work RAM or palette RAM at 5800-5fff */
325	319	m_palette_selected = ~data & 0x10;
326	320
r244680	r244681
585	579	save_item(NAME(m_palette_selected));
586	580	save_item(NAME(m_rambank));
587	581	save_item(NAME(m_pmcbank));
	582
	583	membank("bank1")->configure_entries(0, 16, memregion("maincpu")->base() + 0x10000, 0x2000);
588	584	}
589	585
590	586	MACHINE_START_MEMBER(thunderx_state,thunderx)

trunk/src/mame/drivers/tryout.c
r244680	r244681
43	43	// m_audiocpu->set_input_line(0, CLEAR_LINE);
44	44	}
45	45
	46	void tryout_state::machine_start()
	47	{
	48	membank("bank1")->configure_entries(0, 2, memregion("maincpu")->base() + 0x10000, 0x2000);
	49	}
	50
46	51	WRITE8_MEMBER(tryout_state::tryout_bankswitch_w)
47	52	{
48		UINT8 *RAM = memregion("maincpu")->base();
49		int bankaddress;
50
51		bankaddress = 0x10000 + (data & 0x01) * 0x2000;
52		membank("bank1")->set_base(&RAM[bankaddress]);
	53	membank("bank1")->set_entry(data & 0x01);
53	54	}
54	55
55	56	static ADDRESS_MAP_START( main_cpu, AS_PROGRAM, 8, tryout_state )

trunk/src/mame/drivers/usgames.c
r244680	r244681
30	30	#include "includes/usgames.h"
31	31	#include "machine/nvram.h"
32	32
	33	void usgames_state::machine_start()
	34	{
	35	membank("bank1")->configure_entries(0, 16, memregion("maincpu")->base() + 0x10000, 0x4000);
	36	}
33	37
34	38	WRITE8_MEMBER(usgames_state::usgames_rombank_w)
35	39	{
36		UINT8 *RAM = memregion("maincpu")->base();
37
38		// logerror ("BANK WRITE? -%02x-\n",data);
39		//popmessage("%02x",data);
40
41		membank("bank1")->set_base(&RAM[ 0x10000 + 0x4000 * data] );
	40	membank("bank1")->set_entry(data);
42	41	}
43	42
44	43	WRITE8_MEMBER(usgames_state::lamps1_w)

trunk/src/mame/drivers/vigilant.c
r244680	r244681
22	22	#include "includes/vigilant.h"
23	23	#include "includes/iremipt.h"
24	24
	25	void vigilant_state::machine_start()
	26	{
	27	membank("bank1")->configure_entries(0, 8, memregion("maincpu")->base() + 0x10000, 0x4000);
	28	}
	29
25	30	WRITE8_MEMBER(vigilant_state::vigilant_bank_select_w)
26	31	{
27		int bankaddress;
28		UINT8 *RAM = memregion("maincpu")->base();
29
30		bankaddress = 0x10000 + (data & 0x07) * 0x4000;
31		membank("bank1")->set_base(&RAM[bankaddress]);
	32	membank("bank1")->set_entry(data & 0x07);
32	33	}
33	34
34	35	/***************************************************************************

trunk/src/mame/includes/hng64.h
r244680	r244681
10	10	BURIKI_MCU
11	11	};
12	12
	13	enum hng64trans_t
	14	{
	15	HNG64_TILEMAP_NORMAL = 1,
	16	HNG64_TILEMAP_ADDITIVE,
	17	HNG64_TILEMAP_ALPHA
	18	};
13	19
14	20
	21	struct blit_parameters
	22	{
	23	bitmap_rgb32 * bitmap;
	24	rectangle cliprect;
	25	UINT32 tilemap_priority_code;
	26	UINT8 mask;
	27	UINT8 value;
	28	UINT8 alpha;
	29	hng64trans_t drawformat;
	30	};
	31
	32
	33
	34	///////////////////////
	35	// polygon rendering //
	36	///////////////////////
	37
	38	struct polygonRasterOptions
	39	{
	40	UINT8 texType;
	41	UINT8 texIndex;
	42	UINT8 texPageSmall;
	43	UINT8 texPageHorizOffset;
	44	UINT8 texPageVertOffset;
	45	int palOffset;
	46	int palPageSize;
	47	int debugColor;
	48	};
	49
15	50	class hng64_state : public driver_device
16	51	{
17	52	public:
r244680	r244681
40	75	m_screen(*this, "screen"),
41	76	m_palette(*this, "palette"),
42	77	m_generic_paletteram_32(*this, "paletteram")
43		{ }
44	78
	79	{ }
	80
45	81	required_device<mips3_device> m_maincpu;
46	82	required_device<cpu_device> m_audiocpu;
47	83	required_device<cpu_device> m_comm;
r244680	r244681
70	106	required_device<palette_device> m_palette;
71	107	required_shared_ptr<UINT32> m_generic_paletteram_32;
72	108
	109
73	110	int m_mcu_type;
74	111
75	112	UINT16 *m_soundram;
r244680	r244681
97	134
98	135	UINT8 m_screen_dis;
99	136
100		tilemap_t *m_tilemap0_8x8;
101		tilemap_t *m_tilemap1_8x8;
102		tilemap_t *m_tilemap2_8x8;
103		tilemap_t *m_tilemap3_8x8;
	137	struct hng64_tilemap {
	138	tilemap_t *m_tilemap_8x8;
	139	tilemap_t *m_tilemap_16x16;
	140	tilemap_t *m_tilemap_16x16_alt;
	141	};
104	142
105		tilemap_t *m_tilemap0_16x16;
106		tilemap_t *m_tilemap1_16x16;
107		tilemap_t *m_tilemap2_16x16;
108		tilemap_t *m_tilemap3_16x16;
	143	hng64_tilemap m_tilemap[4];
109	144
110		tilemap_t *m_tilemap0_16x16_alt;
111		tilemap_t *m_tilemap1_16x16_alt;
112		tilemap_t *m_tilemap2_16x16_alt;
113		tilemap_t *m_tilemap3_16x16_alt;
114
115	145	UINT8 m_additive_tilemap_debug;
116	146
117	147	// 3d display buffers
r244680	r244681
121	151
122	152	UINT32 m_old_animmask;
123	153	UINT32 m_old_animbits;
124		UINT16 m_old_tileflags0;
125		UINT16 m_old_tileflags1;
126		UINT16 m_old_tileflags2;
127		UINT16 m_old_tileflags3;
	154	UINT16 m_old_tileflags[4];
128	155
129	156	UINT32 m_dls[2][0x81];
130	157
r244680	r244681
166	193	DECLARE_READ32_MEMBER(unk_vreg_r);
167	194	DECLARE_WRITE32_MEMBER(hng64_soundram_w);
168	195	DECLARE_READ32_MEMBER(hng64_soundram_r);
	196	DECLARE_WRITE32_MEMBER(hng64_vregs_w);
169	197
170	198	// not actually used, but left in code so you can turn it and see the (possibly undesired?) behavior, see notes in memory map
171	199	DECLARE_WRITE32_MEMBER(hng64_soundram2_w);
r244680	r244681
226	254	DECLARE_CUSTOM_INPUT_MEMBER(brake_down_r);
227	255	void clear3d();
228	256	TIMER_CALLBACK_MEMBER(hng64_3dfifo_processed);
	257
	258	void FillSmoothTexPCHorizontalLine(
	259	const polygonRasterOptions& prOptions,
	260	int x_start, int x_end, int y, float z_start, float z_delta,
	261	float w_start, float w_delta, float r_start, float r_delta,
	262	float g_start, float g_delta, float b_start, float b_delta,
	263	float s_start, float s_delta, float t_start, float t_delta);
	264
	265	void hng64_command3d(const UINT16* packet);
	266	void draw_sprites(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	267	void transition_control( bitmap_rgb32 &bitmap, const rectangle &cliprect);
	268	void hng64_tilemap_draw_roz_core(screen_device &screen, tilemap_t tmap, const blit_parameters blit,
	269	UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound);
	270	void hng64_drawtilemap(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, int tm);
	271	void setCameraTransformation(const UINT16* packet);
	272	void setLighting(const UINT16* packet);
	273	void set3dFlags(const UINT16* packet);
	274	void setCameraProjectionMatrix(const UINT16* packet);
	275	void recoverPolygonBlock(const UINT16* packet, struct polygon* polys, int* numPolys);
	276	void hng64_mark_all_tiles_dirty(int tilemap);
	277	void hng64_mark_tile_dirty(int tilemap, int tile_index);
	278
	279	void hng64_tilemap_draw_roz(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
	280	UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
	281	int wraparound, UINT32 flags, UINT8 priority, hng64trans_t drawformat);
	282
	283	void hng64_tilemap_draw_roz_primask(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
	284	UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
	285	int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask, hng64trans_t drawformat);
	286
	287	void RasterizeTriangle_SMOOTH_TEX_PC(
	288	float A[4], float B[4], float C[4],
	289	float Ca[3], float Cb[3], float Cc[3], // PER-VERTEX RGB COLORS
	290	float Ta[2], float Tb[2], float Tc[2], // PER-VERTEX (S,T) TEX-COORDS
	291	const polygonRasterOptions& prOptions);
	292
	293	void drawShaded( struct polygon *p);
	294
	295	void hng64_patch_bios_region(int region);
	296
229	297	};
230	298
231		/----------- defined in video/hng64.c -----------/
232		void hng64_command3d(running_machine& machine, const UINT16* packet);

trunk/src/mame/includes/tankbust.h
r244680	r244681
43	43	DECLARE_READ8_MEMBER(tankbust_soundtimer_r);
44	44	TILE_GET_INFO_MEMBER(get_bg_tile_info);
45	45	TILE_GET_INFO_MEMBER(get_txt_tile_info);
46		virtual void machine_reset();
	46	virtual void machine_start();
	47	virtual void machine_reset();
47	48	virtual void video_start();
48	49	DECLARE_PALETTE_INIT(tankbust);
49	50	UINT32 screen_update_tankbust(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mame/includes/thunderx.h
r244680	r244681
63	63	DECLARE_READ8_MEMBER(k052109_051960_r);
64	64	DECLARE_WRITE8_MEMBER(k052109_051960_w);
65	65	DECLARE_WRITE8_MEMBER(scontra_snd_bankswitch_w);
66		virtual void video_start();
	66	virtual void video_start();
67	67	DECLARE_MACHINE_START(scontra);
68	68	DECLARE_MACHINE_RESET(scontra);
69	69	DECLARE_MACHINE_START(thunderx);

trunk/src/mame/includes/tryout.h
r244680	r244681
36	36	TILE_GET_INFO_MEMBER(get_bg_tile_info);
37	37	TILEMAP_MAPPER_MEMBER(get_fg_memory_offset);
38	38	TILEMAP_MAPPER_MEMBER(get_bg_memory_offset);
39		virtual void video_start();
	39	virtual void machine_start();
	40	virtual void video_start();
40	41	DECLARE_PALETTE_INIT(tryout);
41	42	UINT32 screen_update_tryout(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
42	43	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);

trunk/src/mame/includes/usgames.h
r244680	r244681
17	17	DECLARE_WRITE8_MEMBER(usgames_videoram_w);
18	18	DECLARE_WRITE8_MEMBER(usgames_charram_w);
19	19	TILE_GET_INFO_MEMBER(get_usgames_tile_info);
20		virtual void video_start();
	20	virtual void machine_start();
	21	virtual void video_start();
21	22	DECLARE_PALETTE_INIT(usgames);
22	23	UINT32 screen_update_usgames(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
23	24	required_device<cpu_device> m_maincpu;

trunk/src/mame/includes/vigilant.h
r244680	r244681
38	38	DECLARE_WRITE8_MEMBER(vigilant_horiz_scroll_w);
39	39	DECLARE_WRITE8_MEMBER(vigilant_rear_horiz_scroll_w);
40	40	DECLARE_WRITE8_MEMBER(vigilant_rear_color_w);
41		virtual void video_start();
	41	virtual void machine_start();
	42	virtual void video_start();
42	43	virtual void video_reset();
43	44	UINT32 screen_update_vigilant(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
44	45	UINT32 screen_update_kikcubic(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mame/video/hng64.c
r244680	r244681
7	7
8	8
9	9
10		~~static~~ void hng64_mark_all_tiles_dirty( ~~hng64_state *state,~~ int tilemap )
	10	void hng64_state::hng64_mark_all_tiles_dirty( int tilemap )
11	11	{
12		if (tilemap == 0)
13		{
14		state->m_tilemap0_8x8->mark_all_dirty();
15		state->m_tilemap0_16x16->mark_all_dirty();
16		state->m_tilemap0_16x16_alt->mark_all_dirty();
17		}
18		else if (tilemap == 1)
19		{
20		state->m_tilemap1_8x8->mark_all_dirty();
21		state->m_tilemap1_16x16->mark_all_dirty();
22		state->m_tilemap1_16x16_alt->mark_all_dirty();
23		}
24		else if (tilemap == 2)
25		{
26		state->m_tilemap2_8x8->mark_all_dirty();
27		state->m_tilemap2_16x16->mark_all_dirty();
28		state->m_tilemap2_16x16_alt->mark_all_dirty();
29		}
30		else if (tilemap == 3)
31		{
32		state->m_tilemap3_8x8->mark_all_dirty();
33		state->m_tilemap3_16x16->mark_all_dirty();
34		state->m_tilemap3_16x16_alt->mark_all_dirty();
35		}
	12	m_tilemap[tilemap].m_tilemap_8x8->mark_all_dirty();
	13	m_tilemap[tilemap].m_tilemap_16x16->mark_all_dirty();
	14	m_tilemap[tilemap].m_tilemap_16x16_alt->mark_all_dirty();
36	15	}
37	16
38		~~static~~ void hng64_mark_tile_dirty( ~~hng64_state *state,~~ int tilemap, int tile_index )
	17	void hng64_state::hng64_mark_tile_dirty( int tilemap, int tile_index )
39	18	{
40		if (tilemap == 0)
41		{
42		state->m_tilemap0_8x8->mark_tile_dirty(tile_index);
43		state->m_tilemap0_16x16->mark_tile_dirty(tile_index);
44		state->m_tilemap0_16x16_alt->mark_tile_dirty(tile_index);
45		}
46		else if (tilemap == 1)
47		{
48		state->m_tilemap1_8x8->mark_tile_dirty(tile_index);
49		state->m_tilemap1_16x16->mark_tile_dirty(tile_index);
50		state->m_tilemap1_16x16_alt->mark_tile_dirty(tile_index);
51		}
52		else if (tilemap == 2)
53		{
54		state->m_tilemap2_8x8->mark_tile_dirty(tile_index);
55		state->m_tilemap2_16x16->mark_tile_dirty(tile_index);
56		state->m_tilemap2_16x16_alt->mark_tile_dirty(tile_index);
57		}
58		else if (tilemap == 3)
59		{
60		state->m_tilemap3_8x8->mark_tile_dirty(tile_index);
61		state->m_tilemap3_16x16->mark_tile_dirty(tile_index);
62		state->m_tilemap3_16x16_alt->mark_tile_dirty(tile_index);
63		}
	19	m_tilemap[tilemap].m_tilemap_8x8->mark_tile_dirty(tile_index);
	20	m_tilemap[tilemap].m_tilemap_16x16->mark_tile_dirty(tile_index);
	21	m_tilemap[tilemap].m_tilemap_16x16_alt->mark_tile_dirty(tile_index);
64	22	}
65	23
66	24
r244680	r244681
105	63	* 0x0e0 in Samurai Shodown/Xrally games, 0x1c0 in all the others, zooming factor?
106	64	*/
107	65
108		~~static~~ void draw_sprites(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	66	void hng64_state::draw_sprites(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
109	67	{
110		hng64_state *state = screen.machine().driver_data<hng64_state>();
111	68	gfx_element *gfx;
112		UINT32 *source = state->m_spriteram;
113		UINT32 *finish = state->m_spriteram + 0xc000/4;
	69	UINT32 *source = m_spriteram;
	70	UINT32 *finish = m_spriteram + 0xc000/4;
114	71
115	72	// global offsets in sprite regs
116		int spriteoffsx = (state->m_spriteregs[1]>>0)&0xffff;
117		int spriteoffsy = (state->m_spriteregs[1]>>16)&0xffff;
	73	int spriteoffsx = (m_spriteregs[1]>>0)&0xffff;
	74	int spriteoffsy = (m_spriteregs[1]>>16)&0xffff;
118	75
119	76	#if 0
120	77	for (int iii = 0; iii < 0x0f; iii++)
121		osd_printf_debug("%.8x ", ~~state->~~m_videoregs[iii]);
	78	osd_printf_debug("%.8x ", m_videoregs[iii]);
122	79	osd_printf_debug("\n");
123	80	#endif
124	81
r244680	r244681
182	139	int zoom_factor;
183	140
184	141	/* FIXME: regular zoom mode has precision bugs, can be easily seen in Samurai Shodown 64 intro */
185		zoom_factor = (~~state->~~m_spriteregs[0] & 0x08000000) ? 0x1000 : 0x100;
	142	zoom_factor = (m_spriteregs[0] & 0x08000000) ? 0x1000 : 0x100;
186	143	if(!zoomx) zoomx=zoom_factor;
187	144	if(!zoomy) zoomy=zoom_factor;
188	145
r244680	r244681
197	154	zoomy += (int)((foomY - floor(foomY)) * (float)0x10000);
198	155	}
199	156
200		if (~~state->~~m_spriteregs[0] & 0x00800000) //bpp switch
	157	if (m_spriteregs[0] & 0x00800000) //bpp switch
201	158	{
202		gfx= ~~state->~~m_gfxdecode->gfx(4);
	159	gfx= m_gfxdecode->gfx(4);
203	160	}
204	161	else
205	162	{
206		gfx= ~~state->~~m_gfxdecode->gfx(5);
	163	gfx= m_gfxdecode->gfx(5);
207	164	tileno>>=1;
208	165	pal&=0xf;
209	166	}
r244680	r244681
262	219	tileno=(source[4]&0x0007ffff);
263	220	pal =(source[3]&0x00ff0000)>>16;
264	221
265		if (~~state->~~m_spriteregs[0] & 0x00800000) //bpp switch
	222	if (m_spriteregs[0] & 0x00800000) //bpp switch
266	223	{
267		gfx= ~~state->~~m_gfxdecode->gfx(4);
	224	gfx= m_gfxdecode->gfx(4);
268	225	}
269	226	else
270	227	{
271		gfx= ~~state->~~m_gfxdecode->gfx(5);
	228	gfx= m_gfxdecode->gfx(5);
272	229	tileno>>=1;
273	230	pal&=0xf;
274	231	}
r244680	r244681
328	285	*/
329	286
330	287	/* this is broken for the 'How to Play' screen in Buriki after attract, disabled for now */
331		~~static~~ void transition_control(~~running_machine &machine,~~ bitmap_rgb32 &bitmap, const rectangle &cliprect)
	288	void hng64_state::transition_control( bitmap_rgb32 &bitmap, const rectangle &cliprect)
332	289	{
333		hng64_state *state = machine.driver_data<hng64_state>();
334		UINT32 *hng64_tcram = state->m_tcram;
	290	UINT32 *hng64_tcram = m_tcram;
335	291	int i, j;
336	292
337	293	// float colorScaleR, colorScaleG, colorScaleB;
r244680	r244681
548	504	WRITE32_MEMBER(hng64_state::hng64_videoram_w)
549	505	{
550	506	int realoff;
551		hng64_state *state = machine().driver_data<hng64_state>();
552	507	COMBINE_DATA(&m_videoram[offset]);
553	508
554	509	realoff = offset*4;
555	510
556	511	if ((realoff>=0) && (realoff<0x10000))
557	512	{
558		hng64_mark_tile_dirty(~~state,~~ 0, offset&0x3fff);
	513	hng64_mark_tile_dirty(0, offset&0x3fff);
559	514	}
560	515	else if ((realoff>=0x10000) && (realoff<0x20000))
561	516	{
562		hng64_mark_tile_dirty(~~state,~~ 1, offset&0x3fff);
	517	hng64_mark_tile_dirty(1, offset&0x3fff);
563	518	}
564	519	else if ((realoff>=0x20000) && (realoff<0x30000))
565	520	{
566		hng64_mark_tile_dirty(~~state,~~ 2, offset&0x3fff);
	521	hng64_mark_tile_dirty(2, offset&0x3fff);
567	522	}
568	523	else if ((realoff>=0x30000) && (realoff<0x40000))
569	524	{
570		hng64_mark_tile_dirty(~~state,~~ 3, offset&0x3fff);
	525	hng64_mark_tile_dirty(3, offset&0x3fff);
571	526	}
572	527
573	528	// if ((realoff>=0x40000)) osd_printf_debug("offsw %08x %08x\n",realoff,data);
r244680	r244681
576	531	}
577	532
578	533	/* internal set of transparency states for rendering */
579		enum hng64trans_t
580		{
581		HNG64_TILEMAP_NORMAL = 1,
582		HNG64_TILEMAP_ADDITIVE,
583		HNG64_TILEMAP_ALPHA
584		};
585	534
586	535
587		struct blit_parameters
588		{
589		bitmap_rgb32 * bitmap;
590		rectangle cliprect;
591		UINT32 tilemap_priority_code;
592		UINT8 mask;
593		UINT8 value;
594		UINT8 alpha;
595		hng64trans_t drawformat;
596		};
597
598
599
600	536	static void hng64_configure_blit_parameters(blit_parameters blit, tilemap_t tmap, bitmap_rgb32 &dest, const rectangle &cliprect, UINT32 flags, UINT8 priority, UINT8 priority_mask, hng64trans_t drawformat)
601	537	{
602	538	/* start with nothing */
r244680	r244681
673	609	(UINT32 )dest = alpha_blend_r32((UINT32 )dest, clut[INPUT_VAL], alpha); \
674	610	} while (0)
675	611
676		~~static~~ void hng64_tilemap_draw_roz_core(screen_device &screen, tilemap_t tmap, const blit_parameters blit,
	612	void hng64_state::hng64_tilemap_draw_roz_core(screen_device &screen, tilemap_t tmap, const blit_parameters blit,
677	613	UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, int wraparound)
678	614	{
679		hng64_state *state = screen.machine().driver_data<hng64_state>();
680		const pen_t *clut = &state->m_palette->pen(blit->tilemap_priority_code >> 16);
	615	const pen_t *clut = &m_palette->pen(blit->tilemap_priority_code >> 16);
681	616	bitmap_ind8 &priority_bitmap = screen.priority();
682	617	bitmap_rgb32 &destbitmap = *blit->bitmap;
683	618	bitmap_ind16 &srcbitmap = tmap->pixmap();
r244680	r244681
851	786
852	787
853	788
854		~~static~~ void hng64_tilemap_draw_roz_primask(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
	789	void hng64_state::hng64_tilemap_draw_roz_primask(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
855	790	UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
856	791	int wraparound, UINT32 flags, UINT8 priority, UINT8 priority_mask, hng64trans_t drawformat)
857	792	{
r244680	r244681
879	814	}
880	815
881	816
882		~~INLINE~~ void hng64_tilemap_draw_roz(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
	817	inline void hng64_state::hng64_tilemap_draw_roz(screen_device &screen, bitmap_rgb32 &dest, const rectangle &cliprect, tilemap_t *tmap,
883	818	UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy,
884	819	int wraparound, UINT32 flags, UINT8 priority, hng64trans_t drawformat)
885	820	{
r244680	r244681
888	823
889	824
890	825
891		~~static~~ void hng64_drawtilemap(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, int tm )
	826	void hng64_state::hng64_drawtilemap(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, int tm )
892	827	{
893		hng64_state *state = screen.machine().driver_data<hng64_state>();
894		UINT32 *hng64_videoregs = state->m_videoregs;
895		UINT32 *hng64_videoram = state->m_videoram;
	828	UINT32 *hng64_videoregs = m_videoregs;
	829	UINT32 *hng64_videoram = m_videoram;
896	830	tilemap_t* tilemap = 0;
897	831	UINT32 scrollbase = 0;
898	832	UINT32 tileregs = 0;
r244680	r244681
903	837
904	838	int global_dimensions = (global_tileregs&0x03000000)>>24;
905	839
906		if ( (~~state->~~m_additive_tilemap_debug&(1 << tm)))
	840	if ( (m_additive_tilemap_debug&(1 << tm)))
907	841	debug_blend_enabled = 1;
908	842
909	843	if ((global_dimensions != 0) && (global_dimensions != 3))
r244680	r244681
913	847	{
914	848	scrollbase = (hng64_videoregs[0x04]&0x3fff0000)>>16;
915	849	tileregs = (hng64_videoregs[0x02]&0xffff0000)>>16;
916
917		if (global_dimensions==0)
918		{
919		if (tileregs&0x0200) tilemap = state->m_tilemap0_16x16;
920		else tilemap = state->m_tilemap0_8x8;
921		}
922		else
923		{
924		if (tileregs&0x0200) tilemap = state->m_tilemap0_16x16_alt;
925		else tilemap = state->m_tilemap0_8x8; // _alt
926		}
927	850	}
928	851	else if (tm==1)
929	852	{
930	853	scrollbase = (hng64_videoregs[0x04]&0x00003fff)>>0;
931	854	tileregs = (hng64_videoregs[0x02]&0x0000ffff)>>0;
932
933		if (global_dimensions==0)
934		{
935		if (tileregs&0x0200) tilemap = state->m_tilemap1_16x16;
936		else tilemap = state->m_tilemap1_8x8;
937		}
938		else
939		{
940		if (tileregs&0x0200) tilemap = state->m_tilemap1_16x16_alt;
941		else tilemap = state->m_tilemap1_8x8; // _alt
942		}
943	855	}
944	856	else if (tm==2)
945	857	{
946	858	scrollbase = (hng64_videoregs[0x05]&0x3fff0000)>>16;
947	859	tileregs = (hng64_videoregs[0x03]&0xffff0000)>>16;
948
949		if (global_dimensions==0)
950		{
951		if (tileregs&0x0200) tilemap = state->m_tilemap2_16x16;
952		else tilemap = state->m_tilemap2_8x8;
953		}
954		else
955		{
956		if (tileregs&0x0200) tilemap = state->m_tilemap2_16x16_alt;
957		else tilemap = state->m_tilemap2_8x8; // _alt
958		}
959	860	}
960	861	else if (tm==3)
961	862	{
962	863	scrollbase = (hng64_videoregs[0x05]&0x00003fff)>>0;
963	864	tileregs = (hng64_videoregs[0x03]&0x0000ffff)>>0;
	865	}
964	866
965		if (global_dimensions==0)
966		{
967		if (tileregs&0x0200) tilemap = state->m_tilemap3_16x16;
968		else tilemap = state->m_tilemap3_8x8;
969		}
970		else
971		{
972		if (tileregs&0x0200) tilemap = state->m_tilemap3_16x16_alt;
973		else tilemap = state->m_tilemap3_8x8; // _alt
974		}
	867	if (global_dimensions==0)
	868	{
	869	if (tileregs&0x0200) tilemap = m_tilemap[tm].m_tilemap_16x16;
	870	else tilemap = m_tilemap[tm].m_tilemap_8x8;
975	871	}
	872	else
	873	{
	874	if (tileregs&0x0200) tilemap = m_tilemap[tm].m_tilemap_16x16_alt;
	875	else tilemap = m_tilemap[tm].m_tilemap_8x8; // _alt
	876	}
976	877
977	878	// xrally's pink tilemaps make me think this is a tilemap enable bit.
978	879	// fatfurwa makes me think otherwise.
979		//if (!(tileregs & 0x0040)) return;
	880	// if (!(tileregs & 0x0040)) return;
980	881
981	882	// set the transmask so our manual copy is correct
982	883	if (tileregs & 0x0400)
r244680	r244681
1126	1027	bitmap_ind16 &bm = tilemap->pixmap();
1127	1028	int bmheight = bm.height();
1128	1029	int bmwidth = bm.width();
1129		const pen_t *paldata = ~~state->~~m_palette->pens();
	1030	const pen_t *paldata = m_palette->pens();
1130	1031	UINT32* dstptr;
1131	1032	UINT16* srcptr;
1132	1033	int xx,yy;
r244680	r244681
1222	1123	bitmap_ind16 &bm = tilemap->pixmap();
1223	1124	int bmheight = bm.height();
1224	1125	int bmwidth = bm.width();
1225		const pen_t *paldata = ~~state->~~m_palette->pens();
	1126	const pen_t *paldata = m_palette->pens();
1226	1127	UINT32* dstptr;
1227	1128	UINT16* srcptr;
1228	1129	int xx,yy;
r244680	r244681
1311	1212	// 0940 - samurai shodown 64
1312	1213	// 0880 - buriki
1313	1214
1314		// mmmm dbr? ~~??e?~~ ~~????~~
	1215	// mmmm dbrz zzzz zzzz
1315	1216	// m = mosaic related?
1316	1217	// -- they seem to enable mosaic at the same time as rowscroll in several cases (floor in buriki / ff)
1317	1218	// and also on the rotating logo in buriki.. does it cause some kind of aliasing side-effect, or.. ?
1318	1219	// r = tile size (seems correct)
1319	1220	// b = 4bpp/8bpp (seems correct) (beast busters, samsh64, sasm64 2, xrally switch it for some screens)
1320	1221	// d = line (floor) mode - buriki, fatafurwa, some backgrounds in ss64_2
1321		// e = enable ac~~cor~~ding to sams~~64_2~~ debug ~~mod~~e, buriki and xr~~all~~y.. ~~but~~ ~~NOT~~ ~~fata~~l ~~fury~~ ~~:-(~~
	1222	// z = z depth? tilemaps might also be affected by min / max clip values somewhere? (debug layer on buriki has priority 0x020, which would be highest)
1322	1223
1323	1224
1324	1225	*/
r244680	r244681
1334	1235	UINT32 *hng64_tcram = m_tcram;
1335	1236	UINT32 animmask;
1336	1237	UINT32 animbits;
1337		UINT16 tileflags0, tileflags1;
1338		UINT16 tileflags2, tileflags3;
	1238	UINT16 tileflags[4];
1339	1239
1340	1240	#if 0
1341	1241	// press in sams64_2 attract mode for a nice debug screen from the game
r244680	r244681
1356	1256
1357	1257	animmask = hng64_videoregs[0x0b];
1358	1258	animbits = hng64_videoregs[0x0c];
1359		tileflags0 = hng64_videoregs[0x02]>>16;
1360		tileflags1 = hng64_videoregs[0x02]&0xffff;
1361		tileflags2 = hng64_videoregs[0x03]>>16;
1362		tileflags3 = hng64_videoregs[0x03]&0xffff;
	1259	tileflags[0] = hng64_videoregs[0x02]>>16;
	1260	tileflags[1] = hng64_videoregs[0x02]&0xffff;
	1261	tileflags[2] = hng64_videoregs[0x03]>>16;
	1262	tileflags[3] = hng64_videoregs[0x03]&0xffff;
1363	1263
1364	1264	/* if the auto-animation mask or bits have changed search for tiles using them and mark as dirty */
1365	1265	if ((m_old_animmask != animmask) \|\| (m_old_animbits != animbits))
r244680	r244681
1369	1269	{
1370	1270	if (hng64_videoram[tile_index+(0x00000/4)]&0x200000)
1371	1271	{
1372		hng64_mark_tile_dirty(~~this,~~ 0, tile_index);
	1272	hng64_mark_tile_dirty(0, tile_index);
1373	1273	}
1374	1274	if (hng64_videoram[tile_index+(0x10000/4)]&0x200000)
1375	1275	{
1376		hng64_mark_tile_dirty(~~this,~~ 1, tile_index);
	1276	hng64_mark_tile_dirty(1, tile_index);
1377	1277	}
1378	1278	if (hng64_videoram[tile_index+(0x20000/4)]&0x200000)
1379	1279	{
1380		hng64_mark_tile_dirty(~~this,~~ 2, tile_index);
	1280	hng64_mark_tile_dirty(2, tile_index);
1381	1281	}
1382	1282	if (hng64_videoram[tile_index+(0x30000/4)]&0x200000)
1383	1283	{
1384		hng64_mark_tile_dirty(~~this,~~ 3, tile_index);
	1284	hng64_mark_tile_dirty(3, tile_index);
1385	1285	}
1386	1286	}
1387	1287
r244680	r244681
1389	1289	m_old_animbits = animbits;
1390	1290	}
1391	1291
1392		if (~~(m_old_t~~i~~leflags0&IMPORTANT_DIRTY_TILEFLAG_MASK)!=(~~ti~~leflags~~0~~&IMPORTANT_DIRTY_TILEFLAG_MASK)~~)
	1292	for (int i = 0; i < 4; i++)
1393	1293	{
1394		hng64_mark_all_tiles_dirty(this, 0);
1395		m_old_tileflags0 = tileflags0;
	1294	if ((m_old_tileflags[i]&IMPORTANT_DIRTY_TILEFLAG_MASK)!=(tileflags[i]&IMPORTANT_DIRTY_TILEFLAG_MASK))
	1295	{
	1296	hng64_mark_all_tiles_dirty(i);
	1297	m_old_tileflags[i] = tileflags[i];
	1298	}
1396	1299	}
1397	1300
1398		if ((m_old_tileflags1&IMPORTANT_DIRTY_TILEFLAG_MASK)!=(tileflags1&IMPORTANT_DIRTY_TILEFLAG_MASK))
1399		{
1400		hng64_mark_all_tiles_dirty(this, 1);
1401		m_old_tileflags1 = tileflags1;
1402		}
1403	1301
1404		if ((m_old_tileflags2&IMPORTANT_DIRTY_TILEFLAG_MASK)!=(tileflags2&IMPORTANT_DIRTY_TILEFLAG_MASK))
1405		{
1406		hng64_mark_all_tiles_dirty(this, 2);
1407		m_old_tileflags2 = tileflags2;
1408		}
1409
1410		if ((m_old_tileflags3&IMPORTANT_DIRTY_TILEFLAG_MASK)!=(tileflags3&IMPORTANT_DIRTY_TILEFLAG_MASK))
1411		{
1412		hng64_mark_all_tiles_dirty(this, 3);
1413		m_old_tileflags3 = tileflags3;
1414		}
1415
1416		// mark all frames as dirty if for some reason we don't trust the above code
1417		//hng64_mark_all_tiles_dirty(this, 0);
1418		//hng64_mark_all_tiles_dirty(this, 1);
1419		//hng64_mark_all_tiles_dirty(this, 2);
1420		//hng64_mark_all_tiles_dirty(this, 3);
1421
1422	1302	hng64_drawtilemap(screen,bitmap,cliprect, 3);
1423	1303	hng64_drawtilemap(screen,bitmap,cliprect, 2);
1424	1304	hng64_drawtilemap(screen,bitmap,cliprect, 1);
r244680	r244681
1450	1330	draw_sprites(screen, bitmap,cliprect);
1451	1331
1452	1332	if(0)
1453		transition_control(~~machine(),~~ bitmap, cliprect);
	1333	transition_control(bitmap, cliprect);
1454	1334
1455	1335	if (0)
1456	1336	popmessage("%08x %08x %08x %08x %08x", m_spriteregs[0], m_spriteregs[1], m_spriteregs[2], m_spriteregs[3], m_spriteregs[4]);
1457	1337
1458		if (0)
1459		popmessage("%08x %08x TR(%04x %04x %04x %04x) SB(%04x %04x %04x %04x) %08x %08x %08x %08x %08x AA(%08x %08x) %08x %08x",
	1338	if (1)
	1339	popmessage("%08x %08x TR(%04x %04x %04x %04x) SB(%04x %04x %04x %04x) %08x %08x %08x %08x %08x AA(%08x %08x) %08x",
1460	1340	hng64_videoregs[0x00],
1461	1341	hng64_videoregs[0x01],
1462		(hng64_videoregs[0x02]>>16)&0xf9ff, // ---- bits we're sure about are masked out
1463		(hng64_videoregs[0x02]>>0)&0xf9ff, // ss64_2 debug mode indicates that 0x0040 is enable!
1464		(hng64_videoregs[0x03]>>16)&0xf9ff, // buriki agrees (debug data on text layer) xrally agress (pink layer)
1465		(hng64_videoregs[0x03]>>0)&0xf9ff, // fatal fury doesn't (all backgrounds have it set) joy
	1342	(hng64_videoregs[0x02]>>16)&0x01ff, // ---- bits we're sure about are masked out
	1343	(hng64_videoregs[0x02]>>0)&0x01ff, // ss64_2 debug mode indicates that 0x0040 is enable!
	1344	(hng64_videoregs[0x03]>>16)&0x01ff, // buriki agrees (debug data on text layer) xrally agress (pink layer)
	1345	(hng64_videoregs[0x03]>>0)&0x01ff, // fatal fury doesn't (all backgrounds have it set) joy
1466	1346	(hng64_videoregs[0x04]>>16)&0xffff,
1467	1347	(hng64_videoregs[0x04]>>0)&0xffff,
1468	1348	(hng64_videoregs[0x05]>>16)&0xffff,
r244680	r244681
1474	1354	hng64_videoregs[0x0a],
1475	1355	hng64_videoregs[0x0b],
1476	1356	hng64_videoregs[0x0c],
1477		hng64_videoregs[0x0d],
1478		hng64_videoregs[0x0e]);
	1357	hng64_videoregs[0x0d]);
1479	1358
1480	1359	if (0)
1481	1360	popmessage("3D: %08x %08x %08x %08x : %08x %08x %08x %08x : %08x %08x %08x %08x",
r244680	r244681
1547	1426
1548	1427	m_old_animmask = -1;
1549	1428	m_old_animbits = -1;
1550		m_old_tileflags0 = -1;
1551		m_old_tileflags1 = -1;
1552		m_old_tileflags2 = -1;
1553		m_old_tileflags3 = -1;
	1429	m_old_tileflags[0] = -1;
	1430	m_old_tileflags[1] = -1;
	1431	m_old_tileflags[2] = -1;
	1432	m_old_tileflags[3] = -1;
1554	1433
1555		m_tilemap0_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile0_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
1556		m_tilemap0_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile0_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
1557		m_tilemap0_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile0_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
	1434	m_tilemap[0].m_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile0_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
	1435	m_tilemap[0].m_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile0_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
	1436	m_tilemap[0].m_tilemap_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile0_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
1558	1437
1559		m_tilemap1_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile1_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
1560		m_tilemap1_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile1_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
1561		m_tilemap1_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile1_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
	1438	m_tilemap[1].m_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile1_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
	1439	m_tilemap[1].m_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile1_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
	1440	m_tilemap[1].m_tilemap_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile1_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
1562	1441
1563		m_tilemap2_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile2_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
1564		m_tilemap2_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile2_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
1565		m_tilemap2_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile2_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
	1442	m_tilemap[2].m_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile2_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
	1443	m_tilemap[2].m_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile2_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
	1444	m_tilemap[2].m_tilemap_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile2_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
1566	1445
1567		m_tilemap3_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile3_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
1568		m_tilemap3_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile3_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
1569		m_tilemap3_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile3_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
	1446	m_tilemap[3].m_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile3_8x8_info),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 128); /* 128x128x4 = 0x10000 */
	1447	m_tilemap[3].m_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile3_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 128, 128); /* 128x128x4 = 0x10000 */
	1448	m_tilemap[3].m_tilemap_16x16_alt = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(hng64_state::get_hng64_tile3_16x16_info),this), TILEMAP_SCAN_ROWS, 16, 16, 256, 64); /* 128x128x4 = 0x10000 */
1570	1449
1571		m_tilemap0_8x8->set_transparent_pen(0);
1572		m_tilemap0_16x16->set_transparent_pen(0);
1573		m_tilemap0_16x16_alt->set_transparent_pen(0);
	1450	for (int i = 0; i < 4; i++)
	1451	{
	1452	m_tilemap[i].m_tilemap_8x8->set_transparent_pen(0);
	1453	m_tilemap[i].m_tilemap_16x16->set_transparent_pen(0);
	1454	m_tilemap[i].m_tilemap_16x16_alt->set_transparent_pen(0);
	1455	}
1574	1456
1575		m_tilemap1_8x8->set_transparent_pen(0);
1576		m_tilemap1_16x16->set_transparent_pen(0);
1577		m_tilemap1_16x16_alt->set_transparent_pen(0);
1578
1579		m_tilemap2_8x8->set_transparent_pen(0);
1580		m_tilemap2_16x16->set_transparent_pen(0);
1581		m_tilemap2_16x16_alt->set_transparent_pen(0);
1582
1583		m_tilemap3_8x8->set_transparent_pen(0);
1584		m_tilemap3_16x16->set_transparent_pen(0);
1585		m_tilemap3_16x16_alt->set_transparent_pen(0);
1586
1587	1457	// Debug switch, turn on / off additive blending on a per-tilemap basis
1588	1458	m_additive_tilemap_debug = 0;
1589	1459
r244680	r244681
1634	1504	static void vecmatmul4(float product, const float a, const float *b);
1635	1505	static float vecDotProduct(const float a, const float b);
1636	1506	static void normalize(float* x);
1637
1638	1507	static void performFrustumClip(struct polygon *p);
1639		static void drawShaded(running_machine &machine, struct polygon *p);
1640		//static void plot(running_machine &machine, INT32 x, INT32 y, UINT32 color);
1641		//static void drawline2d(running_machine &machine, INT32 x0, INT32 y0, INT32 x1, INT32 y1, UINT32 color);
1642		//static void DrawWireframe(running_machine &machine, struct polygon *p);
1643
1644	1508	static float uToF(UINT16 input);
1645	1509
1646	1510
r244680	r244681
1678	1542
1679	1543	// Operation 0001
1680	1544	// Camera transformation.
1681		~~static~~ void setCameraTransformation(~~hng64_state state,~~ const UINT16 packet)
	1545	void hng64_state::setCameraTransformation(const UINT16* packet)
1682	1546	{
1683		float *cameraMatrix = ~~state->~~m_cameraMatrix;
	1547	float *cameraMatrix = m_cameraMatrix;
1684	1548
1685	1549	/*//////////////
1686	1550	// PACKET FORMAT
r244680	r244681
1725	1589
1726	1590	// Operation 0010
1727	1591	// Lighting information
1728		~~static~~ void ~~setLig~~hting~~(hng~~64_state state, const UINT16 packet)
	1592	void hng64_state::setLighting(const UINT16* packet)
1729	1593	{
1730		float *lightVector = ~~state->~~m_lightVector;
	1594	float *lightVector = m_lightVector;
1731	1595
1732	1596	/*//////////////
1733	1597	// PACKET FORMAT
r244680	r244681
1754	1618	lightVector[0] = uToF(packet[3]);
1755	1619	lightVector[1] = uToF(packet[4]);
1756	1620	lightVector[2] = uToF(packet[5]);
1757		~~state->~~m_lightStrength = uToF(packet[9]);
	1621	m_lightStrength = uToF(packet[9]);
1758	1622	}
1759	1623
1760	1624	// Operation 0011
1761	1625	// Palette / Model flags?
1762		~~static~~ void ~~set3dFlags(~~hng64_state sta~~te,~~ const UINT16 packet)
	1626	void hng64_state::set3dFlags(const UINT16* packet)
1763	1627	{
1764	1628	/*//////////////
1765	1629	// PACKET FORMAT
r244680	r244681
1780	1644	// [14] - ???? ... ? '' ''
1781	1645	// [15] - ???? ... ? '' ''
1782	1646	////////////*/
1783		~~state->~~m_paletteState3d = (packet[8] & 0xff00) >> 8;
	1647	m_paletteState3d = (packet[8] & 0xff00) >> 8;
1784	1648	}
1785	1649
1786	1650	// Operation 0012
1787	1651	// Projection Matrix.
1788		~~static~~ void setCameraProjectionMatrix(~~hng64_state state,~~ const UINT16 packet)
	1652	void hng64_state::setCameraProjectionMatrix(const UINT16* packet)
1789	1653	{
1790		float *projectionMatrix = ~~state->~~m_projectionMatrix;
	1654	float *projectionMatrix = m_projectionMatrix;
1791	1655
1792	1656	/*//////////////
1793	1657	// PACKET FORMAT
r244680	r244681
1843	1707
1844	1708	// Operation 0100
1845	1709	// Polygon rasterization.
1846		~~static~~ void recoverPolygonBlock(~~running_machine& machine,~~ const UINT16* packet, struct polygon* polys, int* numPolys)
	1710	void hng64_state::recoverPolygonBlock(const UINT16* packet, struct polygon* polys, int* numPolys)
1847	1711	{
1848	1712	/*//////////////
1849	1713	// PACKET FORMAT
r244680	r244681
1880	1744	// [15] - xxxx ... Transformation matrix
1881	1745	////////////*/
1882	1746
1883		hng64_state *state = machine.driver_data<hng64_state>();
1884	1747	UINT32 size[4];
1885	1748	UINT32 address[4];
1886	1749	UINT32 megaOffset;
r244680	r244681
1894	1757	setIdentity(objectMatrix);
1895	1758
1896	1759	struct polygon lastPoly = { 0 };
1897		const rectangle &visarea = m~~achine.first~~_screen()->visible_area();
	1760	const rectangle &visarea = m_screen->visible_area();
1898	1761
1899	1762	/////////////////
1900	1763	// HEADER INFO //
r244680	r244681
1950	1813	//////////////////////////////////////////////*/
1951	1814
1952	1815	// 3d ROM Offset
1953		UINT16* threeDRoms = (UINT16*)(m~~achin~~e~~.root_device().~~memregion("verts")->base());
	1816	UINT16* threeDRoms = (UINT16*)memregion("verts")->base();
1954	1817	UINT32 threeDOffset = (((UINT32)packet[2]) << 16) \| ((UINT32)packet[3]);
1955	1818	UINT16* threeDPointer = &threeDRoms[threeDOffset * 3];
1956	1819
1957		if (threeDOffset >= m~~achine.root_device().m~~emregion("verts")->bytes())
	1820	if (threeDOffset >= memregion("verts")->bytes())
1958	1821	{
1959	1822	printf("Strange geometry packet: (ignoring)\n");
1960	1823	printPacket(packet, 1);
r244680	r244681
2079	1942	/* FIXME: This isn't correct.
2080	1943	Buriki & Xrally need this line. Roads Edge needs it removed.
2081	1944	So instead we're looking for a bit that is on for XRally & Buriki, but noone else. */
2082		if (~~state->~~m_3dregs[0x00/4] & 0x2000)
	1945	if (m_3dregs[0x00/4] & 0x2000)
2083	1946	{
2084		if (strcmp(machine.basename(), "roadedge"))
	1947	if (strcmp(machine().basename(), "roadedge"))
2085	1948	polys[*numPolys].palOffset += 0x800;
2086	1949	}
2087	1950
r244680	r244681
2095	1958	// Apply the dynamic palette offset if its flag is set, otherwise stick with the fixed one
2096	1959	if ((packet[1] & 0x0100))
2097	1960	{
2098		explicitPaletteValue1 = ~~state->~~m_paletteState3d * 0x80;
	1961	explicitPaletteValue1 = m_paletteState3d * 0x80;
2099	1962	explicitPaletteValue2 = 0; // This is probably hiding somewhere in operation 0011
2100	1963	}
2101	1964
r244680	r244681
2289	2152	////////////////////////////////////
2290	2153	// Perform the world transformations...
2291	2154	// !! Can eliminate this step with a matrix stack (maybe necessary?) !!
2292		setIdentity(state->m_modelViewMatrix);
2293		if (state->m_mcu_type != SAMSHO_MCU)
	2155	setIdentity(m_modelViewMatrix);
	2156	if (m_mcu_type != SAMSHO_MCU)
2294	2157	{
2295	2158	// The sams64 games transform the geometry in front of a stationary camera.
2296	2159	// This is fine in sams64_2, since it never calls the 'camera transformation' function
2297	2160	// (thus using the identity matrix for this transform), but sams64 calls the
2298	2161	// camera transformation function with rotation values.
2299	2162	// It remains to be seen what those might do...
2300		matmul4(~~state->~~m_modelViewMatrix, ~~state->~~m_modelViewMatrix, ~~state->~~m_cameraMatrix);
	2163	matmul4(m_modelViewMatrix, m_modelViewMatrix, m_cameraMatrix);
2301	2164	}
2302		matmul4(~~state->~~m_modelViewMatrix, ~~state->~~m_modelViewMatrix, objectMatrix);
	2165	matmul4(m_modelViewMatrix, m_modelViewMatrix, objectMatrix);
2303	2166
2304	2167	// LIGHTING
2305		if (packet[1] & 0x0008 && ~~state->~~m_lightStrength > 0.0f)
	2168	if (packet[1] & 0x0008 && m_lightStrength > 0.0f)
2306	2169	{
2307	2170	for (int v = 0; v < 3; v++)
2308	2171	{
2309	2172	float transformedNormal[4];
2310	2173	vecmatmul4(transformedNormal, objectMatrix, polys[*numPolys].vert[v].normal);
2311	2174	normalize(transformedNormal);
2312		normalize(~~state->~~m_lightVector);
	2175	normalize(m_lightVector);
2313	2176
2314		float intensity = vecDotProduct(transformedNormal, ~~state->~~m_lightVector) * -1.0f;
	2177	float intensity = vecDotProduct(transformedNormal, m_lightVector) * -1.0f;
2315	2178	intensity = (intensity <= 0.0f) ? (0.0f) : (intensity);
2316		intensity = ~~state->~~m_lightStrength 128.0f; // Turns 0x0100 into 1.0
	2179	intensity = m_lightStrength 128.0f; // Turns 0x0100 into 1.0
2317	2180	intensity *= 128.0; // Maps intensity to the range [0.0, 2.0]
2318	2181	if (intensity >= 255.0f) intensity = 255.0f;
2319	2182
r244680	r244681
2356	2219
2357	2220
2358	2221	// BEHIND-THE-CAMERA CULL //
2359		vecmatmul4(cullRay, ~~state->~~m_modelViewMatrix, polys[*numPolys].vert[0].worldCoords);
	2222	vecmatmul4(cullRay, m_modelViewMatrix, polys[*numPolys].vert[0].worldCoords);
2360	2223	if (cullRay[2] > 0.0f) // Camera is pointing down -Z
2361	2224	{
2362	2225	polys[*numPolys].visible = 0;
r244680	r244681
2369	2232	for (int m = 0; m < polys[*numPolys].n; m++)
2370	2233	{
2371	2234	// Transform and project the vertex into pre-divided homogeneous coordinates...
2372		vecmatmul4(eyeCoords, state->m_modelViewMatrix, polys[*numPolys].vert[m].worldCoords);
2373		vecmatmul4(polys[*numPolys].vert[m].clipCoords, state->m_projectionMatrix, eyeCoords);
	2235	vecmatmul4(eyeCoords, m_modelViewMatrix, polys[*numPolys].vert[m].worldCoords);
	2236	vecmatmul4(polys[*numPolys].vert[m].clipCoords, m_projectionMatrix, eyeCoords);
2374	2237	}
2375	2238
2376	2239	if (polys[*numPolys].visible)
r244680	r244681
2410	2273	}
2411	2274	}
2412	2275
2413		void hng64_command3d(~~running_machine& machine,~~ const UINT16* packet)
	2276	void hng64_state::hng64_command3d(const UINT16* packet)
2414	2277	{
2415		hng64_state *state = machine.driver_data<hng64_state>();
2416	2278
2417	2279	/* A temporary place to put some polygons. This will optimize away if the compiler's any good. */
2418	2280	int numPolys = 0;
2419	2281	dynamic_array<polygon> polys(1024*5);
2420	2282
2421		//printf("packet type : %04x %04x\|%04x %04x\|%04x %04x\|%04x %04x\n", packet[0],packet[1],packet[2],packet[3],packet[4],packet[5],packet[6],packet[7]);
	2283	//printf("packet type : %04x %04x\|%04x %04x\|%04x %04x\|%04x %04x \| %04x %04x %04x %04x %04x %04x %04x %04x\n", packet[0],packet[1],packet[2],packet[3],packet[4],packet[5],packet[6],packet[7], packet[8], packet[9], packet[10], packet[11], packet[12], packet[13], packet[14], packet[15]);
	2284
2422	2285	switch (packet[0])
2423	2286	{
2424	2287	case 0x0000: // Appears to be a NOP.
2425	2288	break;
2426	2289
2427	2290	case 0x0001: // Camera transformation.
2428		setCameraTransformation(~~state,~~ packet);
	2291	setCameraTransformation(packet);
2429	2292	break;
2430	2293
2431	2294	case 0x0010: // Lighting information.
2432	2295	//if (packet[9]) printPacket(packet, 1);
2433		setLighting(~~state,~~ packet);
	2296	setLighting(packet);
2434	2297	break;
2435	2298
2436	2299	case 0x0011: // Palette / Model flags?
2437	2300	//printPacket(packet, 1); printf("\n");
2438		set3dFlags(~~state,~~ packet);
	2301	set3dFlags(packet);
2439	2302	break;
2440	2303
2441	2304	case 0x0012: // Projection Matrix
2442	2305	//printPacket(packet, 1);
2443		setCameraProjectionMatrix(~~state,~~ packet);
	2306	setCameraProjectionMatrix(packet);
2444	2307	break;
2445	2308
2446	2309	case 0x0100:
2447	2310	case 0x0101: // Geometry with full transformations
2448	2311	// HACK. Masks out a piece of geo bbust2's drawShaded() crashes on.
2449		if (packet[2] == 0x0003 && packet[3] == 0x8f37 && ~~state->~~m_mcu_type == SHOOT_MCU)
	2312	if (packet[2] == 0x0003 && packet[3] == 0x8f37 && m_mcu_type == SHOOT_MCU)
2450	2313	break;
2451	2314
2452		recoverPolygonBlock(~~machine,~~ packet, polys, &numPolys);
	2315	recoverPolygonBlock( packet, polys, &numPolys);
2453	2316	break;
2454	2317
2455	2318	case 0x0102: // Geometry with only translation
r244680	r244681
2469	2332	miniPacket[7] = 0x7fff;
2470	2333	miniPacket[11] = 0x7fff;
2471	2334	miniPacket[15] = 0x7fff;
2472		recoverPolygonBlock(~~machine,~~ miniPacket, polys, &numPolys);
	2335	recoverPolygonBlock( miniPacket, polys, &numPolys);
2473	2336
2474	2337	memset(miniPacket, 0, sizeof(UINT16)*16);
2475	2338	for (int i = 0; i < 7; i++) miniPacket[i] = packet[i+8];
	2339	for (int i = 0; i < 7; i++) miniPacket[i] = packet[i+8];
2476	2340	miniPacket[7] = 0x7fff;
2477	2341	miniPacket[11] = 0x7fff;
2478	2342	miniPacket[15] = 0x7fff;
2479		recoverPolygonBlock(~~machine,~~ miniPacket, polys, &numPolys);
	2343	recoverPolygonBlock( miniPacket, polys, &numPolys);
2480	2344	break;
2481	2345
2482	2346	case 0x1000: // Unknown: Some sort of global flags?
r244680	r244681
2497	2361	{
2498	2362	if (polys[i].visible)
2499	2363	{
2500		//DrawWireframe(machine, &polys[i]);
2501		drawShaded(machine, &polys[i]);
	2364	//DrawWireframe( &polys[i]);
	2365	drawShaded( &polys[i]);
2502	2366	}
2503	2367	}
2504	2368	}
r244680	r244681
2784	2648	// wireframe rendering //
2785	2649	/////////////////////////
2786	2650	#ifdef UNUSED_FUNCTION
2787		static void plot(~~running_machine &machine,~~ INT32 x, INT32 y, UINT32 color)
	2651	static void plot( INT32 x, INT32 y, UINT32 color)
2788	2652	{
2789	2653	UINT32* cb = &(colorBuffer3d[(y * machine.first_screen()->visible_area().max_x) + x]);
2790	2654	*cb = color;
2791	2655	}
2792	2656
2793	2657	// Stolen from http://en.wikipedia.org/wiki/Bresenham's_line_algorithm (no copyright denoted) - the non-optimized version
2794		static void drawline2d(~~running_machine &machine,~~ INT32 x0, INT32 y0, INT32 x1, INT32 y1, UINT32 color)
	2658	static void drawline2d( INT32 x0, INT32 y0, INT32 x1, INT32 y1, UINT32 color)
2795	2659	{
2796	2660	#define SWAP(a,b) tmpswap = a; a = b; b = tmpswap;
2797	2661
r244680	r244681
2829	2693	{
2830	2694	if (steep)
2831	2695	{
2832		plot(~~machine,~~ x0, y0, color);
	2696	plot( x0, y0, color);
2833	2697	}
2834	2698	else
2835	2699	{
2836		plot(~~machine,~~ y0, x0, color);
	2700	plot( y0, x0, color);
2837	2701	}
2838	2702	while (e >= 0)
2839	2703	{
r244680	r244681
2847	2711	#undef SWAP
2848	2712	}
2849	2713
2850		static void DrawWireframe(~~running_machine &machine,~~ struct polygon *p)
	2714	static void DrawWireframe( struct polygon *p)
2851	2715	{
2852	2716	int j;
2853	2717	for (j = 0; j < p->n; j++)
r244680	r244681
2855	2719	// osd_printf_debug("now drawing : %f %f %f, %f %f %f\n", p->vert[j].clipCoords[0], p->vert[j].clipCoords[1], p->vert[j].clipCoords[2], p->vert[(j+1)%p->n].clipCoords[0], p->vert[(j+1)%p->n].clipCoords[1], p->vert[(j+1)%p->n].clipCoords[2]);
2856	2720	// osd_printf_debug("%f %f %f %f\n", p->vert[j].clipCoords[0], p->vert[j].clipCoords[1], p->vert[(j+1)%p->n].clipCoords[0], p->vert[(j+1)%p->n].clipCoords[1]);
2857	2721	UINT32 color = rgb_t((UINT8)255, (UINT8)255, (UINT8)0, (UINT8)0);
2858		drawline2d(~~machine,~~ p->vert[j].clipCoords[0], p->vert[j].clipCoords[1], p->vert[(j+1)%p->n].clipCoords[0], p->vert[(j+1)%p->n].clipCoords[1], color);
	2722	drawline2d( p->vert[j].clipCoords[0], p->vert[j].clipCoords[1], p->vert[(j+1)%p->n].clipCoords[0], p->vert[(j+1)%p->n].clipCoords[1], color);
2859	2723	}
2860	2724
2861	2725	// SHOWS THE CLIPPING //
r244680	r244681
2870	2734	}
2871	2735	#endif
2872	2736
2873		///////////////////////
2874		// polygon rendering //
2875		///////////////////////
2876	2737
2877		struct polygonRasterOptions
2878		{
2879		UINT8 texType;
2880		UINT8 texIndex;
2881		UINT8 texPageSmall;
2882		UINT8 texPageHorizOffset;
2883		UINT8 texPageVertOffset;
2884		int palOffset;
2885		int palPageSize;
2886		int debugColor;
2887		};
2888
2889	2738	/*********************************************************************/
2890	2739	/ FillSmoothTexPCHorizontalLine /
2891	2740	/ Input: Color Buffer (framebuffer), depth buffer, width and /
r244680	r244681
2895	2744	/ /
2896	2745	/ Output: none /
2897	2746	/*********************************************************************/
2898		~~INLINE~~ void FillSmoothTexPCHorizontalLine(~~running_machine &machine,~~
	2747	inline void hng64_state::FillSmoothTexPCHorizontalLine(
2899	2748	const polygonRasterOptions& prOptions,
2900	2749	int x_start, int x_end, int y, float z_start, float z_delta,
2901	2750	float w_start, float w_delta, float r_start, float r_delta,
2902	2751	float g_start, float g_delta, float b_start, float b_delta,
2903	2752	float s_start, float s_delta, float t_start, float t_delta)
2904	2753	{
2905		hng64_state *state = machine.driver_data<hng64_state>();
2906		float* db = &(state->m_depthBuffer3d[(y * machine.first_screen()->visible_area().max_x) + x_start]);
2907		UINT32* cb = &(state->m_colorBuffer3d[(y * machine.first_screen()->visible_area().max_x) + x_start]);
	2754	float* db = &(m_depthBuffer3d[(y * m_screen->visible_area().max_x) + x_start]);
	2755	UINT32* cb = &(m_colorBuffer3d[(y * m_screen->visible_area().max_x) + x_start]);
2908	2756
2909	2757	UINT8 paletteEntry = 0;
2910	2758	float t_coord, s_coord;
2911		const UINT8 *gfx = ~~state->~~memregion("textures")->base();
	2759	const UINT8 *gfx = memregion("textures")->base();
2912	2760	const UINT8 textureOffset = &gfx[prOptions.texIndex 1024 * 1024];
2913	2761
2914	2762	for (; x_start <= x_end; x_start++)
r244680	r244681
2970	2818	{
2971	2819	// The color out of the texture
2972	2820	paletteEntry %= prOptions.palPageSize;
2973		rgb_t color = ~~state->~~m_palette->pen(prOptions.palOffset + paletteEntry);
	2821	rgb_t color = m_palette->pen(prOptions.palOffset + paletteEntry);
2974	2822
2975	2823	// Apply the lighting
2976	2824	float rIntensity = (r_start/w_start) / 255.0f;
r244680	r244681
3038	2886	// nearest and bilinear filtering: Filtering={0,1}
3039	2887	// replace and modulate application modes: Function={0,1}
3040	2888	//---------------------------------------------------------------------------
3041		~~static~~ void RasterizeTriangle_SMOOTH_TEX_PC(~~running_machine &machine,~~
	2889	void hng64_state::RasterizeTriangle_SMOOTH_TEX_PC(
3042	2890	float A[4], float B[4], float C[4],
3043	2891	float Ca[3], float Cb[3], float Cc[3], // PER-VERTEX RGB COLORS
3044	2892	float Ta[2], float Tb[2], float Tc[2], // PER-VERTEX (S,T) TEX-COORDS
r244680	r244681
3232	3080
3233	3081	// Pass the horizontal line to the filler, this could be put in the routine
3234	3082	// then interpolate for the next values of x and z
3235		FillSmoothTexPCHorizontalLine(~~machine,~~ prOptions,
	3083	FillSmoothTexPCHorizontalLine( prOptions,
3236	3084	x_start, x_end, y_min, z_interp_x, z_delta_x, w_interp_x, w_delta_x,
3237	3085	r_interp_x, r_delta_x, g_interp_x, g_delta_x, b_interp_x, b_delta_x,
3238	3086	s_interp_x, s_delta_x, t_interp_x, t_delta_x);
r244680	r244681
3311	3159
3312	3160	// Pass the horizontal line to the filler, this could be put in the routine
3313	3161	// then interpolate for the next values of x and z
3314		FillSmoothTexPCHorizontalLine(~~machine,~~ prOptions,
	3162	FillSmoothTexPCHorizontalLine( prOptions,
3315	3163	x_start, x_end, y_mid, z_interp_x, z_delta_x, w_interp_x, w_delta_x,
3316	3164	r_interp_x, r_delta_x, g_interp_x, g_delta_x, b_interp_x, b_delta_x,
3317	3165	s_interp_x, s_delta_x, t_interp_x, t_delta_x);
r244680	r244681
3326	3174	}
3327	3175	}
3328	3176
3329		~~static~~ void drawShaded(~~running_machine &machine,~~ struct polygon *p)
	3177	void hng64_state::drawShaded( struct polygon *p)
3330	3178	{
3331	3179	// The perspective-correct texture divide...
3332	3180	// !!! There is a very good chance the HNG64 hardware does not do perspective-correct texture-mapping !!!
r244680	r244681
3354	3202
3355	3203	for (j = 1; j < p->n-1; j++)
3356	3204	{
3357		RasterizeTriangle_SMOOTH_TEX_PC(~~machine,~~
	3205	RasterizeTriangle_SMOOTH_TEX_PC(
3358	3206	p->vert[0].clipCoords, p->vert[j].clipCoords, p->vert[j+1].clipCoords,
3359	3207	p->vert[0].light, p->vert[j].light, p->vert[j+1].light,
3360	3208	p->vert[0].texCoords, p->vert[j].texCoords, p->vert[j+1].texCoords,

trunk/src/mess/audio/gamate.c
r244680	r244681
1	1	/***************************************************************************
2	2	gamate sound hardware
3	3
4		PeT mess@utanet.at
	4	PeT mess@utanet.at 2015
5	5	***************************************************************************/
6	6
7	7	#include "emu.h"
8	8	#include "includes/gamate.h"
	9	#include "ui/ui.h"
9	10
10	11
	12	enum { ClockDelay=32 };
	13
11	14	// device type definition
12	15	const device_type GAMATE_SND = &device_creator<gamate_sound_device>;
13	16
14
	17	const int gamate_sound_device::DAConverter[]={ 0, 3, 7, 13, 23, 41, 75, 137, 249, 453, 825, 1499, 2726, 4956, 9011, 16383 }; // (*.55) on the real below index 8 bareless measureable
	18	const UINT8 Mask[]={ 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0x1f, 0x3f, 0x1f, 0x1f, 0x1f, 0xff, 0xff, 0xf };
	19	const int EnvelopeVolumes[]={ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
15	20	//**************************************************************************
16	21	// LIVE DEVICE
17	22	//**************************************************************************
r244680	r244681
27	32	{
28	33	}
29	34
30
31	35	//-------------------------------------------------
32	36	// device_start - device-specific startup
33	37	//-------------------------------------------------
r244680	r244681
35	39	void gamate_sound_device::device_start()
36	40	{
37	41	// bind callbacks
38		// m_irq_cb.bind_relative_to(*owner());
	42	// m_irq_cb.bind_relative_to(*owner());
39	43
40	44	memset(m_channels, 0, sizeof(m_channels));
41	45	memset(reg, 0, sizeof(reg));
r244680	r244681
52	56	{
53	57	stream_sample_t left=outputs[0], right=outputs[1];
54	58	int i, j;
55		GAMATE_CHANNEL *channel;
56
	59	Tone *channel;
	60
57	61	for (i = 0; i < samples; i++, left++, right++)
58	62	{
	63	noise.pos += noise.step;
	64	while (noise.pos >= 1.0) {
	65	// guess (white noise register taken from supervision)
	66	noise.level = noise.state & 0x40 ? 1 : 0;
	67	bool b1 = (noise.state & 0x40) != 0, b2 = (noise.state & 0x20) != 0;
	68	noise.state=(noise.state<<1)+(b1!=b2?1:0);
	69	noise.pos -= 1;
	70	}
	71
	72	envelope.pos += envelope.step;
	73	while (envelope.pos >= 1.0) {
	74	envelope.pos -= 1;
	75	envelope.index++;
	76	switch (envelope.control) {
	77	case 0: case 1: case 2: case 3:
	78	case 4: case 5: case 6: case 7:
	79	case 8: case 9: case 0xb:
	80	case 0xd: case 0xf:
	81	if (envelope.index>=ARRAY_LENGTH(EnvelopeVolumes)/2) {
	82	envelope.index=0;
	83	envelope.first=false;
	84	}
	85	break;
	86	default:
	87	if (envelope.index>=ARRAY_LENGTH(EnvelopeVolumes)) {
	88	envelope.index=0;
	89	envelope.first=false;
	90	}
	91	break;
	92	}
	93
	94	}
	95
59	96	*left = 0;
60	97	*right = 0;
61	98	for (channel=m_channels, j=0; j<ARRAY_LENGTH(m_channels); j++, channel++)
62	99	{
63	100	if (channel->size != 0)
64	101	{
65		if (channel->on)//\|\|channel->count)
66		{
67		int on = FALSE;
68		on = channel->pos <= channel->size / 2;
69		{
70		INT16 s = on ? channel->volume << 8 : 0;
71		if (j == 0)
72		*right += s;
73		else if (j==1)
74		*left += s;
75		else {
76		*right += s;
77		*left += s;
78		}
79		}
	102	channel->level= channel->pos <= channel->size / 2;
	103	bool l= channel->full_cycle? true: channel->level;
	104	if (!channel->tone) l= l && noise.level;
	105	int volume=0;
	106	if (l) {
	107	if (channel->envelope_on) {
	108	switch (envelope.control) {
	109	case 0: case 1: case 2: case 3:
	110	case 0x9: // one time falling, low
	111	if (envelope.first && channel->level) volume=0xf-EnvelopeVolumes[envelope.index];
	112	break;
	113	case 4: case 5: case 6: case 7:
	114	case 0xf: // one time rising, low
	115	if (envelope.first && channel->level) volume=EnvelopeVolumes[envelope.index];
	116	break;
	117	case 8: // falling
	118	if (channel->level) volume=0xf-EnvelopeVolumes[envelope.index];
	119	break;
	120	case 0xa: // rising, falling
	121	if (channel->level) volume=EnvelopeVolumes[envelope.index];
	122	break;
	123	case 0xb: // one time falling, high
	124	if (channel->level) volume=envelope.first? 0xf-EnvelopeVolumes[envelope.index]: 0xf;
	125	break;
	126	case 0xc: // rising, low
	127	if (channel->level) volume=envelope.index<ARRAY_LENGTH(EnvelopeVolumes)/2? EnvelopeVolumes[envelope.index]: 0;
	128	break;
	129	case 0xd: // one time rising, high
	130	if (channel->level) volume=envelope.first? EnvelopeVolumes[envelope.index]: 0xf;
	131	break;
	132	case 0xe: // falling, rising
	133	if (channel->level) volume=0xf-EnvelopeVolumes[envelope.index];
	134	break;
	135	}
	136	} else {
	137	volume=channel->volume;
	138	}
80	139	}
	140	if (j == Right)
	141	*right += Value2Volume(volume);
	142	else if (j==Left)
	143	*left += Value2Volume(volume);
	144	else {
	145	*right += Value2Volume(volume);
	146	*left += Value2Volume(volume);
	147	}
81	148	channel->pos++;
82	149	if (channel->pos >= channel->size)
83	150	channel->pos = 0;
r244680	r244681
94	161	reg[offset] = data;
95	162	int chan=-1;
96	163
97		switch (offset)
	164	switch (offset&0xf)
98	165	{
99	166	case 0:
100	167	case 1:
r244680	r244681
102	169	case 3:
103	170	case 4:
104	171	case 5:
105		chan=offset/2;
	172	chan=offset/2;
106	173	size = reg[chan2] \| ((reg[chan2+1] & 0xf) << 8);
107	174	if (size)
108	175	{
109		m_channels[chan].size= (int) (machine().sample_rate() * (size ~~<< 5)~~ / machine().device("maincpu")->unscaled_clock());
	176	m_channels[chan].size= (int) (machine().sample_rate() * size*ClockDelay / machine().device("maincpu")->unscaled_clock());
110	177	}
111	178	else
112	179	{
r244680	r244681
115	182	m_channels[chan].pos = 0;
116	183	break;
117	184	case 6:
	185	size=data&0x1f;
	186	if (size==0) size=1;
	187	noise.step= machine().device("maincpu")->unscaled_clock() / (1.0ClockDelaymachine().sample_rate()*size);
	188	break;
118	189	case 7:
	190	m_channels[Right].full_cycle=data&1;
	191	m_channels[Right].tone=data&8;
	192	m_channels[Left].full_cycle=data&2;
	193	m_channels[Left].tone=data&0x10;
	194	m_channels[Both].full_cycle=data&4;
	195	m_channels[Both].tone=data&0x20;
	196	noise.state=1;
	197	noise.pos=0.0;
	198	noise.level=false;
	199	break;
119	200	case 8:
120		chan=offset-6;
121		// m_channels[chan]->on = data & 0x40;
122		// channel->waveform = (data & 0x30) >> 4;
	201	case 9:
	202	case 0xa:
	203	chan=offset-8;
	204	m_channels[chan].envelope_on = data & 0x10; // buggy aussetzer cube up
123	205	m_channels[chan].volume = data & 0xf;
124	206	break;
	207	case 0xb: case 0xc:
	208	size = reg[0xb] \| ((reg[0xc]) << 8);
	209	if (size==0) size=1;
	210	envelope.step= machine().device("maincpu")->unscaled_clock() / (1.0ClockDelaymachine().sample_rate()*size);
	211	break;
	212	case 0xd:
	213	envelope.control=data&0xf;
	214	envelope.pos=0;
	215	envelope.index=0;
	216	envelope.first=true;
	217	break;
	218
125	219	}
126		if (chan!=-1) m_channels[chan].on=m_channels[chan].volume!=0 && m_channels[chan].size>3/* avoid speed loss for unhearable >=23khz*/;
	220	envelope.pos=0; // guess
	221	envelope.index=0;
	222	envelope.first=true;
127	223	}
	224
	225	READ8_MEMBER( gamate_sound_device::device_r )
	226	{
	227	UINT8 data=0;
	228	if ((offset&0xf)<ARRAY_LENGTH(Mask)) data=reg[offset&0xf]&Mask[offset&0xf]; // unused bits set to last write value? in this area
	229	return data;
	230	}

trunk/src/mess/drivers/gamate.c
r244680	r244681
3	3	Peter Wilhelmsen peter.wilhelmsen@gmail.com
4	4	Morten Shearman Kirkegaard morten+gamate@afdelingp.dk
5	5	Juan F??lix Mateos vectrex@hackermesh.org
6		******************************************************************************/
7	6
	7	nmi unknown
	8	cube up audio sometimes missing
	9	bomb blast top status line missing
	10	******************************************************************************/
	11
8	12	#include "emu.h"
9	13	#include "cpu/m6502/m6502.h"
10	14	#include "bus/generic/slot.h"
r244680	r244681
36	40	DECLARE_WRITE8_MEMBER(cart_bankswitch_w);
37	41	DECLARE_READ8_MEMBER(gamate_video_r);
38	42	DECLARE_READ8_MEMBER(gamate_pad_r);
	43	DECLARE_READ8_MEMBER(gamate_nmi_r);
39	44	DECLARE_WRITE8_MEMBER(gamate_video_w);
40	45	DECLARE_READ8_MEMBER(gamate_audio_r);
41	46	DECLARE_WRITE8_MEMBER(gamate_audio_w);
r244680	r244681
51	56
52	57	struct
53	58	{
54		UINT8 reg[8];
55		struct {
56		bool write;
57		bool page2; // else page1
	59	UINT8 reg[8];
	60	struct {
	61	bool page2; // else page1
58	62	UINT8 ypos, xpos/tennis/;
59		UINT8 data[2][0x100][0x20];
60		} bitmap;
61		UINT8 x, y;
	63	UINT8 data[2][0x100][0x20];
	64	} bitmap;
	65	UINT8 x, y;
62	66	bool y_increment;
63	67	} video;
64	68
65	69	struct {
66		bool set;
	70	bool set;
67	71	int bit_shifter;
68	72	UINT8 cartridge_byte;
69	73	UINT16 address; // in reality something more like short local cartridge address offset
70	74	bool unprotected;
71	75	bool failed;
72
	76
73	77	} card_protection;
74	78
75	79	required_device<cpu_device> m_maincpu;
r244680	r244681
80	84	required_shared_ptr<UINT8> m_bios;
81	85	emu_timer *timer1;
82	86	emu_timer *timer2;
83		UINT8 bank_multi;
	87	UINT8 bank_multi;
84	88	};
85	89
86	90	WRITE8_MEMBER( gamate_state::gamate_cart_protection_w )
87	91	{
88		logerror("%.6f protection write %x %x address:%x data:%x shift:%d\n",machine().time().as_double(), offset, data, card_protection.address, card_protection.cartridge_byte, card_protection.bit_shifter);
89
	92	logerror("%.6f protection write %x %x address:%x data:%x shift:%d\n",machine().time().as_double(), offset, data, card_protection.address, card_protection.cartridge_byte, card_protection.bit_shifter);
	93
90	94	switch (offset) {
91	95	case 0:
92	96	card_protection.failed= card_protection.failed \|\| ((card_protection.cartridge_byte&0x80)!=0) != ((data&4)!=0);
r244680	r244681
100	104	}
101	105	READ8_MEMBER( gamate_state::gamate_cart_protection_r )
102	106	{
103		UINT8 ret=1;
104		if (card_protection.bit_shifter==7 && card_protection.unprotected) {
105		ret=m_cart->get_rom_base()[bank_multi*0x4000];
106		} else {
	107
	108	UINT8 ret=1;
	109	if (card_protection.bit_shifter==7 && card_protection.unprotected) {
	110	ret=m_cart->get_rom_base()[bank_multi*0x4000];
	111	} else {
107	112	card_protection.bit_shifter++;
108	113	if (card_protection.bit_shifter==8) {
109	114	card_protection.bit_shifter=0;
r244680	r244681
112	117	}
113	118	ret=(card_protection.cartridge_byte&0x80)?2:0;
114	119	if (card_protection.bit_shifter==7 && !card_protection.failed) { // now protection chip on cartridge activates cartridge chip select on cpu accesses
115		// m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6000, READ8_DELEGATE(gamate_state, gamate_cart_protection_r)); // next time I will try to get this working
	120	// m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6000, READ8_DELEGATE(gamate_state, gamate_cart_protection_r)); // next time I will try to get this working
116	121	}
117	122	card_protection.cartridge_byte<<=1;
118		}
119		logerror("%.6f protection read %x %x address:%x data:%x shift:%d\n",machine().time().as_double(), offset, ret, card_protection.address, card_protection.cartridge_byte, card_protection.bit_shifter);
120		return ret;
	123	}
	124	logerror("%.6f protection read %x %x address:%x data:%x shift:%d\n",machine().time().as_double(), offset, ret, card_protection.address, card_protection.cartridge_byte, card_protection.bit_shifter);
	125	return ret;
121	126	}
122	127
123	128	READ8_MEMBER( gamate_state::protection_r ) { return card_protection.set? 3: 1; } // bits 0 and 1 checked
124	129
125	130	WRITE8_MEMBER( gamate_state::protection_reset )
126	131	{
127		// writes 0x20
128		card_protection.address=0x6005-0x6001;
129		card_protection.bit_shifter=0;
130		card_protection.cartridge_byte=m_cart->get_rom_base()[card_protection.address++];//m_cart_rom[card_protection.address++];
131		card_protection.failed=false;
132		card_protection.unprotected=false;
	132	// writes 0x20
	133	card_protection.address=0x6005-0x6001;
	134	card_protection.bit_shifter=0;
	135	card_protection.cartridge_byte=m_cart->get_rom_base()[card_protection.address++];//m_cart_rom[card_protection.address++];
	136	card_protection.failed=false;
	137	card_protection.unprotected=false;
133	138	}
134	139
135	140	READ8_MEMBER( gamate_state::newer_protection_set )
136	141	{
137		card_protection.set=true;
138		return 0;
	142	card_protection.set=true;
	143	return 0;
139	144	}
140	145
141	146
142	147	WRITE8_MEMBER( gamate_state::gamate_video_w )
143	148	{
144		video.reg[offset]=data;
145		switch (offset) {
146		case 1:
147		if (data&0xf) printf("lcd mode %x\n", data);
148		video.bitmap.write=data&0xc0; // more addressing mode
149		video.y_increment=data&0x40;
150		break;
151		case 2: video.bitmap.xpos=data;break;
152		case 3:
153		if (data>=200) printf("lcd ypos: %x\n", data);
154		video.bitmap.ypos=data;
155		break;
156		case 4: video.bitmap.page2=data&0x80;video.x=data&0x7f;break;
157		case 5: video.y=data;break;
158		case 7:
159		if (video.y>=200)
160		machine().ui().popup_time(2, "bitmap write to x:%x y:%x mode:%x data:%x\n", video.x, video.y, video.reg[1], data);
161		if (video.bitmap.write) {
162		video.bitmap.data[video.bitmap.page2][video.y][video.x]=data;
163		} else {
164		video.bitmap.data[0][video.y][video.x&(ARRAY_LENGTH(video.bitmap.data[0][0])-1)]=data;
165		}
166		if (video.y_increment) video.y++;
167		else video.x++;
168		}
	149	video.reg[offset]=data;
	150	switch (offset) {
	151	case 1:
	152	if (data&0xf) printf("lcd mode %x\n", data);
	153	video.y_increment=data&0x40;
	154	break;
	155	case 2: video.bitmap.xpos=data;break;
	156	case 3:
	157	if (data>=200) printf("lcd ypos: %x\n", data);
	158	video.bitmap.ypos=data;
	159	break;
	160	case 4: video.bitmap.page2=data&0x80;video.x=data&0x1f;break;
	161	case 5: video.y=data;break;
	162	case 7:
	163	video.bitmap.data[video.bitmap.page2][video.y][video.x&(ARRAY_LENGTH(video.bitmap.data[0][0])-1)]=data;
	164	if (video.y_increment) video.y++;
	165	else video.x++; // overruns
	166	}
169	167	}
170	168
171	169	WRITE8_MEMBER( gamate_state::cart_bankswitchmulti_w )
172	170	{
173		bank_multi=data;
174		membank("bankmulti")->set_base(m_cart->get_rom_base()+0x4000*data+1);
	171	bank_multi=data;
	172	membank("bankmulti")->set_base(m_cart->get_rom_base()+0x4000*data+1);
175	173	}
176	174
177	175	WRITE8_MEMBER( gamate_state::cart_bankswitch_w )
r244680	r244681
181	179
182	180	READ8_MEMBER( gamate_state::gamate_video_r )
183	181	{
184		if (offset!=6) return 0;
185		UINT8 data=0;
186		if (video.bitmap.write) {
187		data=video.bitmap.data[video.bitmap.page2][video.y][video.x];
188		} else {
189		data=video.bitmap.data[0][video.y][video.x&(ARRAY_LENGTH(video.bitmap.data[0][0])-1)];
190		}
	182	if (offset!=6) return 0;
	183	UINT8 data=0;
	184	data=video.bitmap.data[video.bitmap.page2][video.y][video.x&(ARRAY_LENGTH(video.bitmap.data[0][0])-1)];
191	185	// if (m_maincpu->pc()<0xf000)
192	186	// machine().ui().popup_time(2, "lcd read x:%x y:%x mode:%x data:%x\n", video.x, video.y, video.reg[1], data);
193		return data;
	187	if (video.y_increment) video.y++;
	188	else video.x++; // overruns?
	189
	190	return data;
194	191	}
195	192
196	193	WRITE8_MEMBER( gamate_state::gamate_audio_w )
197	194	{
198	195	// printf("audio write %x:%x\n", offset, data);//logerror("%.6f %04x audio write %04x %02x\n",machine().time().as_double(),m_maincpu->pc(),offset,data);
199		m_sound->device_w(space, offset, data);
	196	m_sound->device_w(space, offset, data);
200	197	}
201	198
202	199	READ8_MEMBER( gamate_state::gamate_audio_r )
203	200	{
204		// legend of dragon knight
205		// machine().ui().popup_time(2, "%.6f %04x audio read %04x \n",machine().time().as_double(),m_maincpu->pc(),offset);
206		return 0;
	201	UINT8 data=m_sound->device_r(space, offset);
	202	return data;
207	203	}
208	204
209	205
210	206	READ8_MEMBER( gamate_state::gamate_pad_r )
211	207	{
212		UINT8 data=m_io_joy->read();
213		return data;
	208	UINT8 data=m_io_joy->read();
	209	return data;
214	210	}
215	211
	212	READ8_MEMBER( gamate_state::gamate_nmi_r )
	213	{
	214	UINT8 data=0;
	215	machine().ui().popup_time(2, "nmi/4800 read\n");
	216	return data;
	217	}
	218
216	219	static ADDRESS_MAP_START( gamate_mem, AS_PROGRAM, 8, gamate_state )
217		AM_RANGE(0x0000, 0x03ff) AM_RAM
218		AM_RANGE(0x4000, 0x400d) AM_READWRITE(gamate_audio_r, gamate_audio_w)
219		AM_RANGE(0x4400, 0x4400) AM_READ(gamate_pad_r)
220		AM_RANGE(0x5000, 0x5007) AM_READWRITE(gamate_video_r, gamate_video_w)
221		AM_RANGE(0x5800, 0x5800) AM_READ(newer_protection_set)
222		AM_RANGE(0x5900, 0x5900) AM_WRITE(protection_reset)
223		AM_RANGE(0x5a00, 0x5a00) AM_READ(protection_r)
	220	AM_RANGE(0x0000, 0x03ff) AM_RAM
	221	AM_RANGE(0x4000, 0x400d) AM_READWRITE(gamate_audio_r, gamate_audio_w)
	222	AM_RANGE(0x4400, 0x4400) AM_READ(gamate_pad_r)
	223	AM_RANGE(0x4800, 0x4800) AM_READ(gamate_nmi_r)
	224	AM_RANGE(0x5000, 0x5007) AM_READWRITE(gamate_video_r, gamate_video_w)
	225	AM_RANGE(0x5800, 0x5800) AM_READ(newer_protection_set)
	226	AM_RANGE(0x5900, 0x5900) AM_WRITE(protection_reset)
	227	AM_RANGE(0x5a00, 0x5a00) AM_READ(protection_r)
224	228
225		AM_RANGE(0x6001, 0x9fff) AM_READ_BANK("bankmulti")
226		AM_RANGE(0xa000, 0xdfff) AM_READ_BANK("bank")
	229	AM_RANGE(0x6001, 0x9fff) AM_READ_BANK("bankmulti")
	230	AM_RANGE(0xa000, 0xdfff) AM_READ_BANK("bank")
227	231
228	232	AM_RANGE(0x6000, 0x6000) AM_READWRITE(gamate_cart_protection_r, gamate_cart_protection_w)
229	233	AM_RANGE(0x8000, 0x8000) AM_WRITE(cart_bankswitchmulti_w)
230	234	AM_RANGE(0xc000, 0xc000) AM_WRITE(cart_bankswitch_w)
231	235
232		AM_RANGE(0xf000, 0xffff) AM_ROM AM_SHARE("bios")
	236	AM_RANGE(0xf000, 0xffff) AM_ROM AM_SHARE("bios")
233	237	ADDRESS_MAP_END
234	238
235	239
r244680	r244681
245	249	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SELECT) PORT_NAME("Select")
246	250	INPUT_PORTS_END
247	251
248		~~ATTR_UNUSED~~ static const unsigned short gamate_palette[4] =
	252	static const unsigned short gamate_palette[4] =
249	253	{
250	254	0,1,2,3
251	255	};
r244680	r244681
254	258	/* palette in red, green, blue tribles */
255	259	static const unsigned char gamate_colors[4][3] =
256	260	{
257		{ 255,255,255 },
258		{ 0xa0, 0xa0, 0xa0 },
259		{ 0x60, 0x60, 0x60 },
260		{ 0, 0, 0 }
	261	{ 255,255,255 },
	262	{ 0xa0, 0xa0, 0xa0 },
	263	{ 0x60, 0x60, 0x60 },
	264	{ 0, 0, 0 }
261	265	};
262	266
263	267	PALETTE_INIT_MEMBER(gamate_state, gamate)
r244680	r244681
280	284
281	285	UINT32 gamate_state::screen_update_gamate(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
282	286	{
283		int x, y, j;
284		for (y=0;y<152;y++) {
285		for (x=-(video.bitmap.xpos&7), j=0;x<160;x+=8, j++) {
286		UINT8 d1, d2;
287		if (video.bitmap.ypos<200) {
	287	int x, y, j;
	288	for (y=0;y<152;y++) {
	289	for (x=-(video.bitmap.xpos&7), j=0;x<160;x+=8, j++) {
	290	UINT8 d1, d2;
	291	if (video.bitmap.ypos<200) {
288	292	d1=video.bitmap.data[0][(y+video.bitmap.ypos)%200][(j+video.bitmap.xpos/8)&0x1f];
289	293	d2=video.bitmap.data[1][(y+video.bitmap.ypos)%200][(j+video.bitmap.xpos/8)&0x1f];
290		} else if ((video.bitmap.ypos&0xf)<8) { // lcdtest, of course still some registers not known, my gamate doesn't display bottom lines
	294	} else if ((video.bitmap.ypos&0xf)<8) { // lcdtest, of course still some registers not known, my gamate doesn't display bottom lines; most likely problematic 200 warp around hardware! no real usage
291	295	int yi=(y+(video.bitmap.ypos&0xf)-8);
292	296	if (yi<0) yi=video.bitmap.ypos+y; // in this case only 2nd plane used!?, source of first plane?
293	297	d1=video.bitmap.data[0][yi][(j+video.bitmap.xpos/8)&0x1f]; // value of lines bevor 0 chaos
294	298	d2=video.bitmap.data[1][yi][(j+video.bitmap.xpos/8)&0x1f];
295		} else {
	299	} else {
296	300	d1=video.bitmap.data[0][y][(j+video.bitmap.xpos/8)&0x1f];
297		d2=video.bitmap.data[1][y][(j+video.bitmap.xpos/8)&0x1f];
298		}
299		BlitPlane(&bitmap.pix16(y, x+4), d1, d2);
300		BlitPlane(&bitmap.pix16(y, x), d1>>4, d2>>4);
301		}
302		}
303		return 0;
	301	d2=video.bitmap.data[1][y][(j+video.bitmap.xpos/8)&0x1f];
	302	}
	303	BlitPlane(&bitmap.pix16(y, x+4), d1, d2);
	304	BlitPlane(&bitmap.pix16(y, x), d1>>4, d2>>4);
	305	}
	306	}
	307	return 0;
304	308	}
305	309
306	310	DRIVER_INIT_MEMBER(gamate_state,gamate)
r244680	r244681
314	318	void gamate_state::machine_start()
315	319	{
316	320	if (m_cart->exists()) {
317		// m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6000, READ8_DELEGATE(gamate_state, gamate_cart_protection_r));
	321	// m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6000, READ8_DELEGATE(gamate_state, gamate_cart_protection_r));
318	322	membank("bankmulti")->set_base(m_cart->get_rom_base()+1);
319	323	membank("bank")->set_base(m_cart->get_rom_base()+0x4000); // bankswitched games in reality no offset
320	324	}
321		// m_bios[0xdf1]=0xea; m_bios[0xdf2]=0xea; // default bios: $47 protection readback
	325	// m_bios[0xdf1]=0xea; m_bios[0xdf2]=0xea; // default bios: $47 protection readback
322	326	card_protection.set=false;
323	327	bank_multi=0;
324	328	card_protection.unprotected=false;
r244680	r244681
378	382	MCFG_SOUND_ADD("custom", GAMATE_SND, 0)
379	383	MCFG_SOUND_ROUTE(0, "lspeaker", 0.50)
380	384	MCFG_SOUND_ROUTE(1, "rspeaker", 0.50)
381
	385
382	386	MCFG_GENERIC_CARTSLOT_ADD("cartslot", generic_linear_slot, "gamate_cart")
383	387	MCFG_GENERIC_MANDATORY
384	388
r244680	r244681
396	400
397	401
398	402	/* YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY FULLNAME */
399		CONS( 19??, gamate, 0, 0, gamate, gamate, gamate_state, gamate, "Bit Corp", "Gamate", GAME_IMPERFECT_SOUND)
	403	CONS( 19??, gamate, 0, 0, gamate, gamate, gamate_state, gamate, "Bit Corp", "Gamate", 0)
	404
	405

trunk/src/mess/drivers/hh_ucom4.c
r244680	r244681
87	87	DECLARE_INPUT_CHANGED_MEMBER(tmtennis_difficulty_switch);
88	88	DECLARE_MACHINE_RESET(tmtennis);
89	89
	90	void tmpacman_display();
90	91	DECLARE_WRITE8_MEMBER(tmpacman_grid_w);
91	92	DECLARE_WRITE8_MEMBER(tmpacman_plate_w);
92	93	DECLARE_WRITE8_MEMBER(tmpacman_port_e_w);
r244680	r244681
236	237
237	238	WRITE8_MEMBER(hh_ucom4_state::edracula_grid_w)
238	239	{
239		// ~~ports~~ C,D: vfd matrix grid
	240	// C,D: vfd matrix grid
240	241	int shift = (offset - NEC_UCOM4_PORTC) * 4;
241	242	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
242	243
r244680	r244681
245	246
246	247	WRITE8_MEMBER(hh_ucom4_state::edracula_plate_w)
247	248	{
248		// ~~ports~~ E-H,I01: vfd matrix plate
	249	// E-H,I01: vfd matrix plate
249	250	int shift = (offset - NEC_UCOM4_PORTE) * 4;
250	251	m_plate = (m_plate & ~(0xf << shift)) \| (data << shift);
251	252
r244680	r244681
325	326
326	327	READ8_MEMBER(hh_ucom4_state::tmtennis_input_r)
327	328	{
328		// ~~ports~~ A,B: buttons
	329	// A,B: buttons
329	330	return ~read_inputs(2) >> (offset*4);
330	331	}
331	332
332	333	WRITE8_MEMBER(hh_ucom4_state::tmtennis_grid_w)
333	334	{
334		// ~~ports~~ G-I: vfd matrix grid
	335	// G-I: vfd matrix grid
335	336	int shift = (offset - NEC_UCOM4_PORTG) * 4;
336	337	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
337	338
r244680	r244681
340	341
341	342	WRITE8_MEMBER(hh_ucom4_state::tmtennis_plate_w)
342	343	{
343		// ~~ports~~ C-F: vfd matrix plate
	344	// C-F: vfd matrix plate
344	345	if (offset == NEC_UCOM4_PORTF) offset--;
345	346	int shift = (offset - NEC_UCOM4_PORTC) * 4;
346	347	m_plate = (m_plate & ~(0xf << shift)) \| (data << shift);
r244680	r244681
452	453	known releases:
453	454	- Japan: Puck Man
454	455	- USA: Pac Man
455		- UK: Puckman (Tomy), and also ~~as Munchman,~~ published by Grandstand
	456	- UK: Puckman (Tomy), and also published by Grandstand as Munchman
456	457	- Australia: Pac Man-1, published by Futuretronics
457	458
458	459	NOTE!: MESS external artwork is recommended
459	460
460	461	***************************************************************************/
461	462
	463	void hh_ucom4_state::tmpacman_display()
	464	{
	465	UINT8 grid = BITSWAP8((UINT8)m_grid,0,1,2,3,4,5,6,7);
	466	UINT32 plate = BITSWAP24(m_plate,23,22,21,20,19,16,17,18,11,10,9,8,0,2,3,1,4,5,6,7,12,13,14,15);
	467
	468	display_matrix(19, 8, plate \| 0x100, grid);
	469	}
	470
462	471	WRITE8_MEMBER(hh_ucom4_state::tmpacman_grid_w)
463	472	{
464		// ~~ports~~ C,D: vfd matrix grid
	473	// C,D: vfd matrix grid
465	474	int shift = (offset - NEC_UCOM4_PORTC) * 4;
466	475	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
467	476
468		~~dis~~play_ma~~trix(19, 8, m~~_pla~~te, m_grid~~);
	477	tmpacman_display();
469	478	}
470	479
471	480	WRITE8_MEMBER(hh_ucom4_state::tmpacman_plate_w)
472	481	{
473		// ~~ports~~ E-I: vfd matrix plate
	482	// E023,F-I: vfd matrix plate
474	483	int shift = (offset - NEC_UCOM4_PORTE) * 4;
475	484	m_plate = (m_plate & ~(0xf << shift)) \| (data << shift);
476	485
477		~~dis~~play_ma~~trix(19, 8, m~~_pla~~te, m_grid~~);
	486	tmpacman_display();
478	487	}
479	488
480	489	WRITE8_MEMBER(hh_ucom4_state::tmpacman_port_e_w)
r244680	r244681
494	503	PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP ) PORT_16WAY
495	504
496	505	PORT_START("IN.1") // port B
497		PORT_CONFNAME( 0x00, 0x00, DEF_STR( Difficulty ) )
	506	PORT_CONFNAME( 0x01, 0x00, DEF_STR( Difficulty ) )
498	507	PORT_CONFSETTING( 0x00, "Amateur" )
499	508	PORT_CONFSETTING( 0x01, "Professional" )
500	509	PORT_BIT( 0x0e, IP_ACTIVE_HIGH, IPT_UNUSED )
r244680	r244681
548	557
549	558	READ8_MEMBER(hh_ucom4_state::alnchase_input_r)
550	559	{
551		// ~~port~~ A: buttons
	560	// A: buttons
552	561	return read_inputs(2);
553	562	}
554	563
r244680	r244681
556	565	{
557	566	if (offset <= NEC_UCOM4_PORTE)
558	567	{
559		// ~~ports~~ C,D,E0: vfd matrix grid
	568	// C,D,E0: vfd matrix grid
560	569	int shift = (offset - NEC_UCOM4_PORTC) * 4;
561	570	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
562	571
r244680	r244681
567	576
568	577	if (offset >= NEC_UCOM4_PORTE)
569	578	{
570		// ~~ports F-I,~~E23: vfd matrix plate
	579	// E23,F-I: vfd matrix plate
571	580	int shift = (offset - NEC_UCOM4_PORTE) * 4;
572	581	m_plate = ((m_plate << 2 & ~(0xf << shift)) \| (data << shift)) >> 2;
573	582	}
r244680	r244681
684	693	CONS( 1982, edracula, 0, 0, edracula, edracula, driver_device, 0, "Epoch", "Dracula (Epoch)", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK )
685	694
686	695	CONS( 1980, tmtennis, 0, 0, tmtennis, tmtennis, driver_device, 0, "Tomy", "Tennis (Tomy)", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK )
687		CONS( 1982, tmpacman, 0, 0, tmpacman, tmpacman, driver_device, 0, "Tomy", "Pac Man (Tomy)", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK ~~\| GAME_NOT_WORKING~~ )
	696	CONS( 1982, tmpacman, 0, 0, tmpacman, tmpacman, driver_device, 0, "Tomy", "Pac Man (Tomy)", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK )
688	697	CONS( 1984, alnchase, 0, 0, alnchase, alnchase, driver_device, 0, "Tomy", "Alien Chase", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK )

trunk/src/mess/includes/gamate.h
r244680	r244681
11	11	#include "bus/generic/slot.h"
12	12	#include "bus/generic/carts.h"
13	13
14		struct GAMATE_CHANNEL
15		{
16		GAMATE_CHANNEL() :
17		// on(0),
18		// waveform(0),
19		volume(0),
20		pos(0),
21		size(0)
22		// count(0)
23		{
24		}
25	14
26		int on;
27		int /waveform,/ volume;
28		int pos;
29		int size;
30		// int count;
31		};
32
33
34	15	// ======================> gamate_sound_device
35	16
36	17	class gamate_sound_device : public device_t,
r244680	r244681
49	30
50	31	public:
51	32	DECLARE_WRITE8_MEMBER( device_w );
	33	DECLARE_READ8_MEMBER( device_r );
52	34
53	35	private:
54	36
	37	static const int DAConverter[];
	38	static int Value2Volume(int volume) { return DAConverter[volume]*1; }
	39
55	40	sound_stream *m_mixer_channel;
56		GAMATE_CHANNEL m_channels[3];
	41	struct Tone
	42	{
	43	Tone() :
	44	envelope_on(false),
	45	level(false),
	46	tone(false), full_cycle(false),
	47	volume(0),
	48	pos(0),
	49	size(0)
	50	{
	51	}
	52
	53	bool envelope_on, level;
	54	bool tone/else noise/, full_cycle/* else square signal/pulse */;
	55	int volume;
	56	int pos, size;
	57	};
	58	enum { Right, Left, Both };
	59	Tone m_channels[3];
	60	struct Noise {
	61	Noise(): state(1), level(false), step(0.0), pos(0.0) {}
	62	int state;
	63	bool level;
	64	double step, pos;
	65	} noise;
	66	struct Envelope {
	67	Envelope():control(0), index(0), first(false) {}
	68	int control;
	69	int index;
	70	bool first;
	71	double step, pos;
	72	} envelope;
57	73	UINT8 reg[14];
58	74	};
59	75

https://github.com/mamedev/mame/commit/808d9f5307459a063b5257ec07431072975b64e3

199869 Revisions