MAME SVN History

199869 Revisions

r36168 Sunday 1st March, 2015 at 17:31:53 UTC by Couriersud
Aligned monitor handling between sdl and baseline. [Couriersud]

[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
[src/osd/modules]	osdwindow.h
[src/osd/modules/render]	drawd3d.c drawdd.c drawsdl.c
[src/osd/sdl]	video.c video.h window.c window.h
[src/osd/windows]	video.c video.h window.c window.h

trunk/hash/pasogo.xml
r244679	r244680
3	3	<softwarelist name="pasogo" description="Koei PasoGo cartridges">
4	4
5	5	<!--
6		Koei PasoGo (パソ碁) ~~possible~~ undumped games
	6	Koei PasoGo (パソ碁) undumped games
7	7
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
	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
13	12	-->
14	13
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>
	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>
18	17	<year>1996</year>
19	18	<publisher>Koei</publisher>
20		<info name="serial" value="KS-1001"/>
21		<info name="alt_title" value="対局くん I"/>
	19	<info name="serial" value="KS-1009"/>
	20	<info name="alt_title" value="電子碁盤"/>
22	21	<part name="cart" interface="pasogo_cart">
23	22	<dataarea name="rom" width="16" endianness="little" size="1048576">
24		<rom name="ks-1001.ic4" size="1048576" crc="b6a3f97c" sha1="2de63b05ec93a4ba3ea55ba131c0706927a5bf39" offset="00000000" />
	23	<rom name="ks-1010.ic4" size="1048576" crc="b6a3f97c" sha1="2de63b05ec93a4ba3ea55ba131c0706927a5bf39" offset="00000000" />
25	24	</dataarea>
26	25	</part>
27	26	</software>
28	27
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>
42	28
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. -->
	29	<!-- Contains 4M SOP40 ROM only. -->
58	30	<software name="igmks1">
59	31	<description>Igo Meikyokushuu - Dai-1-kan</description>
60	32	<year>1996</year>
r244679	r244680
63	35	<info name="alt_title" value="囲碁名局集第1巻"/>
64	36	<part name="cart" interface="pasogo_cart">
65	37	<dataarea name="rom" width="16" endianness="little" size="524288">
66		<rom name="~~ks-1~~004~~.ic~~4" size="524288" crc="32f9c38a" sha1="1be82afcdf5e2d1a0e873fda4161e663d7a53a85" offset="00000000" />
	38	<rom name="yrm0442m-184s" size="524288" crc="32f9c38a" sha1="1be82afcdf5e2d1a0e873fda4161e663d7a53a85" offset="00000000" />
67	39	</dataarea>
68	40	</part>
69	41	</software>
70	42
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. -->
	43	<!-- Contains 4M SOP40 ROM only. -->
86	44	<software name="tnt1">
87	45	<description>Tsuyoku Naru Tesuji - Dai-1-kan</description>
88	46	<year>1996</year>
r244679	r244680
91	49	<info name="alt_title" value="強くなる手筋・第1巻"/>
92	50	<part name="cart" interface="pasogo_cart">
93	51	<dataarea name="rom" width="16" endianness="little" size="524288">
94		<rom name="ks-1010.ic4" size="524288" crc="3e70fca6" sha1="c46cdc9e01f2f5c66b2523e1d30355e51c839f27" offset="00000000" />
	52	<rom name="ks-1009.ic4" size="524288" crc="3e70fca6" sha1="c46cdc9e01f2f5c66b2523e1d30355e51c839f27" offset="00000000" />
95	53	</dataarea>
96	54	</part>
97	55	</software>

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

trunk/src/mame/drivers/mitchell.c
r244679	r244680
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( "~~pang_~~9.bin", 0x000000, 0x20000, CRC(3a5883f5) SHA1(a8a33071e10f5992e80afdb782c334829f9ae27f) ) /* chars */
	1590	ROM_LOAD( "bb9.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) )
r244679	r244680
1610	1610	ROM_CONTINUE(0x10000, 0x20000 ) /* Decrypted data */
1611	1611
1612	1612	ROM_REGION( 0x100000, "gfx1", ROMREGION_ERASEFF )
1613		ROM_LOAD( "~~pang_~~9.bin", 0x000000, 0x20000, CRC(3a5883f5) SHA1(a8a33071e10f5992e80afdb782c334829f9ae27f) ) /* chars */
	1613	ROM_LOAD( "bb9.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
r244679	r244680
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
r244679	r244680
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) ) ~~// V1.1 1992,1,13~~
	2606	ROM_LOAD( "9.bin", 0x00000, 0x08000, CRC(24f88cfd) SHA1(dfa7313ab6696042bab2e6cc8ff97b331d526c6b) )
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
r244679	r244680
2881	2881
2882	2882	GAME( 1991, hardhea2, 0, hardhea2, hardhea2, suna8_state, hardhea2, ROT0, "SunA", "Hard Head 2 (v2.0)", 0 )
2883	2883
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 )
	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 )
2888	2887	GAME( 1992, brickzn11, brickzn, brickzn, brickzn, suna8_state, brickzn11, ROT90, "SunA", "Brick Zone (v1.1)", GAME_NOT_WORKING )

trunk/src/mame/drivers/suprgolf.c
r244679	r244680
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();
76	75	virtual void machine_reset();
77	76	virtual void video_start();
78	77	UINT32 screen_update_suprgolf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
r244679	r244680
250	249	}
251	250	}
252	251
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
259	252	WRITE8_MEMBER(suprgolf_state::suprgolf_pen_w)
260	253	{
261	254	m_vreg_pen = data;
r244679	r244680
273	266
274	267	WRITE8_MEMBER(suprgolf_state::rom_bank_select_w)
275	268	{
276		m_rom_bank = data;
	269	UINT8 *region_base = memregion("user1")->base();
277	270
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);
	271	m_rom_bank = data;
281	272
	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
282	278	m_msm_nmi_mask = data & 0x40;
283	279	flip_screen_set(data & 0x80);
284	280	}
285	281
286	282	WRITE8_MEMBER(suprgolf_state::rom2_bank_select_w)
287	283	{
288		//osd_printf_debug("ROM_BANK 0x4000 - %X @%X\n",data,space.device().safe_pcbase());
289		membank("bank1")->set_entry(data & 0x0f);
290
	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
291	289	if(data & 0xf0)
292	290	printf("Rom bank select 2 with data %02x activated\n",data);
293	291	}

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

trunk/src/mame/drivers/tankbust.c
r244679	r244680
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
31	25	//port A of ay8910#0
32	26
33	27	TIMER_CALLBACK_MEMBER(tankbust_state::soundlatch_callback)
r244679	r244680
101	95
102	96	case 7: /* 0xe007 bankswitch */
103	97	/* bank 1 at 0x6000-9fff = from 0x10000 when bit0=0 else from 0x14000 */
104		membank("bank1")->set_entry(data & 1);
105
106	98	/* bank 2 at 0xa000-bfff = from 0x18000 when bit0=0 else from 0x1a000 */
107		membank("bank2")->set_entry(data & 1); /* verified (the game will reset after the "game over" otherwise) */
	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) */
108	101	break;
109	102	}
110	103	}

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

trunk/src/mame/drivers/tryout.c
r244679	r244680
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
51	46	WRITE8_MEMBER(tryout_state::tryout_bankswitch_w)
52	47	{
53		membank("bank1")->set_entry(data & 0x01);
	48	UINT8 *RAM = memregion("maincpu")->base();
	49	int bankaddress;
	50
	51	bankaddress = 0x10000 + (data & 0x01) * 0x2000;
	52	membank("bank1")->set_base(&RAM[bankaddress]);
54	53	}
55	54
56	55	static ADDRESS_MAP_START( main_cpu, AS_PROGRAM, 8, tryout_state )

trunk/src/mame/drivers/usgames.c
r244679	r244680
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		}
37	33
38	34	WRITE8_MEMBER(usgames_state::usgames_rombank_w)
39	35	{
40		membank("bank1")->set_entry(data);
	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] );
41	42	}
42	43
43	44	WRITE8_MEMBER(usgames_state::lamps1_w)

trunk/src/mame/drivers/vigilant.c
r244679	r244680
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
30	25	WRITE8_MEMBER(vigilant_state::vigilant_bank_select_w)
31	26	{
32		membank("bank1")->set_entry(data & 0x07);
	27	int bankaddress;
	28	UINT8 *RAM = memregion("maincpu")->base();
	29
	30	bankaddress = 0x10000 + (data & 0x07) * 0x4000;
	31	membank("bank1")->set_base(&RAM[bankaddress]);
33	32	}
34	33
35	34	/***************************************************************************

trunk/src/mame/includes/hng64.h
r244679	r244680
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		};
19	13
20	14
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
50	15	class hng64_state : public driver_device
51	16	{
52	17	public:
r244679	r244680
75	40	m_screen(*this, "screen"),
76	41	m_palette(*this, "palette"),
77	42	m_generic_paletteram_32(*this, "paletteram")
	43	{ }
78	44
79		{ }
80
81	45	required_device<mips3_device> m_maincpu;
82	46	required_device<cpu_device> m_audiocpu;
83	47	required_device<cpu_device> m_comm;
r244679	r244680
106	70	required_device<palette_device> m_palette;
107	71	required_shared_ptr<UINT32> m_generic_paletteram_32;
108	72
109
110	73	int m_mcu_type;
111	74
112	75	UINT16 *m_soundram;
r244679	r244680
134	97
135	98	UINT8 m_screen_dis;
136	99
137		struct hng64_tilemap {
138		tilemap_t *m_tilemap_8x8;
139		tilemap_t *m_tilemap_16x16;
140		tilemap_t *m_tilemap_16x16_alt;
141		};
	100	tilemap_t *m_tilemap0_8x8;
	101	tilemap_t *m_tilemap1_8x8;
	102	tilemap_t *m_tilemap2_8x8;
	103	tilemap_t *m_tilemap3_8x8;
142	104
143		hng64_tilemap m_tilemap[4];
	105	tilemap_t *m_tilemap0_16x16;
	106	tilemap_t *m_tilemap1_16x16;
	107	tilemap_t *m_tilemap2_16x16;
	108	tilemap_t *m_tilemap3_16x16;
144	109
	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
145	115	UINT8 m_additive_tilemap_debug;
146	116
147	117	// 3d display buffers
r244679	r244680
151	121
152	122	UINT32 m_old_animmask;
153	123	UINT32 m_old_animbits;
154		UINT16 m_old_tileflags[4];
	124	UINT16 m_old_tileflags0;
	125	UINT16 m_old_tileflags1;
	126	UINT16 m_old_tileflags2;
	127	UINT16 m_old_tileflags3;
155	128
156	129	UINT32 m_dls[2][0x81];
157	130
r244679	r244680
193	166	DECLARE_READ32_MEMBER(unk_vreg_r);
194	167	DECLARE_WRITE32_MEMBER(hng64_soundram_w);
195	168	DECLARE_READ32_MEMBER(hng64_soundram_r);
196		DECLARE_WRITE32_MEMBER(hng64_vregs_w);
197	169
198	170	// not actually used, but left in code so you can turn it and see the (possibly undesired?) behavior, see notes in memory map
199	171	DECLARE_WRITE32_MEMBER(hng64_soundram2_w);
r244679	r244680
254	226	DECLARE_CUSTOM_INPUT_MEMBER(brake_down_r);
255	227	void clear3d();
256	228	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
297	229	};
298	230
	231	/----------- defined in video/hng64.c -----------/
	232	void hng64_command3d(running_machine& machine, const UINT16* packet);

trunk/src/mame/includes/tankbust.h
r244679	r244680
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_start();
47		virtual void machine_reset();
	46	virtual void machine_reset();
48	47	virtual void video_start();
49	48	DECLARE_PALETTE_INIT(tankbust);
50	49	UINT32 screen_update_tankbust(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mame/includes/thunderx.h
r244679	r244680
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
r244679	r244680
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 machine_start();
40		virtual void video_start();
	39	virtual void video_start();
41	40	DECLARE_PALETTE_INIT(tryout);
42	41	UINT32 screen_update_tryout(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
43	42	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);

trunk/src/mame/includes/usgames.h
r244679	r244680
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 machine_start();
21		virtual void video_start();
	20	virtual void video_start();
22	21	DECLARE_PALETTE_INIT(usgames);
23	22	UINT32 screen_update_usgames(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
24	23	required_device<cpu_device> m_maincpu;

trunk/src/mame/includes/vigilant.h
r244679	r244680
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 machine_start();
42		virtual void video_start();
	41	virtual void video_start();
43	42	virtual void video_reset();
44	43	UINT32 screen_update_vigilant(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
45	44	UINT32 screen_update_kikcubic(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

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

trunk/src/mess/audio/gamate.c
r244679	r244680
1	1	/***************************************************************************
2	2	gamate sound hardware
3	3
4		PeT mess@utanet.at ~~2015~~
	4	PeT mess@utanet.at
5	5	***************************************************************************/
6	6
7	7	#include "emu.h"
8	8	#include "includes/gamate.h"
9		#include "ui/ui.h"
10	9
11	10
12		enum { ClockDelay=32 };
13
14	11	// device type definition
15	12	const device_type GAMATE_SND = &device_creator<gamate_sound_device>;
16	13
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 };
	14
20	15	//**************************************************************************
21	16	// LIVE DEVICE
22	17	//**************************************************************************
r244679	r244680
32	27	{
33	28	}
34	29
	30
35	31	//-------------------------------------------------
36	32	// device_start - device-specific startup
37	33	//-------------------------------------------------
r244679	r244680
39	35	void gamate_sound_device::device_start()
40	36	{
41	37	// bind callbacks
42		// m_irq_cb.bind_relative_to(*owner());
	38	// m_irq_cb.bind_relative_to(*owner());
43	39
44	40	memset(m_channels, 0, sizeof(m_channels));
45	41	memset(reg, 0, sizeof(reg));
r244679	r244680
56	52	{
57	53	stream_sample_t left=outputs[0], right=outputs[1];
58	54	int i, j;
59		Tone *channel;
60
	55	GAMATE_CHANNEL *channel;
	56
61	57	for (i = 0; i < samples; i++, left++, right++)
62	58	{
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
96	59	*left = 0;
97	60	*right = 0;
98	61	for (channel=m_channels, j=0; j<ARRAY_LENGTH(m_channels); j++, channel++)
99	62	{
100	63	if (channel->size != 0)
101	64	{
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		}
	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	}
139	80	}
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		}
148	81	channel->pos++;
149	82	if (channel->pos >= channel->size)
150	83	channel->pos = 0;
r244679	r244680
161	94	reg[offset] = data;
162	95	int chan=-1;
163	96
164		switch (offset~~&0xf~~)
	97	switch (offset)
165	98	{
166	99	case 0:
167	100	case 1:
r244679	r244680
169	102	case 3:
170	103	case 4:
171	104	case 5:
172		chan=offset/2;
	105	chan=offset/2;
173	106	size = reg[chan2] \| ((reg[chan2+1] & 0xf) << 8);
174	107	if (size)
175	108	{
176		m_channels[chan].size= (int) (machine().sample_rate() * size*ClockDelay / machine().device("maincpu")->unscaled_clock());
	109	m_channels[chan].size= (int) (machine().sample_rate() * (size << 5) / machine().device("maincpu")->unscaled_clock());
177	110	}
178	111	else
179	112	{
r244679	r244680
182	115	m_channels[chan].pos = 0;
183	116	break;
184	117	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;
189	118	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;
200	119	case 8:
201		case 9:
202		case 0xa:
203		chan=offset-8;
204		m_channels[chan].envelope_on = data & 0x10; // buggy aussetzer cube up
	120	chan=offset-6;
	121	// m_channels[chan]->on = data & 0x40;
	122	// channel->waveform = (data & 0x30) >> 4;
205	123	m_channels[chan].volume = data & 0xf;
206	124	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
219	125	}
220		envelope.pos=0; // guess
221		envelope.index=0;
222		envelope.first=true;
	126	if (chan!=-1) m_channels[chan].on=m_channels[chan].volume!=0 && m_channels[chan].size>3/* avoid speed loss for unhearable >=23khz*/;
223	127	}
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
r244679	r244680
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	******************************************************************************/
6	7
7		nmi unknown
8		cube up audio sometimes missing
9		bomb blast top status line missing
10		******************************************************************************/
11
12	8	#include "emu.h"
13	9	#include "cpu/m6502/m6502.h"
14	10	#include "bus/generic/slot.h"
r244679	r244680
40	36	DECLARE_WRITE8_MEMBER(cart_bankswitch_w);
41	37	DECLARE_READ8_MEMBER(gamate_video_r);
42	38	DECLARE_READ8_MEMBER(gamate_pad_r);
43		DECLARE_READ8_MEMBER(gamate_nmi_r);
44	39	DECLARE_WRITE8_MEMBER(gamate_video_w);
45	40	DECLARE_READ8_MEMBER(gamate_audio_r);
46	41	DECLARE_WRITE8_MEMBER(gamate_audio_w);
r244679	r244680
56	51
57	52	struct
58	53	{
59		UINT8 reg[8];
60		struct {
61		bool page2; // else page1
	54	UINT8 reg[8];
	55	struct {
	56	bool write;
	57	bool page2; // else page1
62	58	UINT8 ypos, xpos/tennis/;
63		UINT8 data[2][0x100][0x20];
64		} bitmap;
65		UINT8 x, y;
	59	UINT8 data[2][0x100][0x20];
	60	} bitmap;
	61	UINT8 x, y;
66	62	bool y_increment;
67	63	} video;
68	64
69	65	struct {
70		bool set;
	66	bool set;
71	67	int bit_shifter;
72	68	UINT8 cartridge_byte;
73	69	UINT16 address; // in reality something more like short local cartridge address offset
74	70	bool unprotected;
75	71	bool failed;
76
	72
77	73	} card_protection;
78	74
79	75	required_device<cpu_device> m_maincpu;
r244679	r244680
84	80	required_shared_ptr<UINT8> m_bios;
85	81	emu_timer *timer1;
86	82	emu_timer *timer2;
87		UINT8 bank_multi;
	83	UINT8 bank_multi;
88	84	};
89	85
90	86	WRITE8_MEMBER( gamate_state::gamate_cart_protection_w )
91	87	{
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
	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
94	90	switch (offset) {
95	91	case 0:
96	92	card_protection.failed= card_protection.failed \|\| ((card_protection.cartridge_byte&0x80)!=0) != ((data&4)!=0);
r244679	r244680
104	100	}
105	101	READ8_MEMBER( gamate_state::gamate_cart_protection_r )
106	102	{
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 {
	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 {
112	107	card_protection.bit_shifter++;
113	108	if (card_protection.bit_shifter==8) {
114	109	card_protection.bit_shifter=0;
r244679	r244680
117	112	}
118	113	ret=(card_protection.cartridge_byte&0x80)?2:0;
119	114	if (card_protection.bit_shifter==7 && !card_protection.failed) { // now protection chip on cartridge activates cartridge chip select on cpu accesses
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
	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
121	116	}
122	117	card_protection.cartridge_byte<<=1;
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;
	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;
126	121	}
127	122
128	123	READ8_MEMBER( gamate_state::protection_r ) { return card_protection.set? 3: 1; } // bits 0 and 1 checked
129	124
130	125	WRITE8_MEMBER( gamate_state::protection_reset )
131	126	{
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;
	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;
138	133	}
139	134
140	135	READ8_MEMBER( gamate_state::newer_protection_set )
141	136	{
142		card_protection.set=true;
143		return 0;
	137	card_protection.set=true;
	138	return 0;
144	139	}
145	140
146	141
147	142	WRITE8_MEMBER( gamate_state::gamate_video_w )
148	143	{
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		}
	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	}
167	169	}
168	170
169	171	WRITE8_MEMBER( gamate_state::cart_bankswitchmulti_w )
170	172	{
171		bank_multi=data;
172		membank("bankmulti")->set_base(m_cart->get_rom_base()+0x4000*data+1);
	173	bank_multi=data;
	174	membank("bankmulti")->set_base(m_cart->get_rom_base()+0x4000*data+1);
173	175	}
174	176
175	177	WRITE8_MEMBER( gamate_state::cart_bankswitch_w )
r244679	r244680
179	181
180	182	READ8_MEMBER( gamate_state::gamate_video_r )
181	183	{
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)];
	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	}
185	191	// if (m_maincpu->pc()<0xf000)
186	192	// machine().ui().popup_time(2, "lcd read x:%x y:%x mode:%x data:%x\n", video.x, video.y, video.reg[1], data);
187		if (video.y_increment) video.y++;
188		else video.x++; // overruns?
189
190		return data;
	193	return data;
191	194	}
192	195
193	196	WRITE8_MEMBER( gamate_state::gamate_audio_w )
194	197	{
195	198	// 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);
196		m_sound->device_w(space, offset, data);
	199	m_sound->device_w(space, offset, data);
197	200	}
198	201
199	202	READ8_MEMBER( gamate_state::gamate_audio_r )
200	203	{
201		UINT8 data=m_sound->device_r(space, offset);
202		return data;
	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;
203	207	}
204	208
205	209
206	210	READ8_MEMBER( gamate_state::gamate_pad_r )
207	211	{
208		UINT8 data=m_io_joy->read();
209		return data;
	212	UINT8 data=m_io_joy->read();
	213	return data;
210	214	}
211	215
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
219	216	static ADDRESS_MAP_START( gamate_mem, AS_PROGRAM, 8, gamate_state )
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)
	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)
228	224
229		AM_RANGE(0x6001, 0x9fff) AM_READ_BANK("bankmulti")
230		AM_RANGE(0xa000, 0xdfff) AM_READ_BANK("bank")
	225	AM_RANGE(0x6001, 0x9fff) AM_READ_BANK("bankmulti")
	226	AM_RANGE(0xa000, 0xdfff) AM_READ_BANK("bank")
231	227
232	228	AM_RANGE(0x6000, 0x6000) AM_READWRITE(gamate_cart_protection_r, gamate_cart_protection_w)
233	229	AM_RANGE(0x8000, 0x8000) AM_WRITE(cart_bankswitchmulti_w)
234	230	AM_RANGE(0xc000, 0xc000) AM_WRITE(cart_bankswitch_w)
235	231
236		AM_RANGE(0xf000, 0xffff) AM_ROM AM_SHARE("bios")
	232	AM_RANGE(0xf000, 0xffff) AM_ROM AM_SHARE("bios")
237	233	ADDRESS_MAP_END
238	234
239	235
r244679	r244680
249	245	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SELECT) PORT_NAME("Select")
250	246	INPUT_PORTS_END
251	247
252		static const unsigned short gamate_palette[4] =
	248	ATTR_UNUSED static const unsigned short gamate_palette[4] =
253	249	{
254	250	0,1,2,3
255	251	};
r244679	r244680
258	254	/* palette in red, green, blue tribles */
259	255	static const unsigned char gamate_colors[4][3] =
260	256	{
261		{ 255,255,255 },
262		{ 0xa0, 0xa0, 0xa0 },
263		{ 0x60, 0x60, 0x60 },
264		{ 0, 0, 0 }
	257	{ 255,255,255 },
	258	{ 0xa0, 0xa0, 0xa0 },
	259	{ 0x60, 0x60, 0x60 },
	260	{ 0, 0, 0 }
265	261	};
266	262
267	263	PALETTE_INIT_MEMBER(gamate_state, gamate)
r244679	r244680
284	280
285	281	UINT32 gamate_state::screen_update_gamate(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
286	282	{
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) {
	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) {
292	288	d1=video.bitmap.data[0][(y+video.bitmap.ypos)%200][(j+video.bitmap.xpos/8)&0x1f];
293	289	d2=video.bitmap.data[1][(y+video.bitmap.ypos)%200][(j+video.bitmap.xpos/8)&0x1f];
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~~
	290	} else if ((video.bitmap.ypos&0xf)<8) { // lcdtest, of course still some registers not known, my gamate doesn't display bottom lines
295	291	int yi=(y+(video.bitmap.ypos&0xf)-8);
296	292	if (yi<0) yi=video.bitmap.ypos+y; // in this case only 2nd plane used!?, source of first plane?
297	293	d1=video.bitmap.data[0][yi][(j+video.bitmap.xpos/8)&0x1f]; // value of lines bevor 0 chaos
298	294	d2=video.bitmap.data[1][yi][(j+video.bitmap.xpos/8)&0x1f];
299		} else {
	295	} else {
300	296	d1=video.bitmap.data[0][y][(j+video.bitmap.xpos/8)&0x1f];
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;
	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;
308	304	}
309	305
310	306	DRIVER_INIT_MEMBER(gamate_state,gamate)
r244679	r244680
318	314	void gamate_state::machine_start()
319	315	{
320	316	if (m_cart->exists()) {
321		// m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6000, READ8_DELEGATE(gamate_state, gamate_cart_protection_r));
	317	// m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6000, READ8_DELEGATE(gamate_state, gamate_cart_protection_r));
322	318	membank("bankmulti")->set_base(m_cart->get_rom_base()+1);
323	319	membank("bank")->set_base(m_cart->get_rom_base()+0x4000); // bankswitched games in reality no offset
324	320	}
325		// m_bios[0xdf1]=0xea; m_bios[0xdf2]=0xea; // default bios: $47 protection readback
	321	// m_bios[0xdf1]=0xea; m_bios[0xdf2]=0xea; // default bios: $47 protection readback
326	322	card_protection.set=false;
327	323	bank_multi=0;
328	324	card_protection.unprotected=false;
r244679	r244680
382	378	MCFG_SOUND_ADD("custom", GAMATE_SND, 0)
383	379	MCFG_SOUND_ROUTE(0, "lspeaker", 0.50)
384	380	MCFG_SOUND_ROUTE(1, "rspeaker", 0.50)
385
	381
386	382	MCFG_GENERIC_CARTSLOT_ADD("cartslot", generic_linear_slot, "gamate_cart")
387	383	MCFG_GENERIC_MANDATORY
388	384
r244679	r244680
400	396
401	397
402	398	/* YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY FULLNAME */
403		CONS( 19??, gamate, 0, 0, gamate, gamate, gamate_state, gamate, "Bit Corp", "Gamate", 0)
404
405
	399	CONS( 19??, gamate, 0, 0, gamate, gamate, gamate_state, gamate, "Bit Corp", "Gamate", GAME_IMPERFECT_SOUND)

trunk/src/mess/drivers/hh_ucom4.c
r244679	r244680
87	87	DECLARE_INPUT_CHANGED_MEMBER(tmtennis_difficulty_switch);
88	88	DECLARE_MACHINE_RESET(tmtennis);
89	89
90		void tmpacman_display();
91	90	DECLARE_WRITE8_MEMBER(tmpacman_grid_w);
92	91	DECLARE_WRITE8_MEMBER(tmpacman_plate_w);
93	92	DECLARE_WRITE8_MEMBER(tmpacman_port_e_w);
r244679	r244680
237	236
238	237	WRITE8_MEMBER(hh_ucom4_state::edracula_grid_w)
239	238	{
240		// C,D: vfd matrix grid
	239	// ports C,D: vfd matrix grid
241	240	int shift = (offset - NEC_UCOM4_PORTC) * 4;
242	241	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
243	242
r244679	r244680
246	245
247	246	WRITE8_MEMBER(hh_ucom4_state::edracula_plate_w)
248	247	{
249		// E-H,I01: vfd matrix plate
	248	// ports E-H,I01: vfd matrix plate
250	249	int shift = (offset - NEC_UCOM4_PORTE) * 4;
251	250	m_plate = (m_plate & ~(0xf << shift)) \| (data << shift);
252	251
r244679	r244680
326	325
327	326	READ8_MEMBER(hh_ucom4_state::tmtennis_input_r)
328	327	{
329		// A,B: buttons
	328	// ports A,B: buttons
330	329	return ~read_inputs(2) >> (offset*4);
331	330	}
332	331
333	332	WRITE8_MEMBER(hh_ucom4_state::tmtennis_grid_w)
334	333	{
335		// G-I: vfd matrix grid
	334	// ports G-I: vfd matrix grid
336	335	int shift = (offset - NEC_UCOM4_PORTG) * 4;
337	336	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
338	337
r244679	r244680
341	340
342	341	WRITE8_MEMBER(hh_ucom4_state::tmtennis_plate_w)
343	342	{
344		// C-F: vfd matrix plate
	343	// ports C-F: vfd matrix plate
345	344	if (offset == NEC_UCOM4_PORTF) offset--;
346	345	int shift = (offset - NEC_UCOM4_PORTC) * 4;
347	346	m_plate = (m_plate & ~(0xf << shift)) \| (data << shift);
r244679	r244680
453	452	known releases:
454	453	- Japan: Puck Man
455	454	- USA: Pac Man
456		- UK: Puckman (Tomy), and also published by Grandstand ~~as Munchman~~
	455	- UK: Puckman (Tomy), and also as Munchman, published by Grandstand
457	456	- Australia: Pac Man-1, published by Futuretronics
458	457
459	458	NOTE!: MESS external artwork is recommended
460	459
461	460	***************************************************************************/
462	461
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
471	462	WRITE8_MEMBER(hh_ucom4_state::tmpacman_grid_w)
472	463	{
473		// C,D: vfd matrix grid
	464	// ports C,D: vfd matrix grid
474	465	int shift = (offset - NEC_UCOM4_PORTC) * 4;
475	466	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
476	467
477		~~tmpacman_~~display();
	468	display_matrix(19, 8, m_plate, m_grid);
478	469	}
479	470
480	471	WRITE8_MEMBER(hh_ucom4_state::tmpacman_plate_w)
481	472	{
482		// E~~023,F~~-I: vfd matrix plate
	473	// ports E-I: vfd matrix plate
483	474	int shift = (offset - NEC_UCOM4_PORTE) * 4;
484	475	m_plate = (m_plate & ~(0xf << shift)) \| (data << shift);
485	476
486		~~tmpacman_~~display();
	477	display_matrix(19, 8, m_plate, m_grid);
487	478	}
488	479
489	480	WRITE8_MEMBER(hh_ucom4_state::tmpacman_port_e_w)
r244679	r244680
503	494	PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_JOYSTICK_UP ) PORT_16WAY
504	495
505	496	PORT_START("IN.1") // port B
506		PORT_CONFNAME( 0x01, 0x00, DEF_STR( Difficulty ) )
	497	PORT_CONFNAME( 0x00, 0x00, DEF_STR( Difficulty ) )
507	498	PORT_CONFSETTING( 0x00, "Amateur" )
508	499	PORT_CONFSETTING( 0x01, "Professional" )
509	500	PORT_BIT( 0x0e, IP_ACTIVE_HIGH, IPT_UNUSED )
r244679	r244680
557	548
558	549	READ8_MEMBER(hh_ucom4_state::alnchase_input_r)
559	550	{
560		// A: buttons
	551	// port A: buttons
561	552	return read_inputs(2);
562	553	}
563	554
r244679	r244680
565	556	{
566	557	if (offset <= NEC_UCOM4_PORTE)
567	558	{
568		// C,D,E0: vfd matrix grid
	559	// ports C,D,E0: vfd matrix grid
569	560	int shift = (offset - NEC_UCOM4_PORTC) * 4;
570	561	m_grid = (m_grid & ~(0xf << shift)) \| (data << shift);
571	562
r244679	r244680
576	567
577	568	if (offset >= NEC_UCOM4_PORTE)
578	569	{
579		// ~~E23,~~F-I: vfd matrix plate
	570	// ports F-I,E23: vfd matrix plate
580	571	int shift = (offset - NEC_UCOM4_PORTE) * 4;
581	572	m_plate = ((m_plate << 2 & ~(0xf << shift)) \| (data << shift)) >> 2;
582	573	}
r244679	r244680
693	684	CONS( 1982, edracula, 0, 0, edracula, edracula, driver_device, 0, "Epoch", "Dracula (Epoch)", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK )
694	685
695	686	CONS( 1980, tmtennis, 0, 0, tmtennis, tmtennis, driver_device, 0, "Tomy", "Tennis (Tomy)", GAME_SUPPORTS_SAVE \| GAME_REQUIRES_ARTWORK )
696		CONS( 1982, tmpacman, 0, 0, tmpacman, tmpacman, driver_device, 0, "Tomy", "Pac Man (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 )
697	688	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
r244679	r244680
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	}
14	25
	26	int on;
	27	int /waveform,/ volume;
	28	int pos;
	29	int size;
	30	// int count;
	31	};
	32
	33
15	34	// ======================> gamate_sound_device
16	35
17	36	class gamate_sound_device : public device_t,
r244679	r244680
30	49
31	50	public:
32	51	DECLARE_WRITE8_MEMBER( device_w );
33		DECLARE_READ8_MEMBER( device_r );
34	52
35	53	private:
36	54
37		static const int DAConverter[];
38		static int Value2Volume(int volume) { return DAConverter[volume]*1; }
39
40	55	sound_stream *m_mixer_channel;
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;
	56	GAMATE_CHANNEL m_channels[3];
73	57	UINT8 reg[14];
74	58	};
75	59

trunk/src/osd/modules/osdwindow.h
r244679	r244680
55	55
56	56	#ifdef OSD_SDL
57	57	virtual osd_dim blit_surface_size() = 0;
58		virtual sdl_monitor_info *monitor() const = 0;
	58	virtual osd_monitor_info *monitor() const = 0;
59	59	#if (SDLMAME_SDL2)
60	60	virtual SDL_Window *sdl_window() = 0;
61	61	#else
62	62	virtual SDL_Surface *sdl_surface() = 0;
63	63	#endif
64	64	#else
65		virtual ~~win~~_monitor_info *monitor() const = 0;
	65	virtual osd_monitor_info *monitor() const = 0;
66	66	virtual bool win_has_menu() = 0;
67	67	// FIXME: cann we replace winwindow_video_window_monitor(NULL) with monitor() ?
68		virtual ~~win~~_monitor_info winwindow_video_window_monitor(const osd_rect proposed) = 0;
	68	virtual osd_monitor_info winwindow_video_window_monitor(const osd_rect proposed) = 0;
69	69
70	70	// window handle and info
71	71	HWND m_hwnd;

trunk/src/osd/modules/render/drawd3d.c
r244679	r244680
1266	1266	HMONITOR curmonitor = (*d3dintf->d3d.get_adapter_monitor)(d3dintf, adapternum);
1267	1267
1268	1268	// if we match the proposed monitor, this is it
1269		if (curmonitor == window().monitor()->handle())
	1269	if (curmonitor == ((HMONITOR )window().monitor()->oshandle()))
1270	1270	{
1271	1271	return adapternum;
1272	1272	}

trunk/src/osd/modules/render/drawdd.c
r244679	r244680
94	94
95	95	// video modes
96	96	int config_adapter_mode();
97		void get_adapter_for_monitor(~~win~~_monitor_info *monitor);
	97	void get_adapter_for_monitor(osd_monitor_info *monitor);
98	98	void pick_best_mode();
99	99
100	100	// various
r244679	r244680
130	130	/* monitor_enum_info holds information during a monitor enumeration */
131	131	struct monitor_enum_info
132	132	{
133		~~win~~_monitor_info * monitor; // pointer to monitor we want
	133	osd_monitor_info * monitor; // pointer to monitor we want
134	134	GUID guid; // GUID of the one we found
135	135	GUID * guid_ptr; // pointer to our GUID
136	136	int foundit; // TRUE if we found what we wanted
r244679	r244680
263	263	{
264	264	// configure the adapter for the mode we want
265	265	if (config_adapter_mode())
	266	{
	267	osd_printf_error("Unable to configure adapter.\n");
266	268	goto error;
	269	}
267	270
268	271	// create the ddraw object
269	272	if (ddraw_create())
	273	{
	274	osd_printf_error("Unable to create ddraw object.\n");
270	275	goto error;
	276	}
271	277
272	278	return 0;
273	279
r244679	r244680
855	861	// compute the appropriate visible area if we're trying to keepaspect
856	862	if (video_config.keepaspect)
857	863	{
858		~~win~~_monitor_info *monitor = window().winwindow_video_window_monitor(NULL);
	864	osd_monitor_info *monitor = window().winwindow_video_window_monitor(NULL);
859	865	window().target()->compute_visible_area(target_width, target_height, monitor->aspect(), window().target()->orientation(), target_width, target_height);
860	866	desired_aspect = (float)target_width / (float)target_height;
861	867	}
r244679	r244680
945	951	void renderer_dd::blit_to_primary(int srcwidth, int srcheight)
946	952	{
947	953	IDirectDrawSurface7 *target = (back != NULL) ? back : primary;
948		~~win~~_monitor_info *monitor = window().winwindow_video_window_monitor(NULL);
	954	osd_monitor_info *monitor = window().winwindow_video_window_monitor(NULL);
949	955	DDBLTFX blitfx = { sizeof(DDBLTFX) };
950	956	RECT clear, outer, dest, source;
951	957	INT32 dstwidth, dstheight;
r244679	r244680
1161	1167	monitor_enum_info einfo = (monitor_enum_info )context;
1162	1168
1163	1169	// do we match the desired monitor?
1164		if (hmonitor == einfo->monitor->handle() \|\| (hmonitor == NULL && einfo->monitor->is_primary()))
	1170	if (hmonitor == ((HMONITOR )einfo->monitor->oshandle()) \|\| (hmonitor == NULL && einfo->monitor->is_primary()))
1165	1171	{
1166	1172	einfo->guid_ptr = (guid != NULL) ? &einfo->guid : NULL;
1167	1173	if (guid != NULL)
r244679	r244680
1177	1183	// get_adapter_for_monitor
1178	1184	//============================================================
1179	1185
1180		void renderer_dd::get_adapter_for_monitor(~~win~~_monitor_info *monitor)
	1186	void renderer_dd::get_adapter_for_monitor(osd_monitor_info *monitor)
1181	1187	{
1182	1188	monitor_enum_info einfo;
1183	1189	HRESULT result;

trunk/src/osd/modules/render/drawsdl.c
r244679	r244680
271	271	UINT32 fmt;
272	272
273	273	// Determine preferred pixelformat and set up yuv if necessary
274		SDL_GetCurrentDisplayMode(window().monitor()->handle(), &mode);
	274	SDL_GetCurrentDisplayMode(((UINT64 )window().monitor()->handle()), &mode);
275	275
276	276	if (m_yuv_bitmap)
277	277	{

trunk/src/osd/sdl/video.c
r244679	r244680
63	63
64	64	osd_video_config video_config;
65	65
66		sdl_monitor_info *sdl_monitor_info::primary_monitor = NULL;
67		sdl_monitor_info *sdl_monitor_info::list = NULL;
	66	osd_monitor_info *osd_monitor_info::list = NULL;
68	67
69	68	//============================================================
70	69	// LOCAL VARIABLES
r244679	r244680
133	132	//============================================================
134	133	// sdlvideo_monitor_refresh
135	134	//============================================================
136
	135	#if defined(SDLMAME_WIN32) // Win32 version
	136	inline osd_rect RECT_to_osd_rect(const RECT &r)
	137	{
	138	return osd_rect(r.left, r.top, r.right - r.left, r.bottom - r.top);
	139	}
	140	#endif
137	141	void sdl_monitor_info::refresh()
138	142	{
139	143	#if (SDLMAME_SDL2)
r244679	r244680
144	148	#else
145	149	SDL_GetCurrentDisplayMode(m_handle, &dmode);
146	150	#endif
147		SDL_GetDisplayBounds(m_handle, &m_dimensions);
	151	SDL_Rect dimensions;
	152	SDL_GetDisplayBounds(m_handle, &dimensions);
148	153
149		// FIXME: Use SDL_GetDisplayBounds(monitor->handle, &tt) to update monitor_x
150		// SDL_Rect tt;
	154	m_pos_size = SDL_Rect_to_osd_rect(dimensions);
	155	m_usuable_pos_size = SDL_Rect_to_osd_rect(dimensions);
	156	m_is_primary = (m_handle == 0);
	157
151	158	#else
152	159	#if defined(SDLMAME_WIN32) // Win32 version
153	160	MONITORINFOEX info;
154	161	info.cbSize = sizeof(info);
155	162	GetMonitorInfo((HMONITOR)m_handle, (LPMONITORINFO)&info);
156		m_dimensions.x = m_dimensions.y = 0;
157		m_dimensions.w = info.rcMonitor.right - info.rcMonitor.left;
158		m_dimensions.h = info.rcMonitor.bottom - info.rcMonitor.top;
	163	m_pos_size = RECT_to_osd_rect(info.rcMonitor);
	164	m_usuable_pos_size = RECT_to_osd_rect(info.rcWork);
	165	m_is_primary = ((info.dwFlags & MONITORINFOF_PRIMARY) != 0);
159	166	char *temp = utf8_from_wstring(info.szDevice);
160	167	strncpy(m_name, temp, ARRAY_LENGTH(m_name) - 1);
161	168	osd_free(temp);
r244679	r244680
167	174	primary = CGMainDisplayID();
168	175	dbounds = CGDisplayBounds(primary);
169	176
170		m_dimensions.x = m_dimensions.y = 0;
171		m_dimensions.w = dbounds.size.width - dbounds.origin.x;
172		m_dimensions.h = dbounds.size.height - dbounds.origin.y;
	177	m_is_primary = (m_handle == 0);
	178	m_pos_size = osd_rect(0, 0, dbounds.size.width - dbounds.origin.x, dbounds.size.height - dbounds.origin.y);
	179	m_usuable_pos_size = m_pos_size;
173	180	strncpy(m_name, "Mac OS X display", ARRAY_LENGTH(m_name) - 1);
174	181	#elif defined(SDLMAME_X11) \|\| defined(SDLMAME_NO_X11) // X11 version
175	182	{
r244679	r244680
183	190	{
184	191	screen = DefaultScreen(info.info.x11.display);
185	192	SDL_VideoDriverName(m_name, ARRAY_LENGTH(m_name) - 1);
186		m_dimensions.x = m_dimensions.y = 0;
187		m_dimensions.w = DisplayWidth(info.info.x11.display, screen);
188		m_dimensions.h = DisplayHeight(info.info.x11.display, screen);
	193	m_pos_size = osd_rect(0, 0,
	194	DisplayWidth(info.info.x11.display, screen),
	195	DisplayHeight(info.info.x11.display, screen));
189	196
190	197	/* FIXME: If Xinerame is used we should compile a list of monitors
191	198	* like we do for other targets and ignore SDL.
r244679	r244680
197	204
198	205	xineinfo = XineramaQueryScreens(info.info.x11.display, &numscreens);
199	206
200		m_dimensions.w = xineinfo[0].width;
201		m_dimensions.h = xineinfo[0].height;
	207	m_pos_size = osd_rect(0, 0, xineinfo[0].width, xineinfo[0].height);
202	208
203	209	XFree(xineinfo);
204	210	}
	211	m_usuable_pos_size = m_pos_size;
	212	m_is_primary = (m_handle == 0);
205	213	}
206	214	else
207	215	#endif // defined(SDLMAME_X11)
r244679	r244680
238	246	}
239	247	}
240	248	}
241		m_dimensions.w = cw;
242		m_dimensions.h = ch;
	249	m_pos_size = osd_rect(0, 0, cw, ch);
	250	m_usuable_pos_size = m_pos_size;
	251	m_is_primary = (m_handle == 0);
243	252	}
244	253	}
245	254	#elif defined(SDLMAME_OS2) // OS2 version
246		m_dimensions.x = m_dimensions.y = 0;
247		m_dimensions.w = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN );
248		m_dimensions.h = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN );
	255	m_pos_size = osd_rect(0, 0,
	256	WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ),
	257	WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ) );
	258	m_usuable_pos_size = m_pos_size;
	259	m_is_primary = (m_handle == 0);
249	260	strncpy(m_name, "OS/2 display", ARRAY_LENGTH(m_name) - 1);
250	261	#else
251	262	#error Unknown SDLMAME_xx OS type!
r244679	r244680
256	267	if (!info_shown)
257	268	{
258	269	osd_printf_verbose("SDL Device Driver : %s\n", m_name);
259		osd_printf_verbose("SDL Monitor Dimensions: %d x %d\n", m_~~dimensi~~ons.w, m_~~dimensi~~ons.h);
	270	osd_printf_verbose("SDL Monitor Dimensions: %d x %d\n", m_pos_size.width(), m_pos_size.height());
260	271	info_shown = 1;
261	272	}
262	273	}
r244679	r244680
269	280	// sdlvideo_monitor_get_aspect
270	281	//============================================================
271	282
272		float sdl_monitor_info::aspect()
	283	float osd_monitor_info::aspect()
273	284	{
274	285	// refresh the monitor information and compute the aspect
275	286	refresh();
276	287	// FIXME: returning 0 looks odd, video_config is bad
277	288	if (video_config.keepaspect)
278	289	{
279		return m_aspect / ((float)m_~~dimensi~~ons.w / (float)m_~~dimensi~~ons.h);
	290	return m_aspect / ((float)m_pos_size.width() / (float)m_pos_size.height());
280	291	}
281	292	return 0.0f;
282	293	}
r244679	r244680
320	331	#if !defined(SDLMAME_WIN32) && !(SDLMAME_SDL2)
321	332	void sdl_monitor_info::add_primary_monitor(void *data)
322	333	{
323		sdl_monitor_info *tailptr = (sdl_monitor_info *)data;
324		sdl_monitor_info *monitor;
	334	// make a list of monitors
	335	osd_monitor_info::list = NULL;
	336	osd_monitor_info **tailptr = &sdl_monitor_info::list;
325	337
326	338	// allocate a new monitor info
327		monitor = global_alloc_clear(sdl_monitor_info);
	339	osd_monitor_info *monitor = global_alloc_clear(sdl_monitor_info(0, "", 1.0f));
328	340
329		// copy in the data
330		monitor->m_handle = 1;
331
332		monitor->refresh();
333
	341	//monitor->refresh();
334	342	// guess the aspect ratio assuming square pixels
335		monitor->m_aspect = (float)(monitor->~~m_dimen~~sions.w) / (float)(monitor->~~m_dimen~~sions.h);
	343	monitor->set_aspect((float)(monitor->position_size().width()) / (float)(monitor->position_size().height()));
336	344
337		// save the primary monitor handle
338		primary_monitor = monitor;
339
340	345	// hook us into the list
341		**tailptr = monitor;
342		*tailptr = &monitor->m_next;
	346	*tailptr = monitor;
	347	//tailptr = &monitor->m_next;
343	348	}
344	349	#endif
345	350
r244679	r244680
349	354	//============================================================
350	355
351	356	#if defined(SDLMAME_WIN32) && !(SDLMAME_SDL2)
352		~~static~~ BOOL CALLBACK monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data)
	357	BOOL CALLBACK sdl_monitor_info::monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data)
353	358	{
354		sdl_monitor_info *tailptr = (sdl_monitor_info *)data;
355		sdl_monitor_info *monitor;
	359	osd_monitor_info *tailptr = (osd_monitor_info *)data;
	360	osd_monitor_info *monitor;
356	361	MONITORINFOEX info;
357	362	BOOL result;
358	363
r244679	r244680
371	376	monitor = global_alloc(sdl_monitor_info((UINT64) handle, temp, aspect));
372	377	osd_free(temp);
373	378
374		// save the primary monitor handle
375		if (info.dwFlags & MONITORINFOF_PRIMARY)
376		sdl_monitor_info::primary_monitor = monitor;
377
378	379	// hook us into the list
379	380	**tailptr = monitor;
380	381	*tailptr = &monitor->m_next;
r244679	r244680
391	392
392	393	void sdl_monitor_info::init()
393	394	{
394		sdl_monitor_info **tailptr;
	395	osd_monitor_info **tailptr;
395	396
396	397	// make a list of monitors
397		sdl_monitor_info::list = NULL;
398		tailptr = &sdl_monitor_info::list;
	398	osd_monitor_info::list = NULL;
	399	tailptr = &osd_monitor_info::list;
399	400
400	401	#if (SDLMAME_SDL2)
401	402	{
402		int i~~, monx = 0~~;
	403	int i;
403	404
404	405	osd_printf_verbose("Enter init_monitors\n");
405	406
406	407	for (i = 0; i < SDL_GetNumVideoDisplays(); i++)
407	408	{
408	409	sdl_monitor_info *monitor;
409		SDL_DisplayMode dmode;
410	410
	411	char temp[64];
	412	snprintf(temp, sizeof(temp)-1, "%s%d", OSDOPTION_SCREEN,i);
	413
411	414	// allocate a new monitor info
412		monitor = global_alloc_clear(sdl_monitor_info);
413		monitor->m_handle = i;
414	415
415		~~snprintf(~~monitor~~->m~~_na~~me, size~~of(monitor~~->m~~_n~~ame)-1~~, ~~"%s%d"~~, ~~OSDOPTION_SCREEN,i~~);
	416	monitor = global_alloc_clear(sdl_monitor_info(i, temp, 1.0f));
416	417
417		SDL_GetDesktopDisplayMode(i, &dmode);
418		SDL_GetDisplayBounds(i, &monitor->m_dimensions);
	418	osd_printf_verbose("Adding monitor %s (%d x %d)\n", monitor->devicename(),
	419	monitor->position_size().width(), monitor->position_size().height());
419	420
420	421	// guess the aspect ratio assuming square pixels
421		monitor->m_aspect = (float)(dmode.w) / (float)(dmode.h);
	422	monitor->set_aspect((float)(monitor->position_size().width()) / (float)(monitor->position_size().height()));
422	423
423		osd_printf_verbose("Adding monitor %s (%d x %d)\n", monitor->m_name, dmode.w, dmode.h);
424
425		monx += dmode.w;
426
427		// save the primary monitor handle
428		if (i == 0)
429		primary_monitor = monitor;
430
431	424	// hook us into the list
432	425	*tailptr = monitor;
433	426	tailptr = &monitor->m_next;
r244679	r244680
446	439	// free all of our monitor information
447	440	while (sdl_monitor_info::list != NULL)
448	441	{
449		sdl_monitor_info *temp = sdl_monitor_info::list;
	442	osd_monitor_info *temp = sdl_monitor_info::list;
450	443	sdl_monitor_info::list = temp->next();
451	444	global_free(temp);
452	445	}
r244679	r244680
458	451	//============================================================
459	452
460	453	#if (SDLMAME_SDL2) \|\| defined(SDLMAME_WIN32)
461		sdl_monitor_info *sdl_monitor_info::pick_monitor(sdl_options &options, int index)
	454	osd_monitor_info *osd_monitor_info::pick_monitor(sdl_options &options, int index)
462	455	{
463		sdl_monitor_info *monitor;
	456	osd_monitor_info *monitor;
464	457	const char scrname, scrname2;
465	458	int moncount = 0;
466	459	float aspect;
r244679	r244680
494	487	goto finishit;
495	488
496	489	// return the primary just in case all else fails
497		monitor = primary_monitor;
	490	for (monitor = sdl_monitor_info::list; monitor != NULL; monitor = monitor->next())
	491	if (monitor->is_primary())
	492	goto finishit;
498	493
	494	// FIXME: FatalError?
499	495	finishit:
500	496	if (aspect != 0)
501	497	{
r244679	r244680
504	500	return monitor;
505	501	}
506	502	#else
507		sdl_monitor_info *sdl_monitor_info::pick_monitor(sdl_options &options, int index)
	503	osd_monitor_info *osd_monitor_info::pick_monitor(sdl_options &options, int index)
508	504	{
509		sdl_monitor_info *monitor;
	505	osd_monitor_info *monitor;
510	506	float aspect;
511	507
512	508	// get the aspect ratio
513	509	aspect = get_aspect(options.aspect(), options.aspect(index), TRUE);
514	510
515	511	// return the primary just in case all else fails
516		monitor = ~~primary~~_monitor;
	512	monitor = osd_monitor_info::list;
517	513
518	514	if (aspect != 0)
519	515	{

trunk/src/osd/sdl/video.h
r244679	r244680
73	73	class osd_rect
74	74	{
75	75	public:
	76	osd_rect()
	77	: m_x(0), m_y(0), m_d(0,0)
	78	{
	79	}
76	80	osd_rect(const int x, const int y, const int &w, const int &h)
77	81	: m_x(x), m_y(y), m_d(w,h)
78	82	{
r244679	r244680
105	109	return osd_rect(r.x, r.y, r.w, r.h);
106	110	}
107	111
108		// FIXME: This is sort of ugly ... and should be a real interface only
109		class sdl_monitor_info
	112	class osd_monitor_info
110	113	{
111	114	public:
112	115
113		sdl_monitor_info()
114		: m_next(NULL), m_handle(0), m_aspect(0.0f)
115		{}
116		sdl_monitor_info(const UINT64 handle, const char *monitor_device, float aspect)
	116	#if 0
	117	osd_monitor_info()
	118	: m_next(NULL), m_handle(NULL), m_aspect(0.0f)
	119	{
	120	strcpy(m_name, "");
	121	}
	122	#endif
	123	osd_monitor_info(void handle, const char monitor_device, float aspect)
117	124	: m_next(NULL), m_handle(handle), m_aspect(aspect)
118	125	{
119	126	strncpy(m_name, monitor_device, ARRAY_LENGTH(m_name) - 1);
120		refresh();
121	127	}
122	128
123		const UINT64 handle() { return m_handle; }
124		const osd_rect position_size() { refresh(); return SDL_Rect_to_osd_rect(m_dimensions); }
125		const osd_rect usuable_position_size() { refresh(); return SDL_Rect_to_osd_rect(m_dimensions); }
	129	virtual ~osd_monitor_info() { }
126	130
	131	const void *handle() { return m_handle; }
	132
	133	const osd_rect &position_size() { refresh(); return m_pos_size; }
	134	const osd_rect &usuable_position_size() { refresh(); return m_usuable_pos_size; }
	135
127	136	const char *devicename() { refresh(); return m_name[0] ? m_name : "UNKNOWN"; }
128	137
129	138	float aspect();
130	139
131	140	void set_aspect(const float a) { m_aspect = a; }
	141	bool is_primary() { refresh(); return m_is_primary; }
132	142
	143	osd_monitor_info * next() { return m_next; } // pointer to next monitor in list
	144
	145	static osd_monitor_info *pick_monitor(sdl_options &options, int index);
	146	static osd_monitor_info *list;
	147
	148	// FIXME: should be private!
	149	osd_monitor_info *m_next; // pointer to next monitor in list
	150	protected:
	151	virtual void refresh() = 0;
	152	osd_rect m_pos_size;
	153	osd_rect m_usuable_pos_size;
	154	bool m_is_primary;
	155	char m_name[64];
	156	private:
	157
	158	void * m_handle; // handle to the monitor
	159	float m_aspect; // computed/configured aspect ratio of the physical device
	160	};
	161
	162
	163	class sdl_monitor_info : public osd_monitor_info
	164	{
	165	public:
	166	#if 0
	167	sdl_monitor_info()
	168	: m_next(NULL), m_handle(0), m_aspect(0.0f)
	169	{}
	170	#endif
	171	sdl_monitor_info(const UINT64 handle, const char *monitor_device, float aspect)
	172	: osd_monitor_info(&m_handle, monitor_device, aspect), m_handle(handle)
	173	{
	174	refresh();
	175	}
	176
133	177	// STATIC
134	178	static void init();
135	179	static void exit();
136		static sdl_monitor_info *pick_monitor(sdl_options &options, int index);
137	180	#if !defined(SDLMAME_WIN32) && !(SDLMAME_SDL2)
138	181	static void add_primary_monitor(void *data);
139	182	#endif
140
141		sdl_monitor_info * next() { return m_next; } // pointer to next monitor in list
142
143		// STATIC
144		static sdl_monitor_info *primary_monitor;
145		static sdl_monitor_info *list;
146
147		sdl_monitor_info * m_next; // pointer to next monitor in list
	183	#if defined(SDLMAME_WIN32) && !(SDLMAME_SDL2)
	184	static BOOL CALLBACK monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data);
	185	#endif
148	186	private:
149		void refresh();
	187	void virtual refresh();
150	188
151	189	UINT64 m_handle; // handle to the monitor
152		SDL_Rect m_dimensions;
153		char m_name[64];
154		float m_aspect; // computed/configured aspect ratio of the physical device
155	190	};
156	191
157	192	struct osd_video_config

trunk/src/osd/sdl/window.c
r244679	r244680
865	865	minimum_height -= 4;
866	866	}
867	867
868		num = SDL_GetNumDisplayModes(m_monitor->handle());
	868	// FIXME: this should be provided by monitor !
	869	num = SDL_GetNumDisplayModes(((UINT64 )m_monitor->handle()));
869	870
870	871	if (num == 0)
871	872	{
r244679	r244680
877	878	for (i = 0; i < num; ++i)
878	879	{
879	880	SDL_DisplayMode mode;
880		SDL_GetDisplayMode(m_monitor->handle(), i, &mode);
	881	SDL_GetDisplayMode(((UINT64 )m_monitor->handle()), i, &mode);
881	882
882	883	// compute initial score based on difference between target and current
883	884	size_score = 1.0f / (1.0f + fabsf((INT32)mode.w - target_width) + fabsf((INT32)mode.h - target_height));
r244679	r244680
1392	1393	INT32 viswidth, visheight;
1393	1394	INT32 adjwidth, adjheight;
1394	1395	float pixel_aspect;
1395		sdl_monitor_info *monitor = m_monitor;
	1396	osd_monitor_info *monitor = m_monitor;
1396	1397
1397	1398	// get the pixel aspect ratio for the target monitor
1398	1399	pixel_aspect = monitor->aspect();

trunk/src/osd/sdl/window.h
r244679	r244680
35	35	class sdl_window_info : public osd_window
36	36	{
37	37	public:
38		sdl_window_info(running_machine &a_machine, int index, sdl_monitor_info *a_monitor,
	38	sdl_window_info(running_machine &a_machine, int index, osd_monitor_info *a_monitor,
39	39	const osd_window_config *config)
40	40	: osd_window(), m_next(NULL),
41	41	// Following three are used by input code to defer resizes
r244679	r244680
94	94	int xy_to_render_target(int x, int y, int xt, int yt);
95	95
96	96	running_machine &machine() const { return m_machine; }
97		sdl_monitor_info *monitor() const { return m_monitor; }
	97	osd_monitor_info *monitor() const { return m_monitor; }
98	98	int fullscreen() const { return m_fullscreen; }
99	99
100	100	render_target *target() { return m_target; }
r244679	r244680
164	164	// Pointer to machine
165	165	running_machine & m_machine;
166	166	// monitor info
167		sdl_monitor_info * m_monitor;
	167	osd_monitor_info * m_monitor;
168	168	int m_fullscreen;
169	169	int m_index;
170	170	osd_renderer * m_renderer;

trunk/src/osd/windows/video.c
r244679	r244680
41	41	//============================================================
42	42
43	43	// monitor info
44		win_monitor_info *win_monitor_list;
45		static win_monitor_info *primary_monitor;
	44	osd_monitor_info *osd_monitor_info::list = NULL;
46	45
47
48
49	46	//============================================================
50	47	// PROTOTYPES
51	48	//============================================================
52	49
53	50	static void init_monitors(void);
54		static ~~win~~_monitor_info *pick_monitor(windows_options &options, int index);
	51	static osd_monitor_info *pick_monitor(windows_options &options, int index);
55	52
56	53	static void check_osd_inputs(running_machine &machine);
57	54
r244679	r244680
100	97	window_exit();
101	98
102	99	// free all of our monitor information
103		while (~~win~~_monitor_list != NULL)
	100	while (osd_monitor_info::list != NULL)
104	101	{
105		win_monitor_info *temp = win_monitor_list;
106		win_monitor_list = temp->m_next;
	102	osd_monitor_info *temp = osd_monitor_info::list;
	103	osd_monitor_info::list = temp->m_next;
107	104	global_free(temp);
108	105	}
109	106	}
110	107
111	108
112	109
113		win_monitor_info::win_monitor_info()
114		: m_next(NULL),
115		m_handle(NULL),
116		m_aspect(0.0f),
117		m_name(NULL)
	110	win_monitor_info::win_monitor_info(const HMONITOR handle, const char *monitor_device, float aspect)
	111	: osd_monitor_info(&m_handle, monitor_device, aspect), m_handle(handle)
118	112	{
119	113	}
120	114
121	115	win_monitor_info::~win_monitor_info()
122	116	{
123		if (m_name != NULL)
124		osd_free(m_name);
125	117	}
126	118
127	119	//============================================================
r244679	r244680
136	128	m_info.cbSize = sizeof(m_info);
137	129	result = GetMonitorInfo(m_handle, (LPMONITORINFO)&m_info);
138	130	assert(result);
139		if (m_name != NULL)
140		osd_free(m_name);
141		m_name = utf8_from_tstring(m_info.szDevice);
	131	char *temp = utf8_from_tstring(m_info.szDevice);
	132
	133	strncpy(m_name, temp, sizeof(m_name));
	134
	135	m_pos_size = RECT_to_osd_rect(m_info.rcMonitor);
	136	m_usuable_pos_size = RECT_to_osd_rect(m_info.rcWork);
	137	m_is_primary = ((m_info.dwFlags & MONITORINFOF_PRIMARY) != 0);
142	138	(void)result; // to silence gcc 4.6
143	139	}
144	140
145	141
146	142
147	143	//============================================================
148		// ~~win~~video_monitor_get_aspect
	144	// sdlvideo_monitor_get_aspect
149	145	//============================================================
150	146
151		float ~~win~~_monitor_info::aspect()
	147	float osd_monitor_info::aspect()
152	148	{
153	149	// refresh the monitor information and compute the aspect
154	150	refresh();
155	151	// FIXME: returning 0 looks odd, video_config is bad
156	152	if (video_config.keepaspect)
157	153	{
158		int width, height;
159		refresh();
160		width = rect_width(&m_info.rcMonitor);
161		height = rect_height(&m_info.rcMonitor);
162		return m_aspect / ((float)width / (float)height);
	154	return m_aspect / ((float)m_pos_size.width() / (float)m_pos_size.height());
163	155	}
164	156	return 0.0f;
165	157	}
166	158
167
168
169	159	//============================================================
170	160	// winvideo_monitor_from_handle
171	161	//============================================================
172	162
173		~~win~~_monitor_info *win_monitor_info::monitor_from_handle(HMONITOR hmonitor)
	163	osd_monitor_info *win_monitor_info::monitor_from_handle(HMONITOR hmonitor)
174	164	{
175		~~win~~_monitor_info *monitor;
	165	osd_monitor_info *monitor;
176	166
177	167	// find the matching monitor
178		for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->m_next)
179		if (monitor->handle() == hmonitor)
	168	for (monitor = osd_monitor_info::list; monitor != NULL; monitor = monitor->m_next)
	169	if (((HMONITOR )monitor->oshandle()) == hmonitor)
180	170	return monitor;
181	171	return NULL;
182	172	}
r244679	r244680
214	204
215	205	static void init_monitors(void)
216	206	{
217		~~win~~_monitor_info **tailptr;
	207	osd_monitor_info **tailptr;
218	208
219	209	// make a list of monitors
220		win_monitor_list = NULL;
221		tailptr = &win_monitor_list;
	210	osd_monitor_info::list = NULL;
	211	tailptr = &osd_monitor_info::list;
222	212	EnumDisplayMonitors(NULL, NULL, win_monitor_info::monitor_enum_callback, (LPARAM)&tailptr);
223	213
224	214	// if we're verbose, print the list of monitors
225	215	{
226		win_monitor_info *monitor;
227		for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->m_next)
	216	osd_monitor_info *monitor;
	217	for (monitor = osd_monitor_info::list; monitor != NULL; monitor = monitor->m_next)
228	218	{
229		osd_printf_verbose("Video: Monitor %p = \"%s\" %s\n", monitor->handle(), monitor->devicename(), (monitor == primary~~_monitor~~) ? "(primary)" : "");
	219	osd_printf_verbose("Video: Monitor %p = \"%s\" %s\n", monitor->oshandle(), monitor->devicename(), monitor->is_primary() ? "(primary)" : "");
230	220	}
231	221	}
232	222	}
r244679	r244680
239	229
240	230	BOOL CALLBACK win_monitor_info::monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data)
241	231	{
242		win_monitor_info *tailptr = (win_monitor_info *)data;
243		win_monitor_info *monitor;
	232	osd_monitor_info *tailptr = (osd_monitor_info *)data;
	233	osd_monitor_info *monitor;
244	234	MONITORINFOEX info;
245	235	BOOL result;
246	236
r244679	r244680
251	241	(void)result; // to silence gcc 4.6
252	242
253	243	// allocate a new monitor info
254		monitor = global_alloc(win_monitor_info);
255
	244	monitor = global_alloc(win_monitor_info(handle, "", 1.0f));
256	245	// copy in the data
257		monitor->m_handle = handle;
258		monitor->m_info = info;
	246	//monitor->refresh();
259	247
260	248	// guess the aspect ratio assuming square pixels
261	249	monitor->set_aspect((float)(info.rcMonitor.right - info.rcMonitor.left) / (float)(info.rcMonitor.bottom - info.rcMonitor.top));
262	250
263		// save the primary monitor handle
264		if (monitor->m_info.dwFlags & MONITORINFOF_PRIMARY)
265		primary_monitor = monitor;
266
267	251	// hook us into the list
268	252	**tailptr = monitor;
269	253	*tailptr = &monitor->m_next;
r244679	r244680
278	262	// pick_monitor
279	263	//============================================================
280	264
281		static ~~win~~_monitor_info *pick_monitor(windows_options &options, int index)
	265	static osd_monitor_info *pick_monitor(windows_options &options, int index)
282	266	{
283	267	const char scrname, scrname2;
284		~~win~~_monitor_info *monitor;
	268	osd_monitor_info *monitor;
285	269	int moncount = 0;
286	270	float aspect;
287	271
r244679	r244680
299	283	// look for a match in the name first
300	284	if (scrname != NULL && (scrname[0] != 0))
301	285	{
302		for (monitor = ~~win~~_monitor_list; monitor != NULL; monitor = monitor->m_next)
	286	for (monitor = osd_monitor_info::list; monitor != NULL; monitor = monitor->m_next)
303	287	{
304	288	moncount++;
305	289	if (strcmp(scrname, monitor->devicename()) == 0)
r244679	r244680
309	293
310	294	// didn't find it; alternate monitors until we hit the jackpot
311	295	index %= moncount;
312		for (monitor = ~~win~~_monitor_list; monitor != NULL; monitor = monitor->m_next)
	296	for (monitor = osd_monitor_info::list; monitor != NULL; monitor = monitor->m_next)
313	297	if (index-- == 0)
314	298	goto finishit;
315	299
316	300	// return the primary just in case all else fails
317		monitor = primary_monitor;
	301	for (monitor = osd_monitor_info::list; monitor != NULL; monitor = monitor->m_next)
	302	if (monitor->is_primary())
	303	goto finishit;
318	304
319	305	finishit:
320	306	if (aspect != 0)

trunk/src/osd/windows/video.h
r244679	r244680
54	54	class osd_rect
55	55	{
56	56	public:
	57	osd_rect()
	58	: m_x(0), m_y(0), m_d(0,0)
	59	{
	60	}
57	61	osd_rect(const int x, const int y, const int &w, const int &h)
58	62	: m_x(x), m_y(y), m_d(w,h)
59	63	{
r244679	r244680
86	90	return osd_rect(r.left, r.top, r.right - r.left, r.bottom - r.top);
87	91	}
88	92
89		class ~~win~~_monitor_info
	93	class osd_monitor_info
90	94	{
91	95	public:
92		win_monitor_info();
93		virtual ~win_monitor_info();
94	96
95		void refresh();
	97	#if 0
	98	osd_monitor_info()
	99	: m_next(NULL), m_handle(NULL), m_aspect(0.0f)
	100	{
	101	strcpy(m_name, "");
	102	}
	103	#endif
	104	osd_monitor_info(void handle, const char monitor_device, float aspect)
	105	: m_next(NULL), m_handle(handle), m_aspect(aspect)
	106	{
	107	strncpy(m_name, monitor_device, ARRAY_LENGTH(m_name) - 1);
	108	}
96	109
97		const HMONITOR handle() { return m_handle; }
98		// position_size is used only by draw_dd renderer
99		const osd_rect position_size() { refresh(); return RECT_to_osd_rect(m_info.rcMonitor); }
100		const osd_rect usuable_position_size() { refresh(); return RECT_to_osd_rect(m_info.rcWork); }
101		bool is_primary() { return (m_info.dwFlags & MONITORINFOF_PRIMARY) != 0; }
102		const char *devicename() { refresh(); return (m_name != NULL) ? m_name : "UNKNOWN"; }
	110	virtual ~osd_monitor_info() { }
103	111
	112	const void *oshandle() { return m_handle; }
	113
	114	const osd_rect &position_size() { refresh(); return m_pos_size; }
	115	const osd_rect &usuable_position_size() { refresh(); return m_usuable_pos_size; }
	116
	117	const char *devicename() { refresh(); return m_name[0] ? m_name : "UNKNOWN"; }
	118
104	119	float aspect();
105	120
106	121	void set_aspect(const float a) { m_aspect = a; }
	122	bool is_primary() { refresh(); return m_is_primary; }
107	123
108		~~win~~_monitor_info * m_next; // pointer to next monitor in list
	124	osd_monitor_info * next() { return m_next; } // pointer to next monitor in list
109	125
	126	#ifdef OSD_SDL
	127	static osd_monitor_info *pick_monitor(sdl_options &options, int index);
	128	#endif
	129	static osd_monitor_info *list;
	130
	131	// FIXME: should be private!
	132	osd_monitor_info *m_next; // pointer to next monitor in list
	133	protected:
	134	virtual void refresh() = 0;
	135	osd_rect m_pos_size;
	136	osd_rect m_usuable_pos_size;
	137	bool m_is_primary;
	138	char m_name[64];
	139	private:
	140
	141	void * m_handle; // handle to the monitor
	142	float m_aspect; // computed/configured aspect ratio of the physical device
	143	};
	144
	145	class win_monitor_info : public osd_monitor_info
	146	{
	147	public:
	148	win_monitor_info(const HMONITOR handle, const char *monitor_device, float aspect);
	149	virtual ~win_monitor_info();
	150
	151	virtual void refresh();
	152
110	153	// static
111	154
112	155	static BOOL CALLBACK monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data);
113		static ~~win~~_monitor_info *monitor_from_handle(HMONITOR monitor);
	156	static osd_monitor_info *monitor_from_handle(HMONITOR monitor);
114	157
	158	HMONITOR handle() { return m_handle; }
	159
115	160	private:
116	161	HMONITOR m_handle; // handle to the monitor
117	162	MONITORINFOEX m_info; // most recently retrieved info
118
119		float m_aspect; // computed/configured aspect ratio of the physical device
120		char * m_name;
121	163	};
122	164
123	165	struct osd_video_config

trunk/src/osd/windows/window.c
r244679	r244680
646	646	// (main thread)
647	647	//============================================================
648	648
649		void win_window_info::create(running_machine &machine, int index, ~~win~~_monitor_info monitor, const osd_window_config config)
	649	void win_window_info::create(running_machine &machine, int index, osd_monitor_info monitor, const osd_window_config config)
650	650	{
651	651	win_window_info window, win;
652	652
r244679	r244680
833	833	// (window thread)
834	834	//============================================================
835	835
836		~~win~~_monitor_info win_window_info::winwindow_video_window_monitor(const osd_rect proposed)
	836	osd_monitor_info win_window_info::winwindow_video_window_monitor(const osd_rect proposed)
837	837	{
838		~~win~~_monitor_info *monitor;
	838	osd_monitor_info *monitor;
839	839
840	840	// in window mode, find the nearest
841	841	if (!m_fullscreen)
r244679	r244680
858	858	monitor = m_monitor;
859	859
860	860	// make sure we're up-to-date
861		monitor->refresh();
	861	//monitor->refresh();
862	862	return monitor;
863	863	}
864	864
r244679	r244680
1523	1523	INT32 viswidth, visheight;
1524	1524	INT32 adjwidth, adjheight;
1525	1525	float pixel_aspect;
1526		~~win~~_monitor_info *monitor = winwindow_video_window_monitor(&rect);
	1526	osd_monitor_info *monitor = winwindow_video_window_monitor(&rect);
1527	1527
1528	1528	assert(GetCurrentThreadId() == window_threadid);
1529	1529
r244679	r244680
1686	1686	//assert(GetCurrentThreadId() == window_threadid);
1687	1687
1688	1688	// compute the maximum client area
1689		m_monitor->refresh();
	1689	//m_monitor->refresh();
1690	1690	osd_rect maximum = m_monitor->usuable_position_size();
1691	1691
1692	1692	// clamp to the window's max
r244679	r244680
1823	1823	// in full screen, make sure it covers the primary display
1824	1824	else
1825	1825	{
1826		~~win~~_monitor_info *monitor = winwindow_video_window_monitor(NULL);
	1826	osd_monitor_info *monitor = winwindow_video_window_monitor(NULL);
1827	1827	newrect = monitor->position_size();
1828	1828	}
1829	1829

trunk/src/osd/windows/window.h
r244679	r244680
46	46
47	47	void update();
48	48
49		~~win~~_monitor_info winwindow_video_window_monitor(const osd_rect proposed);
	49	osd_monitor_info winwindow_video_window_monitor(const osd_rect proposed);
50	50
51	51	bool win_has_menu()
52	52	{
r244679	r244680
60	60	return osd_dim(client.right - client.left, client.bottom - client.top);
61	61	}
62	62
63		~~win~~_monitor_info *monitor() const { return m_monitor; }
	63	osd_monitor_info *monitor() const { return m_monitor; }
64	64
65	65	void destroy();
66	66
67	67	// static
68	68
69		static void create(running_machine &machine, int index, ~~win~~_monitor_info monitor, const osd_window_config config);
	69	static void create(running_machine &machine, int index, osd_monitor_info monitor, const osd_window_config config);
70	70
71	71	// static callbacks
72	72
r244679	r244680
86	86	int m_ismaximized;
87	87
88	88	// monitor info
89		~~win~~_monitor_info * m_monitor;
	89	osd_monitor_info * m_monitor;
90	90	int m_fullscreen;
91	91	int m_fullscreen_safe;
92	92	float m_aspect;

https://github.com/mamedev/mame/commit/563ff83b3bdda3c64d7f06678ab47c03cbcc619b

199869 Revisions