Previous

199869 Revisions

Next

r34879 Thursday 5th February, 2015 at 22:24:15 UTC by Couriersud
Introduced a comparable "osd_renderer" interface like it now exists for SDL to mainline. Ultimately, this will allow renderers to be placed in modules\renderer and e.g. allow the opengl renderer to be used in mainline or the d3d renderer to be used in sdlmame. (nw)

[src/osd/windows]

d3dhlsl.c drawbgfx.c drawd3d.c drawd3d.h drawdd.c drawgdi.c drawnone.c window.c window.h

trunk/src/osd/windows/d3dhlsl.c

r243390	r243391
224	224	if (!master_enable || !d3dintf->post_fx_available)
225	225	return;
226	226
227		renderer *d3d = (renderer *)window->m_drawdata;
	227	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
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)
r243390	r243391
276	276	if (!master_enable || !d3dintf->post_fx_available)
277	277	return;
278	278
279		renderer *d3d = (renderer *)window->m_drawdata;
	279	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
280	280
281	281	D3DLOCKED_RECT rect;
282	282
r243390	r243391
326	326	if (!master_enable || !d3dintf->post_fx_available)
327	327	return;
328	328
329		renderer *d3d = (renderer *)window->m_drawdata;
	329	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
330	330
331	331	D3DLOCKED_RECT rect;
332	332
r243390	r243391
519	519	if (!master_enable || !d3dintf->post_fx_available)
520	520	return;
521	521
522		renderer *d3d = (renderer *)window->m_drawdata;
	522	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
523	523
524	524	// stop any existing recording
525	525	end_avi_recording();
r243390	r243391
678	678	if (!master_enable || !d3dintf->post_fx_available)
679	679	return;
680	680
681		renderer *d3d = (renderer *)window->m_drawdata;
	681	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
682	682
683	683	if(texture != NULL)
684	684	{
r243390	r243391
820	820	if (!master_enable || !d3dintf->post_fx_available)
821	821	return;
822	822
823		renderer *d3d = (renderer *)window->m_drawdata;
	823	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
824	824
825	825	// get a pointer to the vertex buffer
826	826	fsfx_vertices = (vertex *)vertbuf;
r243390	r243391
892	892	if (!master_enable || !d3dintf->post_fx_available)
893	893	return 0;
894	894
895		renderer *d3d = (renderer *)window->m_drawdata;
	895	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
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);
r243390	r243391
1066	1066	if (!master_enable || !d3dintf->post_fx_available)
1067	1067	return;
1068	1068
1069		renderer *d3d = (renderer *)window->m_drawdata;
	1069	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1070	1070
1071	1071	curr_effect = default_effect;
1072	1072
r243390	r243391
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 = (renderer *)window->m_drawdata;
	1104	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
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);
r243390	r243391
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 = (renderer *)window->m_drawdata;
	1149	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
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);
r243390	r243391
1231	1231	if (!master_enable || !d3dintf->post_fx_available)
1232	1232	return;
1233	1233
1234		renderer *d3d = (renderer *)window->m_drawdata;
	1234	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1235	1235	texture_info *texture = poly->get_texture();
1236	1236
1237	1237	if(PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && texture != NULL)
r243390	r243391
1308	1308
1309	1309	void shaders::ntsc_pass(render_target *rt, vec2f &sourcedims, vec2f &delta)
1310	1310	{
1311		renderer *d3d = (renderer *)window->m_drawdata;
	1311	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1312	1312	UINT num_passes = 0;
1313	1313
1314	1314	if(options->yiq_enable)
r243390	r243391
1370	1370
1371	1371	void shaders::color_convolution_pass(render_target *rt, vec2f &texsize, vec2f &sourcedims)
1372	1372	{
1373		renderer *d3d = (renderer *)window->m_drawdata;
	1373	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1374	1374	UINT num_passes = 0;
1375	1375
1376	1376	curr_effect = color_effect;
r243390	r243391
1398	1398
1399	1399	void shaders::prescale_pass(render_target *rt, vec2f &texsize, vec2f &sourcedims)
1400	1400	{
1401		renderer *d3d = (renderer *)window->m_drawdata;
	1401	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1402	1402	UINT num_passes = 0;
1403	1403
1404	1404	curr_effect = prescale_effect;
r243390	r243391
1426	1426
1427	1427	void shaders::deconverge_pass(render_target *rt, vec2f &texsize, vec2f &delta, vec2f &sourcedims)
1428	1428	{
1429		renderer *d3d = (renderer *)window->m_drawdata;
	1429	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1430	1430	UINT num_passes = 0;
1431	1431
1432	1432	curr_effect = deconverge_effect;
r243390	r243391
1454	1454
1455	1455	void shaders::defocus_pass(render_target *rt, vec2f &texsize)
1456	1456	{
1457		renderer *d3d = (renderer *)window->m_drawdata;
	1457	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1458	1458	UINT num_passes = 0;
1459	1459
1460	1460	// Defocus pass 1
r243390	r243391
1503	1503
1504	1504	void shaders::phosphor_pass(render_target *rt, cache_target *ct, vec2f &texsize, bool focus_enable)
1505	1505	{
1506		renderer *d3d = (renderer *)window->m_drawdata;
	1506	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1507	1507	UINT num_passes = 0;
1508	1508
1509	1509	curr_effect = phosphor_effect;
r243390	r243391
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 = (renderer *)window->m_drawdata;
	1564	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1565	1565	UINT num_passes = 0;
1566	1566
1567	1567	curr_effect = post_effect;
r243390	r243391
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 = (renderer *)window->m_drawdata;
	1619	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1620	1620	UINT num_passes = 0;
1621	1621
1622	1622	curr_effect = post_effect;
r243390	r243391
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 = (renderer *)window->m_drawdata;
	1653	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1654	1654	UINT num_passes = 0;
1655	1655
1656	1656	curr_effect = downsample_effect;
r243390	r243391
1755	1755	return;
1756	1756
1757	1757	UINT num_passes = 0;
1758		renderer *d3d = (renderer *)window->m_drawdata;
	1758	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
1759	1759	curr_texture = poly->get_texture();
1760	1760
1761	1761	if(PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && curr_texture != NULL)
r243390	r243391
2080	2080	return NULL;
2081	2081	}
2082	2082
2083		renderer *d3d = (renderer *)window->m_drawdata;
	2083	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
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 = (renderer *)window->m_drawdata;
	2090	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
2091	2091	if (!add_render_target(d3d, NULL, d3d->get_width(), d3d->get_height(), 1, 1))
2092	2092	{
2093	2093	vector_enable = false;
r243390	r243391
2202	2202
2203	2203	enumerate_screens();
2204	2204
2205		renderer *d3d = (renderer *)window->m_drawdata;
	2205	renderer *d3d = dynamic_cast<renderer *>(window->m_renderer);
2206	2206
2207	2207	int hlsl_prescale_x = prescale_force_x;
2208	2208	int hlsl_prescale_y = prescale_force_y;
r243390	r243391
2994	2994	}
2995	2995
2996	2996	shaders *shadersys = m_shader->m_shaders;
2997		renderer *d3d = (renderer *)shadersys->window->m_drawdata;
	2997	renderer *d3d = dynamic_cast<renderer *>(shadersys->window->m_renderer);
2998	2998	hlsl_options *options = shadersys->options;
2999	2999
3000	3000	switch(m_id)
r243390	r243391
3422	3422	UINT32 origflags = file.openflags();
3423	3423
3424	3424	// handle defaults
3425		const char *snapname = templ ? templ : d3d->get_window()->machine().options().snap_name();
	3425	const char *snapname = templ ? templ : d3d->window().machine().options().snap_name();
3426	3426
3427	3427	if (snapname == NULL || snapname[0] == 0)
3428	3428	snapname = "%g/%i";
r243390	r243391
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->get_window()->machine().root_device());
	3472	image_interface_iterator iter(d3d->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
r243390	r243391
3506	3506
3507	3507	// substitute path and gamename up front
3508	3508	snapstr.replace(0, "/", PATH_SEPARATOR);
3509		snapstr.replace(0, "%g", d3d->get_window()->machine().basename());
	3509	snapstr.replace(0, "%g", d3d->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

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

trunk/src/osd/windows/drawd3d.c

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

trunk/src/osd/windows/drawd3d.h

r243390	r243391
95	95	};
96	96
97	97	/* renderer is the information about Direct3D for the current screen */
98		class renderer
	98	class renderer : public osd_renderer
99	99	{
100	100	public:
101		renderer() { }
	101	//renderer() { }
102	102	renderer(win_window_info *window);
103		~renderer();
	103	virtual ~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
105	113	int                     initialize();
106	114
107	115	int                     device_create();
r243390	r243391
148	156	int                     get_height() { return m_height; }
149	157	int                     get_refresh() { return m_refresh; }
150	158
151		win_window_info *       get_window() { return m_window; }
152
153	159	device *                get_device() { return m_device; }
154	160	present_parameters *    get_presentation() { return &m_presentation; }
155	161
r243390	r243391
181	187	int                     m_refresh;                  // current refresh rate
182	188	int                     m_create_error_count;       // number of consecutive create errors
183	189
184		win_window_info *       m_window;                     // current window info
185
186	190	device *                m_device;                   // pointer to the Direct3DDevice object
187	191	int                     m_gamma_supported;          // is full screen gamma supported?
188	192	present_parameters      m_presentation;             // set of presentation parameters

trunk/src/osd/windows/drawdd.c

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

trunk/src/osd/windows/drawgdi.c

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

trunk/src/osd/windows/drawnone.c

r243390	r243391
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) { }
20	25
	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
21	39	//============================================================
22	40	//  PROTOTYPES
23	41	//============================================================
24	42
25	43	// core functions
26	44	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);
31	45
	46	//============================================================
	47	//  drawnone_create
	48	//============================================================
32	49
	50	osd_renderer *drawnone_create(win_window_info *window)
	51	{
	52	return global_alloc(renderer_none(window));
	53	}
33	54
34	55	//============================================================
35	56	//  drawnone_init
36	57	//============================================================
37	58
38		int drawnone_init(running_machine &machine, win_draw_callbacks *callbacks)
	59	int drawnone_init(running_machine &machine, osd_draw_callbacks *callbacks)
39	60	{
40	61	// fill in the callbacks
41	62	memset(callbacks, 0, sizeof(*callbacks));
42	63	callbacks->exit = drawnone_exit;
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;
	64	callbacks->create = drawnone_create;
47	65	return 0;
48	66	}
49	67
r243390	r243391
63	81	//  drawnone_window_init
64	82	//============================================================
65	83
66		static int drawnone_window_init(win_window_info *window)
	84	int renderer_none::init()
67	85	{
68	86	return 0;
69	87	}
r243390	r243391
74	92	//  drawnone_window_destroy
75	93	//============================================================
76	94
77		static void drawnone_window_destroy(win_window_info *window)
	95	void renderer_none::destroy()
78	96	{
79	97	}
80	98
r243390	r243391
84	102	//  drawnone_window_get_primitives
85	103	//============================================================
86	104
87		static render_primitive_list *drawnone_window_get_primitives(win_window_info *window)
	105	render_primitive_list *renderer_none::get_primitives()
88	106	{
89	107	RECT client;
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();
	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();
93	111	}
94	112
95	113
r243390	r243391
98	116	//  drawnone_window_draw
99	117	//============================================================
100	118
101		static int drawnone_window_draw(win_window_info *window, HDC dc, int update)
	119	int renderer_none::draw(HDC dc, int update)
102	120	{
103	121	return 0;
104	122	}

trunk/src/osd/windows/window.c

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

trunk/src/osd/windows/window.h

r243390	r243391
32	32	//  TYPE DEFINITIONS
33	33	//============================================================
34	34
	35	class osd_renderer;
	36
35	37	class win_window_info
36	38	{
37	39	public:
r243390	r243391
77	79	int                 m_lastclicky;
78	80
79	81	// drawing data
80		void *              m_drawdata;
	82	osd_renderer *      m_renderer;
81	83
82	84	private:
83	85	running_machine &   m_machine;
84	86	};
85	87
	88	class osd_renderer
	89	{
	90	public:
86	91
87		struct win_draw_callbacks
	92	/* Generic flags */
	93	static const int FLAG_NONE                = 0x0000;
	94	static const int FLAG_NEEDS_OPENGL          = 0x0001;
	95
	96	/* SDL 1.2 flags */
	97	static const int FLAG_NEEDS_DOUBLEBUF       = 0x0100;
	98	static const int FLAG_NEEDS_ASYNCBLIT       = 0x0200;
	99
	100	osd_renderer(win_window_info *window, const int flags)
	101	: m_window(window), m_flags(flags) { }
	102
	103	virtual ~osd_renderer() { }
	104
	105	win_window_info &window() { return *m_window; }
	106	int flags() const { return m_flags; }
	107	bool check_flag(const int flag) { return ((m_flags & flag)) == flag; }
	108
	109	virtual int init() = 0;
	110	virtual render_primitive_list *get_primitives() = 0;
	111	virtual int draw(HDC dc, int update) = 0;
	112	virtual void save() = 0;
	113	virtual void record() = 0;
	114	virtual void toggle_fsfx() = 0;
	115	virtual void destroy() = 0;
	116
	117	private:
	118	win_window_info *m_window;
	119	int m_flags;
	120	};
	121
	122	struct osd_draw_callbacks
88	123	{
	124	osd_renderer *(*create)(win_window_info *window);
89	125	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);
98	126	};
99	127
100	128

https://github.com/mamedev/mame/commit/950b1b05147dea8dd86bb2326d841e0b05f2580a

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team