MAME SVN History

199869 Revisions

r34887 Friday 6th February, 2015 at 09:13:57 UTC by David Haywood
added build date information to the Gun Smoke sets, based on strings in ROM (nw)

[src/build]	flags_clang.mak
[src/lib/formats]	kaypro_dsk.c kaypro_dsk.h
[src/mame]	mame.lst
[src/mame/drivers]	gunsmoke.c peplus.c silvmil.c
[src/mame/video]	jagblit.inc
[src/mess/drivers]	kaypro.c pc9801.c
[src/mess/includes]	kaypro.h
[src/mess/machine]	kaypro.c
[src/osd/sdl]	draw13.c drawbgfx.c drawogl.c drawsdl.c window.c window.h
[src/osd/windows]	d3dhlsl.c drawbgfx.c drawd3d.c drawd3d.h drawdd.c drawgdi.c drawnone.c window.c window.h

trunk/src/build/flags_clang.mak
r243398	r243399
5	5	# caused by obj/sdl64d/emu/cpu/tms57002/tms57002.inc
6	6	CCOMFLAGS += -Wno-self-assign-field
7	7
	8	# caused by src/mame/video/jagblit.inc on older clang versions
	9	#CCOMFLAGS += -Wno-constant-logical-operand
	10
8	11	# caused by popmessage(NULL) on older clang versions
9	12	#CCOMFLAGS += -Wno-format-security
10	13
r243398	r243399
29	32
30	33	ifeq ($(findstring 3.4,$(TEST_CLANG)),3.4)
31	34	CCOMFLAGS += -Wno-inline-new-delete
32
33		# caused by src/mame/video/jagblit.inc
34		CCOMFLAGS += -Wno-constant-logical-operand
35	35	endif
36	36
37	37	ifeq ($(findstring 3.5,$(TEST_CLANG)),3.5)

trunk/src/lib/formats/kaypro_dsk.c
r243398	r243399
1	1	// license:BSD-3-Clause
2		// copyright-holders:Olivier Galibert~~, Robbbert~~
	2	// copyright-holders:Olivier Galibert
3	3	/*********************************************************************
4	4
5	5	formats/kaypro_dsk.c
r243398	r243399
9	9	There is no inter-sector info on these disks. It is simply a
10	10	dump of the 512 bytes from each sector and track in order.
11	11	It is just like a headerless quickload.
12		Base class and gaps verified by OG. Please note that these
13		disks usually have DSK extension, but that conflicts with
14		the CPCEMU DSK format. You need to rename your Kaypro DSK
15		disks to KAY extension.
16	12
17	13	*********************************************************************/
18	14
19	15	#include "emu.h"
20	16	#include "formats/kaypro_dsk.h"
21	17
22		kayproii_format::kayproii_format() : upd765_format(formats)
	18	kayproii_format::kayproii_format() : wd177x_format(formats)
23	19	{
24	20	}
25	21
r243398	r243399
35	31
36	32	const char *kayproii_format::extensions() const
37	33	{
38		return "kay";
	34	return "dsk";
39	35	}
40	36
	37	// gap info is a total guess
41	38	const kayproii_format::format kayproii_format::formats[] = {
42	39	{ /* 191K 13cm double density single sided */
43	40	floppy_image::FF_525, floppy_image::SSDD, floppy_image::MFM,
44		2000, 10, 40, 1, 512, {}, 0, {}, 80, ~~16,~~ 22, 26
	41	2000, 10, 40, 1, 512, {}, 1, {}, 32, 22, 31
45	42	},
46	43	{}
47	44	};
48	45
49		kaypro2x_format::kaypro2x_format() : upd765_format(formats)
	46	kaypro2x_format::kaypro2x_format() : wd177x_format(formats)
50	47	{
51	48	}
52	49
r243398	r243399
62	59
63	60	const char *kaypro2x_format::extensions() const
64	61	{
65		return "kay";
	62	return "dsk";
66	63	}
67	64
	65	// gap info is a total guess
68	66	const kaypro2x_format::format kaypro2x_format::formats[] = {
69	67	{ /* 382K 13cm double density double sided */
70	68	floppy_image::FF_525, floppy_image::DSDD, floppy_image::MFM,
71		2000, 10, 40, 2, 512, {}, 0, {}, 80, ~~16,~~ 22, 26
	69	2000, 10, 80, 2, 512, {}, 1, {}, 32, 22, 31
72	70	},
73	71	{}
74	72	};

trunk/src/lib/formats/kaypro_dsk.h
r243398	r243399
9	9	#ifndef KAYPRO_DSK_H_
10	10	#define KAYPRO_DSK_H_
11	11
12		#include "upd765_dsk.h"
	12	#include "wd177x_dsk.h"
13	13
14		class kayproii_format : public upd765_format {
	14	class kayproii_format : public wd177x_format {
15	15	public:
16	16	kayproii_format();
17	17
r243398	r243399
23	23	static const format formats[];
24	24	};
25	25
26		class kaypro2x_format : public upd765_format {
	26	class kaypro2x_format : public wd177x_format {
27	27	public:
28	28	kaypro2x_format();
29	29

trunk/src/mame/drivers/gunsmoke.c
r243398	r243399
578	578
579	579	/* Game Drivers */
580	580
581		GAME( 1985, gunsmoke, 0, gunsmoke, gunsmoke, driver_device, 0, ROT270, "Capcom", "Gun.Smoke (World)", GAME_SUPPORTS_SAVE )
582		GAME( 1985, gunsmokeb, gunsmoke, gunsmoke, gunsmoke, driver_device, 0, ROT270, "bootleg", "Gun.Smoke (bootleg)", GAME_SUPPORTS_SAVE ) // based on world version, warning message patched out
583		GAME( 1985, gunsmokej, gunsmoke, gunsmoke, gunsmoke, driver_device, 0, ROT270, "Capcom", "Gun.Smoke (Japan)", GAME_SUPPORTS_SAVE )
584		GAME( 1985, gunsmokeu, gunsmoke, gunsmoke, gunsmoke, driver_device, 0, ROT270, "Capcom (Romstar license)", "Gun.Smoke (US set 1)", GAME_SUPPORTS_SAVE )
585		GAME( 1986, gunsmokeua, gunsmoke, gunsmoke, gunsmokeua, driver_device, 0, ROT270, "Capcom (Romstar license)", "Gun.Smoke (US set 2)", GAME_SUPPORTS_SAVE )
	581	// at 0x7E50 in the first rom is 85113 (project ident code?) and the project codename 'Gunman' both stored as ASCII.
	582	// Following that at (stored as raw data) is the build date in yyyymmdd format. After that a ROM identification string(?) which I've
	583	// left in the comment after each set.
	584
	585	// this information is not displayed onscreen
	586
	587	GAME( 1985, gunsmoke, 0, gunsmoke, gunsmoke, driver_device, 0, ROT270, "Capcom", "Gun.Smoke (World, 851115)", GAME_SUPPORTS_SAVE ) // GSE_03
	588	GAME( 1985, gunsmokeb, gunsmoke, gunsmoke, gunsmoke, driver_device, 0, ROT270, "bootleg", "Gun.Smoke (World, 851115) (bootleg)", GAME_SUPPORTS_SAVE ) // based on above version, warning message patched out
	589	GAME( 1985, gunsmokej, gunsmoke, gunsmoke, gunsmoke, driver_device, 0, ROT270, "Capcom", "Gun.Smoke (Japan, 851115)", GAME_SUPPORTS_SAVE ) // GSJ_03
	590	GAME( 1985, gunsmokeu, gunsmoke, gunsmoke, gunsmoke, driver_device, 0, ROT270, "Capcom (Romstar license)", "Gun.Smoke (US, 851115)", GAME_SUPPORTS_SAVE ) // GSR_03
	591	GAME( 1986, gunsmokeua, gunsmoke, gunsmoke, gunsmokeua, driver_device, 0, ROT270, "Capcom (Romstar license)", "Gun.Smoke (US, 860408)", GAME_SUPPORTS_SAVE ) // GSA_03

trunk/src/mame/drivers/peplus.c
r243398	r243399
5014	5014	ROM_LOAD( "cap1004.u50", 0x0000, 0x0100, CRC(5eced808) SHA1(b40b8efa8cbc76cff7560c36939275eb360c6f11) )
5015	5015	ROM_END
5016	5016
5017		ROM_START( peps0090 ) /* Normal board : Gold, Silver & Bronze (PS0090) - Payout 90.19% */
5018		ROM_REGION( 0x10000, "maincpu", 0 )
5019		ROM_LOAD( "ps0090_569-a2c.u68", 0x00000, 0x10000, CRC(5a727ff0) SHA1(6eed9d85620eff751c598d56807470f8753e8dd5) ) /* 3 Coins Max / 1 Line */
5020
5021		ROM_REGION( 0x020000, "gfx1", 0 )
5022		ROM_LOAD( "mro-cg1059.u72", 0x00000, 0x8000, CRC(96210de3) SHA1(10daa358f1fc507e9f4c788265c0acc57678fa40) ) /* Also contains graphics for Double Diamonds, use CAP1003 */
5023		ROM_LOAD( "mgo-cg1059.u73", 0x08000, 0x8000, CRC(cfb9a357) SHA1(a390bed240960efd8da6e7815a0b0d272133f20f) )
5024		ROM_LOAD( "mbo-cg1059.u74", 0x10000, 0x8000, CRC(6c159972) SHA1(b6fbebba2749534b7fcb9cd32fe17cdc673912f7) )
5025		ROM_LOAD( "mxo-cg1059.u75", 0x18000, 0x8000, CRC(7ec9d699) SHA1(45ec30370d2ef12511f897cb1155327ed4d2ce01) )
5026
5027		ROM_REGION( 0x100, "proms", 0 )
5028		ROM_LOAD( "cap1059.u50", 0x0000, 0x0100, CRC(a995258f) SHA1(5c33fb2a9a939cfdf4634f886690fa7ccc57fe52) )
5029		ROM_END
5030
5031	5017	ROM_START( peps0092 ) /* Normal board : Wild Cherry Slots (PS0092) - Payout 90.18% */
5032	5018	ROM_REGION( 0x10000, "maincpu", 0 )
5033	5019	ROM_LOAD( "ps0092_569-a2c.u68", 0x00000, 0x10000, CRC(d533f6d5) SHA1(9c470f7c474022445aeb45ee8c5757d1b6957a91) ) /* 3 Coins Max / 1 Line */
r243398	r243399
9297	9283	GAMEL(1996, peps0043, peps0042, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0043) Double Diamond Slots", 0, layout_pe_slots )
9298	9284	GAMEL(1996, peps0045, peps0021, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0045) Red White & Blue Slots", 0, layout_pe_slots )
9299	9285	GAMEL(1996, peps0047, 0, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0047) Wild Cherry Slots", GAME_NOT_WORKING, layout_pe_slots ) /* Needs MxO-CG1004.Uxx graphics roms redumped */
9300		GAMEL(1996, peps0090, 0, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0090) Gold, Silver & Bronze Slots", 0, layout_pe_slots )
9301	9286	GAMEL(1996, peps0092, peps0047, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0092) Wild Cherry Slots", GAME_NOT_WORKING, layout_pe_slots ) /* Needs MxO-CG1004.Uxx graphics roms redumped */
9302	9287	GAMEL(1996, peps0206, peps0021, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0206) Red White & Blue Slots", 0, layout_pe_slots )
9303	9288	GAMEL(1996, peps0207, peps0021, peplus, peplus_slots, peplus_state, peplus, ROT0, "IGT - International Game Technology", "Player's Edge Plus (PS0207) Red White & Blue Slots", 0, layout_pe_slots )

trunk/src/mame/drivers/silvmil.c
r243398	r243399
287	287	PORT_BIT( 0x0200, IP_ACTIVE_LOW, IPT_COIN2 )
288	288	PORT_BIT( 0xfc00, IP_ACTIVE_LOW, IPT_UNKNOWN )
289	289
290		PORT_START("DSW") /* NOTE: In the service mode, the game reports the dipswitch banks in reverse. IE: SW1 is actually SW2 & SW2 is actually SW1 */
291		PORT_DIPUNUSED_DIPLOC( 0x0001, 0x0001, "SW1:1" ) /* Listed as "Unused" */
292		PORT_DIPUNUSED_DIPLOC( 0x0002, 0x0002, "SW1:2" ) /* Listed as "Unused" */
293		PORT_DIPUNUSED_DIPLOC( 0x0004, 0x0004, "SW1:3" ) /* Listed as "Unused" */
294		PORT_DIPUNUSED_DIPLOC( 0x0008, 0x0008, "SW1:4" ) /* Listed as "Unused" */
295		PORT_DIPUNUSED_DIPLOC( 0x0010, 0x0010, "SW1:5" ) /* Listed as "Unused" */
296		PORT_DIPUNUSED_DIPLOC( 0x0020, 0x0020, "SW1:6" ) /* Listed as "Unused" */
297		PORT_DIPUNUSED_DIPLOC( 0x0040, 0x0040, "SW1:7" ) /* Listed as "Unused" */
298		PORT_DIPUNUSED_DIPLOC( 0x0080, 0x0080, "SW1:8" ) /* Listed as "Unused" */
299		PORT_DIPNAME( 0x0300, 0x0100, DEF_STR( Difficulty ) ) PORT_DIPLOCATION("SW2:1,2")
300		PORT_DIPSETTING( 0x0300, DEF_STR( Very_Easy ) ) /* Initial start time 40 secs */
301		PORT_DIPSETTING( 0x0200, DEF_STR( Easy ) ) /* Initial start time 30 secs - Other in game effects?? */
302		PORT_DIPSETTING( 0x0100, DEF_STR( Hard ) ) /* Initial start time 30 secs - Other in game effects?? */
303		PORT_DIPSETTING( 0x0000, DEF_STR( Very_Hard ) ) /* Initial start time 30 secs - Other in game effects?? */
304		PORT_DIPNAME( 0x1c00, 0x1c00, DEF_STR( Coinage ) ) PORT_DIPLOCATION("SW2:3,4,5")
	290	PORT_START("DSW")
	291	PORT_DIPNAME( 0x0001, 0x0001, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:1")
	292	PORT_DIPSETTING( 0x0001, DEF_STR( Off ) )
	293	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	294	PORT_DIPNAME( 0x0002, 0x0002, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:2")
	295	PORT_DIPSETTING( 0x0002, DEF_STR( Off ) )
	296	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	297	PORT_DIPNAME( 0x0004, 0x0004, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:3")
	298	PORT_DIPSETTING( 0x0004, DEF_STR( Off ) )
	299	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	300	PORT_DIPNAME( 0x0008, 0x0008, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:4")
	301	PORT_DIPSETTING( 0x0008, DEF_STR( Off ) )
	302	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	303	PORT_DIPNAME( 0x0010, 0x0010, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:5")
	304	PORT_DIPSETTING( 0x0010, DEF_STR( Off ) )
	305	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	306	PORT_DIPNAME( 0x0020, 0x0020, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:6")
	307	PORT_DIPSETTING( 0x0020, DEF_STR( Off ) )
	308	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	309	PORT_DIPNAME( 0x0040, 0x0040, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:7")
	310	PORT_DIPSETTING( 0x0040, DEF_STR( Off ) )
	311	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	312	PORT_DIPNAME( 0x0080, 0x0080, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:8")
	313	PORT_DIPSETTING( 0x0080, DEF_STR( Off ) )
	314	PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
	315	PORT_DIPNAME( 0x0300, 0x0300, "Game Level" ) PORT_DIPLOCATION("SW1:1,2") /* Difficulty?? - Not sure how this works for Easy --> Very Hard */
	316	PORT_DIPSETTING( 0x0300, "1" ) /* Initial start time 40 secs */
	317	PORT_DIPSETTING( 0x0200, "2" ) /* Initial start time 30 secs - Other in game effects?? */
	318	PORT_DIPSETTING( 0x0100, "3" ) /* Initial start time 30 secs - Other in game effects?? */
	319	PORT_DIPSETTING( 0x0000, "4" ) /* Initial start time 30 secs - Other in game effects?? */
	320	PORT_DIPNAME( 0x1c00, 0x1c00, DEF_STR( Coinage ) ) PORT_DIPLOCATION("SW1:3,4,5")
305	321	PORT_DIPSETTING( 0x1000, DEF_STR( 4C_1C ) )
306	322	PORT_DIPSETTING( 0x1400, DEF_STR( 3C_1C ) )
307	323	PORT_DIPSETTING( 0x0000, DEF_STR( 4C_2C ) ) /* Works the same as 2C/1C */
r243398	r243399
310	326	PORT_DIPSETTING( 0x0800, DEF_STR( 2C_2C ) ) /* Works the same as 1C/1C */
311	327	PORT_DIPSETTING( 0x1c00, DEF_STR( 1C_1C ) )
312	328	PORT_DIPSETTING( 0x0c00, DEF_STR( 1C_2C ) )
313		PORT_DIPNAME( 0x2000, 0x2000, "Coin Box" ) PORT_DIPLOCATION("SW2:6") /* Always displays total credits - No separate Credit display per player */
	329	PORT_DIPNAME( 0x2000, 0x2000, "Coin Box" ) PORT_DIPLOCATION("SW1:6") /* Always displays total credits - No separate Credit display per player */
314	330	PORT_DIPSETTING( 0x2000, "1" ) /* Both players use coins from either Coin 1 or Coin 2 */
315	331	PORT_DIPSETTING( 0x0000, "2" ) /* Players use coins from own coin chute. IE: Player 1 -> Coin 1, Player 2 -> Coin 2 but shows only total credits */
316		PORT_DIPNAME( 0x4000, 0x4000, DEF_STR( Lives ) ) PORT_DIPLOCATION("SW2:7")
	332	PORT_DIPNAME( 0x4000, 0x4000, DEF_STR( Lives ) ) PORT_DIPLOCATION("SW1:7")
317	333	PORT_DIPSETTING( 0x0000, "2" )
318	334	PORT_DIPSETTING( 0x4000, "3" )
319		PORT_SERVICE_DIPLOC( 0x8000, IP_ACTIVE_LOW, "SW2:8" ) /* Verified */
	335	PORT_SERVICE_DIPLOC( 0x8000, IP_ACTIVE_LOW, "SW1:8" ) /* Verified */
320	336	INPUT_PORTS_END
321	337
322	338

trunk/src/mame/mame.lst
r243398	r243399
11212	11212	peps0043 // (c) 1996 IGT - International Game Technology
11213	11213	peps0045 // (c) 1996 IGT - International Game Technology
11214	11214	peps0047 // (c) 1996 IGT - International Game Technology
11215		peps0090 // (c) 1996 IGT - International Game Technology
11216	11215	peps0092 // (c) 1996 IGT - International Game Technology
11217	11216	peps0206 // (c) 1996 IGT - International Game Technology
11218	11217	peps0207 // (c) 1996 IGT - International Game Technology

trunk/src/mame/video/jagblit.inc
r243398	r243399
344	344	}
345	345
346	346	/* check for unhandled command bits */
347		if (~~LOG_UNHANDLED_BLITS &&~~ (COMMAND & 0x24003000))
	347	if ((COMMAND & 0x24003000) && LOG_UNHANDLED_BLITS)
348	348	logerror("Blitter unhandled: these command bits: %08X\n", COMMAND & 0x24003000);
349	349
350	350	/* top of the outer loop */

trunk/src/mess/drivers/kaypro.c
r243398	r243399
163	163
164	164	************************************************************/
165	165
166		FLOPPY_FORMATS_MEMBER( kaypro_state::kayproii_floppy_formats )
167		FLOPPY_KAYPROII_FORMAT
168		FLOPPY_FORMATS_END
169
170		FLOPPY_FORMATS_MEMBER( kaypro_state::kaypro2x_floppy_formats )
171		FLOPPY_KAYPRO2X_FORMAT
172		FLOPPY_FORMATS_END
173
174	166	static SLOT_INTERFACE_START( kaypro_floppies )
175	167	SLOT_INTERFACE( "drive0", FLOPPY_525_DD )
176	168	SLOT_INTERFACE( "drive1", FLOPPY_525_DD )
r243398	r243399
232	224	MCFG_WD_FDC_INTRQ_CALLBACK(WRITELINE(kaypro_state, fdc_intrq_w))
233	225	MCFG_WD_FDC_DRQ_CALLBACK(WRITELINE(kaypro_state, fdc_drq_w))
234	226	MCFG_WD_FDC_FORCE_READY
235		MCFG_FLOPPY_DRIVE_ADD("fdc:0", kaypro_floppies, "drive0", kaypro_state::kayproii_floppy_formats)
236		MCFG_FLOPPY_DRIVE_ADD("fdc:1", kaypro_floppies, "drive1", kaypro_state::kayproii_floppy_formats)
	227	MCFG_FLOPPY_DRIVE_ADD("fdc:0", kaypro_floppies, "drive0", floppy_image_device::default_floppy_formats)
	228	MCFG_FLOPPY_DRIVE_ADD("fdc:1", kaypro_floppies, "drive1", floppy_image_device::default_floppy_formats)
237	229	MCFG_SOFTWARE_LIST_ADD("flop_list","kayproii")
238	230	MACHINE_CONFIG_END
239	231
r243398	r243399
295	287	MCFG_WD_FDC_INTRQ_CALLBACK(WRITELINE(kaypro_state, fdc_intrq_w))
296	288	MCFG_WD_FDC_DRQ_CALLBACK(WRITELINE(kaypro_state, fdc_drq_w))
297	289	MCFG_WD_FDC_FORCE_READY
298		MCFG_FLOPPY_DRIVE_ADD("fdc:0", kaypro_floppies, "drive0", kaypro_state::kaypro2x_floppy_formats)
299		MCFG_FLOPPY_DRIVE_ADD("fdc:1", kaypro_floppies, "drive1", kaypro_state::kaypro2x_floppy_formats)
	290	MCFG_FLOPPY_DRIVE_ADD("fdc:0", kaypro_floppies, "drive0", floppy_image_device::default_floppy_formats)
	291	MCFG_FLOPPY_DRIVE_ADD("fdc:1", kaypro_floppies, "drive1", floppy_image_device::default_floppy_formats)
300	292	MACHINE_CONFIG_END
301	293
302	294	static MACHINE_CONFIG_DERIVED( omni2, kaypro4 )

trunk/src/mess/drivers/pc9801.c
r243398	r243399
1369	1369	UINT16 pc9801_state::egc_do_partial_op(int plane, UINT16 src, UINT16 pat, UINT16 dst)
1370	1370	{
1371	1371	UINT16 out = 0;
	1372	int dst_off = (m_egc.regs[6] >> 4) & 0xf;
	1373	UINT16 src_tmp = src;
1372	1374
1373	1375	for(int i = 7; i >= 0; i--)
1374	1376	{

trunk/src/mess/includes/kaypro.h
r243398	r243399
59	59	DECLARE_PALETTE_INIT(kaypro);
60	60	DECLARE_MACHINE_RESET(kay_kbd);
61	61	DECLARE_DRIVER_INIT(kaypro);
62		DECLARE_FLOPPY_FORMATS(kayproii_floppy_formats);
63		DECLARE_FLOPPY_FORMATS(kaypro2x_floppy_formats);
64	62	UINT32 screen_update_kayproii(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
65	63	UINT32 screen_update_kaypro2x(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
66	64	UINT32 screen_update_omni2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mess/machine/kaypro.c
r243398	r243399
114	114	m_floppy = m_floppy1->get_device();
115	115
116	116	m_fdc->set_floppy(m_floppy);
117		m_fdc->dden_w(BIT(data, 5));
	117	m_fdc->dden_w(BIT(data, 5)); // not connected
118	118
119	119	if (m_floppy)
120	120	{
r243398	r243399
252	252	m_system_port = 0x80;
253	253	m_fdc_rq = 0;
254	254	m_maincpu->reset();
255		timer_set(attotime::from_hz(1), TIMER_FLOPPY); /* ~~kick-s~~t~~art the nm~~i timer */
	255	timer_set(attotime::from_hz(1), TIMER_FLOPPY); /* timer for rtc */
256	256	}
257	257
258	258

trunk/src/osd/sdl/draw13.c
r243398	r243399
145	145	sdl_info13(sdl_window_info *w)
146	146	: osd_renderer(w, FLAG_NONE), m_blittimer(0), m_sdl_renderer(NULL),
147	147	m_last_hofs(0), m_last_vofs(0),
148		m_last_width(0), m_last_height(0),
	148	m_resize_pending(0), m_resize_width(0), m_resize_height(0),
149	149	m_last_blit_time(0), m_last_blit_pixels(0)
150	150	{}
151	151
152		/* virtual */ int create();
	152	/* virtual */ int create(const int width, const int height);
	153	/* virtual */ void resize(const int width, const int height);
153	154	/* virtual */ int draw(const UINT32 dc, const int update);
154	155	/* virtual / int xy_to_render_target(const int x, const int y, int xt, int *yt);
155	156	/* virtual */ void destroy_all_textures();
r243398	r243399
176	177	float m_last_hofs;
177	178	float m_last_vofs;
178	179
179		int m_last_width;
180		int m_last_height;
	180	// resize information
181	181
	182	UINT8 m_resize_pending;
	183	UINT32 m_resize_width;
	184	UINT32 m_resize_height;
	185
182	186	// Stats
183	187	INT64 m_last_blit_time;
184	188	INT64 m_last_blit_pixels;
r243398	r243399
572	576	// a
573	577	//============================================================
574	578
575		int sdl_info13::create()
	579	int sdl_info13::create(int width, int height)
576	580	{
577	581	#if (SDLMAME_SDL2)
578	582	// create renderer
r243398	r243399
613	617	return 0;
614	618	}
615	619
	620	//============================================================
	621	// sdl_info::resize
	622	//============================================================
616	623
	624	void sdl_info13::resize(int width, int height)
	625	{
	626	SDL_RenderSetViewport(m_sdl_renderer, NULL);
	627	m_blittimer = 3;
	628	}
	629
	630
617	631	//============================================================
618	632	// sdl_info::destroy
619	633	//============================================================
r243398	r243399
681	695	return 0;
682	696	}
683	697
684		if ((window().width() != m_last_width) \|\| (window().height() != m_last_height))
	698	#if 0
	699	if (m_resize_pending)
685	700	{
686		m_last_width = window().width();
687		m_last_height = window().height();
	701	SDL_SetWindowSize(window().m_sdl_window, m_resize_width, m_resize_height);
	702	SDL_GetWindowSize(window().m_sdl_window, &window().width(), &window().height());
	703	m_resize_pending = 0;
688	704	SDL_RenderSetViewport(m_sdl_renderer, NULL);
689		m_blittimer = 3;
	705	//sdlvideo_monitor_refresh(window().monitor());
	706
690	707	}
	708	#endif
691	709	//SDL_SelectRenderer(window().sdl_window);
692	710
693	711	if (m_blittimer > 0)

trunk/src/osd/sdl/drawbgfx.c
r243398	r243399
79	79	m_last_blit_time(0), m_last_blit_pixels(0)
80	80	{}
81	81
82		/* virtual */ int create();
	82	/* virtual */ int create(const int width, const int height);
	83	/* virtual */ void resize(const int width, const int height);
83	84	/* virtual */ int draw(const UINT32 dc, const int update);
84	85	/* virtual / int xy_to_render_target(const int x, const int y, int xt, int *yt);
85	86	/* virtual */ void destroy_all_textures();
r243398	r243399
134	135	// sdl_info_bgfx::create
135	136	//============================================================
136	137
137		int sdl_info_bgfx::create()
	138	int sdl_info_bgfx::create(int width, int height)
138	139	{
139	140	// create renderer
140	141
r243398	r243399
151	152	}
152	153
153	154	//============================================================
	155	// sdl_info_bgfx::resize
	156	//============================================================
	157
	158	void sdl_info_bgfx::resize(int width, int height)
	159	{
	160	m_blittimer = 3;
	161	}
	162
	163	//============================================================
154	164	// drawsdl_xy_to_render_target
155	165	//============================================================
156	166

trunk/src/osd/sdl/drawogl.c
r243398	r243399
224	224	sdl_info_ogl(sdl_window_info *window)
225	225	: osd_renderer(window, FLAG_NEEDS_OPENGL), m_blittimer(0),
226	226	m_screen_width(0), m_screen_height(0),
227		m_last_width(0), m_last_height(0),
228	227	#if (SDLMAME_SDL2)
229	228	m_gl_context_id(0),
230	229	#else
r243398	r243399
252	251	m_texVerticex[i] = 0.0f;
253	252	}
254	253
255		/* virtual */ int create();
	254	/* virtual */ int create(const int width, const int height);
	255	/* virtual */ void resize(const int width, int const height);
256	256	/* virtual */ int draw(const UINT32 dc, const int update);
257	257	/* virtual / int xy_to_render_target(const int x, const int y, int xt, int *yt);
258	258	/* virtual */ void destroy_all_textures();
r243398	r243399
280	280	INT32 m_blittimer;
281	281	int m_screen_width;
282	282	int m_screen_height;
283		int m_last_width;
284		int m_last_height;
285	283
286	284	#if (SDLMAME_SDL2)
287	285	SDL_GLContext m_gl_context_id;
r243398	r243399
711	709	// a
712	710	//============================================================
713	711
714		int sdl_info_ogl::create()
	712	int sdl_info_ogl::create(int width, int height)
715	713	{
716	714
717	715	#if (SDLMAME_SDL2)
r243398	r243399
756	754	return 0;
757	755	}
758	756
	757	//============================================================
	758	// sdl_info::resize
	759	//============================================================
759	760
	761	void sdl_info_ogl::resize(int width, int height)
	762	{
	763	#if (SDLMAME_SDL2)
	764	m_blittimer = 3;
	765	#endif
	766	m_init_context = 1;
	767	}
	768
	769
760	770	//============================================================
761	771	// sdl_info::destroy
762	772	//============================================================
r243398	r243399
1211	1221	return 0;
1212	1222	}
1213	1223
1214		if ((window().width() != m_last_width) \|\| (window().height() != m_last_height))
1215		{
1216		m_last_width = window().width();
1217		m_last_height = window().height();
1218	1224	#if (SDLMAME_SDL2)
1219		m_blittimer = 3;
1220		#endif
1221		m_init_context = 1;
1222		}
1223
1224		#if (SDLMAME_SDL2)
1225	1225	SDL_GL_MakeCurrent(window().sdl_window(), m_gl_context_id);
1226	1226	#else
1227	1227	if (!m_init_context)

trunk/src/osd/sdl/drawsdl.c
r243398	r243399
65	65	m_last_hofs(0),
66	66	m_last_vofs(0),
67	67	m_old_blitwidth(0),
68		m_old_blitheight(0),
69		m_last_width(0),
70		m_last_height(0)
	68	m_old_blitheight(0)
71	69	{ }
72	70
73		/* virtual */ int create();
	71	/* virtual */ int create(const int width, const int height);
	72	/* virtual */ void resize(const int width, const int height);
74	73	/* virtual */ int draw(const UINT32 dc, const int update);
75	74	/* virtual / int xy_to_render_target(const int x, const int y, int xt, int *yt);
76	75	/* virtual */ void destroy_all_textures();
r243398	r243399
108	107	int m_last_vofs;
109	108	int m_old_blitwidth;
110	109	int m_old_blitheight;
111		int m_last_width;
112		int m_last_height;
113	110	};
114	111
115	112	struct sdl_scale_mode
r243398	r243399
419	416	// a
420	417	//============================================================
421	418
422		int sdl_info::create()
	419	int sdl_info::create(int width, int height)
423	420	{
424	421
425	422	#if (SDLMAME_SDL2)
r243398	r243399
465	462	}
466	463	}
467	464
468		setup_texture(wind~~ow().wid~~th(), ~~window().~~height());
	465	setup_texture(width, height);
469	466	#else
470	467	#endif
471	468
r243398	r243399
478	475	}
479	476
480	477	//============================================================
	478	// sdl_info::resize
	479	//============================================================
	480
	481	void sdl_info::resize(int width, int height)
	482	{
	483	#if (SDLMAME_SDL2)
	484	SDL_RenderSetViewport(m_sdl_renderer, NULL);
	485	#else
	486	const sdl_scale_mode *sdl_sm = &scale_modes[video_config.scale_mode];
	487	if (sdl_sm->is_yuv)
	488	{
	489	yuv_overlay_init();
	490	}
	491	#endif
	492	}
	493
	494
	495	//============================================================
481	496	// sdl_info::destroy
482	497	//============================================================
483	498
r243398	r243399
565	580	return 0;
566	581	}
567	582
568		if ((window().width() != m_last_width) \|\| (window().height() != m_last_height))
569		{
570		m_last_width = window().width();
571		m_last_height = window().height();
572		#if (SDLMAME_SDL2)
573		SDL_RenderSetViewport(m_sdl_renderer, NULL);
574		#else
575		const sdl_scale_mode *sdl_sm = &scale_modes[video_config.scale_mode];
576		if (sdl_sm->is_yuv)
577		{
578		yuv_overlay_init();
579		}
580		#endif
581		}
582
583	583	// lock it if we need it
584	584	#if (!SDLMAME_SDL2)
585	585

trunk/src/osd/sdl/window.c
r243398	r243399
491	491	window->m_height = window->m_sdlsurf->h;
492	492	#endif
493	493
	494
	495	window->renderer().resize(window->m_width, window->m_height);
	496
494	497	window->blit_surface_size(window->m_width, window->m_height);
495	498
496	499	window->clear();
r243398	r243399
708	711	#endif
709	712	}
710	713
711		OSDWORK_CALLBACK( sdl_window_~~info::~~update_cursor_state_wt )
	714	static OSDWORK_CALLBACK( sdlwindow_update_cursor_state_wt )
712	715	{
713	716	worker_param * wp = (worker_param *) param;
714	717	sdl_window_info * window = wp->window();
r243398	r243399
1020	1023	// adjust the cursor state
1021	1024	//sdlwindow_update_cursor_state(machine, window);
1022	1025
1023		execute_async(&update_cursor_state_wt, worker_param(this));
	1026	execute_async(&sdlwindow_update_cursor_state_wt, worker_param(this));
1024	1027
1025	1028	// if we're visible and running and not in the middle of a resize, draw
1026	1029	if (m_target != NULL)
r243398	r243399
1276	1279	#endif
1277	1280
1278	1281	// initialize the drawing backend
1279		if (window->renderer().create())
	1282	if (window->renderer().create(window->width(), window->height()))
1280	1283	return (void *) &result[1];
1281	1284
1282	1285	// Make sure we have a consistent state

trunk/src/osd/sdl/window.h
r243398	r243399
57	57	int flags() const { return m_flags; }
58	58	bool check_flag(const int flag) { return ((m_flags & flag)) == flag; }
59	59
60		virtual int create() = 0;
	60	virtual int create(const int width, const int height) = 0;
	61	virtual void resize(const int width, const int height) = 0;
61	62	virtual int draw(const UINT32 dc, const int update) = 0;
62	63	virtual int xy_to_render_target(const int x, const int y, int xt, int yt) = 0;
63	64	virtual void destroy_all_textures() = 0;
r243398	r243399
115	116	}
116	117
117	118	int window_init();
	119	void destroy();
118	120
119	121	void update();
120	122	void toggle_full_screen();
121	123	void modify_prescale(int dir);
122	124	void resize(INT32 width, INT32 height);
123		void destroy();
124	125	void clear();
125	126	int xy_to_render_target(int x, int y, int xt, int yt);
126	127
	128	void get_min_bounds(int window_width, int window_height, int constrain);
	129	void get_max_bounds(int window_width, int window_height, int constrain);
	130
127	131	running_machine &machine() const { return m_machine; }
128	132	sdl_monitor_info *monitor() const { return m_monitor; }
129	133	int fullscreen() const { return m_fullscreen; }
130	134
	135	void set_fullscreen(int afullscreen) { m_fullscreen = afullscreen; }
	136	void update_cursor_state();
	137
	138	void blit_surface_size(int window_width, int window_height);
	139	void pick_best_mode(int fswidth, int fsheight);
	140	void set_starting_view(running_machine &machine, int index, const char defview, const char view);
	141
131	142	int index() const { return m_index; }
132	143
	144
	145
133	146	render_target *target() { return m_target; }
134	147	#if (SDLMAME_SDL2)
135	148	SDL_Window *sdl_window() { return m_sdl_window; }
r243398	r243399
159	172	private:
160	173	// window handle and info
161	174	char m_title[256];
162		int m_startmaximized;
163	175
164	176	// diverse flags
165	177	int m_minwidth, m_minheight;
166	178	int m_maxwidth, m_maxheight;
	179	int m_depth;
167	180	int m_refresh;
168		int m_depth;
169	181	int m_windowed_width;
170	182	int m_windowed_height;
	183	int m_startmaximized;
171	184
172	185	// rendering info
173	186	osd_event * m_rendered_event;
r243398	r243399
206	219	osd_renderer &renderer() { return *m_renderer; }
207	220	private:
208	221	void constrain_to_aspect_ratio(int window_width, int window_height, int adjustment);
209		void update_cursor_state();
210		void blit_surface_size(int window_width, int window_height);
211		void pick_best_mode(int fswidth, int fsheight);
212		void set_starting_view(running_machine &machine, int index, const char defview, const char view);
213		void get_min_bounds(int window_width, int window_height, int constrain);
214		void get_max_bounds(int window_width, int window_height, int constrain);
215		void set_fullscreen(int afullscreen) { m_fullscreen = afullscreen; }
216	222
217
218
219
220	223	// Pointer to machine
221	224	running_machine & m_machine;
222	225	// monitor info
r243398	r243399
233	236	static OSDWORK_CALLBACK( sdlwindow_toggle_full_screen_wt );
234	237	static OSDWORK_CALLBACK( sdlwindow_clear_surface_wt );
235	238	static OSDWORK_CALLBACK( destroy_all_textures_wt );
236		static OSDWORK_CALLBACK( update_cursor_state_wt );
237	239
238	240	void measure_fps(UINT32 dc, int update);
239	241

trunk/src/osd/windows/d3dhlsl.c
r243398	r243399
224	224	if (!master_enable \|\| !d3dintf->post_fx_available)
225	225	return;
226	226
227		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	227	renderer d3d = (renderer )window->m_drawdata;
228	228
229	229	HRESULT result = (*d3dintf->device.create_texture)(d3d->get_device(), snap_width, snap_height, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &snap_copy_texture);
230	230	if (result != D3D_OK)
r243398	r243399
276	276	if (!master_enable \|\| !d3dintf->post_fx_available)
277	277	return;
278	278
279		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	279	renderer d3d = (renderer )window->m_drawdata;
280	280
281	281	D3DLOCKED_RECT rect;
282	282
r243398	r243399
326	326	if (!master_enable \|\| !d3dintf->post_fx_available)
327	327	return;
328	328
329		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	329	renderer d3d = (renderer )window->m_drawdata;
330	330
331	331	D3DLOCKED_RECT rect;
332	332
r243398	r243399
519	519	if (!master_enable \|\| !d3dintf->post_fx_available)
520	520	return;
521	521
522		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	522	renderer d3d = (renderer )window->m_drawdata;
523	523
524	524	// stop any existing recording
525	525	end_avi_recording();
r243398	r243399
678	678	if (!master_enable \|\| !d3dintf->post_fx_available)
679	679	return;
680	680
681		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	681	renderer d3d = (renderer )window->m_drawdata;
682	682
683	683	if(texture != NULL)
684	684	{
r243398	r243399
820	820	if (!master_enable \|\| !d3dintf->post_fx_available)
821	821	return;
822	822
823		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	823	renderer d3d = (renderer )window->m_drawdata;
824	824
825	825	// get a pointer to the vertex buffer
826	826	fsfx_vertices = (vertex *)vertbuf;
r243398	r243399
892	892	if (!master_enable \|\| !d3dintf->post_fx_available)
893	893	return 0;
894	894
895		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	895	renderer d3d = (renderer )window->m_drawdata;
896	896
897	897	HRESULT result = (*d3dintf->device.get_render_target)(d3d->get_device(), 0, &backbuffer);
898	898	if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device get_render_target call\n", (int)result);
r243398	r243399
1066	1066	if (!master_enable \|\| !d3dintf->post_fx_available)
1067	1067	return;
1068	1068
1069		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1069	renderer d3d = (renderer )window->m_drawdata;
1070	1070
1071	1071	curr_effect = default_effect;
1072	1072
r243398	r243399
1101	1101	void shaders::blit(surface dst, texture src, surface *new_dst, D3DPRIMITIVETYPE prim_type,
1102	1102	UINT32 prim_index, UINT32 prim_count, int dstw, int dsth)
1103	1103	{
1104		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1104	renderer d3d = (renderer )window->m_drawdata;
1105	1105
1106	1106	HRESULT result = (*d3dintf->device.set_render_target)(d3d->get_device(), 0, dst);
1107	1107	if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device set_render_target call\n", (int)result);
r243398	r243399
1146	1146	void shaders::blit(surface dst, texture src, surface *new_dst, D3DPRIMITIVETYPE prim_type,
1147	1147	UINT32 prim_index, UINT32 prim_count)
1148	1148	{
1149		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1149	renderer d3d = (renderer )window->m_drawdata;
1150	1150
1151	1151	HRESULT result = (*d3dintf->device.set_render_target)(d3d->get_device(), 0, dst);
1152	1152	if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device set_render_target call\n", (int)result);
r243398	r243399
1231	1231	if (!master_enable \|\| !d3dintf->post_fx_available)
1232	1232	return;
1233	1233
1234		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1234	renderer d3d = (renderer )window->m_drawdata;
1235	1235	texture_info *texture = poly->get_texture();
1236	1236
1237	1237	if(PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && texture != NULL)
r243398	r243399
1308	1308
1309	1309	void shaders::ntsc_pass(render_target *rt, vec2f &sourcedims, vec2f &delta)
1310	1310	{
1311		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1311	renderer d3d = (renderer )window->m_drawdata;
1312	1312	UINT num_passes = 0;
1313	1313
1314	1314	if(options->yiq_enable)
r243398	r243399
1370	1370
1371	1371	void shaders::color_convolution_pass(render_target *rt, vec2f &texsize, vec2f &sourcedims)
1372	1372	{
1373		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1373	renderer d3d = (renderer )window->m_drawdata;
1374	1374	UINT num_passes = 0;
1375	1375
1376	1376	curr_effect = color_effect;
r243398	r243399
1398	1398
1399	1399	void shaders::prescale_pass(render_target *rt, vec2f &texsize, vec2f &sourcedims)
1400	1400	{
1401		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1401	renderer d3d = (renderer )window->m_drawdata;
1402	1402	UINT num_passes = 0;
1403	1403
1404	1404	curr_effect = prescale_effect;
r243398	r243399
1426	1426
1427	1427	void shaders::deconverge_pass(render_target *rt, vec2f &texsize, vec2f &delta, vec2f &sourcedims)
1428	1428	{
1429		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1429	renderer d3d = (renderer )window->m_drawdata;
1430	1430	UINT num_passes = 0;
1431	1431
1432	1432	curr_effect = deconverge_effect;
r243398	r243399
1454	1454
1455	1455	void shaders::defocus_pass(render_target *rt, vec2f &texsize)
1456	1456	{
1457		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1457	renderer d3d = (renderer )window->m_drawdata;
1458	1458	UINT num_passes = 0;
1459	1459
1460	1460	// Defocus pass 1
r243398	r243399
1503	1503
1504	1504	void shaders::phosphor_pass(render_target rt, cache_target ct, vec2f &texsize, bool focus_enable)
1505	1505	{
1506		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1506	renderer d3d = (renderer )window->m_drawdata;
1507	1507	UINT num_passes = 0;
1508	1508
1509	1509	curr_effect = phosphor_effect;
r243398	r243399
1561	1561
1562	1562	void shaders::avi_post_pass(render_target rt, vec2f &texsize, vec2f &delta, vec2f &sourcedims, poly_info poly, int vertnum)
1563	1563	{
1564		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1564	renderer d3d = (renderer )window->m_drawdata;
1565	1565	UINT num_passes = 0;
1566	1566
1567	1567	curr_effect = post_effect;
r243398	r243399
1616	1616
1617	1617	void shaders::screen_post_pass(render_target rt, vec2f &texsize, vec2f &delta, vec2f &sourcedims, poly_info poly, int vertnum)
1618	1618	{
1619		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1619	renderer d3d = (renderer )window->m_drawdata;
1620	1620	UINT num_passes = 0;
1621	1621
1622	1622	curr_effect = post_effect;
r243398	r243399
1650	1650
1651	1651	void shaders::raster_bloom_pass(render_target rt, vec2f &texsize, vec2f &delta, poly_info poly, int vertnum)
1652	1652	{
1653		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1653	renderer d3d = (renderer )window->m_drawdata;
1654	1654	UINT num_passes = 0;
1655	1655
1656	1656	curr_effect = downsample_effect;
r243398	r243399
1755	1755	return;
1756	1756
1757	1757	UINT num_passes = 0;
1758		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	1758	renderer d3d = (renderer )window->m_drawdata;
1759	1759	curr_texture = poly->get_texture();
1760	1760
1761	1761	if(PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && curr_texture != NULL)
r243398	r243399
2080	2080	return NULL;
2081	2081	}
2082	2082
2083		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	2083	renderer d3d = (renderer )window->m_drawdata;
2084	2084
2085	2085	return find_render_target(d3d->get_width(), d3d->get_height(), 0, 0);
2086	2086	}
2087	2087
2088	2088	void shaders::create_vector_target(render_primitive *prim)
2089	2089	{
2090		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	2090	renderer d3d = (renderer )window->m_drawdata;
2091	2091	if (!add_render_target(d3d, NULL, d3d->get_width(), d3d->get_height(), 1, 1))
2092	2092	{
2093	2093	vector_enable = false;
r243398	r243399
2202	2202
2203	2203	enumerate_screens();
2204	2204
2205		renderer d3d = ~~dynamic_cast<~~renderer >(window->m_~~ren~~der~~er)~~;
	2205	renderer d3d = (renderer )window->m_drawdata;
2206	2206
2207	2207	int hlsl_prescale_x = prescale_force_x;
2208	2208	int hlsl_prescale_y = prescale_force_y;
r243398	r243399
2994	2994	}
2995	2995
2996	2996	shaders *shadersys = m_shader->m_shaders;
2997		renderer d3d = ~~dynamic_cast<~~renderer >(shadersys->window->m_~~ren~~der~~er)~~;
	2997	renderer d3d = (renderer )shadersys->window->m_drawdata;
2998	2998	hlsl_options *options = shadersys->options;
2999	2999
3000	3000	switch(m_id)
r243398	r243399
3422	3422	UINT32 origflags = file.openflags();
3423	3423
3424	3424	// handle defaults
3425		const char *snapname = templ ? templ : d3d->window().machine().options().snap_name();
	3425	const char *snapname = templ ? templ : d3d->get_window()->machine().options().snap_name();
3426	3426
3427	3427	if (snapname == NULL \|\| snapname[0] == 0)
3428	3428	snapname = "%g/%i";
r243398	r243399
3469	3469	snapdevname.cpysubstr(snapstr, pos + 3, end - pos - 3);
3470	3470
3471	3471	// verify that there is such a device for this system
3472		image_interface_iterator iter(d3d->window().machine().root_device());
	3472	image_interface_iterator iter(d3d->get_window()->machine().root_device());
3473	3473	for (device_image_interface *image = iter.first(); image != NULL; iter.next())
3474	3474	{
3475	3475	// get the device name
r243398	r243399
3506	3506
3507	3507	// substitute path and gamename up front
3508	3508	snapstr.replace(0, "/", PATH_SEPARATOR);
3509		snapstr.replace(0, "%g", d3d->window().machine().basename());
	3509	snapstr.replace(0, "%g", d3d->get_window()->machine().basename());
3510	3510
3511	3511	// determine if the template has an index; if not, we always use the same name
3512	3512	astring fname;

trunk/src/osd/windows/drawbgfx.c
r243398	r243399
22	22	#include <bgfxplatform.h>
23	23	#include <bgfx.h>
24	24
25		class renderer_bgfx : public osd_renderer
26		{
27		public:
28		renderer_bgfx(win_window_info *window)
29		: osd_renderer(window, FLAG_NONE) { }
30
31		virtual ~renderer_bgfx() { }
32
33		virtual int init();
34		virtual render_primitive_list *get_primitives();
35		virtual int draw(HDC dc, int update);
36		virtual void save() {};
37		virtual void record() {};
38		virtual void toggle_fsfx() {};
39		virtual void destroy();
40
41		private:
42		};
43
44
45	25	//============================================================
46	26	// PROTOTYPES
47	27	//============================================================
48	28
49	29	// core functions
50	30	static void drawbgfx_exit(void);
	31	static int drawbgfx_window_init(win_window_info *window);
	32	static void drawbgfx_window_destroy(win_window_info *window);
	33	static render_primitive_list drawbgfx_window_get_primitives(win_window_info window);
	34	static int drawbgfx_window_draw(win_window_info *window, HDC dc, int update);
51	35
52		//============================================================
53		// drawnone_create
54		//============================================================
55	36
56		osd_renderer drawbgfx_create(win_window_info window)
57		{
58		return global_alloc(renderer_bgfx(window));
59		}
60	37
61	38	//============================================================
62	39	// drawbgfx_init
63	40	//============================================================
64	41
65		int drawbgfx_init(running_machine &machine, ~~osd~~_draw_callbacks *callbacks)
	42	int drawbgfx_init(running_machine &machine, win_draw_callbacks *callbacks)
66	43	{
67	44	// fill in the callbacks
68	45	memset(callbacks, 0, sizeof(*callbacks));
69	46	callbacks->exit = drawbgfx_exit;
70		callbacks->create = drawbgfx_create;
	47	callbacks->window_init = drawbgfx_window_init;
	48	callbacks->window_get_primitives = drawbgfx_window_get_primitives;
	49	callbacks->window_draw = drawbgfx_window_draw;
	50	callbacks->window_destroy = drawbgfx_window_destroy;
71	51	return 0;
72	52	}
73	53
r243398	r243399
87	67	// drawbgfx_window_init
88	68	//============================================================
89	69
90		int ~~ren~~der~~er_~~bgfx::init()
	70	static int drawbgfx_window_init(win_window_info *window)
91	71	{
92	72	RECT client;
93		GetClientRect(window~~().~~m_hwnd, &client);
	73	GetClientRect(window->m_hwnd, &client);
94	74
95		bgfx::winSetHwnd(window~~().~~m_hwnd);
	75	bgfx::winSetHwnd(window->m_hwnd);
96	76	bgfx::init();
97	77	bgfx::reset(rect_width(&client), rect_height(&client), BGFX_RESET_VSYNC);
98	78
99	79	// Enable debug text.
100	80	bgfx::setDebug(BGFX_DEBUG_STATS);// BGFX_DEBUG_TEXT);
101	81
	82	window->m_drawdata = window->m_hwnd;
102	83	return 0;
103	84	}
104	85
r243398	r243399
108	89	// drawbgfx_window_destroy
109	90	//============================================================
110	91
111		void ~~ren~~der~~er_~~bgfx::destroy()
	92	static void drawbgfx_window_destroy(win_window_info *window)
112	93	{
113	94	// Shutdown bgfx.
114	95	bgfx::shutdown();
	96	window->m_drawdata = NULL;
115	97	}
116	98
117	99
r243398	r243399
120	102	// drawbgfx_window_get_primitives
121	103	//============================================================
122	104
123		render_primitive_list *~~ren~~der~~er_~~bgfx::get_primitives()
	105	static render_primitive_list drawbgfx_window_get_primitives(win_window_info window)
124	106	{
125	107	RECT client;
126		GetClientRect(window().m_hwnd, &client);
127		window().m_target->set_bounds(rect_width(&client), rect_height(&client), window().m_monitor->get_aspect());
128		return &window().m_target->get_primitives();
	108	GetClientRect(window->m_hwnd, &client);
	109	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	110	return &window->m_target->get_primitives();
129	111	}
130	112
131	113
r243398	r243399
134	116	// drawbgfx_window_draw
135	117	//============================================================
136	118
137		int ~~ren~~der~~er_~~bgfx::draw(HDC dc, int update)
	119	static int drawbgfx_window_draw(win_window_info *window, HDC dc, int update)
138	120	{
139	121	RECT client;
140		GetClientRect(window~~().~~m_hwnd, &client);
	122	GetClientRect(window->m_hwnd, &client);
141	123
142	124	bgfx::setViewClear(0
143	125	, BGFX_CLEAR_COLOR\|BGFX_CLEAR_DEPTH
r243398	r243399
152	134	// if no other draw calls are submitted to view 0.
153	135	bgfx::submit(0);
154	136
155		window~~().~~m_primlist->acquire_lock();
	137	window->m_primlist->acquire_lock();
156	138
157	139	// now draw
158		for (render_primitive *prim = window~~().~~m_primlist->first(); prim != NULL; prim = prim->next())
	140	for (render_primitive *prim = window->m_primlist->first(); prim != NULL; prim = prim->next())
159	141	{
160	142	switch (prim->type)
161	143	{
r243398	r243399
237	219	}
238	220	}
239	221
240		window~~().~~m_primlist->release_lock();
	222	window->m_primlist->release_lock();
241	223	// Advance to next frame. Rendering thread will be kicked to
242	224	// process submitted rendering primitives.
243	225	bgfx::frame();

trunk/src/osd/windows/drawd3d.c
r243398	r243399
179	179
180	180	// core functions
181	181	static void drawd3d_exit(void);
	182	static int drawd3d_window_init(win_window_info *window);
	183	static void drawd3d_window_destroy(win_window_info *window);
	184	static render_primitive_list drawd3d_window_get_primitives(win_window_info window);
	185	static void drawd3d_window_save(win_window_info *window);
	186	static void drawd3d_window_record(win_window_info *window);
	187	static void drawd3d_window_toggle_fsfx(win_window_info *window);
	188	static int drawd3d_window_draw(win_window_info *window, HDC dc, int update);
182	189
	190
183	191	//============================================================
184	192	// drawd3d_window_init
185	193	//============================================================
186	194
187		int d3d~~::re~~nd~~erer::~~init()
	195	static int drawd3d_window_init(win_window_info *window)
188	196	{
189		if (!initialize())
	197	// allocate memory for our structures
	198	d3d::renderer *d3d = global_alloc(d3d::renderer(window));
	199	window->m_drawdata = d3d;
	200
	201	if (!d3d->initialize())
190	202	{
191		destroy();
	203	drawd3d_window_destroy(window);
192	204	osd_printf_error("Unable to initialize Direct3D.\n");
193	205	return 1;
194	206	}
r243398	r243399
206	218	(*d3dintf->d3d.release)(d3dintf);
207	219	}
208	220
209		void d3d~~::re~~nd~~erer::~~toggle_fsfx()
	221	static void drawd3d_window_toggle_fsfx(win_window_info *window)
210	222	{
211		set_restarting(true);
	223	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
	224	d3d->set_restarting(true);
212	225	}
213	226
214		void d3d~~::re~~ndere~~r::re~~cord()
	227	static void drawd3d_window_record(win_window_info *window)
215	228	{
216		get_shaders()->window_record();
	229	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
	230	d3d->get_shaders()->window_record();
217	231	}
218	232
219		void d3d~~::re~~nd~~erer::~~save()
	233	static void drawd3d_window_save(win_window_info *window)
220	234	{
221		get_shaders()->window_save();
	235	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
	236	d3d->get_shaders()->window_save();
222	237	}
223	238
224	239
r243398	r243399
227	242	// drawd3d_window_destroy
228	243	//============================================================
229	244
230		void d3d~~::re~~nd~~erer::~~destroy()
	245	static void drawd3d_window_destroy(win_window_info *window)
231	246	{
232		if (get_shaders() != NULL && get_shaders()->recording())
233		get_shaders()->window_record();
	247	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
234	248
	249	// skip if nothing
	250	if (d3d == NULL)
	251	return;
	252
	253	if (d3d->get_shaders() != NULL && d3d->get_shaders()->recording())
	254	d3d->get_shaders()->window_record();
	255
	256	// free the memory in the window
	257	global_free(d3d);
	258	window->m_drawdata = NULL;
235	259	}
236	260
237	261
r243398	r243399
240	264	// drawd3d_window_get_primitives
241	265	//============================================================
242	266
243		render_primitive_list *d3d~~::re~~nd~~erer::~~get_primitives()
	267	static render_primitive_list drawd3d_window_get_primitives(win_window_info window)
244	268	{
	269	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
245	270	RECT client;
246	271
247		GetClientRectExceptMenu(window~~().~~m_hwnd, &client, window~~().~~m_fullscreen);
	272	GetClientRectExceptMenu(window->m_hwnd, &client, window->m_fullscreen);
248	273	if (rect_width(&client) > 0 && rect_height(&client) > 0)
249	274	{
250		window().m_target->set_bounds(rect_width(&client), rect_height(&client), window().m_monitor->get_aspect());
251		window().m_target->set_max_update_rate((get_refresh() == 0) ? get_origmode().RefreshRate : get_refresh());
	275	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	276	window->m_target->set_max_update_rate((d3d->get_refresh() == 0) ? d3d->get_origmode().RefreshRate : d3d->get_refresh());
252	277	}
253		return &window~~().~~m_target->get_primitives();
	278	return &window->m_target->get_primitives();
254	279	}
255	280
256		//============================================================
257		// drawnone_create
258		//============================================================
259
260		static osd_renderer drawd3d_create(win_window_info window)
	281	int drawd3d_init(running_machine &machine, win_draw_callbacks *callbacks)
261	282	{
262		return global_alloc(d3d::renderer(window));
263		}
264
265		int drawd3d_init(running_machine &machine, osd_draw_callbacks *callbacks)
266		{
267	283	d3dintf = NULL;
268	284
269	285	// Use Direct3D9
r243398	r243399
279	295	// fill in the callbacks
280	296	memset(callbacks, 0, sizeof(*callbacks));
281	297	callbacks->exit = drawd3d_exit;
282		callbacks->create = drawd3d_create;
	298	callbacks->window_init = drawd3d_window_init;
	299	callbacks->window_get_primitives = drawd3d_window_get_primitives;
	300	callbacks->window_draw = drawd3d_window_draw;
	301	callbacks->window_save = drawd3d_window_save;
	302	callbacks->window_record = drawd3d_window_record;
	303	callbacks->window_toggle_fsfx = drawd3d_window_toggle_fsfx;
	304	callbacks->window_destroy = drawd3d_window_destroy;
283	305	return 0;
284	306	}
285	307
r243398	r243399
287	309	// drawd3d_window_draw
288	310	//============================================================
289	311
290		int d3d~~::re~~nd~~erer::~~draw(HDC dc, int update)
	312	static int drawd3d_window_draw(win_window_info *window, HDC dc, int update)
291	313	{
292		int check = pre_window_draw_check();
	314	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
	315
	316	// if we haven't been created, just punt
	317	if (d3d == NULL)
	318	return 1;
	319
	320	int check = d3d->pre_window_draw_check();
293	321	if (check >= 0)
294	322	return check;
295	323
296		begin_frame();
297		process_primitives();
298		end_frame();
	324	d3d->begin_frame();
	325	d3d->process_primitives();
	326	d3d->end_frame();
299	327
300	328	return 0;
301	329	}
r243398	r243399
468	496	osd_printf_verbose("Direct3D: YUV format = %s\n", (m_yuv_format == D3DFMT_YUY2) ? "YUY2" : (m_yuv_format == D3DFMT_UYVY) ? "UYVY" : "RGB");
469	497
470	498	// set the max texture size
471		d3d->window().m_target->set_max_texture_size(m_texture_max_width, m_texture_max_height);
	499	d3d->get_window()->m_target->set_max_texture_size(m_texture_max_width, m_texture_max_height);
472	500	osd_printf_verbose("Direct3D: Max texture size = %dx%d\n", (int)m_texture_max_width, (int)m_texture_max_height);
473	501	}
474	502
r243398	r243399
480	508	{
481	509	// experimental: load a PNG to use for vector rendering; it is treated
482	510	// as a brightness map
483		emu_file file(m_renderer->window().machine().options().art_path(), OPEN_FLAG_READ);
	511	emu_file file(m_renderer->get_window()->machine().options().art_path(), OPEN_FLAG_READ);
484	512	render_load_png(m_vector_bitmap, file, NULL, "vector.png");
485	513	if (m_vector_bitmap.valid())
486	514	{
r243398	r243399
622	650	}
623	651
624	652	renderer::renderer(win_window_info *window)
625		: osd_renderer(window, FLAG_NONE)
626	653	{
627	654	m_device = NULL;
628	655	m_restarting = false;
	656	m_window = window;
629	657	m_shaders = NULL;
630	658	m_numverts = 0;
631	659	m_numpolys = 0;
r243398	r243399
644	672	return false;
645	673
646	674	// create the device immediately for the full screen case (defer for window mode)
647		if (window~~().~~m_fullscreen && device_create())
	675	if (m_window->m_fullscreen && device_create())
648	676	return false;
649	677
650	678	return true;
r243398	r243399
653	681	int renderer::pre_window_draw_check()
654	682	{
655	683	// if we're in the middle of resizing, leave things alone
656		if (window~~().~~m_resize_state == RESIZE_STATE_RESIZING)
	684	if (m_window->m_resize_state == RESIZE_STATE_RESIZING)
657	685	return 0;
658	686
659	687	// if we're restarting the renderer, leave things alone
r243398	r243399
678	706	}
679	707
680	708	// in window mode, we need to track the window size
681		if (!window~~().~~m_fullscreen \|\| m_device == NULL)
	709	if (!m_window->m_fullscreen \|\| m_device == NULL)
682	710	{
683	711	// if the size changes, skip this update since the render target will be out of date
684	712	if (update_window_size())
r243398	r243399
694	722
695	723	void texture_manager::update_textures()
696	724	{
697		for (render_primitive *prim = m_renderer->window().m_primlist->first(); prim != NULL; prim = prim->next())
	725	for (render_primitive *prim = m_renderer->get_window()->m_primlist->first(); prim != NULL; prim = prim->next())
698	726	{
699	727	if (prim->texture.base != NULL)
700	728	{
r243398	r243399
731	759
732	760	m_shaders->begin_frame();
733	761
734		window~~().~~m_primlist->acquire_lock();
	762	m_window->m_primlist->acquire_lock();
735	763
736	764	// first update any textures
737	765	m_texture_manager->update_textures();
r243398	r243399
752	780	m_line_count = 0;
753	781
754	782	// loop over primitives
755		for (render_primitive *prim = window~~().~~m_primlist->first(); prim != NULL; prim = prim->next())
	783	for (render_primitive *prim = m_window->m_primlist->first(); prim != NULL; prim = prim->next())
756	784	if (prim->type == render_primitive::LINE && PRIMFLAG_GET_VECTOR(prim->flags))
757	785	m_line_count++;
758	786	}
r243398	r243399
760	788	void renderer::process_primitives()
761	789	{
762	790	// Rotating index for vector time offsets
763		for (render_primitive *prim = window~~().~~m_primlist->first(); prim != NULL; prim = prim->next())
	791	for (render_primitive *prim = m_window->m_primlist->first(); prim != NULL; prim = prim->next())
764	792	{
765	793	switch (prim->type)
766	794	{
r243398	r243399
790	818
791	819	void renderer::end_frame()
792	820	{
793		window~~().~~m_primlist->release_lock();
	821	m_window->m_primlist->release_lock();
794	822
795	823	// flush any pending polygons
796	824	primitive_flush_pending();
r243398	r243399
865	893	m_presentation.BackBufferCount = video_config.triplebuf ? 2 : 1;
866	894	m_presentation.MultiSampleType = D3DMULTISAMPLE_NONE;
867	895	m_presentation.SwapEffect = D3DSWAPEFFECT_DISCARD;
868		m_presentation.hDeviceWindow = window().m_hwnd;
869		m_presentation.Windowed = !window().m_fullscreen \|\| win_has_menu(&window());
	896	m_presentation.hDeviceWindow = m_window->m_hwnd;
	897	m_presentation.Windowed = !m_window->m_fullscreen \|\| win_has_menu(m_window);
870	898	m_presentation.EnableAutoDepthStencil = FALSE;
871	899	m_presentation.AutoDepthStencilFormat = D3DFMT_D16;
872	900	m_presentation.Flags = 0;
873	901	m_presentation.FullScreen_RefreshRateInHz = m_refresh;
874		m_presentation.PresentationInterval = ((video_config.triplebuf && window~~().~~m_fullscreen) \|\|
	902	m_presentation.PresentationInterval = ((video_config.triplebuf && m_window->m_fullscreen) \|\|
875	903	video_config.waitvsync \|\| video_config.syncrefresh) ?
876	904	D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
877	905
878	906	// create the D3D device
879		result = (*d3dintf->d3d.create_device)(d3dintf, m_adapter, D3DDEVTYPE_HAL, window~~().~~m_focus_hwnd,
	907	result = (*d3dintf->d3d.create_device)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_window->m_focus_hwnd,
880	908	D3DCREATE_SOFTWARE_VERTEXPROCESSING \| D3DCREATE_FPU_PRESERVE, &m_presentation, &m_device);
881	909	if (result != D3D_OK)
882	910	{
r243398	r243399
899	927	osd_printf_verbose("Direct3D: Device created at %dx%d\n", m_width, m_height);
900	928
901	929	// set the gamma if we need to
902		if (window~~().~~m_fullscreen)
	930	if (m_window->m_fullscreen)
903	931	{
904	932	// only set the gamma if it's not 1.0f
905		windows_options &options = downcast<windows_options &>(window~~().~~machine().options());
	933	windows_options &options = downcast<windows_options &>(m_window->machine().options());
906	934	float brightness = options.full_screen_brightness();
907	935	float contrast = options.full_screen_contrast();
908	936	float gamma = options.full_screen_gamma();
r243398	r243399
1064	1092	int retval = 0;
1065	1093
1066	1094	m_shaders = global_alloc_clear(shaders);
1067		m_shaders->init(d3dintf, &window());
	1095	m_shaders->init(d3dintf, m_window);
1068	1096
1069	1097	DWORD tempcaps;
1070	1098	HRESULT result = (*d3dintf->d3d.get_caps_dword)(d3dintf, m_adapter, D3DDEVTYPE_HAL, CAPS_MAX_PS30_INSN_SLOTS, &tempcaps);
r243398	r243399
1203	1231	}
1204	1232
1205	1233	// choose a resolution: window mode case
1206		if (!window~~().~~m_fullscreen \|\| !video_config.switchres \|\| win_has_menu(&window()))
	1234	if (!m_window->m_fullscreen \|\| !video_config.switchres \|\| win_has_menu(m_window))
1207	1235	{
1208	1236	RECT client;
1209	1237
1210	1238	// bounds are from the window client rect
1211		GetClientRectExceptMenu(window~~().~~m_hwnd, &client, window~~().~~m_fullscreen);
	1239	GetClientRectExceptMenu(m_window->m_hwnd, &client, m_window->m_fullscreen);
1212	1240	m_width = client.right - client.left;
1213	1241	m_height = client.bottom - client.top;
1214	1242
r243398	r243399
1219	1247	// make sure it's a pixel format we can get behind
1220	1248	if (m_pixformat != D3DFMT_X1R5G5B5 && m_pixformat != D3DFMT_R5G6B5 && m_pixformat != D3DFMT_X8R8G8B8)
1221	1249	{
1222		char *utf8_device = utf8_from_tstring(window~~().~~m_monitor->info.szDevice);
	1250	char *utf8_device = utf8_from_tstring(m_window->m_monitor->info.szDevice);
1223	1251	if (utf8_device != NULL)
1224	1252	{
1225	1253	osd_printf_error("Device %s currently in an unsupported mode\n", utf8_device);
r243398	r243399
1244	1272	}
1245	1273
1246	1274	// see if we can handle the device type
1247		result = (*d3dintf->d3d.check_device_type)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_pixformat, m_pixformat, !window~~().~~m_fullscreen);
	1275	result = (*d3dintf->d3d.check_device_type)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_pixformat, m_pixformat, !m_window->m_fullscreen);
1248	1276	if (result != D3D_OK)
1249	1277	{
1250		char *utf8_device = utf8_from_tstring(window~~().~~m_monitor->info.szDevice);
	1278	char *utf8_device = utf8_from_tstring(m_window->m_monitor->info.szDevice);
1251	1279	if (utf8_device != NULL)
1252	1280	{
1253	1281	osd_printf_error("Proposed video mode not supported on device %s\n", utf8_device);
r243398	r243399
1275	1303	HMONITOR curmonitor = (*d3dintf->d3d.get_adapter_monitor)(d3dintf, adapternum);
1276	1304
1277	1305	// if we match the proposed monitor, this is it
1278		if (curmonitor == window~~().~~m_monitor->handle)
	1306	if (curmonitor == m_window->m_monitor->handle)
1279	1307	{
1280	1308	return adapternum;
1281	1309	}
r243398	r243399
1298	1326	float best_score = 0.0f;
1299	1327
1300	1328	// determine the refresh rate of the primary screen
1301		const screen_device *primary_screen = window~~().~~machine().config().first_screen();
	1329	const screen_device *primary_screen = m_window->machine().config().first_screen();
1302	1330	if (primary_screen != NULL)
1303	1331	{
1304	1332	target_refresh = ATTOSECONDS_TO_HZ(primary_screen->refresh_attoseconds());
r243398	r243399
1308	1336	// note: technically we should not be calling this from an alternate window
1309	1337	// thread; however, it is only done during init time, and the init code on
1310	1338	// the main thread is waiting for us to finish, so it is safe to do so here
1311		window~~().~~m_target->compute_minimum_size(minwidth, minheight);
	1339	m_window->m_target->compute_minimum_size(minwidth, minheight);
1312	1340
1313	1341	// use those as the target for now
1314	1342	INT32 target_width = minwidth;
r243398	r243399
1343	1371	size_score *= 0.1f;
1344	1372
1345	1373	// if we're looking for a particular mode, that's a winner
1346		if (mode.Width == window~~().~~m_maxwidth && mode.Height == window~~().~~m_maxheight)
	1374	if (mode.Width == m_window->m_maxwidth && mode.Height == m_window->m_maxheight)
1347	1375	size_score = 2.0f;
1348	1376
1349	1377	// compute refresh score
r243398	r243399
1354	1382	refresh_score *= 0.1f;
1355	1383
1356	1384	// if we're looking for a particular refresh, make sure it matches
1357		if (mode.RefreshRate == window~~().~~m_refresh)
	1385	if (mode.RefreshRate == m_window->m_refresh)
1358	1386	refresh_score = 2.0f;
1359	1387
1360	1388	// weight size and refresh equally
r243398	r243399
1384	1412	{
1385	1413	// get the current window bounds
1386	1414	RECT client;
1387		GetClientRectExceptMenu(window~~().~~m_hwnd, &client, window~~().~~m_fullscreen);
	1415	GetClientRectExceptMenu(m_window->m_hwnd, &client, m_window->m_fullscreen);
1388	1416
1389	1417	// if we have a device and matching width/height, nothing to do
1390	1418	if (m_device != NULL && rect_width(&client) == m_width && rect_height(&client) == m_height)
1391	1419	{
1392	1420	// clear out any pending resizing if the area didn't change
1393		if (window().m_resize_state == RESIZE_STATE_PENDING)
1394		window().m_resize_state = RESIZE_STATE_NORMAL;
	1421	if (m_window->m_resize_state == RESIZE_STATE_PENDING)
	1422	m_window->m_resize_state = RESIZE_STATE_NORMAL;
1395	1423	return FALSE;
1396	1424	}
1397	1425
1398	1426	// if we're in the middle of resizing, leave it alone as well
1399		if (window~~().~~m_resize_state == RESIZE_STATE_RESIZING)
	1427	if (m_window->m_resize_state == RESIZE_STATE_RESIZING)
1400	1428	return FALSE;
1401	1429
1402	1430	// set the new bounds and create the device again
r243398	r243399
1406	1434	return FALSE;
1407	1435
1408	1436	// reset the resize state to normal, and indicate we made a change
1409		window~~().~~m_resize_state = RESIZE_STATE_NORMAL;
	1437	m_window->m_resize_state = RESIZE_STATE_NORMAL;
1410	1438	return TRUE;
1411	1439	}
1412	1440
r243398	r243399
1416	1444
1417	1445	void renderer::batch_vectors()
1418	1446	{
1419		windows_options &options = downcast<windows_options &>(window~~().~~machine().options());
	1447	windows_options &options = downcast<windows_options &>(m_window->machine().options());
1420	1448
1421	1449	int vector_size = (options.antialias() ? 24 : 6);
1422	1450	m_vectorbatch = mesh_alloc(m_line_count * vector_size);
r243398	r243399
1426	1454	int line_index = 0;
1427	1455	float period = options.screen_vector_time_period();
1428	1456	UINT32 cached_flags = 0;
1429		for (render_primitive *prim = window~~().~~m_primlist->first(); prim != NULL; prim = prim->next())
	1457	for (render_primitive *prim = m_window->m_primlist->first(); prim != NULL; prim = prim->next())
1430	1458	{
1431	1459	switch (prim->type)
1432	1460	{

trunk/src/osd/windows/drawd3d.h
r243398	r243399
95	95	};
96	96
97	97	/* renderer is the information about Direct3D for the current screen */
98		class renderer ~~: public osd_renderer~~
	98	class renderer
99	99	{
100	100	public:
101		//renderer() { }
	101	renderer() { }
102	102	renderer(win_window_info *window);
103		~~virtual~~ ~renderer();
	103	~renderer();
104	104
105		virtual int init();
106		virtual render_primitive_list *get_primitives();
107		virtual int draw(HDC dc, int update);
108		virtual void save();
109		virtual void record();
110		virtual void toggle_fsfx();
111		virtual void destroy();
112
113	105	int initialize();
114	106
115	107	int device_create();
r243398	r243399
156	148	int get_height() { return m_height; }
157	149	int get_refresh() { return m_refresh; }
158	150
	151	win_window_info * get_window() { return m_window; }
	152
159	153	device * get_device() { return m_device; }
160	154	present_parameters * get_presentation() { return &m_presentation; }
161	155
r243398	r243399
187	181	int m_refresh; // current refresh rate
188	182	int m_create_error_count; // number of consecutive create errors
189	183
	184	win_window_info * m_window; // current window info
	185
190	186	device * m_device; // pointer to the Direct3DDevice object
191	187	int m_gamma_supported; // is full screen gamma supported?
192	188	present_parameters m_presentation; // set of presentation parameters

trunk/src/osd/windows/drawdd.c
r243398	r243399
36	36
37	37
38	38	/* dd_info is the information about DirectDraw for the current screen */
39		~~cla~~ss r~~enderer_dd : p~~u~~bli~~c osd_ren~~derer~~
	39	struct dd_info
40	40	{
41		public:
42		renderer_dd(win_window_info *window)
43		: osd_renderer(window, FLAG_NONE),
44		//adapter(0),
45		adapter_ptr(NULL),
46		clearouter(0),
47		blitwidth(0), blitheight(0),
48		//lastdest
49		ddraw(NULL),
50		primary(NULL),
51		back(NULL),
52		blit(NULL),
53		clipper(NULL),
54		gamma(NULL),
55		//DDSURFACEDESC2 primarydesc;
56		//DDSURFACEDESC2 blitdesc;
57		//DDSURFACEDESC2 origmode;
58		//ddcaps(0),
59		//helcaps(0),
60		membuffer(NULL),
61		membuffersize(NULL)
62		{ }
63
64		virtual ~renderer_dd() { }
65
66		virtual int init();
67		virtual render_primitive_list *get_primitives();
68		virtual int draw(HDC dc, int update);
69		virtual void save() {};
70		virtual void record() {};
71		virtual void toggle_fsfx() {};
72		virtual void destroy();
73
74		int width, height; // current width, height
75		int refresh; // current refresh rate
76
77		private:
78
79		inline void update_outer_rects();
80
81		// surface management
82		int ddraw_create();
83		int ddraw_create_surfaces();
84		void ddraw_delete();
85		void ddraw_delete_surfaces();
86		int ddraw_verify_caps();
87		int ddraw_test_cooperative();
88		HRESULT create_surface(DDSURFACEDESC2 desc, IDirectDrawSurface7 surface, const char type);
89		int create_clipper();
90
91		// drawing helpers
92		void compute_blit_surface_size();
93		void blit_to_primary(int srcwidth, int srcheight);
94
95		// video modes
96		int config_adapter_mode();
97		void get_adapter_for_monitor(win_monitor_info *monitor);
98		void pick_best_mode();
99
100		// various
101		void calc_fullscreen_margins(DWORD desc_width, DWORD desc_height, RECT *margins);
102
103
104	41	GUID adapter; // current display adapter
105	42	GUID * adapter_ptr; // pointer to current display adapter
	43	int width, height; // current width, height
	44	int refresh; // current refresh rate
106	45	int clearouter; // clear the outer areas?
107	46
108	47	INT32 blitwidth, blitheight; // current blit width/height values
r243398	r243399
140	79	/* mode_enum_info holds information during a display mode enumeration */
141	80	struct mode_enum_info
142	81	{
143		win_window_info * window;
	82	win_window_info * window;
144	83	INT32 minimum_width, minimum_height;
145	84	INT32 target_width, target_height;
146	85	double target_refresh;
r243398	r243399
163	102	// INLINES
164	103	//============================================================
165	104
166		~~inline~~ void ~~renderer_dd::~~update_outer_rects()
	105	INLINE void update_outer_rects(dd_info *dd)
167	106	{
168		clearouter = (back != NULL) ? 3 : 1;
	107	dd->clearouter = (dd->back != NULL) ? 3 : 1;
169	108	}
170	109
171	110
r243398	r243399
184	123
185	124	// core functions
186	125	static void drawdd_exit(void);
	126	static int drawdd_window_init(win_window_info *window);
	127	static void drawdd_window_destroy(win_window_info *window);
	128	static render_primitive_list drawdd_window_get_primitives(win_window_info window);
	129	static int drawdd_window_draw(win_window_info *window, HDC dc, int update);
187	130
	131	// surface management
	132	static int ddraw_create(win_window_info *window);
	133	static int ddraw_create_surfaces(win_window_info *window);
	134	static void ddraw_delete(win_window_info *window);
	135	static void ddraw_delete_surfaces(win_window_info *window);
	136	static int ddraw_verify_caps(dd_info *dd);
	137	static int ddraw_test_cooperative(win_window_info *window);
	138	static HRESULT create_surface(dd_info dd, DDSURFACEDESC2 desc, IDirectDrawSurface7 *surface, const char type);
	139	static int create_clipper(win_window_info *window);
188	140
	141	// drawing helpers
	142	static void compute_blit_surface_size(win_window_info *window);
	143	static void blit_to_primary(win_window_info *window, int srcwidth, int srcheight);
189	144
190		//============================================================
191		// drawnone_create
192		//============================================================
	145	// video modes
	146	static int config_adapter_mode(win_window_info *window);
	147	static void get_adapter_for_monitor(dd_info dd, win_monitor_info monitor);
	148	static void pick_best_mode(win_window_info *window);
193	149
194		static osd_renderer drawdd_create(win_window_info window)
195		{
196		return global_alloc(renderer_dd(window));
197		}
198	150
199	151
200	152	//============================================================
201	153	// drawdd_init
202	154	//============================================================
203	155
204		int drawdd_init(running_machine &machine, ~~osd~~_draw_callbacks *callbacks)
	156	int drawdd_init(running_machine &machine, win_draw_callbacks *callbacks)
205	157	{
206	158	// dynamically grab the create function from ddraw.dll
207	159	dllhandle = LoadLibrary(TEXT("ddraw.dll"));
r243398	r243399
234	186	// fill in the callbacks
235	187	memset(callbacks, 0, sizeof(*callbacks));
236	188	callbacks->exit = drawdd_exit;
237		callbacks->create = drawdd_create;
	189	callbacks->window_init = drawdd_window_init;
	190	callbacks->window_get_primitives = drawdd_window_get_primitives;
	191	callbacks->window_draw = drawdd_window_draw;
	192	callbacks->window_destroy = drawdd_window_destroy;
238	193
239	194	osd_printf_verbose("DirectDraw: Using DirectDraw 7\n");
240	195	return 0;
r243398	r243399
258	213	// drawdd_window_init
259	214	//============================================================
260	215
261		int ~~ren~~der~~er_~~dd::init()
	216	static int drawdd_window_init(win_window_info *window)
262	217	{
	218	dd_info *dd;
	219
	220	// allocate memory for our structures
	221	dd = global_alloc_clear(dd_info);
	222	window->m_drawdata = dd;
	223
263	224	// configure the adapter for the mode we want
264		if (config_adapter_mode())
	225	if (config_adapter_mode(window))
265	226	goto error;
266	227
267	228	// create the ddraw object
268		if (ddraw_create())
	229	if (ddraw_create(window))
269	230	goto error;
270	231
271	232	return 0;
272	233
273	234	error:
274		destroy();
	235	drawdd_window_destroy(window);
275	236	osd_printf_error("Unable to initialize DirectDraw.\n");
276	237	return 1;
277	238	}
r243398	r243399
282	243	// drawdd_window_destroy
283	244	//============================================================
284	245
285		void ~~ren~~der~~er_~~dd::destroy()
	246	static void drawdd_window_destroy(win_window_info *window)
286	247	{
	248	dd_info dd = (dd_info )window->m_drawdata;
	249
	250	// skip if nothing
	251	if (dd == NULL)
	252	return;
	253
287	254	// delete the ddraw object
288		ddraw_delete();
	255	ddraw_delete(window);
	256
	257	// free the memory in the window
	258	global_free(dd);
	259	window->m_drawdata = NULL;
289	260	}
290	261
291	262
r243398	r243399
294	265	// drawdd_window_get_primitives
295	266	//============================================================
296	267
297		render_primitive_list *~~ren~~der~~er_~~dd::get_primitives()
	268	static render_primitive_list drawdd_window_get_primitives(win_window_info window)
298	269	{
299		compute_blit_surface_size();
300		window().m_target->set_bounds(blitwidth, blitheight, 0);
301		window().m_target->set_max_update_rate((refresh == 0) ? origmode.dwRefreshRate : refresh);
	270	dd_info dd = (dd_info )window->m_drawdata;
302	271
303		return &window().m_target->get_primitives();
	272	compute_blit_surface_size(window);
	273	window->m_target->set_bounds(dd->blitwidth, dd->blitheight, 0);
	274	window->m_target->set_max_update_rate((dd->refresh == 0) ? dd->origmode.dwRefreshRate : dd->refresh);
	275
	276	return &window->m_target->get_primitives();
304	277	}
305	278
306	279
r243398	r243399
309	282	// drawdd_window_draw
310	283	//============================================================
311	284
312		int ~~ren~~der~~er_~~dd::draw(HDC dc, int update)
	285	static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
313	286	{
	287	dd_info dd = (dd_info )window->m_drawdata;
314	288	render_primitive *prim;
315	289	int usemembuffer = FALSE;
316	290	HRESULT result;
317	291
	292	// if we haven't been created, just punt
	293	if (dd == NULL)
	294	return 1;
	295
318	296	// if we're updating, remember to erase the outer stuff
319	297	if (update)
320		update_outer_rects();
	298	update_outer_rects(dd);
321	299
322	300	// if we have a ddraw object, check the cooperative level
323		if (ddraw_test_cooperative())
	301	if (ddraw_test_cooperative(window))
324	302	return 1;
325	303
326	304	// get the size; if we're too small, delete the existing surfaces
327		if (blitwidth > blitdesc.dwWidth \|\| blitheight > blitdesc.dwHeight)
328		ddraw_delete_surfaces();
	305	if (dd->blitwidth > dd->blitdesc.dwWidth \|\| dd->blitheight > dd->blitdesc.dwHeight)
	306	ddraw_delete_surfaces(window);
329	307
330	308	// if we need to create surfaces, do it now
331		if (blit == NULL && ddraw_create_surfaces() != 0)
	309	if (dd->blit == NULL && ddraw_create_surfaces(window) != 0)
332	310	return 1;
333	311
334	312	// select our surface and lock it
335		result = IDirectDrawSurface7_Lock(blit, NULL, &blitdesc, DDLOCK_WAIT, NULL);
	313	result = IDirectDrawSurface7_Lock(dd->blit, NULL, &dd->blitdesc, DDLOCK_WAIT, NULL);
336	314	if (result == DDERR_SURFACELOST)
337	315	{
338	316	osd_printf_verbose("DirectDraw: Lost surfaces; deleting and retrying next frame\n");
339		ddraw_delete_surfaces();
	317	ddraw_delete_surfaces(window);
340	318	return 1;
341	319	}
342	320	if (result != DD_OK)
r243398	r243399
346	324	}
347	325
348	326	// render to it
349		window~~().~~m_primlist->acquire_lock();
	327	window->m_primlist->acquire_lock();
350	328
351	329	// scan the list of primitives for tricky stuff
352		for (prim = window~~().~~m_primlist->first(); prim != NULL; prim = prim->next())
	330	for (prim = window->m_primlist->first(); prim != NULL; prim = prim->next())
353	331	if (PRIMFLAG_GET_BLENDMODE(prim->flags) != BLENDMODE_NONE \|\|
354	332	(prim->texture.base != NULL && PRIMFLAG_GET_TEXFORMAT(prim->flags) == TEXFORMAT_ARGB32))
355	333	{
r243398	r243399
363	341	int x, y;
364	342
365	343	// based on the target format, use one of our standard renderers
366		switch (blitdesc.ddpfPixelFormat.dwRBitMask)
	344	switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
367	345	{
368		case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break;
369		case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break;
370		case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break;
371		case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break;
	346	case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	347	case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	348	case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	349	case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
372	350	default:
373		osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)blitdesc.ddpfPixelFormat.dwRBitMask, (int)blitdesc.ddpfPixelFormat.dwGBitMask, (int)blitdesc.ddpfPixelFormat.dwBBitMask);
	351	osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->blitdesc.ddpfPixelFormat.dwRBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwGBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwBBitMask);
374	352	break;
375	353	}
376	354
377	355	// handle copying to both 16bpp and 32bpp destinations
378		for (y = 0; y < blitheight; y++)
	356	for (y = 0; y < dd->blitheight; y++)
379	357	{
380		if (blitdesc.ddpfPixelFormat.dwRGBBitCount == 32)
	358	if (dd->blitdesc.ddpfPixelFormat.dwRGBBitCount == 32)
381	359	{
382		UINT32 src = (UINT32 )membuffer + y * blitwidth;
383		UINT32 dst = (UINT32 )((UINT8 )blitdesc.lpSurface + y blitdesc.lPitch);
384		for (x = 0; x < blitwidth; x++)
	360	UINT32 src = (UINT32 )dd->membuffer + y * dd->blitwidth;
	361	UINT32 dst = (UINT32 )((UINT8 )dd->blitdesc.lpSurface + y dd->blitdesc.lPitch);
	362	for (x = 0; x < dd->blitwidth; x++)
385	363	dst++ = src++;
386	364	}
387		else if (blitdesc.ddpfPixelFormat.dwRGBBitCount == 16)
	365	else if (dd->blitdesc.ddpfPixelFormat.dwRGBBitCount == 16)
388	366	{
389		UINT16 src = (UINT16 )membuffer + y * blitwidth;
390		UINT16 dst = (UINT16 )((UINT8 )blitdesc.lpSurface + y blitdesc.lPitch);
391		for (x = 0; x < blitwidth; x++)
	367	UINT16 src = (UINT16 )dd->membuffer + y * dd->blitwidth;
	368	UINT16 dst = (UINT16 )((UINT8 )dd->blitdesc.lpSurface + y dd->blitdesc.lPitch);
	369	for (x = 0; x < dd->blitwidth; x++)
392	370	dst++ = src++;
393	371	}
394	372	}
r243398	r243399
399	377	else
400	378	{
401	379	// based on the target format, use one of our standard renderers
402		switch (blitdesc.ddpfPixelFormat.dwRBitMask)
	380	switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
403	381	{
404		case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 4); break;
405		case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 4); break;
406		case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 2); break;
407		case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 2); break;
	382	case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
	383	case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
	384	case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
	385	case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
408	386	default:
409		osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)blitdesc.ddpfPixelFormat.dwRBitMask, (int)blitdesc.ddpfPixelFormat.dwGBitMask, (int)blitdesc.ddpfPixelFormat.dwBBitMask);
	387	osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->blitdesc.ddpfPixelFormat.dwRBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwGBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwBBitMask);
410	388	break;
411	389	}
412	390	}
413		window~~().~~m_primlist->release_lock();
	391	window->m_primlist->release_lock();
414	392
415	393	// unlock and blit
416		result = IDirectDrawSurface7_Unlock(blit, NULL);
	394	result = IDirectDrawSurface7_Unlock(dd->blit, NULL);
417	395	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X unlocking blit surface\n", (int)result);
418	396
419	397	// sync to VBLANK
420		if ((video_config.waitvsync \|\| video_config.syncrefresh) && window~~().~~machine().video().throttled() && (!window~~().~~m_fullscreen \|\| back == NULL))
	398	if ((video_config.waitvsync \|\| video_config.syncrefresh) && window->machine().video().throttled() && (!window->m_fullscreen \|\| dd->back == NULL))
421	399	{
422		result = IDirectDraw7_WaitForVerticalBlank(ddraw, DDWAITVB_BLOCKBEGIN, NULL);
	400	result = IDirectDraw7_WaitForVerticalBlank(dd->ddraw, DDWAITVB_BLOCKBEGIN, NULL);
423	401	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result);
424	402	}
425	403
426	404	// complete the blitting
427		blit_to_primary(blitwidth, blitheight);
	405	blit_to_primary(window, dd->blitwidth, dd->blitheight);
428	406	return 0;
429	407	}
430	408
r243398	r243399
434	412	// ddraw_create
435	413	//============================================================
436	414
437		int ~~ren~~d~~erer_~~d~~d::dd~~raw_create()
	415	static int ddraw_create(win_window_info *window)
438	416	{
	417	dd_info dd = (dd_info )window->m_drawdata;
439	418	HRESULT result;
440	419	int verify;
441	420
442	421	// if a device exists, free it
443		if (ddraw != NULL)
444		ddraw_delete();
	422	if (dd->ddraw != NULL)
	423	ddraw_delete(window);
445	424
446	425	// create the DirectDraw object
447		result = (directdrawcreateex)(adapter_ptr, (LPVOID )&ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL);
	426	result = (directdrawcreateex)(dd->adapter_ptr, (LPVOID )&dd->ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL);
448	427	if (result != DD_OK)
449	428	{
450	429	osd_printf_verbose("DirectDraw: Error %08X during DirectDrawCreateEx call\n", (int)result);
r243398	r243399
452	431	}
453	432
454	433	// verify the caps
455		verify = ddraw_verify_caps();
	434	verify = ddraw_verify_caps(dd);
456	435	if (verify == 2)
457	436	{
458	437	osd_printf_error("DirectDraw: Error - Device does not meet minimum requirements for DirectDraw rendering\n");
r243398	r243399
463	442
464	443	// set the cooperative level
465	444	// for non-window modes, we will use full screen here
466		result = IDirectDraw7_SetCooperativeLevel(ddraw, win_window_list->m_hwnd, DDSCL_SETFOCUSWINDOW);
	445	result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, win_window_list->m_hwnd, DDSCL_SETFOCUSWINDOW);
467	446	if (result != DD_OK)
468	447	{
469	448	osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(FOCUSWINDOW) call\n", (int)result);
470	449	goto error;
471	450	}
472		result = IDirectDraw7_SetCooperativeLevel(ddraw, window~~().~~m_hwnd, DDSCL_SETDEVICEWINDOW \| (window~~().~~m_fullscreen ? DDSCL_FULLSCREEN \| DDSCL_EXCLUSIVE : DDSCL_NORMAL));
	451	result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->m_hwnd, DDSCL_SETDEVICEWINDOW \| (window->m_fullscreen ? DDSCL_FULLSCREEN \| DDSCL_EXCLUSIVE : DDSCL_NORMAL));
473	452	if (result != DD_OK)
474	453	{
475	454	osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(DEVICEWINDOW) call\n", (int)result);
r243398	r243399
477	456	}
478	457
479	458	// full screen mode: set the resolution
480		if (window~~().~~m_fullscreen && video_config.switchres)
	459	if (window->m_fullscreen && video_config.switchres)
481	460	{
482		result = IDirectDraw7_SetDisplayMode(ddraw, width, height, 32, refresh, 0);
	461	result = IDirectDraw7_SetDisplayMode(dd->ddraw, dd->width, dd->height, 32, dd->refresh, 0);
483	462	if (result != DD_OK)
484	463	{
485		osd_printf_verbose("DirectDraw: Error %08X attempting to set video mode %dx%d@%d call\n", (int)result, width, height, refresh);
	464	osd_printf_verbose("DirectDraw: Error %08X attempting to set video mode %dx%d@%d call\n", (int)result, dd->width, dd->height, dd->refresh);
486	465	goto error;
487	466	}
488	467	}
489	468
490		return ddraw_create_surfaces();
	469	return ddraw_create_surfaces(window);
491	470
492	471	error:
493		ddraw_delete();
	472	ddraw_delete(window);
494	473	return 1;
495	474	}
496	475
r243398	r243399
500	479	// ddraw_create_surfaces
501	480	//============================================================
502	481
503		int ~~ren~~d~~erer_~~d~~d::dd~~raw_create_surfaces()
	482	static int ddraw_create_surfaces(win_window_info *window)
504	483	{
	484	dd_info dd = (dd_info )window->m_drawdata;
505	485	HRESULT result;
506	486
507	487	// make a description of the primary surface
508		memset(&primarydesc, 0, sizeof(primarydesc));
509		primarydesc.dwSize = sizeof(primarydesc);
510		primarydesc.dwFlags = DDSD_CAPS;
511		primarydesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
	488	memset(&dd->primarydesc, 0, sizeof(dd->primarydesc));
	489	dd->primarydesc.dwSize = sizeof(dd->primarydesc);
	490	dd->primarydesc.dwFlags = DDSD_CAPS;
	491	dd->primarydesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
512	492
513	493	// for triple-buffered full screen mode, allocate flipping surfaces
514		if (window~~().~~m_fullscreen && video_config.triplebuf)
	494	if (window->m_fullscreen && video_config.triplebuf)
515	495	{
516		primarydesc.dwFlags \|= DDSD_BACKBUFFERCOUNT;
517		primarydesc.ddsCaps.dwCaps \|= DDSCAPS_FLIP \| DDSCAPS_COMPLEX;
518		primarydesc.dwBackBufferCount = 2;
	496	dd->primarydesc.dwFlags \|= DDSD_BACKBUFFERCOUNT;
	497	dd->primarydesc.ddsCaps.dwCaps \|= DDSCAPS_FLIP \| DDSCAPS_COMPLEX;
	498	dd->primarydesc.dwBackBufferCount = 2;
519	499	}
520	500
521	501	// create the primary surface and report errors
522		result = create_surface(&primarydesc, &primary, "primary");
	502	result = create_surface(dd, &dd->primarydesc, &dd->primary, "primary");
523	503	if (result != DD_OK) goto error;
524	504
525	505	// full screen mode: get the back surface
526		back = NULL;
527		if (window().m_fullscreen && video_config.triplebuf)
	506	dd->back = NULL;
	507	if (window->m_fullscreen && video_config.triplebuf)
528	508	{
529	509	DDSCAPS2 caps = { DDSCAPS_BACKBUFFER };
530		result = IDirectDrawSurface7_GetAttachedSurface(primary, &caps, &back);
	510	result = IDirectDrawSurface7_GetAttachedSurface(dd->primary, &caps, &dd->back);
531	511	if (result != DD_OK)
532	512	{
533	513	osd_printf_verbose("DirectDraw: Error %08X getting attached back surface\n", (int)result);
r243398	r243399
536	516	}
537	517
538	518	// now make a description of our blit surface, based on the primary surface
539		if (blitwidth == 0 \|\| blitheight == 0)
540		compute_blit_surface_size();
541		blitdesc = primarydesc;
542		blitdesc.dwFlags = DDSD_WIDTH \| DDSD_HEIGHT \| DDSD_PIXELFORMAT \| DDSD_CAPS;
543		blitdesc.dwWidth = blitwidth;
544		blitdesc.dwHeight = blitheight;
545		blitdesc.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
	519	if (dd->blitwidth == 0 \|\| dd->blitheight == 0)
	520	compute_blit_surface_size(window);
	521	dd->blitdesc = dd->primarydesc;
	522	dd->blitdesc.dwFlags = DDSD_WIDTH \| DDSD_HEIGHT \| DDSD_PIXELFORMAT \| DDSD_CAPS;
	523	dd->blitdesc.dwWidth = dd->blitwidth;
	524	dd->blitdesc.dwHeight = dd->blitheight;
	525	dd->blitdesc.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
546	526
547	527	// then create the blit surface, fall back to system memory if video mem doesn't work
548		result = create_surface(&blitdesc, &blit, "blit");
	528	result = create_surface(dd, &dd->blitdesc, &dd->blit, "blit");
549	529	if (result != DD_OK)
550	530	{
551		blitdesc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
552		result = create_surface(&blitdesc, &blit, "blit");
	531	dd->blitdesc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
	532	result = create_surface(dd, &dd->blitdesc, &dd->blit, "blit");
553	533	}
554	534	if (result != DD_OK) goto error;
555	535
556	536	// create a memory buffer for offscreen drawing
557		if (membuffersize < blitwidth * blitheight * 4)
	537	if (dd->membuffersize < dd->blitwidth * dd->blitheight * 4)
558	538	{
559		membuffersize = blitwidth * blitheight * 4;
560		global_free_array(membuffer);
561		membuffer = global_alloc_array(UINT8, membuffersize);
	539	dd->membuffersize = dd->blitwidth * dd->blitheight * 4;
	540	global_free_array(dd->membuffer);
	541	dd->membuffer = global_alloc_array(UINT8, dd->membuffersize);
562	542	}
563		if (membuffer == NULL)
	543	if (dd->membuffer == NULL)
564	544	goto error;
565	545
566	546	// create a clipper for windowed mode
567		if (!window~~().~~m_fullscreen && create_clipper())
	547	if (!window->m_fullscreen && create_clipper(window))
568	548	goto error;
569	549
570	550	// full screen mode: set the gamma
571		if (window~~().~~m_fullscreen)
	551	if (window->m_fullscreen)
572	552	{
573	553	// only set the gamma if it's not 1.0f
574		windows_options &options = downcast<windows_options &>(window~~().~~machine().options());
	554	windows_options &options = downcast<windows_options &>(window->machine().options());
575	555	float brightness = options.full_screen_brightness();
576	556	float contrast = options.full_screen_contrast();
577		float fgamma = options.full_screen_gamma();
578		if (brightness != 1.0f \|\| contrast != 1.0f \|\| fgamma != 1.0f)
	557	float gamma = options.full_screen_gamma();
	558	if (brightness != 1.0f \|\| contrast != 1.0f \|\| gamma != 1.0f)
579	559	{
580	560	// see if we can get a GammaControl object
581		result = IDirectDrawSurface_QueryInterface(primary, WRAP_REFIID(IID_IDirectDrawGammaControl), (void **)&gamma);
	561	result = IDirectDrawSurface_QueryInterface(dd->primary, WRAP_REFIID(IID_IDirectDrawGammaControl), (void **)&dd->gamma);
582	562	if (result != DD_OK)
583	563	{
584	564	osd_printf_warning("DirectDraw: Warning - device does not support full screen gamma correction.\n");
585		~~this~~->gamma = NULL;
	565	dd->gamma = NULL;
586	566	}
587	567
588	568	// proceed if we can
589		if (~~this~~->gamma != NULL)
	569	if (dd->gamma != NULL)
590	570	{
591	571	DDGAMMARAMP ramp;
592	572	int i;
593	573
594	574	// create a standard ramp and set it
595	575	for (i = 0; i < 256; i++)
596		ramp.red[i] = ramp.green[i] = ramp.blue[i] = apply_brightness_contrast_gamma(i, brightness, contrast, fgamma) << 8;
	576	ramp.red[i] = ramp.green[i] = ramp.blue[i] = apply_brightness_contrast_gamma(i, brightness, contrast, gamma) << 8;
597	577
598	578	// attempt to set it
599		result = IDirectDrawGammaControl_SetGammaRamp(~~this~~->gamma, 0, &ramp);
	579	result = IDirectDrawGammaControl_SetGammaRamp(dd->gamma, 0, &ramp);
600	580	if (result != DD_OK)
601	581	osd_printf_verbose("DirectDraw: Error %08X attempting to set gamma correction.\n", (int)result);
602	582	}
r243398	r243399
604	584	}
605	585
606	586	// force some updates
607		update_outer_rects();
	587	update_outer_rects(dd);
608	588	return 0;
609	589
610	590	error:
611		ddraw_delete_surfaces();
	591	ddraw_delete_surfaces(window);
612	592	return 1;
613	593	}
614	594
r243398	r243399
618	598	// ddraw_delete
619	599	//============================================================
620	600
621		void ~~ren~~d~~erer_~~d~~d::dd~~raw_delete()
	601	static void ddraw_delete(win_window_info *window)
622	602	{
	603	dd_info dd = (dd_info )window->m_drawdata;
	604
623	605	// free surfaces
624		ddraw_delete_surfaces();
	606	ddraw_delete_surfaces(window);
625	607
626	608	// restore resolutions
627		if (ddraw != NULL)
628		IDirectDraw7_RestoreDisplayMode(ddraw);
	609	if (dd->ddraw != NULL)
	610	IDirectDraw7_RestoreDisplayMode(dd->ddraw);
629	611
630	612	// reset cooperative level
631		if (ddraw != NULL && window().m_hwnd != NULL)
632		IDirectDraw7_SetCooperativeLevel(ddraw, window().m_hwnd, DDSCL_NORMAL);
	613	if (dd->ddraw != NULL && window->m_hwnd != NULL)
	614	IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->m_hwnd, DDSCL_NORMAL);
633	615
634	616	// release the DirectDraw object itself
635		if (ddraw != NULL)
636		IDirectDraw7_Release(ddraw);
637		ddraw = NULL;
	617	if (dd->ddraw != NULL)
	618	IDirectDraw7_Release(dd->ddraw);
	619	dd->ddraw = NULL;
638	620	}
639	621
640	622
r243398	r243399
643	625	// ddraw_delete_surfaces
644	626	//============================================================
645	627
646		void ~~ren~~d~~erer_~~d~~d::dd~~raw_delete_surfaces()
	628	static void ddraw_delete_surfaces(win_window_info *window)
647	629	{
	630	dd_info dd = (dd_info )window->m_drawdata;
	631
648	632	// release the gamma control
649		if (gamma != NULL)
650		IDirectDrawGammaControl_Release(gamma);
651		gamma = NULL;
	633	if (dd->gamma != NULL)
	634	IDirectDrawGammaControl_Release(dd->gamma);
	635	dd->gamma = NULL;
652	636
653	637	// release the clipper
654		if (clipper != NULL)
655		IDirectDrawClipper_Release(clipper);
656		clipper = NULL;
	638	if (dd->clipper != NULL)
	639	IDirectDrawClipper_Release(dd->clipper);
	640	dd->clipper = NULL;
657	641
658	642	// free the memory buffer
659		global_free_array(membuffer);
660		membuffer = NULL;
661		membuffersize = 0;
	643	global_free_array(dd->membuffer);
	644	dd->membuffer = NULL;
	645	dd->membuffersize = 0;
662	646
663	647	// release the blit surface
664		if (blit != NULL)
665		IDirectDrawSurface7_Release(blit);
666		blit = NULL;
	648	if (dd->blit != NULL)
	649	IDirectDrawSurface7_Release(dd->blit);
	650	dd->blit = NULL;
667	651
668	652	// release the back surface
669		if (back != NULL)
670		IDirectDrawSurface7_Release(back);
671		back = NULL;
	653	if (dd->back != NULL)
	654	IDirectDrawSurface7_Release(dd->back);
	655	dd->back = NULL;
672	656
673	657	// release the primary surface
674		if (primary != NULL)
675		IDirectDrawSurface7_Release(primary);
676		primary = NULL;
	658	if (dd->primary != NULL)
	659	IDirectDrawSurface7_Release(dd->primary);
	660	dd->primary = NULL;
677	661	}
678	662
679	663
r243398	r243399
682	666	// ddraw_verify_caps
683	667	//============================================================
684	668
685		int ~~ren~~d~~erer_~~d~~d::dd~~raw_verify_caps()
	669	static int ddraw_verify_caps(dd_info *dd)
686	670	{
687	671	int retval = 0;
688	672	HRESULT result;
689	673
690	674	// get the capabilities
691		ddcaps.dwSize = sizeof(ddcaps);
692		helcaps.dwSize = sizeof(helcaps);
693		result = IDirectDraw7_GetCaps(ddraw, &ddcaps, &helcaps);
	675	dd->ddcaps.dwSize = sizeof(dd->ddcaps);
	676	dd->helcaps.dwSize = sizeof(dd->helcaps);
	677	result = IDirectDraw7_GetCaps(dd->ddraw, &dd->ddcaps, &dd->helcaps);
694	678	if (result != DD_OK)
695	679	{
696	680	osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_GetCaps call\n", (int)result);
r243398	r243399
698	682	}
699	683
700	684	// determine if hardware stretching is available
701		if ((ddcaps.dwCaps & DDCAPS_BLTSTRETCH) == 0)
	685	if ((dd->ddcaps.dwCaps & DDCAPS_BLTSTRETCH) == 0)
702	686	{
703	687	osd_printf_verbose("DirectDraw: Warning - Device does not support hardware stretching\n");
704	688	retval = 1;
r243398	r243399
713	697	// ddraw_test_cooperative
714	698	//============================================================
715	699
716		int ~~ren~~d~~erer_~~d~~d::dd~~raw_test_cooperative()
	700	static int ddraw_test_cooperative(win_window_info *window)
717	701	{
	702	dd_info dd = (dd_info )window->m_drawdata;
718	703	HRESULT result;
719	704
720	705	// check our current status; if we lost the device, punt to GDI
721		result = IDirectDraw7_TestCooperativeLevel(ddraw);
	706	result = IDirectDraw7_TestCooperativeLevel(dd->ddraw);
722	707	switch (result)
723	708	{
724	709	// punt to GDI if someone else has exclusive mode
725	710	case DDERR_NOEXCLUSIVEMODE:
726	711	case DDERR_EXCLUSIVEMODEALREADYSET:
727		ddraw_delete_surfaces();
	712	ddraw_delete_surfaces(window);
728	713	return 1;
729	714
730	715	// if we're ok, but we don't have a primary surface, create one
731	716	default:
732	717	case DD_OK:
733		if (primary == NULL)
734		return ddraw_create_surfaces();
	718	if (dd->primary == NULL)
	719	return ddraw_create_surfaces(window);
735	720	return 0;
736	721	}
737	722	}
r243398	r243399
742	727	// create_surface
743	728	//============================================================
744	729
745		HRESULT ~~renderer_dd::~~create_surface(DDSURFACEDESC2 desc, IDirectDrawSurface7 surface, const char type)
	730	static HRESULT create_surface(dd_info dd, DDSURFACEDESC2 desc, IDirectDrawSurface7 *surface, const char type)
746	731	{
747	732	HRESULT result;
748	733
749	734	// create the surface as requested
750		result = IDirectDraw7_CreateSurface(ddraw, desc, surface, NULL);
	735	result = IDirectDraw7_CreateSurface(dd->ddraw, desc, surface, NULL);
751	736	if (result != DD_OK)
752	737	{
753	738	osd_printf_verbose("DirectDraw: Error %08X creating %s surface\n", (int)result, type);
r243398	r243399
782	767	// create_clipper
783	768	//============================================================
784	769
785		int ~~renderer_dd::~~create_clipper()
	770	static int create_clipper(win_window_info *window)
786	771	{
	772	dd_info dd = (dd_info )window->m_drawdata;
787	773	HRESULT result;
788	774
789	775	// create a clipper for the primary surface
790		result = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
	776	result = IDirectDraw7_CreateClipper(dd->ddraw, 0, &dd->clipper, NULL);
791	777	if (result != DD_OK)
792	778	{
793	779	osd_printf_verbose("DirectDraw: Error %08X creating clipper\n", (int)result);
r243398	r243399
795	781	}
796	782
797	783	// set the clipper's hwnd
798		result = IDirectDrawClipper_SetHWnd(clipper, 0, window~~().~~m_hwnd);
	784	result = IDirectDrawClipper_SetHWnd(dd->clipper, 0, window->m_hwnd);
799	785	if (result != DD_OK)
800	786	{
801	787	osd_printf_verbose("DirectDraw: Error %08X setting clipper hwnd\n", (int)result);
r243398	r243399
803	789	}
804	790
805	791	// set the clipper on the primary surface
806		result = IDirectDrawSurface7_SetClipper(primary, clipper);
	792	result = IDirectDrawSurface7_SetClipper(dd->primary, dd->clipper);
807	793	if (result != DD_OK)
808	794	{
809	795	osd_printf_verbose("DirectDraw: Error %08X setting clipper on primary surface\n", (int)result);
r243398	r243399
818	804	// compute_blit_surface_size
819	805	//============================================================
820	806
821		void ~~renderer_dd::~~compute_blit_surface_size()
	807	static void compute_blit_surface_size(win_window_info *window)
822	808	{
	809	dd_info dd = (dd_info )window->m_drawdata;
823	810	INT32 newwidth, newheight;
824	811	int xscale, yscale;
825	812	RECT client;
826	813
827	814	// start with the minimum size
828		window~~().~~m_target->compute_minimum_size(newwidth, newheight);
	815	window->m_target->compute_minimum_size(newwidth, newheight);
829	816
830	817	// get the window's client rectangle
831		GetClientRect(window~~().~~m_hwnd, &client);
	818	GetClientRect(window->m_hwnd, &client);
832	819
833	820	// hardware stretch case: apply prescale
834	821	if (video_config.hwstretch)
r243398	r243399
854	841	// compute the appropriate visible area if we're trying to keepaspect
855	842	if (video_config.keepaspect)
856	843	{
857		win_monitor_info *monitor = winwindow_video_window_monitor(&window(), NULL);
858		window().m_target->compute_visible_area(target_width, target_height, monitor->get_aspect(), window().m_target->orientation(), target_width, target_height);
	844	win_monitor_info *monitor = winwindow_video_window_monitor(window, NULL);
	845	window->m_target->compute_visible_area(target_width, target_height, monitor->get_aspect(), window->m_target->orientation(), target_width, target_height);
859	846	desired_aspect = (float)target_width / (float)target_height;
860	847	}
861	848
r243398	r243399
897	884	// apply the final scale
898	885	newwidth *= xscale;
899	886	newheight *= yscale;
900		if (newwidth != blitwidth \|\| newheight != blitheight)
	887	if (newwidth != dd->blitwidth \|\| newheight != dd->blitheight)
901	888	{
902	889	// force some updates
903		update_outer_rects();
	890	update_outer_rects(dd);
904	891	osd_printf_verbose("DirectDraw: New blit size = %dx%d\n", newwidth, newheight);
905	892	}
906		blitwidth = newwidth;
907		blitheight = newheight;
	893	dd->blitwidth = newwidth;
	894	dd->blitheight = newheight;
908	895	}
909	896
910	897
r243398	r243399
913	900	// calc_fullscreen_margins
914	901	//============================================================
915	902
916		void ~~renderer_dd::~~calc_fullscreen_margins(DWORD desc_width, DWORD desc_height, RECT *margins)
	903	static void calc_fullscreen_margins(win_window_info window, DWORD desc_width, DWORD desc_height, RECT margins)
917	904	{
918	905	margins->left = 0;
919	906	margins->top = 0;
920	907	margins->right = desc_width;
921	908	margins->bottom = desc_height;
922	909
923		if (win_has_menu(&window()))
	910	if (win_has_menu(window))
924	911	{
925	912	static int height_with_menubar = 0;
926	913	if (height_with_menubar == 0)
r243398	r243399
941	928	// blit_to_primary
942	929	//============================================================
943	930
944		void ~~renderer_dd::~~blit_to_primary(int srcwidth, int srcheight)
	931	static void blit_to_primary(win_window_info *window, int srcwidth, int srcheight)
945	932	{
946		IDirectDrawSurface7 *target = (back != NULL) ? back : primary;
947		win_monitor_info *monitor = winwindow_video_window_monitor(&window(), NULL);
	933	dd_info dd = (dd_info )window->m_drawdata;
	934	IDirectDrawSurface7 *target = (dd->back != NULL) ? dd->back : dd->primary;
	935	win_monitor_info *monitor = winwindow_video_window_monitor(window, NULL);
948	936	DDBLTFX blitfx = { sizeof(DDBLTFX) };
949	937	RECT clear, outer, dest, source;
950	938	INT32 dstwidth, dstheight;
r243398	r243399
956	944	source.bottom = srcheight;
957	945
958	946	// compute outer rect -- windowed version
959		if (!window~~().~~m_fullscreen)
	947	if (!window->m_fullscreen)
960	948	{
961		GetClientRect(window().m_hwnd, &outer);
962		ClientToScreen(window().m_hwnd, &((LPPOINT)&outer)[0]);
963		ClientToScreen(window().m_hwnd, &((LPPOINT)&outer)[1]);
	949	GetClientRect(window->m_hwnd, &outer);
	950	ClientToScreen(window->m_hwnd, &((LPPOINT)&outer)[0]);
	951	ClientToScreen(window->m_hwnd, &((LPPOINT)&outer)[1]);
964	952
965	953	// adjust to be relative to the monitor
966	954	outer.left -= monitor->info.rcMonitor.left;
r243398	r243399
972	960	// compute outer rect -- full screen version
973	961	else
974	962	{
975		calc_fullscreen_margins(primarydesc.dwWidth, primarydesc.dwHeight, &outer);
	963	calc_fullscreen_margins(window, dd->primarydesc.dwWidth, dd->primarydesc.dwHeight, &outer);
976	964	}
977	965
978	966	// if we're respecting the aspect ratio, we need to adjust to fit
r243398	r243399
999	987	else if (video_config.keepaspect)
1000	988	{
1001	989	// compute the appropriate visible area
1002		window~~().~~m_target->compute_visible_area(rect_width(&outer), rect_height(&outer), monitor->get_aspect(), window~~().~~m_target->orientation(), dstwidth, dstheight);
	990	window->m_target->compute_visible_area(rect_width(&outer), rect_height(&outer), monitor->get_aspect(), window->m_target->orientation(), dstwidth, dstheight);
1003	991	}
1004	992
1005	993	// center within
r243398	r243399
1009	997	dest.bottom = dest.top + dstheight;
1010	998
1011	999	// compare against last destination; if different, force a redraw
1012		if (dest.left != lastdest.left \|\| dest.right != lastdest.right \|\| dest.top != lastdest.top \|\| dest.bottom != lastdest.bottom)
	1000	if (dest.left != dd->lastdest.left \|\| dest.right != dd->lastdest.right \|\| dest.top != dd->lastdest.top \|\| dest.bottom != dd->lastdest.bottom)
1013	1001	{
1014		lastdest = dest;
1015		update_outer_rects();
	1002	dd->lastdest = dest;
	1003	update_outer_rects(dd);
1016	1004	}
1017	1005
1018	1006	// clear outer rects if we need to
1019		if (clearouter != 0)
	1007	if (dd->clearouter != 0)
1020	1008	{
1021		clearouter--;
	1009	dd->clearouter--;
1022	1010
1023	1011	// clear the left edge
1024	1012	if (dest.left > outer.left)
r243398	r243399
1058	1046	}
1059	1047
1060	1048	// do the blit
1061		result = IDirectDrawSurface7_Blt(target, &dest, blit, &source, DDBLT_WAIT, NULL);
	1049	result = IDirectDrawSurface7_Blt(target, &dest, dd->blit, &source, DDBLT_WAIT, NULL);
1062	1050	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X blitting to the screen\n", (int)result);
1063	1051
1064	1052	// page flip if triple buffered
1065		if (window~~().~~m_fullscreen && back != NULL)
	1053	if (window->m_fullscreen && dd->back != NULL)
1066	1054	{
1067		result = IDirectDrawSurface7_Flip(primary, NULL, DDFLIP_WAIT);
	1055	result = IDirectDrawSurface7_Flip(dd->primary, NULL, DDFLIP_WAIT);
1068	1056	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result);
1069	1057	}
1070	1058	}
r243398	r243399
1075	1063	// config_adapter_mode
1076	1064	//============================================================
1077	1065
1078		int ~~renderer_dd::~~config_adapter_mode()
	1066	static int config_adapter_mode(win_window_info *window)
1079	1067	{
1080	1068	DDDEVICEIDENTIFIER2 identifier;
	1069	dd_info dd = (dd_info )window->m_drawdata;
1081	1070	HRESULT result;
1082	1071
1083	1072	// choose the monitor number
1084		get_adapter_for_monitor(window~~().~~m_monitor);
	1073	get_adapter_for_monitor(dd, window->m_monitor);
1085	1074
1086	1075	// create a temporary DirectDraw object
1087		result = (directdrawcreateex)(adapter_ptr, (LPVOID )&ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL);
	1076	result = (directdrawcreateex)(dd->adapter_ptr, (LPVOID )&dd->ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL);
1088	1077	if (result != DD_OK)
1089	1078	{
1090	1079	osd_printf_verbose("DirectDraw: Error %08X during DirectDrawCreateEx call\n", (int)result);
r243398	r243399
1092	1081	}
1093	1082
1094	1083	// get the identifier
1095		result = IDirectDraw7_GetDeviceIdentifier(ddraw, &identifier, 0);
	1084	result = IDirectDraw7_GetDeviceIdentifier(dd->ddraw, &identifier, 0);
1096	1085	if (result != DD_OK)
1097	1086	{
1098	1087	osd_printf_error("Error getting identifier for device\n");
r243398	r243399
1101	1090	osd_printf_verbose("DirectDraw: Configuring device %s\n", identifier.szDescription);
1102	1091
1103	1092	// get the current display mode
1104		memset(&origmode, 0, sizeof(origmode));
1105		origmode.dwSize = sizeof(origmode);
1106		result = IDirectDraw7_GetDisplayMode(ddraw, &origmode);
	1093	memset(&dd->origmode, 0, sizeof(dd->origmode));
	1094	dd->origmode.dwSize = sizeof(dd->origmode);
	1095	result = IDirectDraw7_GetDisplayMode(dd->ddraw, &dd->origmode);
1107	1096	if (result != DD_OK)
1108	1097	{
1109	1098	osd_printf_verbose("DirectDraw: Error %08X getting current display mode\n", (int)result);
1110		IDirectDraw7_Release(ddraw);
	1099	IDirectDraw7_Release(dd->ddraw);
1111	1100	return 1;
1112	1101	}
1113	1102
1114	1103	// choose a resolution: full screen mode case
1115		if (window~~().~~m_fullscreen)
	1104	if (window->m_fullscreen)
1116	1105	{
1117	1106	// default to the current mode exactly
1118		width = origmode.dwWidth;
1119		height = origmode.dwHeight;
1120		refresh = origmode.dwRefreshRate;
	1107	dd->width = dd->origmode.dwWidth;
	1108	dd->height = dd->origmode.dwHeight;
	1109	dd->refresh = dd->origmode.dwRefreshRate;
1121	1110
1122	1111	// if we're allowed to switch resolutions, override with something better
1123	1112	if (video_config.switchres)
1124		pick_best_mode();
	1113	pick_best_mode(window);
1125	1114	}
1126	1115
1127	1116	// release the DirectDraw object
1128		IDirectDraw7_Release(ddraw);
1129		ddraw = NULL;
	1117	IDirectDraw7_Release(dd->ddraw);
	1118	dd->ddraw = NULL;
1130	1119
1131	1120	// if we're not changing resolutions, make sure we have a resolution we can handle
1132		if (!window~~().~~m_fullscreen \|\| !video_config.switchres)
	1121	if (!window->m_fullscreen \|\| !video_config.switchres)
1133	1122	{
1134		switch (origmode.ddpfPixelFormat.dwRBitMask)
	1123	switch (dd->origmode.ddpfPixelFormat.dwRBitMask)
1135	1124	{
1136	1125	case 0x00ff0000:
1137	1126	case 0x000000ff:
r243398	r243399
1140	1129	break;
1141	1130
1142	1131	default:
1143		osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)origmode.ddpfPixelFormat.dwRBitMask, (int)origmode.ddpfPixelFormat.dwGBitMask, (int)origmode.ddpfPixelFormat.dwBBitMask);
	1132	osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->origmode.ddpfPixelFormat.dwRBitMask, (int)dd->origmode.ddpfPixelFormat.dwGBitMask, (int)dd->origmode.ddpfPixelFormat.dwBBitMask);
1144	1133	return 1;
1145	1134	}
1146	1135	}
r243398	r243399
1175	1164	// get_adapter_for_monitor
1176	1165	//============================================================
1177	1166
1178		void ~~renderer_dd::~~get_adapter_for_monitor(win_monitor_info *monitor)
	1167	static void get_adapter_for_monitor(dd_info dd, win_monitor_info monitor)
1179	1168	{
1180	1169	monitor_enum_info einfo;
1181	1170	HRESULT result;
r243398	r243399
1189	1178	// set up the adapter
1190	1179	if (einfo.foundit && einfo.guid_ptr != NULL)
1191	1180	{
1192		adapter = einfo.guid;
1193		adapter_ptr = &adapter;
	1181	dd->adapter = einfo.guid;
	1182	dd->adapter_ptr = &dd->adapter;
1194	1183	}
1195	1184	else
1196		adapter_ptr = NULL;
	1185	dd->adapter_ptr = NULL;
1197	1186	}
1198	1187
1199	1188
r243398	r243399
1206	1195	{
1207	1196	float size_score, refresh_score, final_score;
1208	1197	mode_enum_info einfo = (mode_enum_info )context;
1209		~~ren~~d~~erer_~~dd dd = d~~ynamic_cast<ren~~d~~erer~~_dd >(einfo->window->m_~~ren~~der~~er)~~;
	1198	dd_info dd = (dd_info )einfo->window->m_drawdata;
1210	1199
1211	1200	// skip non-32 bit modes
1212	1201	if (desc->ddpfPixelFormat.dwRGBBitCount != 32)
r243398	r243399
1259	1248	// pick_best_mode
1260	1249	//============================================================
1261	1250
1262		void ~~renderer_dd::~~pick_best_mode()
	1251	static void pick_best_mode(win_window_info *window)
1263	1252	{
	1253	dd_info dd = (dd_info )window->m_drawdata;
1264	1254	mode_enum_info einfo;
1265	1255	HRESULT result;
1266	1256
r243398	r243399
1268	1258	// note: technically we should not be calling this from an alternate window
1269	1259	// thread; however, it is only done during init time, and the init code on
1270	1260	// the main thread is waiting for us to finish, so it is safe to do so here
1271		window~~().~~m_target->compute_minimum_size(einfo.minimum_width, einfo.minimum_height);
	1261	window->m_target->compute_minimum_size(einfo.minimum_width, einfo.minimum_height);
1272	1262
1273	1263	// use those as the target for now
1274	1264	einfo.target_width = einfo.minimum_width * MAX(1, video_config.prescale);
r243398	r243399
1276	1266
1277	1267	// determine the refresh rate of the primary screen
1278	1268	einfo.target_refresh = 60.0;
1279		const screen_device *primary_screen = window~~().~~machine().config().first_screen();
	1269	const screen_device *primary_screen = window->machine().config().first_screen();
1280	1270	if (primary_screen != NULL)
1281	1271	einfo.target_refresh = ATTOSECONDS_TO_HZ(primary_screen->refresh_attoseconds());
1282	1272	printf("Target refresh = %f\n", einfo.target_refresh);
r243398	r243399
1296	1286	}
1297	1287
1298	1288	// fill in the rest of the data
1299		einfo.window = &window();
	1289	einfo.window = window;
1300	1290	einfo.best_score = 0.0f;
1301	1291
1302	1292	// enumerate the modes
1303	1293	osd_printf_verbose("DirectDraw: Selecting video mode...\n");
1304		result = IDirectDraw7_EnumDisplayModes(ddraw, DDEDM_REFRESHRATES, NULL, &einfo, enum_modes_callback);
	1294	result = IDirectDraw7_EnumDisplayModes(dd->ddraw, DDEDM_REFRESHRATES, NULL, &einfo, enum_modes_callback);
1305	1295	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X during EnumDisplayModes call\n", (int)result);
1306		osd_printf_verbose("DirectDraw: Mode selected = %4dx%4d@%3dHz\n", width, height, refresh);
	1296	osd_printf_verbose("DirectDraw: Mode selected = %4dx%4d@%3dHz\n", dd->width, dd->height, dd->refresh);
1307	1297	}

trunk/src/osd/windows/drawgdi.c
r243398	r243399
18	18	#include "window.h"
19	19
20	20
	21
21	22	//============================================================
22	23	// TYPE DEFINITIONS
23	24	//============================================================
24	25
25		class renderer_gdi : public osd_renderer
	26	/* gdi_info is the information for the current screen */
	27	struct gdi_info
26	28	{
27		public:
28		renderer_gdi(win_window_info *window)
29		: osd_renderer(window, FLAG_NONE), bmdata(NULL), bmsize(0) { }
30
31		virtual ~renderer_gdi() { }
32
33		virtual int init();
34		virtual render_primitive_list *get_primitives();
35		virtual int draw(HDC dc, int update);
36		virtual void save() {};
37		virtual void record() {};
38		virtual void toggle_fsfx() {};
39		virtual void destroy();
40
41		private:
42		/* gdi_info is the information for the current screen */
43	29	BITMAPINFO bminfo;
44	30	UINT8 * bmdata;
45	31	size_t bmsize;
46	32	};
47	33
48	34
	35
49	36	//============================================================
50	37	// PROTOTYPES
51	38	//============================================================
52	39
53	40	// core functions
54	41	static void drawgdi_exit(void);
	42	static int drawgdi_window_init(win_window_info *window);
	43	static void drawgdi_window_destroy(win_window_info *window);
	44	static render_primitive_list drawgdi_window_get_primitives(win_window_info window);
	45	static int drawgdi_window_draw(win_window_info *window, HDC dc, int update);
55	46
56		//============================================================
57		// drawnone_create
58		//============================================================
59	47
60		static osd_renderer drawgdi_create(win_window_info window)
61		{
62		return global_alloc(renderer_gdi(window));
63		}
64	48
65
66	49	//============================================================
67	50	// drawgdi_init
68	51	//============================================================
69	52
70		int drawgdi_init(running_machine &machine, ~~osd~~_draw_callbacks *callbacks)
	53	int drawgdi_init(running_machine &machine, win_draw_callbacks *callbacks)
71	54	{
72	55	// fill in the callbacks
73	56	memset(callbacks, 0, sizeof(*callbacks));
74	57	callbacks->exit = drawgdi_exit;
75		callbacks->create = drawgdi_create;
	58	callbacks->window_init = drawgdi_window_init;
	59	callbacks->window_get_primitives = drawgdi_window_get_primitives;
	60	callbacks->window_draw = drawgdi_window_draw;
	61	callbacks->window_destroy = drawgdi_window_destroy;
76	62	return 0;
77	63	}
78	64
r243398	r243399
92	78	// drawgdi_window_init
93	79	//============================================================
94	80
95		int ~~ren~~der~~er_~~gdi::init()
	81	static int drawgdi_window_init(win_window_info *window)
96	82	{
	83	// allocate memory for our structures
	84	gdi_info *gdi = global_alloc_clear(gdi_info);
	85	window->m_drawdata = gdi;
97	86
98	87	// fill in the bitmap info header
99		bminfo.bmiHeader.biSize = sizeof(bminfo.bmiHeader);
100		bminfo.bmiHeader.biPlanes = 1;
101		bminfo.bmiHeader.biBitCount = 32;
102		bminfo.bmiHeader.biCompression = BI_RGB;
103		bminfo.bmiHeader.biSizeImage = 0;
104		bminfo.bmiHeader.biXPelsPerMeter = 0;
105		bminfo.bmiHeader.biYPelsPerMeter = 0;
106		bminfo.bmiHeader.biClrUsed = 0;
107		bminfo.bmiHeader.biClrImportant = 0;
	88	gdi->bminfo.bmiHeader.biSize = sizeof(gdi->bminfo.bmiHeader);
	89	gdi->bminfo.bmiHeader.biPlanes = 1;
	90	gdi->bminfo.bmiHeader.biBitCount = 32;
	91	gdi->bminfo.bmiHeader.biCompression = BI_RGB;
	92	gdi->bminfo.bmiHeader.biSizeImage = 0;
	93	gdi->bminfo.bmiHeader.biXPelsPerMeter = 0;
	94	gdi->bminfo.bmiHeader.biYPelsPerMeter = 0;
	95	gdi->bminfo.bmiHeader.biClrUsed = 0;
	96	gdi->bminfo.bmiHeader.biClrImportant = 0;
108	97
109	98	return 0;
110	99	}
r243398	r243399
115	104	// drawgdi_window_destroy
116	105	//============================================================
117	106
118		void ~~ren~~der~~er_~~gdi::destroy()
	107	static void drawgdi_window_destroy(win_window_info *window)
119	108	{
	109	gdi_info gdi = (gdi_info )window->m_drawdata;
120	110
	111	// skip if nothing
	112	if (gdi == NULL)
	113	return;
	114
121	115	// free the bitmap memory
122		if (bmdata != NULL)
123		global_free_array(bmdata);
	116	if (gdi->bmdata != NULL)
	117	global_free_array(gdi->bmdata);
	118	global_free(gdi);
	119	window->m_drawdata = NULL;
124	120	}
125	121
126	122
r243398	r243399
129	125	// drawgdi_window_get_primitives
130	126	//============================================================
131	127
132		render_primitive_list *~~ren~~der~~er_~~gdi::get_primitives()
	128	static render_primitive_list drawgdi_window_get_primitives(win_window_info window)
133	129	{
134	130	RECT client;
135		GetClientRect(window().m_hwnd, &client);
136		window().m_target->set_bounds(rect_width(&client), rect_height(&client), window().m_monitor->get_aspect());
137		return &window().m_target->get_primitives();
	131	GetClientRect(window->m_hwnd, &client);
	132	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	133	return &window->m_target->get_primitives();
138	134	}
139	135
140	136
r243398	r243399
143	139	// drawgdi_window_draw
144	140	//============================================================
145	141
146		int ~~ren~~der~~er_~~gdi::draw(HDC dc, int update)
	142	static int drawgdi_window_draw(win_window_info *window, HDC dc, int update)
147	143	{
	144	gdi_info gdi = (gdi_info )window->m_drawdata;
148	145	int width, height, pitch;
149	146	RECT bounds;
150	147
151	148	// we don't have any special resize behaviors
152		if (window().m_resize_state == RESIZE_STATE_PENDING)
153		window().m_resize_state = RESIZE_STATE_NORMAL;
	149	if (window->m_resize_state == RESIZE_STATE_PENDING)
	150	window->m_resize_state = RESIZE_STATE_NORMAL;
154	151
155	152	// get the target bounds
156		GetClientRect(window~~().~~m_hwnd, &bounds);
	153	GetClientRect(window->m_hwnd, &bounds);
157	154
158	155	// compute width/height/pitch of target
159	156	width = rect_width(&bounds);
r243398	r243399
161	158	pitch = (width + 3) & ~3;
162	159
163	160	// make sure our temporary bitmap is big enough
164		if (pitch * height * 4 > bmsize)
	161	if (pitch * height * 4 > gdi->bmsize)
165	162	{
166		bmsize = pitch * height * 4 * 2;
167		global_free_array(bmdata);
168		bmdata = global_alloc_array(UINT8, bmsize);
	163	gdi->bmsize = pitch * height * 4 * 2;
	164	global_free_array(gdi->bmdata);
	165	gdi->bmdata = global_alloc_array(UINT8, gdi->bmsize);
169	166	}
170	167
171	168	// draw the primitives to the bitmap
172		window().m_primlist->acquire_lock();
173		software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window().m_primlist, bmdata, width, height, pitch);
174		window().m_primlist->release_lock();
	169	window->m_primlist->acquire_lock();
	170	software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window->m_primlist, gdi->bmdata, width, height, pitch);
	171	window->m_primlist->release_lock();
175	172
176	173	// fill in bitmap-specific info
177		bminfo.bmiHeader.biWidth = pitch;
178		bminfo.bmiHeader.biHeight = -height;
	174	gdi->bminfo.bmiHeader.biWidth = pitch;
	175	gdi->bminfo.bmiHeader.biHeight = -height;
179	176
180	177	// blit to the screen
181	178	StretchDIBits(dc, 0, 0, width, height,
182	179	0, 0, width, height,
183		bmdata, &bminfo, DIB_RGB_COLORS, SRCCOPY);
	180	gdi->bmdata, &gdi->bminfo, DIB_RGB_COLORS, SRCCOPY);
184	181	return 0;
185	182	}

trunk/src/osd/windows/drawnone.c
r243398	r243399
17	17	#include "window.h"
18	18
19	19
20		class renderer_none : public osd_renderer
21		{
22		public:
23		renderer_none(win_window_info *window)
24		: osd_renderer(window, FLAG_NONE) { }
25	20
26		virtual ~renderer_none() { }
27
28		virtual int init();
29		virtual render_primitive_list *get_primitives();
30		virtual int draw(HDC dc, int update);
31		virtual void save() { };
32		virtual void record() { };
33		virtual void toggle_fsfx() { };
34		virtual void destroy();
35
36		private:
37		};
38
39	21	//============================================================
40	22	// PROTOTYPES
41	23	//============================================================
42	24
43	25	// core functions
44	26	static void drawnone_exit(void);
	27	static int drawnone_window_init(win_window_info *window);
	28	static void drawnone_window_destroy(win_window_info *window);
	29	static render_primitive_list drawnone_window_get_primitives(win_window_info window);
	30	static int drawnone_window_draw(win_window_info *window, HDC dc, int update);
45	31
46		//============================================================
47		// drawnone_create
48		//============================================================
49	32
50		osd_renderer drawnone_create(win_window_info window)
51		{
52		return global_alloc(renderer_none(window));
53		}
54	33
55	34	//============================================================
56	35	// drawnone_init
57	36	//============================================================
58	37
59		int drawnone_init(running_machine &machine, ~~osd~~_draw_callbacks *callbacks)
	38	int drawnone_init(running_machine &machine, win_draw_callbacks *callbacks)
60	39	{
61	40	// fill in the callbacks
62	41	memset(callbacks, 0, sizeof(*callbacks));
63	42	callbacks->exit = drawnone_exit;
64		callbacks->create = drawnone_create;
	43	callbacks->window_init = drawnone_window_init;
	44	callbacks->window_get_primitives = drawnone_window_get_primitives;
	45	callbacks->window_draw = drawnone_window_draw;
	46	callbacks->window_destroy = drawnone_window_destroy;
65	47	return 0;
66	48	}
67	49
r243398	r243399
81	63	// drawnone_window_init
82	64	//============================================================
83	65
84		int ~~ren~~der~~er_~~none::init()
	66	static int drawnone_window_init(win_window_info *window)
85	67	{
86	68	return 0;
87	69	}
r243398	r243399
92	74	// drawnone_window_destroy
93	75	//============================================================
94	76
95		void ~~ren~~der~~er_~~none::destroy()
	77	static void drawnone_window_destroy(win_window_info *window)
96	78	{
97	79	}
98	80
r243398	r243399
102	84	// drawnone_window_get_primitives
103	85	//============================================================
104	86
105		render_primitive_list *~~ren~~der~~er_~~none::get_primitives()
	87	static render_primitive_list drawnone_window_get_primitives(win_window_info window)
106	88	{
107	89	RECT client;
108		GetClientRect(window().m_hwnd, &client);
109		window().m_target->set_bounds(rect_width(&client), rect_height(&client), window().m_monitor->get_aspect());
110		return &window().m_target->get_primitives();
	90	GetClientRect(window->m_hwnd, &client);
	91	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	92	return &window->m_target->get_primitives();
111	93	}
112	94
113	95
r243398	r243399
116	98	// drawnone_window_draw
117	99	//============================================================
118	100
119		int ~~ren~~der~~er_~~none::draw(HDC dc, int update)
	101	static int drawnone_window_draw(win_window_info *window, HDC dc, int update)
120	102	{
121	103	return 0;
122	104	}

trunk/src/osd/windows/window.c
r243398	r243399
35	35	#include "config.h"
36	36	#include "winutf8.h"
37	37
38		extern int drawnone_init(running_machine &machine, osd_draw_callbacks *callbacks);
39		extern int drawgdi_init(running_machine &machine, osd_draw_callbacks *callbacks);
40		extern int drawdd_init(running_machine &machine, osd_draw_callbacks *callbacks);
41		extern int drawd3d_init(running_machine &machine, osd_draw_callbacks *callbacks);
42		extern int drawbgfx_init(running_machine &machine, osd_draw_callbacks *callbacks);
	38	extern int drawnone_init(running_machine &machine, win_draw_callbacks *callbacks);
	39	extern int drawgdi_init(running_machine &machine, win_draw_callbacks *callbacks);
	40	extern int drawdd_init(running_machine &machine, win_draw_callbacks *callbacks);
	41	extern int drawd3d_init(running_machine &machine, win_draw_callbacks *callbacks);
	42	extern int drawbgfx_init(running_machine &machine, win_draw_callbacks *callbacks);
43	43
44	44
45	45	//============================================================
r243398	r243399
107	107
108	108	static DWORD last_update_time;
109	109
110		static ~~osd~~_draw_callbacks draw;
	110	static win_draw_callbacks draw;
111	111
112	112	static HANDLE ui_pause_event;
113	113	static HANDLE window_thread_ready_event;
r243398	r243399
320	320	m_lastclicktime(0),
321	321	m_lastclickx(0),
322	322	m_lastclicky(0),
323		m_~~ren~~derer(NULL),
	323	m_drawdata(NULL),
324	324	m_machine(machine)
325	325	{
326	326	memset(m_title,0,sizeof(m_title));
r243398	r243399
504	504
505	505	void winwindow_take_snap(void)
506	506	{
	507	if (draw.window_record == NULL)
	508	return;
	509
507	510	win_window_info *window;
508	511
509	512	assert(GetCurrentThreadId() == main_threadid);
r243398	r243399
511	514	// iterate over windows and request a snap
512	515	for (window = win_window_list; window != NULL; window = window->m_next)
513	516	{
514		window~~->m~~_~~renderer->~~save();
	517	(*draw.window_save)(window);
515	518	}
516	519	}
517	520
r243398	r243399
524	527
525	528	void winwindow_toggle_fsfx(void)
526	529	{
	530	if (draw.window_toggle_fsfx == NULL)
	531	return;
	532
527	533	win_window_info *window;
528	534
529	535	assert(GetCurrentThreadId() == main_threadid);
r243398	r243399
531	537	// iterate over windows and request a snap
532	538	for (window = win_window_list; window != NULL; window = window->m_next)
533	539	{
534		window~~->m~~_~~renderer->~~toggle_fsfx();
	540	(*draw.window_toggle_fsfx)(window);
535	541	}
536	542	}
537	543
r243398	r243399
544	550
545	551	void winwindow_take_video(void)
546	552	{
	553	if (draw.window_record == NULL)
	554	return;
	555
547	556	win_window_info *window;
548	557
549	558	assert(GetCurrentThreadId() == main_threadid);
r243398	r243399
551	560	// iterate over windows and request a snap
552	561	for (window = win_window_list; window != NULL; window = window->m_next)
553	562	{
554		window~~->m~~_re~~nderer->re~~cord();
	563	(*draw.window_record)(window);
555	564	}
556	565	}
557	566
r243398	r243399
803	812	}
804	813
805	814	// if we're visible and running and not in the middle of a resize, draw
806		if (m_hwnd != NULL && m_target != NULL)
	815	if (m_hwnd != NULL && m_target != NULL && m_drawdata != NULL)
807	816	{
808	817	int got_lock = TRUE;
809	818
r243398	r243399
826	835	osd_lock_release(m_render_lock);
827	836
828	837	// ensure the target bounds are up-to-date, and then get the primitives
829		primlist = m_rend~~erer->~~get_primitives();
	838	primlist = (*draw.window_get_primitives)(this);
830	839
831	840	// post a redraw request with the primitive list as a parameter
832	841	last_update_time = timeGetTime();
r243398	r243399
1232	1241	if (!window->m_fullscreen \|\| window->m_fullscreen_safe)
1233	1242	{
1234	1243	// finish off by trying to initialize DirectX; if we fail, ignore it
1235		window->m_renderer = draw.create(window);
1236		if (window->m_renderer->init())
	1244	if ((*draw.window_init)(window))
1237	1245	return 1;
1238	1246	ShowWindow(window->m_hwnd, SW_SHOW);
1239	1247	}
r243398	r243399
1409	1417
1410	1418	// destroy: clean up all attached rendering bits and NULL out our hwnd
1411	1419	case WM_DESTROY:
1412		window->m_renderer->destroy();
1413		global_free(window->m_renderer);
1414		window->m_renderer = NULL;
	1420	(*draw.window_destroy)(window);
1415	1421	window->m_hwnd = NULL;
1416	1422	return DefWindowProc(wnd, message, wparam, lparam);
1417	1423
r243398	r243399
1495	1501	// otherwise, render with our drawing system
1496	1502	else
1497	1503	{
1498		window~~->m~~_~~ren~~der~~er->dr~~aw(dc, update);
	1504	(*draw.window_draw)(window, dc, update);
1499	1505	mtlog_add("draw_video_contents: drawing finished");
1500	1506	}
1501	1507	}
r243398	r243399
1865	1871	window->m_fullscreen = fullscreen;
1866	1872
1867	1873	// kill off the drawers
1868		window->m_renderer->destroy();
1869		global_free(window->m_renderer);
1870		window->m_renderer = NULL;
	1874	(*draw.window_destroy)(window);
1871	1875
1872	1876	// hide ourself
1873	1877	ShowWindow(window->m_hwnd, SW_HIDE);
r243398	r243399
1923	1927	{
1924	1928	if (video_config.mode != VIDEO_MODE_NONE)
1925	1929	ShowWindow(window->m_hwnd, SW_SHOW);
1926		window->m_renderer = draw.create(window);
1927		if (window->m_renderer->init())
	1930	if ((*draw.window_init)(window))
1928	1931	exit(1);
1929	1932	}
1930	1933

trunk/src/osd/windows/window.h
r243398	r243399
32	32	// TYPE DEFINITIONS
33	33	//============================================================
34	34
35		class win_window_info;
36
37		class osd_renderer
38		{
39		public:
40
41		/* Generic flags */
42		static const int FLAG_NONE = 0x0000;
43		static const int FLAG_NEEDS_OPENGL = 0x0001;
44
45		/* SDL 1.2 flags */
46		static const int FLAG_NEEDS_DOUBLEBUF = 0x0100;
47		static const int FLAG_NEEDS_ASYNCBLIT = 0x0200;
48
49		osd_renderer(win_window_info *window, const int flags)
50		: m_window(window), m_flags(flags) { }
51
52		virtual ~osd_renderer() { }
53
54		win_window_info &window() { return *m_window; }
55		int flags() const { return m_flags; }
56		bool check_flag(const int flag) { return ((m_flags & flag)) == flag; }
57
58		virtual int init() = 0;
59		virtual render_primitive_list *get_primitives() = 0;
60		virtual int draw(HDC dc, int update) = 0;
61		virtual void save() = 0;
62		virtual void record() = 0;
63		virtual void toggle_fsfx() = 0;
64		virtual void destroy() = 0;
65
66		private:
67		win_window_info *m_window;
68		int m_flags;
69		};
70
71	35	class win_window_info
72	36	{
73	37	public:
r243398	r243399
113	77	int m_lastclicky;
114	78
115	79	// drawing data
116		osd~~_renderer~~ * m_~~ren~~derer;
	80	void * m_drawdata;
117	81
118	82	private:
119	83	running_machine & m_machine;
120	84	};
121	85
122		struct osd_draw_callbacks
	86
	87	struct win_draw_callbacks
123	88	{
124		osd_renderer (create)(win_window_info *window);
125	89	void (*exit)(void);
	90
	91	int (window_init)(win_window_info window);
	92	render_primitive_list (window_get_primitives)(win_window_info *window);
	93	int (window_draw)(win_window_info window, HDC dc, int update);
	94	void (window_save)(win_window_info window);
	95	void (window_record)(win_window_info window);
	96	void (window_toggle_fsfx)(win_window_info window);
	97	void (window_destroy)(win_window_info window);
126	98	};
127	99
128	100

https://github.com/mamedev/mame/commit/2bd20863ba6097e5323f100b69bc23d0d3947ae8

199869 Revisions